/// <summary> /// <para>Applies a previously registered action on a object. The contextCotainer object MUST contain any context objects required by the registered action.</para> /// <para>Registered actions on interfaces and base classes are also automaticaly applied in this order: Interface actions, Base Class (top to bottom) actions, Target type action.</para> /// </summary> /// <typeparam name="T">The target type</typeparam> /// <param name="item">The target instance</param> /// <param name="contextContainer">A context container created by LinqMapper.CreateContext() or null</param> /// <returns>The target instance</returns> public static T ApplyAfterMap <T>(T item, IObjectContext contextContainer = null) { if (item == null) { return(item); } contextContainer = contextContainer ?? LinqMapper.CreateContext(); var runtimeInfo = InternalCache.GetRuntimeInfo(typeof(T)); if (runtimeInfo != null) { //make sure to dispose tracker using (var tracker = new MaterializerTracker()) { if (Materializer.TreeTraversal == TreeTraversal.ChildrenFirst) { runtimeInfo.ApplyOn(item, contextContainer, tracker); } else { runtimeInfo.ApplyOnRootFirst(item, contextContainer, tracker); } } } return(item); }
public ILinqMapperSyntax <TSource, TDest> IgnoreMembers(params string[] members) { var map = LinqMapper.GetMapCreator(_key); map.IgnoreMembers(members); return(this); }
private Dictionary <string, MemberAssignment> GetPropertyBindings() { if (this._PropertyBindings != null || _expression == null) { return(this._PropertyBindings); } return(this._PropertyBindings = LinqMapper.GetBindingExpressionsDictionary(_expression)); }
private IMapCreator GetBaseMapCreator() { if (_baseMapCreator != null) { return(_baseMapCreator); } return(_baseMapCreator = LinqMapper.GetMapCreator(_basekey)); }
private IQueryable <TDest> GetDestQuery() { var map = LinqMapper.GetMap <TSource, TDest>(_materializerContext); var query = _source.Select(map); if (_queryAction != null) { query = _queryAction(query); } return(query); }
public ILinqMapperSyntax <TSource, TDest> IgnoreRuntimeMembers(Func <IObjectContext, IEnumerable <string> > runtimeIgnore) { if (runtimeIgnore == null) { throw new ArgumentNullException("runtimeDelegate"); } var map = LinqMapper.GetMapCreator(_key); map.IgnoreRuntimeMembers(runtimeIgnore); return(this); }
public ILinqMapperSyntax <TSource, TDest> IgnoreMembers(params Expression <Func <TDest, object> >[] members) { if (members == null || members.Length == 0) { return(this); } var memberNames = members.Select(m => GetMemberName(m)).ToList(); var map = LinqMapper.GetMapCreator(_key); map.IgnoreMembers(memberNames); return(this); }
public ILinqMapperSyntax <TSource, TDest> CreateRuntimeMap <TContext>(Func <TContext, Expression <Func <TSource, TDest> > > runtimeMapCreator) where TContext : class { if (runtimeMapCreator == null) { return(this); } var map = LinqMapper.GetMapCreator(_key); var runtimeMap = new RuntimeMapCreator <TContext, TSource, TDest>(runtimeMapCreator); map.Add(runtimeMap); return(this); }
public ILinqMapperSyntax <TSource, TDest> IncludeBase <TBaseSource, TBaseDest>() { if (!typeof(TBaseSource).IsAssignableFrom(typeof(TSource)) || !typeof(TBaseDest).IsAssignableFrom(typeof(TDest)) || (typeof(TBaseSource) == typeof(TSource) && typeof(TBaseDest) == typeof(TDest))) { throw new ArgumentException($"One or more base types [{typeof(TBaseSource).FullName}, {typeof(TBaseDest).FullName}] are not compatible with the current map types [{typeof(TSource).FullName}, {typeof(TDest).FullName}]."); } var map = LinqMapper.GetMapCreator(_key); var baseMap = new CastBaseMapCreator <TBaseSource, TBaseDest, TSource, TDest>(); //Base map happens first map.AddFirst(baseMap); return(this); }
private Expression <Func <TSource, TDest> > CreateDefaultMap() { var sourceType = typeof(TSource); var destType = typeof(TDest); var propertyBindings = new Dictionary <string, MemberAssignment>(); foreach (var propertyBinding in LinqMapper.GetPropertyBindings(sourceType, destType, this.SourceParameter) .Where(m => !this._ignoreMembers.Contains(m.Member.Name))) { propertyBindings.Add(propertyBinding.Member.Name, propertyBinding); } var newExp = ExpressionNewCreator <TDest> .NewExpression; var body = (Expression)Expression.MemberInit(newExp, propertyBindings.Values); return(Expression.Lambda <Func <TSource, TDest> >(body, this.SourceParameter)); }
public ExtendedMapCreator(Expression <Func <TSource, TDest> > customMapping = null) { IList <string> ignoreMembers; ParameterExpression sourceParam = null; if (customMapping != null) { sourceParam = customMapping.Parameters[0]; ignoreMembers = LinqMapper.GetBindingExpressions(customMapping).Select(e => e.Member.Name).ToList(); } else { sourceParam = Expression.Parameter(typeof(TSource), "src"); ignoreMembers = ArrayExtensions.EmptyArray <string>(); } _defaultCreator = new DefaultMapCreator <TSource, TDest>(sourceParam, ignoreMembers); if (customMapping != null) { this.Add(new StaticMapCreator <TSource, TDest>(sourceParam, customMapping)); } }
protected override Expression VisitMethodCall(MethodCallExpression expression) { bool optionalInvoke; if (isInvokeMapExpression(expression, out optionalInvoke)) { var invokeMapExp = expression as MethodCallExpression; var innerExp = invokeMapExp.Arguments[0]; // e.g. src.Member.Property var genericArguments = invokeMapExp.Method.GetGenericArguments(); var existingMap = invokeMapExp.Arguments.Count == 1 ? LinqMapper.GetMapInternal(genericArguments[0], genericArguments[1], resetCallContext: false, context: _context) : invokeMapExp.Arguments[1]; var invokeMethodInfo = LinqKitInvokeTemplate.MakeGenericMethod(genericArguments[0], genericArguments[1]); var invokeExp = Expression.Call(invokeMethodInfo, existingMap, innerExp); this.ExpressionWasReplaced = true; var expandedInvoke = invokeExp.Expand(); if (optionalInvoke) { // condition test: (src.Member.Property == null) var conditionTest = Expression.MakeBinary(ExpressionType.Equal, innerExp, _NullObjectExpression); // src.Member.Property == null ? (TDest) null : [TSource to TDest Expression] var conditionalExp = Expression.Condition(conditionTest, Expression.Constant(null, expandedInvoke.Type), expandedInvoke, expandedInvoke.Type); return(conditionalExp); } else { return(expandedInvoke); } } return(base.VisitMethodCall(expression)); }
public QueryMaterializer(IQueryable <TSource> source) { _source = source; _materializerContext = LinqMapper.CreateContext(); }