? 在编程的世界里，文件的读写操作是我们经常面对的任务之一。
? 当我们只涉及简单的文本文件时，这个任务似乎并不复杂。但是，当我们处理更为复杂的类对象时，逐个字段进行读取和写入会显得非常繁琐。更为严峻的是，当类的字段发生变化时，我们需要同时修改读取和写入模块，而且还要考虑与原有版本文件的兼容性。
? 在面对复杂的类结构时，逐个字段进行读取和写入是非常不便利的。这种方式容易导致代码的冗长和维护的困难。而对象序列化则能够将整个对象保存到文件中，不仅减少了代码量，还提高了代码的可维护性。此外，对象序列化还能够解决不同版本之间的兼容性问题，使得在类结构发生变化时，我们仍然能够正确地读取旧版本的文件。
? 设想一下，当我们开发一个系统时，需要对个人信息进行保存。刚开始只有用户名、密码、邮箱，可随着系统越来越完善，所含有的变量也越来越多，这时候如果还是按照原有的思路，一个变量一个变量进行读写，很有可能产生遗漏，且代码庞杂不美观。
? 我们以一个包含多个字段的PersonalInfo类为例，展示逐个字段读写和对象序列化之间的对比。
首先，我们看一下逐个字段读写的示例：
using System;
using System.Diagnostics;
using System.IO;
class Program
{
class PersonalInfo
{
public string UserName { get; set; }
public string Email { get; set; }
public string Password { get; set; }
public int Level { get; set; }
public string Avatar { get; set; }
public string Signature { get; set; }
// ... 可能还有其他字段 ...
}
static void Main()
{
PersonalInfo person = new PersonalInfo
{
UserName = "JohnDoe",
Email = "john@example.com",
Password = "securepassword",
Level = 3,
Avatar = "avatar.jpg",
Signature = "Hello, world!"
// ... 其他字段的初始化 ...
};
Stopwatch stopwatch = new Stopwatch();
// 逐个字段写入
using (StreamWriter writer = new StreamWriter("person.txt"))
{
stopwatch.Start();
writer.WriteLine(person.UserName);
writer.WriteLine(person.Email);
writer.WriteLine(person.Password);
writer.WriteLine(person.Level);
writer.WriteLine(person.Avatar);
writer.WriteLine(person.Signature);
// ... 其他字段的写入 ...
stopwatch.Stop();
}
Console.WriteLine($"逐个字段写入耗时：{stopwatch.ElapsedMilliseconds} 毫秒");
// 重新初始化 PersonalInfo 对象
person = new PersonalInfo();
// 逐个字段读取
using (StreamReader reader = new StreamReader("person.txt"))
{
stopwatch.Restart();
person.UserName = reader.ReadLine();
person.Email = reader.ReadLine();
person.Password = reader.ReadLine();
person.Level = int.Parse(reader.ReadLine());
person.Avatar = reader.ReadLine();
person.Signature = reader.ReadLine();
// ... 其他字段的读取 ...
stopwatch.Stop();
}
Console.WriteLine($"逐个字段读取耗时：{stopwatch.ElapsedMilliseconds} 毫秒");
}
}
接下来，我们看一下对象序列化的示例：
using System;
using System.Diagnostics;
using System.IO;
using Newtonsoft.Json;
class Program
{
class PersonalInfo
{
public string UserName { get; set; }
public string Email { get; set; }
public string Password { get; set; }
public int Level { get; set; }
public string Avatar { get; set; }
public string Signature { get; set; }
// ... 可能还有其他字段 ...
}
static void Main()
{
PersonalInfo person = new PersonalInfo
{
UserName = "JohnDoe",
Email = "john@example.com",
Password = "securepassword",
Level = 3,
Avatar = "avatar.jpg",
Signature = "Hello, world!"
// ... 其他字段的初始化 ...
};
Stopwatch stopwatch = new Stopwatch();
// 对象序列化
stopwatch.Start();
string json = JsonConvert.SerializeObject(person);
File.WriteAllText("person.json", json);
stopwatch.Stop();
Console.WriteLine($"对象序列化耗时：{stopwatch.ElapsedMilliseconds} 毫秒");
// 重新初始化 PersonalInfo 对象
person = new PersonalInfo();
// 对象反序列化
stopwatch.Restart();
string jsonString = File.ReadAllText("person.json");
PersonalInfo deserializedPerson = JsonConvert.DeserializeObject<PersonalInfo>(jsonString);
stopwatch.Stop();
Console.WriteLine($"对象反序列化耗时：{stopwatch.ElapsedMilliseconds} 毫秒");
}
}
? 通过上述例子，我们可以清晰地看到，使用对象序列化的代码更加简洁、清晰，并且不需要关心逐个字段的读写细节。
? 特别是在处理大型复杂对象时，对象序列化的优势更为明显。这种方式可以提高代码的可读性，减少冗余操作，并确保在类结构发生变化时仍能正确处理文件的读写操作。
? 在C#中，我们常用的对象序列化工具是Newtonsoft.Json。该工具提供了强大而灵活的功能，使得对象序列化变得异常简单。下面通过一个例子来说明：
// 定义一个示例类
public class PersonalInfo
{
public string UserName { get; set; }
public string Email { get; set; }
public string Password { get; set; }
public int Level { get; set; }
public string Avatar { get; set; }
public string Signature { get; set; }
// ... 其他字段 ...
}
// 对象序列化示例
PersonalInfo person = new PersonalInfo
{
UserName = "JohnDoe",
Email = "john@example.com",
Password = "securepassword",
Level = 3,
Avatar = "avatar.jpg",
Signature = "Hello, world!"
// ... 其他字段的初始化 ...
};
string json = JsonConvert.SerializeObject(person);
File.WriteAllText("person.json", json);
// 对象反序列化示例
string jsonString = File.ReadAllText("person.json");
PersonalInfo deserializedPerson = JsonConvert.DeserializeObject<PersonalInfo>(jsonString);
? 在Java中，我们使用Object流来实现对象的序列化。下面是一个简单的Java示例：
import java.io.*;
// 定义一个示例类
class PersonalInfo implements Serializable {
String userName;
String email;
String password;
int level;
String avatar;
String signature;
// ... 其他字段 ...
// 构造函数
public PersonalInfo(String userName, String email, String password, int level, String avatar, String signature) {
this.userName = userName;
this.email = email;
this.password = password;
this.level = level;
this.avatar = avatar;
this.signature = signature;
// ... 其他字段的初始化 ...
}
}
// 对象序列化示例
PersonalInfo person = new PersonalInfo("JohnDoe", "john@example.com", "securepassword", 3, "avatar.jpg", "Hello, world!");
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
oos.writeObject(person);
}
// 对象反序列化示例
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
PersonalInfo deserializedPerson = (PersonalInfo) ois.readObject();
}
? 通过以上示例，我们清晰地展示了对象序列化的威力。在处理类结构较为庞大的情况下，对象序列化能够使代码更加简洁、可读性更强，同时保证了不同版本之间的兼容性。不妨尝试使用对象序列化，提高你的代码效率，让读写操作变得更加轻松！