/// <summary>
/// 字典类型
/// 序列化原理:
/// 原理是基于 key + T + value 结构
/// key 就是 hashValue （验证过每个字符串不一样的hashcode）
/// T 就是具体的类型 占用一个字节，长度占用三个字节
/// value 就是具体的值
/// </summary>
public class Dictionary
{
#region 核心变量
/// <summary>
/// 字典key
/// </summary>
ArrayList Keys = new ArrayList();
/// <summary>
/// 字典值
/// </summary>
ArrayList Values = new ArrayList();
#endregion
#region 增加设定值
/// <summary>
/// 设置到指定的变量值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SetValue(string key, double value)
{
Add(key, value);
}
/// <summary>
/// 设置到指定的变量值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SetValue(string key, int value)
{
Add(key, value);
}
/// <summary>
/// 设置到指定的变量值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SetValue(string key, string value)
{
Add(key, value);
}
/// <summary>
/// 设置到指定的变量值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SetValue(string key, byte[] value)
{
Add(key, value);
}
/// <summary>
/// 设置到指定的变量值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SetValue(int key, object value)
{
Add(key, value);
}
/// <summary>
/// 添加一个字典
/// </summary>
/// <param name="key"></param>
/// <param name="Value"></param>
public void Add(string key, object Value)
{
var dic = new DicObj() { key = key, Value = Value };
if (!Keys.Contains(key))
{
Keys.Add(key);
Values.Add(dic);
}
else
{
for (int i = 0; i < Keys.Count; i++)
{
if (key.Equals(Keys[i]))
{
Values[i] = dic;
break;
}
}
}
}
/// <summary>
/// 添加一个字典
/// </summary>
/// <param name="key"></param>
/// <param name="Value"></param>
public void Add(int hashkey, object Value)
{
//Log.Print("hashkey:" + hashkey, "Add");
for (int i = 0; i < Keys.Count; i++)
{
var hashCode = HashCodeHelper.GetHashCode((string)Keys[i]); //Keys[i].GetHashCode();
//Log.Print("Keys[i]:" + hashCode, "Add");
if (hashCode == hashkey)
{
//Log.Print("key:" + Keys[i] + " Value:" + Value, "Add");
Values[i] = new DicObj() { key = (string)Keys[i], Value = Value };
break;
}
}
}
/// <summary>
/// 获取全部元素
/// </summary>
/// <returns></returns>
public DicObj[] GetEnumerator()
{
return (DicObj[])Values.ToArray(typeof(DicObj));
}
/// <summary>
/// 根据key获取值
/// </summary>
/// <param name="key"></param>
/// <param name="Value"></param>
/// <returns></returns>
public bool TryGetValue(string key, out DicObj Value)
{
bool IsTrue = false;
Value = new DicObj();
if (Keys.Contains(key))
{
for (int i = 0; i < Keys.Count; i++)
{
if (key == (string)Keys[i])
{
Value = (DicObj)Values[i];
IsTrue = true;
break;
}
}
}
return IsTrue;
}
/// <summary>
/// 根据key获取值
/// </summary>
/// <param name="key"></param>
/// <param name="Value"></param>
/// <returns></returns>
public object GetValue(string key)
{
DicObj v = null;
if (TryGetValue(key, out v))
{
return v.Value;
}
return null;
}
/// <summary>
/// 根据key获取值
/// </summary>
/// <param name="key"></param>
/// <param name="Value"></param>
/// <returns></returns>
public string GetStrValue(string key)
{
string Value = string.Empty;
DicObj v = null;
if (TryGetValue(key, out v))
{
Value = (string)v.Value;
}
return Value;
}
/// <summary>
/// 根据key获取值
/// </summary>
/// <param name="key"></param>
/// <param name="Value"></param>
/// <returns></returns>
public double GetDoubleValue(string key)
{
double Value = 0;
DicObj v = null;
if (TryGetValue(key, out v))
{
try
{
if (v.Value is string)
{
double.TryParse((string)v.Value, out Value);
}
else if (v.Value is int)
{
Value = (double)((int)v.Value);
}
else if (v.Value is double)
{
Value = (double)v.Value;
}
else if (v.Value is byte[])
{
Value = BitConverter.ToDouble((byte[])(v.Value), 0);
}
}
catch (Exception) { Value = 0; }
}
return Value;
}
/// <summary>
/// 根据key获取值
/// </summary>
/// <param name="key"></param>
/// <param name="Value"></param>
/// <returns></returns>
public byte[] GetBytesValue(string key)
{
byte[] Value = null;
DicObj v = null;
if (TryGetValue(key, out v))
{
try
{
if (v.Value is byte[])
{
Value = (byte[])(v.Value);
}
}
catch (Exception) { Value = null; }
}
return Value;
}
/// <summary>
/// 根据key获取值
/// </summary>
/// <param name="key"></param>
/// <param name="Value"></param>
/// <returns></returns>
public int GetIntValue(string key)
{
int Value = 0;
DicObj v = null;
if (TryGetValue(key, out v))
{
try
{
if (v.Value is string)
{
Value = int.Parse((string)v.Value);
}
else if (v.Value is int)
{
Value = (int)v.Value;
}
else if (v.Value is byte[])
{
Value = BitConverter.ToInt32((byte[])(v.Value), 0);
}
}
catch (Exception) { Value = 0; }
}
return Value;
}
#endregion
#region 清空和移除操作
/// <summary>
/// 清空全部
/// </summary>
public void Clear()
{
Keys.Clear();
Values.Clear();
}
/// <summary>
/// 移除某个
/// </summary>
/// <param name="key"></param>
public void Remove(string key)
{
if (Keys.Contains(key))
{
for (int i = 0; i < Keys.Count; i++)
{
if (key.Equals(Keys[i]))
{
Keys.RemoveAt(i);
Values.RemoveAt(i);
break;
}
}
}
}
/// <summary>
/// 数据的总数
/// </summary>
public int Count
{
get
{
return Keys.Count;
}
}
#endregion
#region 打印
/// <summary>
/// 获取字段结果
/// </summary>
/// <param name="name"></param>
/// <param name="Vlaue"></param>
/// <returns></returns>
public string getFild(string name, object Value)
{
return name + ":" + Value.ToString();
}
/// <summary>
/// 内置数据打印
/// </summary>
/// <returns></returns>
public string Print()
{
ArrayList data = new ArrayList();
DicObj[] datalist = GetEnumerator();
foreach (DicObj item in datalist)
{
data.Add(getFild(item.key, item.Value));
}
string[] a = (string[])data.ToArray(typeof(string));
return Join(",", a);
}
/// <summary>
/// 字节拼接
/// </summary>
/// <param name="Str"></param>
/// <param name="splitChar"></param>
/// <param name="Data"></param>
/// <returns></returns>
public byte[] Join(byte[][] Data)
{
byte[] data = null;
if (Data != null && Data.Length > 0)
{
foreach (byte[] item in Data)
{
ByteHelper.GetArray(ref data, item);
//Log.Print(data);
}
}
return data;
}
#endregion
#region 序列化操作
/// <summary>
/// 获取写入的字节
/// </summary>
/// <returns></returns>
public byte[] Dump()
{
byte[] data = null;
DicObj[] datalist = GetEnumerator();
for (int i = 0; i < datalist.Length; i++)
{
TypeList type = TypeList.None;
byte[] bytedata = null;
//Log.Print(datalist[i].key, "key");
if (datalist[i].Value is byte[])
{
type = TypeList.Bytes;
bytedata = (byte[])datalist[i].Value;
}
else if (datalist[i].Value is int)
{
type = TypeList.Int;
bytedata = BitConverter.GetBytes((int)datalist[i].Value);
//Log.Print(bytedata, "int");
//Log.Print(41);
}
else if (datalist[i].Value is double)
{
type = TypeList.Double;
bytedata = BitConverter.GetBytes((double)datalist[i].Value);
//Log.Print(bytedata, "double");
//Log.Print(51);
}
else if (datalist[i].Value is string)
{
type = TypeList.String;
bytedata = BitConverter.GetBytes((string)datalist[i].Value);
}
ByteHelper.GetArray(ref data, BypeProcess(datalist[i].key, type, bytedata));
}
return data;
}
/// <summary>
/// 初始化当前对象
/// </summary>
/// <param name="buffer"></param>
public void Parameter(byte[] buffer)
{
try
{
if (buffer != null && buffer.Length > 0)
{
for (int i = 0; i < buffer.Length; )
{
i = Process(i, buffer);
//Log.Print("i:" + i);
}
}
}
catch (Exception)
{ }
}
/// <summary>
/// 处理转变过来的字节数据
/// </summary>
/// <param name="index"></param>
/// <param name="buffer"></param>
/// <returns></returns>
public int Process(int index, byte[] buffer)
{
int nextIndex = index;
//Log.Print(buffer, "buffer");
var name = new byte[4] { buffer[index + 0], buffer[index + 1], buffer[index + 2], buffer[index + 3] };
int Name = BitConverter.ToInt32(name, 0);
//Log.Print(Name, "hashcode");
//Log.Print(3);
nextIndex += 4;
TypeList t = (TypeList)(buffer[index + 4]);
var length = new byte[4] { buffer[index + 7], buffer[index + 6], buffer[index + 5], 0 };
int Length = BitConverter.ToInt32(length, 0);
nextIndex += 4;
//Log.Print("data length:" + Length);
var data = new byte[Length];
Array.Copy(buffer, nextIndex, data, 0, Length);
//Log.Print(data, "Value");
nextIndex += Length;
object value = 0;
if (data.Length > 0)
{
switch (t)
{
case TypeList.Double: { value = BitConverter.ToDouble(data, 0); } break;
case TypeList.Float: { value = BitConverter.ToSingle(data, 0); } break;
case TypeList.Int: { value = BitConverter.ToInt32(data, 0); } break;
case TypeList.None: { } break;
case TypeList.String: { value = BitConverter.ToString(data, 0); } break;
case TypeList.Bytes: { value = data; } break;
}
}
//Log.Print("TypeList:" + (TypeList)t + " Length;" + Length.ToString() + "Name:" + Name + " value;" + value.ToString(), "Process");
SetValue(Name, value);
return nextIndex;
}
/// <summary>
/// 字符串拼接
/// </summary>
/// <param name="Str"></param>
/// <param name="splitChar"></param>
/// <param name="Data"></param>
/// <returns></returns>
public string Join(string splitChar, string[] Data)
{
string temp = string.Empty;
if (Data != null && Data.Length > 0)
{
for (int i = 0; i < Data.Length; i++)
{
if (i == 0)
{
temp += Data[i];
}
else
{
temp += splitChar + Data[i];
}
}
}
return temp;
}
/// <summary>
/// 处理
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public byte[] BypeProcess(string key, TypeList type, byte[] array)
{
var HashCode = HashCodeHelper.GetHashCode(key);//key.GetHashCode();
var name = BitConverter.GetBytes(HashCode);
var length = BitConverter.GetBytes(array.Length);
var HeadProcess = new byte[4] { (byte)type, length[2], length[1], length[0] };
//Log.Print(i, "name");
//Log.Print(array.Length, "array.Length");
//Log.Print(HeadProcess, "HeadProcess");
ByteHelper.GetArray(ref name, HeadProcess);
return ByteHelper.GetArray(ref name, array);
}
#endregion
}
/// <summary>
/// 字典类型 包含值和value
/// </summary>
public class DicObj
{
/// <summary>
/// key主键
/// </summary>
public string key;
/// <summary>
/// value主键
/// </summary>
public object Value;
}
