Generics_RIO.ppt

Changepond Technologies, Confidential
GENERICS, DELEGATES & LAMBDA

GENERICS: OVERVIEW
Introduction:
o Generics allow developers to define types and methods that are parameterized with type
parameters.
o Those parameters are ultimately filled in when such types or methods are used.
2

GENERICS: OBJECTIVES
o Objective:
After completing this chapter you will be able to:
 Describe Generics
 Different implementation of generics
• Generic Methods
• Generic Constraints
3

GENERICS - A PRACTICAL SCENARIO
4
Suppose you’re writing an implementation of a list data structure, which maintains a
sequential ordering of elements and allows index-based access to its elements.
Our collection type provides an improvement over arrays because it allows for the
underlying storage to grow when needed.
Internally, the most obvious way to implement this is by using an array to store the
elements and copy elements to a larger array when storage space is exceeded.
class ArrayList {
private object[] _elements;
...
public object this[int i] {
get { return _elements[i]; }
set { _elements[i] = value; }
}
public void Add(object o) {
// Add to array, dynamically growing as necessary.
}
...
}
Looks Good. Any problem ?

GENERICS: PRACTICAL SCENARIO
5
ArrayList xs = new ArrayList();
xs.Add(1);
xs.Add(2);
xs.Add(3);
//Evil mind at play
xs[0] = “Should not be here”;
Excessive amount of casts
to work with the API
The compiler doesn’t catch any
violations (compile time)against any
implicit contract with regard to the (by
the human) expected types fed in to
the collection

GENERICS: PRACTICAL SCENARIO
o When creating a generic type, whether it’s a class, struct, interface, or delegate, you’re
adding one or more type parameters to the type declaration.
o On the other side , a user of the type can specify types for those parameters
6
class List<T> {
private T[] _elements;
...
public T this[int i] {
get { return _elements[i]; }
set { _elements[i] = value; }
}
public void Add(T o) {
// Add to array, dynamically
growing as necessary.
}
...
}
List<int> xs = new List<int> { 1, 2, 3 };
List<string> names = new List<string> { “Bart”, “John” };
//Lets test if the evil intentions work !!
List<int> xs = new List<int> { 1, 2, 3 };
xs[0] = “Should not be here”; //Evil statement
int first = xs[0]; // No need to cast here anymore...
Better compile
time Checking

GENERIC TYPES DECLARATION
o Declaring Generic Types
class Dictionary<TKey, TValue>
o Stylistically, generic type parameters are prefixed with a capital T, followed by a description of the
parameter.
7
class List<T> {
private T[] _elements;
}
Applied to a
class
public interface IEnumerable<out T> : IEnumerable {
IEnumerator<T> GetEnumerator();
}
Applied to a
Interfaces
Not only classes support generics. Structs , Methods and
interfaces also do

GENERIC DECLARATIONS
o Using Generic Types
8
var numbers = new Dictionary<string, int> {
{ “Bart”, 911 },
{ “John”, 119 }
};
Substituting the TKey type
parameter for string and the
TValue type parameter for int

GENERIC TYPE – ENFORCING CONSTRAINTS
o Generic Constraints
9
class Foo<T> {
public void Bar(T input) {
// What can be done with T?
}
}
class Foo<T> {
private T _field;
public void Bar(T input) {
_field = input;
}
}
May be to store the Value
in a private file
Is it possible to invoke a method in T ?
How do we define a method for T ?
Define and invoke
Methods on T using
Generic Constraints

o Consider the declaration OrderedList<T>
 How do we know what methods that T offers ?
 How do we make sure T is Compared so that it can be ordered?
 May be we need some sort of contract that T should adhere to..
1
class OrderedList<T> where T :
IComparable<T> {
// Now we can use the CompareTo
method on objects of type T...
}
OrderedList<T> can only accept
parameter T,types that implement
IComparable<T>.
Generic Type – Enforcing
Constraints

GENERIC TYPE – ENFORCING CONSTRAINTS
1
class OrderedList<T> where T : IComparable<T> {
private List<T> _elements = new List<T>();
public void Add(T value) {
int i = 0;
while (i < _elements.Count) {
if (_elements[i].CompareTo(value) >= 0)
break;
i++;
}
_elements.Insert(i, value);
}
}

