Is that a good screen class?

[12tails]

yo...
i had worked into this screen class...
maybe it's not the best one, but i wan't to get some opinions about how to do it better...

NOTE: ANY STUPID POST WILL BE REPORTED -.-''

    public class Screen
    {
        uint Uid;
        Character mOwner { get { return Server.Pool[Uid]; } }
        Dictionary<uint, object> List = null;
        public Screen(uint _uid)
        {
            List = new Dictionary<uint, object>();
            Uid = _uid;
        }

        public void Send(byte[] Data, bool m_nTo)
        {
            if (m_nTo) mOwner.Owner.Send(Data);
            object[] Objs = null;
        again:
            try
            {
                Objs = new object[List.Count];
                List.Values.CopyTo(Objs, 0);
            }
            catch { goto again; }

            foreach (object Obj in Objs)
                if (Obj is Character)
                    (Obj as Character).Owner.Send(Data);
        }

        public void Add(uint UID, object Obj)
        {
            if (!List.ContainsKey(UID) && UID != Uid)
            {
                lock (List)
                    List.Add(UID, Obj);

                #region [Client]
                if (Obj is Character)
                {
                    Character Client = (Obj as Character);
                    mOwner.Owner.Send(Client.Spawn);
                }
                #endregion
                #region [Monster]
                if (Obj is Monster)
                {
                    Monster Mob = (Obj as Monster);
                    mOwner.Owner.Send(Packets.ConquerPacket.SpawnMonster(Mob));
                }
                #endregion
                #region [Npc]
                if (Obj is Struct.NPC)
                {
                    Struct.NPC Npc = (Obj as Struct.NPC);
                    mOwner.Owner.Send(Packets.ConquerPacket.SpawnNPC(Npc));
                }
                #endregion
                #region [Terrain]
                if (Obj is Struct.Terrain)
                {
                    Struct.Terrain Terrain = (Obj as Struct.Terrain);
                    mOwner.Owner.Send(Packets.ConquerPacket.TerrainNPC(Terrain));
                }
                #endregion
            }
        }

        public void Remove(uint UID)
        {
            if (Uid != UID && List.ContainsKey(UID)) List.Remove(UID);
            mOwner.Owner.Send(Packets.ConquerPacket.General(UID, 0, 0, 0, 0, 0, Struct.DataType.EntityRemove));
        }

        public object Get(uint UID)
        {
            object Return = null;
            if (List.ContainsKey(UID))
                lock (List)
                    Return = List[UID];

            return Return;
        }

        public bool TryGetValue(uint key, out object value)
        {
            value = null;
            try
            {
                object ob = null;
                if (List.ContainsKey(key))
                {
                    ob = List[key];
                    #region [Client]
                    if (ob is Character)
                    {
                        value = ob as Character;
                        return true;
                    }
                    #endregion
                    #region [Monster]
                    if (ob is Monster)
                    {
                        value = ob as Monster;
                        return true;
                    }
                    #endregion
                    #region [Npc]
                    if (ob is Struct.NPC)
                    {
                        value = ob as Struct.NPC;
                        return true;
                    }
                    #endregion
                    #region [Terrain]
                    if (ob is Struct.Terrain)
                    {
                        value = ob as Struct.Terrain;
                        return true;
                    }
                    #endregion
                }
            }
            catch { return false; }
            return false;
        }

        public void CheckUp()
        {
            object[] Objs = null;
        again:
            try
            {
                Objs = new object[List.Count];
                List.Values.CopyTo(Objs, 0);
            }
            catch { goto again; }

            foreach (object Obj in Objs)
            {
                #region [Client]
                if (Obj is Character)
                {
                    Character Client = (Obj as Character);
                    if (!Calculation.CanSee(Client.X, Client.Y, mOwner.X, mOwner.Y))
                        Remove(Client.UID);
                }
                #endregion
                #region [Monster]
                if (Obj is Monster)
                {
                    Monster Mob = (Obj as Monster);
                    if (!Calculation.CanSee(Mob.X, Mob.Y, mOwner.X, mOwner.Y))
                        Remove(Mob.UID);
                }
                #endregion
                #region [Npc]
                if (Obj is Struct.NPC)
                {
                    Struct.NPC Npc = (Obj as Struct.NPC);
                    if (!Calculation.CanSee(Npc.X, Npc.Y, mOwner.X, mOwner.Y))
                        Remove(Npc.Type);
                }
                #endregion
                #region [Terrain]
                if (Obj is Struct.Terrain)
                {
                    Struct.Terrain Terrain = (Obj as Struct.Terrain);
                    if (!Calculation.CanSee(Terrain.X, Terrain.Y, mOwner.X, mOwner.Y))
                        Remove(Terrain.UID);
                }
                #endregion
            }
        }
    }

thanks in advance.

[nTL3fTy]

C# naming conventions prefix interfaces with an uppercase I, not classes: ,

[12tails]

oh.. yeah that was just a wrong typo haha
changed already :P

[_tao4229_]

Class portrays a poor understanding of OOP.

Not much else to say

[InfamousNoone]

I agree with what tao side. Major things I'd point out:

- mOwner property accesses what seems to be a dictionary each time it's invoked (this is CPU heavy where you could simply retrieve the value once, and store it).
- Instead Dictionary<uint, object> look into interfaces and what they're used for.

[12tails]

okay tkx