.NET Code Snippets

Measure time for code execution

2011-07-16T19:26:00.001-07:00

void Main()
{
    int startTick = Environment.TickCount;
    Thread.Sleep(1000);
    int endTick = Environment.TickCount;

Console.WriteLine("Thread slept for {0} ms", (endTick - startTick));
}

Lambda Expressions Sample

2010-05-08T01:30:00.001-07:00

  using System;
   
  //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
  //(if any) and the right side holds the expression or statement block.
   
  //The lambda expression x => x * x is read "x goes to x times x."
   
  //This expression can be assigned to a delegate type.
   
  delegate string NoInputStrOutputDel ();
  delegate int IntInputIntOutputDel ( int i );
  delegate string MultiStrInputStrOutputDel ( string salutation , string firstName , string lastName );
   
  public class MyClass
  {
      public static void Main ()
      {
   
          NoInputStrOutputDel del1 = () => "Output without Input";
          Console.WriteLine ( del1 () );
   
          IntInputIntOutputDel del2 = x => x * x;
          Console.WriteLine ( del2 ( 5 ) );
   
          MultiStrInputStrOutputDel del3 = ( i , j , k ) => "Hello " + i + " " + j + " " + k;
          Console.WriteLine ( del3 ( "Mr." , "Ajit" , "Singh" ) );
   
          Console.ReadKey ();
   
      }
}

Reading cookie info from a URL in .net code

2010-03-20T19:42:00.001-07:00

using System;
using System.Collections.Generic;
using System.Net;
class MainApp
{
    static void Main ( string[] args )
    {
        string URL = "http://www.yahoo.com";
        //HttpWebRequest request = (HttpWebRequest)WebRequest.Create(args[0]);  
        HttpWebRequest request = ( HttpWebRequest ) WebRequest.Create ( URL );
        request.CookieContainer = new CookieContainer ();
        HttpWebResponse response = ( HttpWebResponse ) request.GetResponse ();
        // Print the properties of each cookie.  
        foreach ( Cookie cook in response.Cookies )
        {
            Console.WriteLine ( "Cookie:" );
            Console.WriteLine ( "{0} = {1}" , cook.Name , cook.Value );
            Console.WriteLine ( "Domain: {0}" , cook.Domain );
            Console.WriteLine ( "Path: {0}" , cook.Path );
            Console.WriteLine ( "Port: {0}" , cook.Port );
            Console.WriteLine ( "Secure: {0}" , cook.Secure );
            Console.WriteLine ( "When issued: {0}" , cook.TimeStamp );
            Console.WriteLine ( "Expires: {0} (expired? {1})" ,
              cook.Expires , cook.Expired );
            Console.WriteLine ( "Don't save: {0}" , cook.Discard );
            Console.WriteLine ( "Comment: {0}" , cook.Comment );
            Console.WriteLine ( "Uri for comments: {0}" , cook.CommentUri );
            Console.WriteLine ( "Version: RFC {0}" , cook.Version == 1 ? "2109" : "2965" );
            // Show the string representation of the cookie.  
            Console.WriteLine ( "String: {0}" , cook.ToString () );
        }
        // Wait for user  
        Console.ReadKey ();
    }
}

DoFactory design patterns and sample codes

2010-03-04T11:10:00.001-08:00

DoFactory Design Patterns page.

Creational Patterns

Abstract Factory
Creates an instance of several families of classes

Builder
Separates object construction from its representation

Factory Method
Creates an instance of several derived classes

Prototype
A fully initialized instance to be copied or cloned

Singleton
A class of which only a single instance can exist

Structural Patterns

Adapter
Match interfaces of different classes

Bridge
Separates an object’s interface from its implementation

Composite
A tree structure of simple and composite objects

Decorator
Add responsibilities to objects dynamically

Facade
A single class that represents an entire subsystem

Flyweight
A fine-grained instance used for efficient sharing

Proxy
An object representing another object

Behavioral Patterns

Chain of Resp.
A way of passing a request between a chain of objects

Command
Encapsulate a command request as an object

Interpreter
A way to include language elements in a program

Iterator
Sequentially access the elements of a collection

Mediator
Defines simplified communication between classes

Memento
Capture and restore an object's internal state

Observer
A way of notifying change to a number of classes

State
Alter an object's behavior when its state changes

Strategy
Encapsulates an algorithm inside a class

Template Method
Defer the exact steps of an algorithm to a subclass

Visitor
Defines a new operation to a class without change

Default constructor calling another constructor

