关于.net：C＃中的朋友类用例的解决方法

Workaround for an use-case of friend classes in C#

考虑以下代码模式：

1
2
3
4
5
6
7
8
9
10
11

// Each foo keeps a reference to its manager
class Foo
{
private FooManager m_manager;
}

// Manager keeps a list of all foos
class FooManager
{
private List<Foo> m_foos;
}

问题：无法创建新的foo并在foomager中同时更新m_foos列表，也无法在新foo实例中更新m_manager引用，而不会公开公开某些特权(并且存在有人将该列表与实际foos取消同步的风险)。

例如，可以在foo中实现构造函数foo(foomager管理器)。它可以设置m_管理器引用，但无法访问m_foos列表。或者可以在管理器中实现createfoo()方法。它可以访问m foo列表，但无法在foo中设置mfoo管理器。

在C++中，很明显地声明FooManger-Foo的一个朋友来表达设计意图，但是这在C语言中是不可能的。我也知道我可以让foo成为foomager的一个内部类来获得访问权，但这也不是一个解决方案(如果foo可以属于多个manager类呢？)

顺便说一句，我知道.NET中的"内部"访问，但它要求foo和foomager单独生活在一个程序集中，这是不可接受的。

在不公开私人物品的情况下，有什么解决办法吗？

相关讨论

它总是在internalsvisibletoattribute，但这听起来像黑客。隐藏在背后的接口的东西呢？
这样的知识将不允许的用户界面看起来像食物和_让m m _经理去从同步？
CAN foomanager是变成了一个工厂的foo？经理知道的话，它创建的所有食品。
"内藏：但如何变化_ foomanager M IT经理没有被公开访问foo？
为什么要到更多的组件和分捡好吗？即使有其他类应在组装，他们的朋友和hostiles(AS或其他一些呼叫他们。
如果创建的是foomanager foo是简单的设置，然后在创建foo(即，它是传递到构造函数的实际foo那时)。除非你需要改变售后经理创作(这似乎是奇怪的)这似乎更容易和更多的实践者和知识#线C / Java代码是写在传统的工厂类是必需的。一个人试图避免拼写参考和有工厂/经理是一个Singleton对象，因此不需要记住所有的参考。
内藏"@：foomanager到foo(foomanager invoke(经理)的构造函数，这个构造函数必须是公共的。有其他人这样做desyncing invoke CAN信息，位置信息。
你有一个伟大的例子如何在大学的朋友#漆C CAN，因为问题的理论。事实上你有被拒绝的一个可能的解决方案(尤其是在组件组装的解决方案，站在为朋友关系)-我不知道这一实际应用中已经来了，或如果这是一个rallying Cry for微软实施的朋友。如果前，我很好奇为什么我不大会工作的解决方案，因为它适合99%"的要求，但这是不可接受的"条款)。坦率地说，在一些点，我愿意信任我的尝试：他们如果需要或火灾)
解决方案：内藏大会，虽然在理论solves问题，是最好的一个，因为黑客问题的地方。foomanager foo /结尾可能会包含一些不属于一类组装两个更不只是研究。本presumably分裂成两个(或更多的连续组装，如果有更多的人foomanager实例foo()A是一个样的杀戮飞炮。
为"内藏"和"A rallying微软"现实生活"的问题，它的两个。我遇到问题的朋友，除了C #哭很经常。在C + +类I CAN接口严格安全使用的朋友。我有一个C #(几年后)学会活在低级的解决方案是不公开大学制作的东西吨。只是一个tradeoffs #使用C。
声明一个a飞炮"是"为什么我所管理的方法。是的，有人可以使用一improperly公共构造函数，但不是所有的解决方案必须技术。朋友是一个在复杂条件(生产成本搜索"C++模板的朋友和我认为问题")是一个可接受的权衡。我还没有尝试在我的流氓和CRP在经理模式还将继续……如果他们做的不只是一个BUG，固定和生命去。因为人民的混乱相比，CAN(但通常不在鸭)型语言(例如，C #)是一个合理的妥协。

如果我理解正确：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public abstract class FooBus
{
protected static FooBus m_bus;
}

public sealed class Foo : FooBus
{
private FooManager m_manager;

public Foo(FooManager fm)
{
if (fm == null)
{
throw new ArgumentNullException("Use FooManager.CreateFoo()");
}

if (m_bus != fm)
{
throw new ArgumentException("Use FooManager.CreateFoo()");
}

m_manager = fm;
}
}

public class FooManager : FooBus
{
private List<Foo> m_foos = new List<Foo>();

public Foo CreateFoo()
{
m_bus = this;
Foo f = new Foo(this);
m_foos.Add(f);
m_bus = null;

return f;
}
}

相关讨论

createfoo签名中的FooManager fm是什么？
@克里斯，谢谢，复制粘贴错误，已修复：)
嗯，这不是一个好的解决方案，因为有人可以直接调用new foo()，而m_foos列表将是无效的。(顺便说一句，我知道FOO施工人员面前有公众)
@Kaalus你说得对，这个解决方案不起作用，但还不能找到更好的解决方案。
@Kaalus又一次尝试，看看吧。
@皮特，谢谢你的努力，我很感激。请不要把我的批评看作是负面的。所以这是：(1)这不是线程安全的。(2)这会产生运行时错误而不是编译错误。(3)其他人可以继承foobus和still desync list和m_manager引用(4)即使可以使其工作，这显然是一个太多的黑客，不可能是一个通用设计模式的有效实现：(-)(5)我们需要c：中的友元声明。-(
@Kaalus 1)是的，但是我们这里没有讨论生产质量代码：)2)您引用的是1吗？，3)这不是真的，但foomager类必须密封，4)可能，这取决于您希望如何严格地使用它，这个实现表5)在c中加上fried，在我看来，弊大于利。
@Petr(2)不，我正在引用答案中的内容。您可以编写看起来像是取消同步列表和M_管理器的代码，但只有在运行时才会失败。理想情况下，甚至不可能写它(编译错误)。(3)为什么这是不真实的，是什么阻止了我写一个继承自foobus的类？(5)缺少朋友是此类问题(以及其他问题)的根本原因-它会阻止您使几个类一起工作并访问它们的私有数据。没有朋友，就一定是一个班。正如这个问题所显示的，在某些情况下，这还不够。
@好吧，我明白了。好吧，不管怎样，最好是有运行时错误，而不是保留运行中的行为错误的代码。
@好吧，我明白了。好吧，不管怎样，最好是有运行时错误，而不是保留运行中的行为错误的代码。3)你说得对，我错了。但这仍然需要对内部结构进行更深入的了解，并且意外使用的可能性很低。5)我不认为这是一个问题，只是你想要确切的设计(例如没有addfoo和setfoomanger方法)。大多数代码在运行时都会破坏不正确的使用，不可能使所有的编译时都安全。

