C#中重载的构造函数类似于Delphi(具有多个名称)

Question

我试图将一些代码从Delphi移植到C#,我发现了一个无法以合理的方式实现的构造,同时遵守.NET Framework设计指南(我在问题的最后解决).

显然,C#,Java,C++(以及许多其他语言)提供了方法/构造函数重载的含义,但Delphi构造函数还可以有多个名称.这样就可以编写直接代表意图的代码:

var
  Data, ParI, ParD, Locl: TDataElement;
begin
  Data := TDataElement.Create('Element');
  ParI := TDataElement.CreateParam('IntElement', 22);
  ParD := TDataElement.CreateParam('DblElement', 3.14);
  Locl := TDataElement.CreateLocal('LocalElement');
  // ... use the above objects ...
end;

简化代码如下:

unit DataManager;

interface

TDataElement = class
  FName: string;
  FPersistent: Boolean;
public
  constructor Create(AName: string);
  constructor CreateParam(AName: string; DefaultInt: Integer); overload;
  constructor CreateParam(AName: string; DefaultDouble: Double); overload;
  constructor CreateLocal(AName: string);
  property Name: string read FName;;
  property Persistent: Boolean read FPersistent;
end;

implementation

constructor TDataElement.Create(AName: string);
begin
  FName := AName;
  FPersistent := True;
  // ... other initialization ...
end;

constructor TDataElement.CreateParam(AName: string; DefaultDouble: Double);
begin
  Create(AName); 
  // ... use DefaultInt ...
end;

constructor TDataElement.CreateParam(AName: string; DefaultInt: Integer);
begin
  Create(AName); 
  // ... use DefaultDouble...
end;

constructor TDataElement.CreateLocal(AName: string);
begin
  Create(AName); 
  FPersistent := False;
  // ... other code for local (non-persistent) elements ...
end;

特别是在C#构造函数中,必须与该类具有相同的名称,因此首先我尝试将行为与枚举区分开来.唉,我偶然发现了几个问题:

• 每个构造函数中的第一个参数是相同的类型(ElementKind)
• 构造函数不像Delphi那样易于识别(Create vs. CreateParam vs. CreateLocal)
• DataElement的子类需要格外小心
• 错误的可能性,比如指定ElementKind.DoubleParam并传递整数值
• 处理本地元素需要额外的bool参数

首次尝试如下:

public enum ElementKind
{
    Regular, IntParam, DoubleParam, Local
}

public class DataElement
{
    private string FName;
    public string Name { get { return FName; } }

    private bool FPersistent;
    public bool Persistent { get { return FPersistent; } }

    public DataElement(ElementKind kind, string name)
    {
        FName = name;
        // ugly switch :-(
        switch (kind)
        {
            case ElementKind.Regular:
            case ElementKind.IntParam:
            case ElementKind.DoubleParam:
                FPersistent = true;
                break;
            case ElementKind.Local:
                FPersistent = false;
                break;
        }
        // ... other initialization ...
    }

    public DataElement(ElementKind kind, string name, int defaultInt)
        : this(kind, name)
    {
        // ... use defaultInt ...
    }

    public DataElement(ElementKind kind, string name, double defaultDouble)
        : this(kind, name)
    {
        // ... use defaultDouble ...
    }

    // Redundant "bool local" parameter :-(
    public DataElement(ElementKind kind, string name, bool local)
        : this(kind, name)
    {
        // What to do when "local" is false ???

        // ... other code for local (non-persistent) elements ...
    }
}

public class Program
{
    public void Run()
    {
        DataElement data = new DataElement(ElementKind.Regular, "Element");
        DataElement parI = new DataElement(ElementKind.IntParam, "IntElement", 22);
        DataElement parD = new DataElement(ElementKind.DoubleParam, "DblElement", 3.14);
        DataElement locl = new DataElement(ElementKind.Local, "LocalElement");
    }
}

然后我尝试了更多面向对象的方法来按类型区分构造函数,同时在Run()方法中保持相同的初始化代码:

public class ElementKind
{
    public class RegularElement
    {
        internal RegularElement() { /* disallow direct creation */ }
    }
    public class IntParamElement
    {
        internal IntParamElement() { /* disallow direct creation */ }
    }
    public class DoubleParamElement
    {
        internal DoubleParamElement() { /* disallow direct creation */ }
    }
    public class LocalElement
    {
        internal LocalElement() { /* disallow direct creation */ }
    }

