资料库 – 中文知识库

C 类序列化 XML 文件完整指南：从原理到实战解决数据持久化与跨平台传输难题

—

by

admin
in

引言：为什么需要序列化？
在现代软件开发中，数据持久化和跨平台传输是两个核心需求。想象一下，你需要将内存中的对象保存到硬盘上以便下次程序启动时恢复，或者需要将对象数据发送到远程服务器。序列化就是解决这些问题的钥匙。
序列化
是将对象的状态信息转换为可以存储或传输的格式的过程，而
反序列化
则是从这种格式重建对象的过程。对于C#开发者来说，XML序列化提供了一种结构清晰、可读性强的序列化方案。
XML序列化基础原理
什么是XML序列化？
XML序列化是将对象的公共属性和字段转换为XML格式的过程。与二进制序列化不同，XML序列化生成的是人类可读的文本格式，这使得它非常适合配置文件、Web服务和跨平台数据交换。
XML序列化的核心组件
在C#中，XML序列化主要依赖于
System.Xml.Serialization
命名空间，核心类包括：
XmlSerializer
：执行序列化和反序列化的主要类
XmlAttribute
、
XmlElement
：控制序列化后XML的结构
XmlRoot
：定义根元素
XmlIgnore
：排除不需要序列化的属性
基础实战：简单对象的序列化
让我们从一个简单的例子开始。假设我们有一个表示用户的类：
using System;
using System.IO;
using System.Xml.Serialization;

// 用户类
public class User
{
public string Name { get; set; }
public int Age { get; set; }
public DateTime BirthDate { get; set; }
public bool IsActive { get; set; }
}

class Program
{
static void Main()
{
// 创建对象实例
User user = new User
{
Name = “张三”,
Age = 25,
BirthDate = new DateTime(1998, 5, 15),
IsActive = true
};

// 序列化到文件
SerializeUserToFile(user, “user.xml”);

// 从文件反序列化
User deserializedUser = DeserializeUserFromFile(“user.xml”);

Console.WriteLine($”反序列化结果：{deserializedUser.Name}, {deserializedUser.Age}岁”);
}

// 序列化方法
static void SerializeUserToFile(User user, string filePath)
{
XmlSerializer serializer = new XmlSerializer(typeof(User));
using (FileStream stream = new FileStream(filePath, FileMode.Create))
{
serializer.Serialize(stream, user);
}
Console.WriteLine($”用户数据已序列化到：{filePath}”);
}

// 反序列化方法
static User DeserializeUserFromFile(string filePath)
{
XmlSerializer serializer = new XmlSerializer(typeof(User));
using (FileStream stream = new FileStream(filePath, FileMode.Open))
{
return (User)serializer.Deserialize(stream);
}
}
}
运行这段代码后，生成的XML文件内容如下：


张三
25
1998-05-15T00:00:00
true

高级配置：自定义XML结构
使用特性(Attributes)控制序列化
C#提供了丰富的特性来精确控制XML的输出格式：
using System;
using System.Xml.Serialization;

// 使用特性自定义XML结构
[XmlRoot(“UserProfile”)]
public class User
{
[XmlElement(“UserName”)]
public string Name { get; set; }

[XmlAttribute(“Age”)]
public int Age { get; set; }

[XmlElement(“BirthDate”)]
public DateTime BirthDate { get; set; }

[XmlIgnore]
public bool IsActive { get; set; } // 不会被序列化

[XmlElement(“Status”)]
public string StatusMessage { get; set; }
}

// 使用示例
class AdvancedExample
{
static void Main()
{
User user = new User
{
Name = “李四”,
Age = 30,
BirthDate = new DateTime(1993, 8, 20),
IsActive = false,
StatusMessage = “在线”
};

XmlSerializer serializer = new XmlSerializer(typeof(User));
using (var stream = new System.IO.StreamWriter(“user_advanced.xml”))
{
serializer.Serialize(stream, user);
}
}
}
生成的XML：


李四
1993-08-20T00:00:00
在线

处理复杂对象和集合
实际应用中，我们经常需要序列化包含其他对象或集合的复杂类型：
using System;
using System.Collections.Generic;
using System.Xml.Serialization;

// 地址类
public class Address
{
[XmlElement(“Street”)]
public string Street { get; set; }

[XmlElement(“City”)]
public string City { get; set; }

[XmlElement(“ZipCode”)]
public string ZipCode { get; set; }
}

// 订单类
public class Order
{
[XmlAttribute(“ID”)]
public int OrderId { get; set; }

[XmlElement(“OrderDate”)]
public DateTime OrderDate { get; set; }

[XmlElement(“TotalAmount”)]
public decimal TotalAmount { get; set; }

[XmlArray(“Items”)]
[XmlArrayItem(“Item”)]
public List Items { get; set; }
}

// 订单项类
public class OrderItem
{
[XmlElement(“ProductID”)]
public int ProductId { get; set; }

[XmlElement(“ProductName”)]
public string ProductName { get; set; }

[XmlElement(“Quantity”)]
public int Quantity { get; set; }

[XmlElement(“Price”)]
public decimal Price { get; set; }
}

// 客户类（包含复杂结构）
public class Customer
{
[XmlElement(“CustomerID”)]
public int CustomerId { get; set; }

[XmlElement(“Name”)]
public string Name { get; set; }

[XmlElement(“Address”)]
public Address ShippingAddress { get; set; }

[XmlArray(“RecentOrders”)]
[XmlArrayItem(“Order”)]
public List RecentOrders { get; set; }
}

class ComplexExample
{
static void Main()
{
// 创建复杂对象图
Customer customer = new Customer
{
CustomerId = 1001,
Name = “王五”,
ShippingAddress = new Address
{
Street = “人民路123号”,
City = “北京”,
ZipCode = “100000”
},
RecentOrders = new List
{
new Order
{
OrderId = 5001,
OrderDate = DateTime.Now.AddDays(-5),
TotalAmount = 299.98m,
Items = new List
{
new OrderItem { ProductId = 101, ProductName = “笔记本电脑”, Quantity = 1, Price = 299.98m }
}
},
new Order
{
OrderId = 5002,
OrderDate = DateTime.Now.AddDays(-2),
TotalAmount = 45.50m,
Items = new List
{
new OrderItem { ProductId = 201, ProductName = “鼠标”, Quantity = 2, Price = 22.75m }
}
}
}
};

// 序列化
XmlSerializer serializer = new XmlSerializer(typeof(Customer));
using (var stream = new System.IO.StreamWriter(“customer.xml”))
{
serializer.Serialize(stream, customer);
}

Console.WriteLine(“复杂对象序列化完成！”);
}
}
生成的XML文件：


1001
王五


人民路123号
北京
100000



2024-01-15T10:30:00
299.98


101
笔记本电脑
1
299.98




2024-01-18T10:30:00
45.50


201
鼠标
2
22.75





处理特殊场景
1. 处理空值和默认值
using System;
using System.Xml.Serialization;

public class Product
{
[XmlElement(“Name”)]
public string Name { get; set; }

// 使用ShouldSerialize模式控制是否序列化
[XmlElement(“Description”)]
public string Description { get; set; }

// 控制是否序列化Description
public bool ShouldSerializeDescription()
{
return !string.IsNullOrEmpty(Description);
}

// 处理默认值
[XmlElement(“StockQuantity”)]
public int StockQuantity { get; set; }

// 控制是否序列化StockQuantity（当为0时不序列化）
public bool ShouldSerializeStockQuantity()
{
return StockQuantity != 0;
}
}

class DefaultValueExample
{
static void Main()
{
Product product = new Product
{
Name = “测试产品”,
Description = null, // 不会被序列化
StockQuantity = 0 // 不会被序列化
};

XmlSerializer serializer = new XmlSerializer(typeof(Product));
using (var stream = new System.IO.StreamWriter(“product.xml”))
{
serializer.Serialize(stream, product);
}
}
}
2. 处理日期格式
using System;
using System.Xml.Serialization;

