The following code demonstrates the creation and initial configuration of an application domain:

using System;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_01
    {
        public static void Main()
        {
            // Instantiate an AppDomainSetup object.
            AppDomainSetup setupInfo = new AppDomainSetup();

            // Configure the application domain setup information.
            setupInfo.ApplicationBase = @"C:MyRootDirectory";
            setupInfo.ConfigurationFile = "MyApp.config";
            setupInfo.PrivateBinPath = "bin;plugins;external";

            // Create a new application domain passing null as the evidence
            // argument. Remember to save a reference to the new AppDomain as
            // this cannot be retrieved any other way.
            AppDomain newDomain =
                AppDomain.CreateDomain("My New AppDomain",null, setupInfo);

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

The following example highlights (in bold) the fundamental difference between creating classes that are passed by value (Recipe03_02MBV) and those passed by reference (Recipe03_02MBR). The code creates a new application domain and instantiates two remotable objects in it (discussed further in recipe 3-7). However, because the Recipe03_02MBV object is an MBV object, when it is created in the new application domain, it is serialized, passed across the application domain boundary, and deserialized as a new independent object in the caller's application domain. Therefore, when the code retrieves the name of the application domain hosting each object, Recipe03_02MBV returns the name of the main application domain, and Recipe03_02MBR returns the name of the new application domain in which it was created.

using System;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    // Declare a class that is passed by value.
    [Serializable]
    public class Recipe03_02MBV
    {

public string HomeAppDomain
        {
            get
            {
                return AppDomain.CurrentDomain.FriendlyName;
            }
        }
    }

    // Declare a class that is passed by reference.
    public class Recipe03_02MBR: MarshalByRefObject
    {
        public string HomeAppDomain
        {
            get
            {
                return AppDomain.CurrentDomain.FriendlyName;
            }
        }
    }

    public class Recipe03_02
    {
        public static void Main(string[] args)
        {
            // Create a new application domain.
            AppDomain newDomain =
                AppDomain.CreateDomain("My New AppDomain");

            // Instantiate an MBV object in the new application domain.
            Recipe03_02MBV mbvObject =
                (Recipe03_02MBV)newDomain.CreateInstanceFromAndUnwrap(
                    "Recipe03-02.exe",
                    "Apress.VisualCSharpRecipes.Chapter03.Recipe03_02MBV");

            // Instantiate an MBR object in the new application domain.
            Recipe03_02MBR mbrObject =
                (Recipe03_02MBR)newDomain.CreateInstanceFromAndUnwrap(
                    "Recipe03-02.exe",
                    "Apress.VisualCSharpRecipes.Chapter03.Recipe03_02MBR");

            // Display the name of the application domain in which each of
            // the objects is located.
            Console.WriteLine("Main AppDomain = {0}",
                AppDomain.CurrentDomain.FriendlyName);
            Console.WriteLine("AppDomain of MBV object = {0}",
                mbvObject.HomeAppDomain);
            Console.WriteLine("AppDomain of MBR object = {0}",
                mbrObject.HomeAppDomain);

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

The following code contains some simple methods that demonstrate how to wrap and unwrap a System.Data.DataSet using an ObjectHandle:

using System;
using System.Data;
using System.Runtime.Remoting;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_03
    {
        // A method to wrap a DataSet.
        public static ObjectHandle WrapDataSet(DataSet ds)
        {
            // Wrap the DataSet.
            ObjectHandle objHandle = new ObjectHandle(ds);

            // Return the wrapped DataSet.
            return objHandle;
        }

        // A method to unwrap a DataSet.
        public static DataSet UnwrapDataSet(ObjectHandle handle)
        {
            // Unwrap the DataSet.
            DataSet ds = (System.Data.DataSet)handle.Unwrap();

            // Return the wrapped DataSet.
            return ds;
        }

        public static void Main()
        {
            DataSet ds = new DataSet();
            Console.WriteLine(ds.ToString());

            ObjectHandle oh = WrapDataSet(ds);
            DataSet ds2 = UnwrapDataSet(oh);
            Console.WriteLine(ds2.ToString());

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

The following code demonstrates various forms of the Load and LoadFrom methods. Notice that unlike the Load method, LoadFrom requires you to specify the extension of the assembly file.

using System;
using System.Reflection;
using System.Globalization;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_05
    {
        public static void ListAssemblies()
        {
            // Get an array of the assemblies loaded into the current
            // application domain.
            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();

            foreach (Assembly a in assemblies)
            {
                Console.WriteLine(a.GetName());
            }
        }

        public static void Main()
        {
            // List the assemblies in the current application domain.
            Console.WriteLine("**** BEFORE ****");
            ListAssemblies();

            // Load the System.Data assembly using a fully qualified display name.
            string name1 = "System.Data,Version=2.0.0.0," +
                "Culture=neutral,PublicKeyToken=b77a5c561934e089";
            Assembly a1 = Assembly.Load(name1);

// Load the System.Xml assembly using an AssemblyName.
            AssemblyName name2 = new AssemblyName();
            name2.Name = "System.Xml";
            name2.Version = new Version(2, 0, 0, 0);
            name2.CultureInfo = new CultureInfo("");    //Neutral culture.
            name2.SetPublicKeyToken(
                new byte[] {0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89});
            Assembly a2 = Assembly.Load(name2);

            // Load the SomeAssembly assembly using a partial display name.
            Assembly a3 = Assembly.Load("SomeAssembly");

            // Load the assembly named c:sharedMySharedAssembly.dll.
            Assembly a4 = Assembly.LoadFrom(@"c:sharedMySharedAssembly.dll");

            // List the assemblies in the current application domain.
            Console.WriteLine("

**** AFTER ****");
            ListAssemblies();

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

The following code demonstrates how to use the ExecuteAssembly method to load and run an assembly. The Recipe03-06 class creates an AppDomain and executes itself in that AppDomain using the ExecuteAssembly method. This results in two copies of the Recipe03-06 assembly loaded into two different application domains.

using System;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_06
    {
        public static void Main(string[] args)
        {
            // For the purpose of this example, if this assembly is executing
            // in an AppDomain with the friendly name "NewAppDomain", do not
            // create a new AppDomain. This avoids an infinite loop of
            // AppDomain creation.
            if (AppDomain.CurrentDomain.FriendlyName != "NewAppDomain")
            {
                // Create a new application domain.
                AppDomain domain = AppDomain.CreateDomain("NewAppDomain");

                // Execute this assembly in the new application domain and
                // pass the array of command-line arguments.
                domain.ExecuteAssembly("Recipe03-06.exe", args);
            }

            // Display the command-line arguments to the screen prefixed with
            // the friendly name of the AppDomain.
            foreach (string s in args)
            {
                Console.WriteLine(AppDomain.CurrentDomain.FriendlyName + " : " + s);
            }

// Wait to continue.
            if (AppDomain.CurrentDomain.FriendlyName != "NewAppDomain")
            {
                Console.WriteLine("
Main method complete. Press Enter.");
                Console.ReadLine();
            }
        }
    }
}

If you run Recipe03-06 using the following command:

Recipe03-06 Testing AppDomains

you will see that the command-line arguments are listed from both the existing and new application domains:

NewAppDomain : Testing

NewAppDomain : AppDomains

Recipe03-06.exe : Testing

Recipe03-06.exe : AppDomains

The following code demonstrates how to use a simplified controller class named PluginManager. When instantiated in an application domain, PluginManager allows you to instantiate classes that implement the IPlugin interface, start and stop those plug-ins, and return a list of currently loaded plug-ins.

using System;
using System.Reflection;
using System.Collections;

using System.Collections.Generic;
using System.Collections.Specialized;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    // A common interface that all plug-ins must implement.
    public interface IPlugin
    {
        void Start();
        void Stop();
    }

    // A simple IPlugin implementation to demonstrate the PluginManager
    // controller class.
    public class SimplePlugin : IPlugin
    {
        public void Start()
        {
            Console.WriteLine(AppDomain.CurrentDomain.FriendlyName +
                ": SimplePlugin starting...");
        }

        public void Stop()
        {
            Console.WriteLine(AppDomain.CurrentDomain.FriendlyName +
                ": SimplePlugin stopping...");
        }
    }

    // The controller class, which manages the loading and manipulation
    // of plug-ins in its application domain.
    public class PluginManager : MarshalByRefObject
    {
        // A Dictionary to hold keyed references to IPlugin instances.
        private Dictionary<string, IPlugin> plugins =
            new Dictionary<string, IPlugin> ();

        // Default constructor.
        public PluginManager() { }

        // Constructor that loads a set of specified plug-ins on creation.
        public PluginManager(NameValueCollection pluginList)
        {
            // Load each of the specified plug-ins.
            foreach (string plugin in pluginList.Keys)
            {
                this.LoadPlugin(pluginList[plugin], plugin);
            }
        }

        // Load the specified assembly and instantiate the specified

// IPlugin implementation from that assembly.
        public bool LoadPlugin(string assemblyName, string pluginName)
        {
            try
            {
                // Load the named private assembly.
                Assembly assembly = Assembly.Load(assemblyName);

                // Create the IPlugin instance, ignore case.
                IPlugin plugin = assembly.CreateInstance(pluginName, true)
                    as IPlugin;

                if (plugin != null)
                {
                    // Add new IPlugin to ListDictionary.
                    plugins[pluginName] = plugin;

                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch
            {
                // Return false on all exceptions for the purpose of
                // this example. Do not suppress exceptions like this
                // in production code.
                return false;
            }
        }

        public void StartPlugin(string plugin)
        {
            try
            {
                // Extract the IPlugin from the Dictionary and call Start.
                plugins[plugin].Start();
            }
            catch
            {
                // Log or handle exceptions appropriately.
            }
        }

public void StopPlugin(string plugin)
        {
            try
            {
                // Extract the IPlugin from the Dictionary and call Stop.
                plugins[plugin].Stop();
            }
            catch
            {
                // Log or handle exceptions appropriately.
            }
        }

        public ArrayList GetPluginList()
        {
            // Return an enumerable list of plug-in names. Take the keys
            // and place them in an ArrayList, which supports marshal-by-value.
            return new ArrayList(plugins.Keys);
        }
    }

    class Recipe03_07
    {
        public static void Main()
        {
            // Create a new application domain.
            AppDomain domain1 = AppDomain.CreateDomain("NewAppDomain1");

            // Create a PluginManager in the new application domain using
            // the default constructor.
            PluginManager manager1 =
                (PluginManager)domain1.CreateInstanceAndUnwrap("Recipe03-07",
                "Apress.VisualCSharpRecipes.Chapter03.PluginManager");

            // Load a new plugin into NewAppDomain1.
            manager1.LoadPlugin("Recipe03-07",
                "Apress.VisualCSharpRecipes.Chapter03.SimplePlugin");

            // Start and stop the plug-in in NewAppDomain1.
            manager1.StartPlugin(
                "Apress.VisualCSharpRecipes.Chapter03.SimplePlugin");
            manager1.StopPlugin(
                "Apress.VisualCSharpRecipes.Chapter03.SimplePlugin");

            // Create a new application domain.
            AppDomain domain2 = AppDomain.CreateDomain("NewAppDomain2");

            // Create a ListDictionary containing a list of plug-ins to create.
            NameValueCollection pluginList = new NameValueCollection();
            pluginList["Apress.VisualCSharpRecipes.Chapter03.SimplePlugin"] =
                "Recipe03-07";

// Create a PluginManager in the new application domain and
            // specify the default list of plug-ins to create.
            PluginManager manager2 = (PluginManager)domain1.CreateInstanceAndUnwrap(
                "Recipe03-07", "Apress.VisualCSharpRecipes.Chapter03.PluginManager",
                true, 0, null, new object[] { pluginList }, null, null);

            // Display the list of plug-ins loaded into NewAppDomain2.
            Console.WriteLine("
Plugins in NewAppDomain2:");
            foreach (string s in manager2.GetPluginList())
            {
                Console.WriteLine(" - " + s);
            }

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

The following example demonstrates how to use the SetData and GetData methods by passing a System.Collections.ArrayList between two application domains. After passing a list of pets to a second application domain for modification, the application displays both the original and modified lists. Notice that the code running in the second application domain does not modify the original list because ArrayList is a pass-by-value type, meaning that the second application domain only has a copy of the original list. (See recipe 3-2 for more details.)

using System;
using System.Reflection;
using System.Collections;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    public class ListModifier
    {

public ListModifier()
        {
            // Get the list from the data cache.
            ArrayList list = (ArrayList)AppDomain.CurrentDomain.GetData("Pets");

            // Modify the list.
            list.Add("turtle");
        }
    }

    class Recipe03_08
    {
        public static void Main()
        {
            // Create a new application domain.
            AppDomain domain = AppDomain.CreateDomain("Test");

            // Create an ArrayList and populate with information.
            ArrayList list = new ArrayList();
            list.Add("dog");
            list.Add("cat");
            list.Add("fish");

            // Place the list in the data cache of the new application domain.
            domain.SetData("Pets", list);

            // Instantiate a ListModifier in the new application domain.
            domain.CreateInstance("Recipe03-08",
                "Apress.VisualCSharpRecipes.Chapter03.ListModifier");

            // Display the contents of the original list.
            Console.WriteLine("Original list contents:");
            foreach (string s in list)
            {
                Console.WriteLine("  - " + s);
            }

            // Get the list and display its contents.
            Console.WriteLine("
Modified list contents:");
            foreach (string s in (ArrayList)domain.GetData("Pets"))
            {
                Console.WriteLine("  - " + s);
            }

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

This code fragment demonstrates the syntax of the Unload method:

// Create a new application domain.
AppDomain newDomain = AppDomain.CreateDomain("New Domain");

// Load assemblies into the application domain.
...

// Unload the new application domain.
AppDomain.Unload(newDomain);

The following example demonstrates how to use typeof and the GetType method to return a Type object for a named type and from existing objects:

using System;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_10
    {
        public static void Main()
        {
            // Obtain type information using the typeof operator.
            Type t1 = typeof(StringBuilder);
            Console.WriteLine(t1.AssemblyQualifiedName);

            // Obtain type information using the Type.GetType method.
            // Case-sensitive, return null if not found.
            Type t2 = Type.GetType("System.String");
            Console.WriteLine(t2.AssemblyQualifiedName);

// Case-sensitive, throw TypeLoadException if not found.
            Type t3 = Type.GetType("System.String", true);
            Console.WriteLine(t3.AssemblyQualifiedName);

            // Case-insensitive, throw TypeLoadException if not found.
            Type t4 = Type.GetType("system.string", true, true);
            Console.WriteLine(t4.AssemblyQualifiedName);

            // Assembly-qualifed type name.
            Type t5 = Type.GetType("System.Data.DataSet,System.Data," +
                "Version=2.0.0.0,Culture=neutral,PublicKeyToken=b77a5c561934e089");
            Console.WriteLine(t5.AssemblyQualifiedName);

            // Obtain type information using the Object.GetType method.
            StringBuilder sb = new StringBuilder();
            Type t6 = sb.GetType();
            Console.WriteLine(t6.AssemblyQualifiedName);

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

The following example demonstrates the various type-testing alternatives described in this recipe:

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_11
    {
        // A method to test whether an object is an instance of a type
        // or a derived type.
        public static bool IsType(object obj, string type)
        {
            // Get the named type, use case-insensitive search, throw
            // an exception if the type is not found.
            Type t = Type.GetType(type, true, true);

            return t == obj.GetType() || obj.GetType().IsSubclassOf(t);
        }

        public static void Main()
        {
            // Create a new StringReader for testing.
            Object someObject = new StringReader("This is a StringReader");

// Test if someObject is a StringReader by obtaining and
            // comparing a Type reference using the typeof operator.
            if (typeof(StringReader) == someObject.GetType())
            {
                Console.WriteLine("typeof: someObject is a StringReader");
            }

            // Test if someObject is, or is derived from, a TextReader
            // using the is operator.
            if (someObject is TextReader)
            {
                Console.WriteLine(
                    "is: someObject is a TextReader or a derived class");
            }

            // Test if someObject is, or is derived from, a TextReader using
            // the Type.GetType and Type.IsSubclassOf methods.
            if (IsType(someObject, "System.IO.TextReader"))
            {
                Console.WriteLine("GetType: someObject is a TextReader");
            }

            // Use the "as" operator to perform a safe cast.
            StringReader reader = someObject as StringReader;
            if (reader != null)
            {
                Console.WriteLine("as: someObject is a StringReader");
            }

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

The following code fragment demonstrates how to instantiate a System.Text.StringBuilder object using reflection and how to specify the initial content for the StringBuilder (a string) and its capacity (an int):

using System;
using System.Text;
using System.Reflection;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_12
    {
        public static StringBuilder CreateStringBuilder()
        {

// Obtain the Type for the StringBuilder class.
            Type type = typeof(StringBuilder);

            // Create a Type[] containing Type instances for each
            // of the constructor arguments - a string and an int.
            Type[] argTypes = new Type[] { typeof(System.String),
              typeof(System.Int32) };

            // Obtain the ConstructorInfo object.
            ConstructorInfo cInfo = type.GetConstructor(argTypes);

            // Create an object[] containing the constructor arguments.
            object[] argVals = new object[] { "Some string", 30 };

            // Create the object and cast it to StringBuilder.
            StringBuilder sb = (StringBuilder)cInfo.Invoke(argVals);

            return sb;
        }
    }
}

The following code demonstrates a factory to instantiate objects that implement the IPlugin interface (first used in recipe 3-7):

using System;
using System.Reflection;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    // A common interface that all plug-ins must implement.
    public interface IPlugin
    {
        string Description { get; set; }
        void Start();
        void Stop();
    }

    // An abstract base class from which all plug-ins must derive.
    public abstract class AbstractPlugin : IPlugin
    {
        // Hold a description for the plug-in instance.
        private string description = "";

        // Sealed property to get the plug-in description.
        public string Description
        {
            get { return description; }
            set { description = value; }
        }

// Declare the members of the IPlugin interface as abstract.
        public abstract void Start();
        public abstract void Stop();
    }

    // A simple IPlugin implementation to demonstrate the PluginFactory class.
    public class SimplePlugin : AbstractPlugin
    {
        // Implement Start method.
        public override void Start()
        {
            Console.WriteLine(Description + ": Starting...");
        }

        // Implement Stop method.
        public override void Stop()
        {
            Console.WriteLine(Description + ": Stopping...");
        }
    }

    // A factory to instantiate instances of IPlugin.
    public sealed class PluginFactory
    {
        public static IPlugin CreatePlugin(string assembly,
            string pluginName, string description)
        {
            // Obtain the Type for the specified plug-in.
            Type type = Type.GetType(pluginName + ", " + assembly);

            // Obtain the ConstructorInfo object.
            ConstructorInfo cInfo = type.GetConstructor(Type.EmptyTypes);

            // Create the object and cast it to StringBuilder.
            IPlugin plugin = cInfo.Invoke(null) as IPlugin;

            // Configure the new IPlugin.
            plugin.Description = description;

            return plugin;
        }

        public static void Main(string[] args)
        {
            // Instantiate a new IPlugin using the PluginFactory.
            IPlugin plugin = PluginFactory.CreatePlugin(
                "Recipe03-12",  // Private assembly name
                "Apress.VisualCSharpRecipes.Chapter03.SimplePlugin",
                  // Plug-in class name.
                "A Simple Plugin"       // Plug-in instance description
            );

// Start and stop the new plug-in.
            plugin.Start();
            plugin.Stop();

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

The following example shows a custom attribute named AuthorAttribute, which you can use to identify the name and company of the person who created an assembly or a class. AuthorAttribute declares a single public constructor that takes a string containing the author's name. This means users of AuthorAttribute must always provide a positional string parameter containing the author's name. The Company property is public, making it an optional named parameter, but the Name property is read-only—no set accessor is declared—meaning that it isn't exposed as a named parameter.

using System;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Assembly,
         AllowMultiple = true, Inherited = false)]

public class AuthorAttribute : System.Attribute
    {
        private string company; // Creator's company
        private string name;    // Creator's name

        // Declare a public constructor.
        public AuthorAttribute(string name)
        {
            this.name = name;
            company = "";
        }

        // Declare a property to get/set the company field.
        public string Company
        {
            get { return company; }
            set { company = value; }
        }

        // Declare a property to get the internal field.
        public string Name
        {
            get { return name; }
        }
    }
}

The following example demonstrates how to decorate types with AuthorAttribute:

using System;

// Declare Allen as the assembly author. Assembly attributes
// must be declared after using statements but before any other.
// Author name is a positional parameter.
// Company name is a named parameter.
[assembly: Apress.VisualCSharpRecipes.Chapter03.Author("Allen",
    Company = "Apress")]

namespace Apress.VisualCSharpRecipes.Chapter03
{
    // Declare a class authored by Allen.
    [Author("Allen", Company = "Apress")]
    public class SomeClass
    {
        // Class implementation.
    }

// Declare a class authored by Lena.
    [Author("Lena")]
    public class SomeOtherClass
    {
        // Class implementation.
    }
}

The following example uses the custom AuthorAttribute declared in recipe 3-13 and applies it to the Recipe03-14 class. The Main method calls the GetCustomAttributes method, filtering the attributes so that the method returns only AuthorAttribute instances. You can safely cast this set of attributes to AuthorAttribute references and access their members without needing to use reflection.

using System;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    [Author("Lena")]
    [Author("Allen", Company = "Apress")]
    class Recipe03_15
    {
        public static void Main()
        {
            // Get a Type object for this class.
            Type type = typeof(Recipe03_15);

            // Get the attributes for the type. Apply a filter so that only
            // instances of AuthorAttribute are returned.
            object[] attrs =
                type.GetCustomAttributes(typeof(AuthorAttribute), true);

            // Enumerate the attributes and display their details.
            foreach (AuthorAttribute a in attrs) {
                Console.WriteLine(a.Name + ", " + a.Company);
            }

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

The following example uses reflection on its own type to enumerate the constructors, methods and properties.

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

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_15
    {
        static void Main(string[] args)
        {

            // Get the type we are interested in.
            Type myType = typeof(Recipe03_15);

            // Get the constructor details.
            Console.WriteLine("
Constructors...");
            foreach (ConstructorInfo constr in myType.GetConstructors())
            {
                Console.Write("Constructor: ");
                // Get the paramters for this constructor.
                foreach (ParameterInfo param in constr.GetParameters())
                {
                    Console.Write("{0} ({1}), ", param.Name, param.ParameterType);
                }
                Console.WriteLine();
            }

            // Get the method details.
            Console.WriteLine("
Methods...");
            foreach (MethodInfo method in myType.GetMethods())
            {
                Console.Write(method.Name);
                // Get the paramters for this constructor.
                foreach (ParameterInfo param in method.GetParameters())
                {
                    Console.Write("{0} ({1}), ", param.Name, param.ParameterType);
                }
                Console.WriteLine();
            }

            // Get the property details.
            Console.WriteLine("
Property...");
            foreach (PropertyInfo property in myType.GetProperties())
            {
                Console.Write("{0} ", property.Name);
                // Get the paramters for this constructor.
                foreach (MethodInfo accessor in property.GetAccessors())
                {
                    Console.Write("{0}, ", accessor.Name);
                }
                Console.WriteLine();
            }

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

        public string MyProperty
        {
            get;
            set;
        }

        public Recipe03_15(string param1, int param2, char param3)
        {

        }
    }
}

The following example calls a method using the InvokeMember method of System.Type and calls it again through the MemberInfo class:

using System;
using System.Reflection;

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_16
    {
        static void Main(string[] args)
        {

            // Create an instance of this type.
            object myInstance = new Recipe03_16();

            // Get the type we are interested in.
            Type myType = typeof(Recipe03_16);

            // Get the method information.
            MethodInfo methodInfo = myType.GetMethod("printMessage",
                new Type[] { typeof(string), typeof(int), typeof(char) });

            // Invoke the method using the instance we created.
            myType.InvokeMember("printMessage", BindingFlags.InvokeMethod,
                null, myInstance, new object[] { "hello", 37, 'c' });

            methodInfo.Invoke(null, BindingFlags.InvokeMethod, null,
                new object[] { "hello", 37, 'c' }, null);

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

        public static void printMessage(string param1, int param2, char param3)
        {
            Console.WriteLine("PrintMessage {0} {1} {2}", param1, param2, param3);
        }
    }
}

Running the program gives the following results:

PrintMessage hello 37 c

PrintMessage hello 37 c

PrintMessage hello 37 c



Main method complete. Press Enter.

The following example calls the same method as in the previous recipe, but does so dynamically:

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

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_17
    {
        static void Main(string[] args)
        {
            // Create an instance of this type.
            dynamic myInstance = new Recipe03_17();

            // Call the method dynamically.
            myInstance.printMessage("hello", 37, 'c'),

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

        public void printMessage(string param1, int param2, char param3)
        {
            Console.WriteLine("PrintMessage {0} {1} {2}", param1, param2, param3);
        }
    }
}

The following example extends the DynamicObject class to create a wrapper around a dictionary such that calls to get and set properties on the dynamic type are mapped to the key/value pairs contained in the dictionary:

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

namespace Apress.VisualCSharpRecipes.Chapter03
{
    class Recipe03_18
    {
        static void Main(string[] args)
        {

            dynamic dynamicDict = new MyDynamicDictionary();
            // Set some properties.
            Console.WriteLine("Setting property values");
            dynamicDict.FirstName = "Adam";
            dynamicDict.LastName = "Freeman";

            // Get some properties.
            Console.WriteLine("
Getting property values");
            Console.WriteLine("Firstname {0}", dynamicDict.FirstName);
            Console.WriteLine("Lastname {0}", dynamicDict.LastName);

            // Call an implemented member.
            Console.WriteLine("
Getting a static property");
            Console.WriteLine("Count {0}", dynamicDict.Count);

            Console.WriteLine("
Getting a non-existent property");
            try
            {
                Console.WriteLine("City {0}", dynamicDict.City);
            }

catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException e)
            {
                Console.WriteLine("Caught exception");
            }

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
    class MyDynamicDictionary : DynamicObject
    {
        private IDictionary<string, object> dict = new Dictionary<string, object>();

        public int Count
        {
            get
            {
                Console.WriteLine("Get request for Count property");
                return dict.Count;
            }
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            Console.WriteLine("Get request for {0}", binder.Name);
            return dict.TryGetValue(binder.Name, out result);
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            Console.WriteLine("Set request for {0}, value {1}", binder.Name, value);
            dict[binder.Name] = value;
            return true;
        }

    }
}

Running the example gives the following results:

Setting property values

Set request for FirstName, value Adam

Set request for LastName, value Freeman



Getting property values

Get request for FirstName

Firstname Adam

Get request for LastName

Lastname Freeman



Getting a static property

Get request for Count property

Count 2



Getting a non-existent property

Get request for City

Caught exception



Main method complete. Press Enter.