C# TypePair类代码示例

 public bool IsMatch(TypePair context)
 {
     return IsPrimitiveArrayType(context.DestinationType) &&
            IsPrimitiveArrayType(context.SourceType) &&
            (TypeHelper.GetElementType(context.DestinationType)
                .Equals(TypeHelper.GetElementType(context.SourceType)));
 }

 private string GetTargetName(
     Option<BindingConfig> bindingConfig,
     TypePair typePair,
     MemberInfo sourceMember,
     Dictionary<string, string> targetBindings)
 {
     Option<string> targetName;
     List<BindAttribute> binds = sourceMember.GetAttributes<BindAttribute>();
     BindAttribute bind = binds.FirstOrDefault(x => x.TargetType.IsNull());
     if (bind.IsNull())
     {
         bind = binds.FirstOrDefault(x => typePair.Target.IsAssignableFrom(x.TargetType));
     }
     if (bind.IsNotNull())
     {
         targetName = new Option<string>(bind.MemberName);
     }
     else
     {
         targetName = bindingConfig.Map(x => x.GetBindField(sourceMember.Name));
         if (targetName.HasNoValue)
         {
             string targetMemberName;
             if (targetBindings.TryGetValue(sourceMember.Name, out targetMemberName))
             {
                 targetName = new Option<string>(targetMemberName);
             }
             else
             {
                 targetName = new Option<string>(sourceMember.Name);
             }
         }
     }
     return targetName.Value;
 }

 private MapperCacheItem CreateMapperCacheItem(TypePair typePair)
 {
     MapperBuilder mapperBuilder = GetMapperBuilder(typePair);
     Mapper mapper = mapperBuilder.Build(typePair);
     MapperCacheItem mapperCacheItem = _mapperCache.Add(typePair, mapper);
     return mapperCacheItem;
 }

 private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, ResolutionContext context)
 {
     var typeMap = context.TypeMap;
     if (typeMap != null)
     {
         typeMapsChecked.Add(typeMap);
         CheckPropertyMaps(typeMapsChecked, context);
     }
     else
     {
         var mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(context.Types));
         if (mapperToUse == null && context.SourceType.IsNullableType())
         {
             var nullableTypes = new TypePair(Nullable.GetUnderlyingType(context.SourceType),
                 context.DestinationType);
             mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(nullableTypes));
         }
         if (mapperToUse == null)
         {
             throw new AutoMapperConfigurationException(context);
         }
         if (mapperToUse is ArrayMapper || mapperToUse is EnumerableMapper || mapperToUse is CollectionMapper)
         {
             CheckElementMaps(typeMapsChecked, context);
         }
     }
 }

 public bool IsMatch(TypePair context)
 {
     // destination type must be IEnumerable interface or a class implementing at least IList 
     return ((context.DestinationType.IsInterface() && context.DestinationType.IsEnumerableType()) ||
             context.DestinationType.IsListType())
            && context.SourceType.IsEnumerableType();
 }

 private static bool EnumToEnumMapping(TypePair context)
 {
     // Enum to enum mapping
     var sourceEnumType = TypeHelper.GetEnumerationType(context.SourceType);
     var destEnumType = TypeHelper.GetEnumerationType(context.DestinationType);
     return sourceEnumType != null && destEnumType != null;
 }

 private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types, TypeMap typeMap, ResolutionContext context)
 {
     if (typeMap != null)
     {
         typeMapsChecked.Add(typeMap);
         if(typeMap.CustomMapper != null || typeMap.TypeConverterType != null)
         {
             return;
         }
         CheckPropertyMaps(typeMapsChecked, typeMap, context);
     }
     else
     {
         var mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(types));
         if (mapperToUse == null && types.SourceType.IsNullableType())
         {
             var nullableTypes = new TypePair(Nullable.GetUnderlyingType(types.SourceType),
                 types.DestinationType);
             mapperToUse = _config.GetMappers().FirstOrDefault(mapper => mapper.IsMatch(nullableTypes));
         }
         if (mapperToUse == null)
         {
             throw new AutoMapperConfigurationException(types);
         }
         if (mapperToUse is ArrayMapper || mapperToUse is EnumerableMapper || mapperToUse is CollectionMapper)
         {
             CheckElementMaps(typeMapsChecked, types, context);
         }
     }
 }

        private static Option<Func<object, object>> ConvertEnum(TypePair pair)
        {
            Func<object, object> result;
            if (pair.IsEnumTypes)
            {
                result = x => Convert.ChangeType(x, pair.Source);
                return result.ToOption();
            }

            if (pair.Target.IsEnum)
            {
                if (pair.Source.IsEnum == false)
                {
                    if (pair.Source == typeof(string))
                    {
                        result = x => Enum.Parse(pair.Target, x.ToString());
                    }
                }
                result = x => Enum.ToObject(pair.Target, Convert.ChangeType(x, Enum.GetUnderlyingType(pair.Target)));
                return result.ToOption();
            }

            if (pair.Source.IsEnum)
            {
                result = x => Convert.ChangeType(x, pair.Target);
                return result.ToOption();
            }
            return Option<Func<object, object>>.Empty;
        }

        private MapperCacheItem CreateMapperCacheItem(TypePair parentTypePair, MappingMember mappingMember)
        {
            MapperBuilder mapperBuilder = _config.GetMapperBuilder(parentTypePair, mappingMember);
            Mapper mapper = mapperBuilder.Build(parentTypePair, mappingMember);
            MapperCacheItem mapperCacheItem = _mapperCache.Add(mappingMember.TypePair, mapper);

            return mapperCacheItem;
        }

 public MemberEmitterDescription Build(TypePair parentTypePair, List<MappingMember> members)
 {
     var emitter = new EmitComposite();
     members.ForEach(x => emitter.Add(Build(parentTypePair, x)));
     var result = new MemberEmitterDescription(emitter, _mapperCache);
     result.AddMapper(_mapperCache);
     return result;
 }

 public TypeMap(TypeDetails sourceType, TypeDetails destinationType, MemberList memberList, ProfileMap profile)
 {
     SourceTypeDetails = sourceType;
     DestinationTypeDetails = destinationType;
     Types = new TypePair(sourceType.Type, destinationType.Type);
     Profile = profile;
     ConfiguredMemberList = memberList;
 }

 public TypeMap(TypeDetails sourceType, TypeDetails destinationType, MemberList memberList)
 {
     _sourceType = sourceType;
     _destinationType = destinationType;
     Types = new TypePair(sourceType.Type, destinationType.Type);
     Profile = ConfigurationStore.DefaultProfileName;
     ConfiguredMemberList = memberList;
 }

 public MapperBuilder GetMapperBuilder(TypePair parentTypePair, MappingMember mappingMember)
 {
     if (_customTypeMapperBuilder.IsSupported(parentTypePair, mappingMember))
     {
         return _customTypeMapperBuilder;
     }
     return GetTypeMapperBuilder(mappingMember.TypePair);
 }

 public bool IsSupported(TypePair parentTypePair, MappingMember mappingMember)
 {
     Option<BindingConfig> bindingConfig = _config.GetBindingConfig(parentTypePair);
     if (bindingConfig.HasNoValue)
     {
         return false;
     }
     return bindingConfig.Value.HasCustomTypeConverter(mappingMember.Target.Name);
 }

        public bool IsMatch(TypePair context)
        {
            if (!(context.SourceType.IsEnumerableType() && context.DestinationType.IsGenericType()))
                return false;

            var genericType = context.DestinationType.GetGenericTypeDefinition();

            return genericType == typeof (ReadOnlyCollection<>);
        }