public class Event
{
[XmlElement(“EventName”)]
public string EventName { get; set; }

// 自定义日期格式
[XmlElement(“EventDate”)]
public string EventDateFormatted { get; set; }

// 原始日期属性（不序列化）
[XmlIgnore]
public DateTime EventDate { get; set; }

// 在序列化前格式化日期
public void PreSerialize()
{
EventDateFormatted = EventDate.ToString(“yyyy-MM-dd HH:mm:ss”);
}

// 在反序列化后解析日期
public void PostDeserialize()
{
if (!string.IsNullOrEmpty(EventDateFormatted))
{
EventDate = DateTime.ParseExact(EventDateFormatted, “yyyy-MM-dd HH:mm:ss”, null);
}
}
}

class DateFormattingExample
{
static void Main()
{
Event ev = new Event
{
EventName = “技术会议”,
EventDate = new DateTime(2024, 3, 15, 14, 30, 0)
};

ev.PreSerialize();

XmlSerializer serializer = new XmlSerializer(typeof(Event));
using (var stream = new System.IO.StreamWriter(“event.xml”))
{
serializer.Serialize(stream, ev);
}

// 反序列化
using (var stream = new System.IO.StreamReader(“event.xml”))
{
Event deserializedEvent = (Event)serializer.Deserialize(stream);
deserializedEvent.PostDeserialize();
Console.WriteLine($”事件时间：{deserializedEvent.EventDate}”);
}
}
}
3. 处理泛型集合
using System;
using System.Collections.Generic;
using System.Xml.Serialization;

// 泛型包装类
[XmlRoot(“DataCollection”)]
public class DataCollection
{
[XmlArray(“Items”)]
[XmlArrayItem(“Item”)]
public List Items { get; set; }

public DataCollection()
{
Items = new List();
}
}

// 数据项
public class DataItem
{
[XmlAttribute(“ID”)]
public int Id { get; set; }

[XmlElement(“Value”)]
public string Value { get; set; }
}

class GenericExample
{
static void Main()
{
// 创建泛型集合
var collection = new DataCollection
{
Items = new List
{
new DataItem { Id = 1, Value = “第一项” },
new DataItem { Id = 2, Value = “第二项” }
}
};

// 序列化
XmlSerializer serializer = new XmlSerializer(typeof(DataCollection));
using (var stream = new System.IO.StreamWriter(“generic_collection.xml”))
{
serializer.Serialize(stream, collection);
}

// 反序列化
using (var stream = new System.IO.StreamReader(“generic_collection.xml”))
{
var deserialized = (DataCollection)serializer.Deserialize(stream);
Console.WriteLine($”加载了 {deserialized.Items.Count} 个数据项”);
}
}
}
实战应用：配置文件管理
创建可配置的应用程序设置
using System;
using System.IO;
using System.Xml.Serialization;

[XmlRoot(“AppSettings”)]
public class AppSettings
{
[XmlElement(“Database”)]
public DatabaseSettings Database { get; set; }

[XmlElement(“Logging”)]
public LoggingSettings Logging { get; set; }

[XmlElement(“API”)]
public APISettings API { get; set; }

public AppSettings()
{
Database = new DatabaseSettings();
Logging = new LoggingSettings();
API = new APISettings();
}

// 从文件加载配置
public static AppSettings Load(string filePath)
{
if (!File.Exists(filePath))
{
// 返回默认配置
return new AppSettings();
}

XmlSerializer serializer = new XmlSerializer(typeof(AppSettings));
using (FileStream stream = new FileStream(filePath, FileMode.Open))
{
return (AppSettings)serializer.Deserialize(stream);
}
}

// 保存配置到文件
public void Save(string filePath)
{
XmlSerializer serializer = new XmlSerializer(typeof(AppSettings));
using (FileStream stream = new FileStream(filePath, FileMode.Create))
{
serializer.Serialize(stream, this);
}
}
}

public class DatabaseSettings
{
[XmlElement(“ConnectionString”)]
public string ConnectionString { get; set; } = “Server=localhost;Database=MyDB;”;

[XmlElement(“Timeout”)]
public int Timeout { get; set; } = 30;

[XmlElement(“MaxPoolSize”)]
public int MaxPoolSize { get; set; } = 100;
}

