/// <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));
}
