What is the C# equivalent of C++ friend keyword?

In C++, the friend keyword allows external functions or classes to access private and protected members of a class. C# does not have a direct equivalent to the friend keyword, but there are several approaches to achieve similar functionality.

Understanding the friend Concept

A friend function in C++ is defined outside a class but has access to all private and protected members of that class. While C# doesn't support this directly, it provides alternative mechanisms to control access between closely related classes.

Using Nested Classes

The closest equivalent to C++ friend functionality is using nested classes. A nested class can access all private members of its outer class −

using System;

public class Outer {
    private int privateValue = 100;
    private string privateMessage = "Hello from Outer";

    public class Inner {
        public void AccessOuterMembers(Outer outerInstance) {
            Console.WriteLine("Accessing private value: " + outerInstance.privateValue);
            Console.WriteLine("Accessing private message: " + outerInstance.privateMessage);
            outerInstance.privateValue = 200;
            Console.WriteLine("Modified private value: " + outerInstance.privateValue);
        }
    }

    public void ShowValue() {
        Console.WriteLine("Current value: " + privateValue);
    }
}

public class Program {
    public static void Main() {
        Outer outer = new Outer();
        Outer.Inner inner = new Outer.Inner();
        
        Console.WriteLine("Before inner class access:");
        outer.ShowValue();
        
        Console.WriteLine("\nInner class accessing outer:");
        inner.AccessOuterMembers(outer);
        
        Console.WriteLine("\nAfter inner class modification:");
        outer.ShowValue();
    }
}

The output of the above code is −

Before inner class access:
Current value: 100

Inner class accessing outer:
Accessing private value: 100
Accessing private message: Hello from Outer
Modified private value: 200

After inner class modification:
Current value: 200

Using internal Access Modifier

Another approach is using the internal access modifier, which allows access within the same assembly −

using System;

public class BankAccount {
    internal decimal balance = 1000m;
    private string accountNumber = "12345";

    internal void InternalDeposit(decimal amount) {
        balance += amount;
        Console.WriteLine($"Internal deposit: {amount}, New balance: {balance}");
    }
}

public class BankHelper {
    public void ProcessAccount(BankAccount account) {
        Console.WriteLine($"Current balance: {account.balance}");
        account.InternalDeposit(500m);
    }
}

public class Program {
    public static void Main() {
        BankAccount account = new BankAccount();
        BankHelper helper = new BankHelper();
        
        helper.ProcessAccount(account);
    }
}

The output of the above code is −

Current balance: 1000
Internal deposit: 500, New balance: 1500

Using Static Helper Classes

You can also create static helper classes that work with internal members −

using System;

public class Calculator {
    internal double value;
    
    public Calculator(double initialValue) {
        value = initialValue;
    }
    
    public void ShowResult() {
        Console.WriteLine($"Result: {value}");
    }
}

public static class CalculatorHelper {
    public static void PerformComplexOperation(Calculator calc) {
        calc.value = Math.Pow(calc.value, 2) + 10;
        Console.WriteLine("Complex operation performed");
    }
}

public class Program {
    public static void Main() {
        Calculator calc = new Calculator(5);
        Console.WriteLine("Initial state:");
        calc.ShowResult();
        
        CalculatorHelper.PerformComplexOperation(calc);
        Console.WriteLine("After helper operation:");
        calc.ShowResult();
    }
}

The output of the above code is −

Initial state:
Result: 5
Complex operation performed
After helper operation:
Result: 35

Comparison of Approaches

Conclusion

While C# doesn't have a direct friend equivalent, nested classes provide the closest functionality by allowing full access to private members. The internal access modifier and static helper classes offer alternative approaches for controlled access between related classes within the same assembly.