CSharp_03_Generics_introduction_withexamples

Programming in C#
Generics
CSE 494R
(proposed course for 459 Programming in C#)
Prof. Roger Crawfis

Motivation
See the Type Unification and the use of
the ArrayList set of slides.
In summary, four main goals:
1. Increase type safety (statically)
2. Eliminate type casts
3. Eliminate box’ing and unbox’ing
4. C++ has templates
 Syntax is similar to C++

Generic Syntax
Write public class Stack<T> { … }
T is the type variable
 Stack<int> myStack = new Stack<int>();
Can have several type parameters
Dictionary<TKey, TValue>
Compiler will now enforce type safety
myStack.Push(4.3) // Compiler error
Design Note
It is customary to use T for a generic single type.
For multiple types or in cases where the type is
clear a more specific name should be used. This is
pre-fixed by a capital T.

Terminology
Why the name Generic?
We separate the behavior from the type
allowing more generic behavior
descriptions.
Also called Parametric Polymorphism
We supply a type parameter and the same
code or behavior applies to this type.

Generic Parameterization
Generics can be used with:
Types
 Struct
 Interface
 Class
 Delegate
Methods

Using Generics - Types
Can be used to easily create non-
generic derived types:
public class IntStack : Stack<int>
{
}

Can be used in internal fields, properties
and methods of a class:
public struct Customer<T>
{
private static List<T> customerList;
private T customerInfo;
public T CustomerInfo { get; set; }
public int CompareCustomers( T customerInfo );
}
A better type name here
would be TCustomerInfo

Using the type is like using any other
non-generic type.
The type parameter only needs to be
specified during instantiation.
Customer<int> fred = new Customer<int>();
fred.CustomerInfo = 4;

Verifying Generic Types
In C#, generic types can be compiled into a
class library or dll and used by many
applications.
Differs from C++ templates, which use the
source code to create a new type at
compile time.
Hence, when compiling a generic type, the
compiler needs to ensure that the code will
work for any type.

Generic Constraints
What if we want to write
public class Stack<T>
public T PopEmpty() {
return new T();
}
}
Why would the compiler produce an
error for this?
What if my type requires
parameters on all of their
constructors?

Generic Constraints
 A new keyword, where provides constraints on a type
parameter.
 A base class or interface can be used as a constraint.
 For instance
public interface IDrawable { public void Draw(); }
 Need a constraint that our type T implements the
IDrawable interface.
public class SceneGraph<T> where T : IDrawable {
public void Render() { … T node; …
node.Draw();
}
}
 No need to cast
 Compiler uses type information to decide
Again, this can
be enforced at
compile time

Generic Constraints
Can also specify a class constraint.
That is, require a reference type:
public class CarFactory<T> where T : class {
private T currentCar = null;
Forbids CarFactory<int> and other value
types.
Useful since I can not set an int to null.

Generic Constraints
Alternatively, require a value (struct)
type.
public struct Nullable<T> where T : struct {
private T value;
Fixes the new problem (but is limited):
public class Stack<T> where T : struct {
return new T();
}
}

Using a Default Value
You may need to initialize a variable
public class GraphNode<T> {
private T nodeLabel;
private void ClearLabel() {
nodeLabel = null;
}
Why doesn’t this work?
What do I
do if T is
int?

Using a Default Value
The default keyword
private T nodeLabel;
private void ClearLabel() {
nodeLabel = default(T);
}
If T is a reference type default(T) will be
null.
For value types all bits are set to zero.

Constructor Constraint
Special constraint using the new keyword:
public class Stack<T> where T : new() {
return new T();
}
}
Parameter-less constructor constraint
 Type T must provide a public parameter-less
constructor
 No support for other constructors or other method
syntaxes.
 The new() constraint must be the last constraint.

Primary Constraints
A generic type parameter, like a regular
type, can have zero or one primary
constraints, including:
Derived from a non-sealed concrete or
abstract base type
The class constraint
The struct constraint

Secondary Constraints
A generic type parameter, like a regular
type, can have zero or more interface
constraints
where T : ICloneable, IComparable
…
}

The where clause
A type parameter can only have one
where clause, so all constraints must be
specified within a single where clause.
Not allowed:
where T : MyNode, ICloneable
where T : IComparable, new()
…
}

Multiple Type Parameters
A generic type can be parameterized
with many type place-holders;
public interface IFunction<TDomain,TRange> {
TRange Evaluate(TDomain sample);
}
2D, 3D, complex function support with
mappings from one domain to another.

Dependent Constraints
Each type parameter can have its own
set of constraints (and own where class).
You can also have one type parameter
be dependent on another.
public class SubSet<U,V> where U : V
public class Group<U,V>
where V : IEnumerable<U> { … }

Compilation Errors
class A {...}
class B {...}
class Incompat<S,T>
where S: A, T
where T: B
{
...
}

Compilation Errors
class StructWithClass<S,T,U>
where S: struct, T
where T: U
where U: A
{
...
}

Compilation Errors
interface I<T>
{
void F();
}
class X<U,V>: I<U>, I<V>
{
void I<U>.F() {...}
void I<V>.F() {...}
}

Generic Methods
C# also allow you to parameterize a
method with generic types:
public static void Swap<T>( ref T a, ref T b )
{
T temp = a;
a = b;
b = temp;
}

Generic Methods
The method does not need to be static.
public class Report<T> : where T IFormatter
{
}
public class Insurance {
public Report<T> ProduceReport<T>()
where T : IFormatter
{
…
}
}

Type Covariance
We say a type Derived is Covariant to
the type, Base, if Derived can be cast to
Base.
Generic types are not covariant.
MyClass<Derived> md;
MyClass<Base> mb = md;

Java Generics v. C#
Java made the decision to keep
backward compatible bytecode.
Hence old JVM’s can run the new Java with
generics code.
Ruins run-time type reflection.
C# 2.0 requires a new CLR.
Generics are supported in the IL code.

C++ Templates v. C#
C++ has slightly more powerful
parametric polymorphism in that non-
type parameters can also be used.
No run-time type support or reflection.
Run-time (generics) versus compile-time
(templates)
Requires you to expose your source
code to everyone.

Assignment
In addition to Reading Chapters 1-3 of the
textbook and going through these lectures,
you should:
 Memorize the C# keywords a-I in the appendix
of the book.
 Think of how you would design a program or set
of programs to display memorization questions
or flashcards.
 Read careful through the errata for book for
Chapters 1-4.

CSharp_03_Generics_introduction_withexamples

More Related Content

Similar to CSharp_03_Generics_introduction_withexamples

More from Ranjithsingh20

Recently uploaded

CSharp_03_Generics_introduction_withexamples