C# BaseEntity.GetType方法代码示例

        public virtual void CommitLinks(BaseEntity entity)
        {
            if (Settings.IsVerbose)
                Console.WriteLine ("  Committing all links for '"  + entity.GetType().Name + "'.");

            var previousEntity = Reader.Read(entity.GetType(), entity.Id);

            FindAndFixDifferences (previousEntity, entity);
        }

        public virtual void FindAndFixDifferences(BaseEntity previousEntity, BaseEntity updatedEntity)
        {
            if (Settings.IsVerbose)
                Console.WriteLine ("    Finding and fixing all differences between previous and updated '" + updatedEntity.GetType().Name + "' entity.");

            foreach (var property in updatedEntity.GetType().GetProperties()) {
                if (Linker.IsLinkProperty (updatedEntity, property)) {
                    FindAndFixDifferences (previousEntity, updatedEntity, property);
                }
            }
        }

        public void AddReturnLink(BaseEntity entity, PropertyInfo property, BaseEntity targetEntity, string targetEntityPropertyName)
        {
            var targetEntityType = targetEntity.GetType ();

            var targetEntityProperty = targetEntityType.GetProperty (targetEntityPropertyName);

            if (targetEntityProperty == null)
                throw new ArgumentException ("The property '" + targetEntityPropertyName + "' was not found on the '" + targetEntity.GetType ().Name + "' entity.");
            var existingReturnLinksObject = targetEntityProperty.GetValue (targetEntity);

            var newReturnLinksObject = AddEntityToObject (entity, existingReturnLinksObject, targetEntityProperty);

            targetEntityProperty.SetValue (targetEntity, newReturnLinksObject);

            entity.IsPendingLinkCommit = true;
        }

        public virtual bool Equals(BaseEntity obj)
        {
            if (obj == null) return false;
            if (ReferenceEquals(this, obj)) return true;

            if(!IsTransient(this) && !IsTransient(obj) && Equals(this.Id, obj.Id))
            {
                var thisType = this.GetType(); //// Khác ở đây
                var otherType = obj.GetType();
                return thisType.IsAssignableFrom(otherType) || otherType.IsAssignableFrom(thisType);
            }
            return false;
        }

        public virtual void CommitNewReverseLinks(BaseEntity entity, PropertyInfo property, BaseEntity[] newLinkedEntities)
        {
            if (Settings.IsVerbose)
                Console.WriteLine ("    Committing new reverse links for '" + entity.GetType ().Name + "' entity on '" + property.Name + "'.");

            var otherPropertyName = Linker.GetOtherPropertyName (property);

            if (!String.IsNullOrEmpty (otherPropertyName)) {
                foreach (var newLinkedEntity in newLinkedEntities) {
                    if (!Saver.PendingSave.Contains (newLinkedEntity)
                        && !Updater.PendingUpdate.Contains(newLinkedEntity)) {
                        Linker.AddReturnLink (entity, property, newLinkedEntity, otherPropertyName);

                        Updater.DelayUpdate (newLinkedEntity);
                    }
                }
            }
        }

        public void AddLink(BaseEntity entity, string propertyName, BaseEntity linkedEntity)
        {
            var otherPropertyName = "";

            var property = entity.GetType ().GetProperty (propertyName);

            if (PropertyHasLinkAttribute (property, out otherPropertyName)
                || IsLinkProperty(entity, property)) {
                var value = property.GetValue (entity);
                var newValue = AddEntityToObject (linkedEntity, value, property);
                property.SetValue (entity, newValue);

                entity.IsPendingLinkCommit = true;

                if (!String.IsNullOrEmpty(otherPropertyName))
                    AddReturnLink (entity, property, linkedEntity, otherPropertyName);
            } else
                throw new Exception ("Invalid property. It needs to have the type BaseEntity.");
        }

        public object AddEntityToObject(BaseEntity entityToAdd, object linksObject, PropertyInfo property)
        {
            if (IsEntityProperty(property)) {
                return entityToAdd;
            }
            else if (IsEntityArrayProperty(property)) {

                var list = new ArrayList ();

                if (linksObject != null)
                    list.AddRange ((BaseEntity[])linksObject);

                // TODO: Should this check that it's not already in the list? Check via id, not via object comparison
                if (!EntityExists((BaseEntity[])list.ToArray(typeof(BaseEntity)), entityToAdd))
                    list.Add (entityToAdd);

                return list.ToArray (entityToAdd.GetType ());
            } else
                throw new Exception ("Invalid return link object. Must be subclass of BaseEntity or BaseEntity[] array.");
        }

        public void RemoveReturnLink(BaseEntity entity, PropertyInfo property, BaseEntity targetEntity, string targetEntityPropertyName)
        {
            if (entity == null)
                throw new ArgumentNullException ("entity");

            if (property == null)
                throw new ArgumentNullException ("property");

            if (targetEntity == null)
                throw new ArgumentNullException ("targetEntity", "Entity '" + entity.GetType().FullName + "', property '" + property.Name + "'.");

            var targetEntityProperty = targetEntity.GetType ().GetProperty (targetEntityPropertyName);

            if (targetEntityProperty == null)
                throw new Exception ("Property '" + targetEntityPropertyName + "' not found on type '" + targetEntity.GetType().FullName + "'.");
            else {
                var existingReturnLinksObject = targetEntityProperty.GetValue (targetEntity);

                var newReturnLinksObject = RemoveEntityFromObject (entity, existingReturnLinksObject, targetEntityProperty);

                targetEntityProperty.SetValue (targetEntity, newReturnLinksObject);
            }
        }

        public object RemoveEntityFromObject(BaseEntity entityToRemove, object linksObject, PropertyInfo property)
        {
            if (IsEntityProperty(property)) {
                return null;
            }
            else if (IsEntityArrayProperty(property)) {
                var list = new ArrayList ();

                if (linksObject != null)
                    list.AddRange ((BaseEntity[])linksObject);

                for (int i = 0; i < list.Count; i++) {
                    if (((BaseEntity)list [i]).Id == entityToRemove.Id) {
                        list.RemoveAt (i);
                        break;
                    }
                }

                return list.ToArray (entityToRemove.GetType());
            } else
                throw new Exception ("Invalid return link object. Must be subclass of BaseEntity or BaseEntity[] array.");
        }

 public void OnDeployItem(Deployer deployer, BaseEntity baseEntity)
 {
     var player = deployer.ownerPlayer;
     var item = deployer.GetItem();
     var itemDef = item.info;
     var type = baseEntity.GetType();
     if (type != typeof (BaseOven) || !itemDef.displayName.translated.ToLower().Equals("furnace")) return;
     var baseOven = (BaseOven)baseEntity;
     var instanceId = RPGHelper.OvenId(baseOven);
     if (PlayersFurnaces.ContainsKey(instanceId))
     {
         ChatMessage(player, "Contact the developer, tell him wrong Id usage for furnace.");
         return;
     }
     PlayersFurnaces.Add(instanceId, RPGHelper.SteamId(player));
 }

 public MappingNotImplementedException(BaseEntity entity)
     : base (message: "Mapper for provided entity model of type" + entity.GetType() + "not found")
 {
     Entity = entity;
 }

 public UnsavedLinksException(BaseEntity entity)
     : base("Some of the entities linked to '" + entity.GetType().Name + " have not been saved. Use the Data.SaveLinkedEntities(entity) function.")
 {
 }

        public virtual void UpdateLinkedEntities(BaseEntity entity)
        {
            if (Settings.IsVerbose)
                Console.WriteLine ("Updating all entities linked to '"  + entity.GetType().Name + "'.");

            foreach (var property in entity.GetType().GetProperties()) {
                if (Linker.IsLinkProperty (entity, property)) {
                    UpdateLinkedEntities (entity, property);
                }
            }
        }

        public virtual void RemoveLinks(BaseEntity entity)
        {
            if (Settings.IsVerbose)
            {
                Console.WriteLine ("  Removing links between '" + entity.GetType().Name + "' and other entities");
            }

            foreach (var property in entity.GetType().GetProperties()) {
                var otherPropertyName = "";

                // TODO: Clean up if statement
                if ((Linker.PropertyHasLinkAttribute(property, out otherPropertyName)
                    || Linker.IsLinkProperty(entity, property))
                    && !String.IsNullOrEmpty(otherPropertyName))
                {
                    RemoveLinks (entity, property, otherPropertyName);
                }
            }
        }

        public bool EntityExists(BaseEntity[] entities, BaseEntity entityToFind)
        {
            if (entities == null)
                return false;

            if (entityToFind == null)
                throw new ArgumentNullException ("entityToFind");

            return (from entity in entities
                where entity != null
                    && entity.GetType() == entityToFind.GetType()
                    && entity.Id == entityToFind.Id
                select entity).Count() > 0;
        }