GENERICS – CREATING GENERIC METHODS
o Generics Methods
 Generic methods enable you to specify a set of related methods with a single method
declaration. Like a Generic classes enable you to specify a set of related classes with a single
class declaration
 Generic Method provide compile-time type safety like its other Generic types.
 Generic methods provide a implicit way of method overloading.
 Consider the code snippet below.
1
int[] intArray = { 1, 2, 3, 4, 5, 6 };
double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
char[] charArray = { 'H', 'E', 'L', 'L', 'O' };
Console.WriteLine( “Printing all the arrays using PrintArray overload methods:" );
PrintArray( intArray ); // Overload for printing Integer Array
PrintArray( doubleArray ); // Overload for Printing double Array
PrintArray( charArray ); // Overload for printing Char Array
}

GENERICS – CREATING GENERIC METHODS
o The above code snippet can be rewritten using a generic method of DisplayArray like the
one below.
o Call the generic method in your code like below
1
private static void PrintArray( T[] inputArray )
{
foreach ( T element in inputArray )
Console.Write( element + " " );
Console.WriteLine( "n" );
}
PrintArray <int[]> ( intArray ); // pass an int array argument
PrintArray <double[]>( doubleArray ); // pass a double array argument
PrintArray <char[]> ( charArray ); // pass a char array argument

GENERICS: SUMMARY
o Recap of Generic Concepts
o Different Generic Types
o Advantages of Generic Types
o Usage of Generic Types
1

DELEGATES
o Delegates were introduced with C# 1.0 (with .NET 1.0) as a way to represent function
pointers
o Delegates are type-safe object that can point to another method (or possibly multiple
methods) in the application, which can be invoked at later time.
o A delegate type maintains three important pieces of information :
– The name of the method on which it make calls
– Any argument (if any) of this method.
– The return value (if any) of this method.
1

DELEGATES
o Delegates in .NET 1.x Era
1
// Step 1 Declare the delegate
delegate int MyDelegate(int firstNumber, int secondNumber);
//Step 2 Declare a method that matches the delegate signature:
private int AddNumbers(int firstNumber, int secondNumber)
{
return firstNumber + secondNumber;
}
//Step 3 Instantiate the delegate (tell the delegate with method to call)
MyDelegate myDelegate = new MyDelegate(this.AddNumbers);
//Step 4Call the delegate and retrieve the result
int result = myDelegate(3, 4);

DELEGATES
o Delegates in .NET 2.0 – 3.0 using Ananymous Methods
o .NET 2.0 introduced a concept called anonymous methods. This allowed us to call inline
business logic (i.e., a method) without having to have the method defined.
o The business logic simply became part of the delegate.
1
//Step 1 Delcare the delegate:
//Step 2 Instantiate the delegate (with the business logic defined inside the delegate "body")
MyDelegate myDelegate= delegate(int firstNumber, int secondNumber)
{
return firstNumber + secondNumber;
};
//Step 3 Call the delegate:
int result = myDelegate(3, 4);

LAMBDA EXPRESSION WITH DELEGATES
oLambda expressions are a further evolution
of syntax brevity for anonymous methods.
oDeclare the business logic inline with
delegates
oLambda Expr are syntactic shortcut for
delegates
1
//Step 1Declare a delegate
//Step 2 Initialize the delegate using a lambda expressions (new in .NET 3.5)
MyDelegate myDelegate = (firstNumber, secondNumber) => firstNumber + secondNumber;
//Setp 3 : Call the delegate
int result= myDelegate(3,4);

LAMBDA EXPRESSION & FUNC DELEGATE
o The other way of using Lambda is by using the new Func delegate.
o A Func is a delegate type with several generic parameters defined.
o There are almost 16 different Func delegates pre-defined that covers the most common
scenarios
1
//For example, the Func below has 2 input parameters and a return parameter. This one of
that is pre-defined in .NET 3.5
public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);
//Using the above Func delegate
Func<int, int, int> myDelegate= (firstNumber, secondNumber) => firstNumber + secondNumber;
int i=myDelegate(4,5);

LAMBDA EXPRESSION & ACTION DELEGATE
o As with Func, the Action delegate has five variations.
o These allow the encapsulation of methods that have up to 16 parameters but do not
return a value. Again, all of the parameters are generic types allowing any type to be used
for each argument.
2
public delegate void Action()
public delegate void Action<T, >(T arg)
public delegate void Action<T1, T2>(T1 arg1, T2 arg2)
public delegate void Action<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3)
public delegate void Action<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
…

LAMBDA EXPRESSION & ACTION DELEGATES
o The simplest Action delegate is used with methods that accept no parameters and return
no values.
2
Action showMessage = delegate { Console.WriteLine("Hello, world"); };
showMessage(); // Outputs "Hello, world"
Action showMessage = () => { Console.WriteLine("Hello, world"); };
showMessage(); // Outputs "Hello, world“
Lambda
Expr
Using Action with Parameters
Action<string> showMessage = delegate(string msg) { Console.WriteLine(msg); };
showMessage("Hello, world"); // Outputs "Hello, world"
Using Action with Parameters
Action<string> showMessage = (msg)=>{ Console.WriteLine(msg); };
showMessage("Hello, world"); // Outputs "Hello, world"
Lambda
Expr

PARTIAL CLASSES
o The partial keyword was introduced in version 2.0 of the .NET framework. Very simply, the
partial keyword permits us to split the definition of a single class, structure, or interface
into more than one file.
o Each source file contains a section of the class definition, and all parts are combined when
the application is compiled.
o More than one developer can simultaneously write the code for the class.
o We can easily write our code (for extended functionality) for a VS.NET generated or other
code generation tool generated class. This will allow us to write the code of our own need
without messing with the system generated code.
2

KEY POINTS ON PARTIAL CLASSES
o All the partial definitions must proceeded with the key word "Partial".
o All the partial types meant to be the part of same type must be defined within a same
assembly and module.
o Method signatures (return type, name of the method, and parameters) must be unique for
the aggregated typed (which was defined partially).
o The partial types must have the same accessibility.
o If any part is sealed, the entire class is sealed.
o If any part is abstract, the entire class is abstract.
o Inheritance at any partial type applies to the entire class.
2

NESTED CLASSES
o A nested class is one that is created inside another class.
o There are several reasons to have inner classes. The two important points are:
 Organizing code into real world situations where there is a special relationship between two
objects.
 Hiding a class within another class so that we do not want the inner class to be used from
outside of the class it is created within.
2

NESTED CLASSES
o Declaration and Use
 A nested class is declared in the same manner as a normal class declaration. The difference is
that a nested class has access to all of the available modifiers.
o The this keyword reference in the inner class only holds a reference to the inner class.
Data members of the outer class are not accessible using the this reference in the inner
class. If this is needed, pass a reference of the outer class into the constructor of the inner
class.
o Static members of the outer class are available in the inner class irrespective of the
accessibility level.
2

NESTED CLASSES -AN EXAMPLE
o For example, a class named Car would have an engine. Objects that fall into this
relationship use of the term "is a part of". "An engine is a part of a car". In UML, an object
relationship that is formed by aggregation is drawn using an empty diamond. An object
relationship that is formed using composition is drawn using a filled diamond.
o The following UML diagram illustrates the concepts of aggregation and composition.
2

NESTED CLASSES -AN EXAMPLE - UML
2

NESTED CLASS :LEND A HAND
o From the previous diagram, Try to create a possible small code sample that shows the two
forms of relationship.
Note: Objects that use composition should be created as inner classes.
2

LEND A HAND - ANSWERS
2
namespace MyCars
{
// Inherit from class Car
public class FordCapri : Car
{
public FordCapri()
{ theEngine.horsePower = 2000;
}
}
}

You have successfully completed
Generics, Delegates and Lambda Expr
Click here to proceed

Generics_RIO.ppt

Recommended

Recommended

More Related Content

Similar to Generics_RIO.ppt

Similar to Generics_RIO.ppt (20)

Recently uploaded

Recently uploaded (20)

Generics_RIO.ppt

Editor's Notes