Производительность в отношении типа возврата для запроса LINQ, совместимого с автоматической сортировкой - PullRequest
Новая
       28

Производительность в отношении типа возврата для запроса LINQ, совместимого с автоматической сортировкой

0 голосов
/ 19 ноября 2009

это на самом деле не проблема, но больше беспокойства, я был бы признателен за какой-либо вклад, пожалуйста.

Winforms C # .net3.5 [sp1] Visual Studio 2008 с использованием Linq2Sql (точнее PLINQO ... что фантастически кстати!). У меня есть набор результатов, возвращающий +/- 19000 строк данных (около 80 байт данных на строку), и я решил перенести метод извлечения данных в фоновый режим и соответствующим образом обновить пользовательский интерфейс. Это отлично работает.

Однако я заметил некоторые различия в производительности при использовании разных типов возврата для моего метода извлечения данных Ling. Я знаю, что все предлагают вернуть List<T> или IEnumarable<T> и установить для этого источник данных DataGridView, но, к сожалению, он не поддерживает собственную сортировку объектов. После некоторых поисков я нашел SortableBindingList<T> на MSDN здесь . Я применил это, и Grid потребовалось меньше секунды, чтобы заполнить себя - однако, когда я щелкаю по столбцу, чтобы отсортировать его, потребовалось чуть больше секунды, чтобы реализовать сортировку.

Затем я решил пойти по пути DataTable, но обнаружил, что метод ToDataTable был удален, но после еще одного поиска нашел способ реализовать его в этой статье MSDN . После его применения я обнаружил, что для заполнения таблицы потребовалось около 2 секунд, но после этого сортировка (по 19000 строк!) Была мгновенной !! Естественно, я придерживался этого подхода.

Также имейте в виду, что я отключил любое редактирование / добавление / удаление в сетке. Сетка предназначена исключительно для отображения данных. Любые другие операции CRUD предоставляются диалоговыми формами в соответствии с текущей выбранной строкой (скрытый столбец первичного ключа).

Вот код, который я использовал для обоих методов:

1) SortableBindingList 

    //declare private member
    private SortableBindingList<PdtAllocation> listAlloc = null;

    private void RefreshData() {
        bcsDataContext ctx = new bcsDataContext();
        try {
            listAlloc = new SortableBindingList<PdtAllocation>(ctx.PdtAllocation.ToList());
        }
        catch (Exception) {
            throw;
        }
        finally {
            ctx.Dispose();
        }

        dataGridView1.DataSource = listAlloc;
    }

2) CopyToDatatable 

    //declare private member
    private DataTable dt = null;

    private void RefreshData() {
        dt = new DataTable();
        bcsDataContext ctx = new bcsDataContext();
        try {
            ctx.PdtAllocation.CopyToDataTable(dt, LoadOption.PreserveChanges);
        }
        catch (Exception) {
            throw;
        }
        finally {
            ctx.Dispose();
        }

        dataGridView1.DataSource = dt;
    }

Теперь я знаю, что это, вероятно, похоже на " вопрос с просьбой и ответом ", но я был бы очень признателен за ваш вклад, а также за любые известные проблемы с маршрутом CopyToDataTable(). *

Спасибо тебе .... и прошу прощения за запрос looong!

1 Ответ

1 голос
/ 19 ноября 2009

вот мой взгляд на ваш вопрос (по маршруту SortableBindingList).

Использовали ли вы общий алгоритм сортировки на основе отражений? Я сделал это сначала, и производительность была действительно плохой. Наконец, я пришел к следующему решению: обеспечить сортировку по умолчанию в SortableBindingList<T>, но также оставить открытой возможность реализовать специализированную сортировку в производных классах.

Вот код.

В SortableBindingList<T>.ApplySortCore(): 

protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
{
    // Check if the sorted property implements IComparable
    ...

    List<T> itemsList = (List<T>)this.Items;

    Comparison<T> comparer = GetComparer(prop);

    itemsList.Sort(comparer);

    if (direction == ListSortDirection.Descending)
    {
        itemsList.Reverse();
    }

    ...
    // Set sort state (is sorted, sort property, sort dir)
}

Универсальный SortableBindingList<T> предоставляет базовый сортировщик на основе отражения: 

protected virtual Comparison<T> GetComparer(PropertyDescriptor prop)
{
    return new Comparison<T>(delegate(T x, T y)
    {
        if (prop.GetValue(x) != null)
            return ((IComparable)prop.GetValue(x)).CompareTo(prop.GetValue(y));
        else if (prop.GetValue(y) != null)
            return -1 * ((IComparable)prop.GetValue(y)).CompareTo(prop.GetValue(x));
        else
            return 0;
    });
}

Как видите, GetComparer() является виртуальным, поэтому его можно переопределить в классе, производном от SortableBindingList<T>, чтобы обеспечить намного более быстрый компаратор, настроенный на тип свойства, являющегося на самом деле отсортировано. Например, хотя общий компаратор отсортировал (по свойству String) 10000 записей за 4 секунды, специализированный компаратор выполнил ту же работу за 70 мс. 

class CustomerList : SortableBindingList<Customer>
{
    protected override Comparison<Customer> GetComparer(PropertyDescriptor prop)
    {
        Comparison<Customer> comparer = null;
        switch (prop.Name)
        {
            case "FirstName":
                comparer = new Comparison<Customer>(delegate(Customer x, Customer y)
                {
                    string xx = (null == x) ? null : x.FirstName;
                    string yy = (null == y) ? null : y.FirstName;
                    return String.Compare(xx, yy);
                });
                break;
            ...
        }
        return comparer;
    }
}

Последнее замечание: большая часть опубликованного кода была скопирована / вдохновлена ​​из других источников, таких как SO или Microsoft, так что кредит не мой. Моим единственным вкладом была виртуализация компаратора, но я уверен, что небольшое прибегание к поиску будет лучше, более ранние решения, основанные на той же идее.

...