/// <summary> /// Creates and caches a function that is euqivalent to the expression <paramref name="expressionToGetTheFunctionFor"/>. /// The expression is modified to return NULL instead of throwing ReferenceNullExceptions if a part of the expression is null. /// </summary> /// <param name="expressionToGetTheFunctionFor"> The expression that should be translated into a compiled function </param> /// <typeparam name="TObject"> The type of the object that is the parameter for the function </typeparam> /// <typeparam name="TResult1"> The type of the result of the function </typeparam> /// <returns> The compiled function that is equivalent to the expression </returns> private static Func <TObject, TResult1> GetMethod <TObject, TResult1>( Expression <Func <TObject, TResult1> > expressionToGetTheFunctionFor) { var key = expressionToGetTheFunctionFor + typeof(TObject).FullName; if (!Expressions.ContainsKey(key)) { var x = (Expression <Func <TObject, TResult1> >)Modifier.Modify(expressionToGetTheFunctionFor); Expressions.Add(key, x.Compile()); } return((Func <TObject, TResult1>)Expressions[key]); }
/// <summary> /// Register a mapping in the private instance. /// </summary> /// <param name="getEntity"> The get expression. </param> /// <param name="setEntity"> The set method. </param> /// <typeparam name="TSource">The source object type</typeparam> /// <typeparam name="TTarget">The target object type</typeparam> public void Register <TSource, TTarget>( Expression <Func <TSource, object> > getEntity, Action <TTarget, object> setEntity) { var typeTupel = new Tuple <Type, Type>(typeof(TSource), typeof(TTarget)); if (!this.mappings.ContainsKey(typeTupel)) { this.mappings.Add(typeTupel, new List <Tuple <object, object> >()); } var mapping = this.mappings[typeTupel]; var modifier = new NullLiftModifier(); var getEntityFunction = ((Expression <Func <TSource, object> >)modifier.Modify(getEntity)).Compile(); mapping.Add(new Tuple <object, object>(getEntityFunction, setEntity)); }
/// <summary> /// compares old to new and sets the destination if both are different. /// </summary> /// <param name="dirty"> The dirty-flag (set to true if a modification in the destination object has been done). </param> /// <param name="newSource"> The new std element. </param> /// <param name="oldSource"> The old std element. </param> /// <param name="valueExtractionExpression"> The expression to extract the value from the source type. </param> /// <param name="setter"> The setter method for the destination object. </param> /// <typeparam name="TDestination"> The type of the destination property. </typeparam> /// <typeparam name="TSource"> The type of the source object. </typeparam> public static void MapIfDiffers <TDestination, TSource>( ref bool dirty, TSource newSource, TSource oldSource, Expression <Func <TSource, TDestination> > valueExtractionExpression, Action <TDestination> setter) { var modifier = new NullLiftModifier(); var function = ((Expression <Func <TSource, TDestination> >)modifier.Modify(valueExtractionExpression)).Compile(); var newValue = function(newSource); if (Equals(function(oldSource), newValue)) { return; } setter(newValue); dirty = true; }