In this lesson, we’re going to cover static vs instance class members. Simply put, a static method or property is one which belongs to – and is therefore accessible via – the class itself, without having to create an instance in order to access it. You may have noticed, in previous lessons, that there were some methods that were called without going through an instance in order to call it; there was no “new” keyword involved before we could access these methods:
Step 1: Using Intellisense to Identify Static Methods and Properties
All of these methods are static. The easiest way to distinguish static from instance methods is that they are accessible through the class name that they belong to. If you start typing a class name into Visual Studio, Intellisense will show you what static methods and properties are available to the type itself:
To demonstrate this difference between static and instance methods, fields and properties, create a simple class that contains both:
And now in another class, let’s create an instance to see what’s available to it via Intellisense. Note how the static field and static method are not available through the instance:
Also, note how the instance field and method are not available through referencing the class itself:
Tip:
As a beginner, it’s recommend that you not use the static keyword in your own classes unless they’re classes that only contain public helper methods and that they don’t contain any properties.
Step 2: Using Static Keyword for Helper Methods
A common use for the static keyword is for whenever there is a public helper method that performs some function that isn’t instance specific. Perhaps the method just processes some data and outputs it to the screen, for example. Here is a very contrived example:
Notice how the static method PerformCalculation() references the other static method handleSomePartOfTheCalculation(). This is perfectly fine, however, it would not be possible for the static method to reference an instance method even if they both belong to the same class:
The reason this is not allowed is because instance methods, in principle, have access to (1) instance fields, properties, and methods with its own class. If handleSomePartOfTheCalculation() were to (2) reference an instance property, then PerfomCalculation() would (3) also be referencing that instance property (although indirectly). However, since PerformCalculation() is statically accessible, handleSomePartOfTheCalculation() wouldn’t know what instance, if any, is being referenced:
The reason why this doesn’t work becomes obvious when we try to call the static method:
Step 3: An Instance Can Reference a Static, But not Vice Versa
We have no way of knowing what instance is being referenced by this static method, and neither does the compiler. That is why a static method can only access other static methods and properties. However, the inverse is possible, which is to say that an instance method can access a static property. Here, we’re creating a simple static property that can count each time a new instance of type Valuation is created:
Step 4: Making an Entire Class Static**
You can also mark an entire class as static, and the only time you would do that is if the class only holds static helper methods. Note that if you do mark a class as static, it is no longer able to hold any non-static fields, properties, or methods:
Step 5: Snapshot of the Static Math Class
One such class that exists in the .NET Framework is the Math class, which is a static class that only holds static methods (for performing common calculations), along with a few constants:
As you can see, the helper methods in the Math class are all static because all they do is return some sort of numerical value. An instance is not needed to do a basic calculation:
You can find more information about this class and its methods by visiting:
