CODEWITHSUNDEEP
c#
NibblyPig
NibblyPig

Reputation: 52922

What does default(object); do in C#?

Googling is only coming up with the keyword, but I stumbled across some code that says 

MyVariable = default(MyObject);

and I am wondering what it means.

Upvotes: 170

Views: 141728

Answers (9)

Webleeuw
Webleeuw

Reputation: 7272

It will set the default value of an object to a variable:

  • null for reference types and
  • 0 for value types.

Upvotes: 0

Marc Gravell
Marc Gravell

Reputation: 1062510

  • For a reference-type, it returns null
  • For a value-type other than Nullable<T> it returns a zero-initialized value
  • For Nullable<T> it returns the empty (pseudo-null) value (actually, this is a re-statement of the second bullet, but it is worth making it explicit)

The biggest use of default(T) is in generics, and things like the Try... pattern:

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

As it happens, I also use it in some code-generation, where it is a pain to initialize fields / variables - but if you know the type:

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

Upvotes: 231

rahul
rahul

Reputation: 187020

Specifies the default value of the type parameter.This will be null for reference types and zero for value types.

See default

Upvotes: 6

kennytm
kennytm

Reputation: 523174

Default value of MyObject. See default Keyword in Generic Code (C# Programming Guide) (MSDN):

In generic classes and methods, one issue that arises is how to assign a default value to a parameterized type T when you do not know the following in advance:

  • Whether T will be a reference type or a value type.
  • If T is a value type, whether it will be a numeric value or a struct.

Given a variable t of a parameterized type T, the statement t = null is only valid if T is a reference type and t = 0 will only work for numeric value types but not for structs. The solution is to use the default keyword, which will return null for reference types and zero for numeric value types. For structs, it will return each member of the struct initialized to zero or null depending on whether they are value or reference types. The following example from the GenericList class shows how to use the default keyword. For more information, see Generics Overview.

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

Upvotes: 5

T.S.
T.S.

Reputation: 19330

Another good use of default(T) is when compiler can't determine returning type, like in here

class X
{
    public int? P {get; set;}
}

// assigning in code

var x = new X();

// consider coll["key"] returns object boxed value
// data readers is one such case
x.P = myReader["someColumn"] == DbNull.Value ? default(int?) : (int)myReader["someColumn"];

Upvotes: 0

Lijo
Lijo

Reputation: 6778

When constraints have not been applied to restrict a generic type parameter to be a reference type, then a value type, such as a struct, could also be passed. In such cases, comparing the type parameter to null would always be false, because a struct can be empty, but never null

wrong code 

public void TestChanges<T>(T inputValue)

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

           }
            catch
            {
                // ignore this.
            }
        }

corrected 

public void TestChanges<T>(T inputValue)

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

           }
            catch
            {
                // ignore this.
            }
        }

Upvotes: 0

perilbrain
perilbrain

Reputation: 8187

Perhaps this may help you:

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

It is not possible to assign null to generic types. The reason is that a generic type can also be instantiated as a value type, and null is allowed only with reference types. To circumvent this problem, you can use the default keyword. With the default keyword, null is assigned to reference types and 0 is assigned to value types.

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

The default keyword has multiple meanings depending on the context where it is used. The switch statement uses a default for defining the default case, and with generics the default is used to initialize generic types either to null or 0 depending on if it is a reference or value type.

Upvotes: 0

Pratik Deoghare
Pratik Deoghare

Reputation: 37172

default keyword will return null for reference types and zero for numeric value types.

For structs, it will return each member of the struct initialized to zero or null depending on whether they are value or reference types.

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

        }
    }

OUTPUT:

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

Upvotes: 22

Diego Mijelshon
Diego Mijelshon

Reputation: 52745

The default keyword returns the "default" or "empty" value for a variable of the requested type.

For all reference types (defined with class, delegate, etc), this is null. For value types (defined with struct, enum, etc) it's an all-zeroes value (for example, int 0, DateTime 0001-01-01 00:00:00, etc).

It's mostly used with generic code that can be applied to both reference and value types, because you can't assign null to a value type variable.

Upvotes: 1

Related Questions