重构上线遇问题：如何将BinaryFormatter序列化结果反序列化为其他类型

Alright, let's tackle this problem—you've got old BinaryFormatter-serialized form data in your database, and you need to deserialize it into a new type after a refactor. I've been in this exact spot before, so here are the most practical solutions sorted by how reliable they are:

First, a quick reminder: BinaryFormatter is tightly coupled to the exact type structure (including private fields, namespace, and assembly) it serialized. That means you can't just point it at a new type and expect it to work. Let's break down your options:

方案1：先反序列到原类型，再映射到新类型（最稳妥） #

This is the go-to approach because it minimizes risk. You'll use the original type as a bridge to get the data out, then convert it to your new model.

Step-by-step: #

1. Bring back the original type definition
   If you deleted it, pull it from version control or redefine it exactly as it was when you serialized the data. This includes:

   • All field/property names and types (even private ones)
   • Namespace and assembly name
   • Any inheritance hierarchy the original type had

   BinaryFormatter will fail if even a tiny detail is off, so don't cut corners here.

2. Deserialize to the original type
   Use a modified version of your original serialization code to get the old model back:

   private OldFormModel DeserializeOldModel(byte[] serializedData)
   {
       try
       {
           var formatter = new BinaryFormatter();
           using (var stream = new MemoryStream(serializedData))
           {
               return (OldFormModel)formatter.Deserialize(stream);
           }
       }
       catch (Exception ex)
       {
           _log.LogError(ex, "Failed to deserialize legacy form data");
           throw;
       }
   }
   

3. Map to the new type
   Either manually copy values or use a tool like AutoMapper to convert the old model to your new one:

   // Manual mapping example (simple and transparent)
   var oldModel = DeserializeOldModel(dbStoredBytes);
   var newModel = new NewFormModel
   {
       FormId = oldModel.FormId,
       UserResponse = oldModel.UserInput,
       SubmittedAt = oldModel.SubmissionDate
       // Map all other fields one-to-one
   };
   

方案2：使用自定义SerializationBinder（仅适用于结构一致的情况） #

If your new type has exactly the same fields/structure as the old one—only the name/namespace changed—you can trick BinaryFormatter into mapping the old type to the new one.

Implementation example: #

public class FormModelBinder : SerializationBinder
{
    public override Type BindToType(string assemblyName, string typeName)
    {
        // Replace the old type's full name with the new one
        if (typeName == "YourOldNamespace.OldFormModel")
        {
            return typeof(YourNewNamespace.NewFormModel);
        }
        // Fall back to default for other types
        return Type.GetType($"{typeName}, {assemblyName}");
    }
}

// Usage
private NewFormModel DeserializeToNewType(byte[] data)
{
    try
    {
        var formatter = new BinaryFormatter();
        formatter.Binder = new FormModelBinder();
        using (var stream = new MemoryStream(data))
        {
            return (NewFormModel)formatter.Deserialize(stream);
        }
    }
    catch (Exception ex)
    {
        _log.LogError(ex, "Failed to deserialize to new form model");
        throw;
    }
}

Heads up: This will break immediately if you added/removed fields, changed field types, or modified access modifiers between the old and new types.

方案3：手动解析BinaryFormatter字节流（最后手段） #

If you've completely lost the original type definition, you can try parsing the raw bytes—but this is extremely tedious and error-prone. BinaryFormatter's format includes type metadata, field names, and value data, which you'd have to decode manually with BinaryReader.

I only recommend this if you have no other option. You'll need to:

1. Read the assembly/type metadata from the start of the byte stream
2. Parse each field's name and value based on the metadata
3. Manually construct the new type instance with the parsed values

额外重要提醒 #

• Retire BinaryFormatter long-term: It's officially marked as unsafe by Microsoft (due to deserialization vulnerabilities). Once you've migrated all old data, switch to a secure alternative like System.Text.Json or Protobuf for new serialized data.
• Batch migration: Don't try to convert all database records at once. Either convert them on-the-fly when a user accesses an old form, or run a background job to process records in batches to avoid performance hits.

内容的提问来源于stack exchange，提问作者JakeHova