public class Circle : Shape
{
    public Circle(double x, double y, double radius)
    {
        // ...
    }
}

Type circleType = typeof (Circle);
// We get this somehow through reflection
 
ConstructorInfo personConstructorInfo =
    circleType.GetConstructor(new[] {typeof (double), typeof (double), typeof (double)});
 
Func<double, double, double, Shape> circleConstructor =
    (Func<double, double, double, Shape>)
    Delegate.CreateDelegate(typeof (Func<double, double, double, Shape>), personConstructorInfo);

Shape circle = circleConstructor(3, 4, 5);
// Shape circle = new Circle(3, 4, 5);

public static class Constructor
{
    public static TDelegate CreateDelegate<TDelegate>(Type givenType)
    {
        ConstructorInfo requestedConstructor = 
            GetConstructorInfo(givenType, typeof (TDelegate));
 
        ParameterInfo[] parameterInfos = requestedConstructor.GetParameters();
 
        List<ParameterExpression> parameterExpressions =
            new List<ParameterExpression>(parameterInfos.Length);
 
        foreach (ParameterInfo parameterInfo in parameterInfos)
        {
            parameterExpressions.Add
                (Expression.Parameter(parameterInfo.ParameterType,
                                      parameterInfo.Name));
        }
 
        NewExpression constructorCall =
            Expression.New(requestedConstructor,
                           parameterExpressions.ToArray());
 
        Expression<TDelegate> constructorLambda =
            Expression.Lambda<TDelegate>(constructorCall,
                                         parameterExpressions);
 
        return constructorLambda.Compile();
    }
 
    private static ConstructorInfo GetConstructorInfo(Type givenType, Type delegateType)
    {
        MethodInfo invoke = delegateType.GetMethod("Invoke");
       
        ParameterInfo[] constructorParameters = invoke.GetParameters();
       
        Type[] constructorParameterTypes =
            constructorParameters.Select(x => x.ParameterType).ToArray();
 
        ConstructorInfo requestedConstructor = 
            givenType.GetConstructor(constructorParameterTypes);
       
        return requestedConstructor;
    }
}

Type circleType = typeof(Circle);
// We get this somehow through reflection
 
Func<double, double, double, Shape> circleConstructor =
    Constructor.CreateDelegate<Func<double, double, double, Shape>>(circleType);
 
for (int i = 0; i <= 10000; i++)
{
    Shape circle = circleConstructor(3, 4, 5);
    // Much faster than 
    //Shape circle = (Shape)Activator.CreateInstance(circleType, 3, 4, 5);
}

public static class Cloner<T>
{
    public static T Clone(T source)
    {
        Type givenType = typeof(T);
        ConstructorInfo constructorInfo =
            givenType.GetConstructor(new Type[0]);
        IEnumerable<PropertyInfo> interestingProperties =
            from property in givenType.GetProperties()
            where property.CanWrite && property.CanRead
            select property;
        T result = (T)constructorInfo.Invoke(null);
        foreach (PropertyInfo interestingProperty in interestingProperties)
        {
            interestingProperty.SetValue(result,
                                   interestingProperty.GetValue(source,null),
                                         null);
        }
        return result;
    }
}

Func<Person, Person> personCloner =
    x => new Person()
             {
                 FirstName = x.FirstName,
                 LastName = x.LastName
             };

Expression<Func<Person, Person>> personCloner =
    x => new Person()
             {
                 FirstName = x.FirstName,
                 LastName = x.LastName
             };

Type personType = typeof (Person);
 
ConstructorInfo constructorInfo = personType.GetConstructor(new Type[0]);
 
PropertyInfo firstNameInfo = 
    personType.GetProperty("FirstName");
 
PropertyInfo lastNameInfo = 
    personType.GetProperty("LastName");
 
ParameterExpression parameterX = Expression.Parameter(personType, "x");
 
