使用 LINQ 创建 List其中 T : someClass;

Answer 1

这是一个可行的解决方案：（您必须为 Type 属性指定完全限定的类型名称，否则您必须以某种方式配置映射...）

我使用了动态关键字，如果您没有，则可以使用反射来设置值C#4...

public static void Test()
{
    string xmlData = "<root><Name1 Type=\"System.String\">Value1</Name1><Name2 Type=\"System.Int32\">324</Name2></root>";

    List<DataField> dataFieldList = DataField.ConvertXML(xmlData);

    Debug.Assert(dataFieldList.Count == 2);
    Debug.Assert(dataFieldList[0].GetType() == typeof(DataField<string>));
    Debug.Assert(dataFieldList[1].GetType() == typeof(DataField<int>));
}

public abstract class DataField
{
    public string Name { get; set; }

    /// <summary>
    /// Instanciate a generic DataField<T> given an XElement
    /// </summary>
    public static DataField CreateDataField(XElement element)
    {
        //Determine the type of element we deal with
        string elementTypeName = element.Attribute("Type").Value;
        Type elementType = Type.GetType(elementTypeName);

        //Instanciate a new Generic element of type: DataField<T>
        dynamic dataField = Activator.CreateInstance(typeof(DataField<>).MakeGenericType(elementType));
        dataField.Name = element.Name.ToString();

        //Convert the inner value to the target element type
        dynamic value = Convert.ChangeType(element.Value, elementType);

        //Set the value into DataField
        dataField.Value = value;

        return dataField;
    }

    /// <summary>
    /// Take all the descendant of the root node and creates a DataField for each
    /// </summary>
    public static List<DataField> ConvertXML(string xmlData)
    {
        var result = (from d in XDocument.Parse(xmlData).Root.DescendantNodes().OfType<XElement>()
                      select CreateDataField(d)).ToList();

        return result;
    }
}

public class DataField<T> : DataField
{
    public T Value { get; set; }
}

Answer 2

在 C# 中无法轻松做到这一点。必须在编译时指定泛型类型参数。您可以使用反射来执行其他操作。

int X = 1;
Type listype = typeof(List<>);
Type constructed = listype.MakeGenericType(  X.GetType()  );
object runtimeList = Activator.CreateInstance(constructed);

这里我们刚刚创建了一个List。你可以用你的类型来做。

Answer 3

泛型类的不同实例实际上是不同的类。
即 DataField 和 DataField 根本不是同一个类（！）

这意味着，您不能在运行时定义通用参数，因为它必须在编译时确定。

Answer 4

我想说这是一个糟糕的方法。实际上，即使在解析 XML 文件之后，您也不会知道您拥有什么类型的“DataFields”。您不妨将它们解析为对象。

但是，如果您知道只会有 x 种类型，则可以这样做：