2010-03-04T10:16:00.001-08:00

using System;  
using System.Collections;  
public class Inventor  
{  
  public string Name;  
  public string Nationality;  
  public string[] Inventions;  
  private DateTime dob;  
  public Inventor()  
    : this(null, DateTime.MinValue, null)  
  { }  
  public Inventor(string name, DateTime dateOfBirth, string nationality)  
  {  
    this.Name = name;  
    this.dob = dateOfBirth;  
    this.Nationality = nationality;  
  }  
  public DateTime DOB  
  {  
    get { return dob; }  
    set { dob = value; }  
  }  
  public int GetAge(DateTime on)  
  {  
    // not very accurate, but it will do the job ;-)  
    return on.Year - dob.Year;  
  }  
}

Threading : Performing long running operations using multiple asynchronous actions

2010-03-04T03:44:00.001-08:00

using System.Threading;  
 using System;  
 using System.Linq;  
 using System.Collections.Generic;  
 using System.Diagnostics;  
 public static class Extensions   
{   
  public static void ExecAsync(this IEnumerable<Action> actions)   
  {   
    int count = 0;   
    AutoResetEvent[] events = new AutoResetEvent[actions.Count()];   
    IAsyncResult[] results = new IAsyncResult[actions.Count()];   
    for (int i = 0; i < events.Length; i++)   
    {   
      events[i] = new AutoResetEvent(false);   
    }   
    foreach (var action in actions)   
    {   
      int localCount = count;   
      results[count++]=    
        action.BeginInvoke((r) =>   
        {   
          try   
          {   
            if (r.IsCompleted)   
            {   
              Action act = r.AsyncState as Action;   
              act.EndInvoke(results[localCount]);   
            }   
          }   
          finally   
          {   
            //set the event regardless of whether there is an exception so that the main thread   
            //is not blocked indefinitely.   
            events[localCount].Set();   
          }   
        }, action);   
    }   
    WaitHandle.WaitAll(events);   
  }   
}   
class Program    
{   
  public static string[] GetUsers()   
  {   
    //simulate a long running operation   
    Thread.Sleep(3000);   
    Console.WriteLine("Current Thread:{0}", Thread.CurrentThread.ManagedThreadId);   
    return new[]{"Jack","Jon","Jim"};         
  }   
  public static string[] GetCountries()   
  {   
    //simulate a long running operation   
    Thread.Sleep(4000);   
    Console.WriteLine("Current Thread:{0}",Thread.CurrentThread.ManagedThreadId);   
    return new[] { "US","UK","Canada" };   
  }   
  public static string[] GetLanguages()   
  {   
    //simulate a long running operation   
    Thread.Sleep(3000);   
    Console.WriteLine("Current Thread:{0}", Thread.CurrentThread.ManagedThreadId);   
    return new[] { "English", "French", "German" };   
  }   
  static void Main(string[] args)   
  {   
    string[] countries;   
    string[] users;   
    string[] languages;   
    Console.WriteLine(Environment.NewLine);   
    Console.WriteLine("Running Synchronously");   
    Console.WriteLine("---------------------");   
    Stopwatch watch = new Stopwatch();   
    watch.Start();   
    countries = GetCountries();   
    users = GetUsers();   
    languages = GetLanguages();   
    watch.Stop();   
    Console.WriteLine("Total time taken:{0} seconds", watch.Elapsed.Seconds);   
    watch.Reset();   
    watch.Start();   
    Console.WriteLine("Running Asynchronously");   
    Console.WriteLine("----------------------");   
    List<Action> actions = new List<Action>()   
    {   
      () => countries = GetCountries(),   
      () => users = GetUsers(),   
      () => languages = GetLanguages(),   
    };   
    actions.ExecAsync();   
    watch.Stop();   
    Console.WriteLine("Total time taken:{0} seconds",watch.Elapsed.Seconds);  
    Console.ReadLine();  
  }   
}

Designing classes with Fluent Interfaces

2010-03-04T03:20:00.001-08:00

http://martinfowler.com/bliki/FluentInterface.html

