Windows form application using System.Windows.Forms; using System.Drawing; class MyForm:Form{ public...

Windows form application

using System.Windows.Forms;using System.Drawing;class MyForm:Form{ public static void Main(){ Application.Run(new MyForm()); } protected override void OnPaint(PaintEventArgs e){ e.Graphics.DrawString("Hello World!", new Font("Arial", 35), Brushes.Blue, 10, 100); }}

The source code in Figure 1‑1 displays the text "Hello World!" in a window. (The C# version of a command line hello-world application would be a one-liner). As you can see from the code, C# has a C-based syntax, but with objects like C++ or Java. Every function in C# is a method of a type.

In this example, the MyForm class is defined to derive its functionality from the Form class (part of the .NET Framework Class Library). In addition it defines two new methods, Main() and OnPaint().

All C# (or .NET) applications must have a static method named Main() defined to be the entry point of the application.

The static Main() method can be defined in any class in the application, so long as its name is “Main” and it is declared to be static.

The OnPaint() method is an override of a virtual method on the Form class. It is called when the window needs to paint itself. This sample uses this method to draw the text "Hello World!".

Most of the code in Figure 1‑1 will be covered in detail throughout this text. Don’t worry too much about the parts that don’t make sense right now. However, I would take the time to look the code over, perhaps build and run it, and get a feel for the sample.

Basics of C#

Array

using System;

class Array{ public static void Main() { int[] myInts = { 5, 10, 15 }; bool[][] myBools = new bool[2][]; myBools[0] = new bool[2]; myBools[1] = new bool[1]; double[,] myDoubles = new double[2, 2]; string[] myStrings = new string[3];

Console.WriteLine("myInts[0]: {0}, myInts[1]: {1}, myInts[2]: {2}", myInts[0], myInts[1], myInts[2]);

myBools[0][0] = true; myBools[0][1] = false; myBools[1][0] = true; Console.WriteLine("myBools[0][0]: {0}, myBools[1][0]: {1}", myBools[0][0],

myBools[1][0]);

myDoubles[0, 0] = 3.147; myDoubles[0, 1] = 7.157; myDoubles[1, 1] = 2.117; myDoubles[1, 0] = 56.00138917; Console.WriteLine("myDoubles[0, 0]: {0}, myDoubles[1, 0]: {1}",myDoubles[0,

0], myDoubles[1, 0]);

myStrings[0] = "Joe"; myStrings[1] = "Matt"; myStrings[2] = "Robert"; Console.WriteLine("myStrings[0]: {0}, myStrings[1]: {1}, myStrings[2]: {2}",

myStrings[0], myStrings[1], myStrings[2]); }}

Binary Opreator

using System;

class Binary{ public static void Main() { int x, y, result; float floatResult;

x = 7; y = 5;

result = x + y; Console.WriteLine("x+y: {0}", result);

result = x - y; Console.WriteLine("x-y: {0}", result);

result = x * y; Console.WriteLine("x*y: {0}", result);

result = x / y; Console.WriteLine("x/y: {0}", result);

floatResult = (float)x / (float)y; Console.WriteLine("x/y: {0}", floatResult);

result = x % y; Console.WriteLine("x%y: {0}", result);

result += x; Console.WriteLine("result+=x: {0}", result); }}

Boolean opearator

using System;

class Booleans{ public static void Main() { bool content = true; bool noContent = false;

Console.WriteLine("It is {0} that C# Stationprovides C# programming language content.", content);

Console.WriteLine("The statement above is not {0}.", noContent);

}}

Unary opearetors

using System;class Unary{ public static void Main() { int unary = 0; int preIncrement; int preDecrement; int postIncrement; int postDecrement; int positive; int negative; sbyte bitNot; bool logNot;

preIncrement = ++unary; Console.WriteLine("Pre-Increment: {0}", preIncrement);

preDecrement = --unary; Console.WriteLine("Pre-Decrement: {0}", preDecrement);

postDecrement = unary--; Console.WriteLine("Post-Decrement: {0}", postDecrement);

postIncrement = unary++; Console.WriteLine("Post-Increment: {0}",

postIncrement);

Console.WriteLine("Final Value of Unary: {0}", unary);

positive = -postIncrement; Console.WriteLine("Positive: {0}", positive);

negative = +postIncrement; Console.WriteLine("Negative: {0}", negative);

bitNot = 0; bitNot = (sbyte)(~bitNot); Console.WriteLine("Bitwise Not: {0}", bitNot);

logNot = false; logNot = !logNot; Console.WriteLine("Logical Not: {0}", logNot); }}

IF

using System;

class IfSelect{ public static void Main() { string myInput; int myInt;

Console.Write("Please enter a number: "); myInput = Console.ReadLine(); myInt = Int32.Parse(myInput);// string to int

if (myInt > 0) { Console.WriteLine("Your number {0} is greater than zero.",myInt); }

if (myInt < 0) Console.WriteLine("Your number is less than zero.",myInt);

if (myInt != 0) { Console.WriteLine("Your number {0} is not equal to zero.",myInt); } else { Console.WriteLine("Your number {0} is equal to zero.",myInt); } if (myInt < 0 || myInt == 0) { Console.WriteLine("Your number {0} is less than or equal to zero.",myInt); } else if (myInt > 0 && myInt <= 10) { Console.WriteLine("Your number {0} is between 1 and 10.",myInt); } else if (myInt >10 && myInt <= 20) { Console.WriteLine("Your number {0} is between 11 and 20.",myInt); } else if (myInt > 20 && myInt <= 30) { Console.WriteLine("Your number {0} is between 21 and 30.",myInt); } else { Console.WriteLine("Your number {0} is greater than 30.",myInt); } }}

switch

using System;

class SwitchSelection{ public static void Main() { string myInput; int myInt;

begin:

Console.Write("Please enter a number between 1 and 3: "); myInput = Console.ReadLine(); myInt = Int32.Parse(myInput);

// Switch with integer type switch (myInt) { case 1: Console.WriteLine("Your number is {0}.", myInt); break; case 2: Console.WriteLine("Your number is {0}.", myInt); break; case 3: Console.WriteLine("Your number is {0}.", myInt); break; default: Console.WriteLine("Your number {0} is not between 1 and 3.", myInt); break; }

decide:

Console.Write("Type\"continue\"to go on or\"quit\"to stop: "); myInput = Console.ReadLine();

// switch with string type switch (myInput) { case "continue": goto begin; case "quit": Console.WriteLine("bye."); break; defualt: Console.WriteLine("Your input {0} is incorrect.", myInput); goto decide; } }}

Loop

Do while foreach

using System;

class ForEachLoop{ public static void Main() { string[] names = {"Cheryl","Joe","Matt","Robert"};

foreach (string person in names) { Console.WriteLine("{0}",person); } }}

using System;

class ForLoop{ public static void Main() { for (int i=0; i < 20; i++) { if (i == 10) break;

if (i % 2 ==0) continue; Console.Write("{0}",i); } Console.WriteLine(); }}

using System;

class WhileLoop{ public static void Main() { int myInt = 0;

while (myInt < 10) { Console.Write("{0}",myInt); myInt++; } Console.WriteLine(); }}

Methods

using System; using System.Collections.Generic; using System.Linq; using System.Text;namespace ConsoleApplication3{ class myclass { public static int multiply(int x, int y) { int res = x * y; Console.WriteLine("Multiplication = " + res); return res; }

public void inc(ref int x) { x = x + 1; }

public void equal(int y) { y = y + 1; } }

class Program { public int add(int x, int y) { return(x+y); } static void Main(string[] args) { int x = 90; int y = 90; // for static method //Console.WriteLine(" output = " + myclass.multiply(67,9887)); Program p = new Program(); int ans = p.add(56,89); Console.WriteLine("addition ==" + ans); // call by ref Console.WriteLine("X befor fuction call " + x); myc.inc(ref x); Console.WriteLine("X after fuction call " + x); // call by value Console.WriteLine("y befor fuction call " +y); myc.equal(y); Console.WriteLine("y after fuction call " + y); } }}

Name Sapce

namespace csharp_station.tutorial{ class myExample { public static void myPrint() { Console.WriteLine("This is a

member of csharp_station.tutorial.myExample.");

} }}

// Namespace Declarationusing System;using csTut = csharp_station.tutorial.myExample; // alias

// Program start classclass AliasDirective{ // Main begins program execution public static void Main() { // Call namespace member csTut.myPrint(); myPrint(); }

// Potentially ambiguous method static void myPrint() { Console.WriteLine("Not a member of

csharp_station.tutorial.myExample."); }}

Nested Name space

using System;namespace csharp_station{ // nested namespace namespace tutorial { class myExample1 { public static void myPrint1() { Console.WriteLine("First Example of calling another namespace member."); } } } // program start class class NamespaceCalling { // Main begins program execution public static void Main() { // Write to console tutorial.myExample1.myPrint1(); tutorial.myExample2.myPrint2(); } }}

namespace csharp_station.tutorial{ class myExample2 { public static void myPrint2() { Console.WriteLine("Second Example

of calling another namespace member.");

} }}

Class

// Namespace Declarationusing System;

// helper classclass OutputClass { string myString;

// Constructor public OutputClass(string inputString) { myString = inputString; }

// Instance Method public void printString() { Console.WriteLine("{0}", myString); }

// Destructor ~OutputClass() { // Some resource cleanup routines }}

// Program start classclass ExampleClass { // Main begins program execution. public static void Main() { // Instance of OutputClass OutputClass outCl = new OutputClass("This is printed by the output class.");

// Call Output class' method outCl.printString(); }}

Inheritance

using System;

public class ParentClass{ public ParentClass() { Console.WriteLine("Parent Constructor."); }

public void print() { Console.WriteLine("I'm a Parent Class."); }}

public class ChildClass : ParentClass{ public ChildClass() { Console.WriteLine("Child Constructor."); }

public static void Main() { ChildClass child = new ChildClass();

child.print(); }

Derived class talking with base class

using System;

public class Parent{ string parentString; public Parent() { Console.WriteLine("Parent Constuctor."); } public Parent(string myString) { parentString = myString; Console.WriteLine(parentString); } public void print() { Console.WriteLine("I'm a Parent Class."); }}

public class Child : Parent{ public Child() : base("From Derived") { Console.WriteLine("Child Constuctor."); } public new void print() { base.print(); Console.WriteLine("I'm a Child Class."); } public static void Main() { Child child = new Child(); child.print(); ((Parent)child).print(); } }

Polymorphism

Program.cs

using System;

public class DrawDemo{ public static int Main() { DrawingObject[] dObj = new DrawingObject[4];

dObj[0] = new Line(); dObj[1] = new Circle(); dObj[2] = new Square(); dObj[3] = new DrawingObject();

foreach (DrawingObject drawObj in dObj) { drawObj.Draw(); }

return 0; }}

using System;

public class DrawingObject{ public virtual void Draw() { Console.WriteLine("I'm just a generic

drawing object."); }}

lcs.cs

using System;

public class Line : DrawingObject{ public override void Draw() { Console.WriteLine("I'm a Line."); }}

public class Circle : DrawingObject{ public override void Draw() { Console.WriteLine("I'm a Circle."); }}

public class Square : DrawingObject{ public override void Draw() { Console.WriteLine("I'm a Square."); }}

Encapsulation

Traditional way of encapsulation

using System; public class Customer { private int m_id = -1;

public int GetID() { return m_id; }

public void SetID(int id) { m_id = id; }

private string m_name = string.Empty;

public string GetName() { return m_name; }

public void SetName(string name) { m_name = name; } }

public class CustomerManagerWithAccessorMethods

{public static void Main() { Customer cust = new Customer(); cust.SetID(1); cust.SetName("Amelio Rosales"); Console.WriteLine( "ID: {0}, Name:

{1}", cust.GetID(), cust.GetName()); Console.ReadKey(); } }

Encapsulating Type State with Properties

public class Customer{ private int m_id = -1;

public int ID { get { return m_id; } set { m_id = value; } }

private string m_name = string.Empty;

public string Name { get { return m_name; } set { m_name = value; } }}

using System;

public class CustomerManagerWithProperties{

public static void Main(){

Customer cust = new Customer();

cust.ID = 1; cust.Name = "Amelio Rosales";

Console.WriteLine( "ID: {0}, Name: {1}“, cust.ID, cust.Name);

Console.ReadKey();}

}

Read only properties - without set method

Write only properties – without get method

Structure

using System;struct Point{ public int x; public int y; public Point(int x, int y) { this.x = x; this.y = y; } public Point Add(Point pt) { Point newPt; newPt.x = x + pt.x; newPt.y = y + pt.y;

return newPt; }}

class StructExample{ static void Main(string[] args) { Point pt1 = new Point(1, 1); Point pt2 = new Point(2, 2); Point pt3;

pt3 = pt1.Add(pt2);

Console.WriteLine("pt3: {0}:{1}",pt3.x,pt3.y); }}

Interface

An interface looks like a class, but has no implementation.

The only thing it contains are declarations of events, indexers, methods and/or properties.

The reason interfaces only provide declarations is because they are inherited by classes and structs, which must provide an implementation for each interface member declared.

So, what are interfaces good for if they don't implement functionality?

They're great for putting together plug-n-play like architectures where components can be interchanged at will.

interface IMyInterface{ void MethodToImplement();}

using System;

class InterfaceImplementer : IMyInterface{ static void Main() { InterfaceImplementer iImp = new

InterfaceImplementer(); iImp.MethodToImplement(); }

public void MethodToImplement() { Console.WriteLine("MethodToImplement() called."); }}

using System;

interface IParentInterface{ void ParentInterfaceMethod();}

interface IMyInterface : IParentInterface{ void MethodToImplement();}

class InterfaceImplementer : IMyInterface{ static void Main() { InterfaceImplementer iImp = new InterfaceImplementer(); iImp.MethodToImplement(); }

public void MethodToImplement() { Console.WriteLine("MethodToImplement() called."); }

public void ParentInterfaceMethod() { Console.WriteLine("ParentInterfaceMethod() called."); }}

Indexers

Indexer are location indicators and used to access class objects , just like accessing elements in an array.

Indexers look like a properties with two differences.

Indexer takes index argument and look like an array

Indexer is declared using the name this

Class list{ArrayList array = new ArrayList();Public object this [int index]{get{

if(index < 0 && index >= array.count){

return null;}

else{

return (array [index]);}

}set{

array[index]=value;}}}

class IndexserTest{Public static void Main(){

List l = new List();l [0] = “123”;l[1] = “abc”;l[2]=“xyz”;for(int i=0; I < list.count;i++)

Console.WriteLine(list[i]); }}

Properties are static indexer is instance member

get set

ARRAY ARRAYLIST1.

Char[] vowel=new

Char[];

ArrayList a_list=new

ArrayList();2.

Array is in the System

namespace

ArrayList is in the System.Collections namespace.

3. The capacity of an Array is fixed

ArrayList can increase and decrease size dynamically

4. An Array is a collection of similar items

ArrayList can hold item of different types

5. An Array can have multiple dimensions

 ArrayList always has exactly one dimension

Delegates

A delegate is a C# language element that allows you to reference a method. If you were a C or C++ programmer, this would sound familiar because a delegate is basically a function pointer.

Why to use ? -- Gives you maximum flexibility to implement any functionality you want at runtime.

which provide dynamic run-time method invocation services.

class Program { public delegate int SumPtr(int x, int

y);//declaration

public int add(int x, int y) { return(x+y); } static void Main(string[] args) { int x = 90; int y = 90; Program p = new Program(); int ans = p.add(56,89); // with delegates SumPtr sPtr = new SumPtr(p.add);

//instantiation Console.WriteLine(" with deleget"+ sPtr(34,

6));//invocation } } }

Sometimes, however, we don't want to call a function directly – we'd like to be able to pass it to somebody else so that they can call it.

This is especially useful in an event-driven system such as a graphical user interface, when I want some code to be executed when the user clicks on a button, or when I want to log some information but can't specify how it is logged

Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object.

The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked.

In C#, delegates are multicast, which means that they can point to more than one function at a time

Delegates can be added and subtracted

delegate void MyDelegate(string s); class MyClass { public static void Hello(string s) { Console.WriteLine(" Hello, {0}!", s); }

public static void Goodbye(string s) { Console.WriteLine(" Goodbye, {0}!", s); }

public static void Main() { MyDelegate a, b, c, d; a = new MyDelegate(Hello); b = new MyDelegate(Goodbye); c = a + b; d = c - a; Console.WriteLine("Invoking delegate a:"); a("A"); Console.WriteLine("Invoking delegate b:"); b("B"); Console.WriteLine("Invoking delegate c:"); c("C"); Console.WriteLine("Invoking delegate d:"); d("D"); }}

Event

The Event model in C# finds its roots in the event programming model that is popular in asynchronous programming.

The basic foundation behind this programming model is the idea of "publisher and subscribers."

We want to cause some code to be executed when something happens elsewhere in the system - or "handle the event".

To do this, we create specific methods for the code we want to be executed.

The glue between the event and the methods to be executed are the delegates

Events and delegates work hand-in-hand.

Any class, including the same class that the event is declared in, may register one of its methods for the event.

This occurs through a delegate, which specifies the signature of the method that is registered for the event.

The delegate may be one of the pre-defined .NET delegates or one you declare yourself. Whichever is appropriate, you assign the delegate to the event, which effectively registers the method that will be called when the event fires.

Event.cs

File Handling

Byte oriented file require FileSteram object defined in system.IO.

Using system.io

To create byte stream linked to a file create File stream object.

Constructor FileStream (string path. FileMode mode) FileStream (string path. FileMode mode, FileAccess access)

Exceptions FileNotFoundException,

IOException,ArgumentNullException,ArgumentException ,SecurityException,PathTooLongException

Close void close();

FileMode.Append

FIleMode.Create

FileMode.CreateNew

FileMode.Open

FileMode.OpenOrCreate

FileMode.Truncate

FileAccess.Read

FileAccess.Write

FileAccess.ReadWrite

int ReadByte() – each time reads single byte from file ,returns -1 when EOF

int Read(byte[] array, int offset, int count) Attempts to read up to count byte into array starting at

array[offset], returns number of bytes successfully read

Void WriteByte(byte value)

Void Writebyte[] array, int offset, int count)

Void Flush()

Operates directly on Unicode characters.

At the OS level file contain set of bytes using stream reader and stream writer does not alter this fact

Constructor 1 - StreamWrite (string path)

Constructor 2 - SteramWriter (string path, bool append)

StreamWriter automatically handles conversion of character to byte.

FileStream fout;try {fout = new

FileStream(“test.txt”,FilleMode.Create);} catch()

StreamWriter fstr_out = new StreamWriter(fout);

try{str = Console.ReadLine();fstr_out.Write(str); }catch()

StreamWriter fstr_out = null;fstr_out = new

StreamWriter(“test.txt”);try{str = Console.ReadLine();fstr_out.Write(str); }catch()

FileStream fin;try {fin = new FileStream(“test.txt”,FilleMode.Open);} catch()

StreamReader fstr_in = new StreamReader(fin);try{While((s= fstr_in.ReadLine() )!= NULL ) Console.WriteLine(s);}catch()

filehandling.cs

Seek() defined by FileStream.

long Seek(long offset,SeekOrigin origin)

Offset – new position in a byte Origin – file pointer from location

SeekOrigin.Begin SeekOrigin.Current SeekOrigin.End

try {F = new FileStream(“ran.txt”,FileMode.Create)for(int i=0;i<26;i++) F.WriteByte((byte)’(A’ + i))

F.Seek(0,SeekOrigin.Begin);Ch = (char) F.ReadByte();Console.WriteLine(ch);} catch(IOEXCeption exe) { Console.WriteLine(exe.Message)}

Generics

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. For more information, see Benefits of Generics.

ARRAY ARRAYLIST1.

Char[] vowel=new

Char[];

ArrayList a_list=new

ArrayList();2.

Array is in the System

namespace

ArrayList is in the System.Collections namespace.

3. The capacity of an Array is fixed

ArrayList can increase and decrease size dynamically

4. An Array is a collection of similar items

ArrayList can hold item of different types

5. An Array can have multiple dimensions

 ArrayList always has exactly one dimension

The problem with ArrayList and all the other .NET v1.0 collections is that they operate on type object.

Since all objects derive from the object type, you can assign anything to an ArrayList.

The problem with this is that you incur performance overhead converting value type objects to and from the object type and a single ArrayList could accidentally hold different types, which would cause hard to find errors at runtime because you wrote code to work with one type.

Generic collections fix these problems.

A generic collection is strongly typed (type safe), meaning that you can only put one type of object into it. 

This eliminates type mismatches at runtime.

Another benefit of type safety is that performance is better with value type objects because they don't incur overhead of being converted to and from type object.

With generic collections, you have the best of all worlds because they are strongly typed, like arrays, and you have the additional functionality, like ArrayList and other non-generic collections, without the problems.

List <T>

Dictionary <Tkey , TValue>

The pattern for using a generic List collection is similar to arrays. You declare the List, populate its members, then access the members.

List<int>, which is referred to as List of int

List<string> or List<Customer> Using the Add method, you can add as

many int objects to the collection as you want.

List<T> class has many more methods you can use, such as Contains, Remove, and more.

List<int> myInts = new List<int>(); myInts.Add(1); myInts.Add(2); myInts.Add(3);

for (int i = 0; i < myInts.Count; i++) { Console.WriteLine("MyInts: {0}", myInts[i]); }

Example of Dictionary

Another very useful generic collection is the Dictionary, which works with key/value pairs.

There is a non-generic collection, called a Hashtable that does the same thing, except that it operates on type object.

Example is that you have a list of Customers that you need to work with. It would be natural to keep track of these Customers via their CustomerID

public class Customer { public Customer(int id, string name) { ID = id; Name = name; } private int m_id; public int ID { get { return m_id; } set { m_id = value; } }private string m_name; public string Name { get { return m_name; } set { m_name = value; } } }

Dictionary<int, Customer> customers = new Dictionary<int, Customer>();Customer cust1 = new Customer(1, "Cust 1");Customer cust2 = new Customer(2, "Cust 2");Customer cust3 = new Customer(3, "Cust 3"); customers.Add(cust1.ID, cust1); customers.Add(cust2.ID, cust2); customers.Add(cust3.ID, cust3);

foreach (KeyValuePair<int, Customer> custKeyVal in customers) { Console.WriteLine( "Customer ID: {0}, Name: {1}", custKeyVal.Key,

custKeyVal.Value.Name); }

The customers variable is declared as a Dictionary<int, Customer>. 

Considering that the formal declaration of Dictionary is Dictionary<TKey, TValue>, the meaning of customers is that it is a Dictionary where the key is type int and the value is type Customer.

Therefore, any time you add an entry to the Dictionary, you must provide the key because it is also the key that you will use to extract a specified Customer from the Dictionary.

Implementation of Ls/Dir command

using System;using System.IO;

class Program{ static void Main() { // Put all file names in root directory into

array. string[] array1 = Directory.GetFiles(@"C:\");

// Put all txt files in root directory into array. string[] array2 = Directory.GetFiles(@"C:\",

"*.BIN"); // <-- Case-insensitive

// Display all files. Console.WriteLine("--- Files: ---"); foreach (string name in array1) { Console.WriteLine(name); }

// Display all BIN files. Console.WriteLine("--- BIN Files: ---"); foreach (string name in array2) { Console.WriteLine(name); } }}

using System; using System.IO; public class Temp { public static void Main(string[] args) { DirectoryInfo di = new DirectoryInfo("."); foreach(FileInfo fi in di.GetFiles("*.cs")) { Console.WriteLine("Looking at

file \""+fi.FullName+"\""); } } }

using System;using System.Threading;

public class RegistrarProxy{ private static Timer _timer; private static readonly TimerCallback _timerCallback =

timerDelegate;

public void Init() { _timer = new Timer(_timerCallback, null, 0, 2000);

//repeat every 2000 milliseconds }

private static void timerDelegate(object state) { Console.WriteLine("timerDeletegate: " + DateTime.Now);

}

public static void Main() { RegistrarProxy rp = new RegistrarProxy(); rp.Init(); Console.In.Read(); //let's wait until the "return" key

pressed }}

Write C# program to display emp table content in tabular format

Write a c# program to list the directory in a drive selected by user

File copy – ask user how many lines to copy from source to destination

Write a program for all string oprations (menu driven)