普遍接受的避免每个派生类的KnownType属性的方法

本文关键字：派生 KnownType 方法 属性 | 更新日期: 2023-09-27 18:11:05

是否有一种普遍接受的方法来避免在WCF服务上使用KnownType属性?我做了一些研究，看起来有两个选择:

  1. 数据合约解析器
  2. NetDataContractSerializer

我不太喜欢每次添加新类型时都静态地添加KnownType属性，因此我希望避免这种情况。

是否应该使用第三个选项?如果有，是什么?如果不是，以上两种选择哪一种是正确的方法?

编辑-使用方法

第三个选择是使用反射

[DataContract]
[KnownType("DerivedTypes")]
public abstract class FooBase
{
    private static Type[] DerivedTypes()
    {
        return typeof(FooBase).GetDerivedTypes(Assembly.GetExecutingAssembly()).ToArray();
    }
}

普遍接受的避免每个派生类的KnownType属性的方法

我想发布的是目前为止我能想到的最简单、最优雅的解决方案。如果出现另一个更好的答案，我就接受它。但就目前而言，这很有效。

基类，只有一个 KnownType属性，指向一个叫做DerivedTypes()的方法:

[KnownType("DerivedTypes")]
[DataContract]
public abstract class TaskBase : EntityBase
{
    // other class members here
    private static Type[] DerivedTypes()
    {
        return typeof(TaskBase).GetDerivedTypes(Assembly.GetExecutingAssembly()).ToArray();
    }
}

GetDerivedTypes()方法，在一个单独的ReflectionUtility类中:

public static IEnumerable<Type> GetDerivedTypes(this Type baseType, Assembly assembly)
{
    var types = from t in assembly.GetTypes()
                where t.IsSubclassOf(baseType)
                select t;
    return types;
}

只要所有涉及的类都在同一个程序集中，Bob提到的方法就可以工作。

下面的方法将跨程序集工作:

[DataContract]
[KnownType("GetDerivedTypes")]
public class BaseClass
{
  public static List<Type> DerivedTypes = new List<Type>();
  private static IEnumerable<Type> GetDerivedTypes()
  {
    return DerivedTypes;
  }
}

[DataContract]
public class DerivedClass : BaseClass
{
  //static constructor
  static DerivedClass()
  {
    BaseClass.DerivedTypes.Add(typeof(DerivedClass)); 
  }
}

这是我对被接受的答案的变体:

    private static IEnumerable<Type> GetKnownTypes() {
        Type baseType = typeof(MyBaseType);
        return AppDomain.CurrentDomain.GetAssemblies()
            .SelectMany(x => x.DefinedTypes)
            .Where(x => x.IsClass && !x.IsAbstract && x.GetCustomAttribute<DataContractAttribute>() != null && baseType.IsAssignableFrom(x));
    }

区别如下:

  1. 查看所有加载的程序集。
  2. 检查一些我们感兴趣的位(DataContract我认为是必需的，如果你使用DataContractJsonSerializer)，如作为一个具体的类。
  3. 你可以在这里使用isSubclassOf，我倾向于使用IsAssignableFrom来捕获所有被覆盖的变量。我认为它特别适用于泛型。
  4. 利用KnownTypes接受IEnumerable(如果在这种情况下重要的话，可能不是)而不是转换为数组。

可以在自定义类型中实现IXmlSerializable，并手动处理其复杂性。下面你可以找到一个示例代码:

[XmlRoot("ComplexTypeA")]
public class ComplexTypeA : IXmlSerializable
{
    public int Value { get; set; }
    public void WriteXml (XmlWriter writer)
    {
        writer.WriteAttributeString("Type", this.GetType().FullName);
        writer.WriteValue(this.Value.ToString());
    }
    public void ReadXml (XmlReader reader)
    {
        reader.MoveToContent();
        if (reader.HasAttributes) {
            if (reader.GetAttribute("Type") == this.GetType().FullName) {
                this.Value = int.Parse(reader.ReadString());
            }
        }
    }
    public XmlSchema GetSchema()
    {
        return(null);
    }
}
[XmlRoot("ComplexTypeB")]
public class ComplexTypeB : IXmlSerializable
{
    public string Value { get; set; }
    public void WriteXml (XmlWriter writer)
    {
        writer.WriteAttributeString("Type", this.GetType().FullName);
        writer.WriteValue(this.Value);
    }
    public void ReadXml (XmlReader reader)
    {
        reader.MoveToContent();
        if (reader.HasAttributes) {
            if (reader.GetAttribute("Type") == this.GetType().FullName) {
                this.Value = reader.ReadString();
            }
        }
    }
    public XmlSchema GetSchema()
    {
        return(null);
    }
}