public class LoggingSettings
{
[XmlElement(“Enabled”)]
public bool Enabled { get; set; } = true;

[XmlElement(“Level”)]
public string Level { get; set; } = “Info”;

[XmlElement(“FilePath”)]
public string FilePath { get; set; } = “logs/app.log”;
}

public class APISettings
{
[XmlElement(“BaseUrl”)]
public string BaseUrl { get; set; } = “https://api.example.com”;

[XmlElement(“Timeout”)]
public int Timeout { get; set; } = 60;

[XmlElement(“Retries”)]
public int Retries { get; set; } = 3;
}

class ConfigManager
{
static void Main()
{
// 创建配置实例
var settings = new AppSettings
{
Database = new DatabaseSettings
{
ConnectionString = “Server=prod-db;Database=Production;User=admin;”,
Timeout = 60,
MaxPoolSize = 200
},
Logging = new LoggingSettings
{
Enabled = true,
Level = “Debug”,
FilePath = “logs/production.log”
},
API = new APISettings
{
BaseUrl = “https://api.production.com”,
Timeout = 120,
Retries = 5
}
};

// 保存配置
settings.Save(“app.config”);
Console.WriteLine(“配置已保存到 app.config”);

// 加载配置
var loadedSettings = AppSettings.Load(“app.config”);
Console.WriteLine($”数据库连接：{loadedSettings.Database.ConnectionString}”);
Console.WriteLine($”日志级别：{loadedSettings.Logging.Level}”);
Console.WriteLine($”API地址：{loadedSettings.API.BaseUrl}”);
}
}
错误处理与最佳实践
完整的错误处理示例
using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

public class SerializationHelper
{
///

/// 安全地序列化对象到XML文件
///

public static bool TrySerialize(T obj, string filePath, out string errorMessage)
{
errorMessage = null;
try
{
if (obj == null)
{
errorMessage = “对象不能为null”;
return false;
}

if (string.IsNullOrWhiteSpace(filePath))
{
errorMessage = “文件路径不能为空”;
return false;
}

// 确保目录存在
string directory = Path.GetDirectoryName(filePath);
if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}

XmlSerializer serializer = new XmlSerializer(typeof(T));

// 使用XmlWriterSettings进行更精细的控制
var settings = new XmlWriterSettings
{
Indent = true,
IndentChars = ” “,
NewLineChars = “\n”,
Encoding = System.Text.Encoding.UTF8
};

using (var writer = XmlWriter.Create(filePath, settings))
{
serializer.Serialize(writer, obj);
}

return true;
}
catch (InvalidOperationException ex)
{
errorMessage = $”序列化错误：{ex.Message}”;
if (ex.InnerException != null)
{
errorMessage += $” 内部异常：{ex.InnerException.Message}”;
}
return false;
}
catch (UnauthorizedAccessException)
{
errorMessage = “没有权限写入文件：” + filePath;
return false;
}
catch (IOException ex)
{
errorMessage = “IO错误：” + ex.Message;
return false;
}
catch (Exception ex)
{
errorMessage = “未知错误：” + ex.Message;
return false;
}
}

///

/// 安全地从XML文件反序列化对象
///

public static bool TryDeserialize(string filePath, out T result, out string errorMessage)
{
result = default(T);
errorMessage = null;

try
{
if (!File.Exists(filePath))
{
errorMessage = $”文件不存在：{filePath}”;
return false;
}

XmlSerializer serializer = new XmlSerializer(typeof(T));

using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
result = (T)serializer.Deserialize(stream);
}

return true;
}
catch (InvalidOperationException ex)
{
errorMessage = $”反序列化错误：{ex.Message}”;
if (ex.InnerException != null)
{
errorMessage += $” 内部异常：{ex.InnerException.Message}”;
}
return false;
}
catch (FileNotFoundException)
{
errorMessage = $”文件未找到：{filePath}”;
return false;
}
catch (UnauthorizedAccessException)
{
errorMessage = “没有权限读取文件：” + filePath;
return false;
}
catch (Exception ex)
{
errorMessage = “未知错误：” + ex.Message;
return false;
}
}
}

