public static IEnumerable <TTarget> Convert <TTarget>(this IEnumerable coll, ModelConvertOptions options)
{
Type sourceType = coll.GetType();
if (sourceType.IsGenericType)
{
sourceType = sourceType.GetGenericArguments()[0];
if (options == null)
{
options = new ModelConvertOptions();
}
options.Source(sourceType);
}
foreach (object obj in coll)
{
yield return(ModelConvert.Convert <TTarget>(obj, options));
}
}
protected virtual ModelConvertOptions CreateConvertOptions(EntityAction action)
{
var options = new ModelConvertOptions();
if (action == EntityAction.ToModel)
{
options.Target <TModel>().Source <TEntity>();
}
else
{
options.Target <TEntity>().Source <TModel>();
}
options.IgnoreReadOnly();
if (action == EntityAction.Modify)
{
options.Target <TEntity>().IgnoreKeys();
}
return(options);
}
public SourceOptions(ModelConvertOptions model, Type modelType)
: base(model, modelType)
{
}
public static IQueryable <TTarget> Build <TSource, TTarget>(IQueryable <TSource> source, ModelConvertOptions options)
{
if (options == null)
{
options = ModelConvert.Target <TTarget>().Source <TSource>().Options.IgnoreReadOnly();
}
options.IgnoreReadOnly();
MemberBindingState state = new MemberBindingState(Expression.Parameter(typeof(TSource), "obj"));
ModelConvert.WalkConvertiblProperties(null, ModelInfo.GetModelInfo(typeof(TTarget)), null, ModelInfo.GetModelInfo(typeof(TSource)), options, BuildProperty, state);
var body = Expression.MemberInit(Expression.New(typeof(TTarget)), state.Bindings);
var lambda = Expression.Lambda <Func <TSource, TTarget> >(body, state.Parameter);
return(source.Select(lambda));
}
public Task <PagedResult <TResult> > QueryByResultAsync <TResult>(QueryArgs args, ModelConvertOptions options = null)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
if (args.Sort.IsNullOrEmpty())
{
args.SetDefaultSort <TEntity>(DefaultSort);
}
return(QueryFilter(Table, args).PagedResultByResultAsync <TEntity, TResult>(args, options));
}
public static PagedResult <TResult> PagedResultByResult <TSource, TResult>(this IQueryable <TSource> query, QueryArgs args, ModelConvertOptions options)
{
IQueryable <TResult> query1;
query1 = Convert <TSource, TResult>(query, options);
var state = WhereAndOrderBy(query1, args);
query1 = state.Final;
WriteSQL(query1);
return(Linq.PagedResult <TResult> .Create(query1.ToArray(), args, state.Count, state.Plain));
}
public static IQueryable <TResult> Convert <TSource, TResult>(this IQueryable <TSource> source, ModelConvertOptions options)
{
return(SelectBuilder.Build <TSource, TResult>(source, options));
}
public static async Task <PagedResult <TResult> > PagedResultByResultAsync <TSource, TResult>(this IQueryable <TSource> query, QueryArgs args, ModelConvertOptions options)
{
IQueryable <TResult> query1;
query1 = query.Convert <TSource, TResult>(options);
var state = await WhereAndOrderBy(query1, args);
query1 = state.Final;
WriteSQL(query1);
return(PagedResult <TResult> .Create(await query1.ToArrayAsync(), args, state.Count, state.Plain));
}
public static IEnumerable <TTarget> Convert <TTarget>(this IEnumerable coll)
{
ModelConvertOptions options = new ModelConvertOptions();
return(Convert <TTarget>(coll, options));
}
public BaseOptions(ModelConvertOptions model, Type modelType)
{
Options = model;
ModelType = modelType;
}