using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
public class TestClass  
{  
  static void Main()  
  {  
    Person person = new Person();  
    person.Set.FirstName("Joe").Age(35).LastName("Patrick").IsActive();  
    Console.WriteLine(person.FirstName+ " "+ person.LastName+"'s age is "+ person.Age );  
    Console.ReadLine();  
  }  
}  
public class Person  
{  
  public Person()  
  {  
    _set = new PersonFluentInterface(this);  
  }  
  private string _firstName;  
  private string _LastName;  
  private int _age;  
  private readonly PersonFluentInterface _set;  
  private bool _isActive;  
  public PersonFluentInterface Set  
  {  
    get { return _set; }  
  }  
  public string FirstName  
  {  
    get { return _firstName; }  
    set { _firstName = value; }  
  }  
  public string LastName  
  {  
    get { return _LastName; }  
    set { _LastName = value; }  
  }  
  public int Age  
  {  
    get { return _age; }  
    set { _age = value; }  
  }  
  public bool IsActive  
  {  
    get { return _isActive; }  
    set { _isActive = value; }  
  }  
  public class PersonFluentInterface  
  {  
    private readonly Person _person;  
    public PersonFluentInterface(Person person)  
    {  
      _person = person;  
    }  
    public PersonFluentInterface FirstName(string firstName)  
    {  
      _person.FirstName = firstName;  
      return this;  
    }  
    public PersonFluentInterface LastName(string lastName)  
    {  
      _person.LastName = lastName;  
      return this;  
    }  
    public PersonFluentInterface Age(int age)  
    {  
      _person.Age = age;  
      return this;  
    }  
    public PersonFluentInterface IsActive()  
    {  
      _person.IsActive = true;  
      return this;  
    }  
    public PersonFluentInterface IsNotActive()  
    {  
      _person.IsActive = false;  
      return this;  
    }  
  }  
}

Serialization : serializing multiple types

2010-03-04T01:49:00.001-08:00

 using System;  
 using System.IO;  
 using System.Xml;  
 using System.Xml.Serialization;  
 // This defines the object that will be serialized.  
 public class Teacher  
 {  
   public string Name;  
   public Teacher() { }  
   /* Note that the Info field returns an array of objects.  
     Any object can be added to the array by adding the  
     object type to the array passed to the extraTypes argument. */  
   [XmlArray(ElementName = "ExtraInfo", IsNullable = true)]  
   public object[] Info;  
   public Phone PhoneInfo;  
 }  
 // This defines one of the extra types to be included.  
 public class Address  
 {  
   public string City;  
   public Address() { }  
   public Address(string city)  
   {  
     City = city;  
   }  
 }  
 // Another extra type to include.  
 public class Phone  
 {  
   public string PhoneNumber;  
   public Phone() { }  
   public Phone(string phoneNumber)  
   {  
     PhoneNumber = phoneNumber;  
   }  
 }  
 // Another type, derived from Phone  
 public class InternationalPhone : Phone  
 {  
   public string CountryCode;  
   public InternationalPhone() { }  
   public InternationalPhone(string countryCode)  
   {  
     CountryCode = countryCode;  
   }  
 }  
 public class Run  
 {  
   public static void Main()  
   {  
     Run test = new Run();  
     test.SerializeObject("Teacher.xml");  
     test.DeserializeObject("Teacher.xml");  
     Console.ReadLine();  
   }  
   private void SerializeObject(string filename)  
   {  
     // Writing the file requires a TextWriter.  
     TextWriter myStreamWriter = new StreamWriter(filename);  
     // Create a Type array.  
     Type[] extraTypes = new Type[3];  
     extraTypes[0] = typeof(Address);  
     extraTypes[1] = typeof(Phone);  
     extraTypes[2] = typeof(InternationalPhone);  
     // Create the XmlSerializer instance.  
     XmlSerializer mySerializer = new XmlSerializer  
     (typeof(Teacher), extraTypes);  
     Teacher teacher = new Teacher();  
     teacher.Name = "Mike";  
     // Add extra types to the Teacher object  
     object[] info = new object[2];  
     info[0] = new Address("Springville");  
     info[1] = new Phone("555-0100");  
     teacher.Info = info;  
     teacher.PhoneInfo = new InternationalPhone("000");  
     mySerializer.Serialize(myStreamWriter, teacher);  
     myStreamWriter.Close();  
   }  
   private void DeserializeObject(string filename)  
   {  
     // Create a Type array.  
     Type[] extraTypes = new Type[3];  
     extraTypes[0] = typeof(Address);  
     extraTypes[1] = typeof(Phone);  
     extraTypes[2] = typeof(InternationalPhone);  
     // Create the XmlSerializer instance.  
     XmlSerializer mySerializer = new XmlSerializer  
     (typeof(Teacher), extraTypes);  
     // Reading a file requires a FileStream.  
     FileStream fs = new FileStream(filename, FileMode.Open);  
     Teacher teacher = (Teacher)mySerializer.Deserialize(fs);  
     // Read the extra information.  
     Address a = (Address)teacher.Info[0];  
     Phone p = (Phone)teacher.Info[1];  
     InternationalPhone Ip =  
     (InternationalPhone)teacher.PhoneInfo;  
     Console.WriteLine(teacher.Name);  
     Console.WriteLine(a.City);  
     Console.WriteLine(p.PhoneNumber);  
     Console.WriteLine(Ip.CountryCode);  
   }  
 }  
 /*  
 <?xml version="1.0" encoding="utf-8"?>  
 <Teacher xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">  
  <Name>Mike</Name>  
  <ExtraInfo>  
   <anyType xsi:type="Address">  
    <City>Springville</City>  
   </anyType>  
   <anyType xsi:type="Phone">  
    <PhoneNumber>555-0100</PhoneNumber>  
   </anyType>  
  </ExtraInfo>  
  <PhoneInfo xsi:type="InternationalPhone">  
   <CountryCode>000</CountryCode>  
  </PhoneInfo>  
 </Teacher>  
 */

