IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo
Sommaire > Le langage C# > Opérations de base
        Comment écrire des commentaires en C# ?
        Quelles sont les signatures possibles pour la méthode Main ?
        Comment faire référence à l'objet courant ?
        Comment utiliser un mot-clé réservé comme nom de variable ou fonction ?
        Comment vérifier qu'un objet est bien d'un certain type ?
        Comment déclarer et utiliser les tableaux à une dimension ?
        Comment effectuer un décalage binaire sur un nombre ?
        Comment récupérer la valeur par défaut d'un type ?
        Comment calculer l'intervalle de temps entre deux dates ?
         Comment définir une valeur null pour un type valeur ?
        Comment passer un paramètre par référence à une méthode ?
        Comment s'abonner à un évènement ?
         Qu'est-ce qu'une méthode anonyme ?



Comment écrire des commentaires en C# ?
auteurs : cardi, tomlev
Il y a 2 manières d'écrire des commentaires de code en C# :

  • // ...
    Toute la ligne sera en commentaire.
  • /* ... */
    Tout ce qui est contenu entre /* et */ sera en commentaire. Ce type de commentaire peut s'étendre sur plusieurs lignes.
Il existe une troisième forme de commentaire, utilisée pour documenter le code :

          
/// <summary>
/// description de la classe
/// </summary>
class MaClasse
{
    // ...
}

        
Une option du compilateur permet d'extraire tous les commentaires de documentation du code dans un fichier XML, qui peut ensuite être utilisé par des outils pour générer des pages de documentation.

lien : ComDoc

Quelles sont les signatures possibles pour la méthode Main ?
auteur : cardi
La méthode Main est le point d'entrée de tout programme. Il existe 4 signatures différentes :

          
      class DifferentsMain
      {
          // Méthode sans paramètres
          // Ni code de retour
          public static void Main()
          { }

          // Méthode sans paramètres
          // Avec code de retour
          public static int Main()
          { return 0; }

          // Méthode avec paramètres
          // Mais sans code de retour
          public static void Main(params String[] param)
          { }

          // Méthode avec paramètres
          // Et code de retour
          public static int Main(params String[] param)
          { return param.Length; }
      }
      
        

Contrairement à ce que vous pourriez penser, il n'y a pas 6 signatures possibles mais bien 4 car il n'est pas possible d'utiliser la classe de base Object à la place de String.


Comment faire référence à l'objet courant ?
auteurs : cardi, tomlev
En C#, il est possible d'accéder explicitement aux membres de l'objet courant par l'intermédiaire du mot réservé this. Cela permet notamment de lever une ambiguïté si une variable locale ou un paramètre porte le même nom qu'un membre de l'objet courant :

          
  class ExempleThis
  {
      private String monString;
      
      public ExempleThis(string monString)
      {
          this.monString = monString;
      }
  }
  
        
Le mot-clé this permet également de faire référence à l'objet courant, par exemple pour le passer à une autre classe :

          
	class Parent
	{
	    private List<Enfants> _enfants = new List<Enfant>();
	    
		public IEnumerable<Enfant> Enfants
		{
			get { return _enfants; }
		}
		
		public Enfant AddEnfant()
		{
			Enfant e = new Enfant(this); // On passe l'objet courant en paramètre
			_enfants.Add(e);
			return e;
		}
	}
	
	class Enfant
	{
	    public Enfant(Parent parent)
	    {
	    	this.Parent = parent;
	    }
	    
	    public Parent Parent { get; private set; }
	}

        

Comment utiliser un mot-clé réservé comme nom de variable ou fonction ?
auteurs : cardi, tomlev
Bien que cela soit déconseillé, il est possible d'utiliser un mot-clé réservé en le préfixant du caractère @ :

          
      void @while()
      {
          int @class = 2007;
      }
      
        

Comment vérifier qu'un objet est bien d'un certain type ?
auteurs : cardi, tomlev
Il existe 2 solutions pour déterminer si un objet est d'un type donné :

La première est d'utiliser le mot-clé is. Ce dernier renvoie vrai si l'objet est bien du type demandé :

          
      String monString = "Ceci est un test !";
      if (monString is String)
          Console.WriteLine("monString est bien de type String !");
      else
          Console.WriteLine("monString n'est pas de type String !");
      
        

Une seconde solution est d'utiliser as. La différence est que as va tenter de faire le cast de l'objet vers le type spécifié. Si le cast n'est pas valide, null sera renvoyé :

          
      class Customer
      { }
      class Vendor
      { }

      public static void Main()
      {
          Object obj = new Vendor();

          Object testCustomer = obj as Customer;
          Object testVendor = obj as Vendor;

          if (testCustomer == null)
              Console.WriteLine("L'objet testé n'est pas de type Customer !");
          else
              Console.WriteLine("L'objet testé est de type Customer !");

          if (testVendor == null)
              Console.WriteLine("L'objet testé n'est pas de type Vendor !");
          else
              Console.WriteLine("L'objet testé est de type Vendor !");
      }
      
        
Notez que le mot-clé as ne peut être utilisé qu'avec un type référence, puisque les objets de type valeur ne peuvent pas valoir null.


Comment déclarer et utiliser les tableaux à une dimension ?
auteurs : Thomas Lebrun, abelman
Pour utiliser un tableau, en C#, vous devez faire suivre le type des éléments du tableau par [].
Pour accéder aux éléments du tableau, vous devez le parcourir en utilisant les index (attention, le premier indice des éléments d'un tableau commence à 0 et pas à 1)

          
    public class Tableau
    {
        // Tableau de type chaine
        private string[] _TableauString;

        public static void Main()
        {
            // On définit la taille du tableau
            _TableauString = new string[3];

            // On remplit le tableau
            for (int i = 0; i < 3; i++)
            {
                _TableauString[i] = "Chaine " + i;
            }

            // Affichage du contenu du tableau
            for (int i = 0; i < 3; i++)
            {
                Console.Write("Case " + i);
                Console.WriteLine("Contenu: " + _TableauString[i]);
            }
        }
    }

        

Comment effectuer un décalage binaire sur un nombre ?
auteurs : cardi, tomlev
Vous pouvez effectuer un décalage à gauche ou droite d'un certain nombre de bits à l'aide des opérateurs << et >> :

          
      int value = 8;
      int res;

      Console.WriteLine("La valeur de départ vaut {0}", value);

      // Décalage vers la gauche
      // res est multiplié par 2
      res = value << 1;
      Console.WriteLine("Après un décalage de 1 vers la gauche, res vaut {0}", res);

      // Décalage vers la droite
      // res est divisé par 2
      res = value >> 1;
      Console.WriteLine("Après un décalage de 1 vers la droite, res vaut {0}", res);

      // Décalage vers la gauche
      // res est multiplié par 4
      res = value << 2;
      Console.WriteLine("Après un décalage de 2 vers la gauche, res vaut {0}", res);
      
        
lien : fr Opérateur << (MSDN)
lien : fr Opérateur >>

Comment récupérer la valeur par défaut d'un type ?
auteurs : cardi, tomlev
Le mot-clé default permet d'obtenir la valeur par défaut d'un type. Pour un type référence, la valeur par défaut est toujours null. Pour un type valeur, la valeur par défaut est une instance du type où tous les champs ont leur valeur par défaut (tous les octets à 0).

          
      Console.WriteLine("Valeur par défaut de int : {0}", default(int) != null ? default(int).ToString() : "NULL");
      Console.WriteLine("Valeur par défaut de string : {0}", default(string) != null ? default(string).ToString() : "NULL");
      
        
Ce mot-clé est particulièrement pratique quand on écrit une classe ou une méthode générique.


Comment calculer l'intervalle de temps entre deux dates ?
auteurs : cardi, tomlev
La différence entre 2 dates s'effectue à l'aide de l'opérateur -, qui est redéfini dans le type DateTime pour renvoyer un objet de type TimeSpan (intervalle de temps).
Calculons le nombre de jours écoulés depuis la création de cette question :

          
      DateTime DateCourante = DateTime.Now;
      DateTime DateCreationquestion = new DateTime(2007, 1, 3);

      TimeSpan Ts = DateCourante - DateCreationquestion;
      Console.WriteLine("Il s'est écoulé {0} jour(s) depuis la création de cette question !", Ts.Days);
      
        
Notez que divers opérateurs arithmétiques sont également redéfinis dans les structures DateTime et TimeSpan, si bien qu'on peut effectuer diverses opérations sur les dates.

  • DateTime - DateTime = TimeSpan
  • DateTime + TimeSpan = DateTime
  • DateTime - TimeSpan = DateTime
  • TimeSpan + TimeSpan = TimeSpan
  • DateTime + DateTime = impossible car cela n'a pas de sens
lien : fr System.TimeSpan (MSDN)

Comment définir une valeur null pour un type valeur ?
auteurs : cardi, tomlev
Un type valeur, par définition, ne peut pas être null : il a forcément une valeur. Il existe cependant un type générique Nullable<T> qui permet d'englober un type valeur, et qui peut valoir null :

          
	// Entier non nullable
	int monInt1 = 42;

	// Entier nullable
	Nullable<int> monInt2 = null;

	// Entier nullable, notation abrégée
	int? monInt3 = null;
	
	// Conversion implicite de int vers Nullable<int>
	monInt2 = monInt1;
	
	// Copie d'un Nullable<int> vers un int
	if (monInt2.HasValue)
	{
		// Pas de conversion implicite de Nullable<int> vers int, on utilise la propriété Value
		monInt1 = monInt2.Value;
	}
      
        
lien : fr System.Nullable<T> (MSDN)

Comment passer un paramètre par référence à une méthode ?
auteurs : Thomas Lebrun, tomlev
En utilisant les mot-clés ref et out. La différence entre ref et out est la suivante :

  • Avec ref, l'initialisation du paramètre est de la responsabilité du code appelant. La méthode n'est pas obligée de modifier la valeur du paramètre.
  • Avec out, l'initialisation de la variable est de la responsabilité de la méthode, qui doit obligatoirement lui affecter une valeur avant de se terminer. Le code appelant n'est pas obligé de l'initialiser.
Voici un exemple pour clarifier tout ça :

          
    class TestRef
    {
        public void TestRef(ref int i)
        {
        	if (i < 0)
	            i = 0;
        }

        public void TestOut(out int j)
        {
            j = 5;
        }

        public static void Main()
        {
            // On initialise l'entier a
            int a = -3;
            // On le passe en paramètre à la fonction, par référence
            TestRef(ref a);
            Console.WriteLine("a vaut maintenant 1");

            // Utilisation de out
            int b;
            // On passe b en paramètre sans l'avoir initialisé
            TestOut(b);
			Console.WriteLine("b vaut maintenant 5");
        }
    }

        

Comment s'abonner à un évènement ?
auteur : tomlev
Il est très facile de s'abonner à un évènement de l'interface graphique à l'aide du designer, mais qu'en est-il quand on veut le faire soi-même dans le code ? Il suffit pour cela d'utiliser l'opérateur += :


monObjet.MonEvenement += new EventHandler(monObjet_MonEvenement);

...

private void monObjet_MonEvenement(object sender, EventArgs e)
{
   Console.WriteLine("MonEvenement s'est produit !");
}
Notez qu'on indique le type de delegate défini pour l'évènement (EventHandler dans ce cas). La signature (type de retour et types des paramètres) de la méthode utilisée pour s'abonner doit correspondre à la signature de ce delegate.

Depuis C# 2, il n'est plus nécessaire de spécifier le type de delegate, on peut donc écrire simplement :

monObjet.MonEvenement += monObjet_MonEvenement;
Cependant la règle de correspondance des signatures s'applique toujours.

Pour se désabonner d'un évènement, on utilise l'opérateur -= :

monObjet.MonEvenement -= monObjet_MonEvenement;

Qu'est-ce qu'une méthode anonyme ?
auteurs : dev01, tomlev
Une méthode anonyme est une méthode sans nom qui peut être créée à l'intérieur d'une autre méthode. Le résultat obtenu est en fait un delegate, qui peut être affecté à une variable ou passé en paramètre d'une méthode.
Voyons un exemple plus parlant :

          
    monButton.Click += delegate
        {
            MessageBox.Show("Une méthode anonyme");
        };

        
On peut aussi spécifier les paramètres au cas où on aurait besoin de les utiliser :

          
    monButton.Click += delegate(object sender, EventArgs e)
        {
            MessageBox.Show("Une méthode anonyme");
        };
					
        
La version 3 de C# introduit une nouvelle syntaxe pour déclarer des méthodes anonymes, appelée "expression lambda" :

          
    monButton.Click += (sender, e) =>
        {
            MessageBox.Show("Une méthode anonyme");
        };

        
lien : L'article de Louis-Guillaume Morand sur les nouveauté du framework 2.0
lien : Les méthodes anonymes en C# (MSDN)


Consultez les autres F.A.Q's


Valid XHTML 1.0 TransitionalValid CSS!

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2010 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.