具有静态方法的C＃类实例与静态类内存使用情况

Question

How does C#, or other languages for that matter, handle memory allocation (and memory de-allocation) between these two scenarios:

1.) A method on a static class is invoked.

public Program {
    Foo foo = Loader.load();
}

public static Loader {
    public static Foo load() {
        return new Foo();
    }
}

2.) A method is invoked on an instance, which then falls out of scope.

public Program {
    Foo foo = new Loader().load();
}

public Loader {
    public Foo load() {
        return new Foo();
    }
}

I suppose the static class is loaded, and remains, in memory; whereas the class instance succumbs to garbage collection at C#'s leisure. Are there any pros or cons to these two paradigms? Is there ever a time when you have a class that never needs to be instantiated (ie some sort of resource loader or factory), but you use the second methodology anyway to take advantage of garbage collection?

The important part of my question is whether or not the first paradigm, while being conceptually correct in some circumstances, may suffer from holding on to memory unnecessarily.

Answer 1

Your second example doesn't work, so let's explore the real options:

1.) A method on a static class is invoked.

public Program {
   Foo foo = Loader.Load();
}

public static Loader {
   public static Foo Load() {
      return new Foo();
   }
}

2.) A static method in a non-static class is invoked.

public Program {
   Foo foo = Loader.Load();
}

public Loader {
   public static Foo Load() {
      return new Foo();
   }
}

3.) An instance method is invoked on an instance

public Program {
   Foo foo = new Loader().Load();
}

public Loader {
   public Foo Load() {
      return new Foo();
   }
}

The two first are the same. Calling a static method is the same regardless if the class is static or not.

The third option will create an instance of the class on the heap. As the class has no data members, it will only be something like 16 bytes. It will be garbage collected eventually, but due to the small size it doesn't matter much when that happens.

Calling an instance method is also slightly different from a static method. A reference to the class instance is sent along, that you can access through the this keyword. It makes little difference in this case as there is no real data in the object to access.

Answer 2

A static method, field, property, or event is callable on a class even when no instance of the class has been created.

http://msdn.microsoft.com/en-us/library/79b3xss3(VS.80).aspx

So in that sense your static methods behaves just as it would if you used it from within a class instance: it is scoped to the type.

Answer 3

The second form creates a temporary Loader object (which is very cheap). You will always have to load the Loader class, no matter which approach you choose.

There is very little performance (memory saving) to gain here. You would normally choose for a static member in a static class if there is no 'state' needed outside the methods local vars.

Answer 4

I cannot find any sources for this, but from my knowledge of programming, when you refernce a class(non static), it's structure is loaded into memory

Creating an instance of a class just to call a method, would waste a lot of processing power(due to creating an instance, assigning it memory, and the garbage collecting).

Instead of keeping the definition, and then on top of it, an instance. Why not just keep the definition(static).

As long as you don't store any data in static variables, your static method should take up the same amount of memory as your non static method definition. But using a static method, only the method will be kept in memory and be ready to be called whenever you need without creating instances. Where as, if the method is non static, it will need to be instantiated(using up memory and processing power) and the garbage collected(freeing memory and using up cpu) therefore it is definitely better using a static member. Thats what they are there for.