var Dictionary<string, Func<string, string, DataField>> myFactoryMaps =
{
    {"Type1", (name, value) => { return new DataField<Type1>(name, Type1.Parse(value); } },
    {"Type2", (name, value) => { return new DataField<Type2>(name, Type2.Parse(value); }  },
};

Answer 5

特米特的回答当然非常好。这是一个小变体。

     public abstract class DataField
        {
                public string Name { get; set; }
        }

        public class DataField<T> : DataField
        {
                public T Value { get; set; }
                public Type GenericType { get { return this.Value.GetType(); } }
        }

        static Func<XElement , DataField> dfSelector = new Func<XElement , DataField>( e =>
        {
                string strType = e.Attribute( "type" ).Value;
                //if you dont have an attribute type, you could call an extension method to figure out the type (with regex patterns)
                //that would only work for struct
                Type type = Type.GetType( strType );
                dynamic df = Activator.CreateInstance( typeof( DataField<>).MakeGenericType( type ) );

                df.Name = e.Attribute( "name" ).Value;
                dynamic value = Convert.ChangeType( e.Value , type );
                df.Value = value;
                return df;
        } );

        public static List<DataField> ConvertXML( string xmlstring )
        {
                var result = XDocument.Parse( xmlstring )
                                        .Root.Descendants("object")
                                        .Select( dfSelector )
                                        .ToList();
                return result;
        }


        static void Main( string[] args )
        {
                string xml = "<root><object name=\"im1\" type=\"System.String\">HelloWorld!</object><object name=\"im2\" type=\"System.Int32\">324</object></root>";

                List<DataField> dfs = ConvertXML( xml );
        }

Answer 6

您可以通过反射创建泛型类型

    var instance = Activator.CreateInstance( typeof(DataField)
                         .MakeGenericType(Type.GetType(typeNameFromAttribute) );
    // and here set properties also by reflection

Answer 7

@Termit 和 @Burnzy 提出了涉及工厂方法的良好解决方案。

这样做的问题是，您正在为可疑的返回加载大量额外的逻辑（更多测试，更多错误）的解析例程。

另一种方法是使用带有类型读取方法的简化的基于字符串的 DataField -

类型化值方法的实现，该方法很好，但仅适用于值类型（不包括字符串，但包括日期时间）：

public T? TypedValue<T>()
    where T : struct
{
    try { return (T?) Convert.ChangeType(this.Value, typeof(T)); }
    catch { return null; }
}

我假设你想要使用类型信息来做一些事情，比如动态地将用户控件分配给字段、验证规则、正确的 SQL 类型以实现持久性等。

我已经用方法做了很多这样的事情这看起来有点像你的。

归根结底，您应该将元数据与代码分开 - @Burnzy 的答案根据元数据（DataField 元素的“type”属性）选择代码，这是一个非常简单的示例。

如果您正在处理 XML，XSD 是一种非常有用且可扩展的元数据形式。

至于您存储每个字段的数据的内容 - 使用字符串，因为：

• 它们可以为空
• 他们可以存储部分值
• 他们可以存储无效值（让告诉用户对他们的行为进行排序更加透明）
• 他们可以存储列表
• 特殊情况不会侵入不相关的代码，因为没有任何
• 学习正则表达式，验证，很高兴
• 你可以很容易地将它们转换为更强的类型

我发现开发这样的小框架非常有价值 - 这是一种学习经历，你会明白更多关于用户体验和现实的内容从中建模。

我建议您首先处理四组测试用例：

• 日期、时间、时间戳（我称之为日期时间）、周期（时间跨度）
  • 特别是，请确保您测试的服务器位置与客户端的服务器位置不同。
• 列表 - 多选外键等
• 空值
• 无效输入 - 这通常涉及保留原始值

使用字符串可以大大简化这一切，因为它允许您在框架内清楚地划分职责。考虑一下在通用模型中执行包含列表的字段 - 它很快就会变得很复杂，并且很容易在几乎每种方法中都出现列表的特殊情况。有了弦，责任就到此为止了。

最后，如果您希望在无需执行任何操作的情况下可靠地实现此类内容，请考虑 数据集 - 我知道老派 - 它们可以做各种你意想不到的奇妙事情，但你必须使用 RTFM。

这个想法的主要缺点是它与 WPF 数据绑定不兼容 - 尽管我的经验是现实与 WPF 数据绑定不兼容。

我希望我正确地理解了你的意图 - 不管怎样，祝你好运:)

Answer 8

不幸的是，例如，C 和 C 之间没有继承关系。
但是，您可以从常见的非泛型类继承，此外还可以实现泛型接口。
在这里，我使用显式接口实现，以便能够声明类型为对象的 Value 属性，以及更具体类型的 Value 属性。
这些值是只读的，只能通过类型化构造函数参数进行分配。我的构造并不完美，但类型安全并且不使用反射。

public interface IValue<T>
{
    T Value { get; }
}

public abstract class DataField
{
    public DataField(string name, object value)
    {
        Name = name;
        Value = value;
    }
    public string Name { get; private set; }
    public object Value { get; private set; }
}

public class StringDataField : DataField, IValue<string>
{
    public StringDataField(string name, string value)
        : base(name, value)
    {
    }

    string IValue<string>.Value
    {
        get { return (string)Value; }
    }
}

public class IntDataField : DataField, IValue<int>
{
    public IntDataField(string name, int value)
        : base(name, value)
    {
    }

    int IValue<int>.Value
    {
        get { return (int)Value; }
    }
}

然后可以使用抽象基类 DataField 作为泛型参数来声明该列表：

var list = new List<DataField>();
switch (fieldType) {
    case "string":
        list.Add(new StringDataField("Item", "Apple"));
        break;
    case "int":
        list.Add(new IntDataField("Count", 12));
        break;
}

通过接口访问强类型字段：

public void ProcessDataField(DataField field)
{
    var stringField = field as IValue<string>;
    if (stringField != null) {
        string s = stringField.Value;
    }
}

Answer 9

虽然其他问题大多提出了一个优雅的解决方案来将 XML 元素转换为通用类实例，但我将处理采用该方法将 DataField 类建模为通用类（例如 DataField<[type Defined] 的方法）的后果。在 XML 元素的属性中]>。

将 DataField 实例选择到列表中后，您要使用这些字段。她的多态性发挥作用了！您想要迭代您的数据字段并以统一的方式处理它们。使用泛型的解决方案通常会陷入奇怪的 switch/if 狂欢中，因为没有简单的方法来根据 C# 中的泛型类型关联行为。

您可能见过这样的代码（我正在尝试计算所有数字 DataField 实例的总和）

var list = new List<DataField>()
{
    new DataField<int>() {Name = "int", Value = 2},
    new DataField<string>() {Name = "string", Value = "stringValue"},
    new DataField<float>() {Name = "string", Value = 2f},
};

var sum = 0.0;

foreach (var dataField in list)
{
    if (dataField.GetType().IsGenericType)
    {
        if (dataField.GetType().GetGenericArguments()[0] == typeof(int))
        {
            sum += ((DataField<int>) dataField).Value;
        }
        else if (dataField.GetType().GetGenericArguments()[0] == typeof(float))
        {
            sum += ((DataField<float>)dataField).Value;
        }
        // ..
    }
}

此代码完全是一团糟！

让我们尝试使用泛型类型 DataField 进行多态实现，并向其中添加一些方法 Sum ，该方法接受旧的 sum 并返回（可能已修改）新的 sum：

public class DataField<T> : DataField 
{
    public T Value { get; set; }
    public override double Sum(double sum)
    {
       if (typeof(T) == typeof(int))
       {
           return sum + (int)Value; // Cannot really cast here!
       }
       else if (typeof(T) == typeof(float))
       {
           return sum + (float)Value; // Cannot really cast here!
       }
       // ...

       return sum;
    }
}

你可以想象你的迭代代码会得到很多现在更清楚了，但代码中仍然有这个奇怪的 switch/if 语句。重点是：泛型在这里并不能帮助你，它是在错误的地方使用了错误的工具。泛型是用 C# 设计的，旨在为您提供编译时类型安全性，以避免潜在的不安全强制转换操作。它们还增加了代码的可读性，但这里的情况并非如此:)

让我们看一下多态解决方案：

public abstract class DataField
{
    public string Name { get; set; }
    public object Value { get; set; }
    public abstract double Sum(double sum);
}

public class IntDataField : DataField
{
    public override double Sum(double sum)
    {
        return (int)Value + sum;
    }
}

public class FloatDataField : DataField
{
    public override double Sum(double sum)
    {
        return (float)Value + sum;
    }
}

我想您不需要太多的幻想来想象对代码的可读性/质量增加了多少。

最后一点是如何创建这些类的实例。只需使用一些约定 TypeName +“DataField”和 Activator：

Activator.CreateInstance("assemblyName", typeName);

简短版本：

泛型不是解决您的问题的适当方法，因为它不会为 DataField 实例的处理增加价值。通过多态方法，您可以轻松地使用 DataField 的实例！

Answer 10

这并非不可能，因为你可以通过反思来做到这一点。但这不是泛型的设计目的，也不是它应该的实现方式。如果您打算使用反射来创建泛型类型，那么您也可以根本不使用泛型类型，而只使用以下类：

public class DataField
{
    public string Name { get; set; }
    public object Value { get; set; }
}

Answer 11

您需要插入用于从 XML 确定数据类型的逻辑，并添加您需要使用的所有类型，但这应该可行：

            result = (from d in XDocument.Parse(data.OuterXML).Root.Descendants()
                      let isString = true //Replace true with your logic to determine if it is a string.
                      let isInt = false   //Replace false with your logic to determine if it is an integer.
                      let stringValue = isString ? (DataField)new DataField<string>
                      {
                          Name = d.Name.ToString(),
                          Value = d.Value
                      } : null
                      let intValue = isInt ? (DataField)new DataField<int>
                      {
                          Name = d.Name.ToString(),
                          Value = Int32.Parse(d.Value)
                      } : null
                      select stringValue ?? intValue).ToList();