如何批量重置C#中数百个标签变量的默认值？

我开发了一个C#应用，用于连接选定机器的控制系统并读取多个标签与数据。针对这些标签和数据，我定义了数百个不同类型（INT、STRING、REAL等）的变量。在断开当前机器连接并切换至另一台机器前，需将这些变量恢复为默认值。目前我在调用Disconnect方法时逐个设置默认值，但因数量过多难以维护。

是否有更简便的实现方式？有人建议使用struct，但我了解到struct无法定义默认值。请问使用struct是否为合适的解决方案？您有什么建议？

现有代码：

public class TagService
{
    public int Tag1=0;
    public int Tag2=0;
    public float Tag3=1;
    public string Tag4="";
    // few hundred Tags   

    public void Disconnect()
    {
        Delete_UserTags();
    }

    public void Delete_UserTags()
    {
        Tag1=0;
        Tag2=0;
        Tag3=0;
        Tag4="";
        //setting all the few hundred tags to their initial value one by one
    }
}

一、关于struct的可行性 #

struct并非不能设置初始值：

• C# 10及以上版本支持直接在struct字段声明时赋值（如public float Tag3 = 1;），创建struct实例时字段会自动使用你定义的初始值。
• 若使用C# 10之前的版本，struct的默认构造函数会将字段设为类型默认值（如int=0、string=null），此时需通过自定义带参构造函数设置初始值，但这需要手动初始化所有字段，和你现在逐个赋值的问题一样，维护成本高。

所以如果你的项目基于C# 10+，struct是可行的解决方案；否则不推荐。

二、推荐的实现方案 #

1. 类封装标签集合 + 实例替换（最简洁高效） #

把所有标签字段封装到一个独立的类中，断开连接时直接创建该类的新实例替换原有实例，一次性完成所有标签的重置。

代码示例：

// 封装所有标签的类
public class TagCollection
{
    public int Tag1 = 0;
    public int Tag2 = 0;
    public float Tag3 = 1;
    public string Tag4 = "";
    // 其他数百个标签按同样方式声明
}

public class TagService
{
    // 持有标签集合实例
    private TagCollection _tags = new TagCollection();

    // 外部访问标签时通过_tags.TagX的方式，需要修改标签值可添加setter
    public int Tag1 { get => _tags.Tag1; set => _tags.Tag1 = value; }
    public int Tag2 { get => _tags.Tag2; set => _tags.Tag2 = value; }
    public float Tag3 { get => _tags.Tag3; set => _tags.Tag3 = value; }
    public string Tag4 { get => _tags.Tag4; set => _tags.Tag4 = value; }

    public void Disconnect()
    {
        // 直接替换实例，所有标签自动回到初始值
        _tags = new TagCollection();
        Delete_UserTags();
    }

    public void Delete_UserTags()
    {
        // 保留其他非标签的清理逻辑
    }
}

优势：后续新增/删除标签只需修改TagCollection，无需维护重置逻辑；性能无开销，代码可读性高。

2. struct标签容器（适合C# 10+项目） #

和类封装的思路一致，只是用struct替代类。由于C# 10支持struct字段初始化，创建新实例时会自动应用你定义的初始值。

代码示例：

public struct TagCollection
{
    public int Tag1 = 0;
    public int Tag2 = 0;
    public float Tag3 = 1;
    public string Tag4 = "";
    // 其他数百个标签
}

public class TagService
{
    private TagCollection _tags = new TagCollection();

    // 暴露标签供外部访问/修改
    public ref int Tag1 => ref _tags.Tag1;
    public ref int Tag2 => ref _tags.Tag2;
    public ref float Tag3 => ref _tags.Tag3;
    public ref string Tag4 => ref _tags.Tag4;

    public void Disconnect()
    {
        // 重新实例化struct完成重置
        _tags = new TagCollection();
    }
}

注意：struct是值类型，赋值时会产生拷贝，但这里仅在重置时创建新实例，对性能影响可忽略。

3. 反射自动重置（无需大规模重构现有代码） #

如果不想改动现有字段的结构，可以用反射遍历所有字段，结合特性标记初始值来自动重置。

步骤1：定义标记初始值的特性

[AttributeUsage(AttributeTargets.Field)]
public class DefaultValueAttribute : Attribute
{
    public object Value { get; }
    public DefaultValueAttribute(object value) => Value = value;
}

步骤2：修改TagService实现自动重置

public class TagService
{
    private readonly Dictionary<string, object> _defaultValues = new();

    [DefaultValue(0)]
    public int Tag1 = 0;
    [DefaultValue(0)]
    public int Tag2 = 0;
    [DefaultValue(1)]
    public float Tag3 = 1;
    [DefaultValue("")]
    public string Tag4 = "";
    // 其他数百个标签添加对应特性

    public TagService()
    {
        // 初始化时保存所有字段的默认值
        var fields = GetType().GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
        foreach (var field in fields)
        {
            var attr = field.GetCustomAttribute<DefaultValueAttribute>();
            _defaultValues[field.Name] = attr?.Value ?? Activator.CreateInstance(field.FieldType);
        }
    }

    public void Disconnect()
    {
        ResetTagsToDefault();
        Delete_UserTags();
    }

    private void ResetTagsToDefault()
    {
        var fields = GetType().GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
        foreach (var field in fields)
        {
            if (_defaultValues.TryGetValue(field.Name, out var defaultValue))
            {
                field.SetValue(this, defaultValue);
            }
        }
    }

    public void Delete_UserTags()
    {
        // 其他清理逻辑
    }
}

优势：无需重构现有字段结构，仅需添加特性标记；缺点：反射存在轻微性能开销，几百个字段的场景下可忽略，但比实例替换方式略慢。

总结建议 #

• 优先选择类封装+实例替换的方案，维护成本最低，代码最简洁。
• 若项目基于C# 10+，struct也是可行选项，但类的灵活性更强（比如后续可添加方法、继承等）。
• 若无法大规模重构现有代码，反射方案能快速减少手动维护工作量。

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