c#将自定义字典写入指定路径的文件中；读取文件中的数据返回到自定义字典

[哈利路亚里路亚]

Dictionary<string, FileDic>

把这个字典中的数据写入文件，FileDic是自定义的一个类

[哈利路亚里路亚]

引用 10 楼 OrdinaryCoder 的回复:

 public class SerializeJsonSwitch
    {
        /// <summary>
        /// JSON序列化
        /// </summary>
        public static string JsonSerializer<T>(T t)
        {
            var ser = new DataContractJsonSerializer(typeof(T));
            var ms = new MemoryStream();
            ser.WriteObject(ms, t);
            string jsonString = Encoding.UTF8.GetString(ms.ToArray());
            ms.Close();
            return jsonString;
        }

        /// <summary>
        /// JSON反序列化
        /// </summary>
        public static T JsonDeserialize<T>(string jsonString)
        {
            var ser = new DataContractJsonSerializer(typeof(T));
            var ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
            var obj = (T)ser.ReadObject(ms);
            return obj;
        }
    }

先序列化成json再写入文本文件 需要引用 System.Runtime.Serialization这个程序集

[OrdinaryCoder]

引用 12 楼 哈利路亚里路亚 的回复:

[quote=引用 10 楼 OrdinaryCoder 的回复:]

 public class SerializeJsonSwitch
    {
        /// <summary>
        /// JSON序列化
        /// </summary>
        public static string JsonSerializer<T>(T t)
        {
            var ser = new DataContractJsonSerializer(typeof(T));
            var ms = new MemoryStream();
            ser.WriteObject(ms, t);
            string jsonString = Encoding.UTF8.GetString(ms.ToArray());
            ms.Close();
            return jsonString;
        }

        /// <summary>
        /// JSON反序列化
        /// </summary>
        public static T JsonDeserialize<T>(string jsonString)
        {
            var ser = new DataContractJsonSerializer(typeof(T));
            var ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
            var obj = (T)ser.ReadObject(ms);
            return obj;
        }
    }

先序列化成json再写入文本文件 需要引用 System.Runtime.Serialization这个程序集

[/quote]
SerializeJsonSwitch.JsonDeserialize<此处泛型需要给一个>(XX);

[哈利路亚里路亚]

引用 13 楼 OrdinaryCoder 的回复:

[quote=引用 12 楼 哈利路亚里路亚 的回复:] [quote=引用 10 楼 OrdinaryCoder 的回复:]

 public class SerializeJsonSwitch
    {
        /// <summary>
        /// JSON序列化
        /// </summary>
        public static string JsonSerializer<T>(T t)
        {
            var ser = new DataContractJsonSerializer(typeof(T));
            var ms = new MemoryStream();
            ser.WriteObject(ms, t);
            string jsonString = Encoding.UTF8.GetString(ms.ToArray());
            ms.Close();
            return jsonString;
        }

        /// <summary>
        /// JSON反序列化
        /// </summary>
        public static T JsonDeserialize<T>(string jsonString)
        {
            var ser = new DataContractJsonSerializer(typeof(T));
            var ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
            var obj = (T)ser.ReadObject(ms);
            return obj;
        }
    }

先序列化成json再写入文本文件 需要引用 System.Runtime.Serialization这个程序集

[/quote] SerializeJsonSwitch.JsonDeserialize<此处泛型需要给一个>(XX); [/quote] 已解决但是value我放的是一个自定义的类，这里写不进去

[OrdinaryCoder]

这个我没试过，回去我试一下

[哈利路亚里路亚]

引用 15 楼 OrdinaryCoder 的回复:

这个我没试过，回去我试一下

感谢感谢

[Comic-Con]

没看懂描述的是啥

[OrdinaryCoder]

文件类型随便吗 如果随便的话 参考一下XML序列化 反序列化

[哈利路亚里路亚]

引用 1 楼 Comic-Con 的回复:

没看懂描述的是啥

就是把字典中的数据保存到文件中，也可以把文件中的数据写入到字典中

[哈利路亚里路亚]

引用 2 楼 OrdinaryCoder 的回复:

