Allgemein akzeptierte Weg, um zu vermeiden KnownType-Attribut für jede abgeleitete Klasse

Gibt es einen allgemein anerkannten Weg, um zu vermeiden, dass du KnownType-Attribute auf WCF-Dienste? Ich habe getan, einige der Forschung, und wie es aussieht, gibt es zwei Möglichkeiten:

  1. Daten Vertrag resolver
  2. NetDataContractSerializer

Ich bin kein großer fan von mit zu statisch hinzufügen KnownType-Attribute jedes mal, wenn ich einen neuen Typ, daher wollte es vermeiden.

Gibt es eine Dritte option, die verwendet werden sollte? Wenn dem so ist, was ist es? Wenn nicht, welche der beiden oben genannten Optionen sind der richtige Weg zu gehen?

Bearbeiten - verwenden Sie eine Methode

Eine Dritte Möglichkeit wäre die Verwendung von Reflexion

[DataContract]
[KnownType("DerivedTypes")]
public abstract class FooBase
{
    private static Type[] DerivedTypes()
    {
        return typeof(FooBase).GetDerivedTypes(Assembly.GetExecutingAssembly()).ToArray();
    }
}
InformationsquelleAutor Bob Horn | 2013-04-25
  1. 25

    Ich posten wollte, was scheint die einfachste, eleganteste Lösung, die ich denken kann, so weit. Wenn eine andere Antwort kommt, die ist besser, ich gehe mit, dass. Aber für jetzt, das funktionierte gut.

    Basis-Klasse, mit nur eine KnownType Attribut den Verweis auf eine Methode namens DerivedTypes():

    [KnownType("DerivedTypes")]
[DataContract]
public abstract class TaskBase : EntityBase
{
    //other class members here

    private static Type[] DerivedTypes()
    {
        return typeof(TaskBase).GetDerivedTypes(Assembly.GetExecutingAssembly()).ToArray();
    }
}

    Den GetDerivedTypes() Methode, in einem separaten ReflectionUtility Klasse:

    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;
}
    • Wenn Sie sich lieber nicht anlegen, die Erweiterung Methode, diese können sich in einem one-liner. return Assembly.GetExecutingAssembly().GetTypes().Where(_ => _.IsSubclassOf(typeof(TaskBase))).ToArray();
    • Dies ist eine großartige Lösung. Sauber und einfach.
    • Dies ist ein Lebensretter, danke!
    InformationsquelleAutor Bob Horn
  2. 8

    Die Methode erwähnt, von Bob funktioniert, solange alle beteiligten Klassen in der gleichen assembly.

    Folgende Methode funktioniert über Baugruppen:

    [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)); 
  }
}
    • +1 für eine nette alternative. Beachten Sie, dass die Reflexion option gemacht werden kann, zu arbeiten in Baugruppen als gut. Ich mag das, weil es ist sauber. Das einzige negative, das ich denken kann ist, dass die abgeleiteten Klassen müssen daran denken, zur Umsetzung dieser statischen Konstruktor. Mit Reflexion, ist nichts mehr übrig, um die Erinnerung an die Entwickler.
    • Stimmt, aber mit vielen Baugruppen, die Leistung kann sich eine überlegung. Ein weiterer Nachteil dieser Vorgehensweise ist, dass aussetzen der öffentlichen Liste der Arten.
    • Sie müssen auch sicherstellen, dass es etwas gibt, rufen die statische Konstruktor: der CLR-runtime, ich glaube, nicht jeder statischen Konstruktor in eine assembly lädt, wird nur das erste mal die Klasse zugegriffen wird oder verwendet in irgendeiner Weise.
    InformationsquelleAutor Leon van der Walt
  3. 1

    Können Sie die IXmlSerializable implementieren in Ihre benutzerdefinierten Typen und Griff Ihrer Komplexität manuell.
    Folgenden finden Sie ein Beispiel-code:

    [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);
    }
}

    Hoffe, es hilft.

    • Danke, @Farzan, aber dies scheint mehr zu sein als ich war auf der Suche, so weit wie Wartung. Meine Dritte option, in meiner Frage, die mir erlaubt, zu implementieren, ein Aufruf, sich nur auf die base-Klasse und sparen eine Menge der Kodierung. Dein Ansatz ist nett zu sehen, aber es ist einfach mehr code zu pflegen.
    InformationsquelleAutor Farzan
  4. 1

    Wenn Sie nicht wie die Attribute überall danach können Sie mithilfe von configuration-Datei.

    <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>
    • Danke für den Tipp, Tim. Aber mein Ziel ist es, nicht zu aktualisieren, eine Liste irgendwo, jedes mal gibt es ein neues geben. Gut zu wissen.
    • Wie gut, müssen Sie aktualisieren Sie Ihre config JEDES mal, wenn Sie Ihre assembly-version geändert.
    InformationsquelleAutor Tim Phan
  5. 1

    Hier ist meine Variante auf die akzeptierte Antwort:

        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));
    }

    Die Unterschiede sind:

    1. Sieht in allen geladenen assemblies.
    2. Prüft ein paar bits wir sind interessiert an (DataContract ich denke, dass ist erforderlich, wenn Sie mit DataContractJsonSerializer) wie wird eine konkrete Klasse.
    3. Können Sie isSubclassOf hier, Neige ich dazu, lieber IsAssignableFrom im Allgemeinen zu fangen alle übergangenen Varianten. Insbesondere ich denke, es funktioniert mit Generika.
    4. Nutzen KnownTypes Annahme einer IEnumerable (wenn es darauf ankommt, in diesem Fall wohl nicht), statt der Umwandlung in ein array.
    InformationsquelleAutor user169771
  6. 0

    Ich würde lieber extrahieren Sie meine benutzerdefinierte Typen alle auf einmal und verwenden Sie es während der Serialisierung/Deserialisierung. Nach der Lektüre dieses post, es dauerte eine Weile, um zu verstehen, wo zu injizieren und diese Liste von Arten, nützlich zu sein für die Objekt-Serialisierung. Die Antwort war ganz einfach: diese Liste ist als einer der Eingabe-Argumente der Konstruktor der serializer-Objekt.

    1 - ich bin mit zwei statischen, generischen Methoden für die Serialisierung und Deserialisierung, dies kann mehr oder weniger wie andere auch, die den job tun, oder zumindest ist es sehr übersichtlich für die Herstellung Vergleich mit dem code:

        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 - Bitte achten Sie auf Konstruktor der DataContractSerializer. Wir haben ein zweites argument gibt es, das ist der Einstiegspunkt für die Injektion Ihre bekannten Typen um Objekt-Serialisierung.

    3 - ich bin eine statische Methode für das extrahieren von all meinen eigenen definierten Typen aus meiner eigenen Baugruppen. den code für diese statische Methode könnte wie folgt Aussehen:

        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;
    }

    Da war ich nicht beteiligt WCF (ich brauchte nur eine binäre Serialisierung für die Datei-operation), meine Lösung kann nicht genau auf die WCF-Architektur, aber es muss Zugriff auf Konstruktor der serializer-Objekt von irgendwo.

    InformationsquelleAutor Alireza Ahmadi Rad
Schreibe einen Kommentar