MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Visual Basic序列化与反序列化策略

2022-01-294.0k 阅读

Visual Basic中的序列化基础概念

在Visual Basic编程环境中，序列化是将对象的状态转换为字节流的过程，这样该字节流可以被存储到文件、数据库，或者通过网络进行传输。反序列化则是相反的过程，它将字节流重新转换回对象的原始状态。这一机制在很多场景下都至关重要，比如保存应用程序的设置以便下次启动时恢复，或者在分布式系统中进行对象的传递。

为什么需要序列化与反序列化

  1. 数据持久化：应用程序常常需要保存对象的当前状态，以便在后续运行中恢复。例如，一个绘图程序可能需要保存用户绘制的图形对象及其属性。通过序列化，可以将这些复杂的图形对象转换为字节流并保存到文件中。当程序下次启动时，通过反序列化从文件中读取字节流并重建图形对象，从而恢复用户之前的工作。
  2. 远程通信：在分布式系统中，不同的计算机之间需要交换对象。由于网络传输只能处理字节流，对象必须先进行序列化才能在网络上传输。接收方则通过反序列化将接收到的字节流还原为对象，实现跨机器的对象交互。

序列化的类型

  1. 二进制序列化：二进制序列化将对象转换为紧凑的二进制格式。这种格式对于存储和网络传输效率很高，因为它占用的空间较小，并且在反序列化时速度较快。然而，二进制格式通常是特定于应用程序的，不同版本的应用程序可能对二进制格式有不同的解读，这可能导致兼容性问题。
  2. XML序列化：XML序列化将对象转换为XML格式。XML具有良好的可读性和跨平台性，适合在不同系统之间进行数据交换。但XML格式相对比较冗长，占用的存储空间较大，在序列化和反序列化时的性能也不如二进制序列化。
  3. JSON序列化：JSON（JavaScript Object Notation）序列化将对象转换为JSON格式。JSON是一种轻量级的数据交换格式，具有良好的可读性和可编写性，同时也易于解析。它在Web应用程序中广泛用于前后端的数据交互，并且在不同编程语言之间具有较好的兼容性。

Visual Basic中的二进制序列化

使用BinaryFormatter进行二进制序列化

在Visual Basic中，可以使用System.Runtime.Serialization.Formatters.Binary.BinaryFormatter类来进行二进制序列化和反序列化。

首先，确保你的项目引用了System.Runtime.Serialization.Formatters命名空间。

以下是一个简单的示例，展示如何对一个自定义对象进行二进制序列化和反序列化：

Imports System.IO
Imports System.Runtime.Serialization.Formatters.Binary

<Serializable()>
Public Class Person
    Public Name As String
    Public Age As Integer
End Class

Module Module1
    Sub Main()
        '创建一个Person对象
        Dim person As New Person()
        person.Name = "Alice"
        person.Age = 30

        '序列化对象到文件
        Using stream As New FileStream("person.bin", FileMode.Create)
            Dim formatter As New BinaryFormatter()
            formatter.Serialize(stream, person)
        End Using

        '从文件反序列化对象
        Using stream As New FileStream("person.bin", FileMode.Open)
            Dim formatter As New BinaryFormatter()
            Dim deserializedPerson As Person = CType(formatter.Deserialize(stream), Person)
            Console.WriteLine($"Name: {deserializedPerson.Name}, Age: {deserializedPerson.Age}")
        End Using
    End Sub
End Module

在上述代码中：

  1. 定义了一个Person类，并使用Serializable特性标记它。这个特性告诉序列化机制该类的对象可以被序列化。
  2. 在Main方法中，创建了一个Person对象，并设置其属性。
  3. 使用FileStream和BinaryFormatter将Person对象序列化到名为person.bin的文件中。
  4. 接着，通过FileStream和BinaryFormatter从文件中反序列化出Person对象，并输出其属性。

二进制序列化的注意事项

  1. 版本兼容性：由于二进制格式特定于应用程序，当应用程序的版本发生变化时，可能会导致反序列化失败。例如，如果在新版本中修改了Person类的结构（如添加或删除字段），旧版本序列化的文件可能无法在新版本中正确反序列化。为了应对这种情况，可以使用OptionalField特性来标记那些在新版本中添加的可选字段，这样在反序列化旧版本数据时不会出错。
  2. 安全性：二进制序列化可能会带来安全风险，因为恶意用户可能会构造恶意的二进制数据，导致反序列化过程中执行恶意代码。为了降低这种风险，应该只反序列化来自可信来源的数据，并且在反序列化时进行必要的验证。

