Alice和Bob

Question

我是C＃的新手，我有一个问题，在C ++中我通常会使用friend标识符。现在我知道C＃中不存在friend关键字，但我对如何解决这个问题没有任何经验（除了将所有类变量设为公共属性，如果可以的话我想避免）

我有以下情况：

public class A 
{
    public string Info { get; set; }
    /* much more data */
}

public class B
{
    private A m_instanceOfA;

    public B(A a) { m_instanceOfA = a; }

    public Info { get return A.info; set A.Info  = value; }

    /* And some more data of its own*/
}

public class C
{
    private A m_instanceOfA;

    // I need a constructor of C, which needs to set C.m_instanceOfA
    // to the same value as b.m_instanceOfA.
    public C(B b) { m_instanceOfA = b.m_instanceOfA ; } // <--- Not allowed!

    /* And some more data of its own*/
}

有没有其他聪明的方法，不公开B.m_instanceOfA，给C访问此变量（仅在构造函数中）？

Answer 1

您可以使用下面显示的技巧在Bob上创建只能由FriendRecieveMessageFromAlice调用的方法Alice。如果没有对私有成员使用反射，邪恶的类Eve将无法调用该方法。

我很想知道其他人之前是否提出过这个或其他解决方案。几个月来我一直在寻找这个问题的解决方案，而且我没有看到一个确保真正的friend语义，只要不使用反射（你几乎可以绕过任何东西）。

Alice和Bob

public interface IKey { }

public class Alice
{
    // Alice, Bob and Carol must only have private constructors, so only nested classes can subclass them.
    private Alice() { }
    public static Alice Create() { return new Alice(); }

    private class AlicePrivateKey : Alice, IKey { }

    public void PublicSendMessageToBob() {
        Bob.Create().FriendRecieveMessageFromAlice<AlicePrivateKey>(42);
    }

    public void FriendRecieveMessageFromBob<TKey>(int message) where TKey : Bob, IKey {
        System.Console.WriteLine("Alice: I recieved message {0} from my friend Bob.", message);
    }
}

public class Bob
{
    private Bob() { }
    public static Bob Create() { return new Bob(); }

    private class BobPrivateKey : Bob, IKey { }

    public void PublicSendMessageToAlice() {
        Alice.Create().FriendRecieveMessageFromBob<BobPrivateKey>(1337);
    }

    public void FriendRecieveMessageFromAlice<TKey>(int message) where TKey : Alice, IKey {
        System.Console.WriteLine("Bob: I recieved message {0} from my friend Alice.", message);
    }
}

class Program
{
    static void Main(string[] args) {
        Alice.Create().PublicSendMessageToBob();
        Bob.Create().PublicSendMessageToAlice();
    }
}

夜

public class Eve
{
    // Eve can't write that, it won't compile:
    // 'Alice.Alice()' is inaccessible due to its protection level
    private class EvePrivateKey : Alice, IKey { }

    public void PublicSendMesssageToBob() {
        // Eve can't write that either:
        // 'Alice.AlicePrivateKey' is inaccessible due to its protection level
        Bob.Create().FriendRecieveMessageFromAlice<Alice.AlicePrivateKey>(42);
    }
}

工作原理

技巧是方法Bob.FriendRecieveMessageFromAlice需要一个（虚拟）泛型类型参数作为令牌。该泛型类型必须从Alice和虚拟接口IKey继承。

由于Alice本身并未实现IKey，因此调用者需要提供一些实现Alice的{{1}}子类。但是，IKey只有私有构造函数，所以它只能被嵌套类子类化，而不能被其他地方声明的类子化。

这意味着只有嵌套在Alice中的类才能将其子类化以实现Alice。这就是IKey的作用，并且由于它被声明为私有，只有AlicePrivateKey可以将其作为Alice的泛型参数传递，因此只有Bob.FriendRecieveMessageFromAlice可以调用该方法。 / p>

然后我们反过来做同样的事情，只有Alice才能调用Bob。

泄漏密钥