Creating a non-generic custom collection supporting simple iteration

2010-02-28T04:42:00.001-08:00

 using System;  
 using System.Collections;  
 public class Person  
 {  
   public Person(string fName, string lName)  
   {  
     this.firstName = fName;  
     this.lastName = lName;  
   }  
   public string firstName;  
   public string lastName;  
 }  
 public class People : IEnumerable  
 {  
   private Person[] _people;  
   public People(Person[] pArray)  
   {  
     _people = new Person[pArray.Length];  
     for (int i = 0; i < pArray.Length; i++)  
     {  
       _people[i] = pArray[i];  
     }  
   }  
   public IEnumerator GetEnumerator()  
   {  
     return new PeopleEnum(_people);  
   }  
 }  
 public class PeopleEnum : IEnumerator  
 {  
   public Person[] _people;  
   // Enumerators are positioned before the first element  
   // until the first MoveNext() call.  
   int position = -1;  
   public PeopleEnum(Person[] list)  
   {  
     _people = list;  
   }  
   public bool MoveNext()  
   {  
     position++;  
     return (position < _people.Length);  
   }  
   public void Reset()  
   {  
     position = -1;  
   }  
   public object Current  
   {  
     get  
     {  
       try  
       {  
         return _people[position];  
       }  
       catch (IndexOutOfRangeException)  
       {  
         throw new InvalidOperationException();  
       }  
     }  
   }  
 }  
 class App  
 {  
   static void Main()  
   {  
     Person[] peopleArray = new Person[3]  
     {  
       new Person("John", "Smith"),  
       new Person("Jim", "Johnson"),  
       new Person("Sue", "Rabon"),  
     };  
     People peopleList = new People(peopleArray);  
     foreach (Person p in peopleList)  
       Console.WriteLine(p.firstName + " " + p.lastName);  
   }  
 }  
 /* This code produces output similar to the following:  
  *   
  * John Smith  
  * Jim Johnson  
  * Sue Rabon  
  *   
  */

Generic Collection Classes from Wintellect’s Power Collections Library

2010-02-28T02:16:00.001-08:00

http://www.codeplex.com/PowerCollections

Exception Handling : Try..Catch..Finally

2010-02-27T04:17:00.001-08:00

 using System;  
 using System.IO;  
 class FinallyDemo  
 {  
   static void Main(string[] args)  
   {  
     FileStream outStream = null;  
     FileStream inStream = null;  
     try  
     {  
       outStream = File.OpenWrite("DestinationFile.txt");  
       inStream = File.OpenRead("BogusInputFile.txt");  
     }  
     catch (FileNotFoundException fnfex)  
     {  
       Console.WriteLine(fnfex.ToString());  
     }  
     catch (Exception ex)  
     {  
       Console.WriteLine(ex.ToString());  
     }  
     finally  
     {  
       if (outStream != null)  
       {  
         outStream.Close();  
         Console.WriteLine("outStream closed.");  
       }  
       if (inStream != null)  
       {  
         inStream.Close();  
         Console.WriteLine("inStream closed.");  
       }  
     }  
   }  
 }

Events : Simple existing and custom events using delegate

