C# - Method modifiers or access modifiers

Method modifiers in C# are keywords used to define specific behaviors or access levels for methods in a class. Each modifier has a distinct purpose, affecting how methods can be accessed and used. Let's explore some common method modifiers in C# with examples:

1. static

Purpose: A static method belongs to the class itself rather than any specific instance of the class.

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(Calculator.Add(5, 3));
    }
}

class Calculator
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}
    

Output: 8

Explanation: The Add method is static, so it's called using the class name Calculator.

2. public

Purpose: A public method can be accessed from anywhere, both inside and outside of its containing class.

class Program
{
    static void Main(string[] args)
    {
        Greeter greeter = new Greeter();
        greeter.SayHello();
    }
}

class Greeter
{
    public void SayHello()
    {
        Console.WriteLine("Hello, World!");
    }
}
    

Output: Hello, World!

Explanation: SayHello is public, so it's accessible from the Main method in Program.

3. private

Purpose: A private method is only accessible within the class it is defined in.

class Program
{
    static void Main(string[] args)
    {
        SecretAgent agent = new SecretAgent();
        agent.PerformMission();
    }
}

class SecretAgent
{
    private void DecodeMessage()
    {
        Console.WriteLine("Message Decoded!");
    }

    public void PerformMission()
    {
        DecodeMessage();  // Accessible here
    }
}
    

Output: Message Decoded!

Explanation: DecodeMessage is private and can only be called within SecretAgent.

4. protected

Purpose: A protected method is accessible within its class and by derived class instances.

class Program
{
    static void Main(string[] args)
    {
        Child child = new Child();
        child.ShowProtectedMethod();
    }
}

class Parent
{
    protected void ProtectedMethod()
    {
        Console.WriteLine("Protected Method Called");
    }
}

class Child : Parent
{
    public void ShowProtectedMethod()
    {
        ProtectedMethod();  // Accessible here
    }
}
    

Output: Protected Method Called

Explanation: ProtectedMethod is protected and is accessible in the Child class, which inherits from Parent.

5. internal

Purpose: An internal method is accessible only within its own assembly (project).

// Assume this is in one assembly
class Program
{
    static void Main(string[] args)
    {
        InternalClass internalClass = new InternalClass();
        internalClass.ShowInternalMethod();
    }
}

internal class InternalClass
{
    public void ShowInternalMethod()
    {
        Console.WriteLine("Internal Method Accessed");
    }
}
    

Output: Internal Method Accessed

Explanation: InternalClass and its methods are internal, so they can be accessed within the same assembly.

These examples illustrate how different method modifiers in C# control the accessibility and behavior of methods within classes. Understanding these modifiers is crucial for properly managing the scope and security of your methods.

Points to Remember:

• static Modifier: Belongs to the class, not instances. Used for utility methods independent of object state.
• public Modifier: Accessible from any class or method. Forms the public interface of the class.
• private Modifier: Only accessible within the class. Used for internal class functionality.
• protected Modifier: Accessible in the class and derived classes. Balances accessibility and encapsulation.
• internal Modifier: Accessible within the same assembly. Ideal for application-internal functionalities.
• Combining Modifiers: Modifiers can be combined (e.g., protected internal) for complex behaviors.
• Impact on Inheritance: Affects method overriding and access in inherited classes.

Understanding these key points is crucial for effective method interaction and implementing encapsulation and inheritance in C#.