public Top10ListElement(string input)
{
var delim_index = input.IndexOf('{');
if (delim_index != -1)
{
StatName = input.Substring(0, delim_index).Trim();
switch (input[delim_index + 1])
{
case 'L': // low to high sorting
Direction = SortDir.ASC;
break;
case 'H': // high to low sorting
Direction = SortDir.DEC;
break;
default:
throw new InvalidConstraintException("That is not an acceptable sorting direction");
}
}
else
{
StatName = input;
Direction = SortDir.ASC;
}
}
public OrderNode(LambdaExpression expression, SortDir direction, string alias, SqlNode parent) : base(parent)
{
LambdaParameter = expression.Parameters[0].Name;
Alias = alias;
Direction = direction;
Argument = For(expression.Body);
}
private SqlParameter CreateSortDirParameter(SortDir sortDir)
{
return(new SqlParameter("@sortDir", sortDir.ToString())
{
SqlDbType = SqlDbType.NVarChar
});
}
/// <summary>
/// 增加排序条件
/// </summary>
/// <param name="sortField">排序字段</param>
public SearchCondition AddSort(string sortField, SortDir dir)
{
sortField = sortField.ToLower().Trim();
if (_sortSql.Trim() == "")
{
_sortSql = string.Format("{0} {1}", sortField, dir);
}
else
{
if (_sortSql.IndexOf(sortField) >= 0)
{
string[] strAry = _sortSql.Split(new char[] { ',' }, StringSplitOptions.None);
for (int i = 0; i < strAry.Length; i++)
{
if (strAry[i].IndexOf(sortField) >= 0)
{
strAry[i] = string.Format("{0} {1}", sortField, dir.ToString());
break;
}
}
_sortSql = string.Join(",", strAry);
}
else
{
_sortSql = string.Format("{0},{1} {2}", _sortSql, sortField, dir.ToString());
}
}
return(this);
}
private string ResetSortToColumn(string sSortField)
{
if (SortField.Length < 1)
{
SortField = sSortField;
SortDir = string.Empty;
}
else
{
if (SortField.ToLowerInvariant() != sSortField.ToLowerInvariant())
{
SortDir = string.Empty; //previous sort not the same field, force ASC
}
SortField = sSortField;
}
if (SortDir.Trim().ToUpperInvariant().IndexOf("ASC") < 0)
{
SortDir = "ASC";
}
else
{
SortDir = "DESC";
}
sSortField = SortField + " " + SortDir;
return(sSortField);
}
private void radioButton2_CheckedChanged(object sender, EventArgs e)
{
if (radioButton2.Checked)
{
radioButton1.Checked = false;
_dir = SortDir.DEC;
}
}
public SortInfo CreateSortInfo(Expression<Func<TModel, object>> pro, SortDir dir)
{
SortInfo rv = new SortInfo
{
Property = PropertyHelper.GetPropertyName(pro),
Direction = dir
};
return rv;
}
public List <T> SortDataList <T>(List <T> d)
{
List <T> query = null;
IEnumerable <T> myEnumerables = d.AsEnumerable();
if (SortDir.Trim().IndexOf("ASC") < 0)
{
query = (from enu in myEnumerables
orderby GetPropertyValue(enu, SortField) descending
select enu).ToList <T>();
}
else
{
query = (from enu in myEnumerables
orderby GetPropertyValue(enu, SortField) ascending
select enu).ToList <T>();
}
return(query.ToList <T>());
}
public IList SortDataListType(IList lst)
{
IList query = null;
List <object> d = lst.Cast <object>().ToList();
IEnumerable <object> enuQueryable = d.AsQueryable();
if (lst != null && lst.Count > 0)
{
SortField = GetProperties(d[0]).Where(x => x.ToLowerInvariant() == SortField.ToLowerInvariant()).FirstOrDefault();
}
else
{
SortField = string.Empty;
}
if (!string.IsNullOrEmpty(SortField))
{
if (SortDir.ToUpperInvariant().Trim().IndexOf("ASC") < 0)
{
query = (from enu in enuQueryable
orderby GetPropertyValue(enu, SortField) descending
select enu).ToList();
}
else
{
query = (from enu in enuQueryable
orderby GetPropertyValue(enu, SortField) ascending
select enu).ToList();
}
}
else
{
query = (from enu in enuQueryable
select enu).ToList();
}
return(query);
}
/// <summary>
/// The IsAscending
/// </summary>
/// <returns>The <see cref="bool"/></returns>
public bool IsAscending()
{
return(SortDir == null || !SortDir.Equals(Descending, StringComparison.InvariantCultureIgnoreCase));
}
private void ColumnHeaderMouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
var header = ((FrameworkElement)sender).Tag as DataGridColumnHeader;
if (header != null)
{
// 通过HeaderName找到对应的Column
string headerName = header.Content.ToString();
var column = RecordsGrid.Columns.Where(col => col.Header.ToString() == headerName).Single();
// 只对可以排序的Column进行处理
if (column.CanUserSort)
{
var newSortName = string.IsNullOrWhiteSpace(column.SortMemberPath) ? headerName : column.SortMemberPath.Trim();
if (newSortName == _sortName)
{
_sortDir = _sortDir == SortDir.ASC ? SortDir.DESC : SortDir.ASC;
}
else
{
_sortName = newSortName;
_sortDir = SortDir.ASC;
}
// 设置箭头状态
string sortState = _sortDir == SortDir.ASC ? "SortAsc" : "SortDesc";
VisualStateManager.GoToState(header, sortState, true);
if (_currSortColumnHeader != null && _currSortColumnHeader != header)
{
VisualStateManager.GoToState(_currSortColumnHeader, "Unsort", false);
}
_currSortColumnHeader = header;
// 查询
QueryRecords();
}
}
e.Handled = true;
}
/// <summary>
/// creates the sorting expression with the property name and applies it to the queryable
/// </summary>
/// <param name="q"></param>
/// <param name="propertyName"></param>
/// <param name="dir"></param>
/// <returns></returns>
public IQueryable <T> SortWith(IQueryable <T> q, string propertyName, SortDir dir)
{
PropertyInfo prop = typeof(T).GetProperty(propertyName);
if (prop == null)
{
throw new Exception("no such property " + propertyName + " in class " + typeof(T).Name);
}
if (prop.PropertyType == typeof(string))
{
var exp = Expressions.PropertyString <T>(propertyName);
if (dir == SortDir.ASC)
{
q = q.OrderBy(exp);
}
else
{
q = q.OrderByDescending(exp);
}
}
else if (prop.PropertyType == typeof(double))
{
var exp = Expressions.PropertyDouble <T>(propertyName);
if (dir == SortDir.ASC)
{
q = q.OrderBy(exp);
}
else
{
q = q.OrderByDescending(exp);
}
}
else if (prop.PropertyType.IsDecimalType())
{
var exp = Expressions.PropertyDecimal <T>(propertyName);
if (dir == SortDir.ASC)
{
q = q.OrderBy(exp);
}
else
{
q = q.OrderByDescending(exp);
}
}
else if (prop.PropertyType.IsIntgerType())
{
var exp = Expressions.PropertyInt <T>(propertyName);
if (dir == SortDir.ASC)
{
q = q.OrderBy(exp);
}
else
{
q = q.OrderByDescending(exp);
}
}
else if (prop.PropertyType == typeof(DateTime))
{
var exp = Expressions.PropertyDate <T>(propertyName);
if (dir == SortDir.ASC)
{
q = q.OrderBy(exp);
}
else
{
q = q.OrderByDescending(exp);
}
}
else if (prop.PropertyType == typeof(Nullable <DateTime>))
{
var exp = Expressions.PropertyDate <T>(propertyName);
if (dir == SortDir.ASC)
{
q = q.OrderBy(exp);
}
else
{
q = q.OrderByDescending(exp);
}
}
else
{
var exp = Expressions.Property <T>(propertyName);
if (dir == SortDir.ASC)
{
q = q.OrderBy(exp);
}
else
{
q = q.OrderByDescending(exp);
}
}
return(q);
}
public void OrderBy(Expression expression, SortDir direction)
{
OrderNodes.Add(new OrderNode(expression.GetLambda(), direction, FromNode.Alias, this));
}
public static IQueryable <T> SortWith <T, TVal>(this IQueryable <T> q, Expression <Func <T, TVal> > exp, SortDir dir) where T : class
{
return((dir == SortDir.ASC) ? q.OrderBy(exp) : q.OrderByDescending(exp));
}
public static string ToStr(this SortDir dir) => dir == SortDir.Asc ? "asc" : "desc";
public IQueryable <T> SortWith(IQueryable <T> q, string propertyName, SortDir dir)
{
PropertyInfo prop = typeof(T).GetProperty(propertyName);
if (prop == null)
{
return(q);
}
if (prop.PropertyType == typeof(string))
{
var exp = Expressions.PropertyExpression <T, string>(propertyName);
q = q.SortWith(exp, dir);
}
else if (prop.PropertyType == typeof(double))
{
var exp = Expressions.PropertyExpression <T, double>(propertyName);
q = q.SortWith(exp, dir);
}
else if (prop.PropertyType == typeof(double?))
{
var exp = Expressions.PropertyExpression <T, double?>(propertyName);
q = q.SortWith(exp, dir);
}
else if (prop.PropertyType.IsDecimalType())
{
var exp = Expressions.PropertyExpression <T, decimal>(propertyName);
q = q.SortWith(exp, dir);
}
else if (prop.PropertyType.IsDecimalType(true))
{
var exp = Expressions.PropertyExpression <T, decimal?>(propertyName);
q = q.SortWith(exp, dir);
}
else if (prop.PropertyType.IsIntgerType())
{
var exp = Expressions.PropertyExpression <T, long>(propertyName);
q = q.SortWith(exp, dir);
}
else if (prop.PropertyType.IsIntgerType(true))
{
var exp = Expressions.PropertyExpression <T, long?>(propertyName);
q = q.SortWith(exp, dir);
}
else if (prop.PropertyType == typeof(DateTime))
{
var exp = Expressions.PropertyExpression <T, DateTime>(propertyName);
q = q.SortWith(exp, dir);
}
else if (prop.PropertyType == typeof(DateTime?))
{
var exp = Expressions.PropertyExpression <T, DateTime?>(propertyName);
q = q.SortWith(exp, dir);
}
else
{
var exp = Expressions.Property <T>(propertyName);
q = q.SortWith(exp, dir);
}
return(q);
}
public LoadResult FindAsSorted <TR, TV>(Expression <Func <T, TR> > exp, Expression <Func <T, TV> > sort, SortDir dir, ListOptions <TR> opts) where TR : class
{
throw new NotImplementedException();
}
public BoundColumnBuilder <T> Order(int value, SortDir sortDirection)
{
this.Column.SortOrder = value;
this.Column.SortDirection = sortDirection;
return(this);
}
public IEnumerable <IImage> SortBy <TKey>(Func <IImage, TKey> sortProperty, IEnumerable <IImage> collectionToSort, SortDir dir)
{
switch (dir)
{
case SortDir.ASC:
return(collectionToSort.OrderBy(sortProperty).ToArray());
case SortDir.DESC:
return(collectionToSort.OrderByDescending(sortProperty).ToArray());
}
return(collectionToSort.ToArray());
}
public virtual LoadResult FindAsSorted <TR, TV>(Expression <Func <T, TR> > exp, Expression <Func <T, TV> > sort, SortDir dir, ListOptions <TR> opts) where TR : class
{
if (dir == SortDir.ASC)
{
return(Loader.OrderBy(sort).Select(exp).LoadWith(opts));
}
else
{
return(Loader.OrderByDescending(sort).Select(exp).LoadWith(opts));
}
}
public BetfairServerResponse<CurrentOrderSummaryReport> ListCurrentOrders(
ISet<string> betIds = null,
ISet<string> marketIds = null,
OrderProjection? orderProjection = null,
TimeRange placedDateRange = null,
TimeRange dateRange = null,
OrderBy? orderBy = null,
SortDir? sortDir = null,
int? fromRecord = null,
int? recordCount = null)
{
return client.ListCurrentOrders(
betIds,
marketIds,
orderProjection,
placedDateRange,
dateRange,
orderBy,
sortDir,
fromRecord,
recordCount).Result;
}
public BoundColumnBuilder <T> Order(SortDir sortDirection)
{
this.Column.SortOrder = 1;
this.Column.SortDirection = sortDirection;
return(this);
}