2010-02-27T04:05:00.001-08:00

 using System;  
 using System.Drawing;  
 using System.Windows.Forms;  
 // custom delegate  
 public delegate void StartDelegate();  
 class EventDemo : Form  
 {  
   // custom event  
   public event StartDelegate StartEvent;  
   public EventDemo()  
   {  
     Button clickMe = new Button();  
     clickMe.Parent = this;  
     clickMe.Text = "Click Me";  
     clickMe.Location = new Point(  
       (ClientSize.Width - clickMe.Width) / 2,  
       (ClientSize.Height - clickMe.Height) / 2);  
     // an EventHandler delegate is assigned  
     // to the button's Click event  
     clickMe.Click += new EventHandler(OnClickMeClicked);  
     // our custom "StartDelegate" delegate is assigned  
     // to our custom "StartEvent" event.  
     StartEvent += new StartDelegate(OnStartEvent);  
     // fire our custom event  
     StartEvent();  
   }  
   // this method is called when the "clickMe" button is pressed  
   public void OnClickMeClicked(object sender, EventArgs ea)  
   {  
     MessageBox.Show("You Clicked My Button!");  
   }  
   // this method is called when the "StartEvent" Event is fired  
   public void OnStartEvent()  
   {  
     MessageBox.Show("I Just Started!");  
   }  
   static void Main(string[] args)  
   {  
     Application.Run(new EventDemo());  
   }  
 }

Casting, IS and AS Operator

2010-02-26T23:20:00.001-08:00

The IS operator checks whether an object is compatible with a given type, and the result of the evaluation is a Boolean: true or false. The is operator will never throw an exception.

 using System;  
 // This type is implicitly derived from System.Object.  
 internal class Employee /* : System.Object */ {  
 }  
 internal class Manager : Employee {  
 }  
 public static class Program {  
   public static void Main() {  
    // No cast needed since new returns an Employee object  
    // and Object is a base type of Employee.  
    Object o = new Employee();  
    // Cast required since Employee is derived from Object.  
    // Other languages (such as Visual Basic) might not require   
    // this cast to compile.  
    Employee e = (Employee) o;  
   }  
   public static void Main2() {  
    // Construct a Manager object and pass it to PromoteEmployee.  
    // A Manager IS-A Object: PromoteEmployee runs OK.  
    Manager m = new Manager();  
    PromoteEmployee(m);  
    // Construct a DateTime object and pass it to PromoteEmployee.  
    // A DateTime is NOT derived from Employee. PromoteEmployee   
    // throws a System.InvalidCastException exception.   
    DateTime newYears = new DateTime(2007, 1, 1);  
    PromoteEmployee(newYears);  
   }  
   public static void PromoteEmployee(Object o) {  
    // At this point, the compiler doesn’t know exactly what  
    // type of object o refers to. So the compiler allows the   
    // code to compile. However, at run time, the CLR does know   
    // what type o refers to (each time the cast is performed) and  
    // it checks whether the object’s type is Employee or any type  
    // that is derived from Employee.  
    Employee e = (Employee) o;  
   }  
   public static void PromoteEmployee2(Object o) {  
    if (o is Employee) {  
      Employee e = (Employee)o;  
      // Use e within the remainder of the 'if' statement.   
    }  
   }  
   public static void PromoteEmployee3(Object o) {  
    Employee e = o as Employee;  
    if (e != null) {  
      // Use e within the 'if' statement.  
    }  
   }  
   internal class B { // Base class  
   }  
   internal class D : B { // Derived class  
   }  
   private static void Main3() { // For Table 4-3 in the book  
    Object o1 = new Object();  
    Object o2 = new B();  
    Object o3 = new D();  
    Object o4 = o3;  
    B b1 = new B();  
    B b2 = new D();  
    D d1 = new D();  
    //B b3 = new Object();  
    //D d2 = new Object();  
    B b4 = d1;  
    //D d3 = b2;  
    D d4 = (D)d1;  
    D d5 = (D)b2;  
    D d6 = (D)b1; // Throws InvalidCastException  
    B b5 = (B)o1; // Throws InvalidCastException  
    B b6 = (D)b2;  
   }  
 }

Sample Assembly Info

2010-02-26T20:53:00.001-08:00

 using System.Reflection;  
 // FileDescription version information:  
 [assembly: AssemblyTitle("SampleAssemblyTypes.dll")]  
 // Comments version information:  
 [assembly: AssemblyDescription("This assembly contains SampleAssembly's types")]  
 // CompanyName version information:  
 [assembly: AssemblyCompany("SampleCompany")]  
 // ProductName version information:  
 [assembly: AssemblyProduct("SampleCompany (R) SampleAssembly's Type Library")]  
 // LegalCopyright version information:  
 [assembly: AssemblyCopyright("Copyright (c) SampleCompany 2010")]  
 // LegalTrademarks version information:  
 [assembly: AssemblyTrademark("SampleAssemblyTypes is a registered trademark of SampleCompany")]  
 // AssemblyVersion version information:  
 [assembly: AssemblyVersion("3.0.0.0")]  
 // FILEVERSION/FileVersion version information:  
 [assembly: AssemblyFileVersion("1.0.0.0")]  
 // PRODUCTVERSION/ProductVersion version information:  
 [assembly: AssemblyInformationalVersion("2.0.0.0")]  
 // Set the Language field (discussed later in the "Culture" section)  
 [assembly: AssemblyCulture("")]

