重铸为派生类型

Question

我有一个问题，我不知道如何解决，我希望这里的人能提供一些好的建议。

我正在解析文本文件，其中包含多个日志（每行一个日志）。格式如下：

Date Type Description
10/20 A LogTypeADescription
10/20 B LogTypeBDescription
10/20 C LogTypeCDescription

在这里，您可以看到日志有三种“类型”（A、B 和 C）。根据日志的类型，我将以不同的方式解析“Description”字段。

我的问题是我应该如何设置数据结构？ 我想做这样的事情：

class Log
{
  DateTime Date;
  String Type;
  String Description;

  public Log(String line)
  {
      Parse(line);
  }
}

class ALog : Log { }
class BLog : Log { }
class CLog : Log { }

现在，每个派生类都可以有自己独特的属性，具体取决于“描述”字段的解析方式，并且它们仍将维护三个“核心”属性（日期、类型和描述） ）。

到目前为止一切都很好，除了在解析日志文件中的行之前我不知道我需要什么类型的（派生）日志。当然，我可以解析该行，然后弄清楚它，但我真的希望解析代码位于“Log”构造函数中。我希望我能做这样的事情：

void Parse(String line)
{
   String[] pieces = line.Split(' ');
   this.Date = DateTime.Parse(pieces[0]);
   this.Type = pieces[1];
   this.Description = pieces[2];

   if(this.Type == "A")
     this = new ALog();
   else if(this.Type == "B")
     this = new BLog();
   else if(this.Type == "C")
     this = new CLog();
}

但不幸的是我认为这是不可能的。 我还没有尝试过，但我很确定这样做：

Log l = new Log(line);
if(l.Type == "A") l = new ALog();

要么是非法的，要么会破坏我第一次创建“日志”时所做的所有解析。

有什么建议吗？

Answer 1

删除构造函数并将 Parse 更改为返回 Log 的静态。

static Log Parse(string line)
{
     string[] tokens  line.Split(' ');
     var log = null;
     if (tokens[1] == "A") log = new ALog();
     else if (tokens[1] == "B") log = new BLog();
     else log = new CLog();
     log.Date = tokens[0];
     log.Description = tokens[1];
     return log;
}

Answer 2

我会将描述解析分解为一个抽象方法，该方法可以针对不同的描述类型进行覆盖。只有描述有所不同，因此只有这部分行解析需要分解为派生类型中包含的逻辑。

using System;

class Log
{
    DateTime Date;
    String Type;
    String Description;

    public Log(String line)
    {
        String[] pieces = line.Split(' ');
        this.Date = DateTime.Parse(pieces[0]);
        this.Type = pieces[1];
        LogParser parser = GetParser(this.Type);
        this.Description = parser.Parse(pieces[2]);
    }

    static LogParser GetParser(string type)
    {
        switch (type)
        {
            case "A":
                return new AParser();
            case "B":
                return new BParser();
            case "C":
                return new CParser();
            default:
                throw new NotSupportedException();
        }
    }
}

abstract class LogParser { public abstract string Parse(string line);}

class AParser : LogParser { public override string Parse(string line) { /* do parsing for A */ return string.Empty; } }
class BParser : LogParser { public override string Parse(string line) { /* do parsing for B */ return string.Empty; } }
class CParser : LogParser { public override string Parse(string line) { /* do parsing for C */ return string.Empty; } }

Answer 3

您可以像这样拆分读取该行，然后读取“类型”并调用 Activator 创建从（可能是抽象的）基本日志派生的具体类型之一，将拆分参数传递给创建新的特定具体实例的构造函数。

（此外，“类型”可能是派生类中的只读属性，因为您知道基于实例类型的值）。

当然，假设您不想避免反思。

Answer 4

还有另一个解决方案。放下你的面向对象锤子，拿起你的功能锤子。

C# 有字典和匿名函数。拥有一个函数字典，该字典知道如何获取Log和描述，并可以解析该信息并将其放入Log中。然后你只需parseDescription[logType](this, description)。

这意味着您需要一个具有 3 个函数的字典，而不是 3 个新类。

在这个例子中差异并没有那么大。但请考虑日志条目中是否有 2 个不同的字段可能需要以多种方式进行解析。基于类的方法需要 9 个新类，而字典方法有 2 个字典，每个字典有 3 个函数。如果有 3 个，则比较将是 27 个类与 3 个字典，每个字典有 3 个函数。

Answer 5

重新审视 joncham 和 btilly 的方法：

using System;

class Log
{
    DateTime Date;
    String Type;
    String Description;
    Dictionary<string,LogParser> logDictionary;

    static Log()
    {
        logDictionary = new Dictionary<string,LogParser>;

        logDictionary.Add("A",new AParser());
        logDictionary.Add("B",new BParser());
        logDictionary.Add("C",new CParser());
    }

    public Log(String line)
    {
        String[] pieces = line.Split(' ');    
        this.Date = DateTime.Parse(pieces[0]);    
        this.Type = pieces[1];
        LogParser parser = GetParser(this.Type);
        this.Description = parser.Parse(pieces[2]);
    }

    static LogParser GetParser(string type)
    {
        return logDictionary<string,LogParser>(type);
    }
}

abstract class LogParser { public abstract string Parse(string line);}

class AParser : LogParser { public override string Parse(string line) { /* do parsing for A */ return string.Empty; } }
class BParser : LogParser { public override string Parse(string line) { /* do parsing for B */ return string.Empty; } }
class CParser : LogParser { public override string Parse(string line) { /* do parsing for C */ return string.Empty; } }