[XmlRoot("ComplexTypeC")]
public class ComplexTypeC : IXmlSerializable
{
    public Object ComplexObj { get; set; }
    public void WriteXml (XmlWriter writer)
    {
        writer.WriteAttributeString("Type", this.GetType().FullName);
        if (this.ComplexObj != null)
        {
            writer.WriteAttributeString("IsNull", "False");
            writer.WriteAttributeString("SubType", this.ComplexObj.GetType().FullName);
            if (this.ComplexObj is ComplexTypeA)
            {
                writer.WriteAttributeString("HasValue", "True");
                XmlSerializer serializer = new XmlSerializer(typeof(ComplexTypeA));
                serializer.Serialize(writer, this.ComplexObj as ComplexTypeA);
            }
            else if (tthis.ComplexObj is ComplexTypeB)
            {
                writer.WriteAttributeString("HasValue", "True");
                XmlSerializer serializer = new XmlSerializer(typeof(ComplexTypeB));
                serializer.Serialize(writer, this.ComplexObj as ComplexTypeB);
            }
            else
            {
                writer.WriteAttributeString("HasValue", "False");
            }
        }
        else
        {
            writer.WriteAttributeString("IsNull", "True");
        }
    }
    public void ReadXml (XmlReader reader)
    {
        reader.MoveToContent();
        if (reader.HasAttributes) {
            if (reader.GetAttribute("Type") == this.GetType().FullName) {
                if ((reader.GetAttribute("IsNull") == "False") && (reader.GetAttribute("HasValue") == "True")) {
                    if (reader.GetAttribute("SubType") == typeof(ComplexTypeA).FullName)
                    {
                        XmlSerializer serializer = new XmlSerializer(typeof(ComplexTypeA));
                        this.ComplexObj = serializer.Deserialize(reader) as ComplexTypeA;
                    }
                    else if (reader.GetAttribute("SubType") == typeof(ComplexTypeB).FullName)
                    {
                        XmlSerializer serializer = new XmlSerializer(typeof(ComplexTypeB));
                        this.ComplexObj = serializer.Deserialize(reader) as ComplexTypeB;
                    }
                }
            }
        }
    }
    public XmlSchema GetSchema()
    {
        return(null);
    }
}

希望能有所帮助。

如果你不喜欢到处都有属性，那么你可以使用配置文件。

<system.runtime.serialization>
   <dataContractSerializer>
      <declaredTypes>
         <add type = "Contact,Host,Version=1.0.0.0,Culture=neutral,
                                                              PublicKeyToken=null">
            <knownType type = "Customer,MyClassLibrary,Version=1.0.0.0,
                                             Culture=neutral,PublicKeyToken=null"/>
         </add>
      </declaredTypes>
   </dataContractSerializer>
</system.runtime.serialization>

我宁愿一次提取所有自定义类型，并在序列化/反序列化期间使用它。读完这篇文章后，我花了一段时间来理解在哪里注入这个类型列表对序列化器对象有用。答案很简单:这个列表将被用作序列化器对象的构造函数的输入参数之一。

1-我使用两个静态泛型方法进行序列化和反序列化，这可能或多或少也是其他人做这项工作的方式，或者至少它非常清楚地与您的代码进行比较:

    public static byte[] Serialize<T>(T obj)
    {
        var serializer = new DataContractSerializer(typeof(T), MyGlobalObject.ResolveKnownTypes());
        var stream = new MemoryStream();
        using (var writer =
            XmlDictionaryWriter.CreateBinaryWriter(stream))
        {
            serializer.WriteObject(writer, obj);
        }
        return stream.ToArray();
    }
    public static T Deserialize<T>(byte[] data)
    {
        var serializer = new DataContractSerializer(typeof(T), MyGlobalObject.ResolveKnownTypes());
        using (var stream = new MemoryStream(data))
        using (var reader =
            XmlDictionaryReader.CreateBinaryReader(
                stream, XmlDictionaryReaderQuotas.Max))
        {
            return (T)serializer.ReadObject(reader);
        }
    }

2-请注意DataContractSerializer的构造函数。这里有第二个参数，它是将已知类型注入序列化器对象的入口点。

3-我使用静态方法从我自己的程序集中提取所有我自己定义的类型。这个静态方法的代码可能如下所示:

    private static Type[] KnownTypes { get; set; }
    public static Type[] ResolveKnownTypes()
    {
        if (MyGlobalObject.KnownTypes == null)
        {
            List<Type> t = new List<Type>();
            List<AssemblyName> c = System.Reflection.Assembly.GetEntryAssembly().GetReferencedAssemblies().Where(b => b.Name == "DeveloperCode" | b.Name == "Library").ToList();
            foreach (AssemblyName n in c)
            {
                System.Reflection.Assembly a = System.Reflection.Assembly.Load(n);
                t.AddRange(a.GetTypes().ToList());
            }
            MyGlobalObject.KnownTypes = t.ToArray();
        }
        return IOChannel.KnownTypes;
    }

由于我没有参与WCF(我只需要二进制序列化文件操作)，我的解决方案可能不完全解决WCF体系结构，但必须从某处访问序列化器对象的构造函数。

相关文章：