C# Programming Ketan Rajpal Page: 1 1st Unit The .NET Framework The .NET Framework is a new and revolutionary platform created by Microsoft for developing applications. It is a framework that runs primarily on Microsoft Windows Machine. It includes a large library and supports several programming languages. .NET framework is a programming infrastructure created by Microsoft for building, deploying, and running applications and services that use .NET technologies, such as desktop applications and Web services. The different versions of .NET are: 1.0, 1.1, 2.0, 3.0, 3.5 and 4.0. The features of .NET Framework Interoperability: Computer systems commonly require interaction between new and older applications, the .NET Framework provides means to access functionality that is implemented in programs that execute outside the .NET environment. Common Language Runtime Engine: The Common Language Runtime (CLR) is the execution engine of the .NET Framework. All .NET programs execute under the supervision of the CLR, guaranteeing certain properties and behaviors in the areas of memory management, security, and exception handling. Language Independence: The .NET Framework introduces a Common Type System, Because of this feature; the .NET Framework supports the exchange of types and object instances between libraries and applications written using any conforming .NET language. Base Class Library: The BCL provides classes which encapsulate a number of common functions, including file reading and writing, graphic rendering, database interaction, XML document manipulation and so on. Security: .NET provides a common security model for all applications. Portability: The design of the .NET Framework is cross-platform compatible. A cross-platform application may run on Microsoft Windows on the x86 architecture, Linux on the x86 architecture and Mac OS X on either the PowerPC or x86 based Apple Macintosh systems. A cross-platform application may run on as many as all existing platforms. Motivation behind the .NET platform Consistent Programming model and Multilanguage support: With .NET, for example, accessing data with a VB .NET and a C# .NET looks very similar apart from slight syntactical differences. Both the programs need to import the System.Data namespace, both the programs establish a connection with the database and both the programs run a query and display the data on a data grid. Direct Support for Security: With .NET, the Framework enables the developer and the system administrator to specify method level security. This makes distributed computing more secure because .NET developers cooperate with network security devices instead of working around their security limitations. Simplified Development Efforts: ASP.NET and the .NET Framework simplify development by separating the application logic and presentation logic making it easier to maintain the code. You write the design code (presentation logic) and the actual code (application logic) separately eliminating the need to mix HTML code with ASP code. Easy Application Deployment and Maintenance: The .NET Framework makes it easy to deploy applications. In the most common form, to install an application, all you need to do is copy the application along with the

C# Programming Ketan Rajpal Page: 2 components it requires into a directory on the target computer. The .NET Framework handles the details of locating and loading the components an application needs, even if several versions of the same application exist on the target computer. The .NET Framework ensures that all the components the application depends on are available on the computer before the application begins to execute Explain the architecture of .NET Framework. Common language Infrastructure (CLI): The specification defines an environment that allows multiple high-level languages to be used on different computer platforms without being rewritten for specific architectures. Common Language Infrastructure specifies:

A common language (the Common Language Specification - CLS) A common set of data types that any language must support (the Common Type System - CTS) An introduction to the component structure How the machine state is managed How exceptions are handled

The CLI specification describes the following four aspects:

Common Type System (CTS): The common type system defines how types are declared, used, and managed in the runtime, and is also an important part of the runtime's support for cross-language integration. The common type system performs the following functions:

Establishes a framework that helps enable cross-language integration, type safety, and high performance code execution.

Provides an object-oriented model that supports the complete implementation of many programming languages.

Defines rules that languages must follow, which helps ensure that objects written in different languages can interact with each other.

Metadata Common Language Specification (CLS): It is a set of basic language features that .Net Languages needed to

develop Applications and Services, which are compatible with the .Net Framework. It ensures complete interoperability among applications, regardless of the language used to create the application.

Virtual Execution System (VES): The VES loads and executes CLI-compatible programs, using the metadata to combine separately generated pieces of code at runtime.

Common language Runtime (CLR): It is the run time environment that provides the underlying infrastructure for Microsoft's .NET framework. This runtime is where the source code of an application is compiled into an intermediate language called CIL (Common Intermediate Language), originally known as MSIL (Microsoft Intermediate Language). When the program is then run, the CIL code is translated into the native code of the operating system using a just-in-time (JIT) compiler. Some of the advantages of CLR are Security, Portability, Flexibility, and Interoperability. Assembly: In the .NET framework, an assembly is a compiled code library used for deployment, versioning, and security. There are two types: process assemblies (EXE) and library assemblies (DLL). A process assembly represents a process that will use classes defined in library assemblies. .NET assemblies contain code in CIL, which is usually generated from a CLI language, and then compiled into machine language at run time by the CLR just-in-time compiler. An assembly can consist of one or more files. Code files are called modules. An assembly can contain more than one code module and since it is possible to use different languages to create code modules it is technically

C# Programming Ketan Rajpal Page: 3 possible to use several different languages to create an assembly. Visual Studio however does not support using different languages in one assembly. Scope of Assemblies: Assemblies can either contain a private or a public scope, based on the level of access required by the clients who access it. The manifest contains information regarding the scope of an assembly. Private Assembly: Assemblies are private in scope if only one application can access them. Private assemblies are only available to clients in the same directory structure as the assembly. Shared Assembly: When an assembly such as a system assembly contains features shared by various applications, standard deployment techniques discourage the use of private assemblies. As a result, you need to maintain a copy of the assembly for each client application. You can also register the assembly in the Global Assembly Cache (GAC), so that all client applications refer to one copy of the assembly. This type of assembly is called a shared assembly. Single File Assemblies: A single *.dll or *.exe file which contains the CIL code, type metadata, manifest and optional resources in one binary package. Single file assemblies are by far and away the most common .NET binary. Visual Studio can only create single file assemblies. Class Libraries, Windows Forms / WPF applications, Console applications and Windows Services are all examples of single file assemblies. Multi File Assemblies: A logical collection of files (termed modules) which are versioned and deployed as a single logical unit. Multi-file assemblies can be useful when we wish to allow remote clients to download chunks of an assembly on demand. The CLR will download requested modules to the local machine when requested. Physically, multi-file assemblies consist of one file which contains the assembly manifest and additional modules which contain CIL code and metadata descriptions for various types. Metadata: .NET metadata, in the Microsoft .NET framework, refers to certain data structures embedded within the Common Intermediate Language code that describes the high-level structure of the code. Metadata describes all classes and class members that are defined in the assembly, and the classes and class members that the current assembly will call from another assembly. The metadata for a method contains the complete description of the method, including the class (and the assembly that contains the class), the return type and all of the method parameters. A .NET language compiler will generate the metadata and store this in the assembly containing the CIL. When the CLR executes CIL it will check to make sure that the metadata of the called method is the same as the metadata that is stored in the calling method. This ensures that a method can only be called with exactly the right number of parameters and exactly the right parameter types. Namespaces: A namespace is a collection of different classes. All .NET applications are developed using classes from the .NET System namespace. The namespace with all the built-in functionality is the System namespace. All other namespaces are based on this System namespace. A namespace is just a grouping of related classes. It's a method of putting classes inside a container so that they can be clearly distinguished from other classes with the same name. Type Distinction: Namespace is a grouping of related types contained in an assembly. A single assembly can contain any number of namespaces. Platform Independent .NET: .NET is a collection of technologies. Some of these technologies are platform independent, some are not. Some of these technologies are standards, some are not. The .NET development tools create CIL. This is then compiled to native code on the target machine. It is possible to have the application compiled when it is installed. Often the CIL will be compiled "Just In Time", JIT, the first time during a session when it is required. .NET code will run on most of the common platforms you will encounter, including Mac, iPhone, Linux, etc.