文件类型随便吗 如果随便的话 参考一下XML序列化 反序列化

就是字典里面嵌套了一个自定义的类

[Comic-Con]

引用 4 楼 哈利路亚里路亚 的回复:

[quote=引用 2 楼 OrdinaryCoder 的回复:] 文件类型随便吗 如果随便的话 参考一下XML序列化 反序列化

就是字典里面嵌套了一个自定义的类[/quote] 实际上你写一个读写文件的帮助类就可以了， 百度一下XmlHelper 然后就是字典的增加项和删除项的操作了。

[OrdinaryCoder]

引用 4 楼 哈利路亚里路亚 的回复:

[quote=引用 2 楼 OrdinaryCoder 的回复:]
文件类型随便吗 如果随便的话 参考一下XML序列化 反序列化

就是字典里面嵌套了一个自定义的类[/quote]
直接序列化反序列化字典

[OrdinaryCoder]

 public class SerializeXmlSwitch
    {

        /// <summary>
        /// XML序列化某一类型到指定的文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="obj"></param>
        /// <param name="type"></param>
        public static void SerializeToXml<T>(string filePath, T obj)
        {
            try
            {
                using (System.IO.StreamWriter writer = new System.IO.StreamWriter(filePath))
                {
                    System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(T));
                    xs.Serialize(writer, obj);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
        /// <summary>
        /// 从某一XML文件反序列化到某一类型
        /// </summary>
        /// <param name="filePath">待反序列化的XML文件名称</param>
        /// <param name="type">反序列化出的</param>
        /// <returns></returns>
        public static T DeserializeFromXml<T>(string filePath)
        {
            try
            {
                if (!System.IO.File.Exists(filePath))
                    throw new ArgumentNullException(filePath + " not Exists");

                using (System.IO.StreamReader reader = new System.IO.StreamReader(filePath))
                {
                    System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(T));
                    T ret = (T)xs.Deserialize(reader);
                    return ret;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                return default(T);
            }
        }

        public static string XmlSerialize<T>(T obj)
        {
            using (StringWriter sw = new StringWriter())
            {
                Type t = obj.GetType();
                XmlSerializer serializer = new XmlSerializer(obj.GetType(),"utf-16");
                serializer.Serialize(sw, obj);
                sw.Close();
                return sw.ToString();
            }
        }
        public static T DESerializer<T>(string strXML) where T : class
        {
            try
            {
                using (StringReader sr = new StringReader(strXML))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(T));
                    return serializer.Deserialize(sr) as T;
                }
            }
            catch (Exception ex)
            {
                return null;
            }
        }


    }

可以序列化反序列化任意类型 集合我试过 字典理论上应该也可以

[兔子家族-二哥]

这是要把一个字典里面的值递归出来 做个树放到 实体里面。

[程序员的键盘]

USING Newtonsoft.Json;

Dictionary<string, FileDic> TEMP=NEW Dictionary<string, FileDic>();

STRING STR=JsonConvert.SerializeObject(TEMP);


Dictionary<string, FileDic> TEMP1=JsonConvert.DeserializeObject<Dictionary<string, FileDic>>(STR);

[NSLKNDF]

直接序列化反序列化字典

[哈利路亚里路亚]

引用 17 楼 程序员的键盘 的回复:

USING Newtonsoft.Json;

Dictionary<string, FileDic> TEMP=NEW Dictionary<string, FileDic>();

STRING STR=JsonConvert.SerializeObject(TEMP);


Dictionary<string, FileDic> TEMP1=JsonConvert.DeserializeObject<Dictionary<string, FileDic>>(STR);

value还是没有数据。

[哈利路亚里路亚]

现在是我先把那个自定义类给序列化了，再序列化字典得到的xml文件是有数据的，但反序列化的时候那个类里面没有数据

[luj_1768]

可能是系统自动提供的服务，把文件的目录和文件名写入资源文件的地址链接项，可能不需要写读取操作代码。

[wilson1966]

受教了,注记一下

[哈利路亚里路亚]

先结贴，功能还在完善，感谢各位的解答