C# 当两个结构都是相同的未知类型时，是否可以将它们复制到另一个结构

这是我的第一次尝试。我希望Fill（）中的最后一条语句可以进行成员复制，但事实上什么都没有发生。问题无疑是赋值中的类型在编译时是未知的。我的意图是在单元测试中使用一个按类型键入的结构字典。如果不在我的类中添加关于各种单独结构的知识，这可能是不可能的

internal class TestData
{
    private static Dictionary<Type, ValueType> mTestData = new Dictionary<Type, ValueType>();

    internal static void Add(ValueType _testData)
    {
        mTestData.Add(_testData.GetType(), _testData);
    }

    internal static void Fill(ValueType _runtimeData)
    {
        ValueType testData = mTestData[_runtimeData.GetType()];
        _runtimeData = testData;
    }
}

内部类TestData
{
私有静态字典mTestData=new Dictionary（）；
内部静态无效添加（ValueType\u testData）
{
添加（_testData.GetType（），_testData）；
}
内部静态空白填充（ValueType\u runtimeData）
{
ValueType testData=mTestData[_runtimeData.GetType（）]；
_runtimeData=testData；
}
}

您的代码中有几个错误。值类型在作为参数传递并从函数返回时被复制：

在

Add（ValueType\u testData）

中，变量

\u testData

将是传递参数的

ValueType

字段的副本

\u testData.GetType（）

将始终返回

typeof（ValueType）

\u runtimeData=testData

修改局部变量

\u runtimeData

，但不能修改传递的参数

重新考虑使用泛型和装箱值类型。下面是代码的工作修改

internal class TestData
{
    private static Dictionary<Type, object> mTestData = new Dictionary<Type, object>();

    internal static void Add<T>(T _testData) where T: ValueType, struct
    {
        mTestData.Add(typeof(T), _testData);
    }

    internal static void Fill<T>(ref T _runtimeData) where T: ValueType, struct
    {
        T testData = (T)mTestData[typeof(T)];
        _runtimeData = testData;
    }
}

内部类TestData
{
私有静态字典mTestData=new Dictionary（）；
内部静态void Add（T_testData），其中T:ValueType，struct
{
mTestData.Add（类型（T），_testData）；
}
内部静态空白填充（参考T_runtimeData），其中T:ValueType，struct
{
T testData=（T）mTestData[typeof（T）]；
_runtimeData=testData；
}
}

对我来说，有效的方法是返回结果：

internal static ValueType Fill(ValueType _runtimeData)
{
    return mTestData[_runtimeData.GetType()];
}

这样称呼它：

parms = (NewRuleParms)TestData.Fill(parms);

---

#2不是这样。我在调试器中停下来，检查字典条目。键是参数的特定结构名称。是否确定

ValueType

为结构？是。其想法是，在开发测试用例时，将使用各种结构。目标代码定义了它们，如果测试代码能够实例化、填充一些数据并运行就好了。在后面，如果不是在测试中，使用它的类将从用户输入填充它，否则将其结构传递给这个。而且，是的，在这里我可以像使用结构一样使用类，即使下面发生了不同的事情。