Можно ли ускорить этот метод?

Question

У меня есть метод, который использует циклы через объекты 7,753+ и получает значение каждого свойства для каждого объекта. Каждый объект имеет 14 объектов.

private void InitializeData(IList objects, PropertyInfo[] props, List<DPV> dataPs, List<Dictionary<string, object>> tod) 
{ 
    foreach (var item in objects) 
    { 
     var kvp = new Dictionary<string, object>(); 
     foreach (var p in props) 
     { 
      var dataPs = dataPs.FirstOrDefault(x => x.Name == p.Name); 
      object returnData; 
      if (dataPoint != null) 
      { 
       int maxLength = (dataP.MaxLength == null) ? 0 : (int) dataP.MaxLength; 
       returnData = p.GetValue(item, null); 
       if (!string.IsNullOrEmpty(dataP.FormatString) && !string.IsNullOrEmpty(returnData.ToString())) 
       { 
        returnData = FormatDataForDisplay(returnData, dataP, maxLength, "", 8); 
       } 
      } 
      else 
      { 
       returnData = p.GetValue(item, null); 
      } 
      kvp.Add(p.Name, returnData); 
     } 
     tod.Add(kvp); 
    } 
} 

Я считаю GetValue это то, что занимает большую часть времени в этом методе, метод занимает около 900ms бежать, но GetValue, который называется 800,000+ раз занимает около 750ms (total, not per-call).

public List<Dictionary<string, object>> GetColumnOptions<T>(List<T> list) 
    { 

     var tod= new List<Dictionary<string, object>>(); 



     var objects = (IList)list[0]; 
     Type objType = objects[0].GetType(); 

     var props = objType.GetProperties(BindingFlags.DeclaredOnly | 
                 BindingFlags.Public | 
                 BindingFlags.Instance); 


     var dPs= GetDPs(); 



     //Initialize aaData 
     //I don't believe this is correct 
     InitializeData2<T>(new List<T> { (T) objects}, props, dPs, tod); 

     return tod; 
    } 

Answer 1

Я сделал простой тест, где я заменил проблематичную .GetValue с функцией исполняющей упрощенного ассигнования («если имя свойства является блабло, значение Object.blabla»). Тест состоит только из простой версии ваших функций/переменных/свойств и цикла, позволяющего полностью контролировать количество итераций. Результаты, безусловно, удивительно: новый подход в 10 раз быстрее! Имейте в виду, что в моих оригинальных тестах (50000 итераций) время было 2276 (старый) против 234 (новый). Эта разница остается постоянной для разных сценариев; например, для 8000 итераций, он обеспечивает 358 мс против 36 мс. Я провел эти тесты на довольно мощном компьютере и на winforms C#; @Xaisoft может взять код ниже, выполнить тест в соответствии с его конкретными условиями и сообщить результаты.

Код:

private void Form1_Load(object sender, EventArgs e) 
{ 
    List<List> var = new List<List>(); 

    List var1 = new List(); 
    var1.var = 1; 
    var1.var2 = 1; 
    var1.var3 = 1; 
    var1.var4 = 1; 
    var1.var5 = 1; 

    List var2 = new List(); 
    var2.var = 1; 
    var2.var2 = 1; 
    var2.var3 = 1; 
    var2.var4 = 1; 
    var2.var5 = 1; 

    List var3 = new List(); 
    var3.var = 1; 
    var3.var2 = 1; 
    var3.var3 = 1; 
    var3.var4 = 1; 
    var3.var5 = 1; 

    List var4 = new List(); 
    var4.var = 1; 
    var4.var2 = 1; 
    var4.var3 = 1; 
    var4.var4 = 1; 
    var4.var5 = 1; 

    var.Add(var1); 
    var.Add(var2); 
    var.Add(var3); 
    var.Add(var4); 

    InitializeData(var, typeof(List).GetProperties()); 
} 

private static void InitializeData(List<List> objects, PropertyInfo[] props) 
{ 
    DateTime start = DateTime.Now; 

    int count = 0; 
    do 
    { 
     count = count + 1; 
     foreach (var item in objects) 
     { 

      foreach (var p in props) 
      { 
       object returnData = p.GetValue(item, null); //returnProps(p.Name, item); 
      } 
     } 

    } while (count < 50000); 


    TimeSpan timer = new TimeSpan(); 
    timer = DateTime.Now.Subtract(start); 
} 

