using System;
   
public class CPU {
  public string model;
   
  public CPU(string model) {
    this.model = model;
  }
   
  public void Start() {
    Console.WriteLine(model + " started");
  }
}
   
public class Intel : CPU {
  public bool convertible;
   
  public Intel(string model, bool convertible) : base(model) {
    this.convertible = convertible;
  }
}
   
public class AMD : CPU {
  public bool sidecar;
   
  public AMD(string model, bool sidecar) : base(model) {
    this.sidecar = sidecar;
  }
   
  public void PullWheelie() {
    Console.WriteLine(model + " pulling a wheelie!");
  }
   
}
   
   
class Test {
  public static void Main() {
    Intel myIntel = new Intel("MR2", true);
   
    // cast myIntel to CPU (upcast)
    CPU myCPU = (CPU) myIntel;
   
    Console.WriteLine("myCPU.model = " + myCPU.model);
    myCPU.Start();
  }
}
           
         
     

   
  

using System;


public class Starter {
    public static void Main() {
        MyClass obj = new MyClass();
        // Fails at compile time
        // YClass alias=obj;

        // Fails at run time
        YClass alias = (YClass)obj;

        obj.MethodA();
        obj.MethodB();

    }
}

public class MyClass {
    public virtual void MethodA() {
    }
    public virtual void MethodB() {
    }
}

public class YClass : MyClass {
    public override void MethodA() {
    }
}

   
     

   
  

class Employee { }
   
class ContractEmployee : Employee { }
   
class CastExample3
{
    public static void Main ()
    {
        ContractEmployee ce = (ContractEmployee)new Employee(); 
    }
}

   
     

   
  

using System;

public class MotorVehicle {

    public string model;

    public MotorVehicle(string model) {
        this.model = model;
    }

    public void Start() {
        Console.WriteLine(model + " started");
    }

}

public class Product : MotorVehicle {

    public bool convertible;

    public Product(string model, bool convertible) :
        base(model) {
        this.convertible = convertible;
    }

}


public class Motorcycle : MotorVehicle {

    public bool sidecar;

    public Motorcycle(string model, bool sidecar) :
        base(model) {
        this.sidecar = sidecar;
    }

    public void PullWheelie() {
        Console.WriteLine(model + " pulling a wheelie!");
    }

}
class MainClass {

    public static void Main() {
        Product myProduct = new Product("MR2", true);

        MotorVehicle myMotorVehicle = (MotorVehicle)myProduct;

        Console.WriteLine("myMotorVehicle.model = " + myMotorVehicle.model);
        myMotorVehicle.Start();
        Motorcycle myMotorcycle = new Motorcycle("V-Rod", true);

        MotorVehicle myMotorVehicle2 = (MotorVehicle)myMotorcycle;

        Console.WriteLine("myMotorVehicle2.model =" + myMotorVehicle2.model);
        myMotorVehicle2.Start();
        Motorcycle myMotorcycle2 = (Motorcycle)myMotorVehicle2;

        Console.WriteLine("myMotorcycle2.model = " + myMotorcycle2.model);
        Console.WriteLine("myMotorcycle2.sidecar = " + myMotorcycle2.sidecar);
        myMotorcycle2.Start();
        myMotorcycle2.PullWheelie();
    }
}

   
     

   
 

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;
using System.Text;
using System.IO;

using System.Runtime.Serialization.Formatters.Soap;


[Serializable]
class MyStringData : ISerializable {
    public string dataItemOne, dataItemTwo;

    public MyStringData() { }

    private MyStringData(SerializationInfo si, StreamingContext ctx) {
        dataItemOne = si.GetString("First_Item").ToLower();
        dataItemTwo = si.GetString("dataItemTwo").ToLower();
    }

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext ctx) {
        // Fill up the SerializationInfo object with the formatted data.
        info.AddValue("First_Item", dataItemOne.ToUpper());
        info.AddValue("dataItemTwo", dataItemTwo.ToUpper());
    }
}

[Serializable]
class MoreData {
    public string dataItemOne, dataItemTwo;

    [OnSerializing]
    internal void OnSerializing(StreamingContext context) {
        dataItemOne = dataItemOne.ToUpper();
        dataItemTwo = dataItemTwo.ToUpper();
    }

    [OnDeserialized]
    internal void OnDeserialized(StreamingContext context) {
        dataItemOne = dataItemOne.ToLower();
        dataItemTwo = dataItemTwo.ToLower();
    }
}
class Program {
    static void Main(string[] args) {
        MyStringData sd = new MyStringData();
        sd.dataItemOne = "some data.";
        sd.dataItemTwo = "some more data";

        Stream s = new FileStream("MyData.soap",
        FileMode.Create, FileAccess.Write, FileShare.None);

        SoapFormatter sf = new SoapFormatter();
        sf.Serialize(s, sd);
        s.Close();

        s = File.OpenRead("MyData.soap");
        sd = (MyStringData)sf.Deserialize(s);
        Console.WriteLine("Item 1: {0}", sd.dataItemOne);
        Console.WriteLine("Item 2: {0}", sd.dataItemTwo);

        MoreData md = new MoreData();
        md.dataItemOne = "1, 2, 3.";
        md.dataItemTwo = "One more test...";

        s = new FileStream("MoreData.soap",FileMode.Create, FileAccess.Write, FileShare.None);

        sf = new SoapFormatter();
        sf.Serialize(s, md);
        s.Close();

        s = File.OpenRead("MoreData.soap");
        md = (MoreData)sf.Deserialize(s);
        Console.WriteLine("Item 1: {0}", md.dataItemOne);
        Console.WriteLine("Item 2: {0}", md.dataItemTwo);
    }
}

    

   
 

using System;

public delegate void AlarmEvent(IAlarm sender);

public interface IAlarm {
    event AlarmEvent IssueAlarm;
}

abstract class MyStuff : ICloneable {
    public object Clone() {
        return null;
    }
    public void DoStuff() {
    }

}
interface IFoo {
    void DoStuff();
}

interface IBar {
    void DoStuff();
}

interface ITest {
    void DoSomething();
    int DoSomethingElse();
}
class MyClass : IFoo, IBar {
    void IFoo.DoStuff() {
    }
    void IBar.DoStuff() {
    }
}

class MainClass : IComparable {
    public int CompareTo(object other) {
        return -1;
    }
    static int Main(string[] args) {
        MainClass c = new MainClass();
        MainClass c2 = new MainClass();
        if (c.CompareTo(c2) == 0)
            return 0;
        MyClass c3 = new MyClass();
        return 1;
    }
}

    

   
 

public interface IZ {
    void MethodA();
    void MethodB();
}

public class MyClass : IZ {
    public void MethodA() {
    }
    public void MethodB() {
    }
}

public class YClass : MyClass, IZ {
    public new void MethodA() {
    }
    public new void MethodB() {
    }
}