Question

我有一个MyData类的列表，该类保存字节数组。我正在创建一个函数，可以将List和字符串传递给该函数，以访问字段并对其进行一些操作-主要是串联。

我正在努力的部分是通过字符串访问类字段。我不确定是否应该使用Linq或反射或两者结合使用。

我有很多数据，因此性能也是一个考虑因素。

谢谢

public class MyData
{
    public byte[] vertices;
    public byte[] indicies;
}    

public byte[] ProcessData(List<MyData> inData, string fieldName)
{          
    byteArray = new byte[inData.Sum(x => x."fieldName").Length];
    offset = 0;
    for (int i = 0; i < inData.Count; i++) {
        Buffer.BlockCopy(inData[i]."fieldName", 0, ret, offset, inData[i]."fieldName".Length);
        offset += inData."fieldName".Length;
    }

    return byteArray;
}

List<MyData> AllMyData = new List<MyData>();
//Load some data (omitted) 
var AllVertices = ProcessData(AllMyData, "vertices"); 
var AllIndicies = ProcessData(AllMyData, "indicies");

Answer 1

public byte[] ProcessData(List<MyData> inData, string fieldName)
{          
    var field = inData.GetType().GetField(fieldName);
    if (field == null)
          throw new ArgumentException("Invalid field name", nameof(fieldName));

    byte[] bytesField = field.GetValue(inData) as byte[];

    var byteArray = new byte[bytesField.Sum().Length];
    var offset = 0;

    for (int i = 0; i < inData.Count; i++) {
        Buffer.BlockCopy(bytesField[i], 0, ret, offset, bytesField.Length);
        offset += bytesField.Length;
    }

    return byteArray;
}

Answer 2

如果可以将字段选择表示为不是字符串，而是表示为函数，则将比反射更快（）：

public byte[] ProcessData(List<MyData> inData, Func<MyData, byte[]> field)
{          
    var byteArray = new byte[inData.Sum(x => field(x).Length)];
    var offset = 0;
    for (int i = 0; i < inData.Count; i++) {
        Buffer.BlockCopy(field(inData[i]), 0, byteArray, offset, field(inData[i]).Length);
        offset += field(inData[i]).Length;
    }

    return byteArray;
}

var allVertices = ProcessData(AllMyData, x => x.vertices); 
var allIndicies = ProcessData(AllMyData, x => x.indicies);

通过字符串访问List <class>的字段

2 个答案: