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

namespace AnonymousDelegatesSample
{
    public class Book
    {
        public string Title;
        public decimal Price;
    }

    public class Person
    {
        public string Firstname;
        public string Lastname;
        public List<Book> BookList;
        public decimal Discount;
        public DiscountCalculator CalculationMethod;
    }

    public delegate decimal DiscountCalculator(decimal price);

    public class Example
    {
        private decimal CalculateDiscount(decimal price)
        {
            return price * new decimal(0.05);
        }

        public void ShowExample()
        {

            DiscountCalculator default_calc = 
                new DiscountCalculator(CalculateDiscount);
            DiscountCalculator specialcustomer_calc = 
                delegate(decimal price) 
                { 
                    return price * new decimal(0.09); 
                };

            Book book1 = new Book();
            book1.Title = "ASP.NET for dummies";
            book1.Price = new decimal(35.99);

            Book Book2 = new Book();
            Book2.Title = "C# for dummies";
            Book2.Price = new decimal(49.99);

            List<Book> bookList = new List<Book>();
            bookList.Add(book1);
            bookList.Add(Book2);

            List<Person> personList = new List<Person>();

            Person person1 = new Person();
            person1.Firstname = "Norbert";
            person1.Lastname = "Eder";
            person1.BookList = bookList;
            person1.CalculationMethod = specialcustomer_calc;
            personList.Add(person1);

            Person person2 = new Person();
            person2.Firstname = "Alf";
            person2.Lastname = "Dudldei";
            person2.BookList = bookList;
            person2.CalculationMethod = default_calc;
            personList.Add(person2);

            foreach (Person p in personList) 
            {
                decimal price = 0;
                foreach (Book b in p.BookList)
                    price += b.Price;

                p.Discount = p.CalculationMethod(price);

                Console.WriteLine(
                    String.Format("{0} {1}:t {2} discount", 
                        p.Firstname, 
                        p.Lastname, 
                        p.Discount.ToString())); 
            }

            Console.WriteLine("Press any key ...");
            Console.ReadKey();
        }
    }
}

public delegate decimal DiscountCalculator(decimal price);

DiscountCalculator default_calc = 
    new DiscountCalculator(CalculateDiscount);

DiscountCalculator default_calc = 
    new DiscountCalculatprivate decimal CalculateDiscount(decimal price)
{
    return price * new decimal(0.05);
}or(CalculateDiscount);

DiscountCalculator specialcustomer_calc = 
    delegate(decimal price) 
    { 
        return price * new decimal(0.09); 
    };

var htTemp = new Hashtable();

Hashtable htTemp = new Hashtable();

if (!EventLog.SourceExists("TestCategory"))
    EventLog.CreateEventSource("TestCategory", "TestLog");

EventLog evtLog = new EventLog();
evtLog.Source = "TestCategory";
evtLog.WriteEntry("This is a test", EventLogEntryType.Information);

public void MoveDirectory(
    string strSourceDir, 
    string strDestDir, 
    bool bDelSource)
{
    if (Directory.Exists(strSourceDir))
    {
        if (Directory.GetDirectoryRoot(strSourceDir) == 
            Directory.GetDirectoryRoot(strDestDir)) 
        {   
            Directory.Move(strSourceDir, strDestDir);
        }
        else
        {
            try
            {
                CopyDirectory(new DirectoryInfo(strSourceDir), 
                    new DirectoryInfo(strDestDir));
                if (bDelSource)
                    Directory.Delete(strSourceDir, true);
            }
            catch (Exception subEx)
            {
                throw subEx;
            }
        }
    }
}

private void CopyDirectory(
    DirectoryInfo diSourceDir, 
    DirectoryInfo diDestDir)
{
    if (!diDestDir.Exists)
        diDestDir.Create();

    FileInfo[] fiSrcFiles = diSourceDir.GetFiles();

    foreach (FileInfo fiSrcFile in fiSrcFiles)
        fiSrcFile.CopyTo(Path.Combine(diDestDir.FullName, fiSrcFile.Name));

    DirectoryInfo[] diSrcDirectories = diSourceDir.GetDirectories();
    
    foreach (DirectoryInfo diSrcDirectory in diSrcDirectories)
        CopyDirectory(
            diSrcDirectory, 
            new DirectoryInfo(
                Path.Combine(diDestDir.FullName, diSrcDirectory.Name)));
}

public class ObjectGenerator
{
    public T GenerateObject<T>()
    {
        return (T)FormatterServices.GetUninitializedObject(typeof(T));
    }

    public T ActivateObject<T>()
    {
        return (T)Activator.CreateInstance<T>();
    }
}

ObjectGenerator og = new ObjectGenerator();

Stopwatch sw = new Stopwatch();
Console.Write("Generate Object [Formatter]: ");

sw.Start();

for (int i = 0; i < 10000; i++)
{
    TestClass tc = og.GenerateObject<TestClass>();
}

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds);

sw.Reset();

Console.Write("Generate Object [Activator]: ");

sw.Start();

for (int i = 0; i < 10000; i++)
{
    TestClass tc = og.ActivateObject<TestClass>();
}

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds);

Console.ReadKey();

Generate Object [Formatter]: 3
Generate Object [Activator]: 21

public class TestClass
{
    private TestClass() { }

    public string GetMessage()
    {
        return "This is a message";
    }
}

Für dieses Objekt wurde kein parameterloser Konstruktor definiert.

public class Binder : SerializationBinder
{
    public override Type 
        BindToType(string assemblyName, string typeName)
    {
        Type type = null;
        string shortAssem = assemblyName.Split(',')[0];
        Assembly[] assemblies = 
            AppDomain.CurrentDomain.GetAssemblies();

        foreach (Assembly assem in assemblies)
        {
            if (shortAssem == assem.FullName.Split(',')[0])
            {
                type = assem.GetType(typeName);
                break;
            }

        }
        return type;

    }

}