Partial Method Declaration, Implementation and Usage in C#

Partial methods in C# are a feature that allows a method to be defined in one part of a partial class and implemented in another part. Partial classes and methods are often used in code generation scenarios, where some parts of the code are generated automatically and other parts are customized by the developer.

Here are the rules for creating and using partial methods in C#:

1. Partial Methods Declaration:

   Partial methods are declared using the partial keyword in a partial class or struct. The declaration of a partial method contains only the method signature, without an implementation.

partial void MyPartialMethod(int x);

2. Partial Method Implementation:

   The partial method can be implemented in another part of the partial class or struct. The implementation of a partial method is optional, and it's not an error if the partial method is never implemented.

partial void MyPartialMethod(int x)
{
 // Implementation code here
}

3. Usage of Partial Methods:

   Partial methods can be called like any other method within the partial class. If the partial method is not implemented, any calls to it are removed by the compiler at build time, minimizing overhead.

public void SomeMethod()
{
 // Call the partial method
 MyPartialMethod(42);
}

4. Visibility and Modifiers:

   Partial methods can have any visibility modifier (public, private, protected, internal, etc.). They can also have modifiers like static, virtual, abstract, sealed, and override as applicable.

partial void MyPartialMethod(int x);

5. Return Type and Parameters:

   Partial methods can have any return type, including void. They can also have parameters, including optional parameters.

partial void MyPartialMethod(int x, string message = "Default message");

6. Partial Method Signature Constraints:

   The signature (name, return type, and parameters) of a partial method must be the same in both the declaration and the implementation.

partial void MyPartialMethod(int x);
partial void MyPartialMethod(int x) // Valid, matching signature
{
 // Implementation code here
}

7. One Declaration, One Implementation:

   A partial method can have at most one declaration and at most one implementation. If there are multiple declarations or implementations, it will result in a compilation error.

// Error: Multiple partial method declarations with the same name and signature
partial void MyPartialMethod(int x);
partial void MyPartialMethod(int x);

// Error: Multiple partial method implementations with the same name and signature
partial void MyPartialMethod(int x)
{
 // Implementation 1
}

partial void MyPartialMethod(int x)
{
 // Implementation 2
}

Partial methods are commonly used in scenarios where generated code needs to call into user-defined code without requiring the user to implement the method if it's not needed.