4

通常我希望某个类 C1 的某些（或全部）函数只能从另一个类 C2 中访问，因为 C2 是一种代理，它拥有 C1 类型的对象（例如：类“神经元”的方法，如“ connect()”，只能从“Brain”访问）。我认为这在 C# 中是不可能直接实现的，这与继承不同，在继承中我们可以使用诸如“private”或“protected”之类的关键字来指定可见性。

在这种情况下，最佳做法是什么？

4

4 回答 4

5

为您的类创建一个程序集，并将不应对外界可见的内部类声明为internal：

内部（C# 参考）：

internal关键字是类型和类型成员的访问修饰符。内部类型或成员只能在同一程序集中的文件中访问

所以，像这样：

namespace YourAssembly.Classes
{
    internal class C1
    {
        public void Foo()
        {
        
        }
    }
    
    public class C2
    {
        public void DoFoo()
        {
            new C1().Foo();     
        }
    }
}

这里C2可以从其他程序集中访问，而C1只能从同一个程序集中访问。

于 2012-12-24T15:46:19.003 回答
3

如果C1除了 之外任何人都无法访问，C2则创建C1一个private.C2

public class C2
{
    public C2() { }

    private class C1
    {
        public C1() { }
    }
}

但是，如果C1可以在 之外访问C2，那么您将需要将某种形式传递key给ctorofC2以确保它是受信任的代理。

public class C1
{
    public C1(string key)
    {
        // verify that it's a valid proxy or user of this class via the key
    }
}
于 2012-12-24T15:43:25.490 回答
0

一个经常用于测试目的的技巧是使用InternalsVisibleToAttribute。您将它应用于这样的程序集（exe 或 dll）

[assembly: InternalsVisibleTo("NameOfFriendAssembly")]

定义为的类（和其他类型）和成员internal将在内部可见，但也对程序集可见NameOfFriendAssembly

于 2012-12-24T15:50:10.703 回答
0

在我看来，最适合你的是做这样的事情：

public interface INeuron 
{
   double GetValue();
   List<INeuron> GetDependents();
   List<double> GetWeights();
}

internal class Neuron : INeuron
{
   // implementation of INeuron
   // ...

   // implementation of methods only known to own classes
   public void Connect(Neuron target, double weight)
   {
      ...
   }
}

public class Brain
{
   private List<Neuron> _allNeurons = new List<Neuron>();       

   public Brain()
   {
      Neuron n1 = new Neuron();
      Neuron n2 = new Neuron();
      n1.Connect(n2,0.5);
      _allNeurons.Add(n1);
      _allNeurons.Add(n2);
   }

   public IEnumerable<INeuron> GetAllNeurons() { return _allNeurons.Cast<INeuron>(); }
}
于 2012-12-24T16:14:22.700 回答