Visual Basic中的XML序列化

使用XmlSerializer进行XML序列化

Visual Basic提供了System.Xml.Serialization.XmlSerializer类来进行XML序列化和反序列化。

以下是将之前的Person类进行XML序列化和反序列化的示例：

Imports System.IO
Imports System.Xml.Serialization

Public Class Person
    <XmlElement("FullName")>
    Public Name As String
    <XmlElement("AgeValue")>
    Public Age As Integer
End Class

Module Module1
    Sub Main()
        '创建一个Person对象
        Dim person As New Person()
        person.Name = "Bob"
        person.Age = 25

        '序列化对象到文件
        Using writer As New StreamWriter("person.xml")
            Dim serializer As New XmlSerializer(GetType(Person))
            serializer.Serialize(writer, person)
        End Using

        '从文件反序列化对象
        Using reader As New StreamReader("person.xml")
            Dim serializer As New XmlSerializer(GetType(Person))
            Dim deserializedPerson As Person = CType(serializer.Deserialize(reader), Person)
            Console.WriteLine($"Name: {deserializedPerson.Name}, Age: {deserializedPerson.Age}")
        End Using
    End Sub
End Module

在上述代码中：

  1. Person类不再需要Serializable特性，但使用了XmlElement特性来指定XML元素的名称。
  2. 使用StreamWriter和XmlSerializer将Person对象序列化为XML格式并保存到person.xml文件中。
  3. 通过StreamReader和XmlSerializer从文件中反序列化出Person对象。

XML序列化的特性

  1. 自定义XML结构：通过使用XmlElement、XmlAttribute等特性，可以精确控制对象在XML中的表示形式。例如，可以将对象的属性表示为XML元素的属性，或者改变元素的名称。
  2. 跨平台兼容性：XML是一种广泛支持的格式，不同的编程语言和平台都可以轻松解析和生成XML。这使得XML序列化非常适合在不同系统之间进行数据交换。
  3. 可读性：XML格式具有良好的可读性，便于人工查看和编辑。这在调试和配置文件等场景下非常有用。

Visual Basic中的JSON序列化

使用Newtonsoft.Json进行JSON序列化

虽然Visual Basic没有内置的JSON序列化类，但可以使用流行的第三方库Newtonsoft.Json（也称为Json.NET）来进行JSON序列化和反序列化。

首先，通过NuGet包管理器安装Newtonsoft.Json。

以下是示例代码：

Imports System.IO
Imports Newtonsoft.Json

Public Class Person
    Public Property Name As String
    Public Property Age As Integer
End Class

Module Module1
    Sub Main()
        '创建一个Person对象
        Dim person As New Person()
        person.Name = "Charlie"
        person.Age = 40

        '序列化对象到文件
        Dim json = JsonConvert.SerializeObject(person)
        File.WriteAllText("person.json", json)

        '从文件反序列化对象
        Dim jsonText = File.ReadAllText("person.json")
        Dim deserializedPerson As Person = JsonConvert.DeserializeObject(Of Person)(jsonText)
        Console.WriteLine($"Name: {deserializedPerson.Name}, Age: {deserializedPerson.Age}")
    End Sub
End Module

在上述代码中：

  1. 定义了Person类，并使用属性（Property）而不是字段。
  2. 使用JsonConvert.SerializeObject方法将Person对象序列化为JSON字符串，并保存到person.json文件中。
  3. 通过File.ReadAllText读取文件内容，然后使用JsonConvert.DeserializeObject方法将JSON字符串反序列化为Person对象。

JSON序列化的优势

  1. 轻量级：JSON格式相对XML更加轻量级，占用的存储空间和网络带宽较小，适合在移动应用和Web应用中进行数据传输。
  2. JavaScript兼容性：由于JSON与JavaScript紧密相关，在Web开发中，JSON序列化的数据可以直接在JavaScript中使用，无需复杂的转换。
  3. 灵活的序列化选项：Newtonsoft.Json提供了丰富的特性和选项，可以对序列化和反序列化过程进行精细控制，如忽略某些属性、自定义日期格式等。

高级序列化场景与技巧

处理复杂对象图