// 使用示例
class ErrorHandlingExample
{
static void Main()
{
var user = new User { Name = “测试用户”, Age = 25, BirthDate = DateTime.Now };

// 序列化
if (SerializationHelper.TrySerialize(user, “safe_user.xml”, out string error))
{
Console.WriteLine(“序列化成功！”);
}
else
{
Console.WriteLine($”序列化失败：{error}”);
}

// 反序列化
if (SerializationHelper.TryDeserialize(“safe_user.xml”, out User loadedUser, out error))
{
Console.WriteLine($”反序列化成功：{loadedUser.Name}”);
}
else
{
Console.WriteLine($”反序列化失败：{error}”);
}
}
}
性能优化技巧
1. 重用XmlSerializer实例
// 避免频繁创建XmlSerializer
public class CachedSerializer
{
private static readonly Dictionary _cache = new Dictionary();

public static XmlSerializer GetSerializer()
{
return GetSerializer(typeof(T));
}

public static XmlSerializer GetSerializer(Type type)
{
if (!_cache.ContainsKey(type))
{
_cache[type] = new XmlSerializer(type);
}
return _cache[type];
}
}
2. 使用流式处理大文件
// 处理大型XML文件
public class LargeFileProcessor
{
public static void ProcessLargeXml(string filePath)
{
XmlSerializer serializer = new XmlSerializer(typeof(List));

using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
// 使用XmlReader进行流式读取
using (XmlReader reader = XmlReader.Create(stream))
{
if (serializer.CanDeserialize(reader))
{
var items = (List)serializer.Deserialize(reader);
// 处理数据…
}
}
}
}
}
跨平台传输实战
创建Web API数据传输对象
using System;
using System.Collections.Generic;
using System.Xml.Serialization;

// Web API响应格式
[XmlRoot(“APIResponse”)]
public class ApiResponse
{
[XmlAttribute(“Status”)]
public string Status { get; set; }

[XmlElement(“Message”)]
public string Message { get; set; }

[XmlElement(“Timestamp”)]
public DateTime Timestamp { get; set; }

[XmlElement(“Data”)]
public T Data { get; set; }

public ApiResponse()
{
Timestamp = DateTime.UtcNow;
Status = “Success”;
}
}

// 用户数据传输对象
public class UserDTO
{
[XmlElement(“UserID”)]
public int UserId { get; set; }

[XmlElement(“Username”)]
public string Username { get; set; }

[XmlElement(“Email”)]
public string Email { get; set; }

[XmlArray(“Roles”)]
[XmlArrayItem(“Role”)]
public List Roles { get; set; }
}

// 跨平台数据交换示例
class CrossPlatformExample
{
static void Main()
{
// 创建API响应
var response = new ApiResponse
{
Status = “Success”,
Message = “用户数据获取成功”,
Data = new UserDTO
{
UserId = 1001,
Username = “cross_platform_user”,
Email = “user@example.com”,
Roles = new List { “Admin”, “User” }
}
};

// 序列化为XML
XmlSerializer serializer = new XmlSerializer(typeof(ApiResponse));
string xmlString;

using (var writer = new StringWriter())
{
serializer.Serialize(writer, response);
xmlString = writer.ToString();
}

Console.WriteLine(“生成的XML（可跨平台传输）：”);
Console.WriteLine(xmlString);

// 模拟接收端反序列化
using (var reader = new StringReader(xmlString))
{
var receivedResponse = (ApiResponse)serializer.Deserialize(reader);
Console.WriteLine($”\n接收端解析结果：”);
Console.WriteLine($”状态：{receivedResponse.Status}”);
Console.WriteLine($”用户：{receivedResponse.Data.Username}”);
Console.WriteLine($”角色：{string.Join(“, “, receivedResponse.Data.Roles)}”);
}
}
}
完整项目示例：数据持久化系统
综合示例：用户管理系统
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;

