Introduction to Static Keyword in C#
Static is a keyword in C# using which an item cannot be instantiated, meaning the item on which static keyword is used becomes non-instantiable, and it can be applied on classes, variables, methods, and constructors, which creates static class, static variables, static methods, static constructors and a static member. It can be created by using the keyword static in the declaration of the member, which does not belong to a specific type of object; rather, it belongs to the type itself.
Static Keyword in C# with Examples
Any member can be declared as static by using the keyword static preceding the declaration of the member. Let’s understand how to declare static class, static variables, static methods, and static constructors.
1. Declaring a Static Class
A class can be declared as a static class by using the keyword static. Only static data members, static methods and static constructors can be contained in a static class. Objects of the static class cannot be created. No inheritance can be performed in a static class.
Example
Let’s declare and understand static class through the below program:
Code:
using System;
//A static class is created using the keyword static
static class example
{
// Creating a string variable and declaring it as static using static keyword
public static string demo = "Welcome to C#";
}
//Creating a public class
public class check
{
// Calling the static main method
static public void Main()
{
//The static member of the tutorial class which is static is called
Console.WriteLine("Understanding static keyword : {0} ", example.demo);
}
}
The output of the above program is shown in the snapshot below:
4.6 (13,258 ratings)
View Course
Output:
2. Declaring a Static Variable
A variable can be declared as a static variable by using the keyword static. A single copy of the variable is created when we declare a variable as static and shared it with all the class objects. We use the name of the class to access the static variables; no object is needed to access the static variables.
Example
Let’s declare and understand static variable through the below program:
Code:
using System;
//A static class is created using the keyword static
class check {
// Creating a string variable and declaring it as static using static keyword
public static string learn = "Python";
}
//Creating a public class
public class checkvar {
// Calling the static main method
static public void Main()
{
//The static member of the check class which is static is called
Console.WriteLine("I want to learn : {0} ",
check.learn);
}
}
The output of the above program is shown in the snapshot below:
Output:
3. Declaring a Static Method
A method can be declared as a static method by using the keyword static. We use the name of the class to access the static methods; both static and non-static fields can be accessed using static methods. There is no need for objects or class name to access the static fields, whereas objects are required to access the non-static fields.
Example
Let’s declare and understand static methods through the below program:
Code:
using System;
//A static class is created using the keyword static
class students
{
// Creating a string variable and declaring it as static using static keyword
static public int number = 100;
//Creating a method and declaring it as static using static keyword
public static void count()
{
Console.WriteLine("Number of students"+
" learning python is :{0}", number);
}
}
//Creating a public class
public class display {
// Calling the static main method
static public void Main()
{
//class name is used to access the number of students
students.count();
}
}
The output of the above program is shown in the snapshot below:
Output:
4. Declaring a Static Constructor
A constructor can be declared as a static constructor by using the keyword static. A static constructor is automatically called before the instance of the constructor is run, and it is called only once in the class before the class id referenced in the program. The name of the class must be the same as the name of the constructor.
Example
Let’s declare and understand static constructor through the below program:
Code:
using System;
//A public class is created
public class constructor {
//A static constructor is defined whose name is same as the name of the class
static constructor()
{
//This statement is displayed as the first line of the output and it is executed only once
Console.WriteLine("Understanding Static Constructor");
}
// The constructor instance is created
public constructor(int a)
{
Console.WriteLine("constructor instance " + a);
}
// A public method is defined
public string details(string name, string work)
{
return "Name: " + name + " Work: " + work;
}
// Calling the public main method
public static void Main()
{
// Invoking all the constructors defined before
constructor con = new constructor(1);
Console.WriteLine(con.details("Shobha", "Data Scientist"));
//Again Invoking all the constructors defined before
constructor co = new constructor(2);
Console.WriteLine(co.details("Shobha", "Tyson"));
}
}
The output of the above program is shown in the snapshot below:
Output:
5. Working of Static Keyword in C#
A static class is similar to a non-static class, but an instance of the static class cannot be created; that is, we cannot create a variable or object of the static class using the new operator, and the members of the static class are accessed using the class name itself. For example, consider the static class System.math in the .NET framework; it consists of methods required to perform mathematical operations without any need to create the instance of math class.
Example
C# program to illustrate static class, static variable, static method, and static constructor.
Code:
using System;
//A public static class is created
public static class check
{
//A public static variable is created
public static int height;
//A static constructor is created
static check()
{
// Method is called by the constructor
height = distance(20);
}
//A static method is created
static int distance(int number)
{
return Environment.TickCount * number;
}
}
//A public class is created
public class Program
{
public static void Main()
{
//Accessing the constructor and its object
Console.WriteLine("Bird can fly upto: {0}", check.height);
}
}
The output of the above program is shown in the snapshot below:
Output:
Recommended Articles
This is a guide to Static Keyword in C#. Here we discuss the concept of static keyword in C#, which includes declaration and working of static keyword along with different examples and its code implementation. You may also have a look at the following articles to learn more –
