Em C #, o que acontece quando você chama um método de extensão em um objeto nulo?

O método é chamado com um valor nulo ou fornece uma exceção de referência nula?

MyObject myObject = null;
myObject.MyExtensionMethod(); // <-- is this a null reference exception?

Se for esse o caso, nunca precisarei verificar se meu parâmetro 'this' é nulo?

Isso funcionará bem (sem exceção). Os métodos de extensão não usam chamadas virtuais (isto é, usam a instrução "call" il, não "callvirt"), portanto, não há verificação nula, a menos que você mesmo a escreva no método de extensão. Isso é realmente útil em alguns casos:

public static bool IsNullOrEmpty(this string value)
{
    return string.IsNullOrEmpty(value);
}
public static void ThrowIfNull<T>(this T obj, string parameterName)
        where T : class
{
    if(obj == null) throw new ArgumentNullException(parameterName);
}

etc

Fundamentalmente, chamadas para chamadas estáticas são muito literais - ou seja,

string s = ...
if(s.IsNullOrEmpty()) {...}

torna-se:

string s = ...
if(YourExtensionClass.IsNullOrEmpty(s)) {...}

onde obviamente não há verificação nula.

Além da resposta correta de Marc Gravell.

Você pode receber um aviso do compilador se for óbvio que o argumento this é nulo:

default(string).MyExtension();

Funciona bem em tempo de execução, mas produz o aviso "Expression will always cause a System.NullReferenceException, because the default value of string is null".

Como você já descobriu, como os métodos de extensão são simplesmente métodos estáticos glorificados, eles serão chamados com nullreferências passadas, sem NullReferenceExceptionserem lançadas. Mas, como eles parecem métodos de instância para o chamador, eles também devem se comportar como tal. Você deve, na maioria das vezes, verificar o thisparâmetro e lançar uma exceção, se for null. Não há problema em fazer isso se o método cuidar explicitamente dos nullvalores e seu nome indicar devidamente, como nos exemplos abaixo:

public static class StringNullExtensions { 
  public static bool IsNullOrEmpty(this string s) { 
    return string.IsNullOrEmpty(s); 
  } 
  public static bool IsNullOrBlank(this string s) { 
    return s == null || s.Trim().Length == 0; 
  } 
}

Também escrevi um post sobre isso há algum tempo.

Um nulo será passado para o método de extensão.

Se o método tentar acessar o objeto sem verificar se ele é nulo, sim, ele lançará uma exceção.

Um cara aqui escreveu os métodos de extensão "IsNull" e "IsNotNull" que verificam se a referência passou nula ou não. Pessoalmente, acho que isso é uma aberração e não deveria ter visto a luz do dia, mas é perfeitamente válido c #.

Como outros apontaram, chamar um método de extensão com referência nula faz com que este argumento seja nulo e nada mais especial acontecerá. Isso dá origem a uma idéia de usar métodos de extensão para escrever cláusulas de guarda.

Você pode ler este artigo para obter exemplos: Como reduzir a complexidade ciclomática: cláusula de guarda A versão curta é a seguinte:

public static class StringExtensions
{
    public static void AssertNonEmpty(this string value, string paramName)
    {
        if (string.IsNullOrEmpty(value))
            throw new ArgumentException("Value must be a non-empty string.", paramName);
    }
}

Este é o método de extensão de classe de cadeia que pode ser chamado na referência nula:

((string)null).AssertNonEmpty("null");

A chamada funciona bem apenas porque o tempo de execução chama com êxito o método de extensão na referência nula. Então você pode usar este método de extensão para implementar cláusulas de guarda sem sintaxe bagunçada:

    public IRegisteredUser RegisterUser(string userName, string referrerName)
    {

        userName.AssertNonEmpty("userName");
        referrerName.AssertNonEmpty("referrerName");

        ...

    }

O método de extensão é estático, portanto, se você não fizer nada a este MyObject, isso não deve ser um problema, um teste rápido deve verificar isso :)

Existem poucas regras de ouro quando você deseja que seja legível e vertical.

• alguém que vale a pena dizer de Eiffel diz que o código específico encapsulado em um método deve funcionar com alguma entrada; esse código é viável se forem atendidas algumas condições prévias e garantir uma saída esperada

No seu caso - DesignByContract está quebrado ... você executará alguma lógica em uma instância nula.