Como posso usar como padrão um parâmetro para Guid.Empty em C #?

Eu gostaria de dizer:

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

Mas o compilador reclama que Guid.Empty não é uma constante de tempo de compilação.

Como não desejo alterar a API, não posso usar:

 Nullable<Guid>

Solução

Você pode usar new Guid()em vez

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

Você também pode usar default(Guid)

default(Guid)também funcionará exatamente como new Guid().

Como Guid é um tipo de valor, não um tipo de referência, portanto, default(Guid)não é igual a, nullpor exemplo, em vez disso, é igual a chamar o construtor padrão.

O que significa que isso:

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

É exatamente o mesmo que o exemplo original.

Explicação

Por que não Guid.Emptyfuncionou?

O motivo pelo qual você está recebendo o erro é porque Emptyé definido como:

public static readonly Guid Empty;

Portanto, é uma variável, não uma constante (definida como static readonlynão como const). O compilador pode ter apenas valores conhecidos do compilador como valores padrão dos parâmetros do método (não somente conhecidos em tempo de execução).

A causa raiz é que você não pode ter constnenhum struct, ao contrário enumdo exemplo. Se você tentar, ele não será compilado.

A razão mais uma vez é que structnão é um tipo primitivo.
Para obter uma lista de todos os tipos primitivos no .NET, consulte http://msdn.microsoft.com/en-gb/library/system.typecode.aspx
(observe que enumgeralmente herda int, que é uma primitiva)

Mas new Guid()também não é uma constante!

Não estou dizendo que precisa de uma constante. Precisa de algo que possa ser decidido em tempo de compilação. Emptyé um campo, portanto, seu valor não é conhecido no tempo de compilação (apenas no início do tempo de execução).

O valor padrão do parâmetro deve ser conhecido em tempo de compilação, que pode ser um constvalor, ou algo definido usando um recurso C # que torna o valor conhecido em tempo de compilação, como default(Guid)or new Guid()(que é decidido em tempo de compilação por structs, pois você não pode modificar o structconstrutor em código).

Embora você possa fornecer defaultou newfacilmente, você não pode fornecer um const(porque não é um tipo primitivo ou enumcomo explicado acima). Portanto, novamente, sem dizer que o parâmetro opcional em si precisa de um valor constante, mas conhecido do compilador.

Guid.Emptyé equivalente a new Guid(), que é equivalente a default(Guid). Então você pode usar:

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

ou

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

Observe que o new Foo()valor é aplicável apenas quando:

• Você está realmente chamando de sem parâmetros construtor sem
• Foo é um tipo de valor

Em outras palavras, quando o compilador sabe que é realmente apenas o valor padrão para o tipo :)

(Curiosamente, tenho 99,9% de certeza de que ele não chamará nenhum new Foo()construtor personalizado que você possa ter criado. Você não pode criar esse construtor em um tipo de valor em C #, mas pode fazê-lo em IL.)

Você pode usar a default(Foo)opção para qualquer tipo.

Você não pode usar:

default ( Guid ) ?

A resposta aceita não funciona no ASP.NET MVC e causa este erro em tempo de execução:

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

Em vez disso, você pode fazer o seguinte:

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

O compilador está bastante correto; Guid.Emptynão é uma constante em tempo de compilação. Você pode tentar sobrecarregar um método como este:

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