This document discusses various .NET system types and interfaces. It explains that base system types provide predefined data types, generics allow creation of type-safe collections, and nullable types allow value types to be assigned null values. It also covers exception handling using exception classes, customizing code with attributes, and implementing common interfaces like IComparable, ICloneable, and IDisposable.

1. In this session, you will learn to:
Explain the purpose of base system types
Implement generics, Nullable types, exception classes, and
attributes
Implement comparison interfaces and the IConvertible,
ICloneable, IFormattable, and IDisposable interfaces
Objectives

2. What are System Types?
System types are pre-defined data types.
Based on how compilers manage data types, software
development environments can be classified into two types:
Loosely typed
Strongly typed
.NET Framework provides a common set of data types called
Common Type System (CTS).
Examining Primary System Types
Strongly typed
environment

3. What are Value Types?
Value types are types that contain the actual data assigned to
them instead of a reference to the data.
There are two types of value types:
Built-in types: These are also referred to as simple or primitive
value types. Some of the built-in types are:
System.Char
System.Int32
System.Single
User-defined value types: These are custom value types that make
the .NET Framework fully extensible. Some of the user-defined
value types are:
Structure
Constant
Enumeration
Examining Primary System Types (Contd.)

4. What are Reference Types?
Reference types are system types that contain a reference to
assigned data instead of the actual data.
The data of a reference type is stored on a heap, but its
reference is stored on a stack.
There are two types of reference types:
Classes
Interfaces
Stack
A=“Hi” HiA
Heap
Examining Primary System Types (Contd.)

5. What is Boxing and Unboxing?
Boxing: It is the conversion of a value type to a reference type.
Unboxing: It is the explicit conversion of a reference type to a
value type.
Boxing
Unboxing
Value Type
Reference
Type
Examining Primary System Types (Contd.)

6. The following code example implements boxing:
int a = 100;
object o = a;
a = 200;
Console.WriteLine("The value-type value = {0}",
a);
Console.WriteLine("The object-type value = {0}",
o);
Examining Primary System Types (Contd.)

7. The following code example implements unboxing:
int a = 1;
Object o = a;
a = 100;
Console.WriteLine(a);
a = (int) o;
Console.WriteLine(a);
Examining Primary System Types (Contd.)

8. What is Casting?
Data type conversion in the .NET Framework is
known as type casting.
Type casting is of two types:
Implicit: Implicit casting is also called widening conversion because
narrow data types are converted to wide data types.
Explicit: Explicit casting is also called narrowing conversion
because wide data types are converted to narrow data types.
Single Double
Implicit casting
Explicit casting
Examining Primary System Types (Contd.)

9. The following code example shows the implementation of
implicit casting:
Int32 a;
Double b;
a = 100;
b = a;
The following code example shows the implementation of
explicit casting:
Int64 a = 100;
Int32 b = 0;
b = (Int32) a;
Examining Primary System Types (Contd.)

10. What is type safety?
Just a minute
Answer
Type safety is a situation where a compiler allows only those
values that comply with the assigned data type to be stored in
the variable.

11. What are Generics?
Generics are used to create type-safe collections for both
reference and value types.
By using generic types, you can create a method, class,
structure, or an interface in your code without specifying any
fixed data type.
They provide advantages such as reusability, type safety and
performance.
Working with Special System Types

12. The following code snippet defines a generic class
called CommonData:
class Program
{
static void Main(string[] args)
{
CommonData<string>name = new
CommonData<string>();
name.Value = ".NET Framework";
CommonData<float>version = new
CommonData<float>();
version.Value = 2.0F;
Console.WriteLine(name.Value);
Console.WriteLine(version.Value);
} }
Working with Special System Types (Contd.)

13. public class CommonData<T>
{
private T _data;
public T Value
{
get
{
return this._data;
}
set
{
this._data = value;
}
}
}
Working with Special System Types (Contd.)

14. Advantages of generics
Reusability: A single generic type definition can be used for
multiple scenarios in the same code, without any alterations.
Type safety: Generic data types provide better type safety,
especially in situations where collections are used.
Performance: Generic types perform better than normal
system types because they reduce the need for boxing,
unboxing, and type casting the variables or objects.
Working with Special System Types (Contd.)

15. What are generics?
Just a minute
Answer
The .NET Framework 2.0 provides generics that you can use to
create type-safe collections for both reference and value types.

16. Assign Null Values to Value Types by Using Nullable
Data Types
By using a Nullable data type you can assign null values for
value type variables.
Nullable data types are expanded only at run time.
The following code snippet shows implementation of the
Nullable data type for the field date of anniversary:
public Nullable<DateTime> Anniversary
{ get
{return this._mAnniversary;}
set
{if (this._married)
this._mAnniversary = value;
else
this._mAnniversary = null;
} }
Working with Special System Types (Contd.)

17. Can value types be assigned a null value, and what value
will they then hold?
Just a minute
Answer
Value types can be assigned a null value. However, when you
assign a null value to a value type variable, only its default value
is assigned to the value type variable. For example, in the case
of an integer value type variable, the default value assigned will
be zero.

18. Handle Exceptions in Applications by Using Exception
Classes
Exceptions are error conditions or unexpected behavior that a
program may encounter at run time.
.Net Framework 2.0 provides two types of exception handling:
Predefined exception handling
User-defined exception handling
The try, catch, and finally block is used to handle exceptions
The throw statement is used to explicitly signal the
occurrence of an exception during program execution.
The exceptions are derived from the System.Exception
class for handling exceptions in the .Net Framework.
Working with Special System Types (Contd.)