Delegate Evolution: method, anonymous method, lambda expression, Func<> and Action<>

2010-02-22T04:24:00.001-08:00

 using System;
class Test
{
    delegate string TestDelegate ( string s );
    static string M ( string s )
    {
        Console.WriteLine ( s );
        return s;
    }
    static void N ( string s )
    {
        Console.WriteLine ( s );
    }
    static void Main ( string[] args )
    {
        // Original delegate syntax required   
        // initialization with a named method.  
        TestDelegate testdelA = new TestDelegate ( M );
        // C# 2.0: A delegate can be initialized with  
        // inline code, called an "anonymous method." This  
        // method takes a string as an input parameter.  
        TestDelegate testDelB = delegate ( string s ) { Console.WriteLine ( s ); return s; };
        // C# 3.0. A delegate can be initialized with  
        // a lambda expression. The lambda also takes a string  
        // as an input parameter (x). The type of x is inferred by the compiler.  
        TestDelegate testDelC = ( x ) => { Console.WriteLine ( x ); return x; };
        // Instantiate using Func delegate  
        Func<string,string > testDelD = M;
        Func<string, string> testDelE = s => { Console.WriteLine ( s ); return s; };
        // Instantiate delegate using action for functions returing void  
        Action <string> testDelF = N;
        Action<string> testDelG = s => { Console.WriteLine ( s ); };
        // Invoke the delegates.  
        testdelA ( "testdelA" );
        testDelB ( "testDelB" );
        testDelC ( "testDelC" );
        testDelD ( "testDelD" );
        testDelE ( "testDelE" );
        testDelF ( "testDelF" );
        testDelG ( "testDelG" );
        // Keep console window open in debug mode.  
        Console.WriteLine ( "Press any key to exit." );
        Console.ReadKey ();
    }
}
 

How to use the My Namespace in C#

2010-02-21T05:23:00.001-08:00

 //Add reference of Microsoft.VisualBasic.dll  
 using System;  
 using Microsoft.VisualBasic.Devices;  
 class TestMyServices  
 {  
   static void Main()  
   {  
     // Play a sound with the Audio class:  
     Audio myAudio = new Audio();  
     Console.WriteLine("Playing sound...");  
     myAudio.Play(@"c:\WINDOWS\Media\chimes.wav");  
     // Display time information with the Clock class:  
     Clock myClock = new Clock();  
     Console.Write("Current day of the week: ");  
     Console.WriteLine(myClock.LocalTime.DayOfWeek);  
     Console.Write("Current date and time: ");  
     Console.WriteLine(myClock.LocalTime);  
     // Display machine information with the Computer class:  
     Computer myComputer = new Computer();  
     Console.WriteLine("Computer name: " + myComputer.Name);  
     if (myComputer.Network.IsAvailable)  
     {  
       Console.WriteLine("Computer is connected to network.");  
     }  
     else  
     {  
       Console.WriteLine("Computer is not connected to network.");  
     }  
   }  
 }

Implementing IEnumerator & IEnumerable interfaces to a collection class to iterate using foreach statement

