surcharge de méthode vs paramètre facultatif en C # 4.0

Question

quel est le meilleur? En bref, le paramètre facultatif semble meilleur (moins de code, moins de documentation XML, etc.), mais pourquoi la plupart des classes de bibliothèques MSDN utilisent-elles la surcharge au lieu de paramètres facultatifs?

Y a-t-il quelque chose de particulier que vous devez prendre en note lorsque vous choisissez d'utiliser un paramètre facultatif (ou une surcharge)?

Answer 1

Un bon cas d'utilisation pour les "paramètres Optionnels" en collaboration avec " Nommé de Paramètres en C# 4.0, c'est qu'il nous présente une alternative élégante à la surcharge de méthode où vous surchargez la méthode basée sur le nombre de paramètres.

Par exemple, dites que vous voulez une méthode foo à être appelé/utilisé comme, foo(), foo(1), foo(1,2), foo(1,2, "hello"). Avec la surcharge de méthode, vous pouvez implémenter la solution de ce genre,

///Base foo method
public void DoFoo(int a, long b, string c)
{
   //Do something
}  

/// Foo with 2 params only
public void DoFoo(int a, long b)
{
    /// ....
    DoFoo(a, b, "Hello");
}

public void DoFoo(int a)
{
    ///....
    DoFoo(a, 23, "Hello");
}

.....

Avec l'option paramètres en C# 4.0, vous pouvez implémenter le cas d'utilisation comme suit,

public void DoFoo(int a = 10, long b = 23, string c = "Hello")

Ensuite, vous pouvez utiliser la méthode comme le Remarque l'utilisation d'un paramètre nommé -

DoFoo(c:"Hello There, John Doe")

Cet appel prend en paramètre a de la valeur de 10 et paramètre b 23. Une autre variante de cet appel - avis, vous n'avez pas besoin de définir les valeurs des paramètres dans l'ordre où elles apparaissent dans la signature de la méthode, le paramètre nommé rend la valeur explicite.

DoFoo(c:"hello again", a:100) 

Un autre avantage d'utiliser des paramètres nommés, c'est qu'il améliore grandement la lisibilité et donc la maintenance du code de paramètre facultatif méthodes.

Notez comment une méthode assez bien fait redondant d'avoir à définir 3 ou plusieurs méthodes de surcharge de la méthode. Ce que j'ai trouvé est un bon cas d'utilisation pour l'utilisation de paramètre facultatif en conjonction avec les paramètres nommés.

Answer 2

Les Paramètres facultatifs de fournir des problèmes lorsque vous les exposer publiquement que l'API. Un changement de nom d'un paramètre peut entraîner des problèmes. La modification de la valeur par défaut conduit aux questions (Voir par exemple ici quelques infos: les mises en garde de C# 4.0 paramètres facultatifs)

Aussi, en option paramètres ne peuvent être utilisés pour des constantes de compilation. Comparer ceci:

public static void Foo(IEnumerable<string> items = new List<string>()) {}
// Default parameter value for 'items' must be a compile-time constant

pour ce

public static void Foo() { Foo(new List<string>());}
public static void Foo(IEnumerable<string> items) {}
//all good

Mise à jour

Voici quelques autres matériel de lecture lorsqu'un constructeur avec paramètres par défaut ne joue pas bien avec la Réflexion.

Answer 3

Je crois qu'ils servent à des fins différentes. Les paramètres facultatifs sont quand vous pouvez utiliser une valeur par défaut pour un paramètre, et le code sous-jacent sera le même:

public CreditScore CheckCredit( 
  bool useHistoricalData = false,  
  bool useStrongHeuristics = true) { 
  // ... 
}

Méthode surcharges sont pour quand vous avez mutuellement exclusif (sous-ensembles de paramètres. Que signifie normalement que vous avez besoin pour traiter certains paramètres, ou que vous avez un code différent pour les différentes "versions" de votre méthode (à noter que même dans ce cas, certains paramètres peuvent être partagés, c'est pourquoi j'ai parlé de "sous-ensembles" ci-dessus):

public void SendSurvey(IList<Customer> customers, int surveyKey) {  
  // will loop and call the other one 
} 
public void SendSurvey(Customer customer, int surveyKey) {  
  ...  
}

(J'ai écrit à ce sujet il y a quelques temps ici)

Answer 4

Celui-ci va presque sans dire, mais:

Toutes les langues ne prennent pas en charge les paramètres facultatifs. Si vous voulez que vos bibliothèques soient amicales avec ces langues, vous devez utiliser des surcharges.

Certes, ce n'est pas un problème pour la plupart des magasins. Mais vous pouvez parier que c’est la raison pour laquelle Microsoft n’utilise pas de paramètres facultatifs dans la bibliothèque de classes de base.

Answer 5

Les paramètres facultatifs doit être la dernière. Si vous ne pouvez pas ajouter un paramètre supplémentaire à cette méthode, à moins que ses aussi en option. Ex:

void MyMethod(int value, int otherValue = 0);

Si vous voulez ajouter un nouveau paramètre à cette méthode sans surcharge, il doit être en option. Comme ceci

void MyMethod(int value, int otherValue = 0, int newParam = 0);

Si il ne peut pas être facultative, vous devez utiliser la surcharge et supprimer l'option de la valeur pour 'otherValue'. Comme ceci:

void MyMethod(int value, int otherValue = 0);
void MyMethod(int value, int otherValue, int newParam);

Je suppose que vous voulez conserver l'ordre des paramètres.

Donc, en utilisant les paramètres facultatifs réduit le nombre de méthodes que vous devez avoir dans votre classe, mais est limitée dans la mesure où ils ont besoin pour être la dernière.

Mise à jour Lors de l'appel de méthodes avec des paramètres optionnels, vous pouvez utiliser des paramètres nommés comme ceci:

void MyMethod(int value, int otherValue = 0, int newValue = 0);

MyMethod(10, newValue: 10); // Here I omitted the otherValue parameter that defaults to 0

Si les paramètres facultatifs donne l'appelant plus de possibilités.

Une dernière chose. Si vous utilisez la surcharge de méthode avec une mise en œuvre, comme ceci:

void MyMethod(int value, int otherValue)
{
   // Do the work
}

void MyMethod(int value)
{
   MyMethod(value, 0); // Do the defaulting by method overloading
}

Ensuite, lors de l'appel 'MyMethod" comme ceci:

MyMethod(100); 

Donnera 2 appels de méthode. Mais si vous utilisez des paramètres optionnels, il y a seulement une mise en œuvre de la "MyMethod" et donc, un seul appel de méthode.