Comment puis-je par défaut un paramètre sur Guid.Empty en C #?

Je souhaite dire:

public void Problem(Guid optional = Guid.Empty)
{
}

Mais le compilateur se plaint que Guid.Empty n'est pas une constante de temps de compilation.

Comme je ne souhaite pas changer l'API, je ne peux pas utiliser:

 Nullable<Guid>

Solution

Vous pouvez utiliser à la new Guid()place

public void Problem(Guid optional = new Guid())
{
  // when called without parameters this will be true
  var guidIsEmpty = optional == Guid.Empty;
}

Vous pouvez aussi utiliser default(Guid)

default(Guid)fonctionnera également exactement comme new Guid().

Étant donné que Guid est un type valeur et non un type référence, il default(Guid)n'est donc pas égal à, nullpar exemple, il est égal à l'appel du constructeur par défaut.

Ce qui signifie que ceci:

public void Problem(Guid optional = default(Guid))
{
  // when called without parameters this will be true
  var guidIsEmpty = optional == Guid.Empty;
}

C'est exactement le même que l'exemple original.

Explication

Pourquoi n'a pas Guid.Emptyfonctionné?

La raison pour laquelle vous obtenez l'erreur est qu'elle Emptyest définie comme:

public static readonly Guid Empty;

Donc, c'est une variable, pas une constante (définie comme static readonlynon comme const). Le compilateur ne peut avoir que des valeurs connues du compilateur comme valeurs par défaut des paramètres de méthode (non connues uniquement à l'exécution).

La cause racine est que vous ne pouvez pas avoir constde tout struct, à la différence enumpar exemple. Si vous essayez, il ne se compilera pas.

La raison est encore une fois que ce structn'est pas un type primitif.
Pour une liste de tous les types primitifs dans .NET, voir http://msdn.microsoft.com/en-gb/library/system.typecode.aspx
(notez que enumgénéralement hérite int, qui est une primitive)

Mais ce new Guid()n'est pas non plus une constante!

Je ne dis pas qu'il faut une constante. Il a besoin de quelque chose qui peut être décidé au moment de la compilation. Emptyest un champ, donc sa valeur n'est pas connue au moment de la compilation (seulement au tout début de l'exécution).

La valeur du paramètre par défaut doit être connue au moment de la compilation, qui peut être une constvaleur, ou quelque chose de défini à l'aide d'une fonctionnalité C # qui rend la valeur connue au moment de la compilation, comme default(Guid)ou new Guid()(qui est décidé au moment de la compilation pour structs car vous ne pouvez pas modifier le structconstructeur dans code).

Bien que vous puissiez fournir defaultou newfacilement, vous ne pouvez pas fournir un const(car ce n'est pas un type primitif ou un enumcomme expliqué ci-dessus). Donc, encore une fois, ne pas dire que le paramètre facultatif lui-même a besoin d'une constante, mais une valeur connue du compilateur.

Guid.Emptyest équivalent à new Guid(), qui est équivalent à default(Guid). Vous pouvez donc utiliser:

public void Problem(Guid optional = default(Guid))

ou

public void Problem(Guid optional = new Guid())

Notez que la new Foo()valeur est uniquement applicable lorsque:

• Vous appelez vraiment le constructeur sans paramètre
• Foo est un type valeur

En d'autres termes, lorsque le compilateur sait qu'il s'agit en réalité de la valeur par défaut du type :)

( Fait intéressant, je suis 99,9% sûr que ce ne sera pas appeler de coutume new Foo()constructeur que vous avez créé. Vous ne pouvez pas créer un tel constructeur dans un type de valeur en C #, mais vous pouvez le faire en IL.)

Vous pouvez utiliser l' default(Foo)option pour n'importe quel type.

Ne pouvez-vous pas utiliser:

default ( Guid ) ?

La réponse acceptée ne fonctionne pas dans ASP.NET MVC et provoque cette erreur d'exécution:

[ArgumentException: The parameters dictionary contains a null entry for parameter 'optional' of non-nullable type 'System.Guid' for method 'System.Web.Mvc.ActionResult Problem(System.Guid)' ....

Au lieu de cela, vous pouvez effectuer les opérations suivantes:

public void Problem(Guid? optional)
{
    if (optional == null)
    {
        optional = new Guid();
    }
}

Le compilateur est tout à fait correct; Guid.Emptyn'est pas une constante de compilation. Vous pouvez essayer de créer une surcharge de méthode comme celle-ci:

public void Problem()
{
    Problem(Guid.Empty);
}