您可以在不同类型的命名空间中创建类，我们称其为"模块"(不要被class关键字愚弄，这不是真正的类)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public static partial class FooModule {

// not visible outside this"module"
private interface IFooSink {
void Add(Foo foo);
}

public class Foo {
private FooManager m_manager;
public Foo(FooManager manager) {
((IFooSink)manager).Add(this);
m_manager = manager;
}
}

public class FooManager : IFooSink {
private List<Foo> m_foos = new List<Foo>();
void IFooSink.Add(Foo foo) {
m_foos.Add(foo);
}
}

}

由于"module"是一个分部类，所以您仍然可以在同一编译单元的其他文件中创建它内部的其他成员。

一个选项是为实现公共接口的foo使用私有嵌套类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public interface IFoo
{
// Foo's interface
}

public sealed class FooManager
{
private readonly List<Foo> _foos = new List<Foo>();

public IFoo CreateFoo()
{
var foo = new Foo(this);
_foos.Add(foo);
return foo;
}

private class Foo : IFoo
{
private readonly FooManager _manager;

public Foo(FooManager manager)
{
_manager = manager;
}
}
}

由于foo类是一个私有的嵌套类，它不能在foomager之外创建，因此foomager的CreateFoo()方法确保所有内容保持同步。

相关讨论

像这样的怎么样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class FriendClass
{
public void DoSomethingInMain()
{
MainClass.FriendOnly(this);
}
}

public class MainClass
{
public static void FriendOnly(object Caller)
{
if (!(Caller is FriendClass) /* Throw exception or return */;

// Code
}
}

当然，这并不妨碍用户这样做：

1
2
3
4
5
6
7

public class NonFriendClass
{
public void DoSomething()
{
MainClass.FriendOnly(new FriendClass());
}
}

我想有办法解决这个问题，但我的任何想法都开始变得过分了。

我正在考虑使用反射。

对于失败的设计(clr中缺少朋友)没有好的解决方案。

相关讨论

在本例中，唯一可以使关系不同步的是foo和管理器本身。在管理器上调用create foo()以创建"托管foo"。其他人可以创建一个foo，但如果没有经理的"同意"，他们就无法让经理管理它。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public class Foo
{
private FooManager m_manager;

public void SetManager(FooManager manager)
{
if (manager.ManagesFoo(this))
{
m_manager = manager;
}
else
{
throw new ArgumentException("Use Manager.CreateFoo() to create a managed Foo");
}
}
}

public class FooManager
{
private List<Foo> m_foos = new List<Foo>();

public Foo CreateFoo()
{
Foo foo = new Foo();
m_foos.Add(foo);
foo.SetManager(this);

return foo;
}

public bool ManagesFoo(Foo foo)
{
return m_foos.Contains(foo);
}
}

有一个基类如何？

1
2
3
4

class FooBase
{
protected static readonly Dictionary<Foo,FooManager> _managerMapping = new Dictionary<Foo,FooManager>();
}

然后foo和foomager将foo base作为基类，可以在不对外公开的情况下更新它们的映射。然后您可以确保没有人会从外部更改此集合。

然后在foo中，您有一个属性Manager，它将返回与之相关联的经理，类似的，Manager中的foos属性将提供所有foo。

相关讨论