Collections and Generics

 1. Interface layout



2. the .NET platform supports two broad groups of data types, termed
value types and reference types. C# provides a very simple mechanism,
termed boxing, to convert a value type to a reference

type.

 

3. In summary, generic containers provide the following benefits over their nongeneric counterparts:

• Generics provide better performance, as they do not result in boxing or unboxing penalties.

• Generics are more type safe, as they can only contain the “type of type” you specify.

• Generics greatly reduce the need to build custom collection types, as
the base class library provides several prefabricated containers.

 

4. With the introduction of generics, the C# default keyword has
been given a dual identity. In addition to its use within a switch
construct, it can be used to set a type parameter to its default value.
This is clearly helpful given that a generic type does not know the
actual placeholders up front and therefore cannot safely assume what
the default value will be. The defaults for a type parameter are as
follows:

• Numeric values have a default value of 0.

• Reference types have a default value of null.

• Fields of a structure are set to 0 (for value types) or null (for reference types).

   1. // The "default" keyword is overloaded in C#.  
   2. // When used with generics, it represents the default  
   3. // value of a type parameter.  
   4. public void ResetPoint()  
   5. {  
   6.     xPos = default(T);  
   7.     yPos = default(T);  
   8. }  

// The "default" keyword is overloaded in C#.
// When used with generics, it represents the default
// value of a type parameter.
public void ResetPoint()
{
xPos = default(T);
yPos = default(T);
}

 

5.

   1. // MyGenericClass derives from Object, while  
   2. // contained items must have a default ctor.  
   3. public class MyGenericClass<T> where T : new()  
   4. {...}  
   5. // MyGenericClass derives from Object, while  

946e
   6. // contained items must be a class implementing IDrawable  
   7. // and support a default ctor.  
   8. public class MyGenericClass<T> where T : class, IDrawable, new()  
   9. {...}  
  10. // MyGenericClass derives from MyBase and implements ISomeInterface,  
  11. // while the contained items must be structures.  
  12. public class MyGenericClass<T> : MyBase, ISomeInterface where T : struct  
  13. {...}  
  14. // <K> must have a default ctor, while <T> must  
  15. // implement the generic IComparable interface.  
  16. public class MyGenericClass<K, T> where K : new()  
  17. where T : IComparable<T>  
  18. {...}