interface I1<T> {}
interface I2<T> {}
class C1<U> {
   public void Fct1(U u){}    // Cette fct ne peut être appelée ...
   public void Fct1(int i){}  // ... si U est int.          

   public void Fct2(U u1, U u2){}       // Pas d'ambiguité.
   public void Fct2(int i, string s){}  

   public void Fct3(I1<U> a){}          // Pas d'ambiguité.
   public void Fct3(I2<U> a){}

   public void Fct4(U a){}              // Pas d'ambiguité.
   public void Fct4(U[] a){}
}
class C2<U,V> {
   public void Fct5(U u, V v){}     // Possibilité d'ambiguité si
   public void Fct5(V v, U u){}     // le type U = le type V.

   public void Fct6(U u, V v){}     // Possibilité d'ambiguité si
   public void Fct6(V v, U u){}     // le type U = le type V != int.
   public void Fct6(int u, V v){}

   public void Fct7(int u, V v){}   // Possibilité d'ambiguité si
   public void Fct7(U u, int v){}   // le type U = le type V = int.

   public void Fct8(U u, I1<V> v){} // Possibilité d'ambiguité
   public void Fct8(I1<V> v, U u){} // par exemple pour c2<I1<int>,int>.

   public void Fct9(U u1, I1<V> v2){} // Pas d'ambiguité.
   public void Fct9(V v1, U u2){}

   public void Fct10(ref U u){}       // Pas d'ambiguité.
   public void Fct10(out V v){ v = default(V); }
}
class Program { 
   static void Main(){
      C1<int> a = new C1<int>();
      a.Fct1(34); // Appelle   Fct1(int i)
      C2<int, int> b = new C2<int, int>();
      b.Fct5(13, 14);  // Erreur de compilation: This call is ambiguous.
      b.Fct6(13, 14);  // Appelle Fct6(int u, V v)
      b.Fct7(13, 14);  // Erreur de compilation: This call is ambiguous.
      C2<I1<int>,int> c = new C2<I1<int>,int>();
      c.Fct8(null,null); //Erreur de compilation:This call is ambiguous.
   }
}