C# Programming Ketan Rajpal Page: 4 Platforms like Windows will be able to run them exactly as if they were native applications. Platforms like iPhone require that they go through a further compilation stage to create the native application before they are installed. Mono .NET: Mono (a Spanish word for Monkey, as in 'code monkey') is an open source and commercially supported distribution of .NET sponsored by Novell Corporation. Mono is targeted to run on many popular flavors of Unix/Linux, Mac OS X, Solaris, and Windows. Portable .NET: Portable .NET is distributed under the GNU General Public License. As the name implies, Portable .NET intends to function on as many operating systems and architectures as possible, including many esoteric platforms such as BeOS, AIX, Xbox, and Sony PlayStation 2 (no, I'm not kidding about those last two). Managed Code: The role of the CLR doesnt end once you have compiled your code to MSIL, and a JIT compiler has compiled that to native code. Code written using the .NET Framework is managed when it is executed. This means that the CLR looks after your applications by managing memory, handling security, allowing cross-language debugging, and so on. By contrast, applications that do not run under the control of the CLR are said to be unmanaged, and certain languages such as C++ can be used to write such applications, which, for example, access low-level functions of the operating system. However, in C# you can write only code that runs in a managed environment. You will make use of the managed features of the CLR and allow .NET itself to handle any interaction with the operating system. Boxing: Converting value types to reference types is also known as boxing. As can be seen in the example below, it is not necessary to tell the compiler an Int32 is boxed to an object, because it takes care of this itself. Example of Implicit Boxing

Int32 x = 10; object o = x ; // Implicit boxing Console.WriteLine("The Object o = {0}",o); // prints out 10 Example of Explicit Boxing

Int32 x = 10; object o = (object) x; // Explicit boxing Console.WriteLine("The object o = {0}",o); // prints out 10 Un-Boxing: The following example intends to show how to unbox a reference type back to a value type. First an Int32 is boxed to an object, and then it is unboxed again. Note that unboxing requires explicit cast. Example of Un-Boxing

Int32 x = 5; object o1 = x; // Implicit Boxing x = (int)o1; // Explicit Unboxing

C# Programming Ketan Rajpal Page: 5 2nd Unit C# pronounced See Sharp is a multi-paradigm programming language encompassing imperative, declarative, functional, generic, object-oriented and component-oriented programming disciplines. C# is intended to be a simple, modern, general-purpose, object-oriented programming language. As C# is a development language of .NET framework, its evolution is closely related with that .NET framework runtime and Visual Studio development environment. C# is intended to be a simple, modern, general-purpose, object-oriented programming language. C# Design Goals: The ECMA standard lists these design goals for C#

C# language is intended to be a simple, modern, general-purpose, object-oriented programming language. The language, and implementations thereof, should provide support for software engineering principles such

as strong type checking, array bounds checking, detection of attempts to use uninitialized variables, and automatic garbage collection. Software robustness, durability, and programmer productivity are important.

The language is intended for use in developing software components suitable for deployment in distributed environments.

Source code portability is very important, as is programmer portability, especially for those programmers already familiar with C and C++.

Support for internationalization is very important. C# is intended to be suitable for writing applications for both hosted and embedded systems, ranging from

the very large that use sophisticated operating systems, down to the very small having dedicated functions. Although C# applications are intended to be economical with regard to memory and processing

power requirements, the language was not intended to compete directly on performance and size with C, C++ or assembly language.

My First C# Program

namespace FirstProgram { using System; class Example { static void Main ( ) { Console.WriteLine ("Hello world!"); } } } Reference and Value Types: C# has a unified type system. This unified type system is called Common Type System. CTS separate data types into two categories: Value Types: A value type contains the actual value. When a value type is assigned to another value type, it is copied. In simple words, all value based types are allocated on the stack. By saying stack, we mean things are kept one on top of the other. We keep track of each value at the top. Example of Value Type

