Beispiel #1
0
        /// <summary>
        /// 执行对象映射构造
        /// </summary>
        public void CreateMap()
        {
            List <(Type Source, Type Target)> tuples = new List <(Type Source, Type Target)>();

            Type[] types = AssemblyManager.FindTypesByAttribute <MapFromAttribute>();
            foreach (Type targetType in types)
            {
                MapFromAttribute attribute = targetType.GetAttribute <MapFromAttribute>(true);
                foreach (Type sourceType in attribute.SourceTypes)
                {
                    var tuple = ValueTuple.Create(sourceType, targetType);
                    tuples.AddIfNotExist(tuple);
                }
            }

            types = AssemblyManager.FindTypesByAttribute <MapToAttribute>();
            foreach (Type sourceType in types)
            {
                MapToAttribute attribute = sourceType.GetAttribute <MapToAttribute>(true);
                foreach (Type targetType in attribute.TargetTypes)
                {
                    var tuple = ValueTuple.Create(sourceType, targetType);
                    tuples.AddIfNotExist(tuple);
                }
            }

            foreach ((Type Source, Type Target)tuple in tuples)
            {
                CreateMap(tuple.Source, tuple.Target);
                _logger.LogDebug($"创建“{tuple.Source}”到“{tuple.Target}”的对象映射关系");
            }
            _logger.LogInformation($"创建了 {tuples.Count} 个对象映射关系");
        }
 public void TestTypeOnlyConstructor()
 {
     Type mappedType = typeof(string);
       MapToAttribute testAttribute = new MapToAttribute(mappedType);
       Assert.AreEqual(mappedType, testAttribute.MappedType);
       Assert.AreEqual(String.Empty, testAttribute.Identifier);
 }
Beispiel #3
0
        /// <inheritdoc />
        public void CreateMap()
        {
            List <(Type Source, Type Target)> tuples = new List <(Type Source, Type Target)>();

            Type[] types = _mapFromAttributeTypeFinder.FindAll(true);
            foreach (Type targetType in types)
            {
                MapFromAttribute attribute = targetType.GetAttribute <MapFromAttribute>();
                foreach (Type sourceType in attribute.SourceTypes)
                {
                    var tuple = ValueTuple.Create(sourceType, targetType);
                    tuples.AddIfNotExist(tuple);
                }
            }

            types = _mapToAttributeTypeFinder.FindAll(true);
            foreach (Type sourceType in types)
            {
                MapToAttribute attribute = sourceType.GetAttribute <MapToAttribute>();
                foreach (Type targetType in attribute.TargetTypes)
                {
                    var tuple = ValueTuple.Create(sourceType, targetType);
                    tuples.AddIfNotExist(tuple);
                }
            }

            foreach ((Type Source, Type Target)tuple in tuples)
            {
                CreateMap(tuple.Source, tuple.Target);
            }
        }
 public void TestTypeStringConstructor()
 {
     Type mappedType = typeof(string);
       string identifier = "identifier";
       MapToAttribute testAttribute = new MapToAttribute(mappedType, identifier);
       Assert.AreEqual(mappedType, testAttribute.MappedType);
       Assert.AreEqual(identifier, testAttribute.Identifier);
 }
Beispiel #5
0
    public static void Create()
    {
        var attribute = new MapToAttribute(typeof(MapToAttributeTests));

        Assert.Multiple(() =>
        {
            Assert.That(attribute.Destination, Is.EqualTo(typeof(MapToAttributeTests)));
            Assert.That(attribute.ContainingNamespaceKind, Is.EqualTo(ContainingNamespaceKind.Source));
            Assert.That(attribute.MatchingPropertyTypeKind, Is.EqualTo(MatchingPropertyTypeKind.Implicit));
        });
    }
Beispiel #6
0
        //public static IQueryable<T> SelectFields<T>(this IQueryable<T> query, string fields = "")
        //{
        //    string[] EntityFields;
        //    if (fields == "")
        //        // get Properties of the T
        //        EntityFields = typeof(T).GetProperties().Select(propertyInfo => propertyInfo.Name).ToArray();
        //    else
        //        EntityFields = fields.Split(',');

        //    // input parameter "o"
        //    var xParameter = Expression.Parameter(typeof(T), "o");

        //    // new statement "new Data()"
        //    var xNew = Expression.New(typeof(T));

        //    // create initializers
        //    var bindings = EntityFields.Select(o => o.Trim())
        //        .Select(o =>
        //        {

        //            // property "Field1"
        //            var mi = typeof(T).GetProperty(o);

        //            // original value "o.Field1"
        //            var xOriginal = Expression.Property(xParameter, mi);

        //            // set value "Field1 = o.Field1"
        //            return Expression.Bind(mi, xOriginal);
        //        }
        //    );

        //    // initialization "new Data { Field1 = o.Field1, Field2 = o.Field2 }"
        //    var xInit = Expression.MemberInit(xNew, bindings);

        //    // expression "o => new Data { Field1 = o.Field1, Field2 = o.Field2 }"
        //    var lambda = Expression.Lambda<Func<T, T>>(xInit, xParameter);

        //    // compile to Func<Data, Data>
        //    return query.Select(lambda.Compile()).AsQueryable();
        //}
        //"Id,Name,CountryCode,Cities(Id,Name,Areas(Id,Name))"



        private static string GetMapToName(string propName, Type parentType)
        {
            string mapToName = string.Empty;

            var property = parentType.GetProperty(propName);
            var attrs    = property.GetCustomAttributes(true);

            foreach (object attr in attrs)
            {
                MapToAttribute mapToAttr = attr as MapToAttribute;
                if (mapToAttr != null)
                {
                    mapToName = mapToAttr.Name;
                }
            }
            return(mapToName);
        }
Beispiel #7
0
    public static IMappingExpression <TSource, TDestination> MapTo <TSource, TDestination>(this IMappingExpression <TSource, TDestination> expression)
    {
        Type    sourceType      = typeof(TSource);
        Type    destinationType = typeof(TDestination);
        TypeMap existingMaps    = Mapper.GetAllTypeMaps().First(b => b.SourceType == sourceType && b.DestinationType == destinationType);

        string[] missingMappings = existingMaps.GetUnmappedPropertyNames();
        if (missingMappings.Any())
        {
            PropertyInfo[] sourceProperties = sourceType.GetProperties();
            foreach (string property in missingMappings)
            {
                foreach (PropertyInfo propertyInfo in sourceProperties)
                {
                    MapToAttribute attr = propertyInfo.GetCustomAttribute <MapToAttribute>();
                    if (attr != null && attr.Name == property)
                    {
                        expression.ForMember(property, opt => opt.ResolveUsing(new MyValueResolve(propertyInfo)));
                    }
                }
            }
        }
        return(expression);
    }
        public static void Create()
        {
            var attribute = new MapToAttribute(typeof(MapToAttributeTests));

            Assert.That(attribute.Destination, Is.EqualTo(typeof(MapToAttributeTests)));
        }