Expression<Func<Person, Person>> personClone =
    Expression.Lambda<Func<Person, Person>>(
        Expression.MemberInit(
            Expression.New(constructorInfo, new Expression[0]),
            new MemberBinding[]
                {
                    Expression.Bind(firstNameInfo.GetSetMethod(),
                                    Expression.Property(parameterX, firstNameInfo.GetGetMethod())),
                    Expression.Bind(lastNameInfo.GetSetMethod(),
                                    Expression.Property(parameterX, lastNameInfo.GetGetMethod()))
                }),
        new ParameterExpression[] {parameterX});

public static class Cloner<T>
{
    private static Func<T, T> mCloner;
 
    public static T Clone(T source)
    {
        if (mCloner == null)
        {
            mCloner = CreateCloneDelegate();
        }
 
        return mCloner(source);
    }
 
    private static Func<T, T> CreateCloneDelegate()
    {
        Type givenType = typeof(T);
 
        ConstructorInfo constructorInfo = 
            givenType.GetConstructor(new Type[0]);
 
        IEnumerable<PropertyInfo> interestingProperties =
            from property in givenType.GetProperties()
            where property.CanWrite && property.CanRead
            select property;
 
        ParameterExpression parameterX = 
            Expression.Parameter(givenType, "x");
 
        MemberAssignment[] memberBindings =
            (from property in interestingProperties
             let getter = Expression.Property(parameterX, property.GetGetMethod())
             let setter = Expression.Bind(property.GetSetMethod(), getter)
             select setter).ToArray();
 
        Expression<Func<T, T>> cloner =
            Expression.Lambda<Func<T, T>>(
                Expression.MemberInit(
                    Expression.New(constructorInfo, new Expression[0]),
                    memberBindings),
                new ParameterExpression[] { parameterX });
 
        return cloner.Compile();
    }
}

Person person =
    new Person
        {
            FirstName = "Maor",
            LastName = "C",
            Age = 37
        };
Person clonedPerson = Cloner<Person>.Clone(person);

public static class Cloner
{
    public static T Clone<T>(T source)
    {
        return Cloner<T>.Clone(source);
    }
}

Person person =
    new Person
        {
            FirstName = "Maor",
            LastName = "C",
            Age = 37
        };
Person clonedPerson = Cloner.Clone(person);

public class Person
{
    public Person(Person source)
    {
    }
    public Person(string name)
    {
    }
}

object person =
    Activator.CreateInstance(typeof (Person), new object[] {null});

public class Circle : Shape, IColored
{
    public Circle()
    {
    }
    public Circle(IColored source)
    {
    }
    public Circle(Shape source)
    {
    }
}
Circle myCircle =
    (Circle)Activator.CreateInstance(typeof (Circle), new Circle());

ConstructorInfo stringConstructorInfo =
    typeof (Person).GetConstructor(new Type[] {typeof (string)});
Person myPerson =
    (Person)stringConstructorInfo.Invoke(new object[] {null});

public static class MyStaticClass<T>
{
    private static object mMyObject = new object();
    public static object MyObject
    {
        get
        {
            return mMyObject;
        }
    }
}

if (MyStaticClass<string>.MyObject == MyStaticClass<int>.MyObject)
{
    // false
}

public static class EmptyArray<T>
{
    private static readonly T[] mInstance = new T[] {};
    public static T[] Instance
    {
        get
        {
            return mInstance;
        }
    }
}

int[] emptyIntArray = EmptyArray<int>.Instance;
string[] emptyStringArray = EmptyArray<string>.Instance;
string[] anotherEmptyStringArray = EmptyArray<string>.Instance;
if (emptyStringArray == anotherEmptyStringArray)
{
    // true
}

public static class Factory<T>
{
    private static Func<T> mBuilder;
    public static void RegisterBuilder(Func<T> builder)
    {
        if (mBuilder != null)
        {
            throw new ArgumentException("Builder was already initialized.",
                                        "builder");
        }
        mBuilder = builder;
    }
    public static T Build()
    {
        if (mBuilder == null)
        {
            throw new ArgumentException("Builder wasn't initialized.");
        }
        return mBuilder();
    }
}

Factory<Shape>.RegisterBuilder(() => new Triangle());
Shape shape = Factory<Shape>.Build(); // Triangle

Expression<Func<Person, int>> myProperty =
    (Person x) => x.Age;
