C# - 当我不知道(T)的类型时，如何反序列化一个泛型列表<T>?

Question

出于听觉原因，我使用binaryformatter将业务方法的参数序列化为数据库中的二进制格式。

问题在于，当参数是泛型列表时，我无法找到转换反序列化对象的方法，因为我不知道类型，或者即使知道类型，也不知道如何在运行时转换对象。

有人知道如何在运行时动态地转换包含泛型列表的对象吗？

我需要这样做是因为我需要在属性网格中显示反序列化数据：

object objArg = bformatter.Deserialize(memStr);

//If the type is a clr type (int, string, etc)
if (objArg.GetType().Module.Name == "mscorlib.dll")
{                 
    //If the type is a generic type (List<>, etc) 
    //(I'm only use List for these cases)
    if (objArg.GetType().IsGenericType)
    {
         // here is the problem
         pgArgsIn.SelectedObject = new { Value = objArg};                    

         //In the previous line I need to do something like... 
         //new { Value = (List<objArg.GetYpe()>) objArg};
     }
     else
     {
         pgArgsIn.SelectedObject = new { Value = objArg.ToString() };                    
     }
}
else
{
    //An entity object
    pgArgsIn.SelectedObject = objArg;                
}

- Ariel Larraburu

---

“Auditory reasons”？在这个上下文中是什么意思？ - Adam Robinson

为了符合审计法规，我想吧。 - AakashM

关于此，如果您更改了对象，BinaryFormatter 将非常脆弱。我建议使用基于契约的序列化程序，例如 XmlSerializer、DataContractSerializer 或（对于二进制）protobuf-net。 - Marc Gravell

关于您的评论；有一种通过自定义描述符来实现您所要求的方法；我会在吃完饭后（很快）写一个例子。 - Marc Gravell

添加了一个不涉及查找T的示例。 - Marc Gravell

Answer 1

使用 BinaryFormatter，您不需要知道类型；元数据包含在流中（使其变得更大，但是嘿！）。但是，如果您不知道类型，则无法进行强制转换。在这种情况下，通常必须使用常见的已知接口（非泛型 IList 等）和反射。而且还需要很多。

我也想不出在 PropertyGrid 中显示类型的巨大需求 - 因为它接受 object，只需提供 BinaryFormatter 提供的即可。您是否看到了特定问题？同样，您可能需要检查非泛型 IList - 但不值得担心 IList<T>，因为这不是 PropertyGrid 检查的内容！

当然，如果您想要的话，可以找到 T（像这样） - 并使用 MakeGenericType() 和 Activator.CreateInstance - 不太好看。

好的，这里有一种使用自定义描述符的方法，不需要知道任何关于对象或列表类型的信息；如果您确实想要，可以将列表项直接扩展为属性，因此在此示例中，您将看到 2 个虚假属性（"Fred" 和 "Wilma"） - 但这需要额外的工作。

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows.Forms;

class Person
{
    public string Name { get; set; }
    public DateTime DateOfBirth { get; set; }

    public override string ToString() {
        return Name;
    }
}

static class Program
{
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Person fred = new Person();
        fred.Name = "Fred";
        fred.DateOfBirth = DateTime.Today.AddYears(-23);
        Person wilma = new Person();
        wilma.Name = "Wilma";
        wilma.DateOfBirth = DateTime.Today.AddYears(-20);

        ShowUnknownObject(fred, "Single object");
        List<Person> list = new List<Person>();
        list.Add(fred);
        list.Add(wilma);
        ShowUnknownObject(list, "List");
    }
    static void ShowUnknownObject(object obj, string caption)
    {
        using(Form form = new Form())
        using (PropertyGrid grid = new PropertyGrid())
        {
            form.Text = caption;
            grid.Dock = DockStyle.Fill;
            form.Controls.Add(grid);
            grid.SelectedObject = ListWrapper.Wrap(obj);
            Application.Run(form);
        }
    }
}

[TypeConverter(typeof(ListWrapperConverter))]
public class ListWrapper
{
    public static object Wrap(object obj)
    {
        IListSource ls = obj as IListSource;
        if (ls != null) obj = ls.GetList(); // list expansions