private class List 
{ 
    public int var { set; get; } 
    public int var2 { set; get; } 
    public int var3 { set; get; } 
    public int var4 { set; get; } 
    public int var5 { set; get; } 
    public int var6 { set; get; } 
    public int var7 { set; get; } 
    public int var8 { set; get; } 
    public int var9 { set; get; } 
    public int var10 { set; get; } 
    public int var11 { set; get; } 
    public int var12 { set; get; } 
    public int var13 { set; get; } 
    public int var14 { set; get; } 
} 
private static object returnProps(string propName, List curObject) 
{ 
    if (propName == "var") 
    { 
     return curObject.var; 
    } 
    else if (propName == "var2") 
    { 
     return curObject.var2; 
    } 
    else if (propName == "var3") 
    { 
     return curObject.var3; 
    } 
    else if (propName == "var4") 
    { 
     return curObject.var4; 
    } 
    else if (propName == "var5") 
    { 
     return curObject.var5; 
    } 
    else if (propName == "var6") 
    { 
     return curObject.var6; 
    } 
    else if (propName == "var7") 
    { 
     return curObject.var7; 
    } 
    else if (propName == "var8") 
    { 
     return curObject.var8; 
    } 
    else if (propName == "var9") 
    { 
     return curObject.var9; 
    } 
    else if (propName == "var10") 
    { 
     return curObject.var10; 
    } 
    else if (propName == "var11") 
    { 
     return curObject.var11; 
    } 
    else if (propName == "var12") 
    { 
     return curObject.var12; 
    } 
    else if (propName == "var13") 
    { 
     return curObject.var13; 
    } 
    else if (propName == "var14") 
    { 
     return curObject.var14; 
    } 

    return new object(); 
} 

FINAL Примечание: Я хотел бы, чтобы люди поняли так впечатляющие результаты в более общем, чем только применительно к .GetValue. В наши дни компьютеры могут справляться с множеством вещей, и вам не нужно максимизировать производительность каждого отдельного бита, это правда. С другой стороны, если у вас проблемы с производительностью, и вам нужно «экономить ресурсы» более соответствующим образом, вы должны сосредоточить свои улучшения на идее «чем проще, тем быстрее». Я сделал себе улучшение производительности в кодах с использованием соответствующего количества Lists и Dictionaries, и результаты можно получить, даже после каждого отдельного изменения (List в обычный Array). Вам не нужно быть слишком пассивным на этом фронте, но в случае необходимости помните, что требования к потреблению памяти/связанного времени с List по отношению к Array выше (и оба элемента в основном одинаковы). То же самое для многомерных массивов, долго размера массивов и т.д.

------ ПОДРОБНЕЕ АНАЛИЗ ИСПОЛНЕНИЯ

Даже если я пусть моя точка очень ясно с самого начала (только идея, которая должен быть адаптирован к каждой ситуации), я понимаю, что мое требование (в 10 раз быстрее) действительно требует правильного определения. Я делаю тесты в разных условиях, и вот результаты:

ПРИМЕЧАНИЕ: вышеупомянутые результаты были выведены 32-битным исполняемым файлом; все перечисленные ниже - из 64-битного. Я наблюдал улучшение производительности .GetValue при переходе от 32-битного к 64-битовому. Обновление 64-разрядная версия результатов выше (мс):

     GetValue  Direct Assignation  
50000 iterations -> 1197     157 
80000 iterations -> 1922     253 
100000 iterations -> 2354     310 

Таким образом, коэффициент изменяется от 10 раз до 7,5 раз.

Я начал увеличивать количество свойств (каждый раз на 64-битных) и GetValue стал лучше и лучше.Результаты:

28 Properties 
          GetValue  Direct Assignation  
    50000 iterations -> 2386    552 
    80000 iterations -> 3857    872 

Aver. ratio = 4.37 

50 Properties 
          GetValue  Direct Assignation  
    50000 iterations -> 4292    1707 
    80000 iterations -> 6772    2711 

Aver. ratio = 2.475 

Я не уверен, если улучшение GetValue продолжится и достигнет точки, где будет лучше, чем упрощенный подход, но кого это волнует? На этом этапе ясно, что все большее число свойств играет против упрощенного подхода, поэтому пришло время попробовать другую (опять же довольно упрощенную) альтернативу: глобальный массив, сохраняющий все свойства.

private static int[,] List0; 

Будучи заселен параллельно с заданным свойством (то есть, когда object.propX = any value соответствующих позиций в массиве также заполняется) и отнесено объекты/позиций свойств (первый объект, третья собственности, и т.д.). Логически это ограничивает количество объектов (рост первого измерения выше 1000 не рекомендуется), но вы можете полагаться на разные массивы (один хранится от первого объекта до 1000-го, другого от 1001-го до 2000-го , и т.д.); вы можете установить функцию, которая принимает в качестве аргумента имя объекта и возвращает соответствующий массив.

Изменения в главном цикле:

