C# 是否有更好的方法来构建应用程序选项？

我有一个类

Translator

，它有两个

解析器（选项）

实例，一个是输入解析器，一个是输出解析器。他们每个人都有自己的选择

每个解析器都有一个

ElementParser（Options）

列表，该列表向下传递选项

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

这似乎太过分了

显而易见的答案是创建一个静态的

解析器.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.
    }
}

---

段

和

元素

似乎只是普通的DTO，因此不能使用它们自己的构造

---

AddABunchOfElements（）

属于

SegmentWriter

实例，包含一个或多个

选项

您发布的内容没有问题。对一个对象的几百次引用在事物的大计划中并没有那么大

如果只有一个

选项（没有），我只会使
选项成为静态的


如果
选项
与
段
的关联性大于与
元素
的关联性，则
元素
可能甚至不需要具有
选项
属性，它可以简单地使用
段
或在其方法中使用
选项
参数

现在，您的程序已经足够抽象，无法判断这是否合适，但必须记住这一点
 你说得对。我更新了示例以显示它们不是DTO。@Greg您的编辑显示您的解析器不仅解析数据，而且保存数据。重构它，制作一个
ElementParser
抛出一个
Element
s的列表。然后，您只需要一个
ElementParser
实例就可以包含所有选项。是的，它与段关联最为密切。它永远不会在元素级别更改。实际上，我可以在段级别上使其保持静态，但同样，我害怕静态属性。“在段级别上使其保持静态”对我来说没有多大意义。一个特定的静态对象只有一个，而不是每个实例一个。每个解析器实际上是一个子类，每个子类都有自己的静态属性，因此只有一个特定的静态对象。我不是说这是一个好主意，只是一个可能的主意。@GregHollywood您的第二个示例没有
元素的集合
，但如果有，您的
元素如何知道要使用哪个
解析器的
选项
？这一点很好。我认为你最初的评论是正确的，即参考资料没有任何问题。元素解析器的数量是有限的，所以这不是一个问题。
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;

    }
}