This following example demonstrates a serializable Employee class that implements the ISerializable interface. In this example, the Employee class does not serialize the address field if the provided StreamingContext object specifies that the destination of the serialized data is a file. The Main method demonstrates the serialization and deserialization of an Employee object.

using System;
using System.IO;
using System.Text;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    [Serializable]
    public class Employee : ISerializable
    {
        private string name;
        private int age;
        private string address;

        // Simple Employee constructor.
        public Employee(string name, int age, string address)
        {
            this.name = name;
            this.age = age;
            this.address = address;
        }

        // Constructor required to enable a formatter to deserialize an
        // Employee object. You should declare the constructor private or at
        // least protected to ensure it is not called unnecessarily.
        private Employee(SerializationInfo info, StreamingContext context)
        {
            // Extract the name and age of the employee, which will always be
            // present in the serialized data regardless of the value of the
            // StreamingContext.
            name = info.GetString("Name");
            age = info.GetInt32("Age");

            // Attempt to extract the employee's address and fail gracefully
            // if it is not available.
            try
            {
                address = info.GetString("Address");
            }

catch (SerializationException)
            {
                address = null;
            }
        }

        // Public property to provide access to employee's name.
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        // Public property to provide access to employee's age.
        public int Age
        {
            get { return age; }
            set { age = value; }
        }

        // Public property to provide access to employee's address.
        // Uses lazy initialization to establish address because
        // a deserialized object will not have an address value.
        public string Address
        {
            get
            {
                if (address == null)
                {
                    // Load the address from persistent storage.
                    // In this case, set it to an empty string.
                    address = String.Empty;
                }
                return address;
            }

            set
            {
                address = value;
            }
        }

        // Declared by the ISerializable interface, the GetObjectData method
        // provides the mechanism with which a formatter obtains the object
        // data that it should serialize.
        public void GetObjectData(SerializationInfo inf, StreamingContext con)
        {
            // Always serialize the employee's name and age.
            inf.AddValue("Name", name);
            inf.AddValue("Age", age);

// Don't serialize the employee's address if the StreamingContext
            // indicates that the serialized data is to be written to a file.
            if ((con.State & StreamingContextStates.File) == 0)
            {
                inf.AddValue("Address", address);
            }
        }

        // Override Object.ToString to return a string representation of the
        // Employee state.
        public override string ToString()
        {
            StringBuilder str = new StringBuilder();

            str.AppendFormat("Name: {0}
", Name);
            str.AppendFormat("Age: {0}
", Age);
            str.AppendFormat("Address: {0}
", Address);

            return str.ToString();
        }
    }

    // A class to demonstrate the use of Employee.
    public class Recipe13_01
    {
        public static void Main(string[] args)
        {
            // Create an Employee object representing Roger.
            Employee roger = new Employee("Roger", 56, "London");

            // Display Roger.
            Console.WriteLine(roger);

            // Serialize Roger specifying another application domain as the
            // destination of the serialized data. All data including Roger's
            // address is serialized.
            Stream str = File.Create("roger.bin");
            BinaryFormatter bf = new BinaryFormatter();
            bf.Context =
                new StreamingContext(StreamingContextStates.CrossAppDomain);
            bf.Serialize(str, roger);
            str.Close();

            // Deserialize and display Roger.
            str = File.OpenRead("roger.bin");
            bf = new BinaryFormatter();
            roger = (Employee)bf.Deserialize(str);
            str.Close();
            Console.WriteLine(roger);

// Serialize Roger specifying a file as the destination of the
            // serialized data. In this case, Roger's address is not included
            // in the serialized data.
            str = File.Create("roger.bin");
            bf = new BinaryFormatter();
            bf.Context = new StreamingContext(StreamingContextStates.File);
            bf.Serialize(str, roger);
            str.Close();

            // Deserialize and display Roger.
            str = File.OpenRead("roger.bin");
            bf = new BinaryFormatter();
            roger = (Employee)bf.Deserialize(str);
            str.Close();
            Console.WriteLine(roger);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates various approaches to cloning. The simple class Employee contains only string and int members, and so relies on the inherited MemberwiseClone method to create a clone. The Team class contains an implementation of the Clone method that performs a deep copy. The Team class contains a collection of Employee objects, representing a team of people. When you call the Clone method of a Team object, the method creates a clone of every contained Employee object and adds it to the cloned Team object. The Team class provides a private constructor to simplify the code in the Clone method. The use of constructors is a common approach to simplifying the cloning process.

using System;
using System.Text;
using System.Collections.Generic;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    public class Employee : ICloneable
    {
        public string Name;
        public string Title;
        public int Age;

        // Simple Employee constructor.
        public Employee(string name, string title, int age)
        {
            Name = name;
            Title = title;
            Age = age;
        }

        // Create a clone using the Object.MemberwiseClone method because the
        // Employee class contains only string and value types.
        public object Clone()
        {
            return MemberwiseClone();
        }

        // Returns a string representation of the Employee object.
        public override string ToString()
        {
            return string.Format("{0} ({1}) - Age {2}", Name, Title, Age);
        }
    }

    public class Team : ICloneable
    {
        // A List to hold the Employee team members.
        public List<Employee> TeamMembers =
            new List<Employee>();

public Team()
        {
        }

        // Private constructor called by the Clone method to create a new Team
        // object and populate its List with clones of Employee objects from
        // a provided List.
        private Team(List<Employee> members)
        {
            foreach (Employee e in members)
            {
                // Clone the individual employee objects and
                // add them to the List.
                TeamMembers.Add((Employee)e.Clone());
            }
        }

        // Adds an Employee object to the Team.
        public void AddMember(Employee member)
        {
            TeamMembers.Add(member);
        }

        // Override Object.ToString to return a string representation of the
        // entire Team.
        public override string ToString()
        {
            StringBuilder str = new StringBuilder();

            foreach (Employee e in TeamMembers)
            {
                str.AppendFormat("  {0}
", e);
            }

            return str.ToString();
        }

        // Implementation of ICloneable.Clone.
        public object Clone()
        {
            // Create a deep copy of the team by calling the private Team
            // constructor and passing the ArrayList containing team members.
            return new Team(this.TeamMembers);

            // The following command would create a shallow copy of the Team.
            // return MemberwiseClone();
        }
    }

// A class to demonstrate the use of Employee.
    public class Recipe13_02
    {
        public static void Main()
        {
            // Create the original team.
            Team team = new Team();
            team.AddMember(new Employee("Frank", "Developer", 34));
            team.AddMember(new Employee("Kathy", "Tester", 78));
            team.AddMember(new Employee("Chris", "Support", 18));

            // Clone the original team.
            Team clone = (Team)team.Clone();

            // Display the original team.
            Console.WriteLine("Original Team:");
            Console.WriteLine(team);

            // Display the cloned team.
            Console.WriteLine("Clone Team:");
            Console.WriteLine(clone);

            // Make change.
            Console.WriteLine("*** Make a change to original team ***");
            Console.WriteLine(Environment.NewLine);
            team.TeamMembers[0].Name = "Luke";
            team.TeamMembers[0].Title = "Manager";
            team.TeamMembers[0].Age = 44;

            // Display the original team.
            Console.WriteLine("Original Team:");
            Console.WriteLine(team);

            // Display the cloned team.
            Console.WriteLine("Clone Team:");
            Console.WriteLine(clone);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The Newspaper class listed here demonstrates the implementation of both the IComparable and IComparer interfaces. The Newspaper.CompareTo method performs a case-insensitive comparison of two Newspaper objects based on their name fields. A private nested class named AscendingCirculationComparer implements IComparer and compares two Newspaper objects based on their circulation fields. An AscendingCirculationComparer object is obtained using the static Newspaper.CirculationSorter property.

The Main method shown here demonstrates the comparison and sorting capabilities provided by implementing the IComparable and IComparer interfaces. The method creates a System.Collections. ArrayList collection containing five Newspaper objects. Main then sorts the ArrayList twice using the ArrayList.Sort method. The first Sort operation uses the default Newspaper comparison mechanism provided by the IComparable.CompareTo method. The second Sort operation uses an AscendingCirculationComparer object to perform comparisons through its implementation of the IComparer.Compare method.

using System;
using System.Collections.Generic;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    public class Newspaper : IComparable<Newspaper>
    {
        private string name;
        private int circulation;

        private class AscendingCirculationComparer : IComparer<Newspaper>
        {
            // Implementation of IComparer.Compare. The generic definition of
            // IComparer allows us to ensure both arguments are Newspaper
            // objects.
            public int Compare(Newspaper x, Newspaper y)
            {
                // Handle logic for null reference as dictated by the
                // IComparer interface. Null is considered less than
                // any other value.
                if (x == null && y == null) return 0;
                else if (x == null) return −1;
                else if (y == null) return 1;

                // Short-circuit condition where x and y are references
                // to the same object.
                if (x == y) return 0;

                // Compare the circulation figures. IComparer dictates that:
                //      return less than zero if x < y
                //      return zero if x = y
                //      return greater than zero if x > y

// This logic is easily implemented using integer arithmetic.
                return x.circulation - y.circulation;
            }
        }

        // Simple Newspaper constructor.
        public Newspaper(string name, int circulation)
        {
            this.name = name;
            this.circulation = circulation;
        }

        // Declare a read-only property that returns an instance of the
        // AscendingCirculationComparer.
        public static IComparer<Newspaper> CirculationSorter
        {
            get { return new AscendingCirculationComparer(); }
        }

        // Override Object.ToString.
        public override string ToString()
        {
            return string.Format("{0}: Circulation = {1}", name, circulation);
        }

        // Implementation of IComparable.CompareTo. The generic definition
        // of IComparable allows us to ensure that the argument provided
        // must be a Newspaper object. Comparison is based on a
        // case-insensitive comparison of the Newspaper names.
        public int CompareTo(Newspaper other)
        {
            // IComparable dictates that an object is always considered greater
            // than null.
            if (other == null) return 1;

            // Short-circuit the case where the other Newspaper object is a
            // reference to this one.
            if (other == this) return 0;

            // Calculate return value by performing a case-insensitive
            // comparison of the Newspaper names.

            // Because the Newspaper name is a string, the easiest approach
            // is to rely on the comparison capabilities of the String
            // class, which perform culture-sensitive string comparisons.
            return string.Compare(this.name, other.name, true);
        }
    }

// A class to demonstrate the use of Newspaper.
    public class Recipe13_03
    {
        public static void Main()
        {
            List<Newspaper> newspapers = new List<Newspaper>();

            newspapers.Add(new Newspaper("The Echo", 125780));
            newspapers.Add(new Newspaper("The Times", 55230));
            newspapers.Add(new Newspaper("The Gazette", 235950));
            newspapers.Add(new Newspaper("The Sun", 88760));
            newspapers.Add(new Newspaper("The Herald", 5670));

            Console.Clear();
            Console.WriteLine("Unsorted newspaper list:");
            foreach (Newspaper n in newspapers)
            {
                Console.WriteLine("  " + n);
            }

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Newspaper list sorted by name (default order):");
            newspapers.Sort();
            foreach (Newspaper n in newspapers)
            {
                Console.WriteLine("  " + n);
            }

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Newspaper list sorted by circulation:");
            newspapers.Sort(Newspaper.CirculationSorter);
            foreach (Newspaper n in newspapers)
            {
                Console.WriteLine("  " + n);
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

Running the example will produce the results shown here. The first list of newspapers is unsorted, the second is sorted using the IComparable interface, and the third is sorted using a comparer class that implements IComparer.

Unsorted newspaper list:

The Echo: Circulation = 125780

The Times: Circulation = 55230

The Gazette: Circulation = 235950

The Sun: Circulation = 88760

The Herald: Circulation = 5670



Newspaper list sorted by name (default order):

The Echo: Circulation = 125780

The Gazette: Circulation = 235950

The Herald: Circulation = 5670

The Sun: Circulation = 88760

The Times: Circulation = 55230



Newspaper list sorted by circulation:

The Herald: Circulation = 5670

The Times: Circulation = 55230

The Sun: Circulation = 88760

The Echo: Circulation = 125780

The Gazette: Circulation = 235950

The following example demonstrates the creation of an enumerable collection using the IEnumerable<T> and IEnumerator<T> interfaces in conjunction with the yield return and yield break statements. The Team class, which represents a team of people, is a collection of enumerable TeamMember objects.

using System;
using System.Collections.Generic;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    // The TeamMember class represents an individual team member.
    public class TeamMember
    {
        public string Name;
        public string Title;

        // Simple TeamMember constructor.
        public TeamMember(string name, string title)
        {
            Name = name;
            Title = title;
        }

        // Returns a string representation of the TeamMember.
        public override string ToString()
        {
            return string.Format("{0} ({1})", Name, Title);
        }
    }

    // Team class represents a collection of TeamMember objects.
    public class Team
    {
        // A List to contain the TeamMember objects.
        private List<TeamMember> teamMembers = new List<TeamMember>();

// Implement the GetEnumerator method, which will support
        // iteration across the entire team member List.
        public IEnumerator<TeamMember> GetEnumerator()
        {
            foreach (TeamMember tm in teamMembers)
            {
                yield return tm;
            }
        }

        // Implement the Reverse method, which will iterate through
        // the team members in alphabetical order.
        public IEnumerable<TeamMember> Reverse
        {
            get
            {
                for (int c = teamMembers.Count - 1; c >= 0; c--)
                {
                    yield return teamMembers[c];
                }
            }
        }

        // Implement the FirstTwo method, which will stop the iteration
        // after only the first two team members.
        public IEnumerable<TeamMember> FirstTwo
        {
            get
            {
                int count = 0;

                foreach (TeamMember tm in teamMembers)
                {
                    if (count >= 2)
                    {
                        // Terminate the iterator.
                        yield break;
                    }
                    else
                    {
                        // Return the TeamMember and maintain the iterator.
                        count++;
                        yield return tm;
                    }
                }
            }
        }

// Adds a TeamMember object to the Team.
        public void AddMember(TeamMember member)
        {
            teamMembers.Add(member);
        }
    }

    // A class to demonstrate the use of Team.
    public class Recipe13_04
    {
        public static void Main()
        {
            // Create and populate a new Team.
            Team team = new Team();
            team.AddMember(new TeamMember("Curly", "Clown"));
            team.AddMember(new TeamMember("Nick", "Knife Thrower"));
            team.AddMember(new TeamMember("Nancy", "Strong Man"));

            // Enumerate the entire Team using the default iterator.
            Console.Clear();
            Console.WriteLine("Enumerate using default iterator:");
            foreach (TeamMember member in team)
            {
                Console.WriteLine("  " + member.ToString());
            }

            // Enumerate the first two Team members only.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Enumerate using the FirstTwo iterator:");
            foreach (TeamMember member in team.FirstTwo)
            {
                Console.WriteLine("  " + member.ToString());
            }

            // Enumerate the entire Team in reverse order.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Enumerate using the Reverse iterator:");
            foreach (TeamMember member in team.Reverse)
            {
                Console.WriteLine("  " + member.ToString());
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The TeamMember, Team, and TeamMemberEnumerator classes in the following example demonstrate the implementation of a custom iterator using the IEnumerable and IEnumerator interfaces. The TeamMember class represents a member of a team. The Team class, which represents a team of people, is a collection of TeamMember objects. Team implements the IEnumerable interface and declares a separate class, named TeamMemberEnumerator, to provide enumeration functionality. Team implements the Observer pattern using delegate and event members to notify all TeamMemberEnumerator objects if their underlying Team changes. (See recipe 13-11 for a detailed description of the Observer pattern.) The TeamMemberEnumerator class is a private nested class, so you cannot create instances of it other than through the Team.GetEnumerator method.

using System;
using System.Collections;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    // TeamMember class represents an individual team member.
    public class TeamMember
    {
        public string Name;
        public string Title;

// Simple TeamMember constructor.
        public TeamMember(string name, string title)
        {
            Name = name;
            Title = title;
        }

        // Returns a string representation of the TeamMember.
        public override string ToString()
        {
            return string.Format("{0} ({1})", Name, Title);
        }
    }

    // Team class represents a collection of TeamMember objects. Implements
    // the IEnumerable interface to support enumerating TeamMember objects.
    public class Team : IEnumerable
    {
        // TeamMemberEnumerator is a private nested class that provides
        // the functionality to enumerate the TeamMembers contained in
        // a Team collection. As a nested class, TeamMemberEnumerator
        // has access to the private members of the Team class.
        private class TeamMemberEnumerator : IEnumerator
        {
            // The Team that this object is enumerating.
            private Team sourceTeam;

            // Boolean to indicate whether underlying Team has changed
            // and so is invalid for further enumeration.
            private bool teamInvalid = false;

            // Integer to identify the current TeamMember. Provides
            // the index of the TeamMember in the underlying ArrayList
            // used by the Team collection. Initialize to −1, which is
            // the index prior to the first element.
            private int currentMember = −1;

            // Constructor takes a reference to the Team that is the source
            // of enumerated data.
            internal TeamMemberEnumerator(Team team)
            {
                this.sourceTeam = team;

                // Register with sourceTeam for change notifications.
                sourceTeam.TeamChange +=
                    new TeamChangedEventHandler(this.TeamChange);
            }

// Implement the IEnumerator.Current property.
            public object Current
            {
                get
                {
                    // If the TeamMemberEnumerator is positioned before
                    // the first element or after the last element, then
                    // throw an exception.
                    if (currentMember == −1 ||
                        currentMember > (sourceTeam.teamMembers.Count - 1))
                    {
                        throw new InvalidOperationException();
                    }

                    //Otherwise, return the current TeamMember.
                    return sourceTeam.teamMembers[currentMember];
                }
            }

            // Implement the IEnumerator.MoveNext method.
            public bool MoveNext()
            {
                // If underlying Team is invalid, throw exception.
                if (teamInvalid)
                {
                    throw new InvalidOperationException("Team modified");
                }

                // Otherwise, progress to the next TeamMember.
                currentMember++;

                // Return false if we have moved past the last TeamMember.
                if (currentMember > (sourceTeam.teamMembers.Count - 1))
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }

            // Implement the IEnumerator.Reset method.
            // This method resets the position of the TeamMemberEnumerator
            // to the beginning of the TeamMembers collection.
            public void Reset()
            {

// If underlying Team is invalid, throw exception.
                if (teamInvalid)
                {
                    throw new InvalidOperationException("Team modified");
                }

                // Move the currentMember pointer back to the index
                // preceding the first element.
                currentMember = −1;
            }

            // An event handler to handle notifications that the underlying
            // Team collection has changed.
            internal void TeamChange(Team t, EventArgs e)
            {
                // Signal that the underlying Team is now invalid.
                teamInvalid = true;
            }
        }

        // A delegate that specifies the signature that all team change event
        // handler methods must implement.
        public delegate void TeamChangedEventHandler(Team t, EventArgs e);

        // An ArrayList to contain the TeamMember objects.
        private ArrayList teamMembers;

        // The event used to notify TeamMemberEnumerators that the Team
        // has changed.
        public event TeamChangedEventHandler TeamChange;

        // Team constructor.
        public Team()
        {
            teamMembers = new ArrayList();
        }

        // Implement the IEnumerable.GetEnumerator method.
        public IEnumerator GetEnumerator()
        {
            return new TeamMemberEnumerator(this);
        }

        // Adds a TeamMember object to the Team.
        public void AddMember(TeamMember member)
        {
            teamMembers.Add(member);

// Notify listeners that the list has changed.
            if (TeamChange != null)
            {
                TeamChange(this, null);
            }
        }
    }

    // A class to demonstrate the use of Team.
    public class Recipe13_05
    {
        public static void Main()
        {
            // Create a new Team.
            Team team = new Team();
            team.AddMember(new TeamMember("Curly", "Clown"));
            team.AddMember(new TeamMember("Nick", "Knife Thrower"));
            team.AddMember(new TeamMember("Nancy", "Strong Man"));

            // Enumerate the Team.
            Console.Clear();
            Console.WriteLine("Enumerate with foreach loop:");
            foreach (TeamMember member in team)
            {
                Console.WriteLine(member.ToString());
            }

            // Enumerate using a While loop.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Enumerate with while loop:");
            IEnumerator e = team.GetEnumerator();
            while (e.MoveNext())
            {
                Console.WriteLine(e.Current);
            }

            // Enumerate the Team and try to add a Team Member.
            // (This will cause an exception to be thrown.)
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Modify while enumerating:");
            foreach (TeamMember member in team)
            {
                Console.WriteLine(member.ToString());
                team.AddMember(new TeamMember("Stumpy", "Lion Tamer"));
            }

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The example enumerates through the data with foreach and while loops and then attempts to modify the data during an enumeration, resulting in an exception. The output from the example is as follows:

Enumerate with foreach loop:

Curly (Clown)

Nick (Knife Thrower)

Nancy (Strong Man)


Enumerate with while loop:

Curly (Clown)

Nick (Knife Thrower)

Nancy (Strong Man)


Modify while enumerating:

Curly (Clown)

Unhandled Exception: System.InvalidOperationException: Team modified

   at Apress.VisualCSharpRecipes.Chapter13.Team.TeamMemberEnumerator.MoveNext() in

C:UsersAdamDocumentsWorkC# CookbookRepositoryCSHARPRECIPESSourceCode

   Chapter13Recipe13-05Recipe13-05.cs:line 85

   at Apress.VisualCSharpRecipes.Chapter13.Recipe13_05.Main() in C:UsersAdam

    DocumentsWorkC# CookbookRepositoryCSH

ARPRECIPESSourceCodeChapter13Recipe13-05Recipe13-05.cs:line 195

Press any key to continue . . .

The following example demonstrates a common implementation of the Dispose pattern.

using System;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    // Implement the IDisposable interface.
    public class DisposeExample : IDisposable
    {
        // Private data member to signal if the object has already been
        // disposed.
        bool isDisposed = false;

        // Private data member that holds the handle to an unmanaged resource.
        private IntPtr resourceHandle;

        // Constructor.
        public DisposeExample()
        {
            // Constructor code obtains reference to unmanaged resource.
            resourceHandle = default(IntPtr);
        }

        // Destructor/finalizer. Because Dispose calls GC.SuppressFinalize,
        // this method is called by the garbage collection process only if
        // the consumer of the object does not call Dispose as it should.
        ~DisposeExample()
        {
            // Call the Dispose method as opposed to duplicating the code to
            // clean up any unmanaged resources. Use the protected Dispose
            // overload and pass a value of "false" to indicate that Dispose is
            // being called during the garbage collection process, not by
            // consumer code.
            Dispose(false);
        }

        // Public implementation of the IDisposable.Dispose method, called
        // by the consumer of the object in order to free unmanaged resources
        // deterministically.
        public void Dispose()
        {
            // Call the protected Dispose overload and pass a value of "true"
            // to indicate that Dispose is being called by consumer code, not
            // by the garbage collector.
            Dispose(true);

            // Because the Dispose method performs all necessary cleanup,
            // ensure the garbage collector does not call the class destructor.
            GC.SuppressFinalize(this);
        }

// Protected overload of the Dispose method. The disposing argument
        // signals whether the method is called by consumer code (true), or by
        // the garbage collector (false). Note that this method is not part of
        // the IDisposable interface because it has a different signature to the
        // parameterless Dispose method.
        protected virtual void Dispose(bool disposing)
        {
            // Don't try to dispose of the object twice.
            if (!isDisposed)
            {
                // Determine if consumer code or the garbage collector is
                // calling. Avoid referencing other managed objects during
                // finalization.
                if (disposing)
                {
                    // Method called by consumer code. Call the Dispose method
                    // of any managed data members that implement the
                    // IDisposable interface.
                    // ...
                }

                // Whether called by consumer code or the garbage collector,
                // free all unmanaged resources and set the value of managed
                // data members to null.
                // Close(resourceHandle);

                // In the case of an inherited type, call base.Dispose(disposing).
            }

            // Signal that this object has been disposed.
            isDisposed = true;
        }

        // Before executing any functionality, ensure that Dispose has not
        // already been executed on the object.
        public void SomeMethod()
        {
            // Throw an exception if the object has already been disposed.
            if (isDisposed)
            {
                throw new ObjectDisposedException("DisposeExample");
            }

            // Execute method functionality.
            // . . .
        }
    }

    // A class to demonstrate the use of DisposeExample.
    public class Recipe13_06
    {

public static void Main()
        {
            // The using statement ensures the Dispose method is called
            // even if an exception occurs.
            using (DisposeExample d = new DisposeExample())
            {
                // Do something with d.
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example contains a class named Person that implements the IFormattable interface. The Person class contains the title and names of a person and will render the person's name in different formats depending on the format strings provided. The Person class does not make use of regional and cultural settings provided by the formatProvider argument. The Main method demonstrates how to use the formatting capabilities of the Person class.

using System;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    public class Person : IFormattable
    {

// Private members to hold the person's title and name details.
        private string title;
        private string[] names;

        // Constructor used to set the person's title and names.
        public Person(string title, params string[] names)
        {
            this.title = title;
            this.names = names;
        }

        // Override the Object.ToString method to return the person's
        // name using the general format.
        public override string ToString()
        {
            return ToString("G", null);
        }

        // Implementation of the IFormattable.ToString method to return the
        // person's name in different forms based on the format string
        // provided.
        public string ToString(string format, IFormatProvider formatProvider)
        {
            string result = null;

            // Use the general format if none is specified.
            if (format == null) format = "G";

            // The contents of the format string determine the format of the
            // name returned.
            switch (format.ToUpper()[0])
            {
                case 'S':
                    // Use short form - first initial and surname.
                    result = names[0][0] + ". " + names[names.Length - 1];
                    break;

                case 'P':
                    // Use polite form - title, initials, and surname.
                    // Add the person's title to the result.
                    if (title != null && title.Length != 0)
                    {
                        result = title + ". ";
                    }
                    // Add the person's initials and surname.
                    for (int count = 0; count < names.Length; count++)
                    {
                        if (count != (names.Length - 1))
                        {
                            result += names[count][0] + ". ";
                        }

else
                        {
                            result += names[count];
                        }
                    }
                    break;

                case 'I':
                    // Use informal form - first name only.
                    result = names[0];
                    break;

                case 'G':
                default:
                    // Use general/default form - first name and surname.
                    result = names[0] + " " + names[names.Length - 1];
                    break;
            }
            return result;
        }
    }

    // A class to demonstrate the use of Person.
    public class Recipe13_07
    {
        public static void Main()
        {
            // Create a Person object representing a man with the name
            // Mr. Richard Glen David Peters.
            Person person =
                new Person("Mr", "Richard", "Glen", "David", "Peters");

            // Display the person's name using a variety of format strings.
            System.Console.WriteLine("Dear {0:G},", person);
            System.Console.WriteLine("Dear {0:P},", person);
            System.Console.WriteLine("Dear {0:I},", person);
            System.Console.WriteLine("Dear {0},", person);
            System.Console.WriteLine("Dear {0:S},", person);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

When executed, the preceding example produces the following output:

Dear Richard Peters,

Dear Mr. R. G. D. Peters,

Dear Richard,

Dear Richard Peters,

Dear R. Peters,

The following example is a custom exception named CustomException that extends Exception and declares two custom data members: a string named stringInfo and a bool named booleanInfo.

using System;
using System.Runtime.Serialization;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    // Mark CustomException as Serializable.
    [Serializable]
    public sealed class CustomException : Exception
    {
        // Custom data members for CustomException.
        private string stringInfo;
        private bool booleanInfo;

        // Three standard constructors and simply call the base class.
        // constructor (System.Exception).
        public CustomException() : base() { }

        public CustomException(string message) : base(message) { }

        public CustomException(string message, Exception inner)
            : base(message, inner) { }

        // The deserialization constructor required by the ISerialization
        // interface. Because CustomException is sealed, this constructor
        // is private. If CustomException were not sealed, this constructor
        // should be declared as protected so that derived classes can call
        // it during deserialization.
        private CustomException(SerializationInfo info,
            StreamingContext context) : base(info, context)
        {
            // Deserialize each custom data member.
            stringInfo = info.GetString("StringInfo");
            booleanInfo = info.GetBoolean("BooleanInfo");
        }

        // Additional constructors to allow code to set the custom data
        // members.
        public CustomException(string message, string stringInfo,
            bool booleanInfo) : this(message)
        {
            this.stringInfo = stringInfo;
            this.booleanInfo = booleanInfo;
        }

public CustomException(string message, Exception inner,
            string stringInfo, bool booleanInfo): this(message, inner)
        {
            this.stringInfo = stringInfo;
            this.booleanInfo = booleanInfo;
        }

        // Read-only properties that provide access to the custom data members.
        public string StringInfo
        {
            get { return stringInfo; }
        }

        public bool BooleanInfo
        {
            get { return booleanInfo; }
        }

        // The GetObjectData method (declared in the ISerializable interface)
        // is used during serialization of CustomException. Because
        // CustomException declares custom data members, it must override the
        // base class implementation of GetObjectData.
        public override void GetObjectData(SerializationInfo info,
            StreamingContext context)
        {
            // Serialize the custom data members.
            info.AddValue("StringInfo", stringInfo);
            info.AddValue("BooleanInfo", booleanInfo);

            // Call the base class to serialize its members.
            base.GetObjectData(info, context);
        }

        // Override the base class Message property to include the custom data
        // members.
        public override string Message
        {
            get
            {
                string message = base.Message;
                if (stringInfo != null)
                {
                    message += Environment.NewLine +
                        stringInfo + " = " + booleanInfo;
                }
                return message;
            }
        }
    }

// A class to demonstrate the use of CustomException.
    public class Recipe13_08
    {
        public static void Main()
        {
            try
            {
                // Create and throw a CustomException object.
                throw new CustomException("Some error",
                    "SomeCustomMessage", true);
            }
            catch (CustomException ex)
            {
                Console.WriteLine(ex.Message);
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates the implementation of an event argument class named MailReceivedEventArgs. Theoretically, an e-mail server passes instances of the MailReceivedEventArgs class to event handlers in response to the receipt of an e-mail message. The MailReceivedEventArgs class contains information about the sender and subject of the received e-mail message.

using System;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    [Serializable]
    public sealed class MailReceivedEventArgs : EventArgs
    {
        // Private read-only members that hold the event state that is to be
        // distributed to all event handlers. The MailReceivedEventArgs class
        // will specify who sent the received mail and what the subject is.
        private readonly string from;
        private readonly string subject;

        // Constructor, initializes event state.
        public MailReceivedEventArgs(string from, string subject)
        {
            this.from = from;
            this.subject = subject;
        }

        // Read-only properties to provide access to event state.
        public string From { get { return from; } }
        public string Subject { get { return subject; } }
    }

// A class to demonstrate the use of MailReceivedEventArgs.
    public class Recipe13_09
    {
        public static void Main()
        {
            MailReceivedEventArgs args =
                new MailReceivedEventArgs("Danielle", "Your book");

            Console.WriteLine("From: {0}, Subject: {1}", args.From, args.Subject);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates an implementation of the Singleton pattern for a class named SingletonExample:

using System;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    public class SingletonExample
    {
        // A static member to hold a reference to the singleton instance.
        private static SingletonExample instance;

        // A static constructor to create the singleton instance. Another
        // alternative is to use lazy initialization in the Instance property.
        static SingletonExample()
        {
            instance = new SingletonExample();
        }

        // A private constructor to stop code from creating additional
        // instances of the singleton type.
        private SingletonExample() { }

        // A public property to provide access to the singleton instance.
        public static SingletonExample Instance
        {
            get { return instance; }
        }

        // Public methods that provide singleton functionality.
        public void SomeMethod1() { /*..*/ }
        public void SomeMethod2() { /*..*/ }
    }
}

To invoke the functionality of the SingletonExample class, you can obtain a reference to the singleton using the Instance property and then call its methods. Alternatively, you can execute members of the singleton directly through the Instance property. The following code shows both approaches.

// Obtain reference to singleton and invoke methods
SingletonExample s = SingletonExample.Instance;
s.SomeMethod1();

// Execute singleton functionality without a reference
SingletonExample.Instance.SomeMethod2();

The example for this recipe contains a complete implementation of the Event pattern, which includes the following types:

The TemperatureChangeEventArgs class (in the following listing) derives from the class System.EventArgs. The custom event argument class should contain all of the data that the subject needs to pass to its observers when it notifies them of an event. If you do not need to pass data with your event notifications, you do not need to define a new argument class; simply pass EventArgs.Empty or null as the argument when you raise the event. (See recipe 13-9 for details on implementing custom event argument classes.)

namespace Apress.VisualCSharpRecipes.Chapter13
{
    // An event argument class that contains information about a temperature
    // change event. An instance of this class is passed with every event.
    public class TemperatureChangedEventArgs : EventArgs
    {
        // Private data members contain the old and new temperature readings.
        private readonly int oldTemperature, newTemperature;

        // Constructor that takes the old and new temperature values.
        public TemperatureChangedEventArgs(int oldTemp, int newTemp)
        {
            oldTemperature = oldTemp;
            newTemperature = newTemp;
        }

        // Read-only properties provide access to the temperature values.
        public int OldTemperature { get { return oldTemperature; } }
        public int NewTemperature { get { return newTemperature; } }
    }
}

The following code shows the declaration of the TemperatureEventHandler delegate. Based on this declaration, all observers must implement a method (the name is unimportant) that returns void and takes two arguments: an Object instance as the first argument and a TemperatureChangeEventArgs object as the second. During notification, the Object argument is a reference to the Thermostat object that raises the event, and the TemperatureChangeEventArgs argument contains data about the old and new temperature values.

namespace Apress.VisualCSharpRecipes.Chapter13
{
    // A delegate that specifies the signature that all temperature event
    // handler methods must implement.
    public delegate void TemperatureChangedEventHandler(Object sender,
        TemperatureChangedEventArgs args);
}

For the purpose of demonstrating the Observer pattern, the example contains two different observer types: TemperatureAverageObserver and TemperatureChangeObserver. Both classes have the same basic implementation. TemperatureAverageObserver keeps a count of the number of temperature change events and the sum of the temperature values, and displays an average temperature when each event occurs. TemperatureChangeObserver displays information about the change in temperature each time a temperature change event occurs.

The following listing shows the TemperatureChangeObserver and TemperatureAverageObserver classes. Notice that the constructors take references to the Thermostat object that the TemperatureChangeObserver or TemperatureAverageObserver object should observe. When you instantiate an observer, pass it a reference to the subject. The observer must create a delegate instance containing a reference to the observer's event-handler method. To register as an observer, the observer object must then add its delegate instance to the subject using the subject's public event member. This is made even easier with the simplified delegate syntax provided by C#, where it is no longer required to explicitly instantiate a delegate to wrap the listening method.

Once the TemperatureChangeObserver or TemperatureAverageObserver object has registered its delegate instance with the Thermostat object, you need to maintain a reference to this Thermostat object only if you want to stop observing it later on. In addition, you do not need to maintain a reference to the subject, because a reference to the event source is included as the first argument each time the Thermostat object raises an event through the TemperatureChange method.

namespace Apress.VisualCSharpRecipes.Chapter13
{
    // A Thermostat observer that displays information about the change in
    // temperature when a temperature change event occurs.
    public class TemperatureChangeObserver
    {
        // A constructor that takes a reference to the Thermostat object that
        // the TemperatureChangeObserver object should observe.
        public TemperatureChangeObserver(Thermostat t)
        {
            // Create a new TemperatureChangedEventHandler delegate instance and
            // register it with the specified Thermostat.
            t.TemperatureChanged += this.TemperatureChange;
        }

        // The method to handle temperature change events.
        public void TemperatureChange(Object sender,
            TemperatureChangedEventArgs temp)
        {
            Console.WriteLine ("ChangeObserver: Old={0}, New={1}, Change={2}",
                temp.OldTemperature, temp.NewTemperature,
                temp.NewTemperature - temp.OldTemperature);
        }
    }

    // A Thermostat observer that displays information about the average
    // temperature when a temperature change event occurs.
    public class TemperatureAverageObserver
    {

// Sum contains the running total of temperature readings.
        // Count contains the number of temperature events received.
        private int sum = 0, count = 0;

        // A constructor that takes a reference to the Thermostat object that
        // the TemperatureAverageObserver object should observe.
        public TemperatureAverageObserver(Thermostat t)
        {
            // Create a new TemperatureChangedEventHandler delegate instance and
            // register it with the specified Thermostat.
            t.TemperatureChanged += this.TemperatureChange;
        }

        // The method to handle temperature change events.
        public void TemperatureChange(Object sender,
            TemperatureChangedEventArgs temp)
        {
            count++;
            sum += temp.NewTemperature;

            Console.WriteLine
                ("AverageObserver: Average={0:F}", (double)sum / (double)count);
        }
    }
}

Finally, the Thermostat class is the observed object in this Observer (Event) pattern. In theory, a monitoring device sets the current temperature by calling the Temperature property on a Thermostat object. This causes the Thermostat object to raise its TemperatureChange event and send a TemperatureChangeEventArgs object to each observer.

The example contains a Recipe13_11 class that defines a Main method to drive the example. After creating a Thermostat object and two different observer objects, the Main method repeatedly prompts you to enter a temperature. Each time you enter a new temperature, the Thermostat object notifies the listeners, which display information to the console. The following is the code for the Thermostat class:

namespace Apress.VisualCSharpRecipes.Chapter13
{
    // A class that represents a Thermostat, which is the source of temperature
    // change events. In the Observer pattern, a Thermostat object is the
    // subject that Observers listen to for change notifications.
    public class Thermostat
    {
        // Private field to hold current temperature.
        private int temperature = 0;

        // The event used to maintain a list of observer delegates and raise
        // a temperature change event when a temperature change occurs.
        public event TemperatureChangedEventHandler TemperatureChanged;

        // A protected method used to raise the TemperatureChanged event.
        // Because events can be triggered only from within the containing

// type, using a protected method to raise the event allows derived
        // classes to provide customized behavior and still be able to raise
        // the base class event.
        virtual protected void OnTemperatureChanged
            (TemperatureChangedEventArgs args)
        {
            // Notify all observers. A test for null indicates whether any
            // observers are registered.
            if (TemperatureChanged != null)
            {
                TemperatureChanged(this, args);
            }
        }

        // Public property to get and set the current temperature. The "set"
        // side of the property is responsible for raising the temperature
        // change event to notify all observers of a change in temperature.
        public int Temperature
        {
            get { return temperature; }

            set
            {
                // Create a new event argument object containing the old and
                // new temperatures.
                TemperatureChangedEventArgs args =
                    new TemperatureChangedEventArgs(temperature, value);

                // Update the current temperature.
                temperature = value;

                // Raise the temperature change event.
                OnTemperatureChanged(args);
            }
        }
    }

    // A class to demonstrate the use of the Observer pattern.
    public class Recipe13_11
    {
        public static void Main()
        {
            // Create a Thermostat instance.
            Thermostat t = new Thermostat();

            // Create the Thermostat observers.
            new TemperatureChangeObserver(t);
            new TemperatureAverageObserver(t);

// Loop, getting temperature readings from the user.
            // Any noninteger value will terminate the loop.
            do
            {
                Console.WriteLine(Environment.NewLine);
                Console.Write("Enter current temperature: ");

                try
                {
                    // Convert the user's input to an integer and use it to set
                    // the current temperature of the Thermostat.
                    t.Temperature = Int32.Parse(Console.ReadLine());
                }
                catch (Exception)
                {
                    // Use the exception condition to trigger termination.
                    Console.WriteLine("Terminating Observer Pattern Example.");

                    // Wait to continue.
                    Console.WriteLine(Environment.NewLine);
                    Console.WriteLine("Main method complete. Press Enter");
                    Console.ReadLine();
                    return;
                }
            } while (true);
        }
    }
}

The following listing shows the kind of output you should expect if you build and run the previous example. The bold values show your input.

Enter current temperature: 50

ChangeObserver: Old=0, New=50, Change=50

AverageObserver: Average=50.00


Enter current temperature: 20

ChangeObserver: Old=50, New=20, Change=-30

AverageObserver: Average=35.00

Enter current temperature: 40

ChangeObserver: Old=20, New=40, Change=20

AverageObserver: Average=36.67

The following example creates a BlockingCollection using a ConcurrentQueue as the underlying collection. Using the .NET parallel programming features (see Chapter 15 for further information about parallel programming), a single consumer reads items from the collection while four producers add items. The main application thread waits for the producers to add their items and finish, before calling CompleteAdding on the collection. This causes the consumer's foreach method to stop blocking when all of the items are read from the collection.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.Concurrent;
using System.Threading.Tasks;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    class Recipe13_12
    {
        static void Main(string[] args)
        {
            // Create the collection.
            BlockingCollection<string> bCollection
                = new BlockingCollection<string>(new ConcurrentQueue<string>(), 3);

            // Start the consumer.
            Task consumerTask = Task.Factory.StartNew(
                () => performConsumerTasks(bCollection));
            // Start the producers.
            Task producer0 = Task.Factory.StartNew(
                () => performProducerTasks(bCollection, 0));
            Task producer1 = Task.Factory.StartNew(
                () => performProducerTasks(bCollection, 1));
            Task producer2 = Task.Factory.StartNew(
                () => performProducerTasks(bCollection, 2));
            Task producer3 = Task.Factory.StartNew(
                () => performProducerTasks(bCollection, 3));

            // Wait for the producers to complete.
            Task.WaitAll(producer0, producer1, producer2, producer3);
            Console.WriteLine("Producer tasks complete.");

// Indicate that we will not add anything further.
            bCollection.CompleteAdding();

            // Wait for the consumer task to complete.
            consumerTask.Wait();

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }

        static void performConsumerTasks(BlockingCollection<string> collection)
        {
            Console.WriteLine("Consumer started");
            foreach (string collData in collection.GetConsumingEnumerable())
            {
                // Write out the data.
                Console.WriteLine("Consumer got message {0}", collData);
            }
            Console.WriteLine("Consumer completed");
        }

        static void performProducerTasks(BlockingCollection<string> collection,
            int taskID)
        {
            Console.WriteLine("Producer started");
            for (int i = 0; i < 100; i++)
            {
                // Put something into the collection.
                collection.Add("TaskID " + taskID + " Message" + i++);
                Console.WriteLine("Task {0} wrote message {1}", taskID, i);
            }
        }
    }
}

The following example defines a type called MyDataType, which has a constructor and a method called sayHello. The Main method called when the application starts creates an instance of MyDataType using eager initialization, prints out a message simulating performing other tasks, and then calls sayHello. This process is then repeated using lazy initialization. The result is that the constructor is called as soon as the object reference is created using eager initialization, whereas the constructor is not called until the sayHello method is invoked when using lazy initialization.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    class Recipe13_13
    {
        static void Main(string[] args)
        {
            // Create an instance using eager initialization.
            MyDataType eagerInstance = new MyDataType(false);
            Console.WriteLine("...do other things...");
            eagerInstance.sayHello();

            Lazy<MyDataType> lazyInstance = new Lazy<MyDataType>(()
               => new MyDataType(true));
            Console.WriteLine("...do other things...");
            lazyInstance.Value.sayHello();

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }

    class MyDataType
    {
        public MyDataType(bool lazy)
        {
            Console.WriteLine("Initializing MyDataType - lazy instance: {0}", lazy);
        }

        public void sayHello()
        {
            Console.WriteLine("MyDataType Says Hello");
        }
    }
}

The following example defines a method with three optional parameters:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    class Recipe13_14
    {
        static void Main(string[] args)
        {
            printMessage();
            printMessage("Allen");
            printMessage("Bob", "Goodbye");
            printMessage("Joe", "Help", true);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }

        static void printMessage(string from = "Adam", string message = "Hello",

bool urgent = false)

        {

Console.WriteLine("From: {0}, Urgent: {1}, Message: {2}",
                from, message, urgent);
        }
    }
}

The following example defines two extension methods for the string type in the namespace Apress.VisualCSharpRecipes.Chapter13.Extensions:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Apress.VisualCSharpRecipes.Chapter13.Extensions;

namespace Apress.VisualCSharpRecipes.Chapter13.Extensions
{
    public static class MyStringExtentions
    {
        public static string toMixedCase(this String str)
        {
            StringBuilder builder = new StringBuilder(str.Length);
            for (int i = 0; i < str.Length; i += 2)
            {
                builder.Append(str.ToLower()[i]);
                builder.Append(str.ToUpper()[i + 1]);
            }
            return builder.ToString();
        }

        public static int countVowels(this String str)
        {
            char[] vowels = { 'a', 'e', 'i', 'o', 'u' };
            int vowelcount = 0;
            foreach (char c in str)
            {
                if (vowels.Contains(c))
                {
                    vowelcount++;
                }
            }
            return vowelcount;
        }
    }
}

namespace Apress.VisualCSharpRecipes.Chapter13
{
    class Recipe13_15
    {
        static void Main(string[] args)
        {
            string str = "The quick brown fox jumped over the...";
            Console.WriteLine(str.toMixedCase());
            Console.WriteLine("There are {0} vowels", str.countVowels());

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example defines a type. The program Main method creates a dynamic instance of that type and calls countVowels, which exists, and thisMethodDoesNotExist, which does not.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Dynamic;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    class myType
    {
        public myType(string strval)
        {
            str = strval;
        }

        public string str {get; set;}

        public int countVowels()
        {
            char[] vowels = { 'a', 'e', 'i', 'o', 'u' };
            int vowelcount = 0;
            foreach (char c in str)
            {
                if (vowels.Contains(c))
                {
                    vowelcount++;
                }
            }
            return vowelcount;
        }
    }

    class Recipe13_16
    {
        static void Main(string[] args)
        {
            // create a dynamic type
            dynamic dynInstance
                = new myType("The quick brown fox jumped over the...");
            // call the countVowels method
            int vowels = dynInstance.countVowels();
            Console.WriteLine("There are {0} vowels", vowels);
            // call a method that does not exist
            dynInstance.thisMethodDoesNotExist();
        }
    }
}

The code compiles, even though we have called a method that does not exist. When we execute the program, we get the following output:

There are 10 vowels



Unhandled Exception: Microsoft.CSharp.RuntimeBinder.RuntimeBinderException:

'Apress.VisualCSharpRecipes.Chapter13.myType

' does not contain a definition for 'thisMethodDoesNotExist'

at CallSite.Target(Closure , CallSite , Object )

at System.Dynamic.UpdateDelegates.UpdateAndExecuteVoid1[T0](

CallSite site, T0 arg0)

at Apress.VisualCSharpRecipes.Chapter13.Recipe13_16.Main(String[] args) in

C:UsersAdamDocumentsWorkC# CookbookChapter13Recipe13-16

Recipe13-16.cs:line 44

Press any key to continue . . .

The following example is similar to the fragments shown preceding, and contains two types (one derived from the other) and a covariant generic interface. In the Main method, we create an implementation of the interface that is typed using the derived class, and then call a method that requires an implementation of the interface that is typed using the base class.

using System;

namespace Apress.VisualCSharpRecipes.Chapter13
{
    class Recipe13_17
    {
        static void Main(string[] args)
        {
            // Create an implementation of the interface that is typed
            // (and contains) the derived type.
            IMyInterface<DerivedType> variant
                = new ImplClass<DerivedType>(new DerivedType());
            // Call a method that accepts an instance of the interface typed.
            // with the base type - if the interface has been
            // defined with the out keyword
            // This will work; otherwise, the compiler will report an error.m
            processData(variant);
        }

        static void processData(IMyInterface<BaseType> data)
        {
            data.getValue().printMessage();
        }
    }

    class BaseType
    {
        public virtual void printMessage()
        {
            Console.WriteLine("BaseType Message");
        }
    }

    class DerivedType : BaseType
    {
        public override void printMessage()
        {
            Console.WriteLine("DerivedType Message");
        }
    }

public interface IMyInterface<out T>
    {
        T getValue();
    }

    public class ImplClass<T> : IMyInterface<T>
    {
        private T value;
        public ImplClass(T val)
        {
            value = val;
        }

        public T getValue()
        {
            return value;
        }
    }
}