> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C# Private Method
A private method in C# is a member function declared with the `private` access modifier, restricting its visibility and invocation strictly to the containing type (`class`, `struct`, `record`, or `interface`). It represents the most restrictive access level in the C# type system, enforcing strict encapsulation by hiding the method's signature and implementation from external types, derived classes, and other assemblies.
```csharp theme={"dark"}
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).
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
