public class DynamicXmlObject : DynamicObject
{
    private readonly XElement mElement;
    public DynamicXmlObject(XElement element)
    {
        mElement = element;
    }
}

public override bool TryGetMember(GetMemberBinder binder, out object result)
{
    string propertyName = binder.Name;
    XAttribute attribute = mElement.Attribute(propertyName);
    if (attribute != null)
    {
        result = attribute.Value;
        return true;
    }
    XElement element = mElement.Element(propertyName);
    
    if (element != null)
    {
        if (!element.HasElements)
        {
            result = element.Value;
        }
        else
        {
            result = new DynamicXmlObject(element);
        }
        return true;
    }
    return base.TryGetMember(binder, out result);
}

XElement myXml =
    new XElement("Person",
                 new XElement("Name", "Yossi"),
                 new XElement("Age", 31),
                 new XElement("LastName", "Levi"),
                 new XElement("Address",
                              new XAttribute("City", "Tel Aviv"),
                              new XElement("Street", "Namir Road")));
dynamic person = new DynamicXmlObject(myXml);
string age = person.Age; // 31
string lastName = person.LastName; // Levi
dynamic address = person.Address;
string city = address.City; // Tel Aviv

public override bool TrySetMember(SetMemberBinder binder, object value)
{
    string propertyName = binder.Name;
    if (!(value is DynamicXmlObject))
    {
        mElement.SetElementValue(propertyName, value);
        return true;
    }
    else
    {
        XElement element =
            ((DynamicXmlObject) value).mElement;
        element.Name = propertyName;
        mElement.Add(element);
        return true;
    }
    return base.TrySetMember(binder, value);
}

person.Age = 31;
person.FirstName = "Yossi";
person.LastName = "Levi";
dynamic address = new DynamicXmlObject(newXElement("Address"));
address.City = "Tel Aviv";
address.Street = "Namir Road";
person.Address = address;

ExpandoObject expando = new ExpandoObject();
dynamic dynamicExpando = expando;
dynamicExpando.Age = 32;
dynamicExpando.LastName = "Bond";
dynamicExpando.NickName = "James Bond";
dynamicExpando.Job = "Spy";
Console.WriteLine(dynamicExpando.Age); // 32
Console.WriteLine(dynamicExpando.NickName); // James Bond

foreach (KeyValuePair<string,object> propertyNameToValue in expando)
{
    Console.WriteLine("Property {0}: {1}",
                      propertyNameToValue.Key,
                      propertyNameToValue.Value);
}
//Property Age : 32
//Property LastName : Bond
//Property NickName : James Bond
//Property Job : Spy

public class MyDynamicObject : DynamicObject
{
    public override bool TryInvokeMember(InvokeMemberBinder binder,
                                         object[] args,
                                         out object result)
    {
        Console.WriteLine("{0} was called", binder.Name);
        Console.WriteLine(args[0]);
        return base.TryInvokeMember(binder, args, out result);
    }
}

dynamic sample = new MyDynamicObject();
sample.MyMethod("This compiles but throws an exception");

public class DaysEqualityComparer : IEqualityComparer<Days>
{
    public bool Equals(Days x, Days y)
    {
        return (x == y);
    }
    public int GetHashCode(Days obj)
    {
        return (int)obj;
    }
}

Dictionary<Days, string> noBoxingDictionary =
    new Dictionary<Days, string>(new DaysEqualityComparer());

public class EnumEqualityComparer<TEnum> : IEqualityComparer<TEnum>
    where TEnum : struct, IConvertible
{
    public bool Equals(TEnum x, TEnum y)
    {
        return (x == y);
    }
    public int GetHashCode(TEnum obj)
    {
        return (int)obj;
    }
}

public class EnumEqualityComparer<TEnum> : IEqualityComparer<TEnum>
    where TEnum : struct, IConvertible
{
    private Func<TEnum, TEnum, bool> mEqualsMethod;
    private Func<TEnum, int> mGetHashCode;
    public bool Equals(TEnum x, TEnum y)
    {
        return mEqualsMethod(x, y);
    }
    public int GetHashCode(TEnum obj)
    {
        return mGetHashCode(obj);
    }
}

private void InitEqualsMethod()
{
    ParameterExpression parameterX =
        Expression.Parameter(typeof(TEnum),"x");
    ParameterExpression parameterY =
       Expression.Parameter(typeof(TEnum),"y");
    BinaryExpression compare =
       Expression.Equal(parameterX, parameterY);
    Expression<Func<TEnum, TEnum, bool>> lambdaExpression =
       Expression.Lambda<Func<TEnum, TEnum, bool>>
        (compare, parameterX, parameterY);
    mEqualsMethod = lambdaExpression.Compile();
}

private void InitGetHashCodeMethod()
{
    ParameterExpression parameterX =
       Expression.Parameter(typeof(TEnum),"x");
    Type underlyingType = Enum.GetUnderlyingType(typeof(TEnum));
    Expression convertExpression =
       Expression.Convert(parameterX, underlyingType);
    Expression getHashCode =
       Expression.Call(convertExpression,
                        "GetHashCode",
                        Type.EmptyTypes);
    Expression<Func<TEnum, int>> lambdaExpression =
       Expression.Lambda<Func<TEnum,int>>
        (getHashCode, parameterX);
    mGetHashCode = lambdaExpression.Compile();
}

public EnumEqualityComparer()
{
    InitEqualsMethod();
    InitGetHashCodeMethod();
}

public static class EnumComparer<TEnum>
    where TEnum : struct, IConvertible
{
    private static IEqualityComparer<TEnum> mEqualityComparer =
        new EnumEqualityComparer<TEnum>();
    public static IEqualityComparer<TEnum> Comparer
    {
        get
        {
            return mEqualityComparer;
        }
    }
}

public static class EnumDictionary
{
    public static IDictionary<TKey, TValue> Create<TKey, TValue>()
        where TKey : struct, IConvertible
    {
      return new Dictionary<TKey,TValue>(EnumComparer<TKey>.Comparer);
    }
}

IDictionary<Days, string> noBoxingDictionary =
    EnumDictionary.Create<Days,string>();

int five = 5; // 101
int twenty = five << 2; // 10100
int two = five >> 1; // 10

[Flags]
public enum Directions
{
    North = 1,
    South = 2,
    East = 4,
    West = 8
}

[Flags]
public enum Directions
{
    North = 1 << 0,
    South = 1 << 1,
    East = 1 << 2,
    West = 1 << 3
}

[Flags]
public enum Directions
{
    North = 1 << 0,
    South = 1 << 1,
    East = 1 << 2,
    West = 1 << 3,
    NorthEast = North | East,
    SouthEast = South | East
}

public abstract class CarVisitor<T>
{
    public T Visit(CarElement element)
    {
        return InnerVisit((dynamic) element);
    }
    protected abstract T InnerVisit(CarElement element);
}

public abstract class CarVisitor<T>
{
    public T Visit(CarElement element)
    {
        return InnerVisit((dynamic)element);
    }
    protected abstract T InnerVisit(CarElement element);
    protected virtual T InnerVisit(Wheel wheel)
    {
        return InnerVisit((CarElement)wheel);
    }
    protected virtual T InnerVisit(Door door)
    {
        return InnerVisit((CarElement)door);
    }
    protected virtual T InnerVisit(Car car)
    {
        return InnerVisit((CarElement)car);
    }
}

public class MyVisitor : CarVisitor<string>
{
    protected override string InnerVisit(CarElement element)
    {
        return element.GetType().Name;
    }
    protected override string InnerVisit(Wheel wheel)
    {
        return base.InnerVisit(wheel) + " With a diameter of " +
               wheel.Diameter;
    }
}

private string InnerVisit(CarElement element)
{
    return element.GetType().Name;
}
private string InnerVisit(Wheel wheel)
{
    return InnerVisit((CarElement)wheel) + " With a diameter of " +
       wheel.Diameter;
}

public interface ICarElementVisitor
{
    void Visit(CarElement element);
}

public abstract class CarElement
{
    public abstract void Accept(ICarElementVisitor carElementVisitor);
}

public class CarXElementVisitor
{
     public XElement ToXElement(CarElement element)
     {
     }
}

public XElement ToXElement(CarElement element)
{
    return InnerToXElement((dynamic) element);
}

private XElement InnerToXElement(Wheel wheel)
{
    return new XElement("Wheel", new XAttribute("Diameter",
                                                wheel.Diameter));
}
private XElement InnerToXElement(Door door)
{
    return new XElement("Door", new XAttribute("Width",
                                               door.Width));
}
private XElement InnerToXElement(Car car)
{
    return new XElement("Car",
                        new XAttribute("Company", car.Company),
                        new XAttribute("Color", car.Color),
                        car.Elements.Select(x => ToXElement(x)));
}
private XElement InnerToXElement(CarElement element)
{
    return new XElement("UnkownElement",
                        new XAttribute("Type",
                                       element.GetType().Name));
}

