Elysia Tools

在一个清晰的工作台里浏览工具、案例、可视化和主题指南。

热门分类

专题

语言
ZHDERUPTENFRES

Elysia Tools

导航

C#

Windows 序列化 - C# 示例

Windows平台C#序列化示例,包括JSON、XML、二进制序列化和数据转换

案例

这个案例集合中的条目

代码csharp简单

JSON序列化和反序列化

使用System.Text.Json处理JSON数据进行对象序列化和反序列化

难度

4/10

预计时间

20 min

标签

csharp, json, serialization, windows

前置条件

C# basics, Object-oriented programming, JSON concepts

csharp
using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.IO;

public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
    public string Email { get; set; }
    public DateTime BirthDate { get; set; }
    public List<string> Hobbies { get; set; }
    public Address Address { get; set; }
}

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
    public string PostalCode { get; set; }
}

class JSONSerialization
{
    // 1. Basic JSON serialization
    public static void BasicJSONSerialization()
    {
        Console.WriteLine("=== Basic JSON Serialization ===");

        // Create a sample object
        var person = new Person
        {
            Id = 1,
            FirstName = "John",
            LastName = "Doe",
            Age = 30,
            Email = "john.doe@example.com",
            BirthDate = new DateTime(1993, 5, 15),
            Hobbies = new List<string> { "Reading", "Swimming", "Programming" },
            Address = new Address
            {
                Street = "123 Main St",
                City = "New York",
                Country = "USA",
                PostalCode = "10001"
            }
        };

        // Serialize to JSON string
        string jsonString = JsonSerializer.Serialize(person, new JsonSerializerOptions
        {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        });

        Console.WriteLine("Serialized JSON:");
        Console.WriteLine(jsonString);

        // Save to file
        File.WriteAllText("person.json", jsonString);
        Console.WriteLine("\nJSON saved to person.json file");
    }

    // 2. Basic JSON deserialization
    public static void BasicJSONDeserialization()
    {
        Console.WriteLine("\n=== Basic JSON Deserialization ===");

        try
        {
            // Read from file
            string jsonString = File.ReadAllText("person.json");
            Console.WriteLine("Reading JSON from file...");

            // Deserialize to object
            Person person = JsonSerializer.Deserialize<Person>(jsonString);

            Console.WriteLine("\nDeserialized Person object:");
            Console.WriteLine($"ID: {person.Id}");
            Console.WriteLine($"Name: {person.FirstName} {person.LastName}");
            Console.WriteLine($"Age: {person.Age}");
            Console.WriteLine($"Email: {person.Email}");
            Console.WriteLine($"Birth Date: {person.BirthDate:yyyy-MM-dd}");
            Console.WriteLine($"Hobbies: {string.Join(", ", person.Hobbies)}");
            Console.WriteLine($"Address: {person.Address.Street}, {person.Address.City}, {person.Address.Country}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error deserializing JSON: {ex.Message}");
        }
    }

    // 3. Advanced JSON serialization with custom options
    public static void AdvancedJSONSerialization()
    {
        Console.WriteLine("\n=== Advanced JSON Serialization ===");

        var employees = new List<Employee>
        {
            new Employee
            {
                Id = 1,
                Name = "Alice Johnson",
                Position = "Software Engineer",
                Salary = 75000.50m,
                HireDate = new DateTime(2020, 3, 15),
                IsActive = true,
                Department = "Engineering"
            },
            new Employee
            {
                Id = 2,
                Name = "Bob Smith",
                Position = "Project Manager",
                Salary = 85000.00m,
                HireDate = new DateTime(2019, 7, 1),
                IsActive = true,
                Department = "Management"
            },
            new Employee
            {
                Id = 3,
                Name = "Carol White",
                Position = "UX Designer",
                Salary = 65000.00m,
                HireDate = new DateTime(2021, 1, 10),
                IsActive = false,
                Department = "Design"
            }
        };

        // Configure JSON serializer options
        var options = new JsonSerializerOptions
        {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
            NumberHandling = JsonNumberHandling.AllowReadingFromString,
            Converters = { new JsonStringEnumConverter() }
        };

        // Serialize list of employees
        string employeesJson = JsonSerializer.Serialize(employees, options);
        Console.WriteLine("Advanced JSON Serialization (Employees):");
        Console.WriteLine(employeesJson);

        // Save to file
        File.WriteAllText("employees.json", employeesJson);
        Console.WriteLine("\nEmployees JSON saved to employees.json");
    }

    // 4. Working with anonymous objects and dynamic JSON
    public static void DynamicJSONOperations()
    {
        Console.WriteLine("\n=== Dynamic JSON Operations ===");

        // Create anonymous object
        var orderData = new
        {
            OrderId = "ORD-2023-001",
            Customer = new
            {
                Name = "Jane Doe",
                Email = "jane@example.com",
                Phone = "+1-555-0123"
            },
            Items = new[]
            {
                new { ProductId = "PROD-001", Name = "Laptop", Quantity = 1, Price = 999.99m },
                new { ProductId = "PROD-002", Name = "Mouse", Quantity = 2, Price = 25.50m },
                new { ProductId = "PROD-003", Name = "Keyboard", Quantity = 1, Price = 75.00m }
            },
            TotalAmount = 1125.99m,
            OrderDate = DateTime.Now,
            Status = "Pending"
        };

        // Serialize anonymous object
        string orderJson = JsonSerializer.Serialize(orderData, new JsonSerializerOptions
        {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
        });

        Console.WriteLine("Anonymous Object Serialization:");
        Console.WriteLine(orderJson);

        // Parse to JsonDocument for dynamic access
        using (JsonDocument document = JsonDocument.Parse(orderJson))
        {
            JsonElement root = document.RootElement;

            Console.WriteLine("\nDynamic JSON Access:");
            Console.WriteLine($"Order ID: {root.GetProperty("orderId").GetString()}");
            Console.WriteLine($"Customer Name: {root.GetProperty("customer").GetProperty("name").GetString()}");
            Console.WriteLine($"Total Amount: ${root.GetProperty("totalAmount").GetDecimal():F2}");

            Console.WriteLine("\nOrder Items:");
            foreach (JsonElement item in root.GetProperty("items").EnumerateArray())
            {
                string name = item.GetProperty("name").GetString();
                int quantity = item.GetProperty("quantity").GetInt32();
                decimal price = item.GetProperty("price").GetDecimal();
                Console.WriteLine($"- {name}: {quantity} x ${price:F2}");
            }
        }
    }

