C# Private Method

public class TargetClass
{
    // Explicitly private method
    private int CalculateHash(string input)
    {
        return input.GetHashCode();
    }

    // Implicitly private method (default behavior in classes/structs/records)
    void FormatData()
    {
        // Implementation
    }

    // Type-bound access demonstration
    public void CompareHash(TargetClass otherInstance)
    {
        // Valid: Accessing a private method on a different instance of the EXACT SAME type
        int otherHash = otherInstance.CalculateHash("data"); 
    }
}

​

Access Rules and Scope

• Containing Type: Fully accessible by any other method, property, event, or constructor defined within the exact same class, struct, record, or interface.
• Type-Bound Access: The private modifier in C# is type-bound, not instance-bound. Code executing within a type can freely invoke private methods on other instantiated objects of that exact same type.
• External Invocation: Attempting to invoke a private method on an instantiated object from outside the declaring type (e.g., obj.CalculateHash("data") called from a different class) results in compiler error CS0122 due to its protection level.
• Derived Types: Inaccessible to types that inherit from the containing class or record. If a derived type requires access, the base method must be marked protected instead.
• Nested Types: Accessible to nested types defined within the containing type. A nested type implicitly shares the access context of its declaring parent type.

​

Technical Characteristics

• Implicit Default: If a method declaration within a class, struct, or record omits an access modifier, the C# compiler implicitly assigns it the private access level. Conversely, interface members default to public, meaning private methods within an interface (supported since C# 8.0) must explicitly declare the private keyword.
• Polymorphism Restrictions: Private methods cannot participate in inheritance-based polymorphism. They cannot be declared with virtual, abstract, or override modifiers because their restricted scope prevents derived classes from seeing them to provide an overridden implementation.
• IL and Binding: Invocations of private methods are resolved at compile-time (early binding). Because they cannot be overridden, the compiler typically emits a call instruction rather than a callvirt instruction in the Common Intermediate Language (CIL), which avoids virtual method table (vtable) lookups.
• Reflection Bypass: While the C# compiler strictly enforces private access restrictions during compilation, private methods can still be discovered and invoked dynamically at runtime using the .NET Reflection API by utilizing BindingFlags.NonPublic | BindingFlags.Instance (or BindingFlags.Static for static private methods).