wp8使用Beetle.NetPackage实现基于TCP通讯的订单查询

在新版本的Beetle.NetPackage中提供了对Protobuf和Controller的支持,所以在WP8下使用Beetle.NetPackage进行基于TCP的数据交互则一件非常简单事情.下面通过组件在WP8下简单实现基于TCP通讯的订单在线查询功能.

协议定义

为了简化交互数据的处理在这里使用Protobuf来描述数据交互,通过Protobuf制订一系列的请求和应答对象来代替平常在TCP下繁琐的数据流处理过程.下面通过Protobuf来描述订单查询的通讯协议.

  1 [ProtoContract]

  2     public class GetCustomer

  3     {

  4         [ProtoMember(1)]

  5         public string Name { get; set; }

  6     }

  7 

  8     [ProtoContract]

  9     public class GetCustomerResponse

 10     {

 11 

 12         [ProtoMember(1)]

 13         public IList<Customer> Items

 14         {

 15             get;

 16             set;

 17         }

 18 

 19     }

 20 

 21     [ProtoContract]

 22     public class Customer

 23     {

 24         [ProtoMember(1)]

 25         public string ID

 26         {

 27             get;

 28             set;

 29         }

 30         [ProtoMember(2)]

 31         public string Name

 32         {

 33             get;

 34             set;

 35         }

 36         public override string ToString()

 37         {

 38             return Name;

 39         }

 40     }

 41 

 42     [ProtoContract]

 43     public class GetEmployee

 44     {

 45         [ProtoMember(1)]

 46         public string Name { get; set; }

 47     }

 48 

 49     [ProtoContract]

 50     public class GetEmployeeResponse

 51     {

 52         [ProtoMember(1)]

 53         public IList<Employee> Items

 54         {

 55             get;

 56             set;

 57         }

 58     }

 59 

 60     [ProtoContract]

 61     public class Employee

 62     {

 63 

 64         [ProtoMember(1)]

 65         public string ID

 66         {

 67             get;

 68             set;

 69         }

 70         [ProtoMember(2)]

 71         public string Name

 72         {

 73             get;

 74             set;

 75         }

 76         public override string ToString()

 77         {

 78             return Name;

 79         }

 80         

 81     }

 82 

 83     [ProtoContract]

 84     public class OrderSearch

 85     {

 86         [ProtoMember(1)]

 87         public string Employee { get; set; }

 88         [ProtoMember(2)]

 89         public int PageIndex { get; set; }

 90         [ProtoMember(3)]

 91         public string Customer { get; set; }

 92         [ProtoMember(4)]

 93         public string FromDate { get; set; }

 94         [ProtoMember(5)]

 95         public string ToDate { get; set; }

 96     }

 97 

 98     [ProtoContract]

 99     public class OrderSearchResponse

100     {

101         [ProtoMember(1)]

102         public IList<Order> Items

103         {

104             get;

105             set;

106         }

107         [ProtoMember(2)]

108         public int PageIndex

109         {

110             get;

111             set;

112         }

113         [ProtoMember(3)]

114         public int Pages

115         {

116             get;

117             set;

118         }

119     }

120 

121     [ProtoContract]

122     public class Order

123     {

124         [ProtoMember(1)]

125         public string OrderID { get; set; }

126         [ProtoMember(2)]

127         public string Employee { get; set; }

128         [ProtoMember(3)]

129         public string Customer { get; set; }

130         [ProtoMember(4)]

131         public string OrderDate { get; set; }

132         [ProtoMember(5)]

133         public string RequiredDate { get; set; }

134         [ProtoMember(6)]

135         public string ShippedDate { get; set; }

136         [ProtoMember(7)]

137         public string ShipName { get; set; }

138         [ProtoMember(8)]

139         public string ShipAddress { get; set; }

140         [ProtoMember(9)]

141         public string ShipCity { get; set; }

142         [ProtoMember(10)]

143         public string ShipRegion { get; set; }

144     }

145 

146     [ProtoContract]

147     public class GetOrderDetail

148     {

149         [ProtoMember(1)]

150         public string OrderID { get; set; }

151     }

152 

153     [ProtoContract]

154     public class GetOrderDetailResponse

