/// <summary> /// Initializes a new instance of the <see cref="ThenByEntitySorter{TEntity, TKey}"/> class. /// </summary> /// <param name="baseSorter">The base sorter.</param> /// <param name="keySelector">The key selector.</param> /// <param name="direction">The direction.</param> public ThenByEntitySorter(IEntitySorter <TEntity> baseSorter, Expression <Func <TEntity, TKey> > keySelector, SortDirection direction) { this.baseSorter = baseSorter; this.keySelector = keySelector; this.direction = direction; }
public static IEntitySorter <T> ThenByDescending <T, TKey>( this IEntitySorter <T> sorter, Expression <Func <T, TKey> > keySelector) { return(new ThenBySorter <T, TKey>(sorter, keySelector, SortDirection.Desc)); }
/// <summary> /// Initializes a new instance of the <see cref="ThenByEntitySorter{TEntity,TKey}" /> class. /// Initializes a new instance of the <see cref="ThenByEntitySorter{TEntity, TKey}" /> class. /// </summary> /// <param name="baseSorter"> /// The base sorter. /// </param> /// <param name="keySelector"> /// The key selector. /// </param> /// <param name="sortDirection"> /// The sortDirection. /// </param> public ThenByEntitySorter( IEntitySorter <TEntity> baseSorter, Expression <Func <TEntity, TKey> > keySelector, SortDirection sortDirection) { _baseSorter = baseSorter; _keySelector = keySelector; _sortDirection = sortDirection; }
public static IQueryable <T> OrderBy <T>(this IQueryable <T> source, params ISorting[] sortings) { IEntitySorter <T> sorter = null; if (sortings != null) { foreach (var sorting in sortings) { if (sorter == null) { sorter = sorting.Ascending ? EntitySorter <T> .OrderBy(sorting.ColumnName) : EntitySorter <T> .OrderByDescending(sorting.ColumnName); } else { sorter = sorting.Ascending ? sorter.ThenBy(sorting.ColumnName) : sorter.ThenByDescending(sorting.ColumnName); } } return(sorter != null?sorter.Sort(source) : source); } return(source); }
public IEnumerable <TResult> Select <TResult>(Func <TEntity, TResult> selector, IEntityFilter <TEntity> filter = null, IEntitySorter <TEntity> sorter = null, IEntityLoader <TEntity> loader = null) { return(List(filter, sorter, null, null, loader).Select(selector)); }
public ThenBySorter(IEntitySorter <T> baseSorter, Expression <Func <T, TKey> > selector, SortDirection direction) { _baseSorter = baseSorter; _keySelector = selector; _direction = direction; }
public static IEntitySorter <T> ThenByDescending <T>(this IEntitySorter <T> sorter, string propertyName) { var builder = new EntitySorterBuilder <T>(propertyName); builder.Direction = SortDirection.Descending; return(builder.BuildThenByEntitySorter(sorter)); }
public static IEntitySorter <T> ThenBy <T>( this IEntitySorter <T> sorter, string propertyName) { var builder = new EntitySorterBuilder <T>(propertyName) { Direction = SortDirection.Asc }; return(builder.BuildThenByEntitySorter(sorter)); }
public TEntity First(IEntityFilter <TEntity> filter = null, IEntitySorter <TEntity> sorter = null, IEntityLoader <TEntity> loader = null) { var entities = (filter ?? EntityFilter <TEntity> .AsQueryable()).Filter(Entities); if (loader != null) { return(loader.First(entities)); } return(entities.First()); }
public IEntitySorter <T> BuildThenByEntitySorter( IEntitySorter <T> baseSorter) { var typeArgs = new[] { typeof(T), _keyType }; var sortType = typeof(ThenBySorter <,>).MakeGenericType(typeArgs); return((IEntitySorter <T>)Activator.CreateInstance(sortType, baseSorter, _keySelector, Direction)); }
internal IEntitySorter <TEntity> BuildThenByEntitySorter(IEntitySorter <TEntity> baseSorter) { Type[] typeArguments = new[] { typeof(TEntity), this.keyType }; Type sorterType = typeof(ThenByEntitySorter <,>).MakeGenericType(typeArguments); object[] constructorArguments = { baseSorter, this.keySelector, this.SortDirection }; object instance = Activator.CreateInstance(sorterType, constructorArguments); return((IEntitySorter <TEntity>)instance); }
/// <summary> /// Creates a new <see cref="IEntitySorter{TEntity}"/> that performs a subsequent ordering of the /// elements in in a collection of <typeparamref name="TEntity"/> objects in descending order /// by using the property, specified by it's <paramref name="propertyName"/>. /// </summary> /// <typeparam name="TEntity">The type of the entity.</typeparam> /// <param name="sorter">The sorter.</param> /// <param name="propertyName">Name of the property or a list of chained properties, separated by a dot.</param> /// <returns>A new <see cref="IEntitySorter{TEntity}"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when the specified <paramref name="keySelector"/> /// is a null reference or when the specified <paramref name="sorter"/> is a null reference.</exception> /// <exception cref="ArgumentException">Thrown when the specified <paramref name="propertyName"/> is /// empty or when the specified property could not be found on the <typeparamref name="TEntity"/>. /// </exception> /// <exception cref="ArgumentNullException">Thrown when <paramref name="sorter"/> or /// <paramref name="propertyName"/> are null.</exception> public static IEntitySorter <TEntity> ThenByDescending <TEntity>(this IEntitySorter <TEntity> sorter, string propertyName) { if (sorter == null) { throw new ArgumentNullException("sorter"); } var builder = new EntitySorterBuilder <TEntity>(propertyName); builder.SortDirection = SortDirection.Descending; return(builder.BuildThenByEntitySorter(sorter)); }
/// <summary> /// Creates a new <see cref="IEntitySorter{TEntity}"/> that performs a subsequent ordering of the /// elements in in aa collection of <typeparamref name="TEntity"/> objects in descending order /// according to a key. /// </summary> /// <typeparam name="TEntity">The type of the entity.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="sorter">The sorter.</param> /// <param name="keySelector">The key selector.</param> /// <returns>A new <see cref="EntitySorter{TEntity}"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="sorter"/> or /// <paramref name="keySelector"/> are null.</exception> public static IEntitySorter <TEntity> ThenByDescending <TEntity, TKey>(this IEntitySorter <TEntity> sorter, Expression <Func <TEntity, TKey> > keySelector) { if (sorter == null) { throw new ArgumentNullException("sorter"); } if (keySelector == null) { throw new ArgumentNullException("keySelector"); } // Wrap the original sorter in a new entity sorter to extend the sorting. return(new ThenByEntitySorter <TEntity, TKey>(sorter, keySelector, SortDirection.Descending)); }
/// <summary> /// Creates a new <see cref="IEntitySorter{TEntity}"/> that sorts the elements of a sequence /// in descending order according to a key. /// </summary> /// <typeparam name="TEntity">The type of the entity.</typeparam> /// <typeparam name="TKey">The type of the key returned by the function that is represented by keySelector.</typeparam> /// <param name="sorter">The sorter.</param> /// <param name="keySelector">A function to extract a key from an element.</param> /// <returns>An <see cref="IEntitySorter{TEntity}"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="sorter"/> or /// <paramref name="keySelector"/> are null.</exception> public static IEntitySorter <TEntity> OrderByDescending <TEntity, TKey>(this IEntitySorter <TEntity> sorter, Expression <Func <TEntity, TKey> > keySelector) { if (sorter == null) { throw new ArgumentNullException("sorter"); } if (keySelector == null) { throw new ArgumentNullException("keySelector"); } // Note: The sorter parameter is not used, because an OrderBy will invalidate all previous // OrderBy and ThenBy statements (as Enumerable.OrderBy and Queryable.OrderBy do). return(EntitySorter <TEntity> .OrderByDescending(keySelector)); }
public IList <TEntity> List(IEntityFilter <TEntity> filter = null, IEntitySorter <TEntity> sorter = null, int?page = null, int?pageSize = null, IEntityLoader <TEntity> loader = null) { if ((page.HasValue || pageSize.HasValue) && sorter == null) { throw new ArgumentException("You have to define a sorting order if you specify a page or pageSize! (IEntitySorter was null)"); } if (page.HasValue && !pageSize.HasValue) { throw new ArgumentException("You have to define a pageSize if you specify a page!"); } var entities = Entities; if (filter != null) { entities = filter.Filter(entities); } if (sorter != null) { entities = sorter.Sort(entities); } if (page != null) { entities = entities.Skip(pageSize.Value * page.Value); } if (pageSize != null) { entities = entities.Take(pageSize.Value); } entities = entities.InterceptWith(new QueryableEntitiesVisitor()); if (loader != null) { return(loader.Load(entities)); } return(entities.ToList()); }
public static IEntitySorter <T> OrderBy <T, TKey>( this IEntitySorter <T> sorter, Expression <Func <T, TKey> > keySelector) { return(EntitySorter <T> .OrderBy(keySelector)); }