C# TypeMapper类代码示例

 public void TransformedType_RequiredProperties_ReturnsRequiredProperties()
 {
     var mapper = new TypeMapper(new CritterPomonaConfiguration());
     var type = mapper.FromType(typeof(Planet));
     var requiredProperties = type.RequiredProperties.ToList();
     Assert.That(requiredProperties.All(x => x.IsRequiredForConstructor), Is.True);
 }

 public void FromType_QueryResult_ReturnsQueryResultType()
 {
     this.typeMapper = new TypeMapper(new SimplePomonaConfiguration());
     var type = TypeMapper.FromType(typeof(QueryResult<Critter>));
     Assert.That(type, Is.InstanceOf<QueryResultType>());
     Assert.That(type, Is.InstanceOf<QueryResultType<Critter>>());
 }

        /// <summary>
        /// 获取指定类型映射器的属性集合。
        /// </summary>
        /// <param name="mapper">类型映射器。</param>
        /// <param name="entity">类型映射器关联的对象实例，并将 <paramref name="entity"/> 转换成映射器的类型 。</param>
        /// <returns>映射属性的集合枚举。</returns>
        protected virtual IEnumerable<PropertyMapper> FindProperties(TypeMapper mapper, ref object entity)
        {
            IEnumerable<PropertyMapper> pms = mapper.Properties;
            var entityType = entity.GetType();
            if(entityType.IsAssignableFrom(mapper.Type)) return pms;

            var mapper2 = TypeMapper.Create(entityType);

            var query = from op in pms
                        join np in mapper2.Properties on op.Property.Name.ToLower() equals np.Name.ToLower()
                        select new { op, np };
            var entity2 = Activator.CreateInstance(mapper.Type, true);

            List<PropertyMapper> pms2 = new List<PropertyMapper>();
            foreach(var item in query)
            {
                pms2.Add(item.op);
                var value = item.np.GetValue(entity);
                if(!item.op.Property.PropertyType.IsAssignableFrom(item.np.Property.PropertyType))
                {
                    value = Convert.ChangeType(value, item.op.Property.PropertyType);
                }

                item.op.SetValue(entity2, value);
            }
            entity = entity2;
            return pms2;
        }

        public void MapEntityType_should_not_map_invalid_structural_type()
        {
            var model = new EdmModel().Initialize();
            var typeMapper = new TypeMapper(new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model));

            Assert.Null(typeMapper.MapEntityType(typeof(string)));
        }

 public void Start()
 {
     var bootstrapper = new CritterBootstrapper();
     Repository = bootstrapper.Repository;
     TypeMapper = bootstrapper.TypeMapper;
     Host = new NancyHost(BaseUri, bootstrapper);
     Host.Start();
 }

 public void Start()
 {
     var bootstrapper = new CritterBootstrapper();
     this.Repository = bootstrapper.Repository;
     this.TypeMapper = bootstrapper.TypeMapper;
     host = new NancyHost(baseUri, bootstrapper);
     host.Start();
 }

 public void Setup()
 {
     var fakeRepository = MockRepository.GenerateStub<IMapperRepository>();
     _mapper = new TypeMapper(fakeRepository);
     _dummyA = new DummyA { Name = "dummy A", Family = "family A", Age = 37 };
     _dummyB = new DummyB { Name = "dummy A", Family = "family A", Age = 37 };
     _dummyC = new DummyC { Name = "dummy A", Family = "family A", Address = null };
 }

 public void GetUriFor_WithEntityWithSpaceInPath_EncodesUrlTheRightWay()
 {
     var typeMapper = new TypeMapper(new CritterPomonaConfiguration());
     var uriResolver = new UriResolver(typeMapper,
         new DummyBaseUriProvider() { BaseUri = new Uri("http://whateva/") });
     var galaxy = new Galaxy() { Name = "this is it" };
     var url = uriResolver.GetUriFor(galaxy);
     Assert.That(url, Is.EqualTo("http://whateva/galaxies/this%20is%20it"));
 }

        public void CanMapSimpleNullableTypes(Type type, string expectedParamType, string expectedFormat = "")
        {
            var mapper = new TypeMapper();
            var inputParam = new InputParameter { Type = type };
            var param = mapper.Map(inputParam);

            Assert.AreEqual(expectedParamType, param.type);
            Assert.AreEqual(expectedFormat, param.format);

            Assert.IsEmpty(mapper.Models);
        }

        public void CanMapEnumerableIntegerTypes(Type collectionType)
        {
            var mapper = new TypeMapper();

            var param = mapper.Register(collectionType);

            Assert.AreEqual("array", param.Type);
            Assert.AreEqual("integer", param.Items.Type);

            Assert.IsEmpty(mapper.Models);
        }

        public void MapComplexType_should_not_map_ignored_type()
        {
            var model = new EdmModel(DataSpace.CSpace);
            var mockModelConfiguration = new Mock<ModelConfiguration>();
            var typeMapper = new TypeMapper(new MappingContext(mockModelConfiguration.Object, new ConventionsConfiguration(), model));
            mockModelConfiguration.Setup(m => m.IsIgnoredType(typeof(AType1))).Returns(true);

            var complexType = typeMapper.MapComplexType(typeof(AType1));

            Assert.Null(complexType);
        }

 public ClientLibGenerator(TypeMapper typeMapper)
 {
     if (typeMapper == null)
         throw new ArgumentNullException("typeMapper");
     this.typeMapper = typeMapper;
     this.allowedReferencedAssemblies = new[]
     {
         /*mscorlib*/typeof(string).Assembly, typeof(IPomonaClient).Assembly, /*System.Core*/
         typeof(Func<>).Assembly, /*System*/ typeof(Uri).Assembly
     };
     PomonaClientEmbeddingEnabled = true;
 }

        public void MapEntityType_should_not_map_ignored_type()
        {
            var model = new EdmModel().Initialize();
            var mockModelConfiguration = new Mock<ModelConfiguration>();
            var typeMapper = new TypeMapper(new MappingContext(mockModelConfiguration.Object, new ConventionsConfiguration(), model));
            var mockType = new MockType("Foo");
            mockModelConfiguration.Setup(m => m.IsIgnoredType(mockType)).Returns(true);

            var entityType = typeMapper.MapEntityType(mockType);

            Assert.Null(entityType);
        }

 public Factory ToFactory(IEnumerable<Column> columns, TypeMapper typeMapper)
 {
   if (columns.Count() != _attributes.Count())
   {
     throw new InvalidOperationException("Did not get equal number of Columns and Attributes");
   }
   var readers = columns.Zip<Column, Attribute, Func<object[], object>>(_attributes, (column, attribute) => {
     var mapper = typeMapper.MappingFor(column, attribute);
     return (row) => mapper(column.Read(row));
   });
   return new Factory(_info, readers.ToArray());
 }

 public HandlerMethod(MethodInfo methodInfo, TypeMapper typeMapper)
 {
     if (methodInfo == null)
         throw new ArgumentNullException(nameof(methodInfo));
     if (typeMapper == null)
         throw new ArgumentNullException(nameof(typeMapper));
     MethodInfo = methodInfo;
     TypeMapper = typeMapper;
     this.parameters =
         new Lazy<IList<HandlerParameter>>(
             () => methodInfo.GetParameters().Select(x => new HandlerParameter(x, this)).ToList());
     this.parameterTypes = new Lazy<IList<Type>>(() => Parameters.MapList(x => x.Type));
 }