另一个 C# 反射

Question

我有一个 csv 文件，其中每一行都是不同类型的记录。我正在解析 csv 并希望将行（各种类型的记录）存储在各种类型的自定义类中。

在每一行，我需要根据记录类型实例化不同的类。

因此，从其他反射示例中，我有以下代码；

      Type type = Type.GetType("myNamespace." + className);
      object recordclass = Activator.CreateInstance(type);

所以我有一个名为 recordclass 的正确类型的对象，但如何使用它？

我真正想做的就是访问类的属性并填充行数据，然后添加到容器类。

我想我错过了一些关于反射的运行时性质的事情。请帮我把这些点连起来！

希望一切都有意义！

TIA， 加里

Answer 1

通过您提供的示例，您可以将对象转换为您需要的实际类型：

Type type = Type.GetType("myNamespace." + className);
object recordclass = Activator.CreateInstance(type);

var record = recordClass as ConcreteRecordType;
if(record != null)
    record.Name = csv["Name"];

或者考虑使用工厂返回填充的记录对象：

public class RecordFactory
{
    RecordBase ParseCsvRow(string[] columns)
    {
        const int typeDescriminatorColumn = 0;
        switch (columns[typeDescriminatorColumn])
        {
            case "RecordTypeA":
                return new RecordTypeA(columns[1], columns[2], ...);
            case "RecordTypeB":
                return new RecordTypeB(columns[1], columns[2], ...);
            default:
                throw new InvalidOperationException("Unexpected descriminator: " + columns[typeDescriminatorColumn]);
        }
    }
}

Answer 2

如果您想通过反射将值存储到记录类的属性中，请使用此

var property = type.GetProperty(propertyName);
property.SetValue(recordclass,value,null);

Answer 3

如果您阅读文档，您将看到，Type.GetType 需要完整的限定类型名称。

Answer 4

如果我正确理解问题，您有一个包含记录文本值的文件。每条记录都存储在一行中，每行的开头是一个标识符，表示要构建哪种记录。

可以为此使用反射，但并不是真正必要。使用反射的问题是您需要知道不同记录类型的所有属性才能按名称访问它们。此时，您可能正在使用类型化对象，但如果您使用单个例程来创建所有记录（使用 CreateInstance()），那么您拥有的只是一个非类型化对象。

另一个解决方案是拥有一组例程，每个例程接收一个 IEnumerable（以逗号分隔的输入行，不包括记录 id）并返回一个对象（或一条记录，如果您有基本记录类）使用工厂来选择每行使用哪个例程。

您通过某个 ID 向工厂注册例程（您所做的记录中的第一个字段很好，它可以是记录类名称，但不一定是），并使用第一个字段迭代 CSV 行件从工厂选择方法并建立记录。

希望这个例子能更好地解释一下：？对代码量感到抱歉

示例中的构建器仅返回空记录，但从行片段填充它们应该很容易。另一个版本是仅传递行或一组行（如果一条记录可以覆盖多行）（但如果记录包含不同数量的行，则更复杂）

hth,
艾伦.

public string[] Input = new[]{
                                    "R1, F1, F2, F3",
                                    "R2, F2, F4",
                                    "R3, F2",
                                    "R3, F2",
                                    "R4, F1, F2, F3, F4"
                                };

public class RecordOne {
}
public class RecordTwo {
}
public class RecordThree {
}
public class RecordFour {
}

public class BuilderFactory {

    public BuilderFactory() {
        Builders = new Dictionary<string, Func<IEnumerable<string>, object>>();
    }

    private Dictionary<string, Func<IEnumerable<string>, object>> Builders { get; set; }


    public void RegisterBuilder(string name, Func<IEnumerable<string>, object> builder) {
        Builders.Add(name, builder);
    }
    public Func<IEnumerable<string>, object> GetBuilder(string name) {
        return Builders[name];
    }
}


[TestMethod]
public void LoadRecords() {

    var factory = new BuilderFactory();
    factory.RegisterBuilder("R1", BuildRecordOne);
    factory.RegisterBuilder("R2", BuildRecordTwo);
    factory.RegisterBuilder("R3", BuildRecordThree);
    factory.RegisterBuilder("R4", BuildRecordFour);

    var output = Input.Select(line => {
        var pieces = line.Split(',').Select(val => val.Trim());
        var builder = factory.GetBuilder(pieces.First());
        return builder(pieces.Skip(1));
    });


    Assert.IsTrue(new[] {typeof(RecordOne),
                         typeof(RecordTwo),
                         typeof(RecordThree),
                         typeof(RecordThree),
                         typeof(RecordFour)}.SequenceEqual(output.Select(rec => rec.GetType())));

}

private static RecordOne BuildRecordOne(IEnumerable<string> pieces) {
    return new RecordOne();
}

private static RecordTwo BuildRecordTwo(IEnumerable<string> pieces) {
    return new RecordTwo();
}
private static RecordThree BuildRecordThree(IEnumerable<string> pieces) {
   return new RecordThree();
}
private static RecordFour BuildRecordFour(IEnumerable<string> pieces) {
    return new RecordFour();
}