Come posso impostare un parametro su Guid.Empty in C #?

Vorrei dire:

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

Ma il compilatore si lamenta che Guid.Empty non è una costante di tempo di compilazione.

Poiché non desidero modificare l'API, non posso usare:

 Nullable<Guid>

Soluzione

Puoi usare new Guid()invece

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

Puoi anche usare default(Guid)

default(Guid)funzionerà anche esattamente come new Guid().

Poiché Guid è un tipo di valore non di tipo di riferimento, quindi default(Guid)non è uguale, ad nullesempio, è uguale a chiamare il costruttore predefinito.

Ciò significa che questo:

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

È esattamente lo stesso dell'esempio originale.

Spiegazione

Perché non ha Guid.Emptyfunzionato?

Il motivo per cui ricevi l'errore è perché Emptyè definito come:

public static readonly Guid Empty;

Quindi, è una variabile, non una costante (definita come static readonlynon come const). Il compilatore può avere solo valori noti del compilatore come valori predefiniti dei parametri del metodo (non noti solo in fase di esecuzione).

La causa principale è che non puoi avere constalcuno struct, a differenza enumad esempio. Se lo provi, non verrà compilato.

Ancora una volta la ragione è che structnon è un tipo primitivo.
Per un elenco di tutti i tipi primitivi in ​​.NET, vedere http://msdn.microsoft.com/en-gb/library/system.typecode.aspx
(notare che di enumsolito eredita int, che è una primitiva)

Ma new Guid()non è anche una costante!

Non sto dicendo che ha bisogno di una costante. Ha bisogno di qualcosa che possa essere deciso in fase di compilazione. Emptyè un campo, quindi il suo valore non è noto in fase di compilazione (solo all'inizio del tempo di esecuzione).

Il valore del parametro predefinito deve essere noto al momento della compilazione, che può essere un constvalore o qualcosa definito utilizzando una funzione C # che rende noto il valore al momento della compilazione, come default(Guid)o new Guid()(che viene deciso al momento della compilazione per structs poiché non è possibile modificare il structcostruttore in codice).

Mentre puoi fornire defaulto newfacilmente, non puoi fornire un const(perché non è un tipo primitivo o un enumcome spiegato sopra). Quindi, ancora una volta, non dicendo che il parametro opzionale stesso necessita di un valore noto costante, ma del compilatore.

Guid.Emptyè equivalente a new Guid(), che è equivalente a default(Guid). Quindi puoi usare:

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

o

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

Si noti che il new Foo()valore è applicabile solo quando:

• Stai davvero chiamando il costruttore senza parametri
• Foo è un tipo di valore

In altre parole, quando il compilatore sa che è davvero solo il valore predefinito per il tipo :)

(È interessante notare che sono sicuro al 99,9% che non chiamerà alcun new Foo()costruttore personalizzato che potresti aver creato. Non puoi creare tale costruttore in un tipo di valore in C #, ma puoi farlo in IL.)

È possibile utilizzare l' default(Foo)opzione per qualsiasi tipo.

Non puoi usare:

default ( Guid ) ?

La risposta accettata non funziona in ASP.NET MVC e causa questo errore di runtime:

[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)' ....

Invece, puoi fare quanto segue:

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

Il compilatore è abbastanza corretto; Guid.Emptynon è una costante di compilazione. Puoi provare a fare un overload del metodo in questo modo:

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