(this == null) em c #!

Devido a um erro corrigido no C # 4, o programa a seguir é impresso true. (Experimente no LINQPad)

void Main() { new Derived(); }

class Base {
    public Base(Func<string> valueMaker) { Console.WriteLine(valueMaker()); }
}
class Derived : Base {
    string CheckNull() { return "Am I null? " + (this == null); }
    public Derived() : base(() => CheckNull()) { }
}

No VS2008 no modo Release, lança uma InvalidProgramException. (No modo de depuração, funciona bem)

No VS2010 Beta 2, ele não é compilado (não tentei o Beta 1); Eu aprendi isso da pior maneira

Existe alguma outra maneira de criar this == nullem c # puro?

Esta observação foi publicada no StackOverflow em outra pergunta hoje cedo.

A grande resposta de Marc para essa pergunta indica que, de acordo com a especificação (seção 7.5.7), você não deve poder acessar thisnesse contexto e a capacidade de fazê-lo no compilador C # 3.0 é um bug. O compilador C # 4.0 está se comportando corretamente de acordo com as especificações (mesmo na Beta 1, esse é um erro de tempo de compilação):

§ 7.5.7 Este acesso

Um acesso a este consiste na palavra reservada this.

este acesso:

this

Um acesso a este é permitido apenas no bloco de um construtor de instância, um método de instância ou um acessador de instância.

A descompilação bruta (Refletor sem otimizações) do binário do modo Debug é:

private class Derived : Program.Base
{
    // Methods
    public Derived()
    {
        base..ctor(new Func<string>(Program.Derived.<.ctor>b__0));
        return;
    }

    [CompilerGenerated]
    private static string <.ctor>b__0()
    {
        string CS$1$0000;
        CS$1$0000 = CS$1$0000.CheckNull();
    Label_0009:
        return CS$1$0000;
    }

    private string CheckNull()
    {
        string CS$1$0000;
        CS$1$0000 = "Am I null? " + ((bool) (this == null));
    Label_0017:
        return CS$1$0000;
    }
}

O método CompilerGenerated não faz sentido; se você olhar para o IL (abaixo), ele está chamando o método em uma sequência nula (!).

   .locals init (
        [0] string CS$1$0000)
    L_0000: ldloc.0 
    L_0001: call instance string CompilerBug.Program/Derived::CheckNull()
    L_0006: stloc.0 
    L_0007: br.s L_0009
    L_0009: ldloc.0 
    L_000a: ret 

No modo Release, a variável local é otimizada, portanto, tenta empurrar uma variável inexistente para a pilha.

    L_0000: ldloc.0 
    L_0001: call instance string CompilerBug.Program/Derived::CheckNull()
    L_0006: ret 

(O refletor trava ao transformá-lo em c #)

Edição : Alguém (Eric Lippert?) Sabe por que o compilador emite o ldloc?

Eu tive isso! (e tenho provas também)

Este não é um "bug". É você que está abusando do sistema de tipos. Você nunca deve passar uma referência à instância atual ( this) para alguém dentro de um construtor.

Eu poderia criar um "bug" semelhante chamando um método virtual também no construtor da classe base.

Só porque você pode fazer algo ruim não significa que é um bug quando você fica com ele.

Eu posso estar errado, mas tenho certeza de que, se seu objeto for null, nunca haverá um cenário onde thisse aplique.

Por exemplo, como você ligaria CheckNull?

Derived derived = null;
Console.WriteLine(derived.CheckNull()); // this should throw a NullReferenceException

Não tenho certeza se é isso que você está procurando

    public static T CheckForNull<T>(object primary, T Default)
    {
        try
        {
            if (primary != null && !(primary is DBNull))
                return (T)Convert.ChangeType(primary, typeof(T));
            else if (Default.GetType() == typeof(T))
                return Default;
        }
        catch (Exception e)
        {
            throw new Exception("C:CFN.1 - " + e.Message + "Unexpected object type of " + primary.GetType().ToString() + " instead of " + typeof(T).ToString());
        }
        return default(T);
    }

exemplo: UserID = CheckForNull (Request.QueryString ["UserID"], 147);