How to Invoke a Private Method Using Reflection in C#: What BindingFlags Does GetMethod() Need?

Table of Contents#

1. What is Reflection in C#?
2. Why Invoke Private Methods?
3. Prerequisites
4. Step-by-Step Guide to Invoking Private Methods
   • 4.1 Understanding BindingFlags
   • 4.2 Invoking an Instance Private Method
   • 4.3 Invoking a Static Private Method
5. Common Pitfalls to Avoid
6. Best Practices
7. Conclusion
8. References

What is Reflection in C#?#

Reflection is a namespace (System.Reflection) and set of APIs that enable runtime inspection and manipulation of .NET types. With reflection, you can:

• Retrieve metadata about types (e.g., class names, base types, attributes).
• Access and invoke methods, properties, fields, and constructors—including non-public members.
• Dynamically create instances of types.

Reflection bypasses compile-time access checks, making it a double-edged sword: powerful but risky if overused. It can break encapsulation, reduce performance, and introduce maintenance issues if misapplied.

Why Invoke Private Methods?#

Private methods are designed to be internal to a class, so invoking them directly is generally discouraged. However, there are legitimate scenarios where it becomes necessary:

• Unit Testing: Testing private helper methods in legacy codebases where refactoring to expose them publicly is impractical.
• Debugging: Temporarily invoking private logic to diagnose issues in closed-source libraries.
• Interoperability: Working with third-party code that only exposes private methods for critical functionality.

Note: Always prefer testing through public APIs when possible. Use reflection on private methods as a last resort.

Prerequisites#

To follow along, you’ll need:

• Basic knowledge of C# and object-oriented programming (classes, methods, access modifiers).
• A C# development environment (e.g., Visual Studio, Rider, or .NET CLI).
• Familiarity with exceptions (reflection often throws runtime exceptions that need handling).

Step-by-Step Guide to Invoking Private Methods#

To invoke a private method via reflection, follow these steps:

4.1 Understanding BindingFlags#

BindingFlags is an enum that specifies how reflection APIs (like Type.GetMethod()) search for members. For private methods, you must combine specific flags to narrow the search to non-public members and specify whether the method is an instance or static member.

Key BindingFlags for Private Methods:#

Critical Combination: To find a private method, use BindingFlags.NonPublic plus either BindingFlags.Instance (for instance methods) or BindingFlags.Static (for static methods). Omitting Instance/Static will cause GetMethod() to return null, even if NonPublic is set.

4.2 Invoking an Instance Private Method#

Let’s walk through invoking a private instance method with a concrete example.

Example Class:#

Suppose we have a BankAccount class with a private instance method CalculateInterest() that computes interest on a balance:

public class BankAccount
{
    private decimal _balance;
 
    public BankAccount(decimal initialBalance)
    {
        _balance = initialBalance;
    }
 
    // Private instance method to calculate interest (e.g., 5% annual rate)
    private decimal CalculateInterest(int months)
    {
        return _balance * 0.05m * (months / 12m);
    }
}

Step 1: Get the Type Object#

First, retrieve the Type object representing the BankAccount class. This can be done using typeof(BankAccount) (for compile-time types) or instance.GetType() (for runtime instances):

Type bankAccountType = typeof(BankAccount); // or new BankAccount(1000).GetType()

Step 2: Locate the Private Method with GetMethod()#

Use Type.GetMethod() with the method name and required BindingFlags. For an instance private method, we need BindingFlags.NonPublic | BindingFlags.Instance:

// Get the private instance method "CalculateInterest" with 1 int parameter
MethodInfo calculateInterestMethod = bankAccountType.GetMethod(
    name: "CalculateInterest",
    bindingAttr: BindingFlags.NonPublic | BindingFlags.Instance,
    binder: null,
    types: new[] { typeof(int) }, // Parameter types (to handle overloads)
    modifiers: null
);

• name: The exact name of the private method (case-sensitive).
• bindingAttr: NonPublic | Instance to target private instance methods.
• types: An array of Type objects representing the method’s parameter types (critical for overloaded methods).

Step 3: Invoke the Method with MethodInfo.Invoke()#

Once you have the MethodInfo object, use MethodInfo.Invoke() to call the method. For instance methods, pass the object instance as the first parameter; for static methods, pass null:

// Create an instance of BankAccount (required for instance methods)
var account = new BankAccount(initialBalance: 1000m);
 
// Invoke the private method with parameters (e.g., 6 months)
object result = calculateInterestMethod.Invoke(
    obj: account, // Instance to invoke on (null for static)
    parameters: new object[] { 6 } // Arguments for the method
);
 
// Cast the result to the expected type (decimal)
decimal interest = (decimal)result;
Console.WriteLine($"Interest: ${interest}"); // Output: Interest: $25.00

