Classe d'utilitaire de sérialisation générique C#

Question

J'ai une classe existante pour la sérialisation et la désérialisation d'objets vers/depuis XML. C'est une classe générique avec un seul paramètre de type T dont la seule contrainte est where T : IXmlSerializable. Cependant, je veux toujours pouvoir utiliser cette classe sur les classes qui n'implémentent pas IXmlSerializable mais qui ont l'attribut [Serializable]. Comment pourrais-je faire cela?

de ma classe générique:

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

J'ai trouvé this discussion mais il n'y avait pas de solution donnée, juste que je ne peux pas faire where T : Serializable. Essayer de faire where T : SerializableAttribute fait Visual Studio dire "Impossible d'utiliser la classe scellée 'System.SerializableAttribute' comme contrainte de paramètre de type".

Edit: basé sur Stephen's answer, je supprimé les restrictions sur XmlSerializationUtils<T> et a ajouté ce constructeur statique:

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

Answer 1

Vous ne pouvez pas exiger un attribut dans le cadre des génériques. Cependant, vous pouvez fournir un constructeur statique qui le vérifie et le lance s'il n'est pas trouvé.

Answer 2

Je venais juste d'éliminer les contraintes de type et attraper le SerializationException lorsque le type ne sérialise pas ou désérialiser correctement ... En fait, cela permet à votre sérialisation générique et deserialize méthodes pour accepter un formatter

public enum Formatter { Binary, Xml } 

qui pourrait contrôler si la sérialisation est binaire ou 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 
} 

Answer 3

Vous pouvez vérifier si un type est sérialisable en utilisant la propriété IsSerializable du type de l'objet. Comme mentionné, ceci n'est pas possible à ajouter en tant que contrainte générique, mais serait probablement vérifié dans un constructeur.