Primitive data types

All the supported datatypes by the compiler of a language are known as primitive data types.

Topics to study

1.What is mutable and immutable..??
2.What is delegate ??
3. Event
4.Diif b/w 1.1/2.0/3.5 Framework..??
5.Wpf,wcf,wwf..??
6.Linq..??
7.Oops concepts..??
8.Queries..??
9. In a single update query i need to update all 1000 to 2000 and all 2000 to 3000 and all 3000 to 4000
10.emp salary lo..second top salary kavali

Events

Events enable a class or object to notify other classes or objects when something of interest occurs. The class that sends (or raises) the event is called the publisher and the classes that receive (or handle) the event are called subscribers.

Boxing And Unboxing C#

Boxing and unboxing is a essential concept inC#�s type system. With Boxing and unboxing one can link betweenvalue-types and reference-types by allowing any value of a value-typeto be converted to and from type object. Boxing and unboxing enables aunified view of the type system wherein a value of any type canultimately be treated as an object.

Converting a value type to reference type is called Boxing.Unboxing is an explicit operation.

C# provides a �unified type system�. Alltypes�including value types�derive from the type object. It is possibleto call object methods on any value, even values of �primitive� typessuch as int.

The example

using System;
class Test
{
static void Main() {
Console.WriteLine(3.ToString());
}
}

calls the object-defined ToString method on an integer literal.

The example

class Test
{
static void Main() {
int i = 1;
object o = i; // boxing
int j = (int) o; // unboxing
}
}

An int value can be converted to object and back again to int.

This example shows both boxing and unboxing.When a variable of a value type needs to be converted to a referencetype, an object box is allocated to hold the value, and the value iscopied into the box.

Unboxing is just the opposite. When an objectbox is cast back to its original value type, the value is copied out ofthe box and into the appropriate storage location.

Boxing conversions

A boxing conversion permits any value-type tobe implicitly converted to the type object or to any interface-typeimplemented by the value-type.Boxing a value of a value-type consists of allocating an objectinstance and copying the value-type value into that instance.

For example any value-type G, the boxing class would be declared as follows:

class vBox
{
G value;
G_Box(G g) {
value = g;
}
}

Boxing of a value v of type G now consists ofexecuting the expression new G_Box(v), and returning the resultinginstance as a value of type object.

Thus, the statements
int i = 12;
object box = i;

conceptually correspond to
int i = 12;
object box = new int_Box(i);

Boxing classes like G_Box and int_Box abovedon�t actually exist and the dynamic type of a boxed value isn�tactually a class type. Instead, a boxed value of type G has the dynamictype G, and a dynamic type check using the is operator can simplyreference type G. For example,
int i = 12;
object box = i;
if (box is int) {
Console.Write("Box contains an int");
}

will output the string �Box contains an int� on the console.

A boxing conversion implies making a copy ofthe value being boxed. This is different from a conversion of areference-type to type object, in which the value continues toreference the same instance and simply is regarded as the less derivedtype object.

For example, given the declaration

struct Point
{
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}

the following statements
Point p = new Point(10, 10);
object box = p;
p.x = 20;
Console.Write(((Point)box).x);
will output the value 10 on the console because the implicit boxingoperation that occurs in the assignment of p to box causes the value ofp to be copied. Had Point instead been declared a class, the value 20would be output because p and box would reference the same instance.

Unboxing conversions

An unboxing conversion permits an explicitconversion from type object to any value-type or from anyinterface-type to any value-type that implements the interface-type. Anunboxing operation consists of first checking that the object instanceis a boxed value of the given value-type, and then copying the valueout of the instance. unboxing conversion of an object box to avalue-type G consists of executing the expression ((G_Box)box).value.

Thus, the statementsobject box = 12;
int i = (int)box;

conceptually correspond to
object box = new int_Box(12);
int i = ((int_Box)box).value;
For an unboxing conversion to a given value-type to succeed atrun-time, the value of the source argument must be a reference to anobject that was previously created by boxing a value of thatvalue-type. If the source argument is null or a reference to anincompatible object, an InvalidCastException is thrown.

CONCLUSION :

This type system unification provides value types with the benefits of object-ness without introducing unnecessary overhead.

For programs that don�t need int values to actlike objects, int values are simply 32-bit values. For programs thatneed int values to behave like objects, this capability is available ondemand. This ability to treat value types as objects bridges the gapbetween value types and reference types that exists in most languages.

Attributes and Reflection

Throughout this book, I have emphasized that a .NET application contains code, data, and metadata. Metadata is information about the data--that is, information about the types, code, assembly, and so forth--stored along with your program. This chapter explores how some of that metadata is created and used.

Attributes are a mechanism for adding metadata, such as compiler instructions and other data about your data, methods, and classes, to the program itself. Attributes are inserted into the metadata and are visible through ILDasm and other metadata-reading tools.

Reflection is the process by which a program can read its own metadata. A program is said to reflect on itself, extracting metadata from its assembly and using that metadata either to inform the user or to modify its own behavior