public class A
        {
        	private string _maVariable;
        
        	public string MaVariable
        	{
        		get
        		{
        			return _maVariable;
        		}
        
        		set
        		{
        			_maVariable = value;
        		}
        	}
        }
        

public string MaVariable { get; set; }

public string MaVariable { get; private set; }

          
const int maConstante = 2007;

        

          
	public class MaClasse
	{
      public const int MaConstante = 42;
      public readonly string MonReadOnly;

      public MaClasse(string monParam)
      {
      	  // initialisation dans le constructeur
          MonReadOnly = monParam;
      }
    }
      
        

          
      class Employee
      {
          private String PrenomNom;

          public Employee(String param_PrenomNom)
          { PrenomNom = param_PrenomNom; }

          public Employee(String param_Prenom, String param_Nom)
              : this(param_Prenom + " " + param_Nom)
          { }
      }
      
        

          
      class Employee : Person
      {
          public Employee(String param_PrenomNom)
		  	: base(param_PrenomNom) // passe le paramètre au constructeur de la classe Person
          {
		  }
      }
      
        

          
    //Fichier MaClasse.1.cs
    public partial class MaClasse
    {
        private List<string> infos;
    }

	//Fichier MaClasse.2.cs
    public partial class MaClasse
    {
        public MaClasse()
        {
            this.infos = new List<string>();
        }
    }

        

          
        public class Configuration
        {
            private static string _connectionString;
        
            public static string ConnectionString
            {
                get
                {
                    return _connectionString;
                }
        
                set
                {
                    _connectionString = value;
                }
        
            }
        }

        

          
      static void Main()
      {
          MaFonctionVariable("Bonjour");
          MaFonctionVariable("Bonjour", "Au revoir");
      }

      static void MaFonctionVariable(params String[] MesParams)
      {
          foreach (String courantString in MesParams)
              Console.WriteLine("Valeur du paramètre : {0}", courantString);
      }
      
        

          
      static void Main()
      {
          MaFonctionVariableEnType("Bonjour");
          MaFonctionVariableEnType("Bonjour", 2007);
          MaFonctionVariableEnType("Bonjour", 2007, true);
          MaFonctionVariableEnType("Bonjour", 2007, true, 10.1);
      }

      static void MaFonctionVariableEnType(params Object[] MesParams)
      {
          foreach (Object courantObject in MesParams)
              Console.WriteLine("Valeur du paramètre : {0}", courantObject);
      }
      
        

          
public class MaClasseGenerique<T>
{
    public T Valeur { get; set; }
}

        

          
	public T GetValue<T>()
	{
	    return (T)value;
	}

        

          
MaClasseGenerique<int> x = new MaClasseGenerique<int>();
x.Valeur = 3;
x.Valeur = "hello"; // impossible car Valeur est de type int

        

          
List<string> stringList = new List<string>();

stringList.Add("Salut"); // ok
stringList.Add(1); // impossible car c'est une liste d'objets de type String

        

          
      public class maClasse<K>
      { 
          protected K paramK;
          public maClasse()
          {
              paramK = new K();
          }
      }
      
        

          
      public class maClasse<K> where K : new()
      { 
          //...
      }
      
        

          
      public class maClasse<K>    where K : new(), IDisposable
      { 
          protected K paramK;
          public maClasse()
          {
              paramK = new K();
              paramK.Dispose();
          }
      }
      
        

          
	public class maClasseReference<K> where K : class
	{
	}

	public class maClasseValeur<K> where K : struct
	{
	}

	// ...
	
	maClasseReference<string> ref1 = new maClasseReference<string>(); // OK, string est un type référence
	maClasseReference<int> ref2 = new maClasseReference<int>(); // impossible, int est un type valeur

	maClasseValeur<int> val1 = new maClasseValeur<int>(); // OK, int est un type valeur
	maClasseValeur<string> val2 = new maClasseValeur<string>(); // impossible, string est un type référence

        

          
      public class MaClasseGenerique<K>
      {
          public void TypeK()
          {
              if (default(K) != null)
            		Console.WriteLine("K est un type valeur !");
              else
              		Console.WriteLine("K est un type référence !");
                  
          }
      }

      class Program
      {
          static void Main(string[] args)
          {
              (new MaClasseGenerique<int>()).TypeK();
              (new MaClasseGenerique<string>()).TypeK();
          }
      }

        

          
      public class MaClasseGenerique<K>
      {
          public void TypeK()
          {
              if (typeof(K).IsValueType)
            		Console.WriteLine("K est un type valeur !");
              else
              		Console.WriteLine("K est un type référence !");
                  
          }
      }
      
        

          
      sealed class ClassImpossibleAHeriter
      { 
          // ...
      }
      
        

          
class LostNumbers : IEnumerable
{
    private int[] _numbers = new[] { 4, 8, 15, 16, 23, 42 };

    public IEnumerator GetEnumerator()
    {
        return new LostNumbersEnumerator(_numbers);
    }
    
    private class LostNumbersEnumerator : IEnumerator
    {
        private int _index;
        private int[] _numbers;
        
        public LostNumbersEnumerator(int[] numbers)
        {
            _numbers = numbers;
            _index = -1;
        }
    
        public void Reset()
        {
            _index = -1;
        }
        
        public bool MoveNext()
        {
            _index++;
            return _index < _numbers.Length;
        }
        
        public object Current
        {
            get { return _numbers[_index]; }
        }
    }
}

        

          
LostNumbers numbers = new LostNumbers();
foreach (int n in numbers)
{
    Console.WriteLine(n);
}

        

          
class LostNumbers : IEnumerable<int>
{
    private int[] _numbers = new[] { 4, 8, 15, 16, 23, 42 };

    public IEnumerator<int> GetEnumerator()
    {
        for(int i = 0; i < _numbers.Length)
        {
            yield return _numbers[i];
        }
    }

    // IEnumerable<T> hérite de IEnumerable, on doit donc définir aussi la méthode
    // non générique GetEnumerator par implémentation explicite de l'interface
    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

        

          
public IEnumerable<int> GetLostNumbers()
{
    yield return 4;
    yield return 8;
    yield return 15;
    yield return 16;
    yield return 23;
    yield return 42;
}