MemberExpression myPropertyBody =
    (MemberExpression) myProperty.Body;
PropertyInfo ageInfo = (PropertyInfo) myPropertyBody.Member;
// Same result as PropertyInfo ageInfo = typeof(Person).GetProperty("Age");

public static PropertyInfo GetProperty<TSource, TResult>(Expression<Func<TSource, TResult>> expression)
{
    MemberExpression expressionBody =
        expression.Body as MemberExpression;
    if (expressionBody == null)
    {
        return null;
    }
    return expressionBody.Member as PropertyInfo;
}

PropertyInfo ageInfo = GetProperty((Person x) => x.Age);
// Same result as PropertyInfo ageInfo = typeof(Person).GetProperty("Age");

public static MethodInfo GetMethod<TSource, TResult>(Expression<Func<TSource, TResult>> expression)
{
    MethodCallExpression expressionBody =
        expression.Body as MethodCallExpression;
    if (expressionBody == null)
    {
        return null;
    }
    return expressionBody.Method;
}

public class Circle : Shape
{
    public Square GetBoundedSquare(double angle, Color color)
    {
        // ...
    }
}

MethodInfo getBoundedSquareInfo =
    GetMethod((Circle x) => x.GetBoundedSquare(default(int), default(Color)));
// Same result as MethodInfo getBoundedSquareInfo = typeof(Circle).GetMethod("GetBoundedSquare");

MethodInfo getBoundedSquareInfo =
    GetMethod((Circle x) => x.GetBoundedSquare(3, Color.Red));
// Same result as MethodInfo getBoundedSquareInfo = typeof(Circle).GetMethod("GetBoundedSquare");

private static IEnumerable<Expression> GetAllExpressions(IEnumerable<double> numbers)
{
    if (numbers.Count() == 1)
    {
        yield return Expression.Constant(numbers.First());
    }
    foreach (double number in numbers)
    {
        IEnumerable<Expression> expressionsWithoutNumber =
            GetAllExpressions(numbers.Except(new[] {number}));
        foreach (Expression expression in expressionsWithoutNumber)
        {
            yield return Expression.Add(Expression.Constant(number), expression);
            yield return Expression.Subtract(Expression.Constant(number), expression);
            yield return Expression.Multiply(Expression.Constant(number), expression);
            yield return Expression.Divide(Expression.Constant(number), expression);
        }
    }
}

private static IEnumerable<Expression> GetAllExpressions(IEnumerable<double> numbers)
{
    if (numbers.Count() == 1)
    {
        yield return Expression.Constant(numbers.FirstOrDefault());
    }
    foreach (double number in numbers)
    {
        var expressionsWithoutNumber =
            GetAllExpressions(numbers.Except(new[] {number}));
        foreach (Expression expression in expressionsWithoutNumber)
        {
            yield return Expression.Add(Expression.Constant(number), expression);
            yield return Expression.Subtract(Expression.Constant(number), expression);
            yield return Expression.Multiply(Expression.Constant(number), expression);
            Func<double> denominator =
                Expression.Lambda<Func<double>>(expression).Compile();
            if (denominator() != 0)
            {
                yield return Expression.Divide(Expression.Constant(number), expression);
            }
        }
    }
}

IEnumerable<Expression> expressions =
    GetAllExpressions(new double[] {1, 5, 6, 7});
foreach (Expression currentExpression in expressions)
{
    Expression<Func<double>> currentLambda =
        Expression.Lambda<Func<double>>(currentExpression);
    Func<double> currentDelegate = currentLambda.Compile();
    // We check when the expression represents 21
    if (currentDelegate() == 21) 
    {
        Console.WriteLine("21 = {0}", currentExpression);
    }
}
// 21 = (6 / (1 - (5 / 7)))

Expression<Func<int, int, int>> sumOfSquaresExpression =
    (x, y) => x * x + y * y;
Func<int, int, int> sumOfSquaresFunction =
    sumOfSquaresExpression.Compile();
int fiveSquared = sumOfSquaresFunction(3, 4); // 25

Func<int, int, int> sumOfSquaresFunction =
    (x, y) => x * x + y * y;

