public void SetSortIcon(int ColumnIndex, SortOrder Order)
{
IntPtr ColumnHeader = SendMessage(Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int ColumnNumber = 0; ColumnNumber <= Columns.Count - 1; ColumnNumber++)
{
IntPtr ColumnPtr = new IntPtr(ColumnNumber);
LVCOLUMN lvColumn = new LVCOLUMN();
lvColumn.mask = HDI_FORMAT;
SendMessageLVCOLUMN(ColumnHeader, HDM_GETITEM, ColumnPtr, ref lvColumn);
if (!(Order == SortOrder.None) && ColumnNumber == ColumnIndex)
{
switch (Order)
{
case SortOrder.Ascending:
lvColumn.fmt &= ~HDF_SORTDOWN;
lvColumn.fmt |= HDF_SORTUP;
break;
case SortOrder.Descending:
lvColumn.fmt &= ~HDF_SORTUP;
lvColumn.fmt |= HDF_SORTDOWN;
break;
}
}
else
{
lvColumn.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
}
SendMessageLVCOLUMN(ColumnHeader, HDM_SETITEM, ColumnPtr, ref lvColumn);
}
}
public static Query OrderBy(this Query qry, string paramName, SortOrder order = SortOrder.Ascending)
{
if (paramName == null) throw Error.ArgumentNull("paramName");
qry.Sort = Tuple.Create(paramName, order);
return qry;
}
public SqlIndexedColumnExpression(SqlColumnExpression column, SortOrder sortOrder, bool lowercaseIndex)
: base(typeof(void))
{
this.Column = column;
this.SortOrder = sortOrder;
this.LowercaseIndex = lowercaseIndex;
}
public async static Task<PagedList<Connection>> FindAllAsync(string type, string query = null, IEnumerable<string> fields = null, int page = 1, int pageSize = 20, string orderBy = null, SortOrder sortOrder = SortOrder.Descending)
{
var request = new FindAllConnectionsRequest()
{
Type = type,
Query = query,
PageNumber = page,
PageSize = pageSize,
OrderBy = orderBy,
SortOrder = sortOrder
};
var response = await request.ExecuteAsync();
if (response.Status.IsSuccessful == false)
throw response.Status.ToFault();
var connections = new PagedList<Connection>()
{
PageNumber = response.PagingInfo.PageNumber,
PageSize = response.PagingInfo.PageSize,
TotalRecords = response.PagingInfo.TotalRecords,
GetNextPage = async skip => await FindAllAsync(type, query, fields, page + skip + 1, pageSize)
};
connections.AddRange(response.Connections);
return connections;
}
protected virtual List<BestMessageInfo> GetBestExistingData(string orderBy, SortOrder sortOrder, int count)
{
List<MessageData> list2;
Assert.ArgumentNotNullOrEmpty(orderBy, "orderBy");
this.AssertOrderBy(orderBy);
Guid managerRoot = this.managerRoot.InnerItem.ID.ToGuid();
List<BestMessageInfo> list = new List<BestMessageInfo>();
do
{
list2 = analyticsDataGateway.GetAllCampaignsSorted(managerRoot, orderBy, sortOrder);
if (list2.Count == 0)
{
return list;
}
int num = Math.Min(list.Count + list2.Count, count);
List<Guid> campaigns = new List<Guid>();
foreach (MessageData data in list2)
{
MessageItem message = this.FindMessage(data, managerRoot);
if ((message != null) && (this.messageSentOnlyByContextUser(message)))
{
list.Add(this.CreateRow(message, data));
if (list.Count >= num)
{
return list;
}
}
}
this.analyticsDataGateway.MarkRemovedMessages(campaigns);
}
while (list2.Count >= 20);
return list;
}
public DataGridViewCustomSorter(DataGridView dgv)
{
myDataGridView = dgv;
mySortTypeCode = Type.GetTypeCode(Type.GetType("System.String"));
ColumnIndex = 0;
OrderOfSort = SortOrder.None;
}
public void HandleColumnClicked(System.Windows.Forms.ListView listView, ColumnClickEventArgs e)
{
// Determine if clicked column is already the column that is being sorted.
if (e.Column == this.SortColumn)
{
// Reverse the current sort direction for this column.
if (this.Order == SortOrder.Ascending)
{
this.Order = SortOrder.Descending;
}
else
{
this.Order = SortOrder.Ascending;
}
}
else
{
// Set the column number that is to be sorted; default to ascending.
this.SortColumn = e.Column;
this.Order = SortOrder.Ascending;
}
// Perform the sort with these new sort options.
listView.Sort();
}
public ListViewColumnSorter(bool sortByDate)
{
this.sortByDate = sortByDate;
ColumnToSort = 0;
OrderOfSort = SortOrder.None;
ObjectCompare = new CaseInsensitiveComparer();
}
private bool TryParseSortOrder(string direction, out SortOrder sortOrder)
{
switch (direction.Trim().ToLower())
{
case "asc":
case "ascending":
case "a":
case "0":
sortOrder = SortOrder.Ascending;
return true;
case "desc":
case "descending":
case "d":
case "1":
sortOrder = SortOrder.Descending;
return true;
case "":
case null:
sortOrder = SortOrder.Unspecified;
return true;
default:
sortOrder = SortOrder.Unspecified;
return false;
}
}
/// <summary>
/// Initializes a new instance of the SorterBase class with the specified
/// TableModel, Column index, IComparer and SortOrder
/// </summary>
/// <param name="tableModel">The TableModel that contains the data to be sorted</param>
/// <param name="column">The index of the Column to be sorted</param>
/// <param name="comparer">The IComparer used to sort the Column's Cells</param>
/// <param name="sortOrder">Specifies how the Column is to be sorted</param>
public SorterBase(TableModel tableModel, int column, IComparer comparer, SortOrder sortOrder)
{
this.tableModel = tableModel;
this.column = column;
this.comparer = comparer;
this.sortOrder = sortOrder;
}
public void ReverseSortOrder()
{
if (SortOrder == SortOrder.Ascending)
SortOrder = SortOrder.Descending;
else
SortOrder = SortOrder.Ascending;
}
public async static Task<PagedList<Article>> FindAllAsync(string type, string query = null, IEnumerable<string> fields = null, int page = 1, int pageSize = 20, string orderBy = null, SortOrder sortOrder = SortOrder.Descending )
{
var service = ObjectFactory.Build<IArticleService>();
var request = new FindAllArticleRequest()
{
Type = type,
Query = query,
PageNumber = page,
PageSize = pageSize,
OrderBy = orderBy,
SortOrder = sortOrder
};
var response = await service.FindAllAsync(request);
if (response.Status.IsSuccessful == false)
throw response.Status.ToFault();
var articles = new PagedList<Article>()
{
PageNumber = response.PagingInfo.PageNumber,
PageSize = response.PagingInfo.PageSize,
TotalRecords = response.PagingInfo.TotalRecords,
GetNextPage = async skip => await FindAllAsync(type, query, fields, page+skip+1, pageSize)
};
articles.AddRange(response.Articles);
return articles;
}
private IList<Student> GetStudentsSorted(int pageIndex, int pageSize, string sortField, SortOrder order)
{
//Off course you are going to use a web service/wcf/EF call instead of this
if (_students == null)
{
fillAllStudents();
}
IList<Student> result= new List<Student>();
if (order == SortOrder.ASC)
{
if (sortField.ToLower() == "age")
{
_students.OrderBy(x => x.Age).Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList<Student>().ForEach(x=>result.Add(x));
}
else
{
_students.OrderBy(x => x.Name).Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList<Student>().ForEach(x => result.Add(x));
}
}
else
{
if (sortField.ToLower() == "age")
{
_students.OrderByDescending(x => x.Age).Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList<Student>().ForEach(x => result.Add(x));
}
else
{
_students.OrderByDescending(x => x.Name).Skip(pageSize * (pageIndex - 1)).Take(pageSize).ToList<Student>().ForEach(x => result.Add(x));
}
}
return result;
}
public static void SetSortIcon(this ColumnHeader column, SortOrder order)
{
ListView listView = column.ListView;
IntPtr columnHeader = SendMessage(listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int i = 0; i <= listView.Columns.Count - 1; i++)
{
IntPtr ColumnPtr = new IntPtr(i);
LVCOLUMN lvColumn = new LVCOLUMN();
lvColumn.mask = HDI_FORMAT;
SendMessage(columnHeader, HDM_GETITEM, ColumnPtr, ref lvColumn);
if (!(order == SortOrder.None) && i == column.Index)
{
switch (order)
{
case SortOrder.Ascending:
lvColumn.fmt &= ~HDF_SORTDOWN;
lvColumn.fmt |= HDF_SORTUP;
break;
case SortOrder.Descending:
lvColumn.fmt &= ~HDF_SORTUP;
lvColumn.fmt |= HDF_SORTDOWN;
break;
}
}
else
{
lvColumn.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
}
SendMessage(columnHeader, HDM_SETITEM, ColumnPtr, ref lvColumn);
}
}
internal Sort(LocationField field, SortOrder order, double latitude, double longitude)
{
SortField = field;
Order = order;
Latitude = latitude;
Longitude = longitude;
}
/// <summary>
/// Gets a paginated list of APObjects matching the given search criteria.
/// </summary>
/// <param name="type">The object type.</param>
/// <param name="query">The search query for objects to be found.</param>
/// <param name="fields">The object fields to be returned for the matching list of objects.</param>
/// <param name="pageNumber">The page number.</param>
/// <param name="pageSize">The page size.</param>
/// <param name="orderBy">The object field on which the results should be sorted.</param>
/// <param name="sortOrder">The sort order.</param>
/// <param name="options">Request specific api options. These will override the global settings for the app for this request.</param>
/// <returns>Paginated list of APObject objects matching the given search criteria.</returns>
public async static Task<PagedList<APObject>> FindAllAsync(string type, IQuery query = null, IEnumerable<string> fields = null, int pageNumber = 1, int pageSize = 20, string orderBy = null, SortOrder sortOrder = SortOrder.Descending, ApiOptions options = null)
{
query = query ?? Query.None;
var request = new FindAllObjectsRequest()
{
Type = type,
Query = query.AsString().Escape(),
PageNumber = pageNumber,
PageSize = pageSize,
OrderBy = orderBy,
SortOrder = sortOrder
};
if( fields != null )
request.Fields.AddRange(fields);
ApiOptions.Apply(request, options);
var response = await request.ExecuteAsync();
if (response.Status.IsSuccessful == false)
throw response.Status.ToFault();
var objects = new PagedList<APObject>()
{
PageNumber = response.PagingInfo.PageNumber,
PageSize = response.PagingInfo.PageSize,
TotalRecords = response.PagingInfo.TotalRecords,
GetNextPage = async skip => await FindAllAsync(type, query, fields, pageNumber + skip + 1, pageSize, orderBy, sortOrder, options)
};
objects.AddRange(response.Objects);
return objects;
}
public static void SetSortIcons(ListView listView, int previouslySortedColumn, int newSortColumn, SortOrder sorting) {
IntPtr headerHandle = SendMessage(listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
IntPtr newColumn = new IntPtr(newSortColumn);
IntPtr prevColumn = new IntPtr(previouslySortedColumn);
HDITEM hditem;
// Only update the previous item if it existed and if it was a different one.
if (previouslySortedColumn != -1 && previouslySortedColumn != newSortColumn) {
// Clear icon from the previous column.
hditem = new HDITEM();
hditem.mask = HDI_FORMAT;
ItemSendMessage(headerHandle, HDM_GETITEM, prevColumn, ref hditem);
hditem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
ItemSendMessage(headerHandle, HDM_SETITEM, prevColumn, ref hditem);
}
// Set icon on the new column.
hditem = new HDITEM();
hditem.mask = HDI_FORMAT;
ItemSendMessage(headerHandle, HDM_GETITEM, newColumn, ref hditem);
if (sorting == SortOrder.Ascending) {
hditem.fmt &= ~HDF_SORTDOWN;
hditem.fmt |= HDF_SORTUP;
}
else {
hditem.fmt &= ~HDF_SORTUP;
hditem.fmt |= HDF_SORTDOWN;
}
ItemSendMessage(headerHandle, HDM_SETITEM, newColumn, ref hditem);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="searcher">该字段所在的查询对象</param>
/// <param name="columnName">字段名称</param>
public SearchColumn(Searcher searcher, string columnName)
{
this.sortOrder = SortOrder.None;
this.sortIndex = 1;
this.columnName = columnName;
this.currentSearcher = searcher;
}
/// <summary>
/// ...
/// </summary>
public ListViewItemComparer()
{
m_UseTagObject = false;
m_SortColumn = 0;
m_SortOrder = SortOrder.None;
m_Comparer = new CaseInsensitiveComparer();
}
public StockReaderForm()
{
InitializeComponent();
stockDataGridView.AutoGenerateColumns = false;
LoadConfigInfo();
BindColumns();
notifyIcon1.Visible = false;
dataList = new SortableBindingList<TickerData>();
portfolioPath = "";
if (portfolio != null)
ProcessTickers();
sortColumn = stockDataGridView.Columns[0];
sortOrder = stockDataGridView.SortOrder;
//int interval = info.TimerInterval;
if (config.ConfigData.Timer.interval <= 0)
{
tickerTimer.Interval = 60000; // default to 1 minute
}
else
{
tickerTimer.Interval = config.ConfigData.Timer.interval * 60000;
}
tickerTimer.Enabled = true;
}
/// <summary>
/// Sorts the <see cref="System.Data.DataTable"/>.
/// </summary>
/// <param name="sourceTable">The source table.</param>
/// <param name="sortColumn">The column to sort by.</param>
/// <param name="order">The <see cref="Tools.Common.SortOrder"/>.</param>
/// <param name="copyIfNoSort">Should only be true when one table owner is assumed
/// other time and space.</param>
/// <returns></returns>
public static DataTable SortDataTable(DataTable sourceTable, string sortColumn, SortOrder order, bool copyIfNoSort)
{
if (String.IsNullOrEmpty(sortColumn))
{
// copyIfNoSort make the semantic more stable, even if there is no sort required
// the copy is returned, so the caller may assume same level of independence.
if (copyIfNoSort) return sourceTable.Copy();
return sourceTable;
}
DataTable targetTable = sourceTable.Clone();
DataRow[] sourceRows = sourceTable.Select(null,
("[" + sortColumn + "] " + order.ToString()).TrimEnd(' '));
for (int i = 0; i < sourceRows.Length; i++)
{
DataRow newRow = targetTable.NewRow();
newRow.ItemArray = sourceRows[i].ItemArray;
targetTable.Rows.Add(newRow);
}
return targetTable;
}
/// <summary>
/// Find all playlists in this account.
/// </summary>
/// <param name="pageSize">Number of playlists returned per page. A page is a subset of all of the playlists that
/// satisfy the request. The maximum page size is 50.</param>
/// <param name="pageNumber">The zero-indexed number of the page to return.</param>
/// <param name="sortBy">The property that you'd like to sort the results by.</param>
/// <param name="sortOrder">The order that you'd like the results sorted - ascending or descending.</param>
/// <param name="videoFields">A list of the fields you wish to have populated in the Videos
/// contained in the playlists. If you omit this parameter, the method returns the following fields of the
/// Video: id, name, shortDescription, longDescription, creationDate, publisheddate, lastModifiedDate, linkURL,
/// linkText, tags, videoStillURL, thumbnailURL, referenceId, length, economics, playsTotal, playsTrailingWeek.
/// If you use a token with URL access, this method also returns the Videos' FLVURL, renditions, FLVFullLength,
/// videoFullLength.</param>
/// <param name="playlistFields">A list of the fields you wish to have populated in the Playlists
/// contained in the returned object. If you omit this parameter, all playlist fields are returned.</param>
/// <param name="customFields">A list of the custom fields you wish to have populated in the videos
/// contained in the returned object. If you omit this parameter, no custom fields are returned, unless you include
/// the value 'customFields' in the video_fields parameter.</param>
/// <param name="getItemCount">If true, also return how many total results there are.</param>
/// <returns>A collection of Playlists that is the specified subset of all the playlists in this account.</returns>
public BrightcoveItemCollection<BrightcovePlaylist> FindAllPlaylists(int pageSize, int pageNumber, SortBy sortBy, SortOrder sortOrder, IEnumerable<string> videoFields,
IEnumerable<string> playlistFields, IEnumerable<string> customFields, bool getItemCount)
{
NameValueCollection parms = BuildBasicReadParams("find_all_playlists");
parms.Add("page_size", pageSize.ToString());
parms.Add("page_number", pageNumber.ToString());
parms.Add("sort_by", sortBy.ToBrightcoveName());
parms.Add("sort_order", sortOrder.ToBrightcoveName());
parms.Add("get_item_count", getItemCount.ToString().ToLower());
if (videoFields != null)
{
parms.AddRange("video_fields", videoFields);
}
if (playlistFields != null)
{
parms.AddRange("playlist_fields", playlistFields);
}
if (customFields != null)
{
parms.AddRange("custom_fields", customFields);
}
return RunQuery<BrightcoveItemCollection<BrightcovePlaylist>>(parms);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Switchvox.CallLogs.Search"/> class for searches where a single search criterion must be specified.
/// </summary>
/// <param name="startDate">The minimum date to search from.</param>
/// <param name="endDate">The maximum date to search to.</param>
/// <param name="searchData">A <see cref="Switchvox.CallLogs.Search.SingleItemSearchData"/> value representing the type of data this request will search for.</param>
/// <param name="data">A single value corresponding with the type of data specified in <paramref name="searchData"/></param>
/// <param name="sortOrder">How the response will be sorted</param>
/// <param name="itemsPerPage">The maximum number of records to be returned by the response. An additional <paramref name="itemsPerPage"/> number of records can be retrieved by making additional requests and modifying the <paramref name="pageNumber"/></param>
/// <param name="pageNumber">The page number of call record results to return.</param>
public Search(DateTime startDate, DateTime endDate, SingleItemSearchData searchData, string data, SortOrder sortOrder = SortOrder.Desc, int itemsPerPage = 50, int pageNumber = 1)
: base("switchvox.callLogs.search")
{
var searchDataElms = GetSingleItemSearchDataElms(searchData, data);
ConstructXml(startDate, endDate, searchDataElms, sortOrder, itemsPerPage, pageNumber);
}
public ListViewColumnSorter()
{
ColumnToSort = 0;
OrderOfSort = SortOrder.None;
numCompare = false;
ObjectCompare = new CaseInsensitiveComparer();
}
/// <summary>
/// Class constructor. Initializes various elements
/// </summary>
public ListViewColumnSorter() {
// Initialize the sort order to 'none'
_orderOfSort = SortOrder.None;
// Initialize the CaseInsensitiveComparer object
_objectCompare = new CaseInsensitiveComparer(CultureInfo.CurrentCulture);
}
public SortFields Add(Range key, SortOn sortOn = SortOn.Values, SortOrder order = SortOrder.Ascending, SortDataOption dataOption = SortDataOption.Normal)
{
InternalObject.GetType().InvokeMember("Add", System.Reflection.BindingFlags.InvokeMethod, null, InternalObject, ComArguments.Prepare(key, sortOn, order, dataOption));
// I'm returning this since the documentation says it returns 'SortFields' not 'SortField'
return this;
}
/// <summary>
/// call this from column click.
/// </summary>
/// <param name="lvs">an instance of listviewsorter</param>
/// <param name="lv">The lv.</param>
/// <param name="column">The column.</param>
/// <param name="forceorder">if set to a value, will sort by that all the time, otherwise will sort as normal</param>
public static void ColumnSort(ListViewSorter lvs, ListView lv, int column, SortOrder? forceorder = null)
{
try
{
lv.ListViewItemSorter = lvs;
if (!(lv.ListViewItemSorter is ListViewSorter))
return;
lvs = (ListViewSorter) lv.ListViewItemSorter;
}
catch (Exception)
{
return;
}
if (forceorder != null)
{
lv.Sorting = (SortOrder) forceorder;
}
else
{
//invert sorting
lv.Sorting = lv.Sorting == SortOrder.Ascending ? SortOrder.Descending : SortOrder.Ascending;
}
lvs.ByColumn = column;
lv.Sort();
}
//---------------------------------------------------------------------
public ListViewColumnSorter()
{
ColumnToSort = 0;
OrderOfSort = SortOrder.None;
ObjectCompare = new CaseInsensitiveComparer();
Order = SortOrder.Ascending;
}
/// <summary>performance tip: expect to have only 1 order item</summary>
public OrderBy(IExpression expr, SortOrder order)
{
orderByList = new List<Pair<IExpression, SortOrder>>(1)
{
new Pair<IExpression, SortOrder>(expr, order)
};
}
public static SearchParams OrderBy(this SearchParams qry, string paramName, SortOrder order = SortOrder.Ascending)
{
if (paramName == null) throw Error.ArgumentNull("paramName");
qry.Sort.Add(Tuple.Create(paramName, order));
return qry;
}
/// <summary>
/// Initializes a new instance of class ListViewItemComparer
/// </summary>
/// <param name="column">Index of sorting column</param>
/// <param name="order">Sort order</param>
public ListViewItemComparer(int column, SortOrder order)
{
col = column;
innerOrder = order;
}
public ListViewSubItemComparerText(int col, SortOrder order)
{
_col = col;
_order = order;
}
public ListViewSubItemComparerText()
{
_col = 0;
_order = SortOrder.Ascending;
}
/// <summary>
/// Initializes a new instance of the NumberComparer class with the specified
/// TableModel, Column index and SortOrder
/// </summary>
/// <param name="tableModel">The TableModel that contains the data to be sorted</param>
/// <param name="column">The index of the Column to be sorted</param>
/// <param name="sortOrder">Specifies how the Column is to be sorted</param>
public NumberComparer(TableModel tableModel, int column, SortOrder sortOrder) : base(tableModel, column, sortOrder)
{
}
public void SetSortIcon(int columnIndex, SortOrder order)
{
}
public ColumnInfo(string input, string output, int maxNumTerms = Defaults.MaxNumTerms, SortOrder sort = Defaults.Sort, string[] term = null, bool textKeyValues = false)
{
Input = input;
Output = output;
Sort = sort;
MaxNumTerms = maxNumTerms;
Term = term;
TextKeyValues = textKeyValues;
}
public static IQueryable <TEntity> Sort <TEntity>(
this IQueryable <TEntity> queryable,
SortOrder <TEntity> sortOrder)
=> sortOrder.Order == SortOrder <TEntity> .Descending
? queryable.OrderByDescending(sortOrder.ToExpression())
: queryable.OrderBy(sortOrder.ToExpression());
public ComboTextComparer(SortOrder order)
{
_modifier = (int)order;
}
private static IOrderedQueryable <TEntity> InvokeSortBy <TEntity>(IQueryable <TEntity> query,
Expression <Func <TEntity, dynamic> > sortPredicate, SortOrder sortOrder)
where TEntity : class, new()
{
var param = sortPredicate.Parameters[0];
string propertyName = null;
Type propertyType = null;
Expression bodyExpression = null;
if (sortPredicate.Body is UnaryExpression)
{
var unaryExpression = sortPredicate.Body as UnaryExpression;
bodyExpression = unaryExpression.Operand;
}
else if (sortPredicate.Body is MemberExpression)
{
bodyExpression = sortPredicate.Body;
}
else
{
throw new ArgumentException(@"The body of the sort predicate expression should be
either UnaryExpression or MemberExpression.", "sortPredicate");
}
var memberExpression = (MemberExpression)bodyExpression;
propertyName = memberExpression.Member.Name;
if (memberExpression.Member.MemberType == MemberTypes.Property)
{
var propertyInfo = memberExpression.Member as PropertyInfo;
if (propertyInfo != null)
{
propertyType = propertyInfo.PropertyType;
}
}
else
{
throw new InvalidOperationException(@"Cannot evaluate the type of property since the member expression
represented by the sort predicate expression does not contain a PropertyInfo object.");
}
var funcType = typeof(Func <,>).MakeGenericType(typeof(TEntity), propertyType);
var convertedExpression = Expression.Lambda(funcType,
Expression.Convert(Expression.Property(param, propertyName), propertyType), param);
var sortingMethods = typeof(Queryable).GetMethods(BindingFlags.Public | BindingFlags.Static);
var sortingMethodName = GetSortingMethodName(sortOrder);
var sortingMethod = sortingMethods.First(sm => sm.Name == sortingMethodName &&
sm.GetParameters().Length == 2);
return((IOrderedQueryable <TEntity>)sortingMethod
.MakeGenericMethod(typeof(TEntity), propertyType)
.Invoke(null, new object[] { query, convertedExpression }));
}
/// <summary>
/// Initializes a new instance of class ListViewItemComparer
/// </summary>
public ListViewItemComparer()
{
col = 0;
innerOrder = SortOrder.Ascending;
}
/// <summary>
/// If set to asc or desc, the column will be sorted in that direction on first
/// sort.Subsequent sorts of the column will toggle as usual (default: null)
/// </summary>
/// <param name = "firstSortOrder">First sort order</param>
public Column SetFirstSortOrder(SortOrder firstSortOrder)
{
_firstSortOrder = firstSortOrder;
return(this);
}
public ComboValueComparer(SortOrder order)
{
_modifier = (int)order;
}
/// <summary>
/// Returns a new pivot everytime it is called recursively and swaps the array elements based on pivot value comparison.
/// </summary>
/// <param name="array">The array that should be sorted.</param>
/// <param name="left">The left partition of <c>array</c>.</param>
/// <param name="right">The right partition of <c>array</c>.</param>
/// <param name="stringComparison">The instance of StringComparsion.</param>
/// <param name="sortOrder">The sort order (Ascending or Descending).</param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when the pivot is out of range.</exception>
/// <returns>The new pivot.</returns>
private static int FindPartition(string[] array, int left, int right, StringComparison stringComparison, SortOrder sortOrder)
{
if (left < 0 || right < 0 || left > array.Length - 1 || right > array.Length - 1)
{
throw new ArgumentOutOfRangeException($"The pivot {left} or {right} is out of range");
}
int i = left, j = right;
string pivot = array[(left + right) / 2];
while (i <= j)
{
while ((sortOrder == SortOrder.Ascending) ? String.Compare(array[i], pivot, stringComparison) < 0 : String.Compare(array[i], pivot, stringComparison) > 0)
{
i++;
}
while ((sortOrder == SortOrder.Ascending) ? String.Compare(array[j], pivot, stringComparison) > 0 : String.Compare(array[j], pivot, stringComparison) < 0)
{
j--;
}
if (i <= j)
{
Swap(ref array[i], ref array[j]);
i++; j--;
}
}
return(i);
}
//============================================================================*
// Private Data Members
//============================================================================*
//============================================================================*
// cListViewFirearmBulletComparer() - Constructor
//============================================================================*
public cListViewFirearmBulletComparer(int nSortColumn, SortOrder SortOrder)
: base(nSortColumn, SortOrder)
{
}
/// <summary>
/// Returns sorted array considering sortorder and sortcomparsion.
/// </summary>
/// <param name="array">The array that should be sorted.</param>
/// <param name="stringComparison">The instance of StringComparsion.</param>
/// <param name="sortOrder">The sort order (Ascending or Descending).</param>
/// <exception cref="ArgumentNullException">Trown when array is null</exception>
/// <returns>The sorted array of string</returns>
public static string[] CustomSort(this string[] array,
StringComparison stringComparison = StringComparison.OrdinalIgnoreCase, SortOrder sortOrder = SortOrder.Ascending)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
if (array.Length == 0)
{
return(array);
}
int left = 0;
int right = array.Count() - 1;
InternalQuickSort(array, left, right, stringComparison, sortOrder);
return(array);
}
public RssItemsListViewColumnSorter()
{
SortColumn = 0;
orderOfSort = SortOrder.Descending;
}
public static IList <T> QuickSort_Iterative <T>(IList <T> elements, SortOrder order) where T : IComparable
{
var borders = new Stack <Tuple <int, int> >();
borders.Push(Tuple.Create(0, elements.Count - 1));
var workers = new List <Thread>();
for (int i = 0; i < 10; i++)
{
workers.Add(new Thread(DoWork));
}
workers.ForEach(w => w.Start());
while (!workers.TrueForAll(w => w.ThreadState == System.Threading.ThreadState.WaitSleepJoin))
{
continue;
}
return(elements);
void DoWork()
{
Tuple <int, int> area;
int comp = (int)order;
while (true)
{
var greater = new List <T>();
var lesser = new List <T>();
var equel = new List <T>();
lock (borders)
{
while (borders.Count == 0)
{
Monitor.Wait(borders);
}
area = borders.Pop();
}
T pivot = elements[area.Item1 / 2 + area.Item2 / 2];
for (int i = area.Item1; i < area.Item2; i++)
{
T current = elements[i];
if (current.CompareTo(pivot) == comp)
{
lesser.Add(current);
}
else if (pivot.CompareTo(current) == comp)
{
greater.Add(current);
}
else
{
equel.Add(current);
}
}
int l = area.Item1;
foreach (var item in lesser.Concat(equel).Concat(greater))
{
elements[l++] = item;
}
lock (borders)
{
if (lesser.Count > 1)
{
borders.Push(Tuple.Create(area.Item1, area.Item1 + lesser.Count));
}
if (greater.Count > 1)
{
borders.Push(Tuple.Create(area.Item2 - greater.Count, area.Item2));
}
Monitor.Pulse(borders);
}
}
}
}
/// <summary>
/// Internal recursive sort algorithm for quick sort using divide and conquer. Sorting is done based on pivot
/// </summary>
/// <param name="array">The array that should be sorted.</param>
/// <param name="left">The left partition of array.</param>
/// <param name="right">The sort order (Ascending or Descending).</param>
/// <param name="stringComparison">The instance of StringComparsion.</param>
/// <param name="sortOrder">The sort order (Ascending or Descending).</param>
private static void InternalQuickSort(string[] array, int left, int right, StringComparison stringComparison, SortOrder sortOrder)
{
int pivotNewIndex = FindPartition(array, left, right, stringComparison, sortOrder);
if (left < pivotNewIndex - 1)
{
InternalQuickSort(array, left, pivotNewIndex - 1, stringComparison, sortOrder);
}
if (pivotNewIndex < right)
{
InternalQuickSort(array, pivotNewIndex, right, stringComparison, sortOrder);
}
}
private static IList <T> Sort <T>(IList <T> list, int start, int end, SortOrder order) where T : IComparable
{
return(QuickSort_Recursive(list, start, end, order));
}
public ListViewItemComparer(int sortColumn, SortOrder sortOrder)
{
_sortColumn = sortColumn;
_sortOrder = sortOrder;
}
public static IList <T> Sort <T>(IList <T> list, SortOrder order = SortOrder.Ascending) where T : IComparable
{
pass = 0;
Sort(list, 0, list.Count - 1, order);
return(list);
}
public static IList <T> QuickSort_Recursive <T>(IList <T> elements, int start, int end, SortOrder order) where T : IComparable
{
int comp = (int)order;
int left = start;
int right = end;
T pivot = elements[start / 2 + end / 2];
while (left < right)
{
while (elements[left].CompareTo(pivot) == comp)
{
left++;
}
while (pivot.CompareTo(elements[right]) == comp)
{
right--;
}
if (left <= right) // '=' needed to push the left and right away
{
T tmp = elements[left];
elements[left] = elements[right];
elements[right] = tmp;
left++;
right--;
}
}
Thread th = null;
if (start < right) //the sequence is now: start...right,left...end
{
if (pass++ < 0)
{
th = new Thread(() => Sort(elements, start, right, order));
th.Start();
}
else
{
Sort(elements, start, right, order);
}
}
if (left < end)
{
Sort(elements, left, end, order);
}
th?.Join();
return(elements);
}
public static UserCollection Top(int count, QueryFilter where, string orderBy = null, SortOrder sortOrder = SortOrder.Ascending, Database database = null)
{
Database db = database ?? Db.For <User>();
QuerySet query = GetQuerySet(db);
query.Top <User>(count);
query.Where(where);
if (orderBy != null)
{
query.OrderBy(orderBy, sortOrder);
}
query.Execute(db);
var results = query.Results.As <UserCollection>(0);
results.Database = db;
return(results);
}
public static void InsertionSort <T>(IList <T> elements, int start, int end, SortOrder order) where T : IComparable
{
int comp = (int)order;
for (int i = start; i < end - 1; i++)
{
int j = i + 1;
T current = elements[j];
while (j > start && current.CompareTo(elements[j - 1]) == comp)
{
elements[j] = elements[j - 1];
j--;
}
elements[j] = current;
}
}
/// <summary>
/// Translates the given <see cref="SortOrder"/> into the string representation
/// used in the XML.
/// </summary>
/// <param name="p_sorOrder">The <see cref="SortOrder"/> to unparse.</param>
/// <returns>The string representation used in the XML for the given <see cref="SortOrder"/>.</returns>
protected string UnparseSortOrder(SortOrder p_sorOrder)
{
return(p_sorOrder.ToString());
}
public SearchImages WithSortOrder(SortOrder value)
{
AddQueryParameter(Constants.SortOrderKey, value);
return(this);
}
protected void GVDoituong_Sorting(object sender, GridViewSortEventArgs e)
{
SortOrder = SortOrder.ToString().Equals("asc") ? "desc" : "asc";
SortExtension = e.SortExpression;
BindList_Doituong();
}
/// <summary>
/// Initializes a new instance of the <see cref="MailKit.UniqueIdSet"/> class.
/// </summary>
/// <remarks>
/// Creates a new unique identifier set.
/// </remarks>
/// <param name="order">The sorting order to use for the unique identifiers.</param>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <paramref name="order"/> is invalid.
/// </exception>
public UniqueIdSet(SortOrder order = SortOrder.None) : this(0, order)
{
}
public OrderItem(Expression <Func <T, dynamic> > sortPredicate, SortOrder sortOrder)
{
this.sortPredicate = sortPredicate;
this.sortOrder = sortOrder;
}
private SortOrder toggleSort(SortOrder o)
{
return(o == SortOrder.Descending ? SortOrder.Ascending : SortOrder.Descending);
}