4.3 Invoking a Static Private Method#

Static private methods are invoked similarly, but with BindingFlags.Static instead of BindingFlags.Instance.

Example Class:#

Add a static private method to BankAccount for validating account numbers:

public class BankAccount
{
    // ... (previous code: _balance, constructor, CalculateInterest)
 
    // Private static method to validate account numbers
    private static bool IsAccountNumberValid(string accountNumber)
    {
        return !string.IsNullOrEmpty(accountNumber) && accountNumber.Length == 10;
    }
}

Step 2 (Revised for Static Methods):#

Use BindingFlags.NonPublic | BindingFlags.Static to locate static private methods:

// Get the private static method "IsAccountNumberValid" with 1 string parameter
MethodInfo isValidMethod = bankAccountType.GetMethod(
    name: "IsAccountNumberValid",
    bindingAttr: BindingFlags.NonPublic | BindingFlags.Static,
    types: new[] { typeof(string) } // Parameter type: string
);

Step 3 (Revised for Static Methods):#

Invoke with obj: null (since static methods belong to the type, not an instance):

// Invoke the static private method (no instance needed)
object isValid = isValidMethod.Invoke(
    obj: null, // Static methods have no instance
    parameters: new object[] { "1234567890" } // Test account number
);
 
bool result = (bool)isValid;
Console.WriteLine($"Account valid: {result}"); // Output: Account valid: True

Common Pitfalls#

Even with the right BindingFlags, invoking private methods can fail due to these common mistakes:

1. Missing Instance or Static Flag#

Forgetting to include BindingFlags.Instance (for instance methods) or BindingFlags.Static (for static methods) is the most frequent error. Without these, GetMethod() will only search for public members by default, returning null for private methods.

2. Incorrect Method Name or Parameters#

• Case Sensitivity: Method names are case-sensitive (e.g., calculateInterest ≠ CalculateInterest).
• Overloads: If the method is overloaded, GetMethod() requires explicit parameter types (types argument) to distinguish between overloads. For example, GetMethod("Add") will fail if there are Add(int) and Add(string) overloads.

3. Unhandled Exceptions#

MethodInfo.Invoke() throws exceptions for invalid inputs:

• TargetException: The instance is null for an instance method, or the instance type doesn’t match the method’s declaring type.
• ArgumentException: Parameters don’t match the method’s signature (wrong type, count, or order).
• TargetInvocationException: Wraps exceptions thrown inside the invoked method (e.g., a NullReferenceException in CalculateInterest).

Always wrap Invoke() in a try-catch block:

try
{
    var result = calculateInterestMethod.Invoke(account, new object[] { 6 });
}
catch (TargetInvocationException ex)
{
    Console.WriteLine($"Error in invoked method: {ex.InnerException.Message}");
}
catch (ArgumentException ex)
{
    Console.WriteLine($"Invalid parameters: {ex.Message}");
}

4. Cross-Assembly Access Restrictions#

Private methods in another assembly may require ReflectionPermission (granted by default in most environments like unit tests). However, internal methods (not private) may be inaccessible in strong-named assemblies unless marked with [InternalsVisibleTo].

Best Practices#

Reflection is powerful but should be used sparingly. Follow these guidelines:

1. Prefer Public APIs#

Test or interact with classes through their public interface whenever possible. Private methods are implementation details and may change without notice, breaking your reflection code.

2. Refactor Legacy Code#

If you’re using reflection to test private methods, consider refactoring: extract the private logic into a separate internal class with public methods, then use [InternalsVisibleTo("YourTestProject")] to expose it to tests.

3. Document Reflection Usage#

Always document why reflection is necessary (e.g., “Invokes private CalculateInterest to test edge cases in legacy code”). This helps future maintainers understand the rationale.

4. Handle Edge Cases#

Validate that MethodInfo is not null before invoking, and use try-catch to handle runtime errors.

Conclusion#

Invoking private methods in C# using reflection requires careful use of BindingFlags to target non-public members. The critical flags are BindingFlags.NonPublic (to access private methods) combined with BindingFlags.Instance (instance methods) or BindingFlags.Static (static methods). By following the steps outlined—retrieving the Type, locating the method with GetMethod(), and invoking with MethodInfo.Invoke()—you can safely call private methods when necessary.

Remember: Reflection bypasses encapsulation, so use it judiciously. Prefer public APIs and refactoring over reflection to keep code maintainable and robust.

References#

• Microsoft Docs: Type.GetMethod()
• Microsoft Docs: BindingFlags Enum
• Microsoft Docs: MethodInfo.Invoke()
• Microsoft Docs: Reflection in .NET