    // 5. JSON with custom serialization attributes
    public static void CustomAttributeSerialization()
    {
        Console.WriteLine("\n=== Custom Attribute Serialization ===");

        var product = new Product
        {
            ProductId = "PROD-001",
            ProductName = "Wireless Headphones",
            Description = "High-quality wireless headphones with noise cancellation",
            Price = 149.99m,
            InStock = true,
            Categories = new List<string> { "Electronics", "Audio", "Wireless" },
            Metadata = new Dictionary<string, object>
            {
                ["Brand"] = "TechSound",
                ["Model"] = "WH-1000XM4",
                ["Weight"] = 254,
                ["BatteryLife"] = "30 hours",
                ["WaterResistant"] = true
            }
        };

        // Serialize with custom attributes
        var options = new JsonSerializerOptions
        {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault
        };

        string productJson = JsonSerializer.Serialize(product, options);
        Console.WriteLine("Product with Custom Attributes:");
        Console.WriteLine(productJson);

        // Deserialize
        Product deserializedProduct = JsonSerializer.Deserialize<Product>(productJson, options);

        Console.WriteLine("\nDeserialized Product:");
        Console.WriteLine($"ID: {deserializedProduct.ProductId}");
        Console.WriteLine($"Name: {deserializedProduct.ProductName}");
        Console.WriteLine($"Price: ${deserializedProduct.Price:F2}");
        Console.WriteLine($"In Stock: {deserializedProduct.InStock}");
        Console.WriteLine($"Categories: {string.Join(", ", deserializedProduct.Categories)}");
        Console.WriteLine($"Brand: {deserializedProduct.Metadata["Brand"]}");
    }

    public static void RunAllExamples()
    {
        Console.WriteLine("JSON Serialization Examples");
        Console.WriteLine("===========================");

        BasicJSONSerialization();
        BasicJSONDeserialization();
        AdvancedJSONSerialization();
        DynamicJSONOperations();
        CustomAttributeSerialization();

        Console.WriteLine("\nJSON serialization examples completed!");
    }
}

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Position { get; set; }
    public decimal Salary { get; set; }
    public DateTime HireDate { get; set; }
    public bool IsActive { get; set; }
    public string Department { get; set; }
}

public class Product
{
    [JsonPropertyName("productId")]
    public string ProductId { get; set; }

    [JsonPropertyName("productName")]
    public string ProductName { get; set; }

    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    public string Description { get; set; }

    [JsonPropertyName("price")]
    [JsonConverter(typeof(DecimalConverter))]
    public decimal Price { get; set; }

    [JsonPropertyName("inStock")]
    public bool InStock { get; set; }

    [JsonPropertyName("categories")]
    public List<string> Categories { get; set; }

    [JsonPropertyName("metadata")]
    public Dictionary<string, object> Metadata { get; set; }
}

public class DecimalConverter : JsonConverter<decimal>
{
    public override decimal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        return reader.GetDecimal();
    }

    public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
    {
        writer.WriteNumberValue(Math.Round(value, 2));
    }
}
代码csharp中等

XML序列化和解析

使用XmlDocument、XDocument和XmlSerializer处理结构化数据

难度

6/10

预计时间

25 min

标签

csharp, xml, serialization, linq, windows

前置条件

C# basics, XML concepts, LINQ basics

csharp
using System;
using System.Collections.Generic;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
using System.Linq;

[XmlRoot("BookStore")]
public class BookStore
{
    [XmlElement("StoreName")]
    public string StoreName { get; set; }

    [XmlElement("Location")]
    public string Location { get; set; }

    [XmlElement("Books")]
    public List<Book> Books { get; set; } = new List<Book>();

    [XmlAttribute("Version")]
    public string Version { get; set; } = "1.0";
}

public class Book
{
    [XmlElement("Title")]
    public string Title { get; set; }

    [XmlElement("Author")]
    public string Author { get; set; }

    [XmlElement("ISBN")]
    public string ISBN { get; set; }

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

    [XmlElement("PublishedDate")]
    public DateTime PublishedDate { get; set; }

    [XmlElement("Genre")]
    public string Genre { get; set; }

    [XmlAttribute("BookId")]
    public int BookId { get; set; }

    [XmlElement("Tags")]
    public List<string> Tags { get; set; } = new List<string>();
}