int countObject = -1; 
foreach (var item in objects) 
{ 
    countObject = countObject + 1; 
    int countProp = -1; 
    foreach (var p in props) 
    { 
     countProp = countProp + 1; 
     object returnData = List0[countObject, countProp]; 
    } 
} 

, запустив этот новый подход в случае, описанном выше, я получаю:

50 Properties 
         GetValue   2D Array  
    80000 iterations -> 6772    155 

Aver. ratio = 45.146 

еще один:

70 Properties 
          GetValue   2D Array  
    80000 iterations -> 10444    213 

Aver. ratio = 49.06 

И я остановился мои тесты здесь. Думаю, этого достаточно, чтобы доказать свою точку зрения.

Различные подходы обеспечивают различные характеристики в разных условиях и, таким образом, лучший способ узнать идеальную конфигурацию для конкретной ситуации - это проверить ее. Опираясь на предельную истину, редко является лучшим решением проблемы (хотя я могу ошибаться ... все еще жду ответа от Дмитрия, чтобы проверить его решение в разных условиях). Таким образом, в соответствии с проверенными условиями, кажется, что исходный упрощенный подход приемлем для случаев, когда количество свойств относительно невелико (т. Е. Ниже 20); выше этого, требуемое усилие hardcoding не кажется достойным, и полагаться на другую альтернативу (например, 2D-массив, который я предложил) лучше. В любом случае GetValue обеспечивает четкую производительность, которая может быть улучшена различными способами.

Я надеюсь, что мне не нужно будет обновлять этот ответ еще раз :)

Answer 2

Если проблема действительно в PropertyInfo.GetValue вызове метода вы можете использовать подход с построения кэш-добытчиками собственности (например, с помощью скомпилированных выражений). Вот образец, который demostrates, что этот подход до 30-40% быстрее, чем оригинальный метод на 8000 объектов с 14 свойствами (с горячей кэш-памяти):

static void Main(string[] args) { 
    IList objects = new List<Obj>(); 
    for(int i = 0; i < 8000; i++) 
     objects.Add(new Obj()); 
    var properties = typeof(Obj).GetProperties(); 


    var sw1 = System.Diagnostics.Stopwatch.StartNew(); 
    InitializeData1(objects, properties, new List<Dictionary<string, object>>()); 
    sw1.Stop(); 
    Console.WriteLine("Reflection PropertyInfo.GetValue: " + sw1.ElapsedTicks.ToString()); 

    // cold cache testing 
    var sw2_coldCache = System.Diagnostics.Stopwatch.StartNew(); 
    InitializeData2<Obj>(objects, properties, new List<Dictionary<string, object>>(), new Dictionary<string, Func<Obj, object>>()); 
    sw2_coldCache.Stop(); 
    Console.WriteLine("Cached Getters (Cold cache): " + sw2_coldCache.ElapsedTicks.ToString()); 

    // cache initialization 
    InitializeData2<Obj>(new List<Obj> { new Obj() }, properties, new List<Dictionary<string, object>>(), gettersCache); 
    // hot cache testing 
    var sw2_hotCache = System.Diagnostics.Stopwatch.StartNew(); 
    InitializeData2<Obj>(objects, properties, new List<Dictionary<string, object>>(), gettersCache); 
    sw2_hotCache.Stop(); 
    Console.WriteLine("Cached Getters (Hot cache): " + sw2_hotCache.ElapsedTicks.ToString()); 

    var sw3 = System.Diagnostics.Stopwatch.StartNew(); 
    InitializeData3(objects, properties, new List<Dictionary<string, object>>()); 
    sw3.Stop(); 
    Console.WriteLine("returnProps special method: " + sw3.ElapsedTicks.ToString()); 

    var sw4 = System.Diagnostics.Stopwatch.StartNew(); 
    InitializeData2_NonGeneric(objects, properties, new List<Dictionary<string, object>>()); 
    sw4.Stop(); 
    Console.WriteLine("Cached Getters (runtime types resolving): " + sw4.ElapsedTicks.ToString()); 
} 

Вот оригинал реализации (уменьшен для целей тестирования):

static void InitializeData1(IList objects, PropertyInfo[] props, List<Dictionary<string, object>> tod) { 
    foreach(var item in objects) { 
     var kvp = new Dictionary<string, object>(); 
     foreach(var p in props) { 
      kvp.Add(p.Name, p.GetValue(item, null)); 
     } 
     tod.Add(kvp); 
    } 
} 

Вот оптимизированная реализация:

