using System;

class MyClass {
}

class Test<T> {
  public T obj;

  public Test() {
    obj = default(T);
  }
}

class DefaultDemo {
  public static void Main() {
    Test<MyClass> x = new Test<MyClass>();

    if(x.obj == null)
      Console.WriteLine("x.obj is null.");

    Test<int> y = new Test<int>();

    if(y.obj == 0)
      Console.WriteLine("y.obj is 0.");
  }
}
           
         
     

   
 

using System;

class A {
}

class B : A {
}

// Here, V must inherit T.
class Gen<T, V> where V : T {
}

class Test {
  public static void Main() {

    // This declaration is OK because B inherits A.
    Gen<A, B> x = new Gen<A, B>();

    // This declaration is in error because
    // A does not inherit B.
//    Gen<B, A> y = new Gen<B, A>();

  }
}
           
         
     

   
  





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

class MyType<T, U> {
    private T _myFirstDataMember;
    private U _mySecondDataMember;

    public MyType(T val1, U val2) {
        this._myFirstDataMember = val1;
        this._mySecondDataMember = val2;
    }

    public T GetFirstDataMember() {
        return this._myFirstDataMember;
    }

    public U GetSecondDataMember() {
        return this._mySecondDataMember;
    }
}

class MyApp {
    static void main(String[] args) {
        MyType<string, string> testType = new MyType<string, string>("Val1", "Val2");
        Console.WriteLine(testType.GetFirstDataMember());
        Console.WriteLine(testType.GetSecondDataMember());
    }
}

  
         
     

   
 

public class GenericList<T>
{
    void Add(T input) { }
}
class TestGenericList
{
    private class ExampleClass { }
    static void Main()
    {
        // Declare a list of type int.
        GenericList<int> list1 = new GenericList<int>();

        // Declare a list of type string.
        GenericList<string> list2 = new GenericList<string>();

        // Declare a list of type ExampleClass.
        GenericList<ExampleClass> list3 = new GenericList<ExampleClass>();
    }
}

   
     

   
 

using System;

public class MyClass {
    public virtual void MethodA<T>(T arg)
        where T : new() {
    }
}

public class YClass : MyClass {
    public override void MethodA<T>(T arg) {
        T obj = new T();
    }
}

    

   


using System;

class MyBaseGenericClass<T> {
  protected T myObject;

  public MyBaseGenericClass(T o) {
    myObject = o;
  }

  public virtual T getmyObject() {
    Console.Write("Base&#039;s getmyObject(): " );
    return myObject;
  }
}

class MyGenericClass<T> : MyBaseGenericClass<T> {

  public MyGenericClass(T o) : base(o) {  }

  public override T getmyObject() {
    Console.Write("overide getmyObject(): ");
    return myObject;
  }
}

class Test {
  public static void Main() {
    MyBaseGenericClass<int> myObject = new MyBaseGenericClass<int>(8);

    Console.WriteLine(myObject.getmyObject());

    myObject = new MyGenericClass<int>(9);

    Console.WriteLine(myObject.getmyObject());
  }
}
           
          

   


using System;

class MyBaseClass {
  int num;

  public MyBaseClass(int i) {
    num = i;
  }

  public int getnum() {
    return num;
  }
}

class MyGenericClass<T> : MyBaseClass {
  T ob;

  public MyGenericClass(T o, int i) : base (i) {
    ob = o;
  }

  public T getob() {
    return ob;
  }
}

class HierDemo3 {
  public static void Main() {

    MyGenericClass<String> w = new MyGenericClass<String>("Hello", 7);

    Console.WriteLine(w.getob());
    Console.WriteLine(w.getnum());
  }
}