Question

我有一个来自Linq-To-Sql查询的大型数据集（IEnumerable [Table] - 属于类对象），我需要从中生成一个CSV文件。我循环遍历数据集，对于每个项目，我使用各种格式选项将项目的每个属性的值转换为字符串。

Type t = typeof(T);
var properties = t.GetProperties();

foreach (var item in list)
{
    foreach (var property in properties)
    {
        // This is made using delegates, but whatever
        object value = property.GetValue(item, null);
        // convert to string and feed to StringBuilder
    }
}

问题是转换运行查询所需的时间更长。数据集包含严重非规范化的数据 - 许多项具有相同的属性，具有相同的值，并且只有一些属性具有不同的值。每个属性值都会针对数据集中的每个项目单独翻译。所以我的代码将相同的数据转换为相同的字符串 - 一遍又一遍。我想以某种方式加快速度，最好不要改变SQL查询。

看起来MemoryCache class可以工作，但我需要为每个对象制作唯一的键。我无法弄清楚如何可靠而有效地制作这样的钥匙。

如何使用MemoryCache以便我可以为不同类型的对象缓存翻译结果？

Answer 1

如果你只是想加快速度，我建议ExpressionTrees比MemoryCache更多。这假设您没有想要读取的嵌套对象，我可以对第一个项目使用反射，并且它对于IEnumerable中的每个项目都是相同的 - 从问题中的示例代码看起来是正确的。

此外，如果它很大并且您只是将其写入文件，我建议直接使用FileStream而不是StringBuilder。

public class CSV
{
    public static StringBuilder ToCSV(IEnumerable list)
    {
        Func<object, object[]> toArray = null;
        var sb = new StringBuilder();

        // Need to initialize the loop and on the first one grab the properties to setup the columns
        foreach (var item in list)
        {
            if (toArray == null)
            {
                toArray = ItemToArray(item.GetType());
            }
            sb.AppendLine(String.Join(",", toArray(item)));
        }

        return sb;
    }

    private static Func<object, object[]> ItemToArray(Type type)
    {
        var props = type.GetProperties().Where(p => p.CanRead);
        var arrayBody = new List<Expression>();

        // Create a parameter to take the item enumeration
        var sourceObject = Expression.Parameter(typeof (object), "source");
        // Convert it to the type that is passed in
        var sourceParam = Expression.Convert(sourceObject, type);

        foreach (var prop in props)
        {
            var propType = prop.PropertyType;

            if (IsValueProperty(propType))
            {
                // get the value of the property
                Expression currentProp = Expression.Property(sourceParam, prop);
                // Need to box to an object if value type
                if (propType.IsValueType)
                {
                    currentProp = Expression.TypeAs(currentProp, typeof (object));
                }
                // Add to the collection of expressions so we can build the array off of this collection
                arrayBody.Add(currentProp);
            }
        }
        // Create an array based on the properties
        var arrayExp = Expression.NewArrayInit(typeof (object), arrayBody);

        // set a default return value of null if couldn't match
        var defaultValue = Expression.NewArrayInit(typeof (object), Expression.Constant(null));

        //Set up so the lambda can have a return value
        var returnTarget = Expression.Label(typeof (object[]));
        var returnExpress = Expression.Return(returnTarget, arrayExp, typeof (object[]));
        var returnLabel = Expression.Label(returnTarget, defaultValue);

        //Create the method
        var code = Expression.Block(arrayExp, returnExpress, returnLabel);
        return Expression.Lambda<Func<object, object[]>>(code, sourceObject).Compile();
    }


    private static bool IsValueProperty(Type propertyType)
    {
        var propType = propertyType;

        if (propType.IsGenericType && propType.GetGenericTypeDefinition() == typeof (Nullable<>))
        {
            propType = new NullableConverter(propType).UnderlyingType;
        }

        return propType.IsValueType || propType == typeof (string);
    }
}

如何使用MemoryCache加速将各种对象转换为字符串？

1 个答案: