CSharp 4
De Banane Atomic
Aller à la navigationAller à la recherche
Les paramètres nommés et optionnels
|
// cette méthode possède un paramètre optionel par défaut à 7
public void Methode(string param1, int param2 = 7) { ... }
Methode("cinq", 10); // appel classique
// param2 est un paramètre optionel. Il est donc possible de ne pas le spécifier
// il prendra donc sa valeur par défaut 7.
Methode("cinq");
// appel en nommant les paramètres
Methode(param2: 10, param1: "cinq");
// Les valeurs par défaut des paramètres optionnels doivent être des constantes
// voici deux manières d'utiliser un DateTime en paramètre optionnel
public void Methode(DateTime date1 = default(DateTime), DateTime? date2 = null)
{
if (date1 == default(DateTime)) date1 = new DateTime(...);
if (date2 == null) date2 = new DateTime(...);
}
|
Dynamic type
Permet de déclarer des instances dont le type est inconnu à la compilation et sera résolu à l'exécution.
|
|
// le type d'instance sera résolu à l'exécution
dynamic instance = ...;
// on peut donc
instance.Methode(); // appeler Methode depuis instance
var v = instance.Propriete; // appeler Propriete depuis instance
var i = instance[0]; // appeler l'index 0 depuis instance
instance("string"); // utiliser instance comme un délégué
|
Covariance et Contra variance des génériques
 |
Seulement pour les interfaces et les delegates |
Covariance
Conversion en sortie grâce au mot clé out: interface IMonInterface<out T>
|
|
List<string> myStrings = new List<string>();
myStrings.Add("Un");
// variance de type générique, pris en charge à partir de C# 4 (List<string> → IEnumerable<object>)
IEnumerable<object> myObjects = myStrings;
// Ne fonctionne pas avec List<object>, IList<object>
List<object> myObjects = myStrings;
// Cannot implicitly convert type `System.Collections.Generic.List<string>' to `System.Collections.Generic.IList<object>'.
// Ne fonctionne pas avec le boxing (int → object)
List<int> myInts = new List<int>();
myInts.Add(1);
IEnumerable<object> myObjects = myInts;
// Cannot implicitly convert type `System.Collections.Generic.List<int>' to `System.Collections.Generic.IEnumerable<object>'.
|
Contra variance
Conversion en entrée grâce au mot clé in: interface IComparer<in T>
|
|
public class C1
{
public string P1 { get; set; }
}
public class C2 : C1
{ }
// classe permettant la comparaison (et donc le tri) entre objets issus de la classe C1
class MyComparer : IComparer<C1>
{
public int Compare(C1 x, C1 y)
{
if (x == null && y == null)
{
return 0;
}
else if (x == null)
{
return -1;
}
else if (y == null)
{
return 1;
}
else
{
return x.P1.ToLower().CompareTo(y.P1.ToLower());
}
}
}
MyComparer comparer = new MyComparer();
List<C1> c1List = new List<C1>();
c1List.Add(new C1() { P1 = "Un" });
c1List.Add(new C1() { P1 = "Deux" });
// tri à l'aide de la classe MyComparer
c1List.Sort(comparer);
// même chode avec C2
List<C2> c2List = new List<C2>();
c2List.Add(new C2() { P1 = "Un" });
c2List.Add(new C2() { P1 = "Deux" });
// tri à l'aide de la classe MyComparer
// on peut ici réutiliser la classe MyComparer grace à la contra variance,
// sinon il aurait fallut écrire une class MyComparerC2 : IComparer<C2>
c2List.Sort(comparer);
|