class XMLSerialization
{
    // 1. XML Serialization using XmlSerializer
    public static void XMLSerializationExample()
    {
        Console.WriteLine("=== XML Serialization Example ===");

        // Create bookstore with sample data
        var bookstore = new BookStore
        {
            StoreName = "Tech Books Emporium",
            Location = "San Francisco, CA",
            Version = "2.1",
            Books = new List<Book>
            {
                new Book
                {
                    BookId = 1,
                    Title = "C# Programming Basics",
                    Author = "John Smith",
                    ISBN = "978-1-234567-89-0",
                    Price = 39.99m,
                    PublishedDate = new DateTime(2023, 1, 15),
                    Genre = "Programming",
                    Tags = new List<string> { "C#", "Programming", "Beginner" }
                },
                new Book
                {
                    BookId = 2,
                    Title = "Advanced Design Patterns",
                    Author = "Jane Johnson",
                    ISBN = "978-0-987654-32-1",
                    Price = 54.99m,
                    PublishedDate = new DateTime(2022, 8, 20),
                    Genre = "Software Engineering",
                    Tags = new List<string> { "Design Patterns", "Architecture", "Advanced" }
                },
                new Book
                {
                    BookId = 3,
                    Title = "Web Development with ASP.NET",
                    Author = "Mike Wilson",
                    ISBN = "978-1-555555-55-5",
                    Price = 49.99m,
                    PublishedDate = new DateTime(2023, 3, 10),
                    Genre = "Web Development",
                    Tags = new List<string> { "ASP.NET", "Web", "Backend" }
                }
            }
        };

        // Serialize to XML
        var xmlSerializer = new XmlSerializer(typeof(BookStore));

        using (var stringWriter = new StringWriter())
        {
            xmlSerializer.Serialize(stringWriter, bookstore);
            string xmlString = stringWriter.ToString();

            Console.WriteLine("Serialized XML:");
            Console.WriteLine(xmlString);

            // Save to file
            File.WriteAllText("bookstore.xml", xmlString);
            Console.WriteLine("\nXML saved to bookstore.xml file");
        }
    }