Expression<Func<int, int, int>> sumOfSquaresExpression =
    Expression.Lambda<Func<int, int, int>>(
        Expression.Add(
            Expression.Multiply(parameterX, parameterX),
            Expression.Multiply(parameterY, parameterY)),
        new ParameterExpression[] {parameterX, parameterY});
Func<int, int, int> sumOfSquaresFunction =
    sumOfSquaresExpression.Compile();
int fiveSquared = sumOfSquaresFunction(3, 4); // 25

Func<int, int> squareFunction =  x => x*x;
int nine = squareFunction(3); // 9

Func<int, int, int> sumOfSquares = (x, y) => x*x + y*y;
int fiveSquared = sumOfSquares(3, 4); // 25

Expression<Func<int, int, int>> sumOfSquares = (x, y) => x*x + y*y;

ParameterExpression parameter = Expression.Parameter(typeof(int), "x");
ParameterExpression parameter = Expression.Parameter(typeof(int), "y");
Expression<Func<int, int, int>> sumOfSquares =
    Expression.Lambda<Func<int, int, int>>(
        Expression.Add(
            Expression.Multiply(parameterX, parameterX),
            Expression.Multiply(parameterY, parameterY)),
        new ParameterExpression[] { parameterX, parameterY });

IEnumerable<Worker> workers = GetAllWorkersFromDb(); // This is heavy!
IEnumerable<Worker> interestingWorkers =
    from worker in workers
    where worker.Salary > 4000
    select worker;

public static IEnumerable<IEnumerable<T>> GetAllPermutations<T>(IEnumerable<T> collection)
{
    if (!collection.Any())
    {
        // There is exactly one permutation of length 0
        // the empty permutation.
        yield return Enumerable.Empty<T>();
    }
    else
    {
        foreach (T firstElement in collection)
        {
            // firstElement will be the first element
            // of our permutation.
            // We now find all permutations of all
            // elements except him.
            IEnumerable<T> withoutCurrent =
                collection.Except(new[] {firstElement});
            // Get the permutations (using recursive call)
            IEnumerable<IEnumerable<T>> permutationsWithoutCurrent =
                GetAllPermutations(withoutCurrent);
            // Iterate over the permutations of the rest elements.
             foreach (IEnumerable<T> currentPermutation in permutationsWithoutCurrent)
            {
                // Put firstElement as the first element :)
                IEnumerable<T> currentFullPermutation =
                    new[] {firstElement}.Concat(currentPermutation);
                yield return currentFullPermutation;
            }
        }
    }

public class ParentClass
{
    [Cool]
    public virtual void NiceMethod()
    {
    }
}
public class ChildClass : ParentClass
{
    public override void NiceMethod()
    {
        Console.WriteLine("This method is nice!");
    }
}

MethodInfo niceMethodInfo =
    typeof (ChildClass).GetMethod("NiceMethod");
object[] niceMethodInfoAttributes =
    niceMethodInfo.GetCustomAttributes(true);
if (niceMethodInfoAttributes.Length > 0)
{
    // true
}

public class ParentClass
{
    [Cool]
    public virtual string NiceProperty
    {
        get
        {
            return string.Empty;
        }
    }
}
public class ChildClass : ParentClass
{
    public override string NiceProperty
    {
        get
        {
            return "This property is nice!";
        }
    }
}

PropertyInfo nicePropertyInfo =
    typeof (ChildClass).GetProperty("NiceProperty");
object[] nicePropertyInfoAttributes =
    nicePropertyInfo.GetCustomAttributes(true);
if (nicePropertyInfoAttributes.Length > 0)
{
    // false
}

public override object[] GetCustomAttributes(bool inherit)
{
    return CustomAttribute.GetCustomAttributes
         (this,
           typeof (object) as RuntimeType);
}

PropertyInfo nicePropertyInfo =
    typeof (ChildClass).GetProperty("NiceProperty");
object[] nicePropertyInfoAttributes =
    Attribute.GetCustomAttributes(nicePropertyInfo, true);
if (nicePropertyInfoAttributes.Length > 0)
{
    // true
}