1

我有一堆数据要在一个类中实例化，并且对于每个变量，我想确保还定义了一组特定的方法。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. 只能从类 Base 中访问变量。
  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. “Partial class”和“Static”方法访问变量的直接方式
  2. “Partial class”方法的本地数据
  3. 自动执行“内部”和“静态”方法的功能实现。

我想避免：

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

如果我要让我的 druthers 我会说我想要以某种方式将接口应用于变量的实例 - 比如：

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

并且以某种方式让编译器从接口名称和变量名称中自动生成最终的函数名称。

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

4

3 回答 3

2

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

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

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

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

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

干杯，阿德里安

于 2009-09-22T03:40:14.753 回答
0

您可以不使用建议 2，而是使用受保护的而不是内部的吗？

于 2009-09-21T13:02:03.487 回答
0

您的问题在很大程度上没有任何真实背景，很难理解。您提供了三个没有明确问题的“答案”（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

于 2009-09-20T22:19:03.580 回答