CarXElementVisitor visitor = new CarXElementVisitor();
Car car = new Car() { Color = "Red", Company = "Ford" };
car.Elements = new CarElement[]
{
    new Wheel() { Diameter = 10 },
    new Door() { Width = 23 }
};
XElement result = visitor.ToXElement(car);
//<Car Company="Ford" Color="Red">
//  <Wheel Diameter="10" />
//  <Door Width="23" />
//</Car>

public interface ICarElementVisitor
{
    void Visit(Wheel wheel);
    void Visit(Door door);
    void Visit(Engine engine);
    void Visit(Body body);
    void Visit(Car car);
}

public abstract void Accept(ICarElementVisitor visitor);

public interface ICarElementVisitor
{
    void Visit(CarElement element);
}

public void Visit(CarElement element)
{
    InnerVisit((dynamic)element);
}

public class CarPhotoShooter : ICarElementVisitor
{
    public void Visit(CarElement element)
    {
        InnerVisit((dynamic)element);
    }
    private void InnerVisit(Wheel wheel)
    {
        Console.WriteLine("Taking a photo of the wheel");
    }
    private void InnerVisit(Door door)
    {
        Console.WriteLine("Taking a photo of the door");
    }
    private void InnerVisit(Car car)
    {
        Console.WriteLine("What a nice car!");
    }
    // ...
    private void InnerVisit(CarElement element)
    {
        Console.WriteLine("Taking a photo of {0}. I don't really know how to shoot this.",
                          element.GetType());
    }
}

ICarElementVisitor visitor = new CarPhotoShooter();
Car car = new Car();
car.Accept(visitor);

public abstract class CarElement
public class Wheel : CarElement
public class Door : CarElement
public class Engine : CarElement
public class Body : CarElement
public class Car : CarElement
{
    public IEnumerable<CarElement> Elements
    {
        get; 
        private set;
    }
}

public abstract class CarElement
{
    public abstract void ShootPhoto();
}

public abstract class CarElement
{
    public abstract void Accept(ICarElementVisitor visitor);
}

public interface ICarElementVisitor
{
    void Visit(Wheel wheel);
    void Visit(Door door);
    void Visit(Engine engine);
    void Visit(Body body);
    void Visit(Car car);
}

public class Wheel : CarElement
{
    public override void Accept(ICarElementVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public class Car : CarElement
{
    public IEnumerable<CarElement> Elements
    {
        get;
        private set;
    }
    public override void Accept(ICarElementVisitor visitor)
    {
        foreach (CarElement element in Elements)
        {
            element.Accept(visitor);
        }
        visitor.Visit(this);
    }
}

public class CarPhotoShooter : ICarElementVisitor
{
    public void Visit(Wheel wheel)
    {
       Console.WriteLine("Taking a photo of the wheel");
    }
    public void Visit(Door door)
    {
       Console.WriteLine("Taking a photo of the door");
    }
    // ...
    public void Visit(Car wheel)
    {
        Console.WriteLine("What a nice car!");
    }
}

ICarElementVisitor visitor = newCarPhotoShooter();
Car car = new Car();
car.Accept(visitor);

public interface ICloneable<T>
{
    T Clone();
}

ICollection<object> result = new List<object>();
foreach (object current in collection)
{
    if (current is ICloneable<>)
    {
        ICloneable<> cloneable = (ICloneable<>) current;
        result.Add(cloneable.Clone());
    }
}

ICollection<object> result = new List<object>();
foreach (object current in collection)
{
    try
    {
        dynamic dynamicCurrent = current;
        result.Add(dynamicCurrent.Clone());
    }
    catch (RuntimeBinderException e)
    {
    }
}

private static T Clone<T>(ICloneable<T> source)
{
    return source.Clone();
}

ICollection<object> result = new List<object>();
foreach (object current in collection)
{
    try
    {
        dynamic dynamicCurrent = current;
        result.Add(Clone(dynamicCurrent));
    }
    catch (RuntimeBinderException e)
    {
    }
}

private static object Clone(object source)
{
    return null;
}

ICollection<object> result = newList<object>();
foreach (object current in collection)
{
    dynamic dynamicCurrent = current;
    object cloneResult = Clone(dynamicCurrent);
    if (cloneResult != null)
    {
        result.Add(cloneResult);
    }
}