Was macht Standard (Objekt); in C # tun?

Beim Googeln wird nur das Schlüsselwort gefunden, aber ich bin auf einen Code gestoßen, der besagt

MyVariable = default(MyObject);

und ich frage mich, was es bedeutet.

• Für einen Referenztyp wird zurückgegeben null
• Für einen anderen Nullable<T>Werttyp als diesen wird ein mit Null initialisierter Wert zurückgegeben
• Denn Nullable<T>es gibt den leeren Wert (Pseudo-Null) zurück (tatsächlich ist dies eine Neuanweisung des ersten Aufzählungszeichens, aber es lohnt sich, ihn explizit zu machen).

Die größte Verwendung von default(T)Generika und Dingen wie dem Try...Muster:

bool TryGetValue(out T value) {
    if(NoDataIsAvailable) {
        value = default(T); // because I have to set it to *something*
        return false;
    }
    value = GetData();
    return true;
}

Zufällig verwende ich es auch bei der Codegenerierung, bei der es schwierig ist, Felder / Variablen zu initialisieren - aber wenn Sie den Typ kennen:

bool someField = default(bool);
int someOtherField = default(int)
global::My.Namespace.SomeType another = default(global::My.Namespace.SomeType);

defaultDas Schlüsselwort wird nullfür Referenztypen und zerofür numerische Werttypen zurückgegeben.

Für structs wird jedes Element der Struktur auf Null oder Null zurückgesetzt, je nachdem, ob es sich um Wert- oder Referenztypen handelt.

von MSDN

Simple Sample code :<br>
    class Foo
    {
        public string Bar { get; set; }
    }

    struct Bar
    {
        public int FooBar { get; set; }
        public Foo BarFoo { get; set; }
    }

    public class AddPrinterConnection
    {
        public static void Main()
        {

            int n = default(int);
            Foo f = default(Foo);
            Bar b = default(Bar);

            Console.WriteLine(n);

            if (f == null) Console.WriteLine("f is null");

            Console.WriteLine("b.FooBar = {0}",b.FooBar);

            if (b.BarFoo == null) Console.WriteLine("b.BarFoo is null");

        }
    }

AUSGABE:

0
f is null
b.FooBar = 0
b.BarFoo is null

Standardwert von MyObject. Siehe Standardschlüsselwort im generischen Code (C # -Programmierhandbuch) (MSDN):

In generischen Klassen und Methoden tritt unter anderem die Frage auf, wie einem parametrisierten Typ T ein Standardwert zugewiesen wird, wenn Sie Folgendes nicht im Voraus wissen:

• Gibt an, ob T ein Referenztyp oder ein Werttyp ist.
• Wenn T ein Werttyp ist, ob es sich um einen numerischen Wert oder eine Struktur handelt.

Bei einer Variablen t eines parametrisierten Typs T ist die Anweisung t = null nur gültig, wenn T ein Referenztyp ist und t = 0 nur für numerische Werttypen funktioniert, nicht jedoch für Strukturen. Die Lösung besteht darin, das Standardschlüsselwort zu verwenden, das für Referenztypen null und für numerische Werttypen null zurückgibt. Bei Strukturen wird jedes Element der Struktur auf Null oder Null zurückgesetzt, je nachdem, ob es sich um Wert- oder Referenztypen handelt. Das folgende Beispiel aus der GenericList-Klasse zeigt, wie das Standardschlüsselwort verwendet wird. Weitere Informationen finden Sie unter Übersicht über Generika.

public class GenericList<T>
{
    private class Node
    {
        //...

        public Node Next;
        public T Data;
    }

    private Node head;

    //...

    public T GetNext()
    {
        T temp = default(T);

        Node current = head;
        if (current != null)
        {
            temp = current.Data;
            current = current.Next;
        }
        return temp;
    }
}

Gibt den Standardwert des Typparameters an. Dieser Wert ist für Referenztypen null und für Werttypen null.

Siehe Standard

Das defaultSchlüsselwort gibt den Wert "Standard" oder "leer" für eine Variable des angeforderten Typs zurück.

Für alle Referenztypen (definiert mit class, delegateetc), dann ist dies null. Für Werttypen (definiert mit struct, enumusw.) Es ist ein all-Nullen - Wert (zum Beispiel int 0, DateTime 0001-01-01 00:00:00usw.).

Es wird hauptsächlich mit generischem Code verwendet, der sowohl auf Referenz- als auch auf Werttypen angewendet werden kann, da Sie keiner Werttypvariablen zuweisen nullkönnen.

Der Standardwert eines Objekts wird auf eine Variable festgelegt: null für Referenztypen und 0 für Werttypen.

Vielleicht hilft Ihnen das:

using System;
using System.Collections.Generic;
namespace Wrox.ProCSharp.Generics
{
    public class DocumentManager < T >
    {
        private readonly Queue < T > documentQueue = new Queue < T > ();
        public void AddDocument(T doc)
        {
            lock (this)
            {
                documentQueue.Enqueue(doc);
            }
        }

        public bool IsDocumentAvailable
        {
            get { return documentQueue.Count > 0; }
        }
    }
}

Es ist nicht möglich, generischen Typen null zuzuweisen. Der Grund dafür ist, dass ein generischer Typ auch als Werttyp instanziiert werden kann und null nur mit Referenztypen zulässig ist. Um dieses Problem zu umgehen, können Sie das Standardschlüsselwort verwenden. Mit dem Standardschlüsselwort wird Referenztypen null und Werttypen 0 zugewiesen.

public T GetDocument()
{
    T doc = default(T);
    lock (this)
    {
        doc = documentQueue.Dequeue();
    }
    return doc;
}

Das Standardschlüsselwort hat je nach Kontext, in dem es verwendet wird, mehrere Bedeutungen. Die switch-Anweisung verwendet einen Standardwert zum Definieren des Standardfalls. Bei Generika wird der Standardwert verwendet, um generische Typen entweder auf null oder 0 zu initialisieren, je nachdem, ob es sich um einen Referenz- oder einen Werttyp handelt.

Wenn keine Einschränkungen angewendet wurden, um einen generischen Typparameter auf einen Referenztyp zu beschränken, kann auch ein Werttyp, z. B. eine Struktur, übergeben werden. In solchen Fällen wäre ein Vergleich des Typparameters mit null immer falsch , da eine Struktur leer sein kann, aber niemals null

falscher Code

public void TestChanges<T>(T inputValue)

            try
            {
                if (inputValue==null)
                    return;
                //operation on inputValue

           }
            catch
            {
                // ignore this.
            }
        }

korrigiert

public void TestChanges<T>(T inputValue)

            try
            {
                if (object.Equals(inputValue, default(T)) )
                    return;
                //operation on inputValue

           }
            catch
            {
                // ignore this.
            }
        }