CODEWITHSUNDEEP
c#
Thomas
Thomas

Reputation: 12107

Why can't we access static method through the object in .net

with the following code:

public class test
{
    public static void DoSomething()
    {
        Console.WriteLine("test");
    }
}

public class test2
{
    public test2()
    {
        var a = new test();
        a.DoSomething(); // invalid
        test.DoSomething(); // is valid
    }
}

I need to access the static method through the base class, and not through the instance.

But, what would have been the downside of letting the user access it through the instance? It seems to me that it would help with readability.

Upvotes: 4

Views: 4399

Answers (6)

cmos
cmos

Reputation: 512

You can't call a static method from a class instance, because all static fields and methods are associated with the type rather than an instance of said type.

For a deeper understanding of static classes I suggest you read this.

Upvotes: 8

Yawar Murtaza
Yawar Murtaza

Reputation: 3865

I guess what you are asking is

When calling a static method, why we must specify the class that defines the method and when calling an instance method, why we must specify an instance that refers to the object of that class.

To answer this, we must understand how CLR manages things in the background. Lets try to understand what happens when a new instance is created:

When we “new” up a class’ instance, the CLR creates an object in the managed heap, this object on the heap (among other things) also contains the bytes necessary to hold all of the instance data fields defined by that class as well as any instance fields defined by any base class (say Object class). This means the instance fields are tied up with that instance of the class that we just created by newing up in our code.

Now, when calling a static method, the JIT compiler locates the class object that corresponds to the type that defines the static method. Note that it doesn’t uses the instance (object) here. Then, the JIT compiler locates the entry in the class object’s method table that refers to the method being called, JITs the method (if first time called), and calls the JITted code. Notice the difference in how CLR does the discovery of an instance and static methods.

Upvotes: 1

MakePeaceGreatAgain
MakePeaceGreatAgain

Reputation: 37000

As for every question on a language-decision you allways have to consider the use and the potential harm that is caused by your request. While it may increase your (personal) readability in a very specific case, it adds lots of confusion to readers of your code that don´t have your source-code. Furthermore it would assume a compiler is able to determine if or if not a member actually does something on the instance or not. So the compiler would have far more complicated logic in order to achieve something you can easily indicate yourself by the static keyword.

In fact an instance-method does something with an instance, it does not neccessarily modifiy its state, it can also just use that state and process some operation. Making something available on that instance-level which does not have instance-semantics seems quite counter-intuituve and breaks the principle of least astonishment - at least for me. If there is a member called on an instance it is supposed to do something with that instance. If or if not this is actually the case is an implementation-detail which a client shouldn´t bother for at all.

Upvotes: 0

T_Bacon
T_Bacon

Reputation: 404

I think this is the key line in the documentation:

Only one copy of a static member exists, regardless of how many instances of the class are created.

Only allowing access through the Class makes sense in light of the above.

Upvotes: -1

kaffekopp
kaffekopp

Reputation: 2619

Using instance.DoSomething(); would indicate your are calling a method of the instance (which of course would not be true since it is a static class member, not related to the instance iteself). Because of this, it would probably only lead to confusion.

By using MyClass.DoSomething(); it is easily understood that it is in fact a member of the class (not of an instance) you are calling. Perhaps it will be clearer if you follow standard naming conventions (class name with leading capital).

For further understanding of static members, see the Microsoft docs.

Upvotes: 0

Dogu Arslan
Dogu Arslan

Reputation: 3384

Alternatively you can create the static method as an extension method on the base class or the child class. And then you can call it directly from the object instance as you attempted.

Upvotes: 0

Related Questions