Question

我有一个类Translator，它有两个Parser(Options options)实例 - 输入解析器和输出解析器。他们每个人都有自己的选择。

每个解析器都有一个ElementParser(Options option)列表，用于传递选项。

如果每个解析器都有一百个元素，这意味着每个选项实例都有一百多个引用。

这似乎过分了。

显而易见的答案是创建一个静态Parser.Options属性，但传统智慧说要远离它们。

那么有更好的方法来构建它吗？

以下是一份工作样本：

public class Options {
    public int Value { get; set; }
}

public class ElementParser {
    public object ElementData { get; set; }
    public ElementParser(Options options) {
        this.Options = options;
    }
    public Options Options { get; set; }
    public void DoesSomethingWithOptions() {
        if (Options.Value == 1)
        {
            //Do something();
        }
        else
        {
            //Do something else();
        }
    }
}

public class SegmentParser{

    public object SegmentData { get; set; }
    public Options Options { get; set; }
    public List<ElementParser> ElementParsers { get; set; } 

    public SegmentParser(Options options) {
        this.Options = options;

    }

    public void AddABunchOfElements() {
        this.ElementParsers = new List<ElementParser>() {new ElementParser(this.Options), new ElementParser(this.Options)};
    }

}
class Program
{
    static void Main(string[] args) {

        var options1 = new Options() {Value = 1};
        var options2 = new Options() {Value = 2};

        var segment1 = new SegmentParser(options1);
        segment1.AddABunchOfElements();

        var segment2 = new SegmentParser(options2);
        segment2.AddABunchOfElements();
        //There are now 3 references of each options.  If there were 100 elements, there would be over 200 references.
    }
}

这是使用静态属性的第二次尝试。请注意，Parser类是子类，因此实际上只有一个静态属性的实例。此示例可以正常工作。

public class Options
{
    public int Value { get; set; }
}

public class Parser{
}

public class Parser1  : Parser
{
    public Parser1(Options options) {
        Options = options;
    }
    public static Options Options { get; set; }
}

public class Parser2  : Parser {
    public Parser2(Options options) {
        Options = options;
    }
    public static Options Options { get; set; }
}

class Program
{
    static void Main(string[] args) {

        var options1 = new Options();
        options1.Value = 1;

        var options2 = new Options();
        options2.Value = 2;

        var test1 = new Parser1(options1);

        var test2 = new Parser2(options2);

        Console.WriteLine(Parser1.Options.Value); //Should be 1
        Console.WriteLine(Parser2.Options.Value); //Should be 2;

    }
}

Answer 1

你发布的内容没有错。在宏观方案中，几百个对象的引用并不是那么大。

如果只有一个Options（没有），我只会Options静态

如果Options与Segment的关联度与Element的{{1}}关联度高于Element，则Options甚至可能不需要Segment属性，只需使用Options，或者它可以在其方法中使用{{1}}参数。

现在你的程序被抽象得足够多，以至于不可能判断这是否合适，但这是要记住的事情。

Answer 2

Segment和Element似乎只是简单的DTO，因此不能用自己的结构。

AddABunchOfElements()属于SegmentWriter个实例，其中包含一个或多个Options。

有没有更好的方法来构建应用程序选项？

2 个答案: