public TDestination Map <TDestination>(object source, TDestination destination = null) where TDestination : class { if (destination != null) { return(source.Adapt(destination)); } return(source.Adapt <TDestination>()); }
public static ValidationErrors Value(object target) { if (target == null) { throw new ArgumentNullException("target"); } // Self validation should be tried first; then the validator should be created ISelfValidation sv = target.Adapt <ISelfValidation>(); if (sv != null) { return(sv.Validate()); } Validator v = Validator.CreateSelfValidator(target.GetType()); if (v != null) { return(v.Validate(target)); } v = Validator.Create(target.GetType()); if (v != null) { return(v.Validate(target)); } throw ValidationFailure.ValidationNotDefined(); }
private EntityCore GetByType(object src) { EntityCore res = new EntityCore(); if (src.GetType() == typeof(LeadViewModel)) { res = src.Adapt <Lead>(config); } if (src.GetType() == typeof(ContactViewModel)) { res = src.Adapt <Contact>(config); } return(res); }
public TDestination Map <TDestination>(object source) { Type sourceType = source.GetType().Namespace == "System.Data.Entity.DynamicProxies" ? source.GetType().BaseType : source.GetType(); return((TDestination)source.Adapt(sourceType, typeof(TDestination), _mapsterConfiguration.Configuration)); }
private T AdaptTypeToDesirableType <T>(object item) { if (item.GetType() == typeof(T)) { return((T)item); } return(item.Adapt <T>()); }
/// <summary> /// Imports / maps the given Poco to the current Bean. /// Poco properties and Bean properties must match exactly. /// </summary> /// <param name="poco">Simple Poco instance</param> public Bean ImportPoco(object poco) { var config = new TypeAdapterConfig(); config.ForType(poco.GetType(), typeof(Dictionary <string, object>)).IgnoreNullValues(true); return(Import(poco.Adapt <Dictionary <string, object> >(config))); }
public static T MapTo <T>(this object obj) { if (obj == null) { return(default(T)); } return(obj.Adapt <T>()); }
/// <summary> /// 对象映射 /// </summary> /// <typeparam name="TDestination"></typeparam> /// <param name="source"></param> /// <param name="ignoreNames">忽略字段</param> /// <returns></returns> public static TDestination MapTo <TDestination>(this object source, IEnumerable <string> ignoreNames) { if (source == null) { return(default(TDestination)); } var setting = new TypeAdapterConfig().NewConfig(source.GetType(), typeof(TDestination)).Ignore(ignoreNames.ToArray()); return(source.Adapt <TDestination>(setting.Config)); }
private Object ConvertEntityCollectionToDto(object elements) { var type1 = elements.GetType(); genericListType = listType.MakeGenericType(this.dtoType); var array = elements.Adapt(type1, this.genericListType); return(array); }
/// <summary> /// Converts an object to another using Mapster library. Creates a new object of /// <typeparamref name="TDestination" />. /// There must be a mapping between objects before calling this method. /// </summary> /// <typeparam name="TDestination">Type of the destination object</typeparam> /// <param name="source">Source object</param> public static TDestination MapTo <TDestination>([NotNull] this object source) { return(source.Adapt <TDestination>(TypeAdapterConfig.GlobalSettings)); }
public TTarget Map <TTarget>(object source) { return(source.Adapt <TTarget>()); }
private object ConvertIt(object @object, Type from, Type to) { var toObject = @object.Adapt(from, to); return(toObject); }
public static List <TTarget> MapToList <TTarget>(this object source) { return(source.Adapt <List <TTarget> >()); }
/// <summary> /// 对象映射 /// </summary> /// <param name="source"></param> /// <param name="destination"></param> /// <param name="sourceType"></param> /// <param name="destinationType"></param> /// <returns></returns> public static object MapTo(this object source, object destination, Type sourceType, Type destinationType) { return(source.Adapt(destination, sourceType, destinationType)); }
public void Map(object source, object target) { source.Adapt(target); }
/// <summary> /// /// </summary> /// <typeparam name="TDestination"></typeparam> /// <param name="source"></param> /// <returns></returns> public TDestination Map <TDestination>(object source) { return(source.Adapt <TDestination>()); }
/// <summary> /// Converts an object to another using Mapster library. Creates a new object of /// <typeparamref name="TDestination" />. /// There must be a mapping between objects before calling this method. /// </summary> /// <typeparam name="TDestination">Type of the destination object</typeparam> /// <param name="source">Source object</param> public static TDestination MapTo <TDestination>(this object source) { return(source.Adapt <TDestination>()); }
/// <summary> /// 对象映射 /// </summary> /// <param name="source"></param> /// <param name="destination"></param> /// <param name="sourceType"></param> /// <param name="destinationType"></param> /// <param name="ignoreNames">忽略字段</param> /// <returns></returns> public static object MapTo(this object source, object destination, Type sourceType, Type destinationType, params string[] ignoreNames) { var setting = new TypeAdapterConfig().NewConfig(sourceType, destinationType).Ignore(ignoreNames); return(source.Adapt(destination, sourceType, destinationType, setting.Config)); }
/// <summary> /// 对象映射 /// </summary> /// <param name="source"></param> /// <param name="destination"></param> /// <param name="sourceType"></param> /// <param name="destinationType"></param> /// <param name="ignoreNames">忽略字段</param> /// <returns></returns> public static object MapTo(this object source, object destination, Type sourceType, Type destinationType, IEnumerable <string> ignoreNames) { var setting = new TypeAdapterConfig().NewConfig(sourceType, destinationType).Ignore(ignoreNames.ToArray()); return(source.Adapt(destination, sourceType, destinationType, setting.Config)); }
public Task <TD> Map <TD>(object message) { return(Task.FromResult(message.Adapt <TD>())); }
public TDestination MapTo <TDestination>(object source) => source.Adapt <TDestination>();
/// <summary> /// Adapt extension of Mapster /// </summary> /// <typeparam name="T"></typeparam> /// <param name="obj"></param> /// <returns></returns> public static T MapType <T>(this object obj) => obj.Adapt <T>();
public static TTarget MapTo <TTarget>(this object source) { return(source.Adapt <TTarget>()); }
public TTarget Map <TTarget>(object source) where TTarget : class { return(source.Adapt <TTarget>()); }
public TDestination Map <TDestination>(object source) { return(source.Adapt <TDestination>(_mapsterConfiguration.Configuration)); }
public object Map(object source, Type targetType) { return(source.Adapt(source.GetType(), targetType)); }
public TDestination Map <TDestination>(object source) { TypeAdapterConfig typeAdapterConfig = TypeAdapterConfig <object, TDestination> .NewConfig().PreserveReference(true).Config; return(source.Adapt <TDestination>(typeAdapterConfig)); }
/// <summary> /// Mapping to an existing object. /// /// </summary> /// <typeparam name="TDestination"></typeparam> /// <param name="source"></param> /// <param name="destination"></param> /// <returns></returns> public static TDestination MapTo <TDestination>(this object source, TDestination destination) { return(source.Adapt(destination)); }