// 用户管理系统核心类
[XmlRoot(“UserManagementSystem”)]
public class UserManagementSystem
{
[XmlElement(“Version”)]
public string Version { get; set; } = “1.0”;

[XmlArray(“Users”)]
[XmlArrayItem(“User”)]
public List Users { get; set; }

[XmlElement(“LastUpdated”)]
public DateTime LastUpdated { get; set; }

public UserManagementSystem()
{
Users = new List();
LastUpdated = DateTime.Now;
}

// 添加用户
public void AddUser(User user)
{
user.Id = Users.Count + 1;
Users.Add(user);
LastUpdated = DateTime.Now;
}

// 查找用户
public User FindUser(string name)
{
return Users.Find(u => u.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
}

// 保存系统状态
public bool Save(string filePath)
{
try
{
XmlSerializer serializer = new XmlSerializer(typeof(UserManagementSystem));
using (var writer = new StreamWriter(filePath))
{
serializer.Serialize(writer, this);
}
return true;
}
catch (Exception ex)
{
Console.WriteLine($”保存失败：{ex.Message}”);
return false;
}
}

// 加载系统状态
public static UserManagementSystem Load(string filePath)
{
if (!File.Exists(filePath))
{
return new UserManagementSystem();
}

XmlSerializer serializer = new XmlSerializer(typeof(UserManagementSystem));
using (var stream = new FileStream(filePath, FileMode.Open))
{
return (UserManagementSystem)serializer.Deserialize(stream);
}
}

// 导出用户数据（用于跨平台传输）
public string ExportUsersXml()
{
XmlSerializer serializer = new XmlSerializer(typeof(List));
using (var writer = new StringWriter())
{
serializer.Serialize(writer, Users);
return writer.ToString();
}
}

// 从XML导入用户数据
public void ImportUsersXml(string xmlContent)
{
XmlSerializer serializer = new XmlSerializer(typeof(List));
using (var reader = new StringReader(xmlContent))
{
var importedUsers = (List)serializer.Deserialize(reader);
Users.AddRange(importedUsers);
LastUpdated = DateTime.Now;
}
}
}

// 增强的用户类
public class User
{
[XmlAttribute(“ID”)]
public int Id { get; set; }

[XmlElement(“Name”)]
public string Name { get; set; }

[XmlElement(“Email”)]
public string Email { get; set; }

[XmlElement(“RegistrationDate”)]
public DateTime RegistrationDate { get; set; }

[XmlElement(“LastLogin”)]
public DateTime LastLogin { get; set; }

[XmlElement(“IsActive”)]
public bool IsActive { get; set; }

[XmlArray(“Permissions”)]
[XmlArrayItem(“Permission”)]
public List Permissions { get; set; }

public User()
{
RegistrationDate = DateTime.Now;
IsActive = true;
Permissions = new List();
}
}

// 控制台应用程序演示
class UserManagerDemo
{
static void Main()
{
const string dataFile = “user_system.xml”;

// 加载或创建系统
var system = UserManagementSystem.Load(dataFile);

Console.WriteLine($”系统版本：{system.Version}”);
Console.WriteLine($”当前用户数：{system.Users.Count}”);
Console.WriteLine($”最后更新：{system.LastUpdated}”);

// 添加新用户
while (true)
{
Console.WriteLine(“\n1. 添加用户”);
Console.WriteLine(“2. 查找用户”);
Console.WriteLine(“3. 显示所有用户”);
Console.WriteLine(“4. 导出数据”);
Console.WriteLine(“5. 导入数据”);
Console.WriteLine(“6. 保存并退出”);
Console.Write(“选择操作：”);

string choice = Console.ReadLine();

switch (choice)
{
case “1”:
Console.Write(“用户名：”);
string name = Console.ReadLine();
Console.Write(“邮箱：”);
string email = Console.ReadLine();

var newUser = new User
{
Name = name,
Email = email,
Permissions = new List { “Read”, “Write” }
};

system.AddUser(newUser);
Console.WriteLine(“用户添加成功！”);
break;

case “2”:
Console.Write(“要查找的用户名：”);
string searchName = Console.ReadLine();
var foundUser = system.FindUser(searchName);
if (foundUser != null)
{
Console.WriteLine($”找到用户：{foundUser.Name} (ID: {foundUser.Id})”);
Console.WriteLine($”邮箱：{foundUser.Email}”);
Console.WriteLine($”权限：{string.Join(“, “, foundUser.Permissions)}”);
}
else
{
Console.WriteLine(“未找到用户”);
}
break;

case “3”:
Console.WriteLine(“\n所有用户：”);
foreach (var user in system.Users)
{
Console.WriteLine($”[{user.Id}] {user.Name} – {user.Email} – {(user.IsActive ? “活跃” : “禁用”)}”);
}
break;

case “4”:
string xmlData = system.ExportUsersXml();
Console.WriteLine(“导出的XML数据：”);
Console.WriteLine(xmlData);
File.WriteAllText(“users_export.xml”, xmlData);
Console.WriteLine(“已保存到 users_export.xml”);
break;

case “5”:
if (File.Exists(“users_export.xml”))
{
string importData = File.ReadAllText(“users_export.xml”);
system.ImportUsersXml(importData);
Console.WriteLine(“数据导入成功！”);
}
else
{
Console.WriteLine(“导出文件不存在”);
}
break;

case “6”:
if (system.Save(dataFile))
{
Console.WriteLine(“系统状态已保存，再见！”);
}
return;

default:
Console.WriteLine(“无效选择”);
break;
}
}
}
}
常见问题与解决方案
1. 循环引用问题
// 问题：循环引用会导致序列化失败
public class Parent
{
public string Name { get; set; }
public List Children { get; set; }
}

public class Child
{
public string Name { get; set; }
public Parent Parent { get; set; } // 循环引用
}

// 解决方案：使用[XmlIgnore]打破循环
public class ChildFixed
{
public string Name { get; set; }

[XmlIgnore]
public Parent Parent { get; set; }
}
2. 处理特殊字符
// XML会自动处理特殊字符，但有时需要手动控制
public class SpecialCharsExample
{
public string TextWithSpecialChars { get; set; }

public void Demonstrate()
{
// XML会自动转义： < > & ‘ ”
var obj = new SpecialCharsExample
{
TextWithSpecialChars = “包含<特殊>字符&引号’的文本”
};

// 序列化后会自动转义为：包含<特殊>字符&引号'的文本
}
}
3. 版本兼容性
// 使用可选元素和默认值处理版本兼容性
public class VersionedData
{
[XmlElement(“Name”)]
public string Name { get; set; }

// 新增字段，使用默认值确保旧XML能正确反序列化
[XmlElement(“NewField”, IsNullable = true)]
public string NewField { get; set; } = “默认值”;

// 可选字段
[XmlElement(“OptionalField”)]
public string OptionalField { get; set; }
}
性能对比与选择建议
XML序列化 vs 其他序列化方式
特性
XML序列化
JSON序列化
二进制序列化
可读性
高
中
低
文件大小
大
中
小
序列化速度
慢
中
快
跨平台
优秀
优秀
差
版本兼容性
好
好
差
人类可编辑
是
是
否
何时选择XML序列化
配置文件
：需要人类可读和可编辑
Web服务
：需要跨平台数据交换
文档存储
：需要长期存档和可读性
调试需求
：需要查看序列化内容
何时避免XML序列化
高性能要求
：二进制序列化更快
大数据量
：XML文件体积过大
简单数据交换
：JSON更轻量
紧密耦合系统
：二进制序列化更高效
总结
XML序列化是C#中处理数据持久化和跨平台传输的强大工具。通过本文的详细指南，您应该能够：
理解原理
：掌握XML序列化的工作机制
基础应用
：实现简单对象的序列化和反序列化
高级技巧
：使用特性自定义XML结构
处理复杂场景
：管理集合、嵌套对象和特殊数据类型
实战应用
：构建配置文件系统和数据管理器
错误处理
：编写健壮的序列化代码
性能优化
：提升序列化效率
跨平台传输
：实现系统间数据交换
记住，XML序列化最适合需要可读性、跨平台兼容性和长期数据存储的场景。对于性能敏感的应用，考虑使用JSON或二进制序列化作为替代方案。
通过实践这些示例和模式，您将能够有效地解决数据持久化和跨平台传输的难题，构建可靠的数据处理系统。