值得注意的是，在调用时，Alice.FriendRecieveMessageFromBob可以访问Bob.FriendRecieveMessageFromAlice泛型类型参数，并可以使用它来欺骗来自TKey的另一种方法{{1}接受Alice。因此，使密钥继承自不同的接口会更安全：第一个是OtherClass.OtherMethod<OtherTkey>，第二个是OtherTKey : Alice, IKey。

比C ++好友

更好

即使Alice, IBobKey本身也无法调用自己的方法Alice, IOtherKey。
Bob可以让多个朋友拥有不同的朋友方法：
```
Bob
```

我有兴趣知道是否有某种方法可以比蛮力的试验和错误更有效地找到这样的技巧。某种“C＃类型系统的代数”，它告诉我们哪些限制可以强制实施，哪些不能实施，但我没有看到任何关于这类主题的讨论。

Answer 2

内部

您可以使用internal关键字。然后，您的类型（或类型成员）将仅对同一程序集中的其他类型可见;还有：

如果您需要从其他程序集中显示内部类型，则可以使用InternalsVisibleToAttribute。此属性以整个程序集为目标，通常写在AssemblyInfo.cs文件中。

PS：在C＃中不存在Friend关键字，但是存在友谊的概念（与C ++中的不完全相同），它在MSDN的Friend Assemblies文章中有所描述。另请注意，friend keyword exists in VB.NET与C＃internal关键字具有完全相同的行为。

Answer 3

我修改了您发布的代码，因此它应该可以正常运行：

using System.Reflection;
using System.Diagnostics;

public class A 
{
    public string Info { get; set; }
    /* much more data */
}

public class B
{
    private A m_instanceOfA;
    public string Info { get; set; }

    public B(A a) => Info = a;

    private readonly ConstructorInfo friend = typeof(C).GetConstructor(new Type[] { typeof(B) });
    public A InstanceOfA
    {
        get
        {
            if (new StackFrame(1).GetMethod() != friend)
               throw new Exception("Call this property only inside the constructor of C");
            return this.m_instanceOfA;
        }
    }
}

public class C
{
    private A m_instanceOfA;

    // Only the constructor of C can set his m_instanceOfA
    // to the same value as b.m_instanceOfA.
    public C(B b)
    {
        Info = b.InstanceOfA; // Call the public property, not the private field. Now it is allowed and it will work too, because you call it inside the constructor of C. In Main method, for example, an exception will be thrown, if you try to get InstanceOfA there.
    }
}

Answer 4

我认为你正在寻找“内部”关键字 - 基本上只对同一个程序集中的类可见

或者你可以这样（原谅方法名称！）：

public interface IAmAFriendOfB {
   void DoSomethingWithA(A instanceOfA);
}

public class B {
    private A m_instanceOfA;

    public B(A a) { m_instanceOfA = a; }

    public void BeFriendlyWith(IAmAFriendOfB friend) {
       friend.DoSomethingWithA(m_instanceOfA);
    }

    // the rest of your class
}

public class C : IAmAFriendOfB {

    private A m_instanceOfA;

    public C(B b) {
        b.BeFriendlyWith(this);
    }

    void DoSomethingWithA(A instanceOfA) {
        m_instanceOfA = b.m_instanceOfA;
    }   
}

Answer 5

您只能使用5个辅助功能修饰符：

公开访问不受限制。

protected 访问仅限于从包含类派生的包含类或类型。

内部访问仅限于当前程序集。

受保护的内部 访问仅限于从包含类派生的当前程序集或类型。

<强>私有访问仅限于包含类型。

Answer 6

这是使用带有internal单例实例的private类的另一种替代方法，它允许您微调哪些方法暴露给伪 - friend类。

using System;

namespace Test
{
    public class A 
    {
        public string Info { get; set; }
        /* much more data */
    }

    public class B
    {
        private A m_instanceOfA;

        public B(A a) { m_instanceOfA = a; }

        public string Info
        {
            get { return m_instanceOfA.Info; }
            set { m_instanceOfA.Info = value; }
        }

        // requires an instance of a private object, this establishes our pseudo-friendship
        internal A GetInstanceOfA(C.AGetter getter) { return getter.Get(m_instanceOfA); }

        /* And some more data of its own*/
    }

    public class C
    {
        private A m_instanceOfA;

        private static AGetter m_AGetter; // initialized before first use; not visible outside of C

        // class needs to be visible to B, actual instance does not (we call b.GetInstanceOfA from C)
        internal class AGetter
        {
            static AGetter() { m_AGetter = new AGetter(); } // initialize singleton

            private AGetter() { } // disallow instantiation except our private singleton in C

            public A Get(A a) { return a; } // force a NullReferenceException if calling b.GetInstanceOfA(null)
        }

        static C()
        {
            // ensure that m_AGetter is initialized
            System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof(AGetter).TypeHandle);
        }

        public C(B b)
        {
            m_instanceOfA = b.GetInstanceOfA(m_AGetter);
        }

        public string Info
        {
            get { return m_instanceOfA.Info; }
            set { m_instanceOfA.Info = value; }
        }

        /* And some more data of its own*/
    }

    public class Test
    {
        public static void Main()
        {
            A a = new A();
            B b = new B(a);
            C c = new C(b);
            c.Info = "Hello World!";
            Console.WriteLine(a.Info);
        }
    }
}

Live Demo

C.AGetter类无法在其自身之外实例化，因此C.m_AGetter（同时为private和static）表示只能从C内访问的单例实例{1}}。由于B.GetInstanceOfA需要C.AGetter的实例，这会使该函数在C之外无用。该函数标记为internal以最大限度地减少其暴露，但该参数也应作为一种自我文档形式，不适合常用。

接口替代方案有可能使方法超出其预期范围（例如，实现接口的类不应该访问公开的方法），而这种方法可以防止这种情况发生。 friend访问的反对者可能仍然反对它，但这使事情更接近预期的范围。

C＃等同于C ++好友关键字？

6 个答案:

Alice和Bob

夜

工作原理

泄漏密钥

比C ++好友

内部