在实际应用中，对象可能包含复杂的引用关系，形成对象图。例如，一个Department类可能包含多个Employee对象，而每个Employee对象又可能引用其他对象。

Imports System.IO
Imports System.Runtime.Serialization.Formatters.Binary

<Serializable()>
Public Class Employee
    Public Name As String
    Public Age As Integer
    Public Manager As Employee
End Class

<Serializable()>
Public Class Department
    Public Name As String
    Public Employees As List(Of Employee)
End Class

Module Module1
    Sub Main()
        '创建员工和部门对象
        Dim manager As New Employee()
        manager.Name = "Manager"
        manager.Age = 45

        Dim employee1 As New Employee()
        employee1.Name = "Employee1"
        employee1.Age = 30
        employee1.Manager = manager

        Dim employee2 As New Employee()
        employee2.Name = "Employee2"
        employee2.Age = 35
        employee2.Manager = manager

        Dim department As New Department()
        department.Name = "Engineering"
        department.Employees = New List(Of Employee)() From {employee1, employee2}

        '序列化部门对象
        Using stream As New FileStream("department.bin", FileMode.Create)
            Dim formatter As New BinaryFormatter()
            formatter.Serialize(stream, department)
        End Using

        '反序列化部门对象
        Using stream As New FileStream("department.bin", FileMode.Open)
            Dim formatter As New BinaryFormatter()
            Dim deserializedDepartment As Department = CType(formatter.Deserialize(stream), Department)
            For Each emp In deserializedDepartment.Employees
                Console.WriteLine($"Employee: {emp.Name}, Age: {emp.Age}, Manager: {If(emp.Manager IsNot Nothing, emp.Manager.Name, "None")}")
            Next
        End Using
    End Sub
End Module

在上述代码中，展示了如何序列化和反序列化包含复杂对象引用的对象图。二进制序列化器会自动处理对象之间的引用关系，确保在反序列化时能够正确重建对象图。

自定义序列化与反序列化

有时候，默认的序列化和反序列化行为不能满足需求，需要进行自定义。例如，对象可能包含一些敏感信息，不希望被序列化，或者需要对某些字段进行特殊的编码。

  1. 使用ISerializable接口进行自定义二进制序列化：
Imports System.IO
Imports System.Runtime.Serialization

<Serializable()>
Public Class SecretData
    Implements ISerializable

    Private _sensitiveInfo As String
    Public PublicInfo As String

    Public Sub New()
        PublicInfo = "Public Information"
        _sensitiveInfo = "Secret Information"
    End Sub

    Protected Sub New(info As SerializationInfo, context As StreamingContext)
        PublicInfo = info.GetString("PublicInfo")
    End Sub

    Public Sub GetObjectData(info As SerializationInfo, context As StreamingContext) Implements ISerializable.GetObjectData
        info.AddValue("PublicInfo", PublicInfo)
    End Sub
End Class

Module Module1
    Sub Main()
        Dim data As New SecretData()

        '序列化对象
        Using stream As New MemoryStream()
            Dim formatter As New BinaryFormatter()
            formatter.Serialize(stream, data)
            stream.Position = 0

            '反序列化对象
            Dim deserializedData As SecretData = CType(formatter.Deserialize(stream), SecretData)
            Console.WriteLine(deserializedData.PublicInfo)
        End Using
    End Sub
End Module

在上述代码中，SecretData类实现了ISerializable接口。通过重写GetObjectData方法，可以控制哪些数据被序列化。在反序列化的构造函数中，可以从SerializationInfo中恢复数据。

  1. 自定义XML序列化：
Imports System.IO
Imports System.Xml.Serialization

Public Class CustomData
    Private _privateField As String
    <XmlElement("PublicField")>
    Public PublicField As String

    <XmlIgnore>
    Public Property PrivateField As String
        Get
            Return _privateField
        End Get
        Set(value As String)
            _privateField = value
        End Set
    End Property

    Public Sub New()
        PublicField = "Public Value"
        _privateField = "Private Value"
    End Sub
End Class

Module Module1
    Sub Main()
        Dim data As New CustomData()

        '序列化对象
        Using writer As New StreamWriter("customdata.xml")
            Dim serializer As New XmlSerializer(GetType(CustomData))
            serializer.Serialize(writer, data)
        End Using

        '反序列化对象
        Using reader As New StreamReader("customdata.xml")
            Dim serializer As New XmlSerializer(GetType(CustomData))
            Dim deserializedData As CustomData = CType(serializer.Deserialize(reader), CustomData)
            Console.WriteLine(deserializedData.PublicField)
        End Using
    End Sub