using System; class Test { static void Main ( ) { int x = 3; int y = x; // assign x to y, y is now a copy of x x++; // increment x to 4 Console.WriteLine (y); // prints 3 }}

C# Programming Ketan Rajpal Page: 6 Reference Types: A reference type contains a reference to the value. When a reference type is assigned to another reference type, a reference is assigned to the value. All reference based types are allocated on the heap. By saying heap, we mean things are kept in a mashed order. We keep track of each value by its address that is referenced by a pointer to it. Example of Reference Type

using System.Text; class Test { static void Main ( ) { StringBuilder x = new StringBuilder ("hello"); StringBuilder y = x; x.Append (" there"); Console.WriteLine (y); // prints "hello there" } } All value types are implicitly derived from System.ValueType. This class actually overrides the implementation in System.Object, the base class for all objects which is a Reference Type itself. Data types like integers, floating point numbers, character data, Boolean values, Enumerations and Structures are examples of Value Types. Classes, Strings, Arrays are examples of Reference Types. A Value Type may not contain NULL values. Reference Types may contain NULL values. It is not possible to derive new types from Value Types. This is possible in Reference types. However, Value Types like Structures can implement interfaces. Value types

Integer, signed (sbyte, short, int, long) Integer, unsigned (byte, ushort, uint, ulong) Floating-point (float, decimal, double)

Reference types

Object String

Primitive types: Any data types directly supported by the compiler are called primitive types. A primitive Type is not the same then a Value Type. A basic type is a data type provided by a programming language as a basic building block. Most languages allow more complicated composite types to be recursively constructed starting from basic types. A built-in type is a data type for which the programming language provides built-in support. Null able Types: The term null is an interesting programming concept in that it does not mean the same as zero or blank; rather, it often implies missing or otherwise undefined data and because of this, is frequently used as a flag in this scenario. Null ability refers to the ability of a data type to accept and appropriately handle NULL values. Example of Null able Types

class NullableExample { static void Main() { int? num = null; if (num.HasValue == true) { System.Console.WriteLine("num = " + num.Value); }

C# Programming Ketan Rajpal Page: 7 else { System.Console.WriteLine("num = Null"); } // y is set to zero int y = num.GetValueOrDefault(); // num.Value throws an InvalidOperationException if num.HasValue is false try { y = num.Value; } catch (System.InvalidOperationException e) { System.Console.WriteLine(e.Message); } } } The example will display the output: num = Null Enumerable Types: An enumeration type (also named an enumeration or an enum) provides an efficient way to define a set of named integral constants that may be assigned to a variable. enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday }; enum Months : byte { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec }; For example, assume that you have to define a variable whose value will represent a day of the week. There are only seven meaningful values which that variable will ever store. To define those values, you can use an enumeration type, which is declared by using the enum keyword. Arrays: Arrays allow a group of elements of a particular type to be stored in a contiguous block of memory. An array is specified by placing square brackets after the element type. Single Dimensional Array: Example of Single Dimensional Array

char[ ] vowels = new char[ ] {'a','e','i','o','u'}; Console.WriteLine(vowels [1]); // Prints "e" Multi Dimensional Array: Multidimensional arrays come in two varieties: rectangular and jagged. Rectangular arrays represent an n-dimensional block, while jagged arrays are arrays of arrays. Example of Multi Dimensional array

// rectangular int [,,] matrixR = new int [3, 4, 5]; // creates 1 big cube // jagged int [ ][ ][ ] matrixJ = new int [3][ ][ ]; for (int i = 0; i < 3; i++) { matrixJ[i] = new int [4][ ]; for (int j = 0; j < 4; j++) matrixJ[i][j] = new int [5];

C# Programming Ketan Rajpal Page: 8 } // assign an element matrixR [1,1,1] = matrixJ [1][1][1] = 7; Classes: A class is a construct that enables you to create your own custom types by grouping together variables of other types, methods and events. A class is like a blueprint. It defines the data and behavior of a type. A class usually represents a noun, such as a person, place or thing. For example, "Banana" is an instance of the class "Fruit" (a "Fruit" object). It is of the type "Fruit". In object-oriented terms, we say that your bicycle is an instance of the class of objects known as bicycles. A class is the blueprint from which individual objects are created. A class can have subclasses that can inherit all or some of the characteristics of the class. In relation to each subclass, the class becomes the super class. Subclasses can also define their own methods and variables that are not part of their super class. The structure of a class and its subclasses is called the class hierarchy. Objects: An object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure. An object is an instance of a class. Example of Classes and Objects

public class Person { public string Name { get; set; } public int Age { get; set; } public Person(string name, int age) { Name = name; Age = age; } } class Program { static void Main() { Person person1 = new Person("Leopold", 6); Console.WriteLine("person1 Name = {0} Age = {1}", person1.Name, person1.Age); Person person2 = person1; person2.Name = "Molly"; person2.Age = 16; Console.WriteLine("person2 Name = {0} Age = {1}", person2.Name, person2.Age); Console.WriteLine("person1 Name = {0} Age = {1}", person1.Name, person1.Age); Console.WriteLine("Press any key to exit."); Console.ReadKey(); } } The example will display the output: person1 Name = Leopold Age = 6 person2 Name = Molly Age = 16 person1 Name = Molly Age = 16 The This Keyword: The this keyword denotes a variable that is a reference to a class or struct instance and is only accessible from within no static function members of the class or struct. The this keyword is also used by a constructor to call an overloaded constructor or declare or access indexers. A common use of the this variable is to distinguish a field name from a parameter name.

C# Programming Ketan Rajpal Page: 9 Example of This Keyword

class Dude { string name; public Dude (string name) { this.name = name; } public void Introduce(Dude a) { if (a!=this) Console.WriteLine("Hello, I'm "+name); } } Static Classes and Static Class Members: Static classes and class members are used to create data and functions that can be accessed without creating an instance of the class. Static class members can be used to separate data and behavior that is independent of any object identity: the data and functions do not change regardless of what happens to the object. Static classes can be used when there is no data or behavior in the class that depends on object identity. A class can be declared static, indicating that it contains only static members. It is not possible to create instances of a static class using the new keyword. Static classes are loaded automatically by the .NET Framework common language runtime (CLR) when the program or namespace containing the class is loaded. The main features of a static class are:

They only contain static members. They cannot be instantiated. They are sealed. They cannot contain Instance Constructors (C# Programming Guide).

Example of Static Classes and Static Class Members

public static class TemperatureConverter { public static double CelsiusToFahrenheit(string temperatureCelsius) { double celsius = System.Double.Parse(temperatureCelsius); double fahrenheit = (celsius * 9 / 5) + 32; return fahrenheit; } public static double FahrenheitToCelsius(string temperatureFahrenheit) { double fahrenheit = System.Double.Parse(temperatureFahrenheit); double celsius = (fahrenheit - 32) * 5 / 9; return celsius; } } class TestTemperatureConverter { static void Main() { System.Console.WriteLine("Please select the convertor direction"); System.Console.WriteLine("1. From Celsius to Fahrenheit."); System.Console.WriteLine("2. From Fahrenheit to Celsius."); System.Console.Write(":"); string selection = System.Console.ReadLine(); double F, C = 0;

C# Programming Ketan Rajpal Page: 10 switch (selection) { case "1": System.Console.Write("Please enter the Celsius temperature: "); F = TemperatureConverter.CelsiusToFahrenheit(System.Console.ReadLine()); System.Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F); break; case "2": System.Console.Write("Please enter the Fahrenheit temperature: "); C = TemperatureConverter.FahrenheitToCelsius(System.Console.ReadLine()); System.Console.WriteLine("Temperature in Celsius: {0:F2}", C); break; default: System.Console.WriteLine("Please select a convertor."); break; } } } The example will display the output: Please select the convertor 1. From Celsius to Fahrenheit. 2. From Fahrenheit to Celsius. :2 Please enter the Fahrenheit temperature: 98.6 Temperature in Celsius: 37.00 Additional sample output might look as follows: Please select the convertor 1. From Celsius to Fahrenheit. 2. From Fahrenheit to Celsius. :1 Please enter the Celsius temperature: 37.00 Temperature in Fahrenheit: 98.60 Garbage Collector: In C and C++, many objects require the programmer to allocate their resources once declared, before the objects can be safely used. Releasing these resources back to the free memory pool once the object has been used is also the responsibility of the programmer. If resources are not released, the code is said to leak memory, as more and more resources are consumed needlessly. On the other hand, if resources are released prematurely, loss of data, the corruption of other memory areas, and null pointer exceptions can occur. C# prevent these dangers by independently managing the lifetime of all objects in use by an application. In C#, garbage collection is handled by the common language runtime (CLR) with similar functionality to that of the JVM. The CLR garbage collector periodically checks the memory heap for any unreferenced objects, and releases the resources held by these objects. In C# we have Automatic Memory Management. Method Overloading: Method overloading allows the programmer to define many methods with the same name but with a different set of parameters. Each combination of parameter types is known as a signature of the method. When a call is made to one of these overloaded methods, the compiler automatically determines which of the methods should be used according to the arguments used in the call and the available method signatures.

C# Programming Ketan Rajpal Page: 11 Constructors: Whenever a class or struct is created, its constructor is called. A class or struct may have multiple constructors that take different arguments. Constructors enable the programmer to set default values, limit instantiation, and write code that is flexible and easy to read. Constructors are class methods that are executed when an object of a given type is created. Constructors have the same name as the class, and usually initialize the data members of the new object. A constructor that takes no parameters is called a default constructor. Default constructors are invoked whenever an object is instantiated by using the new operator and no arguments are provided to new. Unless the class is static, classes without constructors are given a public default constructor by the C# compiler in order to enable class instantiation. Both classes and structs can define constructors that take parameters. (Parameterized Constructors) Constructors that take parameters must be called through a new statement or a base statement. Classes and structs can also define multiple constructors, and neither is required to define a default constructor. Constructors can be marked as public, private, protected, internal, or protected internal. These access modifiers define how users of the class can construct the class. A constructor can be declared static by using the static keyword. Static constructors are called automatically, immediately before any static fields are accessed, and are generally used to initialize static class members. C# does not provide a copy constructor. If you create a new object and want to copy the values from an existing object, you have to write the appropriate method yourself. Instance constructors are used to create and initialize any instance member variables when you use the new expression to create an object of a class. To initialize a static class, or static variables in a non-static class, you must define a static constructor. Example of Instance Constructors

class CoOrds { public int x, y; public CoOrds() { x = 0; y = 0; } public CoOrds(int x, int y) { this.x = x; this.y = y; } public override string ToString() { return (String.Format("({0},{1})", x, y)); } } class MainClass { static void Main() { CoOrds p1 = new CoOrds(); CoOrds p2 = new CoOrds(5, 3);

C# Programming Ketan Rajpal Page: 12 Console.WriteLine("CoOrds #1 at {0}", p1); Console.WriteLine("CoOrds #2 at {0}", p2); Console.ReadKey(); } } The example will display the output: CoOrds #1 at (0,0) CoOrds #2 at (5,3) Encapsulating Data: Encapsulation is the procedure of covering up of data and functions into a single unit (called class). An encapsulated object is often called an abstract data type. The need of encapsulation is to protect or prevent the code (data) from accidental corruption due to the silly little errors that we are all prone to make. Properties are named members of classes, structs, and interfaces. They provide a flexible mechanism to read, write, or compute the values of private fields through accessors. Properties are a new language feature introduced with C#. Only a few languages support this property. Properties in C# helps in protect a field in a class by reading and writing to it. The first method itself is good but Encapsulation can be accomplished much smoother with properties. The accessor of a property contains the executable statements associated with getting (reading or computing) or setting (writing) the property. The accessor declarations can contain a get accessor, a set accessor, or both. The declarations take the following forms: set {accessor-body}, get {accessor-body}. accessor-body: The block that contains the statements to be executed when the accessor is invoked. Example of Encapsulating Data (Property)

using system; public class Department { private string departname; public string Departname { get { return departname; } set { departname=value; } } } public class Departmentmain { public static int Main(string[] args) { Department d= new Department(); d.departname="Communication"; Console.WriteLine("The Department is :{0}",d.Departname); return 0; } } Access Modifiers: All types and type members have an accessibility level, which controls whether they can be used from other code in your assembly or other assemblies. You can use the following access modifiers to specify the accessibility of a type or member when you declare it:

C# Programming Ketan Rajpal Page: 13

Public: The type or member can be accessed by any other code in the same assembly or another assembly that references it.

Private: The type or member can be accessed only by code in the same class or struct. Protected: The type or member can be accessed only by code in the same class or struct, or in a class that is

derived from that class. Internal: The type or member can be accessed by any code in the same assembly, but not from another

assembly. Protected Internal: The type or member can be accessed by any code in the assembly in which it is declared,

or from within a derived class in another assembly. Access from another assembly must take place within a class declaration that derives from the class in which the protected internal element is declared, and it must take place through an instance of the derived class type.

Syntax of Access Modifiers

public class Tricycle { // protected method: protected void Pedal() { } // private field: private int wheels = 3; // protected internal property: protected internal int Wheels { get { return wheels; } } } Indexers Arrays: Indexers permit instances of a class or struct to be indexed in the same way as arrays. Indexers are similar to properties except that their accessors take parameters. Example of Indexers Arrays

using System; class IndexerClass { private int [] myArray = new int[100]; public int this [int index] // Indexer declaration { get { // Check the index limits. if (index < 0 || index >= 100) return 0; else return myArray[index]; } set { if (!(index < 0 || index >= 100)) myArray[index] = value; } } }

C# Programming Ketan Rajpal Page: 14 public class MainClass { public static void Main() { IndexerClass b = new IndexerClass(); // Call the indexer to initialize the elements #3 and #5. b[3] = 256; b[5] = 1024; for (int i=0; i

C# Programming Ketan Rajpal Page: 15 Structures (Struct): A struct is similar to a class. Both classes and structs can implement interfaces. Structure and Class (Difference)

Structure Class

A struct is a value type A class is a reference type

A struct can inherit only from an object and is implicitly sealed

A class fully supports inheritance.

A structure cannot have a destructor A class can have a destructor

The default parameter less constructor for a struct initializes each field with a default value. If a struct declares a constructor, then all of its fields must be assigned in that constructor call.

A class can define a custom parameter less constructor and initialize instance fields.

Interfaces: An interface is similar to a class, but with the following major differences

An interface provides a specification rather than an implementation for its members. This is similar to a pure abstract class, which is an abstract class consisting of only abstract members.

A class and struct can implement multiple interfaces, while a class can inherit only from a single class. A struct can implement an interface, but a struct cannot inherit from a class.

An interface is comprised of Method, Property, Indexer, and Event. Example of Interface

using System; interface IPoint { int x { get; set; } int y { get; set; } } class Point : IPoint { private int _x; private int _y; public Point(int x, int y) { _x = x; _y = y; } public int x { get {

C# Programming Ketan Rajpal Page: 16 return _x; } set { _x = value; } } public int y { get { return _y; } set { _y = value; } } } class MainClass { static void PrintPoint(IPoint p) { Console.WriteLine("x={0}, y={1}", p.x, p.y); } static void Main() { Point p = new Point(2, 3); Console.Write("My Point: "); PrintPoint(p); } } The example will display the output: My Point: x=2, y=3 Nested Classes: A nested type is declared within the scope of another type. A nested type can access all the members of its enclosing type, regardless of a member's access modifier. A nested type can be hidden from other types with type-member access modifiers. Accessing a nested type from outside of its enclosing type requires specifying the type name. This is the same principle used for static members. Example of Nested Classes

using System; public class Container { public class Nested { private Container parent; public Nested() { }

C# Programming Ketan Rajpal Page: 17 public Nested(Container parent) { this.parent = parent; } } } Container.Nested nest = new Container.Nested(); Abstract and Sealed Class: The abstract keyword enables you to create classes and class members that are incomplete and must be implemented in a derived class. The sealed keyword enables you to prevent the inheritance of a class or certain class members that were previously marked virtual. An abstract class cannot be instantiated. The purpose of an abstract class is to provide a common definition of a base class that multiple derived classes can share. Abstract classes may also define abstract methods. This is accomplished by adding the keyword abstract before the return type of the method. Example of Abstract Class

public class D { public virtual void DoWork(int i) { // Original implementation. } } public abstract class E : D { public abstract override void DoWork(int i); } public class F : E { public override void DoWork(int i) { // New implementation. } } Example of Sealed Class

public class D : C { public sealed override void DoWork() { } } String Class: The string type represents a sequence of zero or more Unicode characters. String is an alias for String in the .NET Framework. Strings have comparison, appending, inserting, and conversion, copying, formatting, indexing, joining, splitting, padding, trimming, removing, replacing, and searching methods.

Comparing Strings: The = = operator is overloaded, so you can easily compare two strings by value. string a = "abracadabra"; string b = "abracadabra"; Console.WriteLine(a= =b); // Prints "True"

Immutability of Strings: Strings are immutable, which means they can't be modified after creation. Consequently, many of the methods that initially appear to modify a string actually create a new string.

string a = "Heat";

C# Programming Ketan Rajpal Page: 18 string b = a.Insert(3, "r") Console.WriteLine(b); // Prints Heart

Formatting Strings: The Format( ) method provides a convenient way to build strings that make use of embedded parameters. Parameters in such strings can be of any type, including both predefined and user-defined types.

using System; class TestFormatting { static void Main( ) { int i = 2; decimal m = 42.73m; string s = String.Format("Account {0} has {1:C}.", i, m); Console.WriteLine(s); // Prints "Account 2 has $42.73" } } String Builder Class: Represents a mutable string of characters. This class cannot be inherited.

Capacity: Gets or sets the maximum number of characters that can be contained in the memory allocated by the current instance.

Chars: Gets or sets the character at the specified character position in this instance. Length: Gets or sets the length of this instance. MaxCapacity: Gets the maximum capacity of this instance. Append: Overloaded. Appends the string representation of a specified object to the end of this instance. AppendFormat: Overloaded. Appends a formatted string, which contains zero or more format specifications,

to this instance. Each format specification is replaced by the string representation of a corresponding object argument.

EnsureCapacity: Ensures that the capacity of this instance of StringBuilder is at least the specified value. Equals: Overloaded. Returns a value indicating whether this instance is equal to a specified object. GetType: Gets the Type of the current instance. Insert: Overloaded. Inserts the string representation of a specified object into this instance at a specified

character position. Remove: Removes the specified range of characters from this instance. Replace: Overloaded. Replaces all occurrences of a specified character or string in this instance with another

specified character or string. ToString: Overloaded. Overridden. Converts a StringBuilder to a String.

Handling Errors: An exceptional condition is an error situation that occurs during the normal flow of program and prevents the program from continuing correctly. C# provides exception handling mechanism for handling errors and conditions such as division of numbers by Zero (0) is difficult to predict however, that can be handled by using exceptions. The C# language's exception handling features help you deal with any unexpected or exceptional situations that occur when a program is running. A try block is used by C# programmers to partition code that might be affected by an exception. Associated catch blocks are used to handle any resulting exceptions. A finally block contains code that is run regardless of whether or not an exception is thrown in the try block, such as releasing resources that are allocated in the try block. A try block requires one or more associated catch blocks, or a finally block, or both. Syntax of Exception Handling

try { // Code to try goes here. }

C# Programming Ketan Rajpal Page: 19 catch (SomeSpecificException ex) { // Code to handle the exception goes here. // Only catch exceptions that you know how to handle. // Never catch base class System.Exception without // rethrowing it at the end of the catch block. } finally { // Code to execute after the try (and possibly catch) blocks // goes here. } Example of Exception Handling

class ExceptionTest { static double SafeDivision(double x, double y) { if (y == 0) throw new System.DivideByZeroException(); return x / y; } static void Main() { // Input for test purposes. Change the values to see // exception handling behavior. double a = 98, b = 0; double result = 0; try { result = SafeDivision(a, b); Console.WriteLine("{0} divided by {1} = {2}", a, b, result); } catch (DivideByZeroException e) { Console.WriteLine("Attempted divide by zero."); } } } Compiler Generated Exceptions: Some exceptions are thrown automatically by the .NET Framework's common language runtime (CLR) when basic operations fail.

ArithmeticException: A base class for exceptions that occur during arithmetic operations, such as DivideByZeroException and OverflowException.

ArrayTypeMismatchException: Thrown when an array cannot store a given element because the actual type of the element is incompatible with the actual type of the array.

DivideByZeroException: Thrown when an attempt is made to divide an integral value by zero. IndexOutOfRangeException: Thrown when an attempt is made to index an array when the index is less than

zero or outside the bounds of the array. InvalidCastException: Thrown when an explicit conversion from a base type to an interface or to a derived

type fails at runtime. NullReferenceException: Thrown when you attempt to reference an object whose value is null. OutOfMemoryException: Thrown when an attempt to allocate memory using the new operator fails. This

indicates that the memory available to the common language runtime has been exhausted.

C# Programming Ketan Rajpal Page: 20

OverflowException: Thrown when an arithmetic operation in a checked context overflows. StackOverflowException: Thrown when the execution stack is exhausted by having too many pending

method calls; usually indicates a very deep or infinite recursion. TypeInitializationException: Thrown when a static constructor throws an exception and no compatible catch

clause exists to catch it. The root of all Classes- Object: All C# classes, of any type, ultimately derive from a single class: Object. Object is the base class for all other classes. A base class is the immediate parent of a derived class. A derived class can be the base to further derived classes, creating an inheritance tree or hierarchy. A root class is the topmost class in an inheritance hierarchy. In C#, the root class is Object.

Equals: Evaluates whether two objects are equivalent GetHashCode: Allows objects to provide their own hash function for use in collections GetType: Provides access to the Type object ToString: Provides a string representation of the object Finalize: Cleans up non memory resources; implemented by a destructor.

Specialization and Generalization: One of the most important relationships among objects in the real world is specialization, which can be described as the is-a relationship. Generalization is the process of extracting shared characteristics from two or more classes, and combining them into a generalized superclass. Shared characteristics can be attributes, associations, or methods. Inheritance: Mechanism of deriving a new class from an old is known as inheritance. The old class refers to as base class and new one is called the derived or sub class. A class can inherit from another class to extend or customize the original class. Inheriting from a class allows you to reuse the functionality in that class instead of building it from scratch. Syntax to inherit from a class Public class derivedclass:baseclass Program of Inheritance and Polymorphism

public class Shape { public int X { get; private set; } public int Y { get; private set; } public int Height { get; set; } public int Width { get; set; } public virtual void Draw() { Console.WriteLine("Performing base class drawing tasks"); } } class Circle : Shape { public override void Draw() { Console.WriteLine("Drawing a circle"); base.Draw(); } } class Rectangle : Shape

C# Programming Ketan Rajpal Page: 21 { public override void Draw() { Console.WriteLine("Drawing a rectangle"); base.Draw(); } } class Triangle : Shape { public override void Draw() { Console.WriteLine("Drawing a triangle"); base.Draw(); } } class Program { static void Main(string[] args) { System.Collections.Generic.List shapes = new System.Collections.Generic.List(); shapes.Add(new Rectangle()); shapes.Add(new Triangle()); shapes.Add(new Circle()); foreach (Shape s in shapes) { s.Draw(); } Console.WriteLine("Press any key to exit."); Console.ReadKey(); } } The example will display the output: Drawing a rectangle Performing base class drawing tasks Drawing a triangle Performing base class drawing tasks Drawing a circle Performing base class drawing tasks The DateTime class: The System.DateTime class of the .NET Framework allows you to use, store, and manipulate data of time and date. It has methods for manipulating date such as adding or subtracting days, months, or years to the current date and then returning the resulting date. It has some methods to show your date in various formats. Program of DateTime Class public class Program { public static void Main() { DateTime newyear = new DateTime(2010, 12, 25); Console.WriteLine(newyear.ToString()); } }

C# Programming Ketan Rajpal Page: 22 The example will display the output: 12/25/2010 12:00:00 AM We used the constructor which accepts the year, the month, and the date to initialize our DateTime object. We used the ToString () method of the DateTime class to display the date and time. The default ToString() method displays your DateTime object in this format: MM/DD/YYYY HH:MM:SS AM/PM. Constructors present in DateTime Class

DateTime() DateTime(int year, int month, int day) DateTime(int year, int month, int day, int hour, int minute, int second) DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond)

Using the default parameterless constructor initializes the date to 01/01/0001 12:00:00 AM. To obtain the current date and time, you can use the Now static property of the DateTime class. Predefined Methods DateTime now = DateTime.Now; DateTime today = DateTime.Today; Program of DateTime Class public class Program { public static void Main() { DateTime myDate = DateTime.Now; Console.WriteLine("Year: " + myDate.Year); Console.WriteLine("Month: " + myDate.Month); Console.WriteLine("Day: " + myDate.Day); Console.WriteLine("Today is {0}.", myDate.DayOfWeek.ToString()); //Assign newDate with the current date added by 3 days DateTime newDate = myDate.AddDays(3); Console.WriteLine("The date 3 days from now is {0}.", newDate.ToShortDateString()); //Assign newdate with the current date subtracted by 3 days newDate = myDate.AddDays(-3); Console.WriteLine("The date 3 days ago is {0}.", newDate.ToShortDateString()); } } The example will display the output: Year: 2010 Month: 10 Day: 3 Today is Sunday. The date 3 days from now is 10/6/2010. The date 3 days ago is 9/30/2010.

C# Programming Ketan Rajpal Page: 23 3rd Unit Delegate and event: An event is a message sent by an object to signal the occurrence of an action. The object that raises (triggers) the event is called the event sender. The object that captures the event and responds to it is called the event receiver. In event communication, the event sender class does not know which object or method will receive (handle) the events it raises. What is needed is an intermediary (or pointer-like mechanism) between the source and the receiver. The .NET Framework defines a special type (Delegate) that provides the functionality of a function pointer. A delegate is a class that can hold a reference to a method. Unlike other classes, a delegate class has a signature, and it can hold references only to methods that match its signature. A delegate is thus equivalent to a type-safe function pointer or a callback. While delegates have other uses, the discussion here focuses on the event handling functionality of delegates. The following example shows an event delegate declaration. public delegate void AlarmEventHandler(object sender, AlarmEventArgs e); The syntax is similar to that of a method declaration; however, the delegate keyword informs the compiler that AlarmEventHandler is a delegate type. Anonymous Delegates: Anonymous Method declarations consist of the keyword delegate, an optional parameter list and a statement list enclosed in parenthesis. btnSave.Click += delegate { SaveChanges(); lblStatus.Text = "Your changes have been saved"; }; Event Handler using Anonymous Methods, with a parameter list btnSave.Click += delegate(object sender, EventArgs e) {

MessageBox.Show(((Button)sender).Text); SaveChanges(); MessageBox.Show("Your changes have been saved");

} Anonymous methods can be specified with parameters enclosed in parenthesis, or without parameters, with empty parenthesis. When parameters are specified, the signature of the anonymous method must match the signature of the delegate. When the delegate has no parameters, empty parenthesis are specified in the anonymous method declaration. When an anonymous method is declared without parenthesis, it can be assigned to a delegate with any signature. Note that method attributes cannot be applied to Anonymous methods. Also, anonymous methods can be added to the invocation list for delegates but can be deleted from the invocation list only if they have been saved to delegates. An advantage offered with the use of anonymous methods is that they allow access to the local state of the containing function member. FUNC: The Func type is a parameterized type and you must specify the number and kinds of parameters, and also the type of the return value. The Func type provides a way to store anonymous methods in a generalized and simple way. Example of FUNC class Program { static void Main() {

Func func1 = (x) => string.Format("string = {0}", x); Func func2 = (b, x) =>string.Format("string = {0} and {1}", b,

x); Func func3 = () => Math.PI / 2; Console.WriteLine(func1.Invoke(5)); Console.WriteLine(func2.Invoke(true, 10));

C# Programming Ketan Rajpal Page: 24

Console.WriteLine(func3.Invoke()); } } The example will display the output: string = 5 string = True and 10 1.5707963267949 Action Delegates: Encapsulates a method that has no parameters and does not return a value. Syntax: public delegate void Action() Example of Action Delegates using System; using System.Windows.Forms; public class Name { private string instanceName; public Name(string name) { this.instanceName = name; } public void DisplayToConsole() { Console.WriteLine(this.instanceName); } public void DisplayToWindow() { MessageBox.Show(this.instanceName); } } public class LambdaExpression { public static void Main() { Name testName = new Name("Koani"); Action showMethod = () => testName.DisplayToWindow(); showMethod(); } } Action Delegates: Encapsulates a method that has a single parameter and does not return a value. Syntax: public delegate void Action(T obj) Example of Action Delegates using System; using System.Collections.Generic; class Program { static void Main() { List names = new List(); names.Add("Bruce"); names.Add("Alfred"); names.Add("Tim"); names.Add("Richard"); names.ForEach(Print); names.ForEach(delegate(String name) { Console.WriteLine(name);

C# Programming Ketan Rajpal Page: 25 }); } private static void Print(string s) { Console.WriteLine(s); } } The example will display the output: Bruce Alfred Tim Richard Bruce Alfred Tim Richard Generics: Generics allow you to define type-safe classes without compromising type safety, performance, or productivity. You implement the server only once as a generic server, while at the same time you can declare and use it with any type. To do that, use the < and > brackets, enclosing a generic type parameter. Example of Generics public class Stack { T[] m_Items; public void Push(T item) {...} public T Pop() {...} } Stack stack = new Stack(); stack.Push(1); stack.Push(2); int number = stack.Pop(); Explicit Interfaces Implementation: If a class implements two interfaces that contain a member with the same signature, then implementing that member on the class will cause both interfaces to use that member as their implementation. If the two interface members do not perform the same function, however, this can lead to an incorrect implementation of one or both of the interfaces. It is possible to implement an interface member explicitlycreating a class member that is only called through the interface, and is specific to that interface. This is accomplished by naming the class member with the name of the interface and a period. Example of Explicit Interfaces Implementation interface IControl { void Paint(); } interface ISurface { void Paint(); } public class SampleClass : IControl, ISurface { void IControl.Paint() { System.Console.WriteLine("IControl.Paint"); } void ISurface.Paint() { System.Console.WriteLine("ISurface.Paint"); }

C# Programming Ketan Rajpal Page: 26 } SampleClass obj = new SampleClass(); //obj.Paint(); // Compiler error. IControl c = (IControl)obj; c.Paint(); // Calls IControl.Paint on SampleClass. ISurface s = (ISurface)obj; s.Paint(); // Calls ISurface.Paint on SampleClass. Collection Class: The .NET Framework provides specialized classes for data storage and retrieval. These classes provide support for stacks, queues, lists, and hash tables. Most collection classes implement the same interfaces, and these interfaces may be inherited to create new collection classes that fit more specialized data storage needs. Collection Classes have the following properties

Collection classes are defined as part of the System.Collections or System.Collections.Generic namespace. Most collection classes derive from the interfaces ICollection, IComparer, IEnumerable, IList, IDictionary,

and IDictionaryEnumerator and their generic equivalents. Using generic collection classes provides increased type-safety and in some cases can provide better

performance, especially when storing value types. The following generic types correspond to existing collection types:

List is the generic class corresponding to ArrayList. Dictionary is the generic class corresponding to Hashtable. Collection is the generic class corresponding to CollectionBase. Collection can be used as a base class, but

unlike CollectionBase it is not abstract, making it much easier to use. ReadOnlyCollection is the generic class corresponding to ReadOnlyCollectionBase. ReadOnlyCollection is not

abstract, and has a constructor that makes it easy to expose an existing List as a read-only collection. The Queue, Stack, and SortedList generic classes correspond to the respective non-generic classes with the

same names. Windows Presentation Foundation (WPF): The Windows Presentation Foundation is Microsofts next generation UI framework to create applications with a rich user experience. It is part of the .NET framework 3.0 and higher. WPF combines application UIs, 2D graphics, 3D graphics, documents and multimedia into one single framework. Its vector based rendering engine uses hardware acceleration of modern graphic cards. This makes the UI faster, scalable and resolution independent. WPF separates the appearance of a user interface from its behavior: The appearance is generally specified in the Extensible Application Markup Language (XAML), the behavior is implemented in a managed programming language like C# or Visual Basic. The two parts are tied together by data binding, events and commands. The separation of appearance and behavior brings the following benefits:

Appearance and behavior are loosely coupled Designers and developers can work on separate models. Graphical design tools can work on simple XML documents instead of parsing code.

Rich composition: Controls in WPF are extremely compos able. You can define almost any type of controls as content of another. Although these flexibility sounds horrible to designers, its a very powerful feature if you use it appropriate. Put an image into a button to create an image button, or put a list of videos into a combo box to choose a video file. Highly customizable: Because of the strict separation of appearance and behavior you can easily change the look of a control. The concept of styles let you skin controls almost like CSS in HTML. Templates let you replace the entire appearance of a control. Resolution independence: All measures in WPF are logical units - not pixels. A logical unit is a 1/96 of an inch. If you increase the resolution of your screen, the user interface stays the same size - it just gets crispier. Since WPF builds on a vector based rendering engine it's incredibly easy to build scalable user interfaces.

C# Programming Ketan Rajpal Page: 27 Creating a Simple WPF Application

Open Visual Studio 2008 and choose "File", "New", "Project..." in the main menu. Choose "WPF Application" as project type.

Choose a folder for your project and give it a name. Then press "OK" Visual Studio creates the project and automatically adds some files to the solution. A Window1.xaml and an

App.xaml. The structure looks quite similar to WinForms, except that the Window1.designer.cs file is no longer code but it's now declared in XAML as Window1.xaml

Open the Window1.xaml file in the WPF designer and drag a Button and a TextBox from the toolbox to the Window

Select the Button and switch to the event view in the properties window (click on the little yellow lightning icon). Doubleclick on the "Click" event to create a method in the codebehind that is called, when the user clicks on the button.

Visual Studio automatically creates a method in the code-behind file that gets called when the button is clicked.

private void button1_Click(object sender, RoutedEventArgs e) { textBox1.Text = "Hello WPF!"; }

The textbox has automatically become assigned the name textBox1 by the WPF designer. Set text Text to

"Hello WPF!" when the button gets clicked and we are done! Start the application by hit [F5] on your keyboard.

C# Programming Ketan Rajpal Page: 28 4th Unit Introduction to XML: XML stands for Extensible Markup Language. XML is a markup language much like HTML. XML was designed to carry data, not to display data. XML tags are not predefined. You must define your own tags. XML is designed to be self-descriptive. Some of the important features of a XML document are

XML can be used to exchange, share, and store data. XML documents form a tree structure that starts at "the root" and branches to "the leaves". XML has very simple syntax rules. XML with correct syntax is "Well Formed". Valid XML also validates against

a DTD. XSLT is used to transform XML into other formats like HTML. All modern browsers have a built-in XML parser that can read and manipulate XML. The DOM (Document Object Model) defines a standard way for accessing XML. The XMLHttpRequest object provides a way to communicate with a server after a web page has loaded. XML Namespaces provide a method to avoid element name conflicts. Text inside a CDATA section is ignored by the parser.

The Difference between XML and HTML: All XML Elements Must Have a Closing Tag. XML Tags are Case Sensitive. XML Elements must be Properly Nested. XML Documents Must Have a Root Element. XML Attribute Values must be quoted. All modern browsers have a built-in XML parser. An XML parser converts an XML document into an XML DOM object - which can then be manipulated with JavaScript. XML is not a replacement for HTML. XML and HTML were designed with different goals. XML was designed to transport and store data, with focus on what data is. HTML was designed to display data, with focus on how data looks. HTML is about displaying information, while XML is about carrying information. Usage of XML

XML Separates Data from HTML XML Simplifies Data Sharing XML Simplifies Data Transport XML Simplifies Platform Changes XML Makes Your Data More Available XML is Used to Create New Internet Languages

Example of XML Tove Jani Reminder Don't forget me this weekend! Valid XML Documents XML Document Tove Jani Reminder Don't forget me this weekend! XML DTD

C# Programming Ketan Rajpal Page: 29 ]> XML Schema LINQ: Language Integrated Query (LINQ) gives .NET developers the ability to query and transform data using any .NET language of choice. The data may be present in XML documents, inside relational database tables, or inside collections of objects. LINQ is integrated into the .NET languages like C# and VB.

Query expressions can be used to query and to transform data from any LINQ-enabled data source. Query expressions are easy to master because they use many familiar C# language constructs. The variables in a query expression are all strongly typed, although in many cases you do not have to provide

the type explicitly because the compiler can infer it. A query is not executed until you iterate over the query variable in a foreach statement.

Example of a LINQ Query class LINQQueryExpressions { static void Main() { int[] scores = new int[] { 97, 92, 81, 60 }; IEnumerable scoreQuery = from score in scores where score > 80 select score; foreach (int i in scoreQuery) { Console.Write(i + " "); } } } The example will display the output: 97 92 81 Example of a LINQ Query string[] tools = { "Tablesaw", "Bandsaw", "Planer", "Jointer", "Drill","Sander}; var list = from t in tools

select t; StringBuilder sb = new StringBuilder(); foreach (string s in list) {

sb.Append(s + Environment.NewLine); } MessageBox.Show(sb.ToString(), "Tools"); LINQ Providers

LINQ to Objects LINQ to XML (formerly called XLINQ) LINQ to SQL (formerly called DLINQ) LINQ to DataSets Other providers

C# Programming Ketan Rajpal Page: 30 LINQ to Objects: The LINQ to Objects provider is used for in-memory collections, using the local query execution engine of LINQ. The code generated by this provider refers to the implementation of the standard query operators as defined on the Sequence pattern and allows IEnumerable collections to be queried locally. Current implementation of LINQ to Objects uses e.g. O(n) linear search for simple lookups, and is not optimized for complex queries. Simple Example of LINQ to Objects string[] Birds = { "Indigo Bunting", "Rose Breasted Grosbeak", "Robin", "House Finch", "Gold Finch", "Ruby Throated Hummingbird","Rufous Hummingbird", "Downy Woodpecker" }; var list = from b in Birds where b.StartsWith("R") select b; StringBuilder sb = new StringBuilder(); foreach (string s in list) { sb.Append(s + Environment.NewLine); } MessageBox.Show(sb.ToString(), "R Birds"); LINQ to XML (formerly called XLINQ): The LINQ to XML provider converts an XML document to a collection of XElement objects, which are then queried against using the local execution engine that is provided as a part of the implementation of the standard query operator. Example 1 XElement xml = new XElement("contacts", new XElement("contact", new XAttribute("contactId", "2"), new XElement("firstName", "Barry"), new XElement("lastName", "Gottshall") ), new XElement("contact", new XAttribute("contactId", "3"), new XElement("firstName", "Armando"), new XElement("lastName", "Valdes") ) ); Console.WriteLine(xml); The example will display the output: Barry Gottshall Armando Valdes Example 2 Barney Gottshall

C# Programming Ketan Rajpal Page: 31 Armando Valdes Adam Gauwain ... The C# Code: var xmlSource = contacts.Load(@"../../Contacts.xml"); var q = from c in xmlSource.contact where c.contactId < 4 select c.firstName + " " + c.lastName; foreach(string name in q) Console.WriteLine("Customer name = {0}", name); The example will display the output: Customer name = Barney Gottshall Customer name = Armando Valdes LINQ to SQL (formerly called DLINQ): The LINQ to SQL provider allows LINQ to be used to query SQL Server databases, including SQL Server Compact databases. Since SQL Server data may reside on a remote server, and because SQL Server has its own query engine, LINQ to SQL does not use the query engine of LINQ. Instead, it converts a LINQ query to a SQL query that is then sent to SQL Server for processing. However, since SQL Server stores the data as relational data and LINQ works with data encapsulated in objects, the two representations must be mapped to one another. For this reason, LINQ to SQL also defines a mapping framework. The mapping is done by defining classes that correspond to the tables in the database, and containing all or a subset of the columns in the table as data members. The correspondences, along with other relational model attributes such as primary keys, are specified using LINQ to SQL-defined attributes. Example of LINQ to SQL myLINQDBDataContext db=new myLINQDBDataContext(); To retrieve data from the database var q=from products_1 in db.products where products_1.category.categoryName==Bevrages orderby products_1.productName select products_1; foreach (var x in q) System.console.writeline(x.ProductName); To update data from the database Product p=q.ElementAtovDefault(10); if(p!=null) { System.console.writeLine(p.productName, p.unitPrice); p.UnitPrize-20; } To insert data in the database Product p=new Product { Product Name=new Test Record}; db.Product.InsertOnSubmit(map); db.SubmitChanges(); To delete data from the database

C# Programming Ketan Rajpal Page: 32 var p=from product_1 in db.product where product_1.name==ABC select product_1; if(p!==null) { Db.product.DeleteOnSubmit(p); Db.SubmitChanges(); } LINQ to Datasets: The LINQ to SQL provider works only with Microsoft SQL Server databases; to support any generic database, LINQ also includes the LINQ to Datasets, which uses ADO.NET to handle the communication with the database. Once the data is in ADO.NET Datasets, LINQ to Datasets execute queries against these datasets. Implicitly Typed Local Variable: Theres another language feature known as implicitly typed local variables (or var for short) that instructs the compiler to infer the type of a local variable. For example: var integer = 1; In this case, integer has the type int. Its important to understand that this is still strongly typed. In a dynamic language, integers type could change later. To illustrate this, the following code does not compile: var integer = 1; integer = hello; The C# compiler will report an error on the second line, stating that it cant implicitly convert a string to an int. implicitly typed locals are just that: local within a method. It is not possible for them to escape the boundaries of a method, property, indexer, or other block because the type cannot be explicitly stated, and "var" is not legal for fields or parameter types. Implicitly typed locals turn out to be convenient outside of the context of a query. For example, it helps simplify complicated generic instantiations: var customerListLookup = new Dictionary(); Anonymous Types: This language feature enables us to define inline types without having to explicitly define a class declaration for this type. In other words, imagine we want to use a Point object without defining the class Point (it would be anonymous). var p = new {X = 0, Y = 2}; Extension Methods: Extension methods make it possible to extend existing types and constructed types with additional methods, without having to derive from it or recompile the original type. So instead of writing helper methods for objects they become part of that object itself. As an example, suppose we want to check a string to see if it is a valid email address. We would do this by writing a function that takes a string as an argument and returns a true/false. We defined a static class with a static method containing the extension method. Note how the static method above has a this keyword before the first parameter argument of type string. This tells the compiler that this particular Extension Method should be added to objects of type string. And then we can call it from the string as a member function. An Example of Extension Methods public static class MyExtensions { public static bool IsValidEmailAddress(this string s) { Regex regex = new Regex( @"^[w-.]+@([w-]+.)+[w-]{2,4}$" ); return regex.IsMatch(s); } } using MyExtensions; string email = Request.QueryString["email"];

C# Programming Ketan Rajpal Page: 33 if ( email.IsValidEmailAddress() ) { // ... } Lambda expression: A lambda expression is an anonymous function that can contain expressions and statements, and can be used to create delegates or expression tree types. All lambda expressions use the lambda operator =>, which is read as "goes to". The left side of the lambda operator specifies the input parameters. The right side holds the expression or statement block. The lambda expression x => x * x is read "x goes to x times x." delegate int del(int i); static void Main(string[] args) { del myDelegate = x => x * x; int j = myDelegate(5); //j = 25 } ADO.Net: ADO.NET provides consistent access to data sources such as Microsoft SQL Server, as well as data sources exposed through OLE DB and XML. Data-sharing consumer applications can use ADO.NET to connect to these data sources and retrieve, manipulate, and update data. ADO.NET is conceptually divided into consumers and data providers. The consumers are the applications that need access to the data, and the providers are the software component that implement the interface and thereby provides the data to the consumer. The data access technologies used with ADO.net is

RDBMS ADO (ADO vs. ADO.NET) ODBC JDBC OLE DB XML

The ADO.NET classes are found in System.Data.dll, and are integrated with the XML classes found in System.Xml.dll. When compiling code that uses the System.Data namespace, reference both System.Data.dll and System.Xml.dll.