2010-02-20T01:16:00.001-08:00

 // tokens2.cs  
 using System;  
 using System.Collections;  
 public class Tokens : IEnumerable  
 {  
   private string[] elements;  
   Tokens(string source, char[] delimiters)  
   {  
     elements = source.Split(delimiters);  
   }  
   // IEnumerable Interface Implementation:  
   public TokenEnumerator GetEnumerator() // non-IEnumerable version  
   {  
     return new TokenEnumerator(this);  
   }  
   IEnumerator IEnumerable.GetEnumerator() // IEnumerable version  
   {  
     return (IEnumerator)new TokenEnumerator(this);  
   }  
   // Inner class implements IEnumerator interface:  
   public class TokenEnumerator : IEnumerator  
   {  
     private int position = -1;  
     private Tokens t;  
     public TokenEnumerator(Tokens t)  
     {  
       this.t = t;  
     }  
     public bool MoveNext()  
     {  
       if (position < t.elements.Length - 1)  
       {  
         position++;  
         return true;  
       }  
       else  
       {  
         return false;  
       }  
     }  
     public void Reset()  
     {  
       position = -1;  
     }  
     public string Current // non-IEnumerator version: type-safe  
     {  
       get  
       {  
         return t.elements[position];  
       }  
     }  
     object IEnumerator.Current // IEnumerator version: returns object  
     {  
       get  
       {  
         return t.elements[position];  
       }  
     }  
   }  
   // Test Tokens, TokenEnumerator  
   static void Main()  
   {  
     Tokens f = new Tokens("This is a well-done program.",  
       new char[] { ' ', '-' });  
     foreach (string item in f) // try changing string to int  
     {  
       Console.WriteLine(item);  
     }  
     Console.ReadLine();  
   }  
 }  
 /*  
 Output:  
 This  
 is  
 a  
 well  
 done  
 program.  
  */

Method versioning in derived and base class using “override” and “new” keywords.

2010-02-20T00:35:00.001-08:00

 using System;  
 public class MyBase  
 {  
   public virtual string Meth1()  
   {  
     return "MyBase-Meth1";  
   }  
   public virtual string Meth2()  
   {  
     return "MyBase-Meth2";  
   }  
   public virtual string Meth3()  
   {  
     return "MyBase-Meth3";  
   }  
 }  
 class MyDerived : MyBase  
 {  
   // Overrides the virtual method Meth1 using the override keyword:  
   public override string Meth1()  
   {  
     return "MyDerived-Meth1";  
   }  
   // Explicitly hide the virtual method Meth2 using the new  
   // keyword:  
   public new string Meth2()  
   {  
     return "MyDerived-Meth2";  
   }  
   // Because no keyword is specified in the following declaration  
   // a warning will be issued to alert the programmer that   
   // the method hides the inherited member MyBase.Meth3():  
   public string Meth3()  
   {  
     return "MyDerived-Meth3";  
   }  
   public static void Main()  
   {  
     MyDerived mD = new MyDerived();  
     MyBase mB = (MyBase)mD;  
     MyBase mBn = new MyBase();  
     Console.WriteLine("Base Class");  
     System.Console.WriteLine(mBn.Meth1());  
     System.Console.WriteLine(mBn.Meth2());  
     System.Console.WriteLine(mBn.Meth3());  
     Console.WriteLine("---------------------");  
     Console.WriteLine("Derived Class");  
     System.Console.WriteLine(mD.Meth1());  
     System.Console.WriteLine(mD.Meth2());  
     System.Console.WriteLine(mD.Meth3());  
     Console.WriteLine("---------------------");  
     Console.WriteLine("Derived Class casted to base class");  
     System.Console.WriteLine(mB.Meth1());  
     System.Console.WriteLine(mB.Meth2());  
     System.Console.WriteLine(mB.Meth3());  
     Console.ReadLine();  
   }  
 }  
 /*  
 Output:  
 Base Class  
 MyBase-Meth1  
 MyBase-Meth2  
 MyBase-Meth3  
 ---------------------  
 Derived Class  
 MyDerived-Meth1  
 MyDerived-Meth2  
 MyDerived-Meth3  
 ---------------------  
 Derived Class casted to base class  
 MyDerived-Meth1  
 MyBase-Meth2  
 MyBase-Meth3  
 */

Indexers: Changing the word and characters occurrences in a document

