保存字典<；int，object>；在C#序列化中？

我有一本c语言的词典#

现在，我需要一个通用方法来将字典项序列化和反序列化为字节数组。 像

公共静态void序列化（字典、流）
{
//代码在这里
}

及

公共静态字典反序列化（流）
{
//代码在这里
}

---

有人能帮我吗？？？

除非你想构建自己的完全定制的序列化程序，否则你需要使用内置的

字典和所有引用的类型必须实现内置的序列化结构，该结构要求用正确的属性（即）修饰类，或者，由于对象无法实现它，因此您无法直接序列化它，您需要将其更改为可序列化类型

对于二进制序列化

有关更多信息，请查看

以下是一个可能的解决方案：

public void Serialize(Dictionary<int, UserSessionInfo> dictionary, Stream stream)
{
    BinaryWriter writer = new BinaryWriter(stream);
    writer.Write(dictionary.Count);
    foreach (var obj in dictionary)
    {
        writer.Write(obj.Key);
        writer.Write(obj.Value);
    }
    writer.Flush();
}

public Dictionary<int, UserSessionInfo> Deserialize(Stream stream)
{
    BinaryReader reader = new BinaryReader(stream);
    int count = reader.ReadInt32();
    var dictionary = new Dictionary<int, UserSessionInfo>(count);
    for (int n = 0; n < count; n++)
    {
        var key = reader.ReadInt32();
        var value = reader.ReadString();
        dictionary.Add(key, value);
    }
    return dictionary;                
}

如果要将其序列化为XML

XmlSerializer serializer = new XmlSerializer(
    typeof(Session[]),
    new XmlRootAttribute() { ElementName = "sessions" }
);

现在您可以序列化或反序列化

序列化：

serializer.Serialize(
    stream, 
    dict.Select(kv => new Session(){SessionID = kv.Key, SessionInfo = kv.Info}).ToArray()
);

var deserialized = (
    (Session[])serializer.Deserialize(stream)
).ToDictionary(i => i.id, i => i.info);

反序列化：

serializer.Serialize(
    stream, 
    dict.Select(kv => new Session(){SessionID = kv.Key, SessionInfo = kv.Info}).ToArray()
);

var deserialized = (
    (Session[])serializer.Deserialize(stream)
).ToDictionary(i => i.id, i => i.info);

但是您需要在UserSessionInfo中使用ToString（）方法将其存储在XML中

XML可能如下所示：

<sessions>
    <session id='int_goes_here' value='string_goes_here'/>
</sessions>

---

希望这有帮助。

除非您不想创建文件，否则您可以使用

内存流来实现此目的。但是对于序列化方法，如果不想返回值，则可能应该将
流
参数标记为
[Out]

public static void Serialize(Dictionary<int, object> dictionary, [Out] Stream stream)
{
    stream = new MemoryStream();
    new BinaryFormatter().Serialize(stream, dictionary);
}

public static Dictionary<int, object> Deserialize(Stream stream)
{
    return (Dictionary<int, object>)new BinaryFormatter().Deserialize(stream);
}

试试这个

public static void Serialize<Object>(Object dictionary, Stream stream)
{
    try // try to serialize the collection to a file
    {
        using (stream)
        {
            // create BinaryFormatter
            BinaryFormatter bin = new BinaryFormatter();
            // serialize the collection (EmployeeList1) to file (stream)
            bin.Serialize(stream, dictionary);
        }
    }
    catch (IOException) { ... }
}

public static Object Deserialize<Object>(Stream stream) where Object : new()
{
    Object ret = CreateInstance<Object>();
    try
    {
        using (stream)
        {
            // create BinaryFormatter
            BinaryFormatter bin = new BinaryFormatter();
            // deserialize the collection (Employee) from file (stream)
            ret = (Object)bin.Deserialize(stream);
        }
    }
    catch (IOException) { ... }
    return ret;
}

// function to create instance of T
public static Object CreateInstance<Object>() where Object : new()
{
    return (Object)Activator.CreateInstance(typeof(Object));
}

公共静态void序列化（对象字典、流）
{
尝试//尝试将集合序列化为文件
{
使用（流）
{
//创建二进制格式化程序
BinaryFormatter bin=新的BinaryFormatter（）；
//将集合（EmployeeList1）序列化为文件（流）
序列化（流、字典）；
}
}
捕获（IOException）{…}
}
公共静态对象反序列化（流），其中对象：new（）
{
Object ret=CreateInstance（）；
尝试
{
使用（流）
{
//创建二进制格式化程序
BinaryFormatter bin=新的BinaryFormatter（）；
//从文件（流）反序列化集合（员工）
ret=（对象）bin.反序列化（流）；
}
}
捕获（IOException）{…}
返回ret；
}
//函数创建T的实例
公共静态对象CreateInstance（），其中对象：new（）
{
return（Object）Activator.CreateInstance（typeof（Object））；
}

