Part II Designing Types in Visual C#.NET

Creator PDF 417 in Visual C#.NET Part II Designing Types

As a small side note, C# also lets you omit the parentheses before the open brace if you want to call a parameterless constructor . The line below produces the same IL as the line above:

String s = new Employee { Name = Jeff , Age = 45 }.ToString().ToUpper();

If a property s type implements the IEnumerable or IEnumerable<T> interface, then the property is considered to be a collection, and initializing a collection is an additive operation as opposed to a replacement operation . For example, suppose I have the following class definition:

public sealed class Classroom { private List<String> m_students = new List<String>(); public List<String> Students { get { return m_students; } } public Classroom() {} }

I can now have code that constructs a Classroom object and initializes the Students collection as follows:

public static void M() { Classroom classroom = new Classroom { Students = { "Jeff", "Kristin", "Aidan", "Grant" } }; // Show the 4 students in the classroom foreach (var student in classroom.Students) Console.WriteLine(student); }

When compiling this code, the compiler sees that the Students property is of type List<String> and that this type implements the IEnumerable<String> interface . Now, the compiler assumes that the List<String> type offers a method called Add (because most collection classes actually offer an Add method that adds items to the collection) . The compiler then generates code to call the collection s Add method . So, the code shown above is converted by the compiler into this:

public static void M() { Classroom classroom = new Classroom(); classroom.Students.Add("Jeff"); classroom.Students.Add("Kristin"); classroom.Students.Add("Aidan"); classroom.Students.Add("Grant"); // Show the 4 students in the classroom foreach (var student in classroom.Students) Console.WriteLine(student); }

If the property s type implements IEnumerable or IEnumerable<T> but the type doesn t offer an Add method, then the compiler does not let you use the collection initialize syntax to add items to the collection; instead, the compiler issues something like the following

message: "error CS0117: 'System.Collections.Generic.IEnumerable<string>' does not contain a definition for 'Add'." Some collection s Add methods take multiple arguments . For example, Dictionary s Add method:

public void Add(TKey key, TValue value);

You can pass multiple arguments to an Add method by using nested braces in a collection initializer, as follows:

var table = new Dictionary<String, Int32> { { "Jeffrey", 1 }, { "Kristin", 2 }, { "Aidan", 3 }, { "Grant", 4 } };

The line above is identical to:

var table = new Dictionary<String, Int32>(); table.Add("Jeffrey", 1); table.Add("Kristin", 2); table.Add("Aidan", 3); table.Add("Grant", 4);

C# s anonymous type feature allows you to automatically declare an immutable tuple type using a very simple and succinct syntax . A tuple type1 is a type that contains a collection of properties that are usually related to each other in some way . In the top line of the code below, I am defining a class with two properties (Name of type String, and Year of type Int32), constructing an instance of this type, and setting its Name property to "Jeff" and its Year property to 1964 .

// Define a type, construct an instance of it, & initialize its properties var o1 = new { Name = "Jeff", Year = 1964 }; // Display the properties on the console: Console.WriteLine("Name={0}, Year={1}", o1.Name, o1.Year);// Displays: Name=Jeff, Year=1964

This top line of code creates an anonymous type because I did not specify a type name after the new keyword, so the compiler will create a type name for me automatically and not tell me what it is (which is why it is called an anonymous type) . The line of code uses the object initializer syntax discussed in the previous section to declare the properties and also to initialize these properties . Also, since I (the developer) do not know the name of the type at compile time, I do not know what type to declare the variable o1 as . However, this is not a problem, as I can use C# s implicitly typed local variable feature (var), as discussed in

The term originated as an abstraction of the sequence: single, double, triple, quadruple, quintuple, n-tuple .