End Module

在这个XML序列化的示例中，使用XmlIgnore特性来阻止PrivateField被序列化。同时，可以通过自定义XmlElement特性来控制公共字段在XML中的表示。

序列化与安全性

  1. 防止反序列化攻击：如前所述，反序列化不可信的数据可能导致安全漏洞。为了防止反序列化攻击，可以采取以下措施：
    • 只反序列化来自可信来源的数据。例如，在网络应用中，确保数据来自经过身份验证和授权的客户端。
    • 对反序列化的数据进行严格的验证。可以在反序列化后，对对象的属性进行检查，确保其值在合理范围内。
    • 使用安全的序列化格式和库。一些序列化库可能已经采取了措施来防止常见的反序列化攻击。例如，Newtonsoft.Json在较新版本中增加了对反序列化攻击的防护。
  2. 加密序列化数据：对于敏感数据，在序列化后进行加密是一种有效的保护方式。可以使用.NET提供的加密算法，如AES（高级加密标准），对序列化后的字节流或字符串进行加密。在反序列化之前，先对数据进行解密。
Imports System.IO
Imports System.Security.Cryptography
Imports System.Runtime.Serialization.Formatters.Binary

<Serializable()>
Public Class SensitiveData
    Public SecretMessage As String
End Class

Module Module1
    Sub Main()
        Dim data As New SensitiveData()
        data.SecretMessage = "This is a secret message"

        '序列化对象
        Using stream As New MemoryStream()
            Dim formatter As New BinaryFormatter()
            formatter.Serialize(stream, data)
            stream.Position = 0

            '加密序列化数据
            Dim encryptedData = EncryptData(stream.ToArray())

            '解密并反序列化数据
            Dim decryptedData = DecryptData(encryptedData)
            Using decryptStream As New MemoryStream(decryptedData)
                Dim formatter As New BinaryFormatter()
                Dim deserializedData As SensitiveData = CType(formatter.Deserialize(decryptStream), SensitiveData)
                Console.WriteLine(deserializedData.SecretMessage)
            End Using
        End Using
    End Sub

    Private Function EncryptData(data As Byte()) As Byte()
        Using aesAlg = Aes.Create()
            aesAlg.Key = New Byte() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
            aesAlg.IV = New Byte() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}

            Dim encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV)
            Using msEncrypt = New MemoryStream()
                Using csEncrypt = New CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)
                    csEncrypt.Write(data, 0, data.Length)
                    csEncrypt.FlushFinalBlock()
                End Using
                Return msEncrypt.ToArray()
            End Using
        End Using
    End Function

    Private Function DecryptData(cipherText As Byte()) As Byte()
        Using aesAlg = Aes.Create()
            aesAlg.Key = New Byte() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}
            aesAlg.IV = New Byte() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}

            Dim decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV)
            Using msDecrypt = New MemoryStream(cipherText)
                Using csDecrypt = New CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)
                    Dim decryptBytes = New Byte(cipherText.Length - 1) {}
                    csDecrypt.Read(decryptBytes, 0, decryptBytes.Length)
                    Return decryptBytes
                End Using
            End Using
        End Using
    End Function
End Module

在上述代码中，使用AES加密算法对序列化后的SensitiveData对象进行加密，然后在反序列化之前进行解密，确保敏感数据的安全性。

性能优化与最佳实践

序列化性能比较

不同的序列化方式在性能上有显著差异。一般来说，二进制序列化在速度和空间占用上表现最佳，适合对性能要求较高且数据不需要在不同系统间广泛共享的场景。XML序列化虽然可读性好且跨平台性强，但性能相对较差，适合对可读性和兼容性要求高而对性能要求不是特别苛刻的场景。JSON序列化则介于两者之间，在Web应用中由于其轻量级和与JavaScript的兼容性而广泛使用。

为了比较不同序列化方式的性能，可以编写性能测试代码：

Imports System
Imports System.IO
Imports System.Runtime.Serialization.Formatters.Binary
Imports System.Xml.Serialization
Imports Newtonsoft.Json

<Serializable()>
Public Class PerformanceTestData
    Public Property Value1 As String
    Public Property Value2 As Integer
    Public Property Value3 As Double
    Public Property Value4 As Date
