ASP.NET Core 关系映射

Get新知识:

IPropertyMappingService
PropertyMappingService 服务提供类 的提取接口。

    public interface IPropertyMappingService
    {
        Dictionary<string, PropertyMappingValue> GetPropertyMapping<TSource, TDestination>();
        bool ValidMappingExixtsFor<TSource, TDestination>(string fields);
    }

IPropertyMapping
PropertyMapping 类 的提取接口，便于使用，只需要调用接口，asp.net core会注入一个实例供于使用。

    public interface IPropertyMapping
    {
    }

IPropertyCheckService
PropertyCheckService 服务提供类 的提取接口

    public interface IPropertyCheckService
    {
        bool TypeHasProperities<T>(string fields);
    }

PropertyMappingValue
提供DTO的字段值的存放，以及排序方式，DestinationProperties 存放DTO类的全部字段值名。

    public class PropertyMappingValue
    {
        public IEnumerable<String> DestinationProperties { get; set; }
        public bool Revert { get; set; }
        public PropertyMappingValue(IEnumerable<string> destinationProperties, bool revert = false)
        {
            DestinationProperties = destinationProperties ?? throw new ArgumentNullException(nameof(destinationProperties));
            Revert = revert;
        }
    }

PropertyMapping
用于 实体类的字段 和 DTO类的字段 的映射关系的存放，即 MappingDictionary 属性， string 是实体类的字段值名，PropertyMappingValue 是 DTO类的字段值名。

    public class PropertyMapping<TSource, TDestination> : IPropertyMapping
    {
        public Dictionary<string, PropertyMappingValue> MappingDictionary { get;private set; }

        public PropertyMapping(Dictionary<string, PropertyMappingValue> mappingDictionary)
        {
            MappingDictionary = mappingDictionary ?? throw new ArgumentNullException(nameof(mappingDictionary));
        }

    }

PropertyMappingService
服务提供类，提供 获取属性映射关系的方法

    public class PropertyMappingService : IPropertyMappingService
    {
    	// 只读字段，映射关系的配置，就是说明需要映射的两个类之间的字段对应关系
        // 这里是 Company 和 CompanyDto 类之间的具体的字段对应关系的配置
        private readonly Dictionary<string, PropertyMappingValue> _companyProperMapping =
            new Dictionary<string, PropertyMappingValue>(StringComparer.OrdinalIgnoreCase)
            {
                { "Id", new PropertyMappingValue(new List<String>{ "Id"})},
                { "Companyame", new PropertyMappingValue(new List<String>{ "Name"})},
                { "Country", new PropertyMappingValue(new List<String>{ "Country"})},
                { "Industry", new PropertyMappingValue(new List<String>{ "Industry"})},
                { "Product", new PropertyMappingValue(new List<String>{ "Product"})},
                { "Introduction", new PropertyMappingValue(new List<String>{ "Introduction"})}
            };
        // 这里是 Employee 和 EmployeeDto 类之间的具体的字段对应关系的配置
        private readonly Dictionary<string, PropertyMappingValue> _employeeProperMapping =
            new Dictionary<string, PropertyMappingValue>(StringComparer.OrdinalIgnoreCase)
            {
                { "Id", new PropertyMappingValue(new List<String>{ "Id"})},
                { "CompanyId", new PropertyMappingValue(new List<String>{ "CompanyId"})},
                { "EmployeeNo", new PropertyMappingValue(new List<String>{ "EmployeeNo"})},
                { "Name", new PropertyMappingValue(new List<String>{ "First", "LastName"})},
                { "GenderDisplay", new PropertyMappingValue(new List<String>{ "Gender"})},
                { "Age", new PropertyMappingValue(new List<String>{ "DataOfBirth"}, true)}
            };
		// 存放PropertyMapping 的集合
        private readonly IList<IPropertyMapping> _propertyMappings = new List<IPropertyMapping>();
        // 构造函数，
        public PropertyMappingService()
        {
            _propertyMappings.Add(new PropertyMapping<EmployeeDTO, Employee>(_employeeProperMapping));
            _propertyMappings.Add(new PropertyMapping<CompanyDTO, Company>(_companyProperMapping));
        }

        public Dictionary<string, PropertyMappingValue> GetPropertyMapping<TSource, TDestination>()
        {
        	// 从集合等序列中筛选 指定类型的元素，这里是筛选 PropertyMapping 泛型类型的元素
            // 返回存放符合条件元素的集合
            var matchingMapping = _propertyMappings.OfType<PropertyMapping<TSource, TDestination>>();
            if (matchingMapping.Count() == 1)
            {
                return matchingMapping.First().MappingDictionary;
            }
            throw new Exception($"无法找到唯一的映射关系{typeof(TSource)}和{typeof(TDestination)}");
        }

        public bool ValidMappingExixtsFor<TSource, TDestination>(string fields)
        {
            if (string.IsNullOrWhiteSpace(fields))
            {
                return true;
            }
            var propertyMapping = GetPropertyMapping<TSource, TDestination>();
            var fieldAfterSplit = fields.Split(',');
            foreach (var field in fieldAfterSplit)
            {
                var trimmedFields = field.Trim();
                var indexOfFirstSpace = trimmedFields.IndexOf(" ");
                var propertyName = indexOfFirstSpace == -1 ? trimmedFields : trimmedFields.Remove(indexOfFirstSpace);
                if (!propertyMapping.ContainsKey(propertyName))
                {
                    return false;
                }
            }
            return true;
        }
    }