The Object Class in .NET using C#

Have you ever wondered where all .NET classes are ultimately derived from? In this post, we are going to explore the System.Object class and see its benefits.

Introduction

 

In my opinion, learning the C# language is fascinating. I hope you agree, especially to those who have been using it for a while in their career. I still remember back when I was starting out, I noticed that when I typed anything within Visual Studio, it seems that everything behaves like an object. To elaborate further, for example when you have typed a literal number and magically you can invoke the ToString() method after you have typed dot (.).

 

In this blog post, we are going to discuss the System.Object class. Thus, in this post we are going to tackle the following topics:

• What is the System.Object class?
• Summarized purposes of the object class methods

What is the System.Object class?

All .NET classes are ultimately derived from the System.Object class. In fact, when you don’t specify a base class while defining a class, the compiler automatically assumes that it derives from System.Object. Lastly, because of this behavior, you have access to many public, protected member methods that have been defined for the Object class.

 

To prove some of the statements above, I have created a unit test to prove the following:

• System.Object is the parent of all classes within the .NET.
• All class builtin and/or defined is a subclass of System.Object

See the sample code below:

[Fact]
public void UnitTest_Get_Base_Class_Of_DotNet_Classes()
{
    //get the assembly name of .net core
    string assemblyFullName = "System.Private.CoreLib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e";

    //load the assembly
    Assembly assembly = Assembly.Load(assemblyFullName);

    //filter base on the following criteria
    // Doesn't have a base type because System.Object is the root of all types within the .NET Core
    // System.Object is a class and ansiclass
    TypeInfo baseOfAllClasses = assembly.DefinedTypes.FirstOrDefault(x => x.BaseType == null && x.IsClass && x.IsAnsiClass);

    string objectAlias = string.Empty;

    using (var provider = new CSharpCodeProvider())
    {
        objectAlias = provider.GetTypeOutput(new CodeTypeReference(baseOfAllClasses));
    }

    Assert.True(objectAlias == "object");

}

Above, as you can see, we have loaded the assembly System.Private.CoreLib of .NET Core and filtered into a type that has no base type, a class, and an ANSI class. As a result, we've got back the System.Object or object as the result. 

[Fact]
public void UnitTest_Check_Base_Class_Of_System_Object()
{
    object obj = new object(); //create new instance of object

    Assert.IsType<object>(obj); //check if object

    Type objType = obj.GetType();

    Assert.Null(objType.BaseType); //doesn't have a base type

    Assert.True(objType.Name == "Object");
    Assert.True(objType.FullName == "System.Object");
    Assert.True(objType.Namespace == "System");

    Assert.True(objType.IsAnsiClass);//is ansiclass
    Assert.True(objType.IsClass);//is class

}

Above, we have created a new instance of System.Object and checked some properties to see if they're valid. 

[Fact]
public void Prove_That_All_Classes_Reference_And_Value_Types_Are_Derived_From_System_Object()
{
    Assert.True(typeof(string).IsSubclassOf(typeof(object)));

    Assert.True(typeof(Array).IsSubclassOf(typeof(object)));

    // this is the main reason why value types and primitive types behaves like an object
    Assert.True(typeof(ValueType).IsSubclassOf(typeof(object)));
}

Above, we have just proved that everything is derived from the System.Object class.

Summarized purposes of the object class methods

Before dealing with the different properties and methods that we can directly inherit from the Object class, first let's try to answer this question: Why are all types in .NET derived from the object/System.Object class? 

• It gives the developer a universal behavior of the properties and methods of the object class. Therefore; it can be used in any type of the .NET core/framework. 
• Developers have the ability to pass anything generically as an object. 
• Developers can refer to objects of unknowable type, especially when using reflection. 

I might not be able to give a lot of answers to this design decision. However; the list above was base on my experience and observation with the .NET core/framework since day one. 

GetHashCode 

If you intend your class to be used as a key for a dictionary, you need to override GetHashCode. Basically, this method returns a hashcode for an object. 

ToString 

This is fairly easy, it just helps the developer to have a quick-and-easy string representation of the type used. See an example usage below.

[Fact]
public void UnitTest_ToString()
{
    Assert.True("5" == 5.ToString());
    Assert.True((89.99m).ToString() == "89.99");
    Assert.True(true.ToString() == "True");
    Assert.True(true.ToString() == bool.TrueString);
    Assert.True(false.ToString() == "False");
    Assert.True(false.ToString() == bool.FalseString);
}

Equals and ReferenceEquals

Using these two Equals and ReferenceEquals gives you the ability to compare objects. See an example usage below.

[Fact]
public void UnitTest_Object_Equals_Static_And_Virtual()
{

    Assert.True(5.Equals(5));

    object first = null;
    object second = null;

    Assert.True(object.ReferenceEquals(first, second));

    first = new object();

    Assert.False(object.ReferenceEquals(first, second));

    second = first;

    Assert.True(object.ReferenceEquals(first, second));
}

GetType

This method gives you the ability to get the type of the object. See an example of usage below. 

[Fact]
public void Unit_Test_Object_GetType()
{
    int num = 5;
    decimal num2 = 5.23m;
    string name = "jin";

    Assert.True(num.GetType() == typeof(int));
    Assert.True(num2.GetType() == typeof(decimal));
    Assert.True(name.GetType() == typeof(string));

}

Summary

 

In this blog post, we have discussed the System.Object class and gave a reasonable list of why this was beneficial. I hope you have enjoyed this blog post, as I have enjoyed writing it. You can also find the sample code here at GitHub. Until next time, Happy programming!