static IDictionary<string, Func<Obj, object>> gettersCache = new Dictionary<string, Func<Obj, object>>(); 
static void InitializeData2<T>(IList objects, PropertyInfo[] props, List<Dictionary<string, object>> tod, IDictionary<string, Func<T, object>> getters) { 
    Func<T, object> getter; 
    foreach(T item in objects) { 
     var kvp = new Dictionary<string, object>(); 
     foreach(var p in props) { 
      if(!getters.TryGetValue(p.Name, out getter)) { 
       getter = GetValueGetter<T>(p); 
       getters.Add(p.Name, getter); 
      } 
      kvp.Add(p.Name, getter(item)); 
     } 
     tod.Add(kvp); 
    } 
} 

static Func<T, object> GetValueGetter<T>(PropertyInfo propertyInfo) { 
    var instance = System.Linq.Expressions.Expression.Parameter(propertyInfo.DeclaringType, "i"); 
    var property = System.Linq.Expressions.Expression.Property(instance, propertyInfo); 
    var convert = System.Linq.Expressions.Expression.TypeAs(property, typeof(object)); 
    return (Func<T, object>)System.Linq.Expressions.Expression.Lambda(convert, instance).Compile(); 
} 

испытаний класс:

class Obj { 
    public int p00 { set; get; } 
    public string p01 { set; get; } 
    public float p02 { set; get; } 
    public double p03 { set; get; } 
    public char p04 { set; get; } 
    public byte p05 { set; get; } 
    public long p06 { set; get; } 
    public int p07 { set; get; } 
    public string p08 { set; get; } 
    public float p09 { set; get; } 
    public double p10 { set; get; } 
    public char p11 { set; get; } 
    public byte p12 { set; get; } 
    public long p13 { set; get; } 
} 

Обновление: Добавлено решение от varocarbas в тестах

static void InitializeData3(IList objects, PropertyInfo[] props, List<Dictionary<string, object>> tod) { 
    foreach(Obj item in objects) { 
     var kvp = new Dictionary<string, object>(); 
     foreach(var p in props) { 
      kvp.Add(p.Name, returnProps(p.Name, item)); 
     } 
     tod.Add(kvp); 
    } 
} 
static object returnProps(string propName, Obj curObject) { 
    if(propName == "p00") { 
     return curObject.p00; 
    } 
    else if(propName == "p01") { 
     return curObject.p01; 
    } 
    else if(propName == "p02") { 
     return curObject.p02; 
    } 
    else if(propName == "p03") { 
     return curObject.p03; 
    } 
    else if(propName == "p04") { 
     return curObject.p04; 
    } 
    else if(propName == "p05") { 
     return curObject.p05; 
    } 
    else if(propName == "p06") { 
     return curObject.p06; 
    } 
    else if(propName == "p07") { 
     return curObject.p07; 
    } 
    else if(propName == "p08") { 
     return curObject.p08; 
    } 
    else if(propName == "p09") { 
     return curObject.p09; 
    } 
    else if(propName == "p10") { 
     return curObject.p10; 
    } 
    else if(propName == "p11") { 
     return curObject.p11; 
    } 
    else if(propName == "p12") { 
     return curObject.p12; 
    } 
    else if(propName == "p13") { 
     return curObject.p13; 
    } 
    return new object(); 
} 

Консольные Результаты: (Release, x64) (Core i5 M560 @ 2,67 ГГц, 8 Гб оперативной памяти, Win7x64)

Reflection PropertyInfo.GetValue: 161288 
Cached Getters (Cold cache): 153808 
Cached Getters (Hot cache): 110837 
returnProps special method: 128905 

Таким образом, подход к кешированию является лучшим.

UPDATE2
Методы продемонстрированные в образце, предназначены для использования, когда тип objects элементов известно во время компиляции (общий путь):

InitializeData2<Obj>(...) 

При использовании объектов список, тип которого неизвестен во время компиляции, вы можете использовать следующий подход для вызова метода общего назначения InitializeData2<> во время выполнения:

InitializeData2_NonGeneric(objects, properties, new List<Dictionary<string, object>>()); 
//... 
static void InitializeData2_NonGeneric(IList objects, PropertyInfo[] props, List<Dictionary<string, object>> tod) { 
    Type elementType = objects[0].GetType(); 
    var genericMethodInfo = typeof(Program).GetMethod("InitializeData2", BindingFlags.Static | BindingFlags.NonPublic); 
    var genericMethod = genericMethodInfo.MakeGenericMethod(new Type[] { elementType }); 

    var genericGetterType = typeof(Func<,>).MakeGenericType(elementType,typeof(object)); 
    var genericCacheType = typeof(Dictionary<,>).MakeGenericType(typeof(string), genericGetterType); 
    var genericCacheConstructor = genericCacheType.GetConstructor(new Type[] { }); 
    genericMethod.Invoke(null, new object[] { objects, props, tod, genericCacheConstructor.Invoke(new object[] { }) }); 
}