这种友谊可以通过分离接口和实现来模拟。其思想是:“需要一个具体实例，但限制该实例的构造访问”。

例如

interface IFriend { }

class Friend : IFriend
{
    public static IFriend New() { return new Friend(); }
    private Friend() { }

    private void CallTheBody() 
    {  
        var body = new Body();
        body.ItsMeYourFriend(this);
    }
}

class Body
{ 
    public void ItsMeYourFriend(Friend onlyAccess) { }
}

尽管ItsMeYourFriend()是公共的，但只有Friend类可以访问它，因为其他人不可能获得Friend类的具体实例。它有一个私有构造函数，而工厂New()方法返回一个接口。

有关详细信息，请参阅我的文章《朋友和内部接口成员，免费为接口编码》。

Some have suggested that things can get out of control by using friend. I would agree, but that doesn't lessen its usefulness. I'm not certain that friend necessarily hurts the OO paradigm any more than making all your class members public. Certainly the language will allow you to make all your members public, but it is a disciplined programmer that avoids that type of design pattern. Likewise a disciplined programmer would reserve the use of friend for specific cases where it makes sense. I feel internal exposes too much in some cases. Why expose a class or method to everything in the assembly?

我有一个ASP。NET页面，它继承了我自己的基页，而基页又继承了System.Web.UI.Page。在本页中，我有一些代码，用于在受保护的方法中处理应用程序的最终用户错误报告

ReportError("Uh Oh!");

现在，我有了一个包含在页面中的用户控件。我希望用户控件能够调用页面中的错误报告方法。

MyBasePage bp = Page as MyBasePage;
bp.ReportError("Uh Oh");

如果ReportError方法是受保护的，它就不能这样做。我可以将它设置为内部的，但它会暴露给程序集中的任何代码。我只是想把它暴露给当前页面的一部分UI元素(包括子控件)。更具体地说，我希望我的基控件类定义完全相同的错误报告方法，并简单地调用基页中的方法。

protected void ReportError(string str) {
    MyBasePage bp = Page as MyBasePage;
    bp.ReportError(str);
}

我相信像friend这样的东西可以很有用，并且可以在语言中实现，而不会使语言变得不那么“面向对象”，比如作为属性，这样你就可以让类或方法成为特定类或方法的朋友，允许开发人员提供非常特定的访问。也许就像……(伪代码)

[Friend(B)]
class A {

    AMethod() { }

    [Friend(C)]
    ACMethod() { }
}

class B {
    BMethod() { A.AMethod() }
}

class C {
    CMethod() { A.ACMethod() }
}

在我之前的例子中，可能会有如下内容(有人可能会争论语义学，但我只是想让大家理解):

class BasePage {

    [Friend(BaseControl.ReportError(string)]
    protected void ReportError(string str) { }
}

class BaseControl {
    protected void ReportError(string str) {
        MyBasePage bp = Page as MyBasePage;
        bp.ReportError(str);
    }
}

在我看来，朋友概念并不比将事物公开，或创建公共方法或属性来访问成员更有风险。如果朋友允许数据可访问性的另一个粒度级别，并允许你缩小可访问性，而不是用内部或公共来扩大它。

B.s.d。

有人说，朋友伤害纯粹的孤独。我同意这一点。

还有人说，朋友会帮助封装，我也同意这一点。

我认为友谊应该添加到OO方法中，但不像在c++中那样。我想有一些字段/方法，我的朋友类可以访问，但我不希望他们访问我所有的字段/方法。在现实生活中，我会让我的朋友们进入我的私人冰箱，但我不会让他们进入我的银行账户。

我们可以按照下面的方法实现它

    class C1
    {
        private void MyMethod(double x, int i)
        {
            // some code
        }
        // the friend class would be able to call myMethod
        public void MyMethod(FriendClass F, double x, int i)
        {
            this.MyMethod(x, i);
        }
        //my friend class wouldn't have access to this method 
        private void MyVeryPrivateMethod(string s)
        {
            // some code
        }
    }
    class FriendClass
    {
        public void SomeMethod()
        {
            C1 c = new C1();
            c.MyMethod(this, 5.5, 3);
        }
    }

这当然会生成一个编译器警告，并将损害智能感知。但它会起作用的。

另一方面，我认为一个自信的程序员应该在不访问私有成员的情况下进行测试单元。这已经超出了本文的范围，但请尝试阅读TDD。 然而，如果你仍然想这样做(有c++喜欢的朋友)，尝试一些像

#if UNIT_TESTING
        public
#else
        private
#endif
            double x;

所以你写的所有代码都没有定义UNIT_TESTING，当你想要进行单元测试时，你在文件的第一行添加#define UNIT_TESTING(并在#if UNIT_TESTING下编写所有进行单元测试的代码)。这应该小心处理。

因为我认为单元测试对于朋友的使用是一个不好的例子，所以我想举一个例子来说明为什么我认为朋友可以是好的。假设你有一个破碎的系统(类)。随着使用，破碎系统磨损，需要翻新。现在，你希望只有有执照的技工才能修理它。为了让这个例子不那么琐碎，我想说机械师会用他的私人螺丝刀来修理它。这就是为什么机制类应该是breakingSystem类的朋友。

关于信息，. net中另一个相关但不完全相同的东西是[InternalsVisibleTo]，它允许一个程序集指定另一个程序集(例如单元测试程序集)，该程序集(有效地)具有对原始程序集中的类型/成员的“内部”访问。

这种友谊也可以通过使用“代理”——一些内部类来模拟。考虑下面的例子:

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.
  }
}

如果只用于访问静态成员，则会简单得多。 这种实现的好处是，所有类型都在友谊类的内部作用域中声明，并且与接口不同，它允许访问静态成员。

拥有编程领域的朋友或多或少被认为是“肮脏的”，容易被滥用。它破坏了类之间的关系，破坏了OO语言的一些基本属性。

也就是说，这是一个很好的特性，我自己在c++中使用过很多次;并且也想在c#中使用它。但我敢打赌，因为c#的“纯”OOness(与c++的伪OOness相比)，MS决定因为Java没有朋友，关键字c#也不应该(开玩笑;))

严肃地说:内部关系不如朋友关系好，但它确实能完成工作。请记住，您很少会不通过DLL将代码分发给第三方开发人员;因此，只要您和您的团队了解内部类及其使用，就应该没问题。

让我来澄清一下friend关键字是如何破坏OOP的。

私有和受保护的变量和方法可能是OOP中最重要的部分之一。对象可以保存只有它们可以使用的数据或逻辑的思想允许您编写独立于环境的功能实现—并且您的环境不能更改它不适合处理的状态信息。通过使用friend，你将两个类的实现耦合在一起——这比仅仅耦合它们的接口要糟糕得多。