End Class

Module Module1
    Sub Main()
        Dim data As New PerformanceTestData()
        data.Value1 = "Test String"
        data.Value2 = 12345
        data.Value3 = 3.14159
        data.Value4 = DateTime.Now

        Dim iterations = 10000

        '二进制序列化性能测试
        Dim binarySerializeTime As Double = 0
        Dim binaryDeserializeTime As Double = 0
        For i = 1 To iterations
            Dim sw As New Stopwatch()
            sw.Start()
            Using stream As New MemoryStream()
                Dim formatter As New BinaryFormatter()
                formatter.Serialize(stream, data)
            End Using
            sw.Stop()
            binarySerializeTime += sw.Elapsed.TotalMilliseconds

            sw.Restart()
            Using stream As New MemoryStream()
                Dim formatter As New BinaryFormatter()
                formatter.Deserialize(stream)
            End Using
            sw.Stop()
            binaryDeserializeTime += sw.Elapsed.TotalMilliseconds
        Next

        'XML序列化性能测试
        Dim xmlSerializeTime As Double = 0
        Dim xmlDeserializeTime As Double = 0
        For i = 1 To iterations
            Dim sw As New Stopwatch()
            sw.Start()
            Using writer As New StreamWriter("temp.xml")
                Dim serializer As New XmlSerializer(GetType(PerformanceTestData))
                serializer.Serialize(writer, data)
            End Using
            sw.Stop()
            xmlSerializeTime += sw.Elapsed.TotalMilliseconds

            sw.Restart()
            Using reader As New StreamReader("temp.xml")
                Dim serializer As New XmlSerializer(GetType(PerformanceTestData))
                serializer.Deserialize(reader)
            End Using
            sw.Stop()
            xmlDeserializeTime += sw.Elapsed.TotalMilliseconds
        Next

        'JSON序列化性能测试
        Dim jsonSerializeTime As Double = 0
        Dim jsonDeserializeTime As Double = 0
        For i = 1 To iterations
            Dim sw As New Stopwatch()
            sw.Start()
            Dim json = JsonConvert.SerializeObject(data)
            sw.Stop()
            jsonSerializeTime += sw.Elapsed.TotalMilliseconds

            sw.Restart()
            JsonConvert.DeserializeObject(Of PerformanceTestData)(json)
            sw.Stop()
            jsonDeserializeTime += sw.Elapsed.TotalMilliseconds
        Next

        Console.WriteLine($"Binary Serialize Time: {binarySerializeTime / iterations} ms")
        Console.WriteLine($"Binary Deserialize Time: {binaryDeserializeTime / iterations} ms")
        Console.WriteLine($"XML Serialize Time: {xmlSerializeTime / iterations} ms")
        Console.WriteLine($"XML Deserialize Time: {xmlDeserializeTime / iterations} ms")
        Console.WriteLine($"JSON Serialize Time: {jsonSerializeTime / iterations} ms")
        Console.WriteLine($"JSON Deserialize Time: {jsonDeserializeTime / iterations} ms")
    End Sub
End Module

通过上述代码，可以对不同序列化方式在多次迭代中的平均序列化和反序列化时间进行测量，从而更直观地了解它们的性能差异。

最佳实践总结

  1. 选择合适的序列化方式：根据应用场景的需求，如性能、兼容性、可读性等，选择最合适的序列化方式。如果是内部应用且对性能要求高，二进制序列化可能是最佳选择；如果需要在不同系统间交换数据且对可读性有要求，XML或JSON可能更合适。
  2. 避免不必要的序列化：如果对象的状态不需要持久化或传输，不要进行序列化。序列化和反序列化操作都有一定的性能开销，尽量减少不必要的操作可以提高应用程序的整体性能。
  3. 优化对象结构：对于复杂对象，尽量简化其结构，避免包含过多不必要的字段和复杂的引用关系。这不仅可以减少序列化的数据量，还可以提高序列化和反序列化的速度。
  4. 缓存序列化结果：如果某些对象的状态不经常变化，可以缓存其序列化后的结果。这样在需要时可以直接使用缓存的数据，而避免重复的序列化操作。

通过遵循这些最佳实践，可以在Visual Basic应用程序中更高效地使用序列化与反序列化机制，提升应用程序的性能和可靠性。