April 23, 2014
Hot Topics:
RSS RSS feed Download our iPhone app

Anonymous Types (or Projections) in VB9

  • June 8, 2007
  • By Paul Kimmel
  • Send Email »
  • More Articles »

There is so much new stuff in the upcoming version of .NET, and it's not just run of the mill components. Microsoft has torqued up .NET and added some very, very powerful features that will significantly change the way you program. These are quantum changes.

In this article, I will demonstrate a small part of my presentation from the West Michigan .NET Users Group Day of .NET, An Introduction to Orcas, anonymous types. (Kudos to Chris Woodruff for pulling off a first rate event.)

Anonymous types (or projections) are a new feature that permits you to define strong types on the fly without writing the nominal—full class—definition. Anonymous types give you the power of strong types, classes defined at design time, without actually having to write that code. Anonymous types are essential for LINQ (Language Integrated Query), and you will find them useful in every day code.

Details That are Useful to Know

Anonymous types are also referred to as projections. (You will see this term used in MSIL (the Microsoft Intermediate Language) if you look at your compiled code with the ILDASM utility.) Anonymous types are types that do not have a formal coded type, a nominal type.

Anonymous types are critical to LINQ because LINQ returns dynamically shaped data whose type is determined by the LINQ query. But, anonymous types are really important for this reason: Anonymous types will let you focus on coding primary domain types specifically, but allow you to not code domain sub-types that are needed only temporarily or just once. Sub-types are usually what are now being referred to as shaped data. For example, given a customer object and address object, sometimes you may want to just want the customer name and address. Anonymous types would permit you to extricate those elements from multiple sources into a dynamic type without a lot of coding beforehand.

Anonymous Types (or Projections) introduce new phrases like data shaping and n-tuples. Data shaping means you organize data into new shapes or organizations. The concept of an n-tuple refers to the number of elements in the anonymous type. For example, an anonymous type with five elements would be referred to as a five-tuple.

Some anonymous type facts include:

  • Anonymous types are strongly typed and checked at compile time.
  • Code is actually generated and emitted as MSIL for you to support your anonymous types. The name of these types is something like <projection>f__0, but you don't care.
  • Anonymous types have local scope. You can return an anonymous type but callers won't know the type so you will need Reflection to figure out what's in there.

Using an Anonymous Type

You can use anonymous types to create random types on the fly (see anon in Listing 1), but it is probably more likely that you will be shaping new types that are some cross section of multiple types (see customerCity in Listing 1, also). The anonymous type declarations are shown in bold. The statements beginning with Dim anon and Dim customerCity demonstrate the syntax for defining anonymous types.

Listing 1: A random anonymous type and a shaped type that is a cross section of a Customer class and an Address class.

Imports System.Collections.Generic

Module Module1

   Sub Main()

   'Randomly defined type
   Dim anon = new with {.ID = 1, .Name="Paul Kimmel" }
   Console.WriteLine(anon)
   Console.WriteLine(anon.ID)
   Console.WriteLine(anon.Name)

   Dim address1 As Address = New Address("1313 Mockingbird Lane", _
      "Hollywood", "CA", "90201", 1)
   Dim customer As Customer = New Customer(1, "SoftConcepts", address1)
   dim customerCity = new with {customer.Name, _
      customer.Address.City}

   Console.WriteLine(customerCity)

   Console.ReadLine()

   End Sub

   Public Class Customer
      Private _iD As Integer
      Public Property ID() As Integer
         Get
            Return _iD
         End Get
         Set(ByVal Value As Integer)
            _iD = Value
         End Set
      End Property

      Private _name As String
      Public Property Name() As String
         Get
            Return _name
         End Get
         Set(ByVal Value As String)
            _name = Value
         End Set
      End Property

      Private _address As Address
      Public Property Address() As Address
         Get
            Return _address
         End Get
         Set(ByVal Value As Address)
            _address = Value
         End Set
      End Property

      ''' <summary>
      ''' Initializes a new instance of the Customer class.
      ''' </summary>
      ''' <param name="iD"></param>
      ''' <param name="name"></param>
      ''' <param name="address"></param>
      Public Sub New(ByVal iD As Integer, _
         ByVal name As String, ByVal address As Address)
         _iD = iD
         _name = name
         _address = address
      End Sub

      ''' <summary>
      ''' Initializes a new instance of the Customer class.
      ''' </summary>
      Public Sub New()
      End Sub
   End Class

   Public Class Address

      Private _address1 As String
      Public Property Address1() As String
         Get
            Return _address1
         End Get
         Set(ByVal Value As String)
            _address1 = Value
         End Set
      End Property

      Private _city As String
      Public Property City() As String
         Get
            Return _city
         End Get
         Set(ByVal Value As String)
            _city = Value
         End Set
      End Property

      Private _state As String
      Public Property State() As String
         Get
            Return _state
         End Get
         Set(ByVal Value As String)
            _state = Value
         End Set
      End Property

      Private _zipCode As String
      Public Property ZipCode() As String
         Get
            Return _zipCode
         End Get
         Set(ByVal Value As String)
            _zipCode = Value
         End Set
      End Property

      Private _iD As Integer
      Public Property ID() As Integer
         Get
            Return _iD
         End Get
         Set(ByVal Value As Integer)
            _iD = Value
         End Set
      End Property

The anonymous types captured by anon and customerCity exist as strong types as if you had defined a class containing an Integer and String—anon—or a class containing two strings—customerCity—created instances, and copied data from the origin types to the new shaped types. Collectively, this is going to save programmers a lot of time because you will no longer need to write nominal definitions for transient types.

Compiling Orcas Code

.NET 3.5 (Orcas) is in beta 1. This means that when you download the beta your installation of Visual Studio, will probably use the default VBC compiler for 2.0. You will need to open a command window and invoke the .NET 3.5 compiler manually. (The good news is that Orcas is scheduled for release this year.)

Here is a sample command line compiler statement that will compile the code represented by Module1 in Listing 1.

C:\WINDOWS\Microsoft.NET\Framework\v3.5.20404\vbc 
"C:\Books\Earthweb\WWW.CODEGURU.COM\2007\05-24-2007\ExtensionMethods1\AnonymousMethods\Module1.vb"
/r:Microsoft.VisualBasic.dll /libpath:"C:\WINDOWS\Microsoft.NET\Framework\v3.5.20404 

In the example, you have specified the path to the VB9 compiler (vbc.exe), the source code, and have included references to the Microsoft.VisualBasic.dll assembly and a library path referring to the .NET 3.5 framework.

Summary

Anonymous types (or Projections) are a means of using strong types that you don't have to write the code for. Anonymous types are key to data returned from LINQ queries and they will eliminate the need to define named types for every variation on domain types you might need.

Anonymous types may define a new basic, general best practice: Define core domain types in code and everything that is used once or twice, wag at it with an anonymous type.

Work is hard, but we propeller heads are supposed to be smart. So let's not work so hard; let's work oh so smart.

About the Author

Paul Kimmel is the VB Today columnist for www.codeguru.com and has written several books on object-oriented programming and .NET. Check out his new book UML DeMystified from McGraw-Hill/Osborne. Paul is a software architect for Tri-State Hospital Supply Corporation. You may contact him for technology questions at pkimmel@softconcepts.com.

If you are interested in joining or sponsoring a .NET Users Group, check out www.glugnet.org.

Copyright © 2007 by Paul T. Kimmel. All Rights Reserved.






Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Sitemap | Contact Us

Rocket Fuel