155     {

156         [ProtoMember(1)]

157         public IList<OrderDetail> Items

158         {

159             get;

160             set;

161         }

162     }

163 

164     [ProtoContract]

165     public class OrderDetail

166     {

167         [ProtoMember(1)]

168         public string OrderID { get; set; }

169         [ProtoMember(2)]

170         public string Product { get; set; }

171         [ProtoMember(3)]

172         public double UnitPrice { get; set; }

173         [ProtoMember(4)]

174         public int Quantity { get; set; }

175         [ProtoMember(5)]

176         public float Discount { get; set; }

177     }

View Code

由于这里使用了protobuf-net,所以通过类和特性来结合,其实规范方便其他平台处理还是建议使用proto文件描述来生成对应的类,这样可以方便生成C++,JAVA等不同平台的交互对象.

定义TCP通讯对象

通过Beetle.NetPackage对protobuf的支持,在WP8下建立相应的TCP通讯是件非常简单的事情.

1 Beetle.NetPackage.ProtoPakcage.Register(typeof(MainPage).Assembly);

2             if (mClient == null)

3             {

4                 mClient = new Beetle.NetPackage.NetClient("192.168.0.104", 9088, new Beetle.NetPackage.ProtoPakcage(), this);

5                 mClient.LittleEndian = false;

6             }

7             mClient.Connect();

在使用protobuf前通过ProtoPakcage.Register把程序集下面对应的protobuf消息注册到组件中,然后创建相应的NetClient就可以进行数据通讯.在这里为了和android交互兼容把client的LittleEndian属性设置成false即在处理数据过程采用高字序作为一些数据类型的处理方式.

消息路由分发

在新版本的Beetle.NetPackage中提供简单的消息路由功能,因此在编写消息接收处理的时候再也不需要通过if来判断不同消息去调用方法.使用消息路由并不需开发人员定义复杂的消息规则,只需要定义相应消息类型的参数即可让组件帮助完成这个事情.

 1 public void OnSearchOrderResponse(Beetle.NetPackage.NetClient client, OrderSearchResponse e)

 2         {

 3             if (e.Items == null)

 4                 lstOrders.ItemsSource = null;

 5             else

 6                 lstOrders.ItemsSource = e.Items.ToList();

 7             mPageIndex = e.PageIndex;

 8             mPages = e.Pages;

 9         }

10 

11         public void OnGetEmployee(Beetle.NetPackage.NetClient client, GetEmployeeResponse e)

12         {

13             mEmployees = e.Items;

14             lstEmployee.ItemsSource = e.Items.ToList();

15         }

16         public void OnGetCustomer(Beetle.NetPackage.NetClient client, GetCustomerResponse e)

17         {

18             mCustomers = e.Items;

19             lstCustomer.ItemsSource = e.Items.ToList();

20 

21         }

22         public void OnGetOrderDetail(Beetle.NetPackage.NetClient client, GetOrderDetailResponse e)

23         {

24             DialogOrderDetail detail = new DialogOrderDetail();

25             CustomMessageBox mOrderDetailDialog = new CustomMessageBox

26             {

27                 Content = detail,

28                 Title = "OrderDetail",

29                 RightButtonContent = "OK"

30             };

31             detail.ListSelector.ItemsSource = e.Items.ToList();

32             mOrderDetailDialog.Show();

33         }

以上是制定不同消息的处理过程,在接收消息的时候触发这些过程只需要简单地调用Controller.Invoke方法即可完成.

1 public void ClientReceive(Beetle.NetPackage.NetClient client, object message)

2         {

3             this.Dispatcher.BeginInvoke(() =>

4             {

5                 Beetle.NetPackage.Controller.Invoke(this, mClient, message);

6             });

7         }

在消息接收方法中调用Controller.Invoke组件会自动匹配相应消息处理的方法并调用,由于是组件自动匹配所以在制定方法的过程也需要遵循一个规则,就是在一个对象中对应消息处理的方法必须是唯一的. 

运行效果

　　

总结

通过Beetle.NetPackage只需要很少量的代码就能完成基于TCP的对象数据交互处理,而开发者是完全不用关心下层的协议处理细节,Beetle.NetPackage不仅仅提供对wp8的支持,还提供对flash和android的支持.

下载sample 

 组件开源官网:https://beetlenp.codeplex.com/