O que padrão (objeto); fazer em c #?

Pesquisando apenas a palavra-chave, mas me deparei com um código que diz

MyVariable = default(MyObject);

e eu estou querendo saber o que isso significa.

• Para um tipo de referência, ele retorna null
• Para um tipo de valor diferente de Nullable<T>retornar um valor inicializado com zero
• Pois Nullable<T>ele retorna o valor vazio (pseudo-nulo) (na verdade, esta é uma declaração do primeiro marcador, mas vale a pena torná-lo explícito)

O maior uso de default(T)é em genéricos, e coisas como o Try...padrão:

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

Por acaso, eu também o uso em alguma geração de código, onde é difícil inicializar campos / variáveis ​​- mas se você souber o tipo:

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

defaultA palavra-chave retornará nullpara tipos de referência e tipos zerode valores numéricos.

Para structs, ele retornará cada membro da estrutura inicializado como zero ou nulo, dependendo do tipo de valor ou referência.

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

        }
    }

RESULTADO:

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

Valor padrão de MyObject. Consulte a palavra-chave padrão no código genérico (Guia de Programação em C #) (MSDN):

Nas classes e métodos genéricos, surge um problema: como atribuir um valor padrão a um tipo de parâmetro T quando você não sabe o seguinte com antecedência:

• Se T será um tipo de referência ou um tipo de valor.
• Se T for um tipo de valor, se será um valor numérico ou uma estrutura.

Dada uma variável t de um tipo parametrizado T, a instrução t = null será válida apenas se T for um tipo de referência et = 0 funcionará apenas para tipos de valores numéricos, mas não para estruturas. A solução é usar a palavra-chave padrão, que retornará nulo para tipos de referência e zero para tipos de valores numéricos. Para estruturas, ele retornará cada membro da estrutura inicializado como zero ou nulo, dependendo de serem tipos de valor ou referência. O exemplo a seguir da classe GenericList mostra como usar a palavra-chave padrão. Para mais informações, consulte Visão geral sobre genéricos.

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

Especifica o valor padrão do parâmetro type. Isso será nulo para tipos de referência e zero para tipos de valor.

Ver padrão

A defaultpalavra-chave retorna o valor "padrão" ou "vazio" para uma variável do tipo solicitado.

Para todos os tipos de referência (definidos com class, delegate, etc.), isto é null. Para os tipos de valor (definidos com struct, enum, etc.) é um valor de todos os zeros-(por exemplo, int 0, DateTime 0001-01-01 00:00:00, etc.).

É usado principalmente com código genérico que pode ser aplicado aos tipos de referência e de valor, porque você não pode atribuir nulla uma variável de tipo de valor.

Ele definirá o valor padrão de um objeto para uma variável: nulo para tipos de referência e 0 para tipos de valor.

Talvez isso possa ajudá-lo:

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

Não é possível atribuir nulo a tipos genéricos. O motivo é que um tipo genérico também pode ser instanciado como um tipo de valor e nulo é permitido apenas com tipos de referência. Para contornar esse problema, você pode usar a palavra-chave padrão. Com a palavra-chave padrão, null é atribuído aos tipos de referência e 0 é atribuído aos tipos de valor.

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

A palavra-chave padrão possui vários significados, dependendo do contexto em que é usada. A instrução switch usa um padrão para definir o caso padrão e, com os genéricos, o padrão é usado para inicializar tipos genéricos como nulos ou 0, dependendo se é um tipo de referência ou valor.

Quando restrições não foram aplicadas para restringir um parâmetro de tipo genérico a ser um tipo de referência, um tipo de valor, como uma estrutura, também pode ser passado. Nesses casos, comparar o parâmetro de tipo com nulo sempre seria falso , porque uma estrutura pode estar vazia, mas nunca nula

Código errado

public void TestChanges<T>(T inputValue)

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

           }
            catch
            {
                // ignore this.
            }
        }

corrigido

public void TestChanges<T>(T inputValue)

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

           }
            catch
            {
                // ignore this.
            }
        }