Qu'est-ce que default (object); faire en C #?

Google ne fait que trouver le mot-clé, mais je suis tombé sur un code qui dit

MyVariable = default(MyObject);

et je me demande ce que cela signifie.

• Pour un type référence, il renvoie null
• Pour un type de valeur autre que Nullable<T>celui-ci renvoie une valeur initialisée à zéro
• Car Nullable<T>il renvoie la valeur vide (pseudo-nulle) (en fait, il s'agit d'une ré-instruction de la première puce, mais cela vaut la peine de la rendre explicite)

La plus grande utilisation de default(T)est dans les génériques, et des choses comme le Try...modèle:

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

En l'occurrence, je l'utilise également dans certaines générations de code, où il est difficile d'initialiser des champs / variables - mais si vous connaissez le type:

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

defaultLe mot-clé retournera nullpour les types de référence et zeropour les types de valeur numérique.

Pour structs, il retournera chaque membre de la structure initialisé à zéro ou nul selon qu'il s'agit de types valeur ou référence.

depuis 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");

        }
    }

PRODUCTION:

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

Valeur par défaut de MyObject. Voir le mot-clé par défaut dans le code générique (Guide de programmation C #) (MSDN):

Dans les classes et méthodes génériques, un problème qui se pose est de savoir comment attribuer une valeur par défaut à un type T paramétré lorsque vous ne connaissez pas à l'avance les éléments suivants:

• Si T sera un type référence ou un type valeur.
• Si T est un type valeur, que ce soit une valeur numérique ou une structure.

Étant donné une variable t d'un type paramétré T, l'instruction t = null n'est valide que si T est un type référence et t = 0 ne fonctionnera que pour les types valeur numérique mais pas pour les structs. La solution consiste à utiliser le mot-clé par défaut, qui renverra null pour les types référence et zéro pour les types valeur numérique. Pour les structures, il retournera chaque membre de la structure initialisé à zéro ou à null selon qu'il s'agit de types valeur ou référence. L'exemple suivant de la classe GenericList montre comment utiliser le mot-clé par défaut. Pour plus d'informations, consultez Présentation des génériques.

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

Spécifie la valeur par défaut du paramètre type. Elle sera nulle pour les types référence et zéro pour les types valeur.

Voir par défaut

Le defaultmot clé renvoie la valeur "par défaut" ou "vide" pour une variable du type demandé.

Pour tous les types de référence (définis avec class, delegate, etc.), c'est null. Pour les types de valeur (définie avec struct, enum, etc.) , il est une valeur tout-zéros (par exemple int 0, DateTime 0001-01-01 00:00:00, etc.).

Il est principalement utilisé avec du code générique qui peut être appliqué à la fois aux types référence et valeur, car vous ne pouvez pas attribuer nullà une variable de type valeur.

Il définira la valeur par défaut d'un objet sur une variable: null pour les types référence et 0 pour les types valeur.

Peut-être que cela peut vous aider:

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

Il n'est pas possible d'attribuer null aux types génériques. La raison en est qu'un type générique peut également être instancié en tant que type valeur et null n'est autorisé qu'avec les types référence. Pour contourner ce problème, vous pouvez utiliser le mot clé par défaut. Avec le mot-clé par défaut, null est affecté aux types de référence et 0 aux types de valeur.

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

Le mot-clé par défaut a plusieurs significations selon le contexte dans lequel il est utilisé. L'instruction switch utilise une valeur par défaut pour définir la casse par défaut, et avec les génériques, la valeur par défaut est utilisée pour initialiser les types génériques à null ou à 0 selon qu'il s'agit d'un type référence ou valeur.

Lorsque des contraintes n'ont pas été appliquées pour restreindre un paramètre de type générique à un type de référence, un type valeur, tel qu'une structure, peut également être passé. Dans de tels cas, comparer le paramètre de type à null serait toujours faux , car une structure peut être vide, mais jamais nulle

mauvais code

public void TestChanges<T>(T inputValue)

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

           }
            catch
            {
                // ignore this.
            }
        }

corrigée

public void TestChanges<T>(T inputValue)

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

           }
            catch
            {
                // ignore this.
            }
        }