    // 2. XML Deserialization
    public static void XMLDeserializationExample()
    {
        Console.WriteLine("\n=== XML Deserialization Example ===");

        try
        {
            // Read XML from file
            string xmlString = File.ReadAllText("bookstore.xml");
            Console.WriteLine("Reading XML from file...");

            var xmlSerializer = new XmlSerializer(typeof(BookStore));

            using (var stringReader = new StringReader(xmlString))
            {
                BookStore bookstore = (BookStore)xmlSerializer.Deserialize(stringReader);

                Console.WriteLine("\nDeserialized BookStore:");
                Console.WriteLine($"Store Name: {bookstore.StoreName}");
                Console.WriteLine($"Location: {bookstore.Location}");
                Console.WriteLine($"Version: {bookstore.Version}");
                Console.WriteLine($"Total Books: {bookstore.Books.Count}");

                Console.WriteLine("\nBooks:");
                foreach (var book in bookstore.Books)
                {
                    Console.WriteLine($"\nBook ID: {book.BookId}");
                    Console.WriteLine($"Title: {book.Title}");
                    Console.WriteLine($"Author: {book.Author}");
                    Console.WriteLine($"ISBN: {book.ISBN}");
                    Console.WriteLine($"Price: ${book.Price:F2}");
                    Console.WriteLine($"Published: {book.PublishedDate:yyyy-MM-dd}");
                    Console.WriteLine($"Genre: {book.Genre}");
                    Console.WriteLine($"Tags: {string.Join(", ", book.Tags)}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error deserializing XML: {ex.Message}");
        }
    }

    // 3. Working with XDocument (LINQ to XML)
    public static void XDocumentOperations()
    {
        Console.WriteLine("\n=== XDocument Operations (LINQ to XML) ===");

        // Create XML document using XDocument
        XDocument doc = new XDocument(
            new XElement("Employees",
                new XElement("Employee",
                    new XAttribute("Id", "1"),
                    new XElement("Name", "Alice Johnson"),
                    new XElement("Department", "Engineering"),
                    new XElement("Position", "Senior Developer"),
                    new XElement("Salary", "95000"),
                    new XElement("HireDate", "2020-01-15"),
                    new XElement("Skills",
                        new XElement("Skill", "C#"),
                        new XElement("Skill", "JavaScript"),
                        new XElement("Skill", "SQL")
                    )
                ),
                new XElement("Employee",
                    new XAttribute("Id", "2"),
                    new XElement("Name", "Bob Smith"),
                    new XElement("Department", "Marketing"),
                    new XElement("Position", "Marketing Manager"),
                    new XElement("Salary", "85000"),
                    new XElement("HireDate", "2019-06-01"),
                    new XElement("Skills",
                        new XElement("Skill", "SEO"),
                        new XElement("Skill", "Analytics"),
                        new XElement("Skill", "Content Strategy")
                    )
                ),
                new XElement("Employee",
                    new XAttribute("Id", "3"),
                    new XElement("Name", "Carol White"),
                    new XElement("Department", "Engineering"),
                    new XElement("Position", "UX Designer"),
                    new XElement("Salary", "75000"),
                    new XElement("HireDate", "2021-03-10"),
                    new XElement("Skills",
                        new XElement("Skill", "UI Design"),
                        new XElement("Skill", "User Research"),
                        new XElement("Skill", "Prototyping")
                    )
                )
            )
        );

        Console.WriteLine("Created XDocument:");
        Console.WriteLine(doc.ToString());

        // Save to file
        doc.Save("employees.xml");
        Console.WriteLine("\nXDocument saved to employees.xml");

        // Query the XML document
        Console.WriteLine("\n=== Querying XML with LINQ ===");

        // Load the document
        XDocument loadedDoc = XDocument.Load("employees.xml");

        // Find all employees in Engineering department
        var engineeringEmployees = loadedDoc.Descendants("Employee")
            .Where(e => e.Element("Department").Value == "Engineering")
            .Select(e => new
            {
                Id = e.Attribute("Id").Value,
                Name = e.Element("Name").Value,
                Position = e.Element("Position").Value,
                Salary = decimal.Parse(e.Element("Salary").Value)
            });

        Console.WriteLine("Engineering Department Employees:");
        foreach (var emp in engineeringEmployees)
        {
            Console.WriteLine($"- {emp.Name} ({emp.Position}): ${emp.Salary:N0}");
        }

        // Find employees with specific skills
        var csharpDevelopers = loadedDoc.Descendants("Employee")
            .Where(e => e.Descendants("Skill").Any(s => s.Value == "C#"))
            .Select(e => e.Element("Name").Value);

        Console.WriteLine("\nC# Developers:");
        foreach (var dev in csharpDevelopers)
        {
            Console.WriteLine($"- {dev}");
        }
    }

    // 4. XmlDocument operations (traditional XML DOM)
    public static void XmlDocumentOperations()
    {
        Console.WriteLine("\n=== XmlDocument Operations ===");

        // Create XmlDocument
        XmlDocument xmlDoc = new XmlDocument();

        // Create root element
        XmlElement root = xmlDoc.CreateElement("Products");
        xmlDoc.AppendChild(root);

        // Add products
        var products = new[]
        {
            new { Id = "1", Name = "Laptop", Category = "Electronics", Price = "999.99", Stock = "50" },
            new { Id = "2", Name = "Mouse", Category = "Electronics", Price = "25.50", Stock = "200" },
            new { Id = "3", Name = "Keyboard", Category = "Electronics", Price = "75.00", Stock = "100" },
            new { Id = "4", Name = "Monitor", Category = "Electronics", Price = "299.99", Stock = "75" }
        };

        foreach (var product in products)
        {
            XmlElement productElement = xmlDoc.CreateElement("Product");
            productElement.SetAttribute("Id", product.Id);

            XmlElement nameElement = xmlDoc.CreateElement("Name");
            nameElement.InnerText = product.Name;
            productElement.AppendChild(nameElement);

            XmlElement categoryElement = xmlDoc.CreateElement("Category");
            categoryElement.InnerText = product.Category;
            productElement.AppendChild(categoryElement);

            XmlElement priceElement = xmlDoc.CreateElement("Price");
            priceElement.InnerText = product.Price;
            productElement.AppendChild(priceElement);

            XmlElement stockElement = xmlDoc.CreateElement("Stock");
            stockElement.InnerText = product.Stock;
            productElement.AppendChild(stockElement);

            root.AppendChild(productElement);
        }

        Console.WriteLine("Created XmlDocument:");
        Console.WriteLine(xmlDoc.OuterXml);

        // Save to file
        xmlDoc.Save("products.xml");
        Console.WriteLine("\nXmlDocument saved to products.xml");

        // Read and manipulate
        Console.WriteLine("\n=== Reading and Manipulating XmlDocument ===");

        XmlDocument loadedDoc = new XmlDocument();
        loadedDoc.Load("products.xml");

        // Get all product nodes
        XmlNodeList productNodes = loadedDoc.GetElementsByTagName("Product");

        Console.WriteLine($"Found {productNodes.Count} products:");

        decimal totalValue = 0;
        foreach (XmlNode node in productNodes)
        {
            string name = node["Name"].InnerText;
            decimal price = decimal.Parse(node["Price"].InnerText);
            int stock = int.Parse(node["Stock"].InnerText);

            Console.WriteLine($"- {name}: ${price:F2} (Stock: {stock})");
            totalValue += price * stock;
        }

        Console.WriteLine($"\nTotal inventory value: ${totalValue:N2}");

        // Modify an element
        XmlNode firstProduct = productNodes[0];
        firstProduct["Stock"].InnerText = "45";
        Console.WriteLine("\nUpdated first product stock to 45");

        // Add a new attribute
        XmlElement firstProductElement = (XmlElement)firstProduct;
        firstProductElement.SetAttribute("Status", "Available");
        Console.WriteLine("Added Status attribute to first product");

        // Save changes
        loadedDoc.Save("products_modified.xml");
        Console.WriteLine("\nModified XmlDocument saved to products_modified.xml");
    }

    // 5. XML transformation and validation
    public static void XMLTransformation()
    {
        Console.WriteLine("\n=== XML Transformation ===");

        // Create source XML
        string sourceXml = @"
<Orders>
    <Order OrderId='ORD-001'>
        <Customer>
            <Name>John Doe</Name>
            <Email>john@example.com</Email>
        </Customer>
        <Items>
            <Item ProductId='PROD-001' Name='Laptop' Quantity='1' Price='999.99' />
            <Item ProductId='PROD-002' Name='Mouse' Quantity='2' Price='25.50' />
        </Items>
    </Order>
    <Order OrderId='ORD-002'>
        <Customer>
            <Name>Jane Smith</Name>
            <Email>jane@example.com</Email>
        </Customer>
        <Items>
            <Item ProductId='PROD-003' Name='Keyboard' Quantity='1' Price='75.00' />
            <Item ProductId='PROD-004' Name='Monitor' Quantity='1' Price='299.99' />
        </Items>
    </Order>
</Orders>";

        XDocument sourceDoc = XDocument.Parse(sourceXml);

        // Transform to a summary format
        var transformedData = sourceDoc.Descendants("Order")
            .Select(order => new
            {
                OrderId = order.Attribute("OrderId").Value,
                CustomerName = order.Element("Customer").Element("Name").Value,
                CustomerEmail = order.Element("Customer").Element("Email").Value,
                Items = order.Descendants("Item").Count(),
                TotalAmount = order.Descendants("Item")
                    .Sum(item => decimal.Parse(item.Attribute("Price").Value) *
                                   int.Parse(item.Attribute("Quantity").Value))
            });

        // Create transformed XML
        XDocument transformedDoc = new XDocument(
            new XElement("OrderSummary",
                new XElement("GeneratedDate", DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss")),
                new XElement("TotalOrders", transformedData.Count()),
                new XElement("Orders",
                    transformedData.Select(order => new XElement("Order",
                        new XElement("OrderId", order.OrderId),
                        new XElement("Customer", order.CustomerName),
                        new XElement("Email", order.CustomerEmail),
                        new XElement("ItemCount", order.Items),
                        new XElement("TotalAmount", order.TotalAmount.ToString("F2"))
                    ))
                )
            )
        );

        Console.WriteLine("Transformed XML:");
        Console.WriteLine(transformedDoc.ToString());

        // Save transformation
        transformedDoc.Save("order_summary.xml");
        Console.WriteLine("\nTransformed XML saved to order_summary.xml");

        // Calculate statistics
        decimal grandTotal = transformedData.Sum(order => order.TotalAmount);
        double averageOrder = (double)grandTotal / transformedData.Count();

        Console.WriteLine("\n=== Order Statistics ===");
        Console.WriteLine($"Total Orders: {transformedData.Count()}");
        Console.WriteLine($"Grand Total: ${grandTotal:F2}");
        Console.WriteLine($"Average Order Value: ${averageOrder:F2}");
    }

    public static void RunAllExamples()
    {
        Console.WriteLine("XML Serialization Examples");
        Console.WriteLine("==========================");

        XMLSerializationExample();
        XMLDeserializationExample();
        XDocumentOperations();
        XmlDocumentOperations();
        XMLTransformation();

        Console.WriteLine("\nXML serialization examples completed!");
    }
}
代码csharp复杂

二进制和自定义序列化

二进制序列化、自定义格式化程序和性能关键应用程序的高级序列化模式

难度

8/10

预计时间

30 min

标签

csharp, binary, serialization, performance, windows

前置条件

C# advanced, Serialization concepts, Performance optimization

csharp
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text.Json;

[Serializable]
public class Product
{
    public int ProductId { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public DateTime CreatedDate { get; set; }
    public List<string> Categories { get; set; }

    [NonSerialized]
    public string InternalCode; // This won't be serialized

    public Product()
    {
        Categories = new List<string>();
        InternalCode = Guid.NewGuid().ToString("N");
    }

    public override string ToString()
    {
        return $"Product {ProductId}: {Name} - ${Price:F2} (Stock: {Stock})";
    }
}

[Serializable]
public class Order
{
    public int OrderId { get; set; }
    public string CustomerName { get; set; }
    public string CustomerEmail { get; set; }
    public DateTime OrderDate { get; set; }
    public List<OrderItem> Items { get; set; }
    public decimal TotalAmount { get; set; }
    public string Status { get; set; }

    public Order()
    {
        Items = new List<OrderItem>();
    }

    public void CalculateTotal()
    {
        TotalAmount = 0;
        foreach (var item in Items)
        {
            TotalAmount += item.Price * item.Quantity;
        }
    }
}

[Serializable]
public class OrderItem
{
    public string ProductId { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }

    [NonSerialized]
    public decimal Discount; // Won't be serialized
}

class BinarySerialization
{
    // 1. Basic Binary Serialization
    public static void BasicBinarySerialization()
    {
        Console.WriteLine("=== Basic Binary Serialization ===");

        try
        {
            // Create sample products
            var products = new List<Product>
            {
                new Product
                {
                    ProductId = 1,
                    Name = "Laptop Pro",
                    Description = "High-performance laptop for professionals",
                    Price = 1299.99m,
                    Stock = 25,
                    CreatedDate = DateTime.Now.AddDays(-30),
                    Categories = new List<string> { "Electronics", "Computers", "Professional" }
                },
                new Product
                {
                    ProductId = 2,
                    Name = "Wireless Mouse",
                    Description = "Ergonomic wireless mouse",
                    Price = 49.99m,
                    Stock = 150,
                    CreatedDate = DateTime.Now.AddDays(-15),
                    Categories = new List<string> { "Electronics", "Accessories", "Wireless" }
                },
                new Product
                {
                    ProductId = 3,
                    Name = "Mechanical Keyboard",
                    Description = "RGB mechanical keyboard",
                    Price = 129.99m,
                    Stock = 75,
                    CreatedDate = DateTime.Now.AddDays(-7),
                    Categories = new List<string> { "Electronics", "Input Devices", "Gaming" }
                }
            };

            // Binary serialization
            IFormatter formatter = new BinaryFormatter();

            using (var stream = new FileStream("products.bin", FileMode.Create))
            {
                formatter.Serialize(stream, products);
                Console.WriteLine("Products serialized to binary file");
            }

            // Get file size for comparison
            FileInfo fileInfo = new FileInfo("products.bin");
            Console.WriteLine($"Binary file size: {fileInfo.Length} bytes");

            // Display products before serialization
            Console.WriteLine("\nOriginal Products:");
            foreach (var product in products)
            {
                Console.WriteLine($"- {product} (Internal Code: {product.InternalCode})");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in binary serialization: {ex.Message}");
        }
    }

    // 2. Binary Deserialization
    public static void BasicBinaryDeserialization()
    {
        Console.WriteLine("\n=== Binary Deserialization ===");

        try
        {
            IFormatter formatter = new BinaryFormatter();

            using (var stream = new FileStream("products.bin", FileMode.Open))
            {
                var deserializedProducts = (List<Product>)formatter.Deserialize(stream);
                Console.WriteLine($"Deserialized {deserializedProducts.Count} products");

                Console.WriteLine("\nDeserialized Products:");
                foreach (var product in deserializedProducts)
                {
                    Console.WriteLine($"- {product} (Internal Code: {product.InternalCode ?? "NULL"})");
                    Console.WriteLine($"  Categories: {string.Join(", ", product.Categories)}");
                    Console.WriteLine($"  Created: {product.CreatedDate:yyyy-MM-dd HH:mm:ss}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in binary deserialization: {ex.Message}");
        }
    }

    // 3. Performance comparison: Binary vs JSON
    public static void SerializationPerformanceComparison()
    {
        Console.WriteLine("\n=== Serialization Performance Comparison ===");

        // Create a large dataset
        var largeDataSet = new List<Order>();
        var random = new Random();

        for (int i = 1; i <= 1000; i++)
        {
            var order = new Order
            {
                OrderId = i,
                CustomerName = $"Customer {i}",
                CustomerEmail = $"customer{i}@example.com",
                OrderDate = DateTime.Now.AddDays(-random.Next(0, 365)),
                Status = "Processing"
            };

            // Add random items to each order
            int itemCount = random.Next(1, 6);
            for (int j = 1; j <= itemCount; j++)
            {
                order.Items.Add(new OrderItem
                {
                    ProductId = $"PROD-{random.Next(1, 100):000}",
                    ProductName = $"Product {random.Next(1, 500)}",
                    Quantity = random.Next(1, 5),
                    Price = (decimal)(random.NextDouble() * 500 + 10)
                });
            }

            order.CalculateTotal();
            largeDataSet.Add(order);
        }

        Console.WriteLine($"Created dataset with {largeDataSet.Count} orders");

        // Binary serialization performance
        var binaryStopwatch = System.Diagnostics.Stopwatch.StartNew();
        long binarySize = 0;

        using (var stream = new MemoryStream())
        {
            IFormatter formatter = new BinaryFormatter();
            formatter.Serialize(stream, largeDataSet);
            binarySize = stream.Length;
        }
        binaryStopwatch.Stop();

        // JSON serialization performance
        var jsonStopwatch = System.Diagnostics.Stopwatch.StartNew();
        long jsonSize = 0;

        var jsonOptions = new JsonSerializerOptions
        {
            WriteIndented = false // Minified for fair comparison
        };
        string jsonString = JsonSerializer.Serialize(largeDataSet, jsonOptions);
        jsonSize = System.Text.Encoding.UTF8.GetByteCount(jsonString);
        jsonStopwatch.Stop();

        Console.WriteLine("\nPerformance Results:");
        Console.WriteLine($"Binary Serialization:");
        Console.WriteLine($"  Time: {binaryStopwatch.ElapsedMilliseconds} ms");
        Console.WriteLine($"  Size: {binarySize:N0} bytes");

        Console.WriteLine($"JSON Serialization:");
        Console.WriteLine($"  Time: {jsonStopwatch.ElapsedMilliseconds} ms");
        Console.WriteLine($"  Size: {jsonSize:N0} bytes");

        double sizeRatio = (double)jsonSize / binarySize;
        double timeRatio = (double)jsonStopwatch.ElapsedMilliseconds / binaryStopwatch.ElapsedMilliseconds;

        Console.WriteLine($"\nComparison:");
        Console.WriteLine($"  Size Ratio (JSON/Binary): {sizeRatio:F2}");
        Console.WriteLine($"  Time Ratio (JSON/Binary): {timeRatio:F2}");
    }

    // 4. Custom serialization with ISerializable
    public static void CustomSerialization()
    {
        Console.WriteLine("\n=== Custom Serialization Example ===");

        try
        {
            // Create a custom serializable object
            var sensitiveData = new SensitiveDocument
            {
                DocumentId = "DOC-001",
                Title = "Confidential Report",
                Content = "This is sensitive information that should be encrypted",
                Author = "John Doe",
                CreatedDate = DateTime.Now.AddDays(-10),
                AccessLevel = 5,
                Tags = new List<string> { "Confidential", "Internal", "Restricted" }
            };

            Console.WriteLine("Original SensitiveDocument:");
            Console.WriteLine($"ID: {sensitiveData.DocumentId}");
            Console.WriteLine($"Title: {sensitiveData.Title}");
            Console.WriteLine($"Content: {sensitiveData.Content}");
            Console.WriteLine($"Author: {sensitiveData.Author}");
            Console.WriteLine($"Access Level: {sensitiveData.AccessLevel}");

            // Serialize using custom method
            IFormatter formatter = new BinaryFormatter();

            using (var stream = new FileStream("sensitive_doc.bin", FileMode.Create))
            {
                formatter.Serialize(stream, sensitiveData);
                Console.WriteLine("\nSensitiveDocument serialized with custom logic");
            }

            // Deserialize
            using (var stream = new FileStream("sensitive_doc.bin", FileMode.Open))
            {
                var deserializedDoc = (SensitiveDocument)formatter.Deserialize(stream);

                Console.WriteLine("\nDeserialized SensitiveDocument:");
                Console.WriteLine($"ID: {deserializedDoc.DocumentId}");
                Console.WriteLine($"Title: {deserializedDoc.Title}");
                Console.WriteLine($"Content: {deserializedDoc.Content}");
                Console.WriteLine($"Author: {deserializedDoc.Author}");
                Console.WriteLine($"Access Level: {deserializedDoc.AccessLevel}");
                Console.WriteLine($"Deserialization Count: {deserializedDoc.DeserializationCount}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in custom serialization: {ex.Message}");
        }
    }

    // 5. Streaming serialization for large datasets
    public static void StreamingSerialization()
    {
        Console.WriteLine("\n=== Streaming Serialization Example ===");

        try
        {
            // Create large dataset
            var sensorData = new List<SensorReading>();
            var random = new Random();

            Console.WriteLine("Generating sensor data...");
            for (int i = 0; i < 10000; i++)
            {
                sensorData.Add(new SensorReading
                {
                    Timestamp = DateTime.Now.AddSeconds(-i),
                    SensorId = $"SENSOR-{(i % 10 + 1):D2}",
                    Temperature = 20 + random.NextDouble() * 15,
                    Humidity = 30 + random.NextDouble() * 40,
                    Pressure = 980 + random.NextDouble() * 50,
                    Location = $"Location-{(i % 5 + 1)}"
                });
            }

            Console.WriteLine($"Generated {sensorData.Count} sensor readings");

            // Stream serialization
            Console.WriteLine("\nPerforming streaming serialization...");
            var streamingStopwatch = System.Diagnostics.Stopwatch.StartNew();

            using (var stream = new FileStream("sensor_data_stream.bin", FileMode.Create))
            {
                using (var writer = new BinaryWriter(stream))
                {
                    // Write header
                    writer.Write(sensorData.Count);
                    writer.Write(DateTime.Now.ToBinary());

                    // Stream each reading individually
                    foreach (var reading in sensorData)
                    {
                        writer.Write(reading.Timestamp.ToBinary());
                        writer.Write(reading.SensorId ?? string.Empty);
                        writer.Write(reading.Temperature);
                        writer.Write(reading.Humidity);
                        writer.Write(reading.Pressure);
                        writer.Write(reading.Location ?? string.Empty);
                    }
                }
            }
            streamingStopwatch.Stop();

            var streamSize = new FileInfo("sensor_data_stream.bin").Length;
            Console.WriteLine($"Streaming serialization completed in {streamingStopwatch.ElapsedMilliseconds} ms");
            Console.WriteLine($"Stream size: {streamSize:N0} bytes");

            // Stream deserialization
            Console.WriteLine("\nPerforming streaming deserialization...");
            streamingStopwatch.Restart();

            var deserializedReadings = new List<SensorReading>();

            using (var stream = new FileStream("sensor_data_stream.bin", FileMode.Open))
            {
                using (var reader = new BinaryReader(stream))
                {
                    // Read header
                    int count = reader.ReadInt32();
                    DateTime createdDate = DateTime.FromBinary(reader.ReadInt64());

                    // Read each reading
                    for (int i = 0; i < count; i++)
                    {
                        deserializedReadings.Add(new SensorReading
                        {
                            Timestamp = DateTime.FromBinary(reader.ReadInt64()),
                            SensorId = reader.ReadString(),
                            Temperature = reader.ReadDouble(),
                            Humidity = reader.ReadDouble(),
                            Pressure = reader.ReadDouble(),
                            Location = reader.ReadString()
                        });
                    }
                }
            }
            streamingStopwatch.Stop();

            Console.WriteLine($"Streaming deserialization completed in {streamingStopwatch.ElapsedMilliseconds} ms");
            Console.WriteLine($"Deserialized {deserializedReadings.Count} readings");

            // Show sample data
            Console.WriteLine("\nSample readings:");
            for (int i = 0; i < Math.Min(5, deserializedReadings.Count; i++)
            {
                var reading = deserializedReadings[i];
                Console.WriteLine($"  {reading.Timestamp:HH:mm:ss} - {reading.SensorId}: {reading.Temperature:F1}°C, {reading.Humidity:F1}%");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error in streaming serialization: {ex.Message}");
        }
    }

    public static void RunAllExamples()
    {
        Console.WriteLine("Binary and Custom Serialization Examples");
        Console.WriteLine("=========================================");

        BasicBinarySerialization();
        BasicBinaryDeserialization();
        SerializationPerformanceComparison();
        CustomSerialization();
        StreamingSerialization();

        Console.WriteLine("\nBinary serialization examples completed!");
    }
}

[Serializable]
public class SensitiveDocument : ISerializable
{
    public string DocumentId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public string Author { get; set; }
    public DateTime CreatedDate { get; set; }
    public int AccessLevel { get; set; }
    public List<string> Tags { get; set; }

    [NonSerialized]
    public int DeserializationCount;

    public SensitiveDocument()
    {
        Tags = new List<string>();
    }

    // Custom serialization constructor
    protected SensitiveDocument(SerializationInfo info, StreamingContext context)
    {
        DocumentId = info.GetString("DocumentId");
        Title = info.GetString("Title");
        Author = info.GetString("Author");
        CreatedDate = info.GetDateTime("CreatedDate");
        AccessLevel = info.GetInt32("AccessLevel");
        Tags = (List<string>)info.GetValue("Tags", typeof(List<string>));

        // Custom logic: "encrypt" content during serialization
        string encryptedContent = info.GetString("EncryptedContent");
        Content = DecryptContent(encryptedContent);

        DeserializationCount++;
    }

    // Custom serialization method
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("DocumentId", DocumentId);
        info.AddValue("Title", Title);
        info.AddValue("Author", Author);
        info.AddValue("CreatedDate", CreatedDate);
        info.AddValue("AccessLevel", AccessLevel);
        info.AddValue("Tags", Tags);

        // Custom logic: "encrypt" sensitive content
        string encryptedContent = EncryptContent(Content);
        info.AddValue("EncryptedContent", encryptedContent);
    }

    private string EncryptContent(string content)
    {
        // Simple "encryption" for demonstration (XOR with a key)
        char[] chars = content.ToCharArray();
        for (int i = 0; i < chars.Length; i++)
        {
            chars[i] = (char)(chars[i] ^ 0x55);
        }
        return new string(chars);
    }

    private string DecryptContent(string encryptedContent)
    {
        // Reverse the encryption
        char[] chars = encryptedContent.ToCharArray();
        for (int i = 0; i < chars.Length; i++)
        {
            chars[i] = (char)(chars[i] ^ 0x55);
        }
        return new string(chars);
    }
}

[Serializable]
public class SensorReading
{
    public DateTime Timestamp { get; set; }
    public string SensorId { get; set; }
    public double Temperature { get; set; }
    public double Humidity { get; set; }
    public double Pressure { get; set; }
    public string Location { get; set; }
}

工具

经常与该案例搭配使用的工具

相关内容

相关案例集合

相关内容

相关专题

专题

容器发布前的 Dockerfile 与环境配置审查

检查 Dockerfile 规则、镜像引用格式与环境变量重复键,解释预发布和生产配置差异,形成可核对的容器发布记录。

专题

域名上线前的 DNS、DNSSEC 与 HTTPS 验收

先拟定 DNS 区域记录,再核对在线解析、DNSSEC 委派和实际提供的 HTTPS 证书,为域名上线留下可复核的依据。

专题

重复日历与 ICS 日程安排

跨时区规划并验证重复会议,处理工作日、节假日、冲突和 ICS 导出要求。

专题

API Mock 夹具生成与审阅

生成可重复的 Mock 负载,构造符合格式的边界值,发现易混淆字段名,并在共享临时 Mock 服务前完成复核。

首页
工具3212
案例593
可视化471
文件查看器103
专题239
标签333
图像、音频与视频657

图像、音频、视频处理、转换与优化工具

数学、日期与金融647

计算器、数值计算、日期逻辑、统计与金融工具

设计与颜色298

颜色、版式、图形、视觉样式与设计辅助工具

文本与写作209

写作、清洗、格式化、提取与文本分析工具

开发与 Web193

开发者工具、网络处理、Web 调试与自动化辅助工具

转换与编码175

格式、文件、压缩包、单位与编码转换工具

潜客测验发布与联系人交接
讣告、悼词与纪念卡的家属复核及交付
本地习惯记录的备份、恢复演练与分享前检查
长文改编 X 串文与 LinkedIn 帖子的事实复核与交付
Markdown 互动课件审校、离线演示与交付

© 2026 Elysia Tools. 保留所有权利。

文档价格关于我们服务条款隐私政策Cookie 政策联系我们

Format Conversion

JSON转XML转换器

将JSON数据转换为XML格式,支持自定义格式化选项

Format Conversion

XML转JSON转换器

将XML数据转换为JSON格式,支持自定义解析选项

Development

游戏存档查看器

拖入任意游戏存档——Minecraft NBT、虚幻引擎 GVAS、幻兽帕鲁容器、JSON/XML/INI/Lua 文本存档、SQLite 档案——识别格式、引擎版本、关键进度字段并给出有界的结构树。

Development

SBOM SPDX / CycloneDX 许可证策略审计器

审计 SPDX 2.3 或 CycloneDX 1.5 组件许可证,输出 SARIF 和失败依赖链

Format Conversion

XLSX 迷你图注入器

通过修改工作表 XML 向 Excel 单元格中插入 Sparkline 迷你图

Data Processing

AI数据规范化器

AI驱动的数据格式规范化工具,使用高级AI分析智能清理和标准化混乱数据

Data Processing

数据规范化器

基于代码逻辑的数据格式规范化工具,使用程序化方法清理和标准化混乱数据

Format Conversion

Excel转JSON转换器

将Excel文件转换为JSON格式,提取第一个工作表的数据

Java

Android Java 序列化示例

Android Java 序列化示例,包括JSON序列化、反序列化和XML解析

Kotlin

Android Kotlin 序列化示例

Android Kotlin 序列化示例,包括JSON序列化、反序列化和XML解析

Python

Web Python 数据序列化示例

Web Python 数据序列化示例,包括JSON和XML处理

C++

Windows C++ 序列化示例

Windows C++ 数据序列化示例,包括JSON序列化/反序列化和XML解析

Objective-C

macOS Objective-C 序列化示例

macOS Objective-C 序列化示例,包括JSON序列化、JSON反序列化和XML解析

Go

Web Go 数据序列化示例

Web Go 数据序列化示例,包括JSON编码/解码和XML解析