Static keyword in C# full Explanation
The `static` keyword in C# is used to declare members
(fields, methods, properties, etc.) that belong to the type itself rather than
instances of the type. Here's a full explanation of the `static` keyword and
its usage in C#:
1.
Static Fields:
v A
static field is a field that belongs to the type itself rather than individual
instances of the type.
v All
instances of the type share the same static field.
v Static
fields are initialized only once, at the first access, and retain their value
throughout the lifetime of the program.
v Example:
class MyClass
{
public static int count; // Static field
public void Increment()
{
count++;
}
}
// Usage:
MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass();
obj1.Increment();
Console.WriteLine(MyClass.count); // Output: 1
obj2.Increment();
Console.WriteLine(MyClass.count); // Output: 2
2.
Static Methods:
v A
static method is a method that belongs to the type itself and does not require
an instance of the type to be called.
v Static
methods can only access other static members (fields, methods, properties) of
the type and cannot access instance members.
v They
are useful for utility methods, helper functions, or operations that don't
require access to instance-specific data.
v Example:
class MathUtils
{
public static int Add(int a, int b)
{
return a + b;
}
}
// Usage:
int sum = MathUtils.Add(3, 5); // Calling the static method directly
3.
Static Properties:
v A
static property is a property that belongs to the type itself, rather than
individual instances of the type.
v Static
properties provide a way to access and modify shared data or state related to
the type.
v They
can have a getter and/or setter, just like instance properties.
v Example:
class Logger
{
public static string LogPath { get; set; } // Static property
}
// Usage:
Logger.LogPath = "C:\\logs\\app.log"; // Accessing the static property
4.
Static Constructors:
v A
static constructor is a special constructor that is used to initialize static
members of a type.
v It
is called automatically before any static member of the type is accessed or any
instance of the type is created.
v Static
constructors are executed only once, regardless of the number of instances or
static member accesses.
v Example:
class MyClass
{
static int count;
static MyClass()
{
count = 0;
}
public static void Increment()
{
count++;
}
}
// Usage:
MyClass.Increment();
5.
Static Classes:
v A
static class is a class that can only contain static members (fields, methods,
properties).
v It
cannot be instantiated, and its members can be accessed directly through the
class itself, without creating instances.
v Static
classes are often used for utility classes that provide a collection of related
helper methods or constants.
v Example:
static class MathUtils
{
public static int Add(int a, int b)
{
return a + b;
}
}
// Usage:
int sum = MathUtils.Add(3, 5); // Calling the static method directly from
the class
The `static` keyword allows you to define members
that are associated with the type itself rather than individual instances. It
provides a way to share and manage data or behavior across multiple instances
or without the need for creating instances. Understanding and properly using
the `static` keyword can help you design and implement efficient and reusable
code in C#.
0 Comments