1

我有一个类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;

    }
}
4

2 回答 2

2

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

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

如果与它的Options关联Segment比与它的关联更多，那么Element您Element甚至可能不需要拥有该Options属性，它可以简单地使用Segment's 或者它可以Options在它的方法中使用一个参数。

现在您的程序已经足够抽象，无法判断这是否合适，但请记住这一点。

于 2013-07-29T15:39:02.753 回答
1

Segment并且Element似乎只是普通的 DTO，因此应该无法使用自己的构造。

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

于 2013-07-29T15:37:47.000 回答