public MemberConfigurationEntityCacheExpression <TSource, TDestination, TMember, TKey, TEntity> Entity <TEntity>( Expression <Func <TEntity, TMember> > entityValueExpression) where TEntity : class { var resolver = new EntityCacheMemberValueResolver <TSource, TDestination, TKey, TMember, TEntity>( entityValueExpression); _memberConfigurationExpression.MapFrom(resolver, _sourceKeyMember); return(new MemberConfigurationEntityCacheExpression <TSource, TDestination, TMember, TKey, TEntity>( resolver)); }
public void ApplyConfiguration(IMemberConfigurationExpression memberConfigurationExpression) { var sourceMemberAttribute = memberConfigurationExpression.DestinationMember.GetCustomAttribute <SourceMemberAttribute>(); if (sourceMemberAttribute != null) { memberConfigurationExpression.MapFrom(Type, sourceMemberAttribute.Name); } else { memberConfigurationExpression.MapFrom(Type); } }
private void PropertyBuilder(IMemberConfigurationExpression <Product, ProductResponse, string> obj) { var url = "https://localhost:44306/content"; obj.MapFrom(s => s.PictureUrl); obj.AddTransform(x => string.IsNullOrEmpty(x) ? "No url found.." : $"{url}/{x}"); }
private void DepartmentFamilies(IMemberConfigurationExpression <DepartmentEntity, DepartmentResource, CategoryFamily[]> opt) { opt.MapFrom((tr, a, b, map) => tr.CategoriesByFamily.Select(s => new CategoryFamily() { Name = s.Key, Categories = map.Mapper.Map <CategoryResource[]>(s.Value) })); }
public static void MapFromPrice <TSource, TDestination, TMember>( this IMemberConfigurationExpression <TSource, TDestination, TMember> config, string listId) where TSource : ODataProductModel { config.MapFrom(model => model.GetPrice(listId)); }
public static void MapFromField <TSource, TDestination, TMember>( this IMemberConfigurationExpression <TSource, TDestination, TMember> config, string fieldId) where TSource : ODataProductModel { config.MapFrom((model, destination, member, context) => model.GetValue <TMember>(fieldId, context.GetMappingCulture())); }
public static void MapFromField <TSource, TDestination, TMember>( this IMemberConfigurationExpression <TSource, TDestination, TMember> config, string fieldId, string culture) where TSource : ODataProductModel { config.MapFrom(model => model.GetValue <TMember>(fieldId, CultureInfo.GetCultureInfo(culture))); }
private static void ResolveImageModelFromBlogPost <T>(IMemberConfigurationExpression <BlogPost, T, ImageViewModel> exp) { exp.MapFrom((blogPost, viewModel, image) => blogPost.Image == null ? null : new ImageViewModel() { UriPath = blogPost.Image.UriPath }); }
public void As <TResult>() where TResult : class { _configurationExpression.MapFrom(src => { var session = _getSession(); var id = (object)_getSourceMember(src); return(session.Load <TResult>(id)); }); }
public static void DropAndCreateCollection <TSource, TSourceItem, TDestination, TDestinationItem> ( this IMemberConfigurationExpression <TSource, TDestination, ICollection <TDestinationItem> > config, Expression <Func <TSource, ICollection <TSourceItem> > > sourceCollectionSelector, Func <TSourceItem, TDestinationItem> projection = null, Action <TDestinationItem> removeCallback = null, Func <TDestinationItem, bool> destinationFilter = null ) { var dropAndCreateCollectionResolver = new DropAndCreateCollectionResolver <TSource, TSourceItem, TDestination, TDestinationItem>(projection, removeCallback, destinationFilter); config.MapFrom(dropAndCreateCollectionResolver, sourceCollectionSelector); }
public static void NullSafeMapFrom <T, TResult>(this IMemberConfigurationExpression <T> opt, Expression <Func <T, TResult> > sourceMemberExpression) { var sourceMember = sourceMemberExpression.Compile(); opt.MapFrom(src => { try { return(sourceMember(src)); } catch (NullReferenceException) {} return(default(TResult)); }); }
public static void Unflatten <TSource, TDestination, TMember>(this IMemberConfigurationExpression <TSource, TDestination, TMember> config) { config.MapFrom((source, destination, member, resolutionContext) => { string prefix = typeof(TMember).Name; TMember resolvedObject = (TMember)Activator.CreateInstance(typeof(TMember)); PropertyInfo[] targetProperties = resolvedObject.GetType().GetProperties(); foreach (var sourceMember in source.GetType().GetProperties()) { // find the matching target property and populate it PropertyInfo matchedProperty = targetProperties.FirstOrDefault(p => sourceMember.Name == prefix + p.Name); matchedProperty?.SetValue(resolvedObject, sourceMember.GetValue(source)); } return(resolvedObject); }); }
/// <summary> /// /// </summary> /// <typeparam name="TSource"></typeparam> /// <typeparam name="TDestination"></typeparam> /// <typeparam name="TMember"></typeparam> /// <param name="config"></param> /// <param name="fieldId"></param> /// <param name="culture">If null, will take culture from the mapping context (i.e use together with .MapWithCultureTo(...)</param> public static void MapFromTextOptionLabel <TSource, TDestination, TMember>( this IMemberConfigurationExpression <TSource, TDestination, TMember> config, string fieldId, string culture = null) where TSource : ODataProductModel { Func <ODataProductModel, TDestination, TMember, ResolutionContext, string> mapping = (model, destination, member, context) => { var field = IoC.Resolve <FieldDefinitionService>().Get <ProductArea>(fieldId); if (field == null) { return(null); } var options = field.Option as TextOption; if (options == null) { return(null); } var value = model.GetValue <object>(fieldId); var result = new List <string>(); if (value is IList <string> values) { foreach (var i in values) { AddLabel(options, i, culture ?? context.GetMappingCulture(), result); } } else if (value != null) { AddLabel(options, (string)value, culture ?? context.GetMappingCulture(), result); } return(string.Join(",", result)); }; config.MapFrom(mapping); }
public static void SyncCollectionByKey <TSource, TSourceItem, TDestination, TDestinationItem, TKey> ( this IMemberConfigurationExpression <TSource, TDestination, ICollection <TDestinationItem> > config, Expression <Func <TSource, ICollection <TSourceItem> > > sourceCollectionSelector, Func <TSourceItem, TKey> sourceKeySelector, Func <TDestinationItem, TKey> destinationSelector, Func <TSourceItem, TDestinationItem> createFunction = null, Action <TSourceItem, TDestinationItem> updateFunction = null, Action <TDestinationItem> removeFunction = null, bool keepRemovedItemsInDestinationCollection = false, Func <TDestinationItem, bool> destinationFilter = null ) { config.MapFrom(new SyncByKeyCollectionResolver <TSource, TSourceItem, TDestination, TDestinationItem, TKey>() { SourceKeySelector = sourceKeySelector, DestinationKeySelector = destinationSelector, CreateFunction = createFunction, UpdateFunction = updateFunction, RemoveFunction = removeFunction, KeepRemovedItemsInDestinationCollection = keepRemovedItemsInDestinationCollection, DestinationFilter = destinationFilter ?? (_ => true) }, sourceCollectionSelector); }
private void MapFromMicrosoftPosters(IMemberConfigurationExpression <Post> opt) { opt.MapFrom(x => x.Comments.Where(c => c.Email.Contains("@microsoft.com")).Select(c => c.Email)); }
private void MapFileName(IMemberConfigurationExpression <BuildableProject, BuildableProjectDto, string> memberConfigurationExpression) { var pathProxy = ProvisioningServiceSingleton.Instance.GetService <IPathProxy>(); memberConfigurationExpression.MapFrom(f => pathProxy.GetFileName(f.FilePath)); }
public static void ReadAsNumber(this IMemberConfigurationExpression <IDataReader> opt, string fieldName) { opt.MapFrom(reader => reader.GetDecimal(reader.GetOrdinal(fieldName))); }
public static void ReadAsBoolean(this IMemberConfigurationExpression <IDataReader> opt, string fieldName) { opt.MapFrom(reader => reader.GetString(reader.GetOrdinal(fieldName)).ToUpper() == "Y"); }
/// <summary> /// 加载实体对象。 /// <remarks></remarks> /// </summary> public void LoadEntity <TSource, TMember, TKey>(IMemberConfigurationExpression <TSource> opt, Func <TSource, TKey> getId, Func <TKey, TMember> doLoad) where TMember : class { opt.Condition(src => (getId(src) != null)); opt.MapFrom(src => CheckIdIsValid <TKey>(getId(src)) ? null : doLoad(getId(src))); }
private void MapFromClaimType(IMemberConfigurationExpression <IEnumerable <Claim>, User, string> opts, string claimType) { opts.MapFrom(src => src.First(c => c.Type == claimType).Value); }
// Summary: // Resolve destination member using a custom value resolver callback. Used instead // of MapFrom when not simply redirecting a source member This method cannot be // used in conjunction with LINQ query projection // // Parameters: // resolver: // Callback function to resolve against source type public static void ResolveUsing <TSource, TDestination, TMember, TResult>(this IMemberConfigurationExpression <TSource, TDestination, TMember> member, Func <TSource, TResult> resolver) => member.MapFrom((Func <TSource, TDestination, TResult>)((src, dest) => resolver(src)));
public static void MapFromField <TSource, TDestination, TMember>(this IMemberConfigurationExpression <TSource, TDestination, TMember> config, string fieldId) where TSource : FieldFrameworkModel { config.MapFrom(model => model.GetValue <TMember>(fieldId)); }