C# Model.GetType方法代码示例

        public override void Collided(Model with, Displayable.CollisionStatus status)
        {
            if (status == Displayable.CollisionStatus.TOP) return; //lol???
            if (status == Displayable.CollisionStatus.BOTTOM)
            {
                DisableFreeFall();
                this.Velocity = new Velocity();
                return;
            }

            if (with.GetType() == typeof(Wall))
            {
                mBlockedWallId = with.ModelId;
                return;
            }

            if (with.GetType() != typeof(Character))
            {
                return;
            }

            if (mBlockedWallId != -1) return;

            if (status == Displayable.CollisionStatus.LEFT)
            {
                this.mPosition.X = with.Left - this.Origin.X;
            }
            else if (status == Displayable.CollisionStatus.RIGHT)
            {
                this.mPosition.X = with.Right + this.Origin.X;
            }
        }

 public static View.IDisplayItem produce(Model.IStoryContent storyContent)
 {
     if (storyContent.GetType().Equals(typeof(Model.RssStoryContent))) {
         Model.RssStoryContent rssStoryContent = (Model.RssStoryContent)storyContent;
         return new View.RssDisplayStory(rssStoryContent.Title, rssStoryContent.Description, rssStoryContent.Published, rssStoryContent.Link);
     }
     else if (storyContent.GetType().Equals(typeof(Model.AtomStoryContent))) {
         Model.AtomStoryContent atomStoryContent = (Model.AtomStoryContent)storyContent;
         return new View.AtomDisplayStory(atomStoryContent.Title, atomStoryContent.Summary, atomStoryContent.Updated, atomStoryContent.Link);
     }
     else
     {
         throw new Exception("Cannot display unsupported news content");
     }
 }

        public override void NotColliding(Model with)
        {
            if (with.GetType() != typeof(Character)) return;
            Character chara = (Character)with;
            if (mPlayerIndex != (PlayerIndex)chara.Index) return;

            mDoorStatus = DoorStatus.CLOSED;
        }

        public IJobTaskWorker GetWorkerFor( Model.JobTask task )
        {
            var tt = task.GetType();
            var generic = typeof( IJobTaskWorker<> );
            var worker = generic.MakeGenericType( tt );

            return ( IJobTaskWorker )this.container.GetService( worker );
        }

        public Handlers.Tasks.IJobTaskRunner GetRunnerFor( Model.JobTask task )
        {
            var tt = task.GetType();
            var generic = typeof( IJobTaskRunner<> );
            var runner = generic.MakeGenericType( tt );

            return ( IJobTaskRunner )this.container.GetService( runner );
        }

        public IJobWorker GetWorkerFor( Model.Job job )
        {
            var jt = job.GetType();
            var generic = typeof( IJobWorker<> );
            var worker = generic.MakeGenericType( jt );

            return ( IJobWorker )this.container.GetService( worker );
        }

        public Handlers.Jobs.IJobRunner GetRunnerFor( Model.Job job )
        {
            var jt = job.GetType();
            var generic = typeof( IJobRunner<> );
            var runner = generic.MakeGenericType( jt );

            return ( IJobRunner )this.container.GetService( runner );
        }

 // POST api/clientes
 public void Post(Model.Cidade model)
 {
     using (TextWriter textWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath(string.Format("~/XMLFiles/{0}.xml", ((Model.Cidade)model).Codigo.ToString()))))
     {
         XmlSerializer serializer = new XmlSerializer(model.GetType(), new XmlRootAttribute("Cidade"));
         serializer.Serialize(textWriter, model);
     }
 }

        public override void Collided(Model with, Displayable.CollisionStatus status)
        {
            if (status == Displayable.CollisionStatus.TOP) return;
            if (with.GetType() != typeof(Character)) return;
            Character chara = (Character)with;
            if (mPlayerIndex != (PlayerIndex)chara.Index) return;

            mDoorStatus = DoorStatus.OPEN;
        }

        /// <summary>
        /// 生成插入语句
        /// </summary>
        /// <param name="model">模型对象</param>
        /// <returns></returns>
        public virtual string BuildInsertSQL(Model.Model model)
        {
            List<string> fileds = new List<string>();
            List<string> values = new List<string>();
            var propertys = model.GetType().GetProperties();
            var identity = model.getIdentify();
            foreach (var p in propertys)
            {
                if (!Magic.Mvc.Equals.IsNull(identity) && identity.Name == p.Name) continue;

                var notmaps = p.GetCustomAttributes(typeof(Model.NotMapingAttribute), false);
                if (notmaps != null && notmaps.Length > 0) continue;

                fileds.Add(string.Format("[{0}]", p.Name));
                values.Add(string.Format("@{0}", p.Name));
            }

            return string.Format(" INSERT INTO [{0}]({1}) VALUES({2}) ", model.GetType().Name, string.Join(",", fileds.ToArray()), string.Join(",", values.ToArray()));
        }

        /// <summary>
        /// 获取sql参数
        /// </summary>
        /// <returns></returns>
        public virtual IDataParameter[] GetParameters(Model.Model model)
        {
            var propertys = model.GetType().GetProperties();

            List<IDataParameter> listSQLParamter = new List<IDataParameter>();
            foreach (var p in propertys)
            {
                listSQLParamter.Add(new SqlParameter() { ParameterName = p.Name, Value = model.Property(p.Name) });
            }
            return listSQLParamter.ToArray();
        }

        public void Label_from_property_should_return_the_example()
        {
            Model m = new Model() { Enum = Foo.Bar };
            var pi = m.GetType().GetProperty("Enum");
            //arrange

            //act
            var result = _conventions.LabelForPropertyConvention(pi);

            //assert
            Assert.AreEqual("label", result);
        }

        public void Label_from_property_should_return_the_property_name()
        {
            Model m = new Model() { String = "foo" };
            var pi = m.GetType().GetProperty("String");
            //arrange

            //act
            var result = _conventions.LabelForPropertyConvention(pi);

            //assert
            Assert.AreEqual("String", result);
        }

 public override void Collided(Model with, Displayable.CollisionStatus status)
 {
     if (ProjectHelper.IsDebugNoKill) return;
     if (status != Displayable.CollisionStatus.BOTTOM) return;
     if (with.IsDestroyed) return;
     if (with.GetType() != typeof(Character)) return;
     Character chara = (Character)with;
     if (chara.CharacterPlayerIndex == mPlayerIndex || mPlayerIndex == PlayerIndex.Three)
     {
         with.Destroy();
     }
 }

        public void Example_from_property_should_return_an_empty_string()
        {
            Model m = new Model() { String = "foo" };
            var pi = m.GetType().GetProperty("String");
            //arrange

            //act
            var result = _conventions.ExampleForPropertyConvention(pi);

            //assert
            Assert.AreEqual("", result);
        }