C#类元组结构异构数据的磁盘存储优化方案咨询

结合你的需求——既要节省磁盘空间，又要保证字段访问性能，同时避免手动维护大量字段组合类的重复劳动，推荐以下几个实用方案：

方案1：强类型派生类+支持可选字段的二进制序列化（最推荐） #

核心思路：定义包含公共字段的基类，针对不同事件类型派生仅含必要字段的子类，使用支持仅序列化非空字段的二进制序列化框架（如Protobuf-net），既保证强类型访问的高性能，又彻底避免空字段占用空间。

代码示例 #

// 公共基类：包含所有事件必有的字段
[ProtoContract]
public abstract class EventBase
{
    [ProtoMember(1, IsRequired = true)]
    public DateTime EventTime { get; set; }

    [ProtoMember(2, IsRequired = true)]
    public EventTag Tag { get; set; }
}

// 针对"Tom遇见Jack"的事件类
[ProtoContract]
public class PersonMeetingEvent : EventBase
{
    [ProtoMember(3)] // IsRequired默认false，仅当非空时序列化
    public Person Person1 { get; set; }

    [ProtoMember(4)]
    public Person Person2 { get; set; }
}

// 针对"农场下雨"的事件类
[ProtoContract]
public class RainEvent : EventBase
{
    [ProtoMember(3)]
    public Location FarmLocation { get; set; }
}

优势 #

• 空间效率：二进制序列化+可选字段，空字段完全不写入磁盘，比JSON/XML节省70%以上空间；
• 访问性能：强类型直接访问属性，无需反射或接口调用的额外开销；
• 维护成本：仅需为每种事件类型编写少量代码，无需手动实现统一接口。

序列化/反序列化示例 #

// 序列化到磁盘
using var stream = File.OpenWrite("events.dat");
Serializer.Serialize(stream, new PersonMeetingEvent 
{ 
    EventTime = DateTime.Now, 
    Tag = EventTag.Meeting, 
    Person1 = new Person("Tom"), 
    Person2 = new Person("Jack") 
});

// 反序列化（可通过类型标识自动匹配子类）
using var readStream = File.OpenRead("events.dat");
var evt = Serializer.Deserialize<EventBase>(readStream);
if (evt is PersonMeetingEvent meetingEvt)
{
    // 直接访问强类型字段
    Console.WriteLine($"{meetingEvt.Person1.Name} met {meetingEvt.Person2.Name}");
}

方案2：T4代码生成自动生成字段组合类 #

如果必须保留统一接口（如IFields）的访问方式，可通过T4模板自动生成所有需要的字段组合类，彻底消除手动编写重复代码的工作量。

T4模板示例 #

<#@ template language="C#" #>
<#@ output extension=".cs" #>
namespace YourApp.Events
{
    public interface IFields
    {
        DateTime GetTime();
        Location? GetLocation();
        List<Person>? GetPersons();
        EventTag GetTag();
    }

<# // 配置所有需要的字段组合
var fieldCombos = new[] {
    new { ClassName = "TimeTwoPersonEvent", HasTime=true, HasLocation=false, HasPersons=true, PersonCount=2 },
    new { ClassName = "TimeLocationEvent", HasTime=true, HasLocation=true, HasPersons=false }
};

foreach(var combo in fieldCombos) { #>
    public class <#= combo.ClassName #> : IFields
    {
        private readonly DateTime _time;
        private readonly EventTag _tag;
<# if(combo.HasLocation) { #>
        private readonly Location _location;
<# } #>
<# if(combo.HasPersons) { #>
        private readonly List<Person> _persons;
<# } #>

        public <#= combo.ClassName #>(DateTime time, EventTag tag<# if(combo.HasLocation) { #>, Location location<# } #><# if(combo.HasPersons) { #>, List<Person> persons<# } #>)
        {
            _time = time;
            _tag = tag;
<# if(combo.HasLocation) { #>
            _location = location;
<# } #>
<# if(combo.HasPersons) { #>
            _persons = persons;
<# } #>
        }

        public DateTime GetTime() => _time;
        public EventTag GetTag() => _tag;
<# if(combo.HasLocation) { #>
        public Location? GetLocation() => _location;
<# } else { #>
        public Location? GetLocation() => null;
<# } #>
<# if(combo.HasPersons) { #>
        public List<Person>? GetPersons() => _persons;
<# } else { #>
        public List<Person>? GetPersons() => null;
<# } #>
    }
<# } #>
}

优势 #

• 完全保留统一接口的访问方式，符合你原有的架构习惯；
• 仅需配置字段组合，自动生成所有类，零重复劳动；
• 强类型实现，访问性能与手动编写的类一致。

方案3：键值对+类型标识（适合极端多字段组合场景） #

如果字段组合数量极大（超过10种），且对访问性能要求略宽松，可使用结构化键值对存储，每个事件仅存储存在的字段，同时加入类型标识用于读取时解析。

代码示例 #

public struct EventData
{
    public DateTime EventTime { get; set; }
    public EventTag Tag { get; set; }
    public Dictionary<string, object> Fields { get; set; } = new();
}

// 存储"Tom遇见Jack"
var meetingData = new EventData
{
    EventTime = DateTime.Now,
    Tag = EventTag.Meeting,
    Fields = { {"Person1", new Person("Tom")}, {"Person2", new Person("Jack")} }
};

// 读取时强转访问
if (meetingData.Fields.TryGetValue("Person1", out var obj) && obj is Person p1)
{
    Console.WriteLine(p1.Name);
}

注意 #

• 需使用二进制序列化字典（如Protobuf-net支持字典序列化），避免JSON键名占用额外空间；
• 访问时需要类型转换，性能略低于强类型方案，适合字段组合极多的场景。

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