In C# Object-Oriented Programming (OOP), methods are a key component for defining the behavior of objects. A method is a block of code that performs a specific task and can be called (invoked) by other code. In OOP, methods encapsulate functionality and are associated with the objects (or instances) of a class.

Key Features of Methods in C# OOP:

1. Encapsulation of Behavior:

   • Methods encapsulate actions that an object can perform. For example, a Car class may have methods like Start(), Stop(), or Accelerate(), which describe the car’s behavior.

2. Modularity:

   • Methods break down complex problems into smaller, manageable tasks. Each method can perform a specific function, making the code modular, reusable, and easier to maintain.

3. Reusability:

   • Methods can be called multiple times from different places in the code, improving code reusability.

4. Method Signature:

   • The method signature in C# consists of the method name, return type, parameter list, and the access modifier (such as public, private, etc.). The method signature must be unique within the class to avoid conflicts.

Syntax of a Method in C#:

A basic method in C# includes:

• Access modifier (public, private, etc.).
• Return type (such as int, void, string, etc.).
• Method name.
• Parameter list (optional).
• Method body, which is the code block that defines the task the method performs.

class ClassName
{
    // Access modifier, return type, method name, and parameters
    public ReturnType MethodName(ParameterType parameter1, ParameterType parameter2)
    {
        // Method body (code)
        // Perform some task
        return result; // Optional, based on return type
    }
}

Example of a Method in C#:

class Calculator
{
    // A method to add two numbers
    public int Add(int num1, int num2)
    {
        int sum = num1 + num2;
        return sum;
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of the Calculator class
        Calculator calc = new Calculator();
        
        // Call the Add method
        int result = calc.Add(5, 3);
        
        // Output the result
        Console.WriteLine(result);  // Output: 8
    }
}

Key Concepts of Methods in C# OOP:

1. Access Modifiers:

   • Public: A public method can be accessed by any other class or code.
   • Private: A private method can only be accessed within the same class.
   • Protected: A protected method can only be accessed by the class itself and derived classes (subclasses).
   • Internal: Accessible within the same assembly but not from another assembly.

   Example:

   public void PublicMethod() { }
   private void PrivateMethod() { }
   

2. Return Type:

   • A method can return a value of any type (int, string, bool, etc.) or return void if it doesn’t return anything.

   Example:

   public int GetNumber() // returns an int
   {
       return 42;
   }
   
   public void DisplayMessage() // returns nothing (void)
   {
       Console.WriteLine("Hello, World!");
   }
   

3. Method Parameters:

   • Methods can accept inputs in the form of parameters. These parameters allow data to be passed into the method when it is called.
   • Parameters have a type and a name, and they are declared inside the parentheses following the method name.

   Example:

   public void PrintName(string name)
   {
       Console.WriteLine("Hello, " + name);
   }
   

4. Method Overloading:

   • Method overloading allows multiple methods in the same class to have the same name but different parameter lists (types, number of parameters, etc.).
   • This allows a method to perform similar operations but with different types or numbers of inputs.

   Example:

   public class MathOperations
   {
       // Overloaded methods with different signatures
       public int Add(int a, int b)
       {
           return a + b;
       }
   
       public double Add(double a, double b)
       {
           return a + b;
       }
   
       public int Add(int a, int b, int c)
       {
           return a + b + c;
       }
   }
   

5. Static Methods:

   • Static methods belong to the class itself rather than an instance (object) of the class. These methods can be called without creating an instance of the class.

   Example:

   class MathUtility
   {
       // Static method
       public static int Square(int number)
       {
           return number * number;
       }
   }
   
   class Program
   {
       static void Main()
       {
           // Call static method without creating an instance
           int result = MathUtility.Square(4);
           Console.WriteLine(result);  // Output: 16
       }
   }
   

6. Return Statement:

   • The return statement is used to return a value from a method. The type of the returned value must match the method’s return type.
   • If the return type is void, the method does not need to return any value, but you can still use the return; statement to exit the method early.

7. Recursion:

   • A method can call itself, which is known as recursion. This is useful for solving problems like calculating factorials, traversing data structures, etc.

   Example:

   public int Factorial(int n)
   {
       if (n == 0)
           return 1;
       else
           return n * Factorial(n - 1);
   }
   

8. Optional Parameters:

   • You can specify default values for method parameters. If the caller does not provide a value for these parameters, the default value is used.

   Example:

   public void DisplayInfo(string name, int age = 30)
   {
       Console.WriteLine($"Name: {name}, Age: {age}");
   }
   
   // Method call without specifying age
   DisplayInfo("John"); // Output: Name: John, Age: 30
   

9. Ref and Out Parameters:

   • C# provides the ref and out keywords to allow methods to modify arguments passed to them.

   • ref: Requires the variable to be initialized before passing it to the method.

   • out: Does not require initialization but must be assigned inside the method.

   Example:

   public void Modify(ref int number)
   {
       number += 10;
   }
   
   public void Assign(out int number)
   {
       number = 10; // Must be assigned inside the method
   }
   
   static void Main()
   {
       int x = 5;
       Modify(ref x); // x becomes 15
   
       int y;
       Assign(out y); // y becomes 10
   }
   

Conclusion:

• Methods in C# OOP encapsulate the behavior of objects and promote reusability, maintainability, and modularity.
• Methods can be defined with different access levels, return types, and parameters.
• C# provides features like method overloading, static methods, recursion, and parameter passing techniques (ref, out) to add flexibility to method usage.