C# TypeMap类代码示例

 public IModelSQLEmit CreateModelSQLEmit(IObjectMapInfoCache cache)
 {
     ITypeMap tm = new TypeMap();
     ISQLTranslator tr = new SQLTranslator();
     IModelColumnsBuilder cb = new ModelColumnsBuilder(tr, tm);
     return new ModelSQLEmit(cache, tr, tm, cb);
 }

        private static Expression CreateDestinationFunc(
            TypeMap typeMap,
            TypeMapRegistry typeMapRegistry,
            ParameterExpression srcParam,
            ParameterExpression destParam,
            ParameterExpression ctxtParam)
        {
            var newDestFunc = ToType(CreateNewDestinationFunc(typeMap, typeMapRegistry, srcParam, ctxtParam),
                typeMap.DestinationTypeToUse);

            var getDest = typeMap.DestinationTypeToUse.GetTypeInfo().IsValueType
                ? newDestFunc
                : Coalesce(destParam, newDestFunc);

            Expression destinationFunc = Assign(destParam, getDest);

            if (typeMap.PreserveReferences)
            {
                var dest = Variable(typeof (object), "dest");

                Expression valueBag = Property(ctxtParam, "InstanceCache");
                var set = Assign(Property(valueBag, "Item", srcParam), dest);
                var setCache =
                    IfThen(NotEqual(srcParam, Constant(null)), set);

                destinationFunc = Block(new[] {dest}, Assign(dest, destinationFunc), setCache, dest);
            }
            return destinationFunc;
        }

            protected override void Establish_context()
            {
                _configuration = new Configuration(new TypeMapFactory(), MapperRegistry.AllMappers());
                _configuration.CreateMap<Source, Destination>();

                _expected = _configuration.FindTypeMapFor(null, typeof(Source), typeof(Destination));
            }

 public override void MapByType( Type t, TypeMap otm )
 {
     this.Context = otm;
     XmlDocument document = new XmlDocument();
     document.Load( this.MappingDocument );
     XmlNode node = document.SelectSingleNode( String.Format( "//type-map[@type={0}]", t.Name ) );
     otm.Table = node.Attributes["table"].InnerText;
 }

        private static MemberAssignment BindCustomProjectionExpression(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result)
        {
            var visitor = new ParameterReplacementVisitor(result.ResolutionExpression);

            var replaced = visitor.Visit(propertyTypeMap.CustomProjection.Body);

            return Expression.Bind(propertyMap.DestinationProperty.MemberInfo, replaced);
        }

        public void First()
        {
            var map = new TypeMap();

            ushort id;
            Assert.IsTrue (map.GetTypeId (typeof (string), out id));
            Assert.AreEqual (0, id);
        }

        public static NamedTypeSymbol Construct(this NamedTypeSymbol type, params TypeSymbol[] arguments)
        {
            Debug.Assert(type != null);
            Debug.Assert(arguments != null);
            TypeMap map = new TypeMap(ReadOnlyArray<TypeSymbol>.CreateFrom(type.ConstructedFrom.TypeParameters),
                                            arguments.AsReadOnly());

            return map.SubstituteNamedType(type.ConstructedFrom);
        }

        public void Configure(TypeMap typeMap)
        {
            var sourcePropertyConfig = typeMap.FindOrCreateSourceMemberConfigFor(_sourceMember);

            foreach (var action in _sourceMemberActions)
            {
                action(sourcePropertyConfig);
            }
        }

 public SPParameterConfig(SPParameter parameter, TypeMap map)
 {
     Definition = parameter;
     FriendlyName = NamingHelpers.SplitObjectName(Definition.Name);
     IsRequired = Definition.DefaultValue == null;
     Type= map.GetCodeType(Definition.TypeInfo.TypeName);
     SampleValue = Definition.DefaultValue as String;
     Enabled = true;
 }

        public void When_creating_a_new_context_from_an_existing_context_Should_preserve_context_type_map()
        {
            var map = new TypeMap(new TypeInfo(typeof(int)), new TypeInfo(typeof(string)), MemberList.Destination);

            var context = new ResolutionContext(map, 5, typeof(int), typeof(string), new MappingOperationOptions());

            ResolutionContext newContext = context.CreateValueContext(10);

            newContext.GetContextTypeMap().ShouldNotBeNull();
        }

 public TypeMapPlanBuilder(IConfigurationProvider configurationProvider, TypeMapRegistry typeMapRegistry, TypeMap typeMap)
 {
     _configurationProvider = configurationProvider;
     _typeMapRegistry = typeMapRegistry;
     _typeMap = typeMap;
     _source = Parameter(typeMap.SourceType, "src");
     _initialDestination = Parameter(typeMap.DestinationTypeToUse, "dest");
     _context = Parameter(typeof(ResolutionContext), "ctxt");
     _destination = Variable(_initialDestination.Type, "typeMapDestination");
 }

        internal SPConfig(SPInfo definition, ISPLoader loader, TypeMap typeMap)
        {
            _core = definition;
            _loader = loader;
            _typeMap = typeMap;

            //Defaults:
            FriendlyName = NamingHelpers.SplitObjectName(definition.Name);
            Enabled = true;
        }

        public void ToString_Always_Succeeds()
        {
            //Arrange
            var typeMap = new TypeMap(typeof(string), typeof(int));

            //Act
            string actual = typeMap.ToString();

            //Assert
            Assert.AreEqual<string>(string.Format("{{{0}, {1}}}", typeof(string), typeof(int)), actual);
        }

        public void Add_GoodValues_Succeeds()
        {
            //Arrange
            var typeMapCollection = new TypeMapCollection();
            var typeMap = new TypeMap(typeof(Type), typeof(Type));

            //Act
            typeMapCollection.Add(typeMap);

            //Assert
            Assert.AreEqual<TypeMapBase>(typeMap, typeMapCollection.Get(typeof(Type), typeof(Type)));
        }

        public void CtorTypeMap()
        {
            var map = new TypeMap();
            ushort id;
            map.GetTypeId (typeof (string), out id);
            map.GetTypeId (typeof (int), out id);

            var c = new MockClientConnection (new MockConnectionProvider (MockProtocol.Instance));

            var context = new SerializationContext (c, MockProtocol.Instance, map);

            Assert.AreSame (map, context.TypeMap);
        }