用法

Serialize(userSessionLookupTable, File.Open("data.bin", FileMode.Create));
Dictionary<int, UserSessionInfo> deserializeObject = Deserialize<Dictionary<int, UserSessionInfo>>(File.Open("data.bin", FileMode.Open));

Serialize（userSessionLookupTable，File.Open（“data.bin”，FileMode.Create））；
Dictionary deserializeObject=反序列化（File.Open（“data.bin”，FileMode.Open））；

我在上面的代码中使用了“Object”来满足您的需求，但就我个人而言，我会使用“T”，它通常表示C#
中的通用对象，回答可能有点晚，但根据我的经验，这里有一个实用且更通用的答案：如果您想要快速简单的东西，或者如果对JSON没有太多需求，请使用简单的JSON序列化数据大小或性能。如果你想要一些高效、快速和跨平台的东西，可以使用谷歌协议缓冲区

JSON
使用以下命令生成代码：

:

另外，一个简短的提示，让您知道可能有一个鲜为人知的功能

基于反射的Protobuf网
下面是一个快速示例（复制自）

[协议]
班主任{
[原成员（1）]
公共int Id{get；set；}
[原成员（2）]
公共字符串名称{get；set；}
}
序列化器。序列化（文件、人员）；
newPerson=序列化程序。反序列化（文件）；

二进制、文本、流，噢，天哪！
抱歉，我有点忽略了关于“二进制”序列化的问题（并且不是一个特定的
BinaryFormatter
问题），因为有很多方法可以使用流来处理流程中进出的数据。C#stream、reader和writer等都有很好的文档记录。
您想如何序列化它？JSON？二元的？XML？二进制。。问题编辑请注意，使用属性通常不被称为实现，并且确实存在一个ISerializable接口（）。您的快速错误，我意识到我需要更正术语，但被您编辑它所锁定。如果您只是要创建一个新的one@MikeT：谢谢，我不确定应该使用
ref
或
Out
中的哪一个。ref表示您传递的是对象引用，而不是其值，这表示对象的更改反映在传递成员中（注意类是引用类型，因此始终是ref），out意味着您将创建一个对象，并从方法返回它，替换调用函数中最初包含在其中的任何值。我不是本地C#开发人员，但我知道
ref
的功能（相当于Visual Basic中的
ByRef
）。不过你写了一个简单明了的解释；）。我有时使用
ref
而不是
Out
来节省内存（不过这只是针对特殊情况）。很抱歉，我想将其序列化为字节数组。。。问题编辑为二进制文件添加了可能的序列化方法
public static void Serialize(Dictionary<int, object> dictionary, [Out] Stream stream)
{
    stream = new MemoryStream();
    new BinaryFormatter().Serialize(stream, dictionary);
}

public static Dictionary<int, object> Deserialize(Stream stream)
{
    return (Dictionary<int, object>)new BinaryFormatter().Deserialize(stream);
}

MemoryStream outputStream;
Serialize(your dictionary here, outputStream);
byte[] bytes = outputStream.ToArray();

public static void Serialize<Object>(Object dictionary, Stream stream)
{
    try // try to serialize the collection to a file
    {
        using (stream)
        {
            // create BinaryFormatter
            BinaryFormatter bin = new BinaryFormatter();
            // serialize the collection (EmployeeList1) to file (stream)
            bin.Serialize(stream, dictionary);
        }
    }
    catch (IOException) { ... }
}

public static Object Deserialize<Object>(Stream stream) where Object : new()
{
    Object ret = CreateInstance<Object>();
    try
    {
        using (stream)
        {
            // create BinaryFormatter
            BinaryFormatter bin = new BinaryFormatter();
            // deserialize the collection (Employee) from file (stream)
            ret = (Object)bin.Deserialize(stream);
        }
    }
    catch (IOException) { ... }
    return ret;
}

// function to create instance of T
public static Object CreateInstance<Object>() where Object : new()
{
    return (Object)Activator.CreateInstance(typeof(Object));
}

Serialize(userSessionLookupTable, File.Open("data.bin", FileMode.Create));
Dictionary<int, UserSessionInfo> deserializeObject = Deserialize<Dictionary<int, UserSessionInfo>>(File.Open("data.bin", FileMode.Open));

string output = JsonConvert.SerializeObject(myObject);
var copyOfMyObject = JsonConvert.DeserializeObject<MyObject>(output);

message Person {
  int32 id = 1;
  string name = 2;
}

protoc --csharp_out=$DST_DIR $SRC_DIR/person.proto

Person john = ...;
john.WriteTo(stream);
var copyOfJohn = Person.Parser.ParseFrom(stream);

[ProtoContract]
class Person {
    [ProtoMember(1)]
    public int Id {get;set;}
    [ProtoMember(2)]
    public string Name {get;set;}
}
Serializer.Serialize(file, person);
newPerson = Serializer.Deserialize<Person>(file);