public void TestEncodeDictionary1()
{
//Test1
DictNode dict1 = new DictNode();
string source1 = BEncode.StringEncode(dict1);
Assert.AreEqual(source1, "[]");
//Test2
DictNode dict2 = new DictNode();
dict2.Add("age", 25);
dict2.Add("eyes", "blue");
string source2 = BEncode.StringEncode(dict2);
Assert.AreEqual(source2, "[3:agei25e4:eyes4:blue]");
//Test3
DictNode dh31 = new DictNode();
dh31.Add(Encoding.Default.GetBytes("author"), "Alice");
dh31.Add("length", 1048576);
DictNode dict3 = new DictNode();
dict3.Add("spam.mp3", dh31);
string source3 = BEncode.StringEncode(dict3);
Assert.AreEqual(source3, "[8:spam.mp3[6:author5:Alice6:lengthi1048576e]]");
Assert.AreEqual(dict3.ToString(), "[8:spam.mp3[6:author5:Alice6:lengthi1048576e]]");
}
public void TestEncodeDictionary1()
{
//Test1
DictNode dict1 = new DictNode();
string source1 = BEncodingFactory.StringEncode(dict1);
Assert.AreEqual(source1, "de");
//Test2
DictNode dict2 = new DictNode();
dict2.Add("age", 25);
dict2.Add("eyes", "blue");
string source2 = BEncodingFactory.StringEncode(dict2);
Assert.AreEqual(source2, "d3:agei25e4:eyes4:bluee");
//Test3
DictNode dh31 = new DictNode();
dh31.Add("author", "Alice");
dh31.Add("length", 1048576);
DictNode dict3 = new DictNode();
dict3.Add("spam.mp3", dh31);
string source3 = BEncodingFactory.StringEncode(dict3);
Assert.AreEqual(source3, "d8:spam.mp3d6:author5:Alice6:lengthi1048576eee");
Assert.AreEqual(dict3.ToString(), "d8:spam.mp3d6:author5:Alice6:lengthi1048576eee");
}
/// <summary>
/// 处理Scalar函数
/// </summary>
/// <param name="cmd">数据库命令</param>
public DictNode HandleScalar(DbCommand cmd)
{
object obj;
using (DbConnection conn = new SqlConnection(connectionString))
{
conn.Open();
cmd.Connection = conn;
obj = cmd.ExecuteScalar();
}
DictNode result = new DictNode();
result.Add("code", 3);
BEncodedNode itemNode = CreateItemNode(obj);
result.Add("item", itemNode);
ListNode parmlistNode = CreateParmListNode(cmd);
if (parmlistNode.Count != 0)
{
result.Add("parmlist", parmlistNode);
}
return(result);
}
private ListNode CreateParmListNode(DbCommand cmd)
{
ListNode result = new ListNode();
foreach (DbParameter para in cmd.Parameters)
{
switch (para.Direction)
{
case ParameterDirection.InputOutput:
case ParameterDirection.Output:
case ParameterDirection.ReturnValue:
DictNode parmNode = new DictNode();
parmNode.Add("name", para.ParameterName);
parmNode.Add("type", para.Value.GetType().ToString());
if (para.Value == DBNull.Value)
{
parmNode.Add("value", BytesNode.NullBytesNode);
}
else if (para.DbType == DbType.Binary)
{
parmNode.Add("value", (byte[])para.Value);
}
else
{
parmNode.Add("value", para.Value.ToString());
}
result.Add(parmNode);
break;
}
}
cmd.Parameters.Clear();
cmd.Dispose();
return(result);
}
/// <summary>
/// 创建异常数据
/// </summary>
/// <param name="e">异常数据</param>
/// <returns>返回异常数据节点</returns>
static DictNode CreateExceptionNode(Exception e)
{
DictNode result = new DictNode();
result.Add("code", 4);
result.Add("message", string.Format("{0}: {1}", e.GetType(), e.Message));
return(result);
}
/// <summary>
/// 新建握手数据包
/// </summary>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <returns>返回握手数据包</returns>
public static byte[] BuildHandshake(byte[] key, byte[] iv)
{
DictNode node = new DictNode();
node.Add("key", key);
node.Add("iv", iv);
return(BEncode.ByteArrayEncode(node));
}
/// <summary>
/// 建立失败打开数据包
/// </summary>
/// <param name="message">失败消息</param>
/// <returns>返回数据包</returns>
private byte[] BuildFailOpenPacket(string message)
{
DictNode result = new DictNode();
result.Add("code", 6);
result.Add("message", message);
return(BEncode.ByteArrayEncode(result));
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="iv"></param>
/// <returns></returns>
private byte[] BuildAckMessage(byte[] key, byte[] iv)
{
DictNode node = new DictNode();
node.Add("key", key);
node.Add("iv", iv);
return(BEncode.ByteArrayEncode(node));
}
/// <summary>
/// 建立连接包
/// </summary>
/// <returns></returns>
private byte[] BuildHandshakeMessage()
{
DictNode node = new DictNode();
node.Add("port", clientPort);
node.Add("key", key);
node.Add("iv", iv);
return(BEncode.ByteArrayEncode(node));
}
/// <summary>
/// 建立成功打开数据包
/// </summary>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <returns>返回数据包</returns>
private byte[] BuildSuccessOpenPacket(byte[] key, byte[] iv)
{
DictNode result = new DictNode();
result.Add("code", 1);
result.Add("key", key);
result.Add("iv", iv);
return(BEncode.ByteArrayEncode(result));
}
/// <summary>
/// 建立打开DB Proxy Server包
/// </summary>
/// <returns>返回数据包</returns>
private byte[] BuildOpenPacket()
{
DictNode rootNode = new DictNode();
rootNode.Add("action", 1);
rootNode.Add("deviceid", deviceId);
rootNode.Add("priority", priority);
return(BEncode.ByteArrayEncode(rootNode));
}
/// <summary>
/// 记录数据包
/// </summary>
/// <param name="buffer">待记录的数据包</param>
/// <param name="endPoint">IP端点</param>
public override void Write(byte[] buffer, IPEndPoint endPoint)
{
DictNode node = new DictNode();
node.Add("buffer", buffer);
node.Add("endpoint", endPoint.ToString());
byte[] sndMsg = BEncode.ByteArrayEncode(node);
handler.SendNormalPacket(sndMsg);
}
/// <summary>
/// 创建类型节点
/// </summary>
/// <param name="rdr">数据库读取器</param>
/// <returns>返回类型节点</returns>
private ListNode CreateTypeListNode(IDataRecord rdr)
{
ListNode result = new ListNode();
for (int i = 0; i < rdr.FieldCount; i++)
{
DictNode columnNode = new DictNode();
columnNode.Add("name", rdr.GetName(i));
columnNode.Add("type", rdr.GetDataTypeName(i));
result.Add(columnNode);
}
return(result);
}
/// <summary>
/// 创建Scalar返回值节点
/// </summary>
/// <param name="obj">Scalar返回值</param>
/// <returns>返回Scalar返回值节点</returns>
private BEncodedNode CreateItemNode(object obj)
{
string typeName = obj != null?obj.GetType().ToString() : typeof(object).ToString();
BytesNode valueNode = obj != null
? typeName != "System.Byte[]" ? new BytesNode(obj.ToString()) : (byte[])obj
: BytesNode.NullBytesNode;
DictNode result = new DictNode();
result.Add("type", typeName);
result.Add("value", valueNode);
return(result);
}
private byte[] BuildMessage(DictNode contentNode)
{
switch (commandType)
{
case CommandType.Text:
contentNode.Add("type", TextNum);
return(BuildTextMessage(contentNode));
case CommandType.StoredProcedure:
contentNode.Add("type", ProcNum);
return(BuildProcMessage(contentNode));
}
throw new DbProxyException("建立传输数据出错!");
}
/// <summary>
/// 处理Reader函数
/// </summary>
/// <param name="cmd">数据库命令</param>
public DictNode HandleReader(DbCommand cmd)
{
DictNode result = new DictNode();
using (DbConnection conn = new SqlConnection(connectionString))
{
conn.Open();
cmd.Connection = conn;
using (DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
ListNode typeListNode = CreateTypeListNode(rdr);
result.Add("typelist", typeListNode);
ListNode itemsNode = new ListNode();
while (rdr.Read())
{
ListNode itemNode = new ListNode();
for (int i = 0; i < rdr.FieldCount; i++)
{
if (rdr.IsDBNull(i))
{
itemNode.Add(BytesNode.NullBytesNode);
}
else
{
if (IsBinaryType(rdr.GetDataTypeName(i)))
{
itemNode.Add((byte[])rdr.GetValue(i));
}
else
{
itemNode.Add(rdr.GetValue(i).ToString());
}
}
}
itemsNode.Add(itemNode);
}
result.Add("items", itemsNode);
}
}
result.Add("code", 2);
ListNode parmlistNode = CreateParmListNode(cmd);
if (parmlistNode.Count != 0)
{
result.Add("parmlist", parmlistNode);
}
return(result);
}
/// <summary>
/// 生成存储过程发送的字节流
/// </summary>
/// <returns>返回发送的字节流</returns>
private byte[] BuildProcMessage(DictNode contentNode)
{
contentNode.Add("text", commandText);
//建立参数列表
if (parameters.Count != 0)
{
ListNode parmsNode = new ListNode();
foreach (DbProxyParameter para in parameters)
{
DictNode parmNode = new DictNode();
parmNode.Add("name", para.ParameterName);
parmNode.Add("type", (int)para.DbType);
switch (para.Direction)
{
case ParameterDirection.Input:
parmNode.Add("value", NodeEncoder.GetValueNode(para));
break;
case ParameterDirection.Output:
parmNode.Add("direction", OutputNum);
break;
case ParameterDirection.InputOutput:
parmNode.Add("direction", InputOutputNum);
parmNode.Add("value", NodeEncoder.GetValueNode(para));
break;
case ParameterDirection.ReturnValue:
parmNode.Add("direction", ReturnValueNum);
break;
}
if (para.Size != 0)
{
parmNode.Add("size", para.Size);
}
parmsNode.Add(parmNode);
}
contentNode.Add("parms", parmsNode);
}
return(BEncode.ByteArrayEncode(contentNode));
}
/// <summary>
/// 创建关闭回应包
/// </summary>
/// <returns></returns>
static DictNode CreateCloseNode()
{
DictNode result = new DictNode();
result.Add("code", 1);
return(result);
}
public override object ExecuteScalar()
{
DictNode contentNode = new DictNode();
contentNode.Add("action", 5);
byte[] sendMsg = BuildMessage(contentNode);
connection.SendPacket(sendMsg);
byte[] rcvMsg = connection.ReceivePacket();
return(DecodeScalar(rcvMsg));
}
public override int ExecuteNonQuery()
{
DictNode contentNode = new DictNode();
contentNode.Add("action", 3);
byte[] sendMsg = BuildMessage(contentNode);
connection.SendPacket(sendMsg);
byte[] rcvMsg = connection.ReceivePacket();
return(DecodeNonQuery(rcvMsg));
}
public new DbProxyDataReader ExecuteReader()
{
DbProxyDataReader result = new DbProxyDataReader(this);
DictNode contentNode = new DictNode();
contentNode.Add("action", 4);
byte[] sendMsg = BuildMessage(contentNode);
connection.SendPacket(sendMsg);
byte[] rcvMsg = connection.ReceivePacket();
DecodeReader(rcvMsg, result.SchemaTable);
return(result);
}
/// <summary>
/// 处理NonQuery函数
/// </summary>
/// <param name="cmd">数据库命令</param>
public DictNode HandleNonQuery(DbCommand cmd)
{
int lineNum;
using (DbConnection conn = new SqlConnection(connectionString))
{
conn.Open();
cmd.Connection = conn;
lineNum = cmd.ExecuteNonQuery();
}
DictNode result = new DictNode();
result.Add("code", 1);
result.Add("linenum", lineNum);
ListNode parmlistNode = CreateParmListNode(cmd);
if (parmlistNode.Count != 0)
{
result.Add("parmlist", parmlistNode);
}
return(result);
}
/// <summary>
/// 生成SQL文本发送的字节流
/// </summary>
/// <returns>返回发送的字节流</returns>
private byte[] BuildTextMessage(DictNode contentNode)
{
contentNode.Add("text", commandText);
return(BEncode.ByteArrayEncode(contentNode));
}