\n{
\n.maxstack 1
\n.locals init (int32 V_0, object V_1, int32 V_2) IL_0000: nop
\nIL_0001: ldc.i4.s 25 IL_0003: stloc.0 IL_0004: ldloc.0
\nIL_0005: box [System.Runtime]System.Int32 IL_000a: stloc.1
\nIL_000b: ldloc.1
\nIL_000c: unbox.any [System.Runtime]System.Int32 IL_0011: stloc.2
\nIL_0012: ret
\n} \/\/ end of method '
Remember that unlike when performing a typical cast, you must unbox into an appropriate data type. If you attempt to unbox a piece of data into the incorrect data type, an InvalidCastException exception will be thrown. To be perfectly safe, you should wrap each unboxing operation in try\/catch logic; however, this would be quite labor intensive to do for every unboxing operation. Consider the following code update, which will throw an error because you\u2019re attempting to unbox the boxed int into a long:<\/p>\n
static void SimpleBoxUnboxOperation()
\n{
\n\/\/ Make a ValueType (int) variable. int myInt = 25;<\/p>\n
\/\/ Box the int into an object reference. object boxedInt = myInt;<\/p>\n
\/\/ Unbox in the wrong data type to trigger
\n\/\/ runtime exception.
\ntry
\n{
\nlong unboxedLong = (long)boxedInt;
\n}
\ncatch (InvalidCastException ex)
\n{
\nConsole.WriteLine(ex.Message);
\n}
\n}<\/p>\n
At first glance, boxing\/unboxing might seem like a rather uneventful language feature that is more academic than practical. After all, you will seldom need to store a local value type in a local object variable, as shown here. However, it turns out that the boxing\/unboxing process is quite helpful because it allows you to assume everything can be treated as a System.Object, while the CoreCLR takes care of the memory- related details on your behalf.<\/p>\n
Let\u2019s look at a practical use of these techniques. We will examine the System.Collections.ArrayList class and use it to hold onto a batch of numeric (stack-allocated) data. The relevant members of the ArrayList class are listed as follows. Notice that they are prototyped to operate on System.Object data. Now consider the Add(), Insert(), and Remove() methods, as well as the class indexer.<\/p>\n
public class ArrayList : IList, ICloneable
\n{
\n...
\npublic virtual int Add(object? value);
\npublic virtual void Insert(int index, object? value); public virtual void Remove(object? obj);
\npublic virtual object? this[int index] {get; set; }
\n}<\/p>\n
ArrayList has been built to operate on objects, which represent data allocated on the heap, so it might seem strange that the following code compiles and executes without throwing an error:<\/p>\n
static void WorkWithArrayList()
\n{
\n\/\/ Value types are automatically boxed when
\n\/\/ passed to a method requesting an object. ArrayList myInts = new ArrayList(); myInts.Add(10);
\nmyInts.Add(20); myInts.Add(35);
\n}<\/p>\n
Although you pass in numerical data directly into methods requiring an object, the runtime automatically boxes the stack-based data on your behalf. Later, if you want to retrieve an item from the ArrayList using the type indexer, you must unbox the heap-allocated object into a stack-allocated integer using a casting operation. Remember that the indexer of the ArrayList is returning System.Objects, not System.Int32s.<\/p>\n
static void WorkWithArrayList()
\n{
\n\/\/ Value types are automatically boxed when
\n\/\/ passed to a member requesting an object. ArrayList myInts = new ArrayList(); myInts.Add(10);
\nmyInts.Add(20); myInts.Add(35);<\/p>\n
\/\/ Unboxing occurs when an object is converted back to
\n\/\/ stack-based data.
\nint i = (int)myInts[0];<\/p>\n
\/\/ Now it is reboxed, as WriteLine() requires object types!
\nConsole.WriteLine("Value of your int: {0}", i);
\n}<\/p>\n
Again, note that the stack-allocated System.Int32 is boxed prior to the call to ArrayList.Add(), so it can be passed in the required System.Object. Also note that the System.Object is unboxed back into a
\nSystem.Int32 once it is retrieved from the ArrayList via the casting operation, only to be boxed again when it is passed to the Console.WriteLine() method, as this method is operating on System.Object variables.
\nBoxing and unboxing are convenient from a programmer\u2019s viewpoint, but this simplified approach to stack\/heap memory transfer comes with the baggage of performance issues (in both speed of execution and code size) and a lack of type safety. To understand the performance issues, ponder these steps that must occur to box and unbox a simple integer:
\n1.A new object must be allocated on the managed heap.
\n2.The value of the stack-based data must be transferred into that memory location.
\n3.When unboxed, the value stored on the heap-based object must be transferred back to the stack.
\n4.The now unused object on the heap will (eventually) be garbage collected.
\nAlthough this particular WorkWithArrayList() method won\u2019t cause a major bottleneck in terms of performance, you could certainly feel the impact if an ArrayList contained thousands of integers that your program manipulates on a somewhat regular basis. In an ideal world, you could manipulate stack-based data in a container without any performance issues. Ideally, it would be nice if you did not have to bother plucking data from this container using try\/catch scopes (this is exactly what generics let you achieve).<\/p>\n
The Issue of Type Safety
\nI touched on the issue of type safety when covering unboxing operations. Recall that you must unbox your data into the same data type it was declared as before boxing. However, there is another aspect of type safety you must keep in mind in a generic-free world: the fact that a majority of the classes of System.Collections can typically hold anything whatsoever because their members are prototyped to operate on System.
\nObjects. For example, this method builds an ArrayList of random bits of unrelated data:<\/p>\n
static void ArrayListOfRandomObjects()
\n{
\n\/\/ The ArrayList can hold anything at all. ArrayList allMyObjects = new ArrayList(); allMyObjects.Add(true);
\nallMyObjects.Add(new OperatingSystem(PlatformID.MacOSX, new Version(10, 0))); allMyObjects.Add(66);
\nallMyObjects.Add(3.14);
\n}<\/p>\n
In some cases, you will require an extremely flexible container that can hold literally anything (as shown here). However, most of the time you desire a type-safe container that can operate only on a particular type of data point. For example, you might need a container that can hold only database connections, bitmaps, or IPointy-compatible objects.
\nPrior to generics, the only way you could address this issue of type safety was to create a custom (strongly typed) collection class manually. Assume you want to create a custom collection that can contain only objects of type Person.<\/p>\n
namespace IssuesWithNonGenericCollections; public class Person
\n{
\npublic int Age {get; set;}
\npublic string FirstName {get; set;} public string LastName {get; set;}<\/p>\n
public Person(){}
\npublic Person(string firstName, string lastName, int age)
\n{
\nAge = age;
\nFirstName = firstName;
\nLastName = lastName;
\n}<\/p>\n
public override string ToString()
\n{
\nreturn $"Name: {FirstName} {LastName}, Age: {Age}";
\n}
\n}<\/p>\n
To build a collection that can hold only Person objects, you could define a System.Collections. ArrayList member variable within a class named PersonCollection and configure all members to operate on strongly typed Person objects, rather than on System.Object types. Here is a simple example (a production-level custom collection could support many additional members and might extend an abstract base class from the System.Collections or System.Collections.Specialized namespace):<\/p>\n
using System.Collections;
\nnamespace IssuesWithNonGenericCollections; public class PersonCollection : IEnumerable
\n{
\nprivate ArrayList arPeople = new ArrayList();<\/p>\n
\/\/ Cast for caller.
\npublic Person GetPerson(int pos) => (Person)arPeople[pos];<\/p>\n
\/\/ Insert only Person objects.
\npublic void AddPerson(Person p)
\n{
\narPeople.Add(p);
\n}<\/p>\n
public void ClearPeople()
\n{
\narPeople.Clear();
\n}<\/p>\n
public int Count => arPeople.Count;<\/p>\n
\/\/ Foreach enumeration support.
\nIEnumerator IEnumerable.GetEnumerator() => arPeople.GetEnumerator();
\n}<\/p>\n
Notice that the PersonCollection class implements the IEnumerable interface, which allows a foreach- like iteration over each contained item. Also notice that your GetPerson() and AddPerson() methods have been prototyped to operate only on Person objects, not bitmaps, strings, database connections, nor other items. With these types defined, you are now assured of type safety, given that the C# compiler will be able
\nto determine any attempt to insert an incompatible data type. Update the using statements in Program.cs to the following and add the UserPersonCollection() method to the end of your current code:<\/p>\n
using System.Collections; \/\/ This would be a compile-time error! foreach (Person p in myPeople) While custom collections do ensure type safety, this approach leaves you in a position where you must create an (almost identical) custom collection for each unique data type you want to contain. Thus, if you need a custom collection that can operate only on classes deriving from the Car base class, you need to build a highly similar collection class.<\/p>\n using System.Collections; \/\/ Cast for caller. \/\/ Insert only Car objects. public void AddCar(Car c) public void ClearCars() public int Count => arCars.Count;<\/p>\n \/\/ Foreach enumeration support. However, a custom collection class does nothing to solve the issue of boxing\/unboxing penalties. using System.Collections; \/\/ Get an int (performs unboxing!). \/\/ Insert an int (performs boxing)! public void ClearInts() public int Count => arInts.Count;<\/p>\n IEnumerator IEnumerable.GetEnumerator() => arInts.GetEnumerator(); Regardless of which type you might choose to hold the integers, you cannot escape the boxing dilemma using nongeneric containers.<\/p>\n A First Look at Generic CollectionsT static void UseGenericList() \/\/ This List<> can hold only Person objects. List \/\/ This List<> can hold only integers. List \/\/ Compile-time error! Can't add Person object The first List The Role of Generic Type Parameters \u25a0 Note only classes, structures, interfaces, and delegates can be written generically; enum types cannot.<\/p>\n When you see a generic item listed in the .NET Core documentation or the Visual Studio Object Browser, you will notice a pair of angled brackets with a letter or other token sandwiched within. Figure 10-1 shows the Visual Studio Object Browser displaying a number of generic items located within the System. Figure 10-1. Generic items supporting type parameters<\/p>\n Formally speaking, you call these tokens type parameters; however, in more user-friendly terms, you can simply call them placeholders. You can read the symbol \u25a0 Note the name of a type parameter (placeholder) is irrelevant, and it is up to the developer who created the generic item. However, typically T is used to represent types, TKey or K is used for keys, and TValue or V is used for values.<\/p>\n When you create a generic object, implement a generic interface, or invoke a generic member, it is up to you to supply a value to the type parameter. You\u2019ll see many examples in this chapter and throughout the remainder of the text. However, to set the stage, let\u2019s see the basics of interacting with generic types and members.<\/p>\n Specifying Type Parameters for Generic Classes\/Structures \/\/ This List<> can hold only Person objects. List You can read the first line in the preceding snippet as \u201ca List<> of T, where T is of type Person.\u201d Or, more simply, you can read it as \u201ca list of person objects.\u201d After you specify the type parameter of a generic item, it cannot be changed (remember, generics are all about type safety). When you specify a type parameter for a generic class or structure, all occurrences of the placeholder(s) are now replaced with your supplied value. \/\/ A partial listing of the List When you create a List namespace System.Collections.Generic; public class List public bool TrueForAll(System.Predicate Of course, when you create a generic List Specifying Type Parameters for Generic Members int[] myInts = { 10, 4, 2, 33, 93 };<\/p>\n \/\/ Specify the placeholder to the generic foreach (int i in myInts) Specifying Type Parameters for Generic Interfaces public interface IComparable In Chapter 8, you also implemented this interface on your Car class to enable sorting in a standard array. However, the code required several runtime checks and casting operations because the parameter was a general System.Object.<\/p>\n public class Car : IComparable { Now assume you use the generic counterpart of this interface.<\/p>\n public interface IComparable In this case, your implementation code will be cleaned up considerably.<\/p>\n public class Car : IComparable Here, you do not need to check whether the incoming parameter is a Car because it can only be a Car! If someone were to pass in an incompatible data type, you would get a compile-time error. Now that you have a better handle on how to interact with generic items, as well as the role of type parameters (aka placeholders), you\u2019re ready to examine the classes and interfaces of the System.Collections.Generic namespace.<\/p>\n The System.Collections.Generic Namespace Table 10-4. Key Interfaces Supported by Classes of System.Collections.Generic<\/p>\n System.Collections.Generic The System.Collections.Generic namespace also defines several classes that implement many of these key interfaces. Table 10-5 describes some commonly used classes of this namespace, the interfaces they implement, and their basic functionality.<\/p>\n Table 10-5. Classes of System.Collections.Generic<\/p>\n Generic Class Supported Key Interfaces Meaning in Life The System.Collections.Generic namespace also defines many auxiliary classes and structures that work in conjunction with a specific container. For example, the LinkedListNode item from a container using a nonexistent key, and so forth. Be sure to consult the .NET Core documentation for full details of the System.Collections.Generic namespace. Understanding Collection Initialization Syntax using System.Collections; using System.Drawing;<\/p>\n \u25a0 Note You can apply collection initialization syntax only to classes that support an Add() method, which is formalized by the ICollection Consider the following examples:<\/p>\n \/\/ Init a standard array. \/\/ Init a generic List<> of ints. \/\/ Init an ArrayList with numerical data. If your container is managing a collection of classes or a structure, you can blend object initialization syntax with collection initialization syntax to yield some functional code. You might recall the Point class from Chapter 5, which defined two properties named X and Y. If you wanted to build a generic List List foreach (var pt in myListOfPoints) Again, the benefit of this syntax is that you save yourself numerous keystrokes. While the nested curly brackets can become difficult to read if you don\u2019t mind your formatting, imagine the amount of code that would be required to fill the following List List Working with the List namespace FunWithGenericCollections; public class Person public Person(){} public override string ToString() Clear out the generated code in Program.cs and add the following using statement:<\/p>\n using FunWithGenericCollections;<\/p>\n The first generic class you will examine is List static void UseGenericList() \/\/ Print out # of items in List. Console.WriteLine("Items in list: {0}", people.Count);<\/p>\n \/\/ Enumerate over list. foreach (Person p in people) \/\/ Insert a new person. \/\/ Copy data into a new array. Here, you use collection initialization syntax to populate your List Fun with Generic Collections <\/em><\/strong><\/strong> Items in list: 4 ->Inserting new person. The List Working with the Stack static void UseGenericStack() \/\/ Now look at the top item, pop it, and look again. Console.WriteLine("First person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); Console.WriteLine("\\nFirst person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); Console.WriteLine("\\nFirst person item is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop());<\/p>\n try { Here, you build a stack that contains three people, added in the order of their first names: Homer, Marge, and Lisa. As you peek into the stack, you will always see the object at the top first; therefore, the first call to Peek() reveals the third Person object. After a series of Pop() and Peek() calls, the stack eventually empties, at which time additional Peek() and Pop() calls raise a system exception. You can see the output for this here:<\/p>\n Fun with Generic Collections <\/em><\/strong><\/strong> First person is: Name: Lisa Simpson, Age: 9 Popped off Name: Lisa Simpson, Age: 9<\/p>\n First person is: Name: Marge Simpson, Age: 45 Popped off Name: Marge Simpson, Age: 45<\/p>\n First person item is: Name: Homer Simpson, Age: 47 Popped off Name: Homer Simpson, Age: 47<\/p>\n Error! Stack empty.<\/p>\n Working with the Queue Table 10-6. Members of the Queue Select Member of Queue Now let\u2019s put these methods to work. You can begin by leveraging your Person class again and building a Queue static void UseGenericQueue() peopleQ.Enqueue(new Person {FirstName= "Marge", LastName="Simpson", Age=45}); peopleQ.Enqueue(new Person {FirstName= "Lisa", LastName="Simpson", Age=9});<\/p>\n \/\/ Peek at first person in Q. \/\/ Remove each person from Q. GetCoffee(peopleQ.Dequeue()); GetCoffee(peopleQ.Dequeue()); GetCoffee(peopleQ.Dequeue()); Here, you insert three items into the Queue Fun with Generic Collections <\/em><\/strong><\/strong> Homer is first in line! Working with the PriorityQueue<TElement, TPriority> Class (New 10) static void UsePriorityQueue() PriorityQueue<Person, int> peopleQ = new(); while (peopleQ.Count > 0) If more than one item is set to the current lowest priority, the order of dequeuing is not guaranteed. As shown in code sample, the third call to Dequeue() will return either Homer or Marge, as they are both set to a priority of three. The fourth call will then return the other person. If exact order matters, you must ensure values for each priority are unique.<\/p>\n Working with the SortedSet namespace FunWithGenericCollections; class SortPeopleByAge : IComparer Now add the following new method that demonstrates using SortedSet static void UseSortedSet() \/\/ Note the items are sorted by age! \/\/ Add a few new people, with various ages. \/\/ Still sorted by age! When you run your application, the listing of objects is now always ordered based on the value of the Fun with Generic Collections <\/em><\/strong><\/strong> Name: Bart Simpson, Age: 8 Name: Saku Jones, Age: 1 Name: Bart Simpson, Age: 8 Name: Lisa Simpson, Age: 9 Name: Mikko Jones, Age: 32 Name: Marge Simpson, Age: 45 Name: Homer Simpson, Age: 47<\/p>\n Working with the Dictionary<TKey, TValue> Class private static void UseDictionary() \/\/ Get Homer. \/\/ Populate with initialization syntax. \/\/ Get Lisa. It is also possible to populate a Dictionary<TKey,TValue> using a related initialization syntax that is specific to this type of container (not surprisingly termed dictionary initialization). Similar to the syntax used to populate the personB object in the previous code example, you still define an initialization scope for the collection object; however, you can use the indexer to specify the key and assign this to a new object as so:<\/p>\n \/\/ Populate with dictionary initialization syntax. The System.Collections.ObjectModel Namespace Table 10-7. Useful Members of System.Collections.ObjectModel<\/p>\n System.Collections. The ObservableCollection Working with ObservableCollection using System.Collections.ObjectModel; using System.Collections.Specialized; using FunWithObservableCollections;<\/p>\n \/\/ Make a collection to observe \/\/ Wire up the CollectionChanged event. people.CollectionChanged += people_CollectionChanged;<\/p>\n static void people_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) The incoming NotifyCollectionChangedEventArgs parameter defines two important properties, OldItems and NewItems, which will give you a list of items that were currently in the collection before the event fired and the new items that were involved in the change. However, you will want to examine these lists only under the correct circumstances. Recall that the CollectionChanged event can fire when items are added, removed, relocated, or reset. To discover which of these actions triggered the event, you can use the Action property of NotifyCollectionChangedEventArgs. The Action property can be tested against any of the following members of the NotifyCollectionChangedAction enumeration:<\/p>\n public enum NotifyCollectionChangedAction Here is an implementation of the CollectionChanged event handler that will traverse the old and new sets when an item has been inserted into or removed from the collection at hand (notice the using for System.Collections.Specialized):<\/p>\n using System.Collections.Specialized; \/\/ They removed something. { \/\/ They added something. Now, update your calling code to add and remove an item.<\/p>\n \/\/ Now add a new item. When you run the program, you will see output similar to the following:<\/p>\n Action for this event: Add Here are the NEW items: Action for this event: Remove Here are the OLD items: That wraps up the examination of the various collection-centric namespaces. To conclude the chapter, you will now examine how you can build your own custom generic methods and custom generic types.<\/p>\n Creating Custom Generic Methods While overloading is a useful feature in an object-oriented language, one problem is that you can easily end up with a ton of methods that essentially do the same thing. For example, assume you need to build some methods that can switch two pieces of data using a simple swap routine. You might begin by authoring a new static class with a method that can operate on integers, like this:<\/p>\n namespace CustomGenericMethods; static class SwapFunctions So far, so good. But now assume you also need to swap two Person objects; this would require authoring a new version of Swap().<\/p>\n \/\/ Swap two Person objects. No doubt, you can see where this is going. If you also needed to swap floating-point numbers, bitmaps, cars, buttons, etc., you would have to build even more methods, which would become a maintenance nightmare. You could build a single (nongeneric) method that operated on object parameters, but then you face all the issues you examined earlier in this chapter, including boxing, unboxing, a lack of type safety, explicit casting, and so on. \/\/ This method will swap any two items. Notice how a generic method is defined by specifying the type parameters after the method name but before the parameter list. Here, you state that the Swap Console.WriteLine(\"***** Fun with Custom Generic Methods *****\\n\");<\/p>\n \/\/ Swap 2 ints. \/\/ Swap 2 strings. Console.ReadLine();<\/p>\n The output looks like this:<\/p>\n ***** Fun with Custom Generic Methods ***** Before swap: 10, 90 Before swap: Hello There! The major benefit of this approach is that you have only one version of Swap Inference of Type Parameters \/\/ Compiler will infer System.Boolean. bool b1 = true, b2 = false; Even though the compiler can discover the correct type parameter based on the data type used to declare b1 and b2, you should get in the habit of always specifying the type parameter explicitly.<\/p>\n SwapFunctions.Swap This makes it clear to your fellow programmers that this method is indeed generic. Moreover, inference of type parameters works only if the generic method has at least one parameter. For example, assume you have the following generic method in your Program.cs file:<\/p>\n static void DisplayBaseClass In this case, you must supply the type parameter upon invocation.<\/p>\n ... \/\/ Compiler error! No params? Must supply placeholder! Of course, generic methods do not need to be static as they are in these examples. All rules and options for nongeneric methods also apply.<\/p>\n Creating Custom Generic Structures and Classes \/\/ Point using ints. \/\/ Point using double.
\nusing IssuesWithNonGenericCollections;
\n\/\/Top level statements in Program.cs static void UsePersonCollection()
\n{
\nConsole.WriteLine(" Custom Person Collection <\/em><\/strong><\/strong>\\n"); PersonCollection myPeople = new PersonCollection(); myPeople.AddPerson(new Person("Homer", "Simpson", 40)); myPeople.AddPerson(new Person("Marge", "Simpson", 38)); myPeople.AddPerson(new Person("Lisa", "Simpson", 9)); myPeople.AddPerson(new Person("Bart", "Simpson", 7)); myPeople.AddPerson(new Person("Maggie", "Simpson", 2));<\/p>\n
\n\/\/ myPeople.AddPerson(new Car());<\/p>\n
\n{
\nConsole.WriteLine(p);
\n}
\n}<\/p>\n
\npublic class CarCollection : IEnumerable
\n{
\nprivate ArrayList arCars = new ArrayList();<\/p>\n
\npublic Car GetCar(int pos) => (Car) arCars[pos];<\/p>\n
\n{
\narCars.Add(c);
\n}<\/p>\n
\n{
\narCars.Clear();
\n}<\/p>\n
\nIEnumerator IEnumerable.GetEnumerator() => arCars.GetEnumerator();
\n}<\/p>\n
\nEven if you were to create a custom collection named IntCollection that you designed to operate only on System.Int32 items, you would have to allocate some type of object to hold the data (e.g., System.Array and ArrayList).<\/p>\n
\npublic class IntCollection : IEnumerable
\n{
\nprivate ArrayList arInts = new ArrayList();<\/p>\n
\npublic int GetInt(int pos) => (int)arInts[pos];<\/p>\n
\npublic void AddInt(int i)
\n{
\narInts.Add(i);
\n}<\/p>\n
\n{
\narInts.Clear();
\n}<\/p>\n
\n}<\/p>\n
\nWhen you use generic collection classes, you rectify all the previous issues, including boxing\/unboxing penalties and a lack of type safety. Also, the need to build a custom (generic) collection class becomes quite rare. Rather than having to build unique classes that can contain people, cars, and integers, you can use a generic collection class and specify the type of type.
\nConsider the following method (added to the bottom of Program.cs), which uses the generic List
\n{
\nConsole.WriteLine(" Fun with Generics <\/em><\/strong><\/strong>\\n");<\/p>\n
\nmoreInts.Add(2);
\nint sum = moreInts[0] + moreInts[1];<\/p>\n
\n\/\/ to a list of ints!
\n\/\/ moreInts.Add(new Person());
\n}<\/p>\n
\nList
\n\u2022 Generics provide better performance because they do not result in boxing or unboxing penalties when storing value types.
\n\u2022 Generics are type-safe because they can contain only the type of type you specify.
\n\u2022 Generics greatly reduce the need to build custom collection types because you specify the \u201ctype of type\u201d when creating the generic container.<\/p>\n
\nYou can find generic classes, interfaces, structures, and delegates throughout the .NET Core base class libraries, and these might be part of any .NET Core namespace. Also be aware that generics have far more uses than simply defining a collection class. To be sure, you will see many different generics used in the remainder of this book for various reasons.<\/p>\n
\nCollections.Generic namespace, including the highlighted List
\nWhen you create an instance of a generic class or structure, you specify the type parameter when you declare the variable and when you invoke the constructor. As you saw in the preceding code example, UseGenericList() defined two List
\n\/\/ This List<> can hold only integers. List
\nIf you were to view the full declaration of the generic List
\npublic class List
\n{
\n...
\npublic void Add(T item);
\npublic void AddRange(IEnumerable
\npublic bool Contains(T item); public void CopyTo(T[] array);
\npublic int FindIndex(System.Predicate
\npublic int RemoveAll(System.Predicate
\npublic bool TrueForAll(System.Predicate
\n}<\/p>\n
\n: IList
\n{
\n...
\npublic void Add(Person item);
\npublic void AddRange(IEnumerable
\npublic bool Contains(Person item); public void CopyTo(Person[] array);
\npublic int FindIndex(System.Predicate
\npublic int RemoveAll(System.Predicate
\n}<\/p>\n
\nIt is fine for a nongeneric class or structure to support generic properties. In these cases, you would also need to specify the placeholder value at the time you invoke the method. For example, System.Array supports several generic methods. Specifically, the nongeneric static Sort() method now has a generic counterpart named Sort
\n\/\/ Sort<>() method.
\nArray.Sort
\n{
\nConsole.WriteLine(i);
\n}<\/p>\n
\nIt is common to implement generic interfaces when you build classes or structures that need to support various framework behaviors (e.g., cloning, sorting, and enumeration). In Chapter 8, you learned about a number of nongeneric interfaces, such as IComparable, IEnumerable, IEnumerator, and IComparer. Recall that the nongeneric IComparable interface was defined like this:<\/p>\n
\n{
\nint CompareTo(object obj);
\n}<\/p>\n
\n{
\n...
\n\/\/ IComparable implementation.
\nint IComparable.CompareTo(object obj)
\n{
\nif (obj is Car temp)<\/p>\n
\nreturn this.CarID.CompareTo(temp.CarID);
\n}
\nthrow new ArgumentException("Parameter is not a Car!");
\n}
\n}<\/p>\n
\n{
\nint CompareTo(T obj);
\n}<\/p>\n
\n{
\n...
\n\/\/ IComparable
\nint IComparable
\n{
\nif (this.CarID > obj.CarID)
\n{
\nreturn 1;
\n}
\nif (this.CarID < obj.CarID)
\n{
\nreturn -1;
\n}
\nreturn 0;
\n}
\n}<\/p>\n
\nWhen you are building a .NET Core application and need a way to manage in-memory data, the classes of System.Collections.Generic will most likely fit the bill. At the opening of this chapter, I briefly mentioned some of the core nongeneric interfaces implemented by the nongeneric collection classes. Not too surprisingly, the System.Collections.Generic namespace defines generic replacements for many of them.
\nIn fact, you can find a number of the generic interfaces that extend their nongeneric counterparts. This might seem odd; however, by doing so, implementing classes will also support the legacy functionally found in their nongeneric siblings. For example, IEnumerable
\nInterface Meaning in Life
\nICollection
\nIComparer
\nIDictionary<TKey, TValue> Allows a generic collection object to represent its contents using key- value pairs.
\nIEnumerable
\nIAsyncEnumerable (new in C# 8.0) is covered in Chapter 15.
\nIEnumerator
\nIList
\nISet
\nDictionary<TKey, TValue> ICollection
\nLinkedList
\nList
\nQueue
\nSortedDictionary<TKey, TValue> ICollection
\nSortedSet
\nStack
\nIn any case, your next task is to learn how to use some of these generic collection classes. Before you do, however, allow me to illustrate a C# language feature (first introduced in .NET 3.5) that simplifies the way you populate generic (and nongeneric) collection containers with data.<\/p>\n
\nIn Chapter 4, you learned about object initialization syntax, which allows you to set properties on a new variable at the time of construction. Closely related to this is collection initialization syntax. This C# language feature makes it possible to populate many containers (such as ArrayList or List
\nint[] myArrayOfInts = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };<\/p>\n
\nList
\nArrayList myList = new ArrayList { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };<\/p>\n
\n{
\nnew Point { X = 2, Y = 2 }, new Point { X = 3, Y = 3 }, new Point { X = 4, Y = 4 }
\n};<\/p>\n
\n{
\nConsole.WriteLine(pt);
\n}<\/p>\n
\n{
\nnew Rectangle {
\nHeight = 90, Width = 90,
\nLocation = new Point { X = 10, Y = 10 }}, new Rectangle {
\nHeight = 50,Width = 50,
\nLocation = new Point { X = 2, Y = 2 }},
\n};
\nforeach (var r in myListOfRects)
\n{
\nConsole.WriteLine(r);
\n}<\/p>\n
\nCreate a new Console Application project named FunWithGenericCollections. Add a new file, named
\nPerson.cs, and add the following code (which is the same code as the previous Person class):<\/p>\n
\n{
\npublic int Age {get; set;}
\npublic string FirstName {get; set;} public string LastName {get; set;}<\/p>\n
\npublic Person(string firstName, string lastName, int age)
\n{
\nAge = age;
\nFirstName = firstName;
\nLastName = lastName;
\n}<\/p>\n
\n{
\nreturn $"Name: {FirstName} {LastName}, Age: {Age}";
\n}
\n}<\/p>\n
\n{
\n\/\/ Make a List of Person objects, filled with
\n\/\/ collection\/object init syntax. List
\n{
\nnew Person {FirstName= "Homer", LastName="Simpson", Age=47}, new Person {FirstName= "Marge", LastName="Simpson", Age=45}, new Person {FirstName= "Lisa", LastName="Simpson", Age=9}, new Person {FirstName= "Bart", LastName="Simpson", Age=8}
\n};<\/p>\n
\n{
\nConsole.WriteLine(p);
\n}<\/p>\n
\nConsole.WriteLine("\\n->Inserting new person.");
\npeople.Insert(2, new Person { FirstName = "Maggie", LastName = "Simpson", Age = 2 }); Console.WriteLine("Items in list: {0}", people.Count);<\/p>\n
\nPerson[] arrayOfPeople = people.ToArray(); foreach (Person p in arrayOfPeople)
\n{
\nConsole.WriteLine("First Names: {0}", p.FirstName);
\n}
\n}<\/p>\n
\nFinally, notice the call to the ToArray() method, which returns an array of Person objects based on the contents of the original List
\nName: Homer Simpson, Age: 47 Name: Marge Simpson, Age: 45 Name: Lisa Simpson, Age: 9 Name: Bart Simpson, Age: 8<\/p>\n
\nItems in list: 5
\nFirst Names: Homer First Names: Marge First Names: Maggie First Names: Lisa First Names: Bart<\/p>\n
\nThe Stack
\n{
\nStack
\nstackOfPeople.Push(new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 }); stackOfPeople.Push(new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 }); stackOfPeople.Push(new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 });<\/p>\n
\n{
\nConsole.WriteLine("\\nnFirst person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop());
\n}
\ncatch (InvalidOperationException ex)<\/p>\n
\nConsole.WriteLine("\\nError! {0}", ex.Message);
\n}
\n}<\/p>\n
\nQueues are containers that ensure items are accessed in a first-in, first-out manner. Sadly, we humans are subject to queues all day long: lines at the bank, lines at the movie theater, and lines at the morning coffeehouse. When you need to model a scenario in which items are handled on a first-come, first-served
\nbasis, you will find the Queue
\nDequeue() Removes and returns the object at the beginning of the Queue
\nEnqueue() Adds an object to the end of the Queue
\nPeek() Returns the object at the beginning of the Queue
\n{
\n\/\/ Make a Q with three people. Queue
\npeopleQ.Enqueue(new Person {FirstName= "Homer", LastName="Simpson", Age=47});<\/p>\n
\nConsole.WriteLine("{0} is first in line!", peopleQ.Peek().FirstName);<\/p>\n
\n\/\/ Try to de-Q again? try
\n{
\nGetCoffee(peopleQ.Dequeue());
\n}
\ncatch(InvalidOperationException e)
\n{
\nConsole.WriteLine("Error! {0}", e.Message);
\n}
\n\/\/Local helper function
\nstatic void GetCoffee(Person p)
\n{
\nConsole.WriteLine("{0} got coffee!", p.FirstName);
\n}
\n}<\/p>\n
\nHomer got coffee!
\nMarge got coffee!
\nLisa got coffee!
\nError! Queue empty.<\/p>\n
\nIntroduced in .NET 6\/C# 10, the PriorityQueue works just like the Queue
\n{
\nConsole.WriteLine(" Fun with Generic Priority Queues <\/em>\\n");<\/p>\n
\npeopleQ.Enqueue(new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 }, 1); peopleQ.Enqueue(new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 }, 3); peopleQ.Enqueue(new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 }, 3); peopleQ.Enqueue(new Person { FirstName = "Bart", LastName = "Simpson", Age = 12 }, 2);<\/p>\n
\n{
\nConsole.WriteLine(peopleQ.Dequeue().FirstName); \/\/Displays Lisa Console.WriteLine(peopleQ.Dequeue().FirstName); \/\/Displays Bart Console.WriteLine(peopleQ.Dequeue().FirstName); \/\/Displays either Marge or Homer Console.WriteLine(peopleQ.Dequeue().FirstName); \/\/Displays the other priority 3 item
\n}
\n}<\/p>\n
\nThe SortedSet
\nwant it to sort the objects, by passing in as a constructor argument an object that implements the generic
\nIComparer
\nBegin by creating a new class named SortPeopleByAge, which implements IComparer
\n{
\npublic int Compare(Person firstPerson, Person secondPerson)
\n{
\nif (firstPerson?.Age > secondPerson?.Age)
\n{
\nreturn 1;
\n}
\nif (firstPerson?.Age < secondPerson?.Age)
\n{
\nreturn -1;
\n}
\nreturn 0;
\n}
\n}<\/p>\n
\n{
\n\/\/ Make some people with different ages.
\nSortedSet
\n{
\nnew Person {FirstName= "Homer", LastName="Simpson", Age=47}, new Person {FirstName= "Marge", LastName="Simpson", Age=45}, new Person {FirstName= "Lisa", LastName="Simpson", Age=9}, new Person {FirstName= "Bart", LastName="Simpson", Age=8}
\n};<\/p>\n
\nforeach (Person p in setOfPeople)
\n{
\nConsole.WriteLine(p);
\n}
\nConsole.WriteLine();<\/p>\n
\nsetOfPeople.Add(new Person { FirstName = "Saku", LastName = "Jones", Age = 1 }); setOfPeople.Add(new Person { FirstName = "Mikko", LastName = "Jones", Age = 32 });<\/p>\n
\nforeach (Person p in setOfPeople)
\n{
\nConsole.WriteLine(p);
\n}
\n}<\/p>\n
\nAge property, regardless of the order you inserted or removed objects.<\/p>\n
\nName: Lisa Simpson, Age: 9 Name: Marge Simpson, Age: 45 Name: Homer Simpson, Age: 47<\/p>\n
\nAnother handy generic collection is the Dictionary<TKey,TValue> type, which allows you to hold any number of objects that may be referred to via a unique key. Thus, rather than obtaining an item from a List
\nLike other collection objects, you can populate a Dictionary<TKey,TValue> by calling the generic Add() method manually. However, you can also fill a Dictionary<TKey,TValue> using collection initialization syntax. Do be aware that when you are populating this collection object, key names must be unique. If you mistakenly specify the same key multiple times, you will receive a runtime exception.
\nConsider the following method that fills a Dictionary<K,V> with various objects. Notice when you create the Dictionary<TKey,TValue> object, you specify the key type (TKey) and underlying object type (TValue) as constructor arguments. In this example, you are using a string data type as the key and
\na Person type as the value. Also note that you can combine object initialization syntax with collection initialization syntax.<\/p>\n
\n{
\n\/\/ Populate using Add() method
\nDictionary<string, Person> peopleA = new Dictionary<string, Person>(); peopleA.Add("Homer", new Person { FirstName = "Homer", LastName = "Simpson", Age
\n= 47 });
\npeopleA.Add("Marge", new Person { FirstName = "Marge", LastName = "Simpson", Age
\n= 45 });
\npeopleA.Add("Lisa", new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 });<\/p>\n
\nPerson homer = peopleA["Homer"]; Console.WriteLine(homer);<\/p>\n
\nDictionary<string, Person> peopleB = new Dictionary<string, Person>()
\n{
\n{ "Homer", new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 } },
\n{ "Marge", new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 } },
\n{ "Lisa", new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 } }
\n};<\/p>\n
\nPerson lisa = peopleB["Lisa"]; Console.WriteLine(lisa);
\n}<\/p>\n
\nDictionary<string, Person> peopleC = new Dictionary<string, Person>()
\n{
\n["Homer"] = new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 }, ["Marge"] = new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 }, ["Lisa"] = new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 }
\n};<\/p>\n
\nNow that you understand how to work with the major generic classes, we will briefly examine an additional collection-centric namespace, System.Collections.ObjectModel. This is a relatively small namespace, which contains a handful of classes. Table 10-7 documents the two classes that you should most certainly be aware of.<\/p>\n
\nObjectModel Type Meaning in Life
\nObservableCollection
\nReadOnlyObservable Collection
\nCreate a new Console Application project named FunWithObservableCollections and import the System.Collections.ObjectModel namespace into your initial C# code file. In many ways, working with ObservableCollection
\nLike any event, CollectionChanged is defined in terms of a delegate, which in this case is NotifyCollectionChangedEventHandler. This delegate can call any method that takes an object as the first parameter and takes a NotifyCollectionChangedEventArgs as the second. Consider the following code, which populates an observable collection containing Person objects and wires up the CollectionChanged event:<\/p>\n
\n\/\/and add a few Person objects.
\nObservableCollection
\n{
\nnew Person{ FirstName = \"Peter\", LastName = \"Murphy\", Age = 52 }, new Person{ FirstName = \"Kevin\", LastName = \"Key\", Age = 48 },
\n};<\/p>\n
\n{
\nthrow new NotImplementedException();
\n}<\/p>\n
\n{
\nAdd = 0,
\nRemove = 1,
\nReplace = 2,
\nMove = 3,
\nReset = 4,
\n}<\/p>\n
\n...
\nstatic void people_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
\n{
\n\/\/ What was the action that caused the event? Console.WriteLine(\"Action for this event: {0}\", e.Action);<\/p>\n
\nif (e.Action == NotifyCollectionChangedAction.Remove)
\n{
\nConsole.WriteLine(\"Here are the OLD items:\"); foreach (Person p in e.OldItems)<\/p>\n
\nConsole.WriteLine(p.ToString());
\n}
\nConsole.WriteLine();
\n}<\/p>\n
\nif (e.Action == NotifyCollectionChangedAction.Add)
\n{
\n\/\/ Now show the NEW items that were inserted. Console.WriteLine(\"Here are the NEW items:\"); foreach (Person p in e.NewItems)
\n{
\nConsole.WriteLine(p.ToString());
\n}
\n}
\n}<\/p>\n
\npeople.Add(new Person(\"Fred\", \"Smith\", 32));
\n\/\/ Remove an item. people.RemoveAt(0);<\/p>\n
\nName: Fred Smith, Age: 32<\/p>\n
\nName: Peter Murphy, Age: 52<\/p>\n
\nWhile most developers typically use the existing generic types within the base class libraries, it is also possible to build your own generic members and custom generic types. Let\u2019s look at how to incorporate custom generics into your own projects. The first step is to build a generic swap method. Begin by creating a new console application named CustomGenericMethods.
\nWhen you build custom generic methods, you achieve a supercharged version of traditional method overloading. In Chapter 2, you learned that overloading is the act of defining multiple versions of a single method, which differ by the number of, or type of, parameters.<\/p>\n
\n{
\n\/\/ Swap two integers.
\nstatic void Swap(ref int a, ref int b)
\n{
\nint temp = a; a = b;
\nb = temp;
\n}
\n}<\/p>\n
\nstatic void Swap(ref Person a, ref Person b)
\n{
\nPerson temp = a; a = b;
\nb = temp;
\n}<\/p>\n
\nWhenever you have a group of overloaded methods that differ only by incoming arguments, this is your clue that generics could make your life easier. Consider the following generic Swap
\n\/\/ as specified by the type parameter
\n{
\nConsole.WriteLine(\"You sent the Swap() method a {0}\", typeof(T)); T temp = a;
\na = b;
\nb = temp;
\n}<\/p>\n
\nint a = 10, b = 90;
\nConsole.WriteLine(\"Before swap: {0}, {1}\", a, b); SwapFunctions.Swap
\nstring s1 = \"Hello\", s2 = \"There\"; Console.WriteLine(\"Before swap: {0} {1}!\", s1, s2); SwapFunctions.Swap
\nYou sent the Swap() method a System.Int32 After swap: 90, 10<\/p>\n
\nYou sent the Swap() method a System.String After swap: There Hello!<\/p>\n
\nWhen you invoke generic methods such as Swap
\nConsole.WriteLine(\"Before swap: {0}, {1}\", b1, b2); SwapFunctions.Swap(ref b1, ref b2); Console.WriteLine(\"After swap: {0}, {1}\", b1, b2);<\/p>\n
\n{
\n\/\/ BaseType is a method used in reflection,
\n\/\/ which will be examined in Chapter 17
\nConsole.WriteLine(\"Base class of {0} is: {1}.\", typeof(T), typeof(T).BaseType);
\n}<\/p>\n
\n\/\/ Must supply type parameter if
\n\/\/ the method does not take params. DisplayBaseClass
\n\/\/ DisplayBaseClass();
\nConsole.ReadLine();<\/p>\n
\nNow that you understand how to define and invoke generic methods, it\u2019s time to turn your attention to the construction of a generic structure (the process of building a generic class is identical) within a new Console Application project named GenericPoint. Assume you have built a generic Point structure that supports a single type parameter that represents the underlying storage for the (x, y) coordinates. The caller can then create Point
\nPoint
\nPoint