19. The following code example uses a try/catch block to
catch a possible predefined exception:
ArgumentOutOfRangeException.
class ExceptionHandling
{
public static void Main()
{
int[] sourceIntArray={1,2,3};
int[] destinationIntArray={5,6,7,8};
try
{
Array.Copy(sourceIntArray,
destinationIntArray,-1);
}
Working with Special System Types (Contd.)

20. catch (ArgumentOutOfRangeException e)
{
Console.WriteLine("Argument Out
Of Range Exception: {0}",e);
}
finally
{
Console.WriteLine("Finally block
is always executed.");
}
}
}
Working with Special System Types (Contd.)

21. Customize Code Behavior by Using Attributes
Attributes are an extended way to document code.
Attributes are of two types:
Predefined attributes: The following code snippet shows
declaration of System.ObsoleteAttribute:
public class ObsoleteAttributeExample
{
[Obsolete("This function is obsolete")]
public static int Subtract( int a, int b)
{
return (a-b);
}
public static void Main()
{
int result = Subtract(9,2);
}
}
Working with Special System Types (Contd.)

22. Custom attributes: The following code snippet defines a custom
attribute class MaxLengthAttribute:
[AttributeUsage(AttributeTargets.Field)]
class MaxLengthAttribute : Attribute
{ private int _max;
public MaxLengthAttribute(int max)
{ this._max = max;}
public bool IsValidLength(string value)
{
if (value == null)
return true;
else
if (this._max <= value.Length)
return true;
else
return false;
}
}
Working with Special System Types (Contd.)

23. What are Interfaces?
An interface looks like a class, but has no implementation. It
only contains definitions of events, indexers, methods, and
properties.
The classes and structures provide an implementation for each
member declared in the interface.
The following code example shows how you can define an
interface named Ishape:
interface IShape
{
int Area();
}
Working with Interfaces

24. Does an interface contain implementation?
Just a minute
Answer
An interface looks like a class, but it has no implementation. It
only contains definitions of events, indexers, methods, and
properties.

25. Compare Reference Types by Using Comparison Interfaces
The .NET Framework provides comparison interfaces for
comparing reference types.
The two most common types of comparison interfaces are:
IComparable: It defines a generalized comparison method that a
value type or class implements to create a type-specific
comparison method.
IEquatable: This interface applies only to generics. This
interface provides a generalized method to perform an equality
check between two instances of the same type.
Working with Interfaces (Contd.)
Comparison Interface
Reference
type 2
Reference
type 1

26. Convert a Reference Type by Using the IConvertible
Interface
IConvertible interface can be used to convert an object to
one of the CLR types.
IConvertible interface converts the value of an instance of
the implementing type to the equivalent data type under CTS.
The following code snippet shows its implementation of
IConvertible interface :
class Decision : IConvertible
{ bool _agree;
DateTime
IConvertible.ToDateTime(IFormatProvider
provider)
{throw new InvalidCastException("Cannot cast
to DateTime"); }
//... other IConvertible Methods
}
Working with Interfaces (Contd.)

27. Create a Copy of a Reference Type by Using the
ICloneable Interface
The ICloneable interface is used to create a new instance of
an object with the same value as an existing instance.
.Net Framework supports two types of cloning:
Shallow Cloning: Involves copying an object without copying any
references.
Deep Cloning: Involves making a copy of an object and any
references to other objects.
Working with Interfaces (Contd.)

28. Format System Data to a String by Using the
IFormattable Interface
The IFormattable interface can be used for formatting the
value of the current instance by using the specified format.
The interface defines the ToString method to implement the
same.
The System.Object class provides a default implementation
of the ToString method.
Working with Interfaces (Contd.)

29. Dispose Unmanaged Resources by Using the
IDisposable Interface
A special component of the .Net Framework called the garbage
collector manages the release of object memory on the heap
automatically.
The garbage collector periodically looks for unused objects on
the heap and deallocates their memory.
In the .NET Framework, unmanaged resources can be
released explicitly by implementing the IDisposable
interface.
Garbage
CollectorMemory
Garbage
Collection
Working with Interfaces (Contd.)

30. The following code example shows the implementation of
the IDisposable interface in a class named
CustomerDataAccess:
public class CustomerDataAccess : IDisposable
{
protected virtual void Dispose(bool
disposing)
{ if(disposing)
{
// call dispose on any objects referenced by this
object }
// release unmanaged resources
}
Working with Interfaces (Contd.)

31. public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
~CustomerDataAccess()
{
this.Dispose(false);
}
}
Working with Interfaces (Contd.)

32. What is garbage collection?
Just a minute
Answer
Garbage collection is a form of automatic memory management.
The garbage collector manages the allocation and release of
memory for your application.

33. In this session, you learned that:
Base system types represent a set of predefined data types.
Boxing and unboxing can be used for conversion between
value types and reference types.
Generic types are used to create a method, class, structure, or
an interface without specifying any fixed data type.
Nullable data type is used to assign null values for value
type variables.
Predefined exceptions that the CLR generates or a custom
exception class can be used to handle exceptions.
Attributes are used to customize code behavior at run time.
Interfaces are used to specify a set of properties that, on
implementation, perform a specific functionality.
The commonly used interfaces are IComparable,
IEquatable, IConvertible, ICloneable, and
IFormattable.
Summary