    public static readonly ElementKind.RegularElement Regular = new RegularElement();
    public static readonly ElementKind.IntParamElement IntParam = new IntParamElement();
    public static readonly ElementKind.DoubleParamElement DoubleParam = new DoubleParamElement();
    public static readonly ElementKind.LocalElement Local = new LocalElement();
}

public class DataElement
{
    private string FName;
    public string Name { get { return FName; } }

    private bool FPersistent;
    public bool Persistent { get { return FPersistent; } }

    protected DataElement(string name)
    {
        FName = name;
        // ... other initialization ...
    }

    public DataElement(ElementKind.RegularElement kind, string name)
        : this(name)
    {
        FPersistent = true;
    }

    public DataElement(ElementKind.IntParamElement kind, string name, int defaultInt)
        : this(name)
    {
        FPersistent = true;
        // ... use defaultInt ...
    }

    public DataElement(ElementKind.DoubleParamElement kind, string name, double defaultDouble)
        : this(name)
    {
        FPersistent = true;
        // ... use defaultDouble ...
    }

    public DataElement(ElementKind.LocalElement kind, string name)
        : this(name)
    {
        FPersistent = false;

        // ... other code for "local" elements ...
    }
}

public class Program
{
    public void Run()
    {
        DataElement data = new DataElement(ElementKind.Regular, "Element");
        DataElement parI = new DataElement(ElementKind.IntParam, "IntElement", 22);
        DataElement parD = new DataElement(ElementKind.DoubleParam, "DblElement", 3.14);
        DataElement locl = new DataElement(ElementKind.Local, "LocalElement");
    }
}

一切都编译好,效果很好.那我的问题是什么？.NET Framework设计指南和名为Microsoft FxCop的工具.通过这个工具运行最后一个代码后,我遇到了多个破解问题(见下文).

问题是:如何设计我的类以符合.NET设计指南和最佳实践？

打破 - 确定性90% - 嵌套类型不应该是可见的 - ElementKind + RegularElement打破 - 确定性90% - 嵌套类型不应该是可见的 - ElementKind + IntParamElement打破 - 确定性90% - 嵌套类型不应该是可见的 - ElementKind + DoubleParamElement打破 - 确定性90% - 嵌套类型不应该是可见的 - ElementKind + LocalElement

打破 - 确定性90% - 静态持有者类型不应该有构造函数 - ElementKind

打破 - 确定性75% - 标识符不应包含类型名称 - DataElement.#.ctor(ElementKind + IntParamElement,System.String,System.Int32)

打破 - 确定性75% - 标识符不应包含类型名称 - DataElement.#.ctor(ElementKind + DoubleParamElement,System.String,System.Double)

非中断 - 确定性25% - 不要声明只读可变引用类型 - ElementKind.#Regular

非中断 - 确定性25% - 不要声明只读可变引用类型 - ElementKind.#IntParam

非中断 - 确定性25% - 不声明只读可变引用类型 - ElementKind.#DoubleParam

非中断 - 确定性25% - 不声明只读可变引用类型 - ElementKind.#Local

Answer 1

对于初学者来说,我会取代你的嵌套"ElementKind" class有enum:

public enum ElementKind
{
    RegularElement,
    IntParamElement,
    DoubleParamElement,
    LocalElement
}

另外,我认为您的Delphi代码不需要映射到构造函数.你可能最好使用返回a的静态工厂方法DataElement.例如:

public static DataElement Create(string name)
{
    return new DataElement(ElementKind.Regular, name);
}

public static DataElement CreateParam(string name, int defaultInt);
{
    return new DataElement(ElementKind.IntParam, name);
    // ... use defaultInt ... 
}

// similar to above
public static DataElement CreateParam(string name, double defaultDouble); 
public static DataElement CreateLocal(string name);

由于您正在使用工厂函数来创建DataElement对象,因此您应该将构造函数设为私有.

然后,您将更新Run()函数以使用它们,如下所示:

public void Run() 
{ 
    DataElement data = DataElement.Create("Element");
    DataElement parI = DataElement.CreateParam("IntElement", 22);
    DataElement parD = DataElement.CreateParam("DblElement", 3.14); 
    DataElement locl = DataElement.CreateLocal("LocalElement"); 
} 

更新:我包含了对您的Run()功能的建议更改并更正了基本的Create()工厂方法(我相信它应该返回"常规" DataElement).