C# Language
Fonctions C # 4.0

Paramètres facultatifs et arguments nommés

Nous pouvons omettre l'argument dans l'appel si cet argument est un argument facultatif Chaque argument optionnel a sa propre valeur par défaut Il prendra une valeur par défaut si nous ne fournissons pas la valeur Une valeur par défaut d'un argument facultatif doit être

1. Expression constante
2. Doit être un type de valeur tel que enum ou struct.
3. Doit être une expression du formulaire par défaut (valueType)

Il doit être défini à la fin de la liste des paramètres

Paramètres de méthode avec les valeurs par défaut:

public void ExampleMethod(int required, string optValue = "test", int optNum = 42)
{
    //...
}

Comme indiqué par MSDN, un argument nommé,

Vous permet de passer l'argument à la fonction en associant le nom du paramètre Pas besoin de mémoriser la position des paramètres dont nous n'avons pas toujours conscience. Pas besoin de regarder l'ordre des paramètres dans la liste de paramètres de la fonction appelée. Nous pouvons spécifier le paramètre pour chaque argument par son nom.

Arguments nommés:

// required = 3, optValue = "test", optNum = 4
ExampleMethod(3, optNum: 4);
// required = 2, optValue = "foo", optNum = 42
ExampleMethod(2, optValue: "foo");
// required = 6, optValue = "bar", optNum = 1
ExampleMethod(optNum: 1, optValue: "bar", required: 6);

Limitation de l'utilisation d'un argument nommé

La spécification d'argument nommé doit apparaître après que tous les arguments fixes ont été spécifiés.

Si vous utilisez un argument nommé avant un argument fixe, vous obtiendrez une erreur de compilation comme suit.

La spécification d'argument nommé doit apparaître après que tous les arguments fixes ont été spécifiés

Variance

Les paramètres et les délégués génériques peuvent avoir leurs paramètres de type marqués comme covariant ou contravariant en utilisant respectivement les mots-clés out et in . Ces déclarations sont ensuite respectées pour les conversions de types, à la fois implicites et explicites, ainsi que pour la compilation et l'exécution.

Par exemple, l'interface existante IEnumerable<T> a été redéfinie comme étant covariante:

interface IEnumerable<out T>
{
    IEnumerator<T> GetEnumerator();
}

L'interface existante IComparer a été redéfinie comme étant contravariante:

public interface IComparer<in T>
{
    int Compare(T x, T y);
}

Mot clé ref optionnel lors de l'utilisation de COM

Le mot-clé ref pour les appelants de méthodes est désormais facultatif lors de l'appel de méthodes fournies par les interfaces COM. Étant donné une méthode COM avec la signature

void Increment(ref int x);

l'invocation peut maintenant être écrite soit

Increment(0); // no need for "ref" or a place holder variable any more

Recherche de membre dynamique

Un nouveau type de pseudo- dynamic est introduit dans le système de type C #. Il est traité comme System.Object , mais en outre, tout accès de membre (appel de méthode, champ, propriété ou accès à l'indexeur ou appel de délégué) ou l'application d'un opérateur sur une valeur de ce type est autorisé sans vérification de type. et sa résolution est reportée à l'exécution. Ceci est connu comme le typage de canard ou la liaison tardive. Par exemple:

// Returns the value of Length property or field of any object
int GetLength(dynamic obj)
{
    return obj.Length;
}
  
GetLength("Hello, world");        // a string has a Length property,
GetLength(new int[] { 1, 2, 3 }); // and so does an array,
GetLength(42);                    // but not an integer - an exception will be thrown
                                  // in GetLength method at run-time

Dans ce cas, le type dynamique est utilisé pour éviter une réflexion plus verbeuse. Il utilise toujours Reflection sous le capot, mais il est généralement plus rapide grâce à la mise en cache.

Cette fonctionnalité est principalement destinée à l'interopérabilité avec les langages dynamiques.

// Initialize the engine and execute a file
var runtime = ScriptRuntime.CreateFromConfiguration();
dynamic globals = runtime.Globals;
runtime.ExecuteFile("Calc.rb");

// Use Calc type from Ruby
dynamic calc = globals.Calc.@new();
calc.valueA = 1337;
calc.valueB = 666;
dynamic answer = calc.Calculate();

Le type dynamique a des applications même dans un code typé principalement de manière statique, par exemple, il permet une double répartition possible sans implémenter le motif de visiteur.