Animal[] animalArray = new Animal[2];

ArrayList animalArrayList = new ArrayList();

Cow myCow1 = new Cow("Deirdre");
animalArray[0] = myCow1;
animalArray[1] = new Chicken("Ken");

Cow myCow2 = new Cow("Hayley");
animalArrayList.Add(myCow2);
animalArrayList.Add(new Chicken("Roy"));

animalArrayList[1] = new Chicken("Roy2")

foreach (Animal myAnimal in animalArray)
{
}

foreach (Animal myAnimal in animalArrayList)
{
}

int animalCount = animalArray.Length;

int animalCount2 = animalArrayList.Count;

animalArray[0].Feed();

((Chicken)animalArray[1]).LayEgg();

((Animal)animalArrayList[0]).Feed();
((Chicken)animalArrayList[1]).LayEgg();

animalArrayList.AddRange(animalArray);

int iIndex =  animalArrayList.IndexOf(myCow1);
((Animal)animalArrayList[iIndex]).Feed();

public class Animals : CollectionBase
 {
    public void Add(Animal newAnimal)
    {
        List.Add(newAnimal);
    }

    public void Remove(Animal oldAnimal)
    {
        List.Remove(oldAnimal);
    }

    public Animals()
    {
    }
 }

Animals animalCollection = new Animals();
animalCollection.Add(new Cow("Sarah"));
foreach (Animal myAnimal in animalCollection)
{
}

public class Animals : CollectionBase
{
     ...
     public Animal this[int animalIndex]
     {
         get
         {
             return (Animal)List[animalIndex];
         }
         set
         {
             List[animalIndex] = value;
         }
     }
 }

animalCollection[0].Feed();

public class Animals : DictionaryBase
 {
    public void Add(string newID, Animal newAnimal)
    {
        Dictionary.Add(newID, newAnimal);
    }

    public void Remove(string animalID)
    {
        Dictionary.Remove(animalID);
    }

    public Animals()
    {
    }

    public Animal this[string animalID]
    {
        get
        {
            return (Animal)Dictionary[animalID];
        }
        set
        {
            Dictionary[animalID] = value;
        }
    }
}

foreach (Animal myAnimal in animalCollection)
{
    myAnimal.Feed();
}

foreach (DictionaryEntry myEntry in animalCollection)
{
    ((Animal)myEntry.Value).Feed();
}

yield return value;

public static IEnumerable SimpleList()
{
    yield return "string 1";
    yield return "string 2";
    yield return "string 3";
}

public static void Main(string[] args)
{
    foreach (string item in SimpleList())
    Console.WriteLine(item);

    Console.ReadKey();
}

public new IEnumerator GetEnumerator()
{
    foreach (object animal in Dictionary.Values)
    yield return (Animal)animal;
}

foreach (Animal myAnimal in animalCollection)
{
}

public class Content
{
    public int Val;
}
    
public class Cloner
{
    public Content MyContent = new Content();
    
    public Cloner(int newVal)
    {
        MyContent.Val = newVal;
    }

    public object GetCopy()
    {
        return MemberwiseClone();
    }
}

Cloner mySource = new Cloner(5);
Cloner myTarget = (Cloner)mySource.GetCopy();
int iVal1 = myTarget.MyContent.Val;
mySource.MyContent.Val = 2;
int iVal2 = myTarget.MyContent.Val;

public class Content
{
    public int Val;
}
    
public class Cloner : ICloneable
{
    public Content MyContent = new Content();
    public int iVal = 0;
    
    public Cloner(int newVal)
    {
        MyContent.Val = newVal;
    }
    
    public object Clone()
    {
        Cloner clonedCloner = new Cloner(MyContent.Val);
        clonedCloner.iVal = iVal;
        return clonedCloner;
    }
}

if (myObj.GetType() == typeof(MyComplexClass))
{
    // myObj is an instance of the class MyComplexClass.
}

struct MyStruct
{
    public int Val;
}

MyStruct valType1 = new MyStruct();
valType1.Val = 5;
object refType = valType1;

valType1.Val = 6;
MyStruct valType2 = (MyStruct)refType;

class MyStruct
{
    public int Val;
}

interface IMyInterface
{
}
struct MyStruct : IMyInterface
{
    public int Val;
}

MyStruct valType1 = new MyStruct();
IMyInterface refType = valType1;

MyStruct ValType2 = (MyStruct)refType;

public class AddClass1
{
    public int val;

    public static AddClass3 operator +(AddClass1 op1, AddClass2 op2)
    {
        AddClass3 returnVal = new AddClass3();
        returnVal.val = op1.val + op2.val;
        return returnVal;
    }
}

public class AddClass2
{
    public int val;
}

public class AddClass3
{
    public int val;
}

AddClass1 op1 = new AddClass1();
op1.val = 5;
AddClass2 op2 = new AddClass2();
op2.val = 4;
AddClass3 op3 = op1 + op2;

class Addclass1
{
    public int val;

    public static bool operator >=(Addclass1 op1, Addclass2 op2)
    {
        return op1.val >= op2.val;
    }

    public static bool operator <(Addclass1 op1, Addclass2 op2)
    {
        return !(op1>= op2);
    }

    public static bool operator <=(Addclass1 op1, Addclass2 op2)
    {
        return op1.val <= op2.val;
    }

    public static bool operator >(Addclass1 op1, Addclass2 op2)
    {
        return !(op1 <= op2);
    }
}

class Addclass1
{
    public int val;

    public static bool operator ==(Addclass1 op1, Addclass1 op2)
    {
        return (op1.val == op2.val);
    }

    public static bool operator !=(Addclass1 op1, Addclass1 op2)
    {
        return !(op1== op2);
    }

    public override bool Equals(object obj)
    {
        return val == ((Addclass1)obj).val;
    }

    public override int GetHashCode()
    {
        return val;
    }
}

public class SamplesComparer
{
    public static void Main()
    {
        String str1 = "llegar";
        String str2 = "lugar";
        Console.WriteLine("Comparing \"{0}\" and \"{1}\" ", str1, str2);

        // Uses the DefaultInvariant Comparer.
        Console.WriteLine("   Invariant Comparer: {0}", Comparer.DefaultInvariant.Compare(str1, str2));

        // Uses the Comparer based on the culture "es-ES" (Spanish - Spain, international sort).
        Comparer myCompIntl = new Comparer(new CultureInfo("es-ES", false));
        Console.WriteLine("   International Sort: {0}", myCompIntl.Compare(str1, str2))
    }
}

class Person : IComparable
{
    public string Name;
    public int Age;

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public int CompareTo(object obj)
    {
        if (obj is Person)
        {
            Person otherPerson = obj as Person;
            return this.Age - otherPerson.Age;
        }
        else
        {
            throw new ArgumentException( "Object to compare to is not a Person object.");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Person person1 = new Person("Jim", 30);
        Person person2 = new Person("Bob", 25);

        if (person1.CompareTo(person2) == 0)
        {
            Console.WriteLine("Same age");
        }
        else if (person1.CompareTo(person2) > 0)
        {
            Console.WriteLine("person 1 is Older");
        }
        else
        {
            Console.WriteLine("person1 is Younger");
        }
    }
}

public class PersonComparer : IComparer
{
    public static IComparer Default = new PersonComparer();

    public int Compare(object x, object y)
    {
        if (x is Person && y is Person)
        {
            return Comparer.Default.Compare(((Person)x).Age, ((Person)y).Age);
        }
        else
        {
            throw new ArgumentException(
            "One or both objects to compare are not Person objects.");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Person person1 = new Person("Jim", 30);
        Person person2 = new Person("Bob", 25);

        if (PersonComparer.Default.Compare(person1, person2) == 0)
        {
            Console.WriteLine("Same age");
        }
        else if (PersonComparer.Default.Compare(person1, person2) > 0)
        {
            Console.WriteLine("person 1 is Older");
        }
        else
        {
            Console.WriteLine("person1 is Younger");
        }
    }
}

public class ConvClass1
{
    public int val;

    public static implicit operator ConvClass2(ConvClass1 op1)
    {
        ConvClass2 returnVal = new ConvClass2();
        returnVal.val = op1.val.ToString();
        return returnVal;
    }
}

public class ConvClass2
{
    public string val;

    public static explicit operator ConvClass1(ConvClass2 op1)
    {
        ConvClass1 returnVal = new ConvClass1();
        returnVal.val = Convert.ToInt32(op1.val);
        return returnVal;
    }
}

ConvClass1 op1 = new ConvClass1();
op1.val = 5;
ConvClass2 op2 = op1;

ConvClass2 op1 = new ConvClass2();
op1.val = "6";
ConvClass1 op2 = (ConvClass1)op1;

class ClassA : IMyInterface
{
}
    
class ClassD : ClassA
{
}

ClassA obj1 = new ClassA();
ClassD obj2 = obj1 as ClassD;