room,id,entity构造这样一个数据结构需要大量运用设计的思想

[ 1896 查看 / 2 回复 ]

返回列表
发新话题 回复该主题
shenyoujia
头像

陈健

  • 管理员
  • 14848
  • 1423
  • 2009-11-07
2010-01-07 17:03 |只看楼主 1#
t T
  1.     class Program
  2.     {
  3.         static void Main(string[] args)
  4.         {
  5.             BizHandler biz = BizHandler.Instance;
  6.             biz.Register("register", "2", new Entity()
  7.             {
  8.                 Ip = "1.2.3.4",
  9.                 port = "80",
  10.                 Type = "register",
  11.                 ServerName = "cj"
  12.             });
  13.             biz.Register("getList", "5", new Entity()
  14.             {
  15.                 Ip = "1.2.3.4",
  16.                 port = "80",
  17.                 Type = "register",
  18.                 ServerName = "cj"
  19.             });

  21.             biz.PrintAllRooms();
  22.         }
  23.     }

  25.     class Entity
  26.     {
  27.         public string Type { get; set; }
  28.         public string Ip { get; set; }
  29.         public string port { get; set; }
  30.         public string ServerName { get; set; }

  32.         public override string ToString()
  33.         {
  34.             return this.Ip + "-" + this.ServerName;
  35.         }
  36.     }

  38.     /// <summary>
  39.     /// 简单工厂类，返回一个Container
  40.     /// </summary>
  41.     class ContainerFactory
  42.     {
  43.         public static Container<string, string, Entity> Instance
  44.         {
  45.             get
  46.             {
  47.                 return container;
  48.             }
  49.         }
  50.         //构造器私有化
  51.         private ContainerFactory() { }

  53.         private static Container<string, string, Entity> container = new Container<string, string, Entity>();
  54.     }

  56.     //自定义一个泛型类，作为 3个元素 存储的容器——相当于三层架构中的数据存储
  57.     //开写这个底层容器之前还没有感觉，现在发现写下来以后，这个容器还是有不少作用的。
  58.     //比较像的是 DataBase中的 分组 功能。如相同的房间room中，有不同的id号的人，拿到他们的Entity。
  59.     //T1对应于String的room，T2多半就是UniqueIdentifier的唯一标识，T3可以是任何object
  60.     class Container<T1, T2, T3>
  61.     {
  62.         private Dictionary<T1, Dictionary<T2, T3>> dictionary = null;
  63.         public Container()
  64.         {
  65.             dictionary = new Dictionary<T1, Dictionary<T2, T3>>();
  66.         }

  68.         //存入相对简单，因为是 黑匣 操作。用户无需关心底层是如何实现存储的。
  69.         /// <summary>
  70.         /// 类似于数据库中的‘增’
  71.         /// </summary>
  72.         /// <param name="t1"></param>
  73.         /// <param name="t2"></param>
  74.         /// <param name="t3"></param>
  75.         public void PutThree(T1 t1, T2 t2, T3 t3)
  76.         {
  77.             Dictionary<T2, T3> subMap = null;
  78.             if (subMap == null)
  79.             {
  80.                 subMap = new Dictionary<T2, T3>();
  81.                 dictionary.Add(t1, subMap);
  82.             }
  83.             subMap.Add(t2, t3);
  84.         }

  86.         //查就要麻烦的多

  88.         /// <summary>
  89.         /// 拿到最大的那个集合中的Key的List
  90.         /// 亦即返回所有的Rooms组成一个集合（看看一共有多少Rooms）
  91.         /// </summary>
  92.         /// <returns></returns>
  93.         public ICollection<T1> GetKeys()
  94.         {
  95.             return dictionary.Keys;

  97.         }

  99.         /// <summary>
  100.         /// 根据指定的T1，获取 子Map（SubMap）
  101.         /// 亦即根据Room，获得其中的 唯一标识+实体 List
  102.         /// </summary>
  103.         /// <param name="t1"></param>
  104.         /// <returns></returns>
  105.         public Dictionary<T2, T3> GetSubMap(T1 t1)
  106.         {
  107.             return dictionary[t1];
  108.         }

  110.         /// <summary>
  111.         /// 得到小集合的键的List
  112.         /// 亦即给定一个 子集合，就得到一个 唯一标识 组成的List
  113.         /// </summary>
  114.         /// <param name="subMap"></param>
  115.         /// <returns></returns>
  116.         public ICollection<T2> GetSubKeys(Dictionary<T2, T3> subMap)
  117.         {
  118.             return subMap.Keys;
  119.         }

  121.         /// <summary>
  122.         /// 根据给定的一个 大集合 的Key，得到小集合的Key组成的集合:重载的方法
  123.         /// 亦即给定 Room ，就可以得到该room中所有的 唯一标识 List
  124.         /// </summary>
  125.         /// <param name="t1"></param>
  126.         /// <returns></returns>
  127.         public ICollection<T2> GetSubKeys(T1 t1)
  128.         {
  129.             return dictionary[t1].Keys;
  130.         }

  132.         /// <summary>
  133.         /// 根据给定的 子集合 和 子集合的键 得到对应的 值
  134.         /// 亦即给定一个 唯一标识+实体 List 和 标识，可以得到对应的实体
  135.         /// </summary>
  136.         /// <param name="subMap"></param>
  137.         /// <param name="t2"></param>
  138.         /// <returns></returns>
  139.         public T3 GetSubValues(Dictionary<T2, T3> subMap, T2 t2)
  140.         {
  141.             return subMap[t2];
  142.         }

  144.         /// <summary>
  145.         /// 给定 大集合的主键和小集合的主键，就能得到对应的值，很像 复合主键：重载的方法
  146.         /// 亦即给定 room 和 id ，就能得到对应的 object
  147.         /// </summary>
  148.         /// <param name="t1"></param>
  149.         /// <param name="t2"></param>
  150.         /// <returns></returns>
  151.         public T3 GetSubValues(T1 t1, T2 t2)
  152.         {
  153.             //var subMap = this.GetSubMap(t1);
  154.             return this.GetSubValues(this.GetSubMap(t1), t2);

  156.         }

  158.    
  159.     }

  161.     //增加一层中间层，将DAL与UI隔离开，也便于测试。且实现单例模式
  162.     class BizHandler
  163.     {
  164.         private static BizHandler _instance = _instance = new BizHandler();

  166.         internal static BizHandler Instance
  167.         {
  168.             get { return BizHandler._instance; }

  170.         }
  171.         private BizHandler()
  172.         {

  174.         }

  176.         //持有一个下层的引用
  177.         Container<string, string, Entity> container = ContainerFactory.Instance;

  179.         /// <summary>
  180.         /// 类似于数据库中的‘增’
  181.         /// </summary>
  182.         /// <param name="t1"></param>
  183.         /// <param name="t2"></param>
  184.         /// <param name="t3"></param>
  185.         public void Register(string room, string id, Entity server)
  186.         {
  187.             container.PutThree(room, id, server);
  188.         }

  190.         public void PrintAllRooms()
  191.         {
  192.             if (container.GetKeys().Count == 0)
  193.             {
  194.                 Console.WriteLine("还没有放入任何元素");
  195.             }
  196.             else
  197.             {
  198.                 foreach (var keys in container.GetKeys())
  199.                 {
  200.                     Console.WriteLine(keys);
  201.                     Console.WriteLine("------房间内的东西-------");

  203.                     foreach (var subkey in container.GetSubKeys(keys))
  204.                     {
  205.                         Console.Write(subkey + ":::::::::::");
  206.                         Console.WriteLine(container.GetSubValues(keys, subkey));
  207.                     }
  208.                     Console.WriteLine();
  209.                     Console.WriteLine();
  210.                 }
  211.             }
  212.         }

  214.      



  218.     }
复制代码
1

评分次数

    本主题由 管理员 张波老师 于 2010-1-7 18:09:41 执行 设置精华/取消 操作
    TOP
    tiansdxx1
    头像

    • 终身学员
    • 914
    • 69
    • 2010-10-10
    2010-12-09 09:54 |只看该用户 2#
    t T

    class Entity 这个类是不是可以用结构呢。

    原来用到的简单工厂 创建类时也是可以把类放到属性里的和放到方法里不一样 当然这里只有一个单独的类。

    private static BizHandler _instance = _instance = new BizHandler();
    这句为什么赋值了两个相同的变量？

    基本都看的董 没有在细看。
    TOP
    返回列表
    上一主题 | 下一主题