C# - generische Serialisierung utility-Klasse

Ich habe eine vorhandene Klasse zum serialisieren und Deserialisieren von Objekten auf/von XML. Es ist eine generische Klasse mit einem einzigen parameter vom Typ T deren einzige Einschränkung ist where T : IXmlSerializable. Ich möchte jedoch noch in der Lage sein, um diese Klasse zu verwenden, die auf Klassen, nicht umsetzen IXmlSerializable aber haben die [Serializable] Attribut. Wie könnte ich Sie gehen über das tun dies?

Aus meiner generische Klasse:

public static class XmlSerializationUtils<T> where T : IXmlSerializable
{
    public static T DeserializeXml(XmlDocument xml) { ... }
    public static XmlDocument SerializeToXml(T toSerialize) { ... }
}

Fand ich diese Diskussion aber es war keine Lösung gegeben, nur, dass ich nicht tun kann where T : Serializable. Versuchen zu tun where T : SerializableAttribute macht Visual Studio sagen "Nicht verwenden, versiegelte Klasse 'System.SerializableAttribute' als Typ-parameter-constraint".

Edit: basierend auf Stephen ' s Antwort, ich entfernt die Einschränkungen für XmlSerializationUtils<T> und ergänzt diese statische Konstruktor:

static XmlSerializationUtils()
{
    Type type = typeof(T);
    bool hasAttribute = null != Attribute.GetCustomAttribute(type,
        typeof(SerializableAttribute));
    bool implementsInterface =
        null != type.GetInterface(typeof(IXmlSerializable).FullName);
    if (!hasAttribute && !implementsInterface)
    {
        throw new ArgumentException(
            "Cannot use XmlSerializationUtils on class " + type.Name +
            " because it does not have the Serializable attribute " +
            " and it does not implement IXmlSerializable"
        );
    }
}
InformationsquelleAutor Sarah Vessels | 2010-07-20
  1. 6

    Können Sie nicht verlangen, ein Attribut als Teil von Generika. Jedoch, Sie könnten einen statischen Konstruktor, der überprüft, ob es und wirft, wenn es nicht gefunden.

    InformationsquelleAutor Steven Sudit
  2. 8

    Können Sie überprüfen, um zu sehen, wenn ein Typ serialisierbar ist mit dem IsSerializable - Eigenschaft den Typ des Objekts.

    myObj.GetType().IsSerializable

    Wie bereits erwähnt, ist dies nicht möglich, hinzuzufügen, als eine Allgemeine Einschränkung, aber wahrscheinlich werden daraufhin in einem Konstruktor.

    • Das ist besser, als Prüfung für das Attribut. Danke.
    • Hm. Meine aktuelle Lösung (in meiner Frage) überprüft, um zu sehen, ob IXmlSerializable oder [Serializable] gilt für die gegebene Klasse T. Tut IsSerializable account für beide?
    • Anscheinend. Siehe msdn.microsoft.com/en-us/library/...
    InformationsquelleAutor womp
  3. 6

    Ich würde nur zu beseitigen, den Typ-Einschränkung und fangen die SerializationException, wenn der Typ nicht serialisieren oder Deserialisieren korrekt... In der Tat, damit können Sie Ihre generischen Serialisieren und Deserialisieren von Methoden zu akzeptieren formatter 

    public enum Formatter { Binary, Xml }

    könnten Sie kontrollieren, ob die Serialisierung ist Binär oder Xml -

    public class Serialization
{
    public enum Formatter { Binary, Xml }

    #region Serialization methods
    public static void Serialize2File<T>(T obj, string pathSpec, 
        Formatter formatter)
    {
        try
        {
            switch (formatter)
            {
                case (Formatter.Binary):
                    using (var fs = new FileStream(pathSpec, FileMode.Create,
                                        FileAccess.Write, FileShare.Write))
                        (new BinaryFormatter()).Serialize(fs, obj);
                    break;

                case (Formatter.Xml):
                    var serializer = new XmlSerializer(typeof(T));
                    TextWriter textWriter = new StreamWriter(pathSpec);
                    serializer.Serialize(textWriter, obj);
                    textWriter.Close();
                    break;

                default:
                    throw new MyCustomException("Invalid Formatter option");
            }
        }
        catch (SerializationException sX)
        {
            var errMsg = String.Format(
                "Unable to serialize {0} into file {1}",
                obj, pathSpec);
            throw new MyCustomException(errMsg, sX);
        }
    }
    public static T DeSerializeFromFile<T>(string pathSpec, 
        Formatter formatter) where T : class
    {
        try
        {
            switch (formatter)
            {
                case (Formatter.Binary):
                    using (var strm = new FileStream(pathSpec,
                                        FileMode.Open, FileAccess.Read))
                    {
                        IFormatter fmt = new BinaryFormatter();
                        var o = fmt.Deserialize(strm);
                        if (!(o is T))
                            throw new ArgumentException("Bad Data File");
                        return o as T;
                    }

                case (Formatter.Xml):
                    var serializer = new XmlSerializer(typeof(T));
                    TextReader rdr = new StreamReader(pathSpec);
                    return (T)serializer.Deserialize(rdr);

                default:
                    throw new MyCustomException("Invalid Formatter option");
            }
        }
        catch (SerializationException sX)
        {
            var errMsg = String.Format(
                "Unable to deserialize {0} from file {1}",
                typeof(T), pathSpec);
            throw new MyCustomException(errMsg, sX);
        }
    }
    #endregion Serialization methods
}
    • Das ist nicht eine unzumutbare Lösung.
    • Ja, ich Stimme zu, es ist von einem Entwickler, der sollte wissen, ob die Klasse, in der er versucht, serialise ist serliasable, wenn er es falsch ist, was Ausnahmen sind, können Sie nicht beseitigen jeden möglichen Fehler zur compile-Zeit.
    • Wir können nicht immer so tun, aber wir sollten sicherlich versuchen, Sie zu fangen bugs, die früh und Häufig. In diesem Fall können wir nicht fangen es zur compile-Zeit, aber wenn wir die statische Konstruktor trick, wir fangen es ganz am Anfang der Laufzeit (das heißt, eine post-compile-smoke check werden es nicht verpassen).
    • Wenn ich origianlly codiert hatte ich es code in die Klasse, zu erkennen, (nur beim Versuch die Xml-Serialisierung), wenn die übergebene variable vom Typ implementiert IXmlSerializable oder (mit Reflexion), war geschmückt mit der [Serializable] Attribut... Dann WCF kam und Sie fügten hinzu, die [DataContract] Attribut, die es erlaubt, auch eine Art zu sein, die als Xml serialisiert. So habe ich es entfernt...
    InformationsquelleAutor Charles Bretana
Schreibe einen Kommentar