不使用“Internal”的 C# 类设计或“静态”？

Question

我想在类中实例化一堆数据，并且对于每个变量，我想确保还定义了一组特定的方法。 IE：

[TypeA] VarA
[TypeB] VarB
[TypeC] VarC

FA1() which is a function of VarA and VarB
FA2() which is a function of VarA and VarC

FB1() which is a function of VarB and VarA
FB2() which is a function of VarB and VarC
...

由于会有大量变量（因此会有更多函数），我想将源代码分成可管理的块。因此，我正在寻找一种自动方法来确保每个变量的所有函数都被实例化。

我想出了 3 种可能的方法来组织我的代码，但我对每种方法都不太满意，我正在寻找或建议哪种方法更好（或者即使我错过了完全不同的实现方法）：

<强>1。部分类

partial class Base
{
}

partial class Base 
{
  [TypeA] VarA;

  FA1 { .. };  // function of VarA and VarB
  FA2 { .. };  // function of VarA and VarC
}


partial class Base 
{
  [TypeB] VarB;

  FB1 { .. };  // function of VarB and VarA
  FB2 { .. };  // function of VarB and VarC
}

优点：

1. 简单
2. 变量只能从基类内部访问。
3. 如果有两个相同类型的变量，那么每个变量的函数可以不同地实现自己的函数。

缺点：

1. 无法自动确保为每个变量创建所有函数，
2. 需要手动确保每个函数名称之间不存在名称冲突。

请注意，缺点可以通过某种代码生成器来解决（也许是时候学习 T4？？）

---

2。内部类

class Base 
{
  internal [ClassA] ObjA = new [ClassA]();
  internal [ClassB] ObjB = new [ClassB]();
}

class [BaseClassA]
{
  public [TypeA] VarA;

  public virtual F1 { .. };
  public virtual F2 { .. };
}

class [ClassA] : [BassClassA]
{
  public override F1 { .. };  // function of VarA and ObjB.VarB
  public override F2 { .. };  // function of VarA and ObjC.VarC
}
...

优点：

1. 类层次结构强制创建所有函数并访问变量。
2. 通过使用虚拟函数可以创建函数的实例特定实现。

缺点：

1. 使用内部意味着数据在程序集中任何地方都可见。

---

3.静态数据

abstract class Data
{
   static [TypeA] VarA;
   static [TypeB] VarB;
   ...
}

abstract class [BaseClassA] : Data
{
  public virtual F1 { .. };
  public virtual F2 { .. };
}

class [ClassA] : [BassClassA]
{
  public override F1 { .. };  // function of VarA and VarB
  public override F2 { .. };  // function of VarA and VarC
}

class Base 
{
 [ClassA] ObjA = new [ClassA]();
 [ClassB] ObjB = new [ClassB]();
}

优点：

1. 系统确保所有例程都被实例化
2. 数据不会在程序集周围爆炸
3. 在每个函数中，您可以按照“部分类”解决方案直接引用其他变量

缺点：

1. 使用静态 闻起来就像我刚刚重新发明了全球数据。

---

我想要的是以某种方式挑选每个方法的最佳点：

1. 访问“部分类”和“静态”方法的变量的直接方式
2. “部分类”方法的本地数据
3. 自动执行该方法的函数实现“内部”和“静态”方法。

我想避免：

1. “部分类”中缺乏强制函数生成
2. “内部”方法中数据的全局访问
3. “静态”方法中全局数据的重新发明

如果我要让我的德鲁瑟斯我想说，我想要的是以某种方式将接口应用于变量的实例 - 例如：

[TypeA] VarA : IFunctions;
[TypeB] VarB : IFunctions;

并以某种方式让编译器从接口名称和可用名称自动生成最终函数名称。

因此，人们可以建议他们更愿意实施这 3 种方法中的哪一种，或者建议任何其他可能适合的方法。

Answer 1

您提供了四个代码示例，“简单”版本以便您可以解释问题，然后提供 3 个“更好”的解决方案来解决问题。唯一不言自明的版本是简单版本。所以，我想到了明年必须维护的可怜的开发人员（可能是忘记自己做了什么的你）。

那么，您是否可以考虑一种完全不同的机制来“确保每个变量的所有函数都被实例化”。您提到愿意在编译时使用 T4 自动生成存根。使用 Microsoft FxCop< /a> 捕获任何您忘记添加内容的实例。

如果您不熟悉它，Microsoft FxCop（也嵌入在某些版本的 Visual Studio 中）扫描已编译的程序集，并针对您的代码评估数百条框架规则，从变量的正确拼写和大小写到未使用的局部变量。

虽然我个人同意 Microsoft 捆绑到 FxCop 中的大部分规则，但我认为它的真正美妙之处在于能够创建自己的规则。我创建了添加到 FxCop 中的规则，以强制执行 CRUD 原则，例如，如果您有一个 CreateXxx 方法，则必须有一个DeleteXxx 方法等。因此，如果您确定一个与您想要的模式匹配的类，您可以获得所有变量 {A, B, C} 的列表，然后保证 FuncAB(A, B) 存在并且 FuncAC(A, C) 存在等。

然后，即使是当初级开发人员下次实现 IBiVariableFunction 并忘记对上的函数时，他会被 FxCop 抓住。

干杯，阿德里安

Answer 2

你的问题基本上没有任何实际背景，很难理解。您提供了三个“答案”，但没有明确的问题（imo）。

坦率地说，如果您想确保您所说的每个“变量”都有关联的方法，您应该考虑使用接口，并使用属性代替字段（因为接口不能指定字段。）

interface IAStuff {
    TypeA AProp { get; }
    void DoSomethingToA();
}

interface IBStuff {
    TypeB BProp { get; }
    void DoSomethingToB();
}

public class Foo : IAStuff, IBStuff {
    TypeA AProp { get; private set; }
    TypeB BProp { get; private set; }

    void DoSomethingToA() { ... }
    void DoSomethingToB() { ... }
}

如果类声明它实现了接口，则它别无选择，只能提供指定的成员，否则将无法编译。

希望这有帮助，

-Oisin

Answer 3

你能不能不使用建议2，而是使用protected 而不是internal？