private InvokeResult <(IEnumerable <Condition> conditions, IEnumerable <Sort> sorts)> CreateMunrosQuery( IEnumerable <HillCategory> hillCategories = null, SortDirectionType heightSortDirectionType = SortDirectionType.None, SortDirectionType nameSortDirectionType = SortDirectionType.None, double?heightMinMetres = null, double?heightMaxMetres = null) => _invokeHandler.Invoke(() =>
public InvokeResult <IEnumerable <MunroModel> > GetMunrosByQuery( IEnumerable <HillCategory> hillCategories = null, SortDirectionType heightSortDirectionType = SortDirectionType.None, SortDirectionType nameSortDirectionType = SortDirectionType.None, double?heightMinMetres = null, double?heightMaxMetres = null, int?limit = null) => _invokeHandler.Invoke(() => { var queryResult = this.CreateMunrosQuery( hillCategories, heightSortDirectionType, nameSortDirectionType, heightMinMetres, heightMaxMetres); if (!queryResult.IsSuccess) { return(InvokeResult <IEnumerable <MunroModel> > .Fail(queryResult.Code)); } var munros = _munrosRepository.GetAll(); var result = _munroService.GetMunrosByQuery(munros, queryResult.Result.conditions, queryResult.Result.sorts, limit); return(result); });
private static IEnumerable <OrderByInfo> ParseOrderBy(string orderColumn, SortDirectionType orderDirection) { if (String.IsNullOrEmpty(orderColumn)) { yield break; } string[] items = orderColumn.Split(','); bool initial = true; foreach (string item in items) { string[] pair = item.Trim().Split(' '); if (pair.Length > 2) { throw new ArgumentException(String.Format("Invalid OrderBy string '{0}'. Order By Format: Property, Property2 ASC, Property2 DESC", item)); } string prop = pair[0].Trim(); if (String.IsNullOrEmpty(prop)) { throw new ArgumentException("Invalid Property. Order By Format: Property, Property2 ASC, Property2 DESC"); } yield return(new OrderByInfo { PropertyName = prop, Direction = orderDirection, Initial = initial }); initial = false; } }
/// <summary> /// 按照指定的规则排序 /// </summary> /// <param name="orderByProperty"></param> /// <param name="direction"></param> public void Sort(OrderByPropertyType orderByProperty, SortDirectionType direction) { T[] objArray = this.ToArray(); Array.Sort(objArray, delegate(T x, T y) { int result = 0; switch (orderByProperty) { case OrderByPropertyType.FullPath: result = x.FullPath.CompareTo(y.FullPath); break; case OrderByPropertyType.GlobalSortID: result = x.GlobalSortID.CompareTo(y.GlobalSortID); break; case OrderByPropertyType.Name: result = x.Name.CompareTo(y.Name); break; } if (direction == SortDirectionType.Descending) { result = -result; } return(result); }); this.Clear(); this.CopyFrom(objArray); }
/// <summary> /// To the list. /// </summary> /// <param name="array">The array.</param> /// <param name="sortDirectionType">Type of the sort direction.</param> /// <param name="removeDuplicates">if set to <c>true</c> [remove duplicates].</param> public static List <string> ToList(this Array array, SortDirectionType sortDirectionType = SortDirectionType.None, bool removeDuplicates = false) { if (array == null) { throw new ArgumentNullException(nameof(array)); } var list = new List <string>(array.Length); for (var i = 0; i < array.Length; i++) { var s = array.GetValue(i).ToString(); if (removeDuplicates) { if (!list.Contains(s)) { list.Add(s); } } else { list.Add(s); } } return(sortDirectionType switch { SortDirectionType.None => list, SortDirectionType.Ascending => list.OrderBy(x => x).ToList(), SortDirectionType.Descending => list.OrderByDescending(x => x).ToList(), _ => throw new SwitchCaseDefaultException(sortDirectionType) });
public void ConvertEnumToArray <T>( T dummyForT, int expectedCount, DropDownFirstItemType dropDownFirstItemType, bool useDescriptionAttribute, bool includeDefault, SortDirectionType sortDirectionType, bool byFlagIncludeBase, bool byFlagIncludeCombined) where T : Enum { // Arrange var enumType = dummyForT.GetType(); // Act var actual = EnumHelper.ConvertEnumToArray( enumType, dropDownFirstItemType, useDescriptionAttribute, includeDefault, sortDirectionType, byFlagIncludeBase, byFlagIncludeCombined); // Assert actual.Should().NotBeNull().And.HaveCount(expectedCount); }
public void SortTable(int expected, string sortOnColumn, SortDirectionType sortDirection) { // Arrange var dt = GenerateTestTable(); // Act var actual = dt.SortTable(sortOnColumn, sortDirection); dt.Dispose(); // Assert actual.Should().NotBeNull().And.BeOfType <DataTable>(); actual.Rows.Should().HaveCount(expected); var sortOnColumnArray = ( from DataRow row in actual.Rows select row[sortOnColumn].ToString()) .ToArray(); if (sortDirection == SortDirectionType.Ascending) { sortOnColumnArray.Should().Equal("Brian", "Christoff", "David", "Janet", "Melanie", "Sam"); } else { sortOnColumnArray.Should().Equal("Sam", "Melanie", "Janet", "David", "Christoff", "Brian"); } }
public void ChangeSortMethod(SortCriteria sortBy, SortDirectionType sortDirection) { if (CurrentBrowserViewModel is BaseDirectoryViewerViewModel <FI, DI, FSI> ) { var dirVM = (CurrentBrowserViewModel as BaseDirectoryViewerViewModel <FI, DI, FSI>).EmbeddedDirectoryViewModel; dirVM.SortBy = sortBy; dirVM.SortDirection = sortDirection == SortDirectionType.sortAssending ? ListSortDirection.Ascending : ListSortDirection.Descending; } }
public void ToList(string[] expected, string[] input, SortDirectionType sortDirectionType, bool removeDuplicates) { // Act var actual = input.ToList(sortDirectionType, removeDuplicates); // Assert actual.Should() .NotBeNull() .And.HaveCount(expected.Length) .And.Contain(expected); }
private static string GetSortMethodName(SortDirectionType sortDirect) { switch (sortDirect) { case SortDirectionType.Ascending: return("OrderBy"); case SortDirectionType.Descending: return("OrderByDescending"); default: return(""); } }
public void ToArray <T>( T dummyForT, int expectedCount, DropDownFirstItemType dropDownFirstItemType, bool useDescriptionAttribute, bool includeDefault, SortDirectionType sortDirectionType, bool byFlagIncludeBase, bool byFlagIncludeCombined) where T : Enum { // ReSharper disable once UnusedVariable object dummyAssignment = dummyForT; // Act var actual = Enum <T> .ToArray(dropDownFirstItemType, useDescriptionAttribute, includeDefault, sortDirectionType, byFlagIncludeBase, byFlagIncludeCombined); // Assert actual.Should().NotBeNull().And.HaveCount(expectedCount); }
public static void ChangeSortMethod <FI, DI, FSI>( this System.Collections.ObjectModel.ObservableCollection <NavigationItemViewModel <FI, DI, FSI> > collection, SortCriteria sortBy, System.ComponentModel.ListSortDirection sortDirection) where FI : FSI where DI : FSI { System.Windows.Data.ListCollectionView dataView = (System.Windows.Data.ListCollectionView) (System.Windows.Data.CollectionViewSource.GetDefaultView(collection)); dataView.SortDescriptions.Clear(); dataView.CustomSort = null; SortDirectionType direction = sortDirection == System.ComponentModel.ListSortDirection.Ascending ? SortDirectionType.sortAssending : SortDirectionType.sortDescending; dataView.CustomSort = new EntryComparer <FI, DI, FSI>(sortBy, direction) { IsFolderFirst = true }; }
/// <summary> /// 排序 /// </summary> /// <param name="orderByProperty">排序属性,<seealso cref="OrderByPropertyType"/>。</param> /// <param name="direction">排序方式,<seealso cref="SortDirectionType"/>。</param> public void Sort(OrderByPropertyType orderByProperty, SortDirectionType direction) { T[] objArray = new T[this.Count]; Items.CopyTo(objArray, 0); Array.Sort(objArray, delegate(T x, T y) { int result = 0; switch (orderByProperty) { case OrderByPropertyType.FullPath: result = x.FullPath.CompareTo(y.FullPath); break; case OrderByPropertyType.GlobalSortID: result = x.GlobalSortID.CompareTo(y.GlobalSortID); break; case OrderByPropertyType.Name: result = x.Name.CompareTo(y.Name); break; } if (direction == SortDirectionType.Descending) { result = -result; } return(result); }); Items.Clear(); for (int i = 0; i < objArray.Length; i++) { Items.Add(objArray[i]); } }
public static IOrderedQueryable <T> OrderBy <T>(this IQueryable <T> current, SortDirectionType sortDirect, string field) { var modelType = typeof(T); var methodName = GetSortMethodName(sortDirect); // Генерируем x => x.Name var param = Expression.Parameter(modelType, "x"); var property = Expression.Property(param, field); var lambdaProperty = Expression.Lambda(property, param); var methodInfo = typeof(Queryable).GetMethods(BindingFlags.Public | BindingFlags.Static).FirstOrDefault(x => x.Name == methodName && x.GetParameters().Length == 2 && x.GetGenericArguments().Length == 2); var genericMethod = methodInfo.MakeGenericMethod(modelType, property.Type); var commonParam = Expression.Parameter(typeof(IQueryable <T>), "y"); // Генерируем вызов метода OrderBy или OrderByDescending var exp = Expression.Call(genericMethod, commonParam, lambdaProperty); var a = Expression.Lambda <Func <IQueryable <T>, IOrderedQueryable <T> > >(exp, commonParam); return(a.Compile()(current)); }
/// <summary> /// To the array. /// </summary> /// <param name="array">The array.</param> /// <param name="sortDirectionType">Type of the sort direction.</param> /// <param name="removeDuplicates">if set to <c>true</c> [remove duplicates].</param> public static Array ToArray(this Array array, SortDirectionType sortDirectionType = SortDirectionType.None, bool removeDuplicates = false) { return(ToList(array, sortDirectionType, removeDuplicates).ToArray()); }
public ProvincesList(ProvinceListSortField sort, SortDirectionType dir, Dictionary<ProvinceListFilter, string> filters) { }
public TransactionsList(TransactionsListSortField sort, SortDirectionType dir, Dictionary<TransactionsListFilter, string> filters) { }
/// <summary> /// Convenience constructor /// </summary> /// <param name="sortDirection">Direction of the sort</param> /// <param name="propertyPath">Property path used for this field order</param> /// public FieldOrderType(SortDirectionType sortDirection, BasePathToElementType propertyPath) { this.orderField = sortDirection; this.itemField = propertyPath; }
//sorts cameras by Camera3D::drawDepth - used for PIP screen layout - see ScreenManager public void SortByDepth(SortDirectionType sortDirectionType) { this.cameraList.Sort(new CameraDepthComparer(sortDirectionType)); }
public EntryComparer(SortCriteria criteria, SortDirectionType direction) { SortBy = criteria; SortDirection = direction; }
/// <summary> /// Sorts the table. /// </summary> /// <param name="dataTable">The data table.</param> /// <param name="sortOnColumn">The sort on column.</param> /// <param name="sortDirection">The sort direction.</param> public static DataTable SortTable(this DataTable dataTable, string sortOnColumn, SortDirectionType sortDirection) { if (dataTable == null) { throw new ArgumentNullException(nameof(dataTable)); } if (string.IsNullOrEmpty(sortOnColumn)) { throw new ArgumentNullOrDefaultException(nameof(sortOnColumn)); } var sortExpression = sortDirection == SortDirectionType.Ascending ? sortOnColumn + " ASC" : sortOnColumn + " DESC"; return(FilterTable(dataTable, string.Empty, sortExpression)); }
public static IQueryable <T> OrderBy <T>(this IQueryable <T> collection, string orderColumn, SortDirectionType orderDirection) { return(ParseOrderBy(orderColumn, orderDirection).Aggregate(collection, ApplyOrderBy)); }
public InventoryList(InventoryListSortField sort, SortDirectionType dir, Dictionary<InventoryListFilter, string> filters) { }
public CameraDepthComparer(SortDirectionType sortDirectionType) { this.sortDirectionType = sortDirectionType; }
public SortField(string expression, SortDirectionType direction) { SortDirection = direction; SortExpression = expression; }
public ProvincesList(ProvinceListSortField sort, SortDirectionType dir, Dictionary <ProvinceListFilter, string> filters) { }
public RelationshipTypeList(RelationshipTypeListSortField sort, SortDirectionType dir, Dictionary<ProvinceListFilter, string> filters) { }
public RelationshipTypeList(RelationshipTypeListSortField sort, SortDirectionType dir, Dictionary <ProvinceListFilter, string> filters) { }
public TransactionsList(TransactionsListSortField sort, SortDirectionType dir, Dictionary <TransactionsListFilter, string> filters) { }
public static IQueryable <TSource> OrderWithDirectionBy <TSource, TKey>(this IQueryable <TSource> source, bool isFirst, SortDirectionType direction, Expression <Func <TSource, TKey> > selector) { return(!isFirst ? direction == SortDirectionType.Ascending ? ((IOrderedQueryable <TSource>)source).ThenBy(selector) : ((IOrderedQueryable <TSource>)source).ThenByDescending(selector) : direction == SortDirectionType.Ascending ? source.OrderBy(selector) : source.OrderByDescending(selector)); }
public InventoryList(InventoryListSortField sort, SortDirectionType dir, Dictionary <InventoryListFilter, string> filters) { }