2010-02-19T23:49:00.001-08:00

 // indexedproperty.cs  
 using System;  
 public class Document  
 {  
   // Type allowing the document to be viewed like an array of words:  
   public class WordCollection  
   {  
     readonly Document document; // The containing document  
     internal WordCollection(Document d)  
     {  
       document = d;  
     }  
     // Helper function -- search character array "text", starting at  
     // character "begin", for word number "wordCount." Returns false  
     // if there are less than wordCount words. Sets "start" and  
     // length" to the position and length of the word within text:  
     private bool GetWord(char[] text, int begin, int wordCount,   
                     out int start, out int length)   
     {   
       int end = text.Length;  
       int count = 0;  
       int inWord = -1;  
       start = length = 0;   
       for (int i = begin; i <= end; ++i)   
       {  
         bool isLetter = i < end && Char.IsLetterOrDigit(text[i]);  
         if (inWord >= 0)   
         {  
           if (!isLetter)   
           {  
             if (count++ == wordCount)   
             {  
               start = inWord;  
               length = i - inWord;  
               return true;  
             }  
             inWord = -1;  
           }  
         }  
         else   
         {  
           if (isLetter)  
             inWord = i;  
         }  
       }  
       return false;  
     }  
     // Indexer to get and set words of the containing document:  
     public string this[int index]   
     {  
       get   
       {   
         int start, length;  
         if (GetWord(document.TextArray, 0, index, out start,   
                              out length))  
           return new string(document.TextArray, start, length);  
         else  
           throw new IndexOutOfRangeException();  
       }  
       set   
       {  
         int start, length;  
         if (GetWord(document.TextArray, 0, index, out start,   
                              out length))   
         {  
           // Replace the word at start/length with the   
           // string "value":  
           if (length == value.Length)   
           {  
             Array.Copy(value.ToCharArray(), 0,   
                  document.TextArray, start, length);  
           }  
           else   
           {  
             char[] newText =   
               new char[document.TextArray.Length +   
                       value.Length - length];  
             Array.Copy(document.TextArray, 0, newText,   
                             0, start);  
             Array.Copy(value.ToCharArray(), 0, newText,   
                        start, value.Length);  
             Array.Copy(document.TextArray, start + length,  
                   newText, start + value.Length,  
                  document.TextArray.Length - start  
                               - length);  
             document.TextArray = newText;  
           }  
         }            
         else  
           throw new IndexOutOfRangeException();  
       }  
     }  
     // Get the count of words in the containing document:  
     public int Count   
     {  
       get   
       {   
         int count = 0, start = 0, length = 0;  
         while (GetWord(document.TextArray, start + length, 0,   
                        out start, out length))  
           ++count;  
         return count;   
       }  
     }  
   }  
   // Type allowing the document to be viewed like an "array"   
   // of characters:  
   public class CharacterCollection  
   {  
     readonly Document document; // The containing document  
     internal CharacterCollection(Document d)  
     {  
      document = d;   
     }  
     // Indexer to get and set characters in the containing document:  
     public char this[int index]   
     {  
       get   
       {   
         return document.TextArray[index];   
       }  
       set   
       {   
         document.TextArray[index] = value;   
       }  
     }  
     // Get the count of characters in the containing document:  
     public int Count   
     {  
       get   
       {   
         return document.TextArray.Length;   
       }  
     }  
   }  
   // Because the types of the fields have indexers,   
   // these fields appear as "indexed properties":  
   public readonly WordCollection Words;  
   public readonly CharacterCollection Characters;  
   private char[] TextArray; // The text of the document.   
   public Document(string initialText)  
   {  
     TextArray = initialText.ToCharArray();  
     Words = new WordCollection(this);  
     Characters = new CharacterCollection(this);  
   }  
   public string Text   
   {  
     get   
     {   
       return new string(TextArray);   
     }  
   }  
 }  
 class Test  
 {  
   static void Main()  
   {  
     Document d = new Document(  
       "peter piper picked a peck of pickled peppers. How many pickled peppers did peter piper pick?"  
     );  
     // Change word "peter" to "penelope":  
     for (int i = 0; i < d.Words.Count; ++i)   
     {  
       if (d.Words[i] == "peter")   
         d.Words[i] = "penelope";  
     }  
     // Change character "p" to "P"  
     for (int i = 0; i < d.Characters.Count; ++i)   
     {  
       if (d.Characters[i] == 'p')  
         d.Characters[i] = 'P';  
     }  
     Console.WriteLine(d.Text);  
   }  
 }

Indexers

2010-02-19T23:10:00.001-08:00

 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;  
     }  
   }  
 }  
 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 <= 10; i++)  
     {  
       Console.WriteLine("Element #{0} = {1}", i, b[i]);  
     }  
   }  
 }  

output:

 Element #0 = 0  
 Element #1 = 0  
 Element #2 = 0  
 Element #3 = 256  
 Element #4 = 0  
 Element #5 = 1024  
 Element #6 = 0  
 Element #7 = 0  
 Element #8 = 0  
 Element #9 = 0  
 Element #10 = 0

Number of Command Line Parameters

2010-02-19T22:42:00.001-08:00

 
 using System;  
 public class CommandLine  
 {  
   public static void Main(string[] args)  
   {  
     // The Length property is used to obtain the length of the array.   
     // Notice that Length is a read-only property:  
     Console.WriteLine("Number of command line parameters = {0}",  
      args.Length);  
     for(int i = 0; i < args.Length; i++)  
     {  
       Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]);  
     }  
   }  
 }