        IList list = obj as IList;
        return list == null ? obj : new ListWrapper(list);
    }
    private readonly IList list;
    private ListWrapper(IList list)
    {
        if (list == null) throw new ArgumentNullException("list");
        this.list = list;
    }
    internal class ListWrapperConverter : TypeConverter
    {
        public override bool GetPropertiesSupported(ITypeDescriptorContext context)
        {
            return true;
        }
        public override PropertyDescriptorCollection GetProperties(
            ITypeDescriptorContext context, object value, Attribute[] attributes) {
            return new PropertyDescriptorCollection(
                new PropertyDescriptor[] { new ListWrapperDescriptor(value as ListWrapper) });
        }
    }
    internal class ListWrapperDescriptor : PropertyDescriptor {
        private readonly ListWrapper wrapper;
        internal ListWrapperDescriptor(ListWrapper wrapper) : base("Wrapper", null)
        {
            if (wrapper == null) throw new ArgumentNullException("wrapper");
            this.wrapper = wrapper;
        }
        public override bool ShouldSerializeValue(object component) { return false; }
        public override void ResetValue(object component) {
            throw new NotSupportedException();
        }
        public override bool CanResetValue(object component) { return false; }
        public override bool IsReadOnly {get {return true;}}
        public override void SetValue(object component, object value) {
            throw new NotSupportedException();
        }
        public override object GetValue(object component) {
            return ((ListWrapper)component).list;
        }
        public override Type ComponentType {
            get { return typeof(ListWrapper); }
        }
        public override Type PropertyType {
            get { return wrapper.list.GetType(); }
        }
        public override string DisplayName {
            get {
                IList list = wrapper.list;
                if (list.Count == 0) return "Empty list";

                return "List of " + list.Count
                    + " " + list[0].GetType().Name;
            }
        }
    }
}

- Marc Gravell

---

嗨，马克，我不知道为什么，但如果我像这样设置属性网格： pgArgsIn.SelectedObject = new { Value = arg}; //当arg是反序列化的参数时。 在属性网格中会出现以下内容： Value = [system.collections....]，没有任何更多的东西让我有机会知道对象里面有什么。 但是，如果我像这样设置属性网格： pgArgsIn.SelectedObject = new { Value = arg as List<Entities.Diagnostico>}; 在属性网格中会出现以下内容： Value = (Collection) [...]，并带有一个按钮，显示实体列表及其属性。 - Ariel Larraburu

然后，我需要在运行时将反序列化的对象转换。激活器和其他东西返回一个对象，那么我就没有我需要的东西了。 - Ariel Larraburu

你为什么认为需要进行强制转换？PropertyGrid不关心你的变量类型... - Marc Gravell

Answer 2

如果您使用的序列化器不保留类型信息，那么至少您必须将 T 的类型与数据一起存储，并使用反射机制来创建泛型列表：

//during storage:
Type elementType = myList.GetType().GetGenericTypeDefinition().GetGenericArguments[0];
string typeNameToSave = elementType.FullName;

//during retrieval
string typeNameFromDatabase = GetTypeNameFromDB();
Type elementType = Type.GetType(typeNameFromDatabase);
Type listType = typeof(List<>).MakeGenericType(new Type[] { elementType });

现在您有了listType，它是您使用的确切List<T>（例如List<Foo>）。您可以将该类型传递到反序列化程序中。

- Rex M

---

是的！这是一个好方法，但我还没有解决方案。我有反序列化的对象和泛型类型（List<Entidades.Diagnosticos>）。现在，我需要在运行时转换对象，我需要做类似于MyTypedObjectArg = objArg as List<Entidades.Diagnosticos>的事情。为什么？如果我将属性网格绑定到对象，我会得到：Value = [System.Collection.Generic.List`1]，但如果我设置了类型化的对象，我就有了一个集合，我可以看到实体内部和实体内部的属性等。 - Ariel Larraburu

typeof(List<>).MakeGenericType(new Type[] { elementType }); 对我解决了问题。 - maiconmm