c++的friend关键字允许类a将类B指定为它的friend。这允许类B访问类A的私有/受保护成员。
我从来没有读过任何关于为什么c#(和VB.NET)中不包含这个的东西。大多数关于StackOverflow问题的答案似乎都在说它是c++的一个有用的部分，并且有很好的理由使用它。以我的经验，我不得不同意。
对我来说，另一个问题似乎是在问如何在c#应用程序中做类似于friend的事情。虽然答案通常围绕嵌套类，但它似乎没有使用friend关键字那么优雅。
最初的《设计模式》一书在其示例中经常使用它。
总之，为什么在c#中没有friend，在c#中模拟friend的“最佳实践”方法是什么?
(顺便说一下，internal关键字不是一回事，它允许整个程序集中的所有类访问内部成员，而friend允许你给某个类完全访问另一个类)
当前回答
如果你正在使用c++，你发现你自己使用friend关键字，这是一个非常强烈的迹象，你有一个设计问题，因为为什么一个类需要访问其他类的私有成员?
其他回答
你可以用c#关键字“internal”来接近c++的“朋友”。
我怀疑这与c#编译模型有关——在运行时构建IL和JIT编译。也就是说:c#泛型与c++泛型有本质区别的原因是一样的。
您可以保持它为私有，并使用反射来调用函数。测试框架可以做到这一点，如果你要求它测试一个私有函数
这种友谊也可以通过使用“代理”——一些内部类来模拟。考虑下面的例子:
public class A // Class that contains private members
{
private class Accessor : B.BAgent // Implement accessor part of agent.
{
private A instance; // A instance for access to non-static members.
static Accessor()
{ // Init static accessors.
B.BAgent.ABuilder = Builder;
B.BAgent.PrivateStaticAccessor = StaticAccessor;
}
// Init non-static accessors.
internal override void PrivateMethodAccessor() { instance.SomePrivateMethod(); }
// Agent constructor for non-static members.
internal Accessor(A instance) { this.instance = instance; }
private static A Builder() { return new A(); }
private static void StaticAccessor() { A.PrivateStatic(); }
}
public A(B friend) { B.Friendship(new A.Accessor(this)); }
private A() { } // Private constructor that should be accessed only from B.
private void SomePrivateMethod() { } // Private method that should be accessible from B.
private static void PrivateStatic() { } // ... and static private method.
}
public class B
{
// Agent for accessing A.
internal abstract class BAgent
{
internal static Func<A> ABuilder; // Static members should be accessed only by delegates.
internal static Action PrivateStaticAccessor;
internal abstract void PrivateMethodAccessor(); // Non-static members may be accessed by delegates or by overrideable members.
}
internal static void Friendship(BAgent agent)
{
var a = BAgent.ABuilder(); // Access private constructor.
BAgent.PrivateStaticAccessor(); // Access private static method.
agent.PrivateMethodAccessor(); // Access private non-static member.
}
}
如果只用于访问静态成员，则会简单得多。 这种实现的好处是，所有类型都在友谊类的内部作用域中声明，并且与接口不同，它允许访问静态成员。
如果有朋友，c++设计人员可以精确控制私有*成员暴露给谁。但是，他被迫暴露了每一个私人成员。
对于内部，c#设计器可以精确控制他所公开的私有成员集。显然，他只能暴露单个私有成员。但是，它将暴露给程序集中的所有类。
通常，设计人员只希望将少数私有方法暴露给选定的少数其他类。例如，在类工厂模式中，可能希望类C1只由类工厂CF1实例化。因此类C1可能有一个受保护的构造函数和一个友类工厂CF1。
As you can see, we have 2 dimensions along which encapsulation can be breached. friend breaches it along one dimension, internal does it along the other. Which one is a worse breach in the encapsulation concept? Hard to say. But it would be nice to have both friend and internal available. Furthermore, a good addition to these two would be the 3rd type of keyword, which would be used on member-by-member basis (like internal) and specifies the target class (like friend). * For brevity I will use "private" instead of "private and/or protected". - Nick
