(this == null) in C #!

A causa di un errore corretto in C # 4, viene stampato il seguente programma true. (Provalo in 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()) { }
}

In VS2008 in modalità Release, genera un InvalidProgramException. (In modalità Debug, funziona benissimo)

In VS2010 Beta 2, non viene compilato (non ho provato Beta 1); L'ho imparato nel modo più duro

C'è un altro modo di fare this == nullin C # puro?

Questa osservazione è stata pubblicata su StackOverflow in un'altra domanda all'inizio di oggi.

La grande risposta di Marc a questa domanda indica che, secondo le specifiche (sezione 7.5.7), non dovresti essere in grado di accedere thisin quel contesto e la possibilità di farlo nel compilatore C # 3.0 è un bug. Il compilatore C # 4.0 si comporta correttamente in base alle specifiche (anche in Beta 1, si tratta di un errore di tempo di compilazione):

§ 7.5.7 Questo accesso

Un accesso di questo consiste nella parola riservata this.

questo accesso:

this

Un accesso di questo è consentito solo nel blocco di un costruttore di istanze, di un metodo di istanza o di un accessor di istanza.

La decompilazione non elaborata (Reflector senza ottimizzazioni) del binario della modalità 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;
    }
}

Il metodo CompilerGenerated non ha senso; se guardi l'IL (sotto), sta chiamando il metodo su una stringa nulla (!).

   .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 

In modalità Release, la variabile locale è ottimizzata, quindi tenta di inserire una variabile inesistente nello stack.

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

(Il riflettore si arresta in modo anomalo quando lo si trasforma in C #)

EDIT : Qualcuno (Eric Lippert?) Sa perché il compilatore emette il ldloc?

L'ho avuto! (e anche le prove)

Questo non è un "bug". Stai abusando del sistema dei tipi. Non devi mai passare un riferimento all'istanza corrente ( this) a nessuno all'interno di un costruttore.

Potrei creare un "bug" simile chiamando anche un metodo virtuale all'interno del costruttore della classe base.

Solo perché puoi fare qualcosa di brutto non significa che sia un bug quando ci si sente un po '.

Potrei sbagliarmi, ma sono abbastanza sicuro se il tuo oggetto è che nullnon ci sarà mai uno scenario in cui si thisapplichi.

Ad esempio, come chiameresti CheckNull?

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

Non sono sicuro se questo è quello che stai cercando

    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);
    }

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