Json转化为.cs类
由于经常需要调用接口，所以每次都需要手动把XML或Json格式的字符串生成一个.cs模型层文件
个人感觉很麻烦，所以就自己写了个XML转换.CS类的方法
可是Json俺就不会了，XMl可以先转换为XmlNode对象 这样就帮我解决了层次的问题，可是Json目前没找到类似的方法所以
目前无法实现


请问大家有什么好方法可以分享下吗，暂时我是Json转换成XML然后再调用自己的XML转换方法

[解决办法]
public class SerializableHelper
{
/// <summary>
/// 序列化成一个字节数组
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
public static byte[] SerializeToBytes<T>(T t)
{
MemoryStream mStream = new MemoryStream();
BinaryFormatter ser = new BinaryFormatter();
ser.Serialize(mStream, t);
return mStream.ToArray();
}

/// <summary>
/// 序列化成一个字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns>序列化代码</returns>
public static string SerializeToXml<T>(T t)
{
try
{
XmlSerializer s = new XmlSerializer(typeof(T));
Stream stream = new MemoryStream();
s.Serialize(stream, t);

stream.Seek(0, SeekOrigin.Begin); //这一点非常重要 否则无法读取
string strSource = "";
using (StreamReader reader = new StreamReader(stream))
{
strSource = reader.ReadToEnd();
}
return strSource;
}
catch { return null; }

}


public static string SerializeToJson<T>(T t)
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(t.GetType());
//DataContractSerializer serializer2 = new DataContractSerializer(typeof(T), typeof(T).Name, string.Empty, null, int.MaxValue, false, true, null, null);

MemoryStream stream = new MemoryStream();
serializer.WriteObject(stream, t);
byte[] dataBytes = new byte[stream.Length];
stream.Position = 0;
stream.Read(dataBytes, 0, (int)stream.Length);
return Encoding.UTF8.GetString(dataBytes);
}



/// <summary>
/// xml 文件反序列化为泛型数组
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path"></param>
/// <returns></returns>
public static T DeSerialize<T>(FileInfo fi)
{
if (fi.Exists == false) return default(T);

XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));

FileStream fs = fi.OpenRead();
T t;
try
{
t = (T)xmlSerializer.Deserialize(fs);
}
finally
{
fs.Close();
}
return t;
}
/// <summary>
/// 字符串反序列化成一个类
/// </summary>
/// <param name="binary"></param>
/// <returns></returns>
public static T DeSerialize<T>(string stringSource)
{
if (string.IsNullOrEmpty(stringSource)) return default(T);

try
{
XmlSerializer x = new XmlSerializer(typeof(T));

Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(stringSource));

stream.Seek(0, SeekOrigin.Begin);
object obj = x.Deserialize(stream);
stream.Close();

return (T)obj;
}
catch
{
return default(T);
}
}
public static T JsonDeSerialize<T>(string jsonString)
{
if (string.IsNullOrEmpty(jsonString)) return default(T);

try
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));

MemoryStream mStream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));

return (T)serializer.ReadObject(mStream);
}
catch
{
return default(T);
}
}
public static Dictionary<TKey, TValue> DeSerialize<TKey, TValue>(FileInfo fi)
{
if (fi.Exists == false) return default(Dictionary<TKey, TValue>);

FileStream fs = fi.OpenRead();
if (fs.Length == 0) return default(Dictionary<TKey, TValue>);

XmlReader reader = XmlReader.Create(fs);
XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
bool wasEmpty = reader.IsEmptyElement;

if (wasEmpty)
return default(Dictionary<TKey, TValue>);

Dictionary<TKey, TValue> dic = new Dictionary<TKey, TValue>();
while (reader.Read())
{
if (reader.NodeType != XmlNodeType.Element) continue;
if (reader.Name == "Root") continue;

reader.ReadStartElement("Row");
reader.ReadStartElement("Key");
TKey key = (TKey)keySerializer.Deserialize(reader);
reader.ReadEndElement();
reader.ReadStartElement("Value");
TValue value = (TValue)valueSerializer.Deserialize(reader);
reader.ReadEndElement();
dic.Add(key, value);
reader.ReadEndElement();
//reader.MoveToContent();

}
fs.Close();
return dic;
}





/// <summary>
/// 序列化泛型数组为xml文件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <param name="FullName"></param>
/// <returns>是否序列化成功</returns>
public static bool Serialize<T>(T t, string FullName)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
TextWriter writer = new StreamWriter(FullName);
try
{
xmlSerializer.Serialize(writer, t);

return true;
}
catch
{
return false;
}
finally
{
writer.Close();
}
}
/// <summary>
/// 序列化 Dictionary
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
/// <param name="dic"></param>
/// <param name="FullName"></param>
/// <returns></returns>
public static bool Serialize<TKey, TValue>(Dictionary<TKey, TValue> dic, string FullName)

{
try
{
System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.Indent = true;
settings.ConformanceLevel = ConformanceLevel.Fragment;

XmlWriter writer = XmlWriter.Create(FullName, settings);


XmlSerializer KeySerializer = new XmlSerializer(typeof(TKey));
XmlSerializer ValueSerializer = new XmlSerializer(typeof(TValue));


writer.WriteStartElement("Root");
foreach (KeyValuePair<TKey, TValue> kv in dic)
{
writer.WriteStartElement("Row");
writer.WriteStartElement("Key");
KeySerializer.Serialize(writer, kv.Key);
writer.WriteEndElement();
writer.WriteStartElement("Value");
ValueSerializer.Serialize(writer, kv.Value);
writer.WriteEndElement();
writer.WriteEndElement();

} writer.WriteEndElement();
writer.Close();

return true;
}
catch
{
try
{
File.Delete(FullName);
}
catch { }
return false;
}
}


}