Generics

C# 2.
0 enhancement
Generics
Anonymous methods
Nullable Types
Iterators
Partial types
Generics
Generics
Permit classes, structs, interfaces, delegates, and

methods to be parameterized by the types of data they
store and manipulate.
Generics are useful because they provide stronger

compile-time type checking, require fewer explicit
conversions between data types, and reduce the need
for boxing operations and run-time type checks.
To Understand Generics
Understand Value v/s Reference type.
Boxing & Un boxing
Why need Strong Type
Generic (as Management jargon)

Generics
First we have to Understanding Value types & Reference Types
- .net Data type may be Value based or Reference based
Valued Based:
- Value based Data types includes (numeric data types like float, int, etc.)
and enumerations and structures. And are allocated on the stack.
- Value based types could be quickly remove from the Stack / memory once
they fall out from the defining scope…
public void m()
{
int x=0;
console.writeline(x);
………..// x will pop out from the stack ..
}
Valued based v/s Referenced based type
Valued Based:
- Member to member copy is achieved on assigning one value type to
another.
public void m()
{
int x=20;
int y=x;
// now if I make j=200;
x= 20; (It will stay same)
}
- Struct are always Value types:

Struct Myname
{
public int x, y;
}
to call it I will use – Myname ob = new Myname();
Referenced Based Type:
- Referenced based type are allocated on Managed Heap.
- .Net Garbage collector destroy them. Till them they stay in the
memory.
- Assignment of reference type results in a new reference to the same

object on the heap.
Demo
(console application D:\prabhjot\hcl)

la ss
it hc
e w
c tur
u
str
lace
p
Re
Pitch for Boxing & Unboxing
Looking at the old example we realize that the behaviors of value

based and reference based are so different
Over everything: what if?
We may occasionally needs to represent a variable of one

category as the variable of another category.
Boxing
- To convert Value type to Reference type c# provides Boxing
mechanism.
Short s =25;
// to box the value
object ob= s;
A process of explicitly converting the value type into corresponding

reference type by storing the variable in a System.Object.
CLR works in the back ground and allocate a new object on the heap
plus assign the value(here 25).
& Unboxing
- To convert Reference type to Value type c# provides UNBoxing
mechanism.
Short y= (short)ob;
It is must or mandatory that you unbox into an Appropriate data type.
Else you will get a INVALIDCASTEXCEPTION.

& Unboxing
Demo
(D:\prabhjot\hcldemo2\hcldemo2)
& Unboxing
ers
ra mm
o g
pr
f or
blem
o
Pr
Automatic Unboxing
Demo
Console application : D:\prabhjot\hclcsharpdemo3\hclcsharpdemo3

Automatic Unboxing
Automatic boxing
• When working with System.Collections (Arraylist

provides you members that allows to insert obtain and
remove items)
Automatic boxing
C # Automatically boxes variables when appropriate. (passing a value type into

a method requiring an Object parameter).
Static void main(string[] args)

{
// create a int (value type)
Int myInt =99;
Use(myInt)
}
Static void Use(Oblect o)
{
console.writeline(“value {0}, o”);
}
Unboxing with Custom Value type (No automatic)
• When you pass custom Struct or enumeration into a

method which takes Object as parameter
Generics
Generics
• In Reality- The unboxing process is very helpful in that it

allows everything can be treated as s System.Object type,
while CLR takes care of memory related details on our behalf.
So far Out come:
• Boxing and Unboxing takes some Processing Time. It hurts

the Performance of the Application. So is Very Expensive.
(Performance loss with Arraylist)
• Unbxing is Must But needs to be with proper data type else
run time error. (Programmer pain)
Generics
• This simplified Approach came with a burden of box-
unbox-box process as a result reflects two weakness:
- Performance loss (With Array List)
- Lack of type safety

(At runtime will know that you have used wrong data type for
casting)
Generics
• When using System.Collections.Generic.List<>, Boxing

and unboxing is not required.
Demo
D:\prabhjot\windows\hcldcsharpdemo4
Generics
Generics
Generics
• When using System.Collections.Generic.List<>, Boxing

and unboxing is not required.
• Generics Provides a way for programmer to define

“place holder”, formally called typed parameter.
• We can build our own generic method, classes,

structures, interfaces and delegates.
Generics
• Generics Provides a way for programmer to define

“place holder”, formally called typed parameter.

structures, interfaces and delegates.
Demo
Console Application D:\prabhjot\hcalcsharpdemogm5

Generics
Generics
Generics
Generics

structures, Base Class, Custom Generic
collections, interfaces and delegates.
Demo
D:\prabhjot\hclcsharpdemo6gc
Generics
Generics
Generics
Generic Base Class
Generic Interface
Generic Delegates
Generic Lacks Operator Supports
C# Nullable Types
C# Nullable Types
A Nullable type supports all values of its underlying type

plus an additional null state.
Thus if we declare Nullable System.Boolean, it could be

assigned a value from the set {true, false, null}.
C# Nullable Types
Static void Main (string[] args)
{ // compile error
bool myBool = null;
int myint= Null;
}

{ // define some local nullable type
bool? nullablemyBool = null;
int? nullablemyint= Null;
Int? nullableinttwo=30;
int? arrayof nullableInts= new int?[10];
}
C# Nullable Types
{ int? i= dr.GetIntFromDatabase();
if(i.HasVAlue)
{
}
else
{console.writeline (“sorry”); }
}

{ // define some local nullable type
bool? nullablemyBool = null;
int? nullablemyint= Null;
Int? nullableinttwo=30;
int? arrayof nullableInts= new int?[10];
}
C# Nullable Types
To define a Nullable variable type, the question mark symbol(?), is

suffixed to the under lying Datatype.
This syntax is only legal with value type or value of array types. Any
attempts to create a nullable reference type will issue a compile
error.
Local nullable variable must be assigned an initial value

C# Nullable Types
Can be particularly useful when you are interacting with databases, given
that columns in a data base may be intentionally empty.
Class Databasereader
{ //nullable Data field
public int? numbericValue;
public bool? boolValue=True;
//nullable return type
public int? GetintFromDatabse()

{return numbericValue;}
//nullable return type
public bool? GetBoolFromDatabase()

{return boolValue;}
}
Partial Types
Allow classes, structs, and interfaces to be broken into multiple pieces stored in
different source files for easier development and maintenance.
C# 2005 introduces a new type modifier named partial that allows you to define a C#
type across multiple *.cs files. Earlier version required all code for a given type to be
defined within a single *.cs file.
For example, using Partial class modifier, we could place all the public members in a
file named MyType_Public.cs and while the private fields into MyType_Private.cs file.
once these files are compile by csc.exe, forms a single unified type
Partial Types
partial classes mean that your class definition can be split into
multiple physical files. Logically, partial classes do not make
any difference to the compiler. During compile time, it simply
groups all the various partial classes and treats them as a
single entity.
Using partial classes, the UI code can be hidden from the

developer, who usually has no need to access it anyway.
Partial classes will also make debugging easier, as the code
is partitioned into separate files.
Here are some good reasons to use partial classes:
They allow programmers on your team to work on different parts of
a class without needing to share the same physical file.
• The most compelling reason for using partial class is to separate

your application business logic from the designer-generated code.
For example, the code generated by Visual Studio 2005 for a
Windows Form is kept separate from your business logic (we will
discuss this in a later section). This will prevent developers from
messing with the code that is used for the UI. At the same time, it
will prevent you from losing your changes to the designer-generated
code when you change the UI.
Partial Types
Demo
D:\prabhjot\PartialType
Partial Types
Partial Types
Partial Types
Anonymous methods
Allows code blocks to be written “in-line” where delegate

values are expected.
Anonymous methods
Lets Understand the Difference between old delegate and new proposed
Anonymous Delegate through Practical.
Lets start with normal delegate first……

Anonymous methods
ate
eleg
d
al
orm
N
Anonymous methods
In c# 2.0 this code will not have a name

Anonymous methods
So we used Anonymous Delegate

in place of Normal delegate. So we have a
Methods without a name, compiler will give it any
Anonymous methods
If the method will not be reused then use inline

Declaration i.e anonymous else not
Anonymous method
• For Closure we will use this.
• Anonymous delegate retain its scope at

the time they were instantiated.
• Lets create a methods that will return the

instance of our delegate
Anonymous method
It remembered Hello
Anonymous method-end
Iterators
As we all familiar about C# for-each , it allow to iterate over the elements

of a collection of enumerable ,the GetEnumerator method returns the
enumerator from the collection. If we look enumerator has certain
constraints like performance, implementations etc , Iterators makes this
task more simple and efficient
Iterators
Demo
D:\prabhjot\hclcsharpdemo6
D:\prabhjot\csharpdemo5
Without Iterators
Without Iterators
Without Iterators
Without Iterators
With Iterators
With Iterators
Iterators-end
Conclusion:

Generics

Uploaded by

Copyright:

Available Formats

Generics

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Generics

Uploaded by

Copyright:

Available Formats

C# 2.

Permit classes, structs, interfaces, delegates, and

Generics are useful because they provide stronger

Understand Value v/s Reference type.

Boxing & Un boxing

Why need Strong Type

Generic (as Management jargon)

- Struct are always Value types:

Referenced Based Type:

- Referenced based type are allocated on Managed Heap.

- Assignment of reference type results in a new reference to the same

(console application D:\prabhjot\hcl)

Looking at the old example we realize that the behaviors of value

Over everything: what if?

We may occasionally needs to represent a variable of one

A process of explicitly converting the value type into corresponding

It is must or mandatory that you unbox into an Appropriate data type.

Else you will get a INVALIDCASTEXCEPTION.

Console application : D:\prabhjot\hclcsharpdemo3\hclcsharpdemo3

• When working with System.Collections (Arraylist

C # Automatically boxes variables when appropriate. (passing a value type into

Static void main(string[] args)

• When you pass custom Struct or enumeration into a

• In Reality- The unboxing process is very helpful in that it

So far Out come:

• Boxing and Unboxing takes some Processing Time. It hurts

- Performance loss (With Array List)

- Lack of type safety

• When using System.Collections.Generic.List<>, Boxing

• When using System.Collections.Generic.List<>, Boxing

• Generics Provides a way for programmer to define

• We can build our own generic method, classes,

• Generics Provides a way for programmer to define

• We can build our own generic method, classes,

Console Application D:\prabhjot\hcalcsharpdemogm5

• We can build our own generic method, classes,

A Nullable type supports all values of its underlying type

Thus if we declare Nullable System.Boolean, it could be

Static void Main (string[] args)

Static void Main (string[] args)

To define a Nullable variable type, the question mark symbol(?), is

Local nullable variable must be assigned an initial value

public int? GetintFromDatabse()

public bool? GetBoolFromDatabase()

Using partial classes, the UI code can be hidden from the

• The most compelling reason for using partial class is to separate

Allows code blocks to be written “in-line” where delegate

Lets start with normal delegate first……

In c# 2.0 this code will not have a name

So we used Anonymous Delegate

If the method will not be reused then use inline

• Anonymous delegate retain its scope at

• Lets create a methods that will return the

As we all familiar about C# for-each , it allow to iterate over the elements

You might also like