it-swarm-fr.com

Comment vérifier si un objet est sérialisable en C #

Je cherche un moyen simple de vérifier si un objet en C # est sérialisable.

Comme nous le savons, vous pouvez rendre un objet sérialisable en implémentant l'interface ISerializable ou en plaçant [Serializable] en haut de la classe.

Ce que je recherche, c'est un moyen rapide de vérifier cela sans avoir à refléter la classe pour obtenir ses attributs. L'interface serait rapide en utilisant une instruction is.

En utilisant la suggestion de @ Flard, c'est le code que j'ai trouvé, crier est qu'il y a une meilleure façon.

private static bool IsSerializable(T obj)
{
    return ((obj is ISerializable) || (Attribute.IsDefined(typeof (T), typeof (SerializableAttribute))));
}

Ou encore mieux, obtenez simplement le type de l'objet, puis utilisez la propriété IsSerializable sur le type:

typeof(T).IsSerializable

Rappelez-vous que cela semble ne concerner que la classe à laquelle nous avons affaire si la classe contient d'autres classes que vous voulez probablement toutes vérifier ou essayez de sérialiser et d'attendre les erreurs comme l'a souligné @pb.

92
FryHard

Vous avez une jolie propriété sur la classe Type appelée IsSerializable.

113
leppie

Vous devrez vérifier tous les types dans le graphique des objets en cours de sérialisation pour l'attribut sérialisable. La manière la plus simple est d'essayer de sérialiser l'objet et de capturer l'exception. (Mais ce n'est pas la solution la plus propre). Type.IsSerializable et la vérification de l'attribut serializalbe ne prennent pas en compte le graphique.

exemple

[Serializable]
public class A
{
    public B B = new B();
}

public class B
{
   public string a = "b";
}

[Serializable]
public class C
{
    public D D = new D();
}

[Serializable]
public class D
{
    public string d = "D";
}


class Program
{
    static void Main(string[] args)
    {

        var a = typeof(A);

        var aa = new A();

        Console.WriteLine("A: {0}", a.IsSerializable);  // true (WRONG!)

        var c = typeof(C);

        Console.WriteLine("C: {0}", c.IsSerializable); //true

        var form = new BinaryFormatter();
        // throws
        form.Serialize(new MemoryStream(), aa);
    }
}
41
Paul van Brenk

Il s'agit d'une ancienne question, qui peut nécessiter une mise à jour pour .NET 3.5+. Type.IsSerializable peut réellement retourner false si la classe utilise l'attribut DataContract. Voici un extrait que j'utilise, s'il pue, faites le moi savoir :)

public static bool IsSerializable(this object obj)
{
    Type t = obj.GetType();

     return  Attribute.IsDefined(t, typeof(DataContractAttribute)) || t.IsSerializable || (obj is IXmlSerializable)

}
16
Mike_G

Utilisez Type.IsSerializable comme d'autres l'ont souligné.

Cela ne vaut probablement pas la peine d'essayer de réfléchir et de vérifier si tous les membres du graphe d'objet sont sérialisables.

Un membre peut être déclaré comme un type sérialisable, mais en fait être instancié comme un type dérivé qui n'est pas sérialisable, comme dans l'exemple artificiel suivant:

[Serializable]
public class MyClass
{
   public Exception TheException; // serializable
}

public class MyNonSerializableException : Exception
{
...
}

...
MyClass myClass = new MyClass();
myClass.TheException = new MyNonSerializableException();
// myClass now has a non-serializable member

Par conséquent, même si vous déterminez qu'une instance spécifique de votre type est sérialisable, vous ne pouvez généralement pas être sûr que ce sera le cas pour toutes les instances.

8
Joe
Attribute.IsDefined(typeof (YourClass), typeof (SerializableAttribute));

Implique probablement une réflexion sous l'eau, mais le moyen le plus simple?

6
Grad van Horck

Voici une variante 3.5 qui le rend disponible pour toutes les classes utilisant une méthode d'extension.

public static bool IsSerializable(this object obj)
{
    if (obj is ISerializable)
        return true;
    return Attribute.IsDefined(obj.GetType(), typeof(SerializableAttribute));
}
5
Michael Meadows

J'ai pris la réponse à cette question et la réponse ici et l'ai modifiée pour que vous obteniez une liste de types qui ne sont pas sérialisables. De cette façon, vous pouvez facilement savoir lesquels marquer.

    private static void NonSerializableTypesOfParentType(Type type, List<string> nonSerializableTypes)
    {
        // base case
        if (type.IsValueType || type == typeof(string)) return;

        if (!IsSerializable(type))
            nonSerializableTypes.Add(type.Name);

        foreach (var propertyInfo in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
        {
            if (propertyInfo.PropertyType.IsGenericType)
            {
                foreach (var genericArgument in propertyInfo.PropertyType.GetGenericArguments())
                {
                    if (genericArgument == type) continue; // base case for circularly referenced properties
                    NonSerializableTypesOfParentType(genericArgument, nonSerializableTypes);
                }
            }
            else if (propertyInfo.GetType() != type) // base case for circularly referenced properties
                NonSerializableTypesOfParentType(propertyInfo.PropertyType, nonSerializableTypes);
        }
    }

    private static bool IsSerializable(Type type)
    {
        return (Attribute.IsDefined(type, typeof(SerializableAttribute)));
        //return ((type is ISerializable) || (Attribute.IsDefined(type, typeof(SerializableAttribute))));
    }

Et puis vous l'appelez ...

    List<string> nonSerializableTypes = new List<string>();
    NonSerializableTypesOfParentType(aType, nonSerializableTypes);

Lorsqu'il s'exécute, nonSerializableTypes aura la liste. Il peut y avoir une meilleure façon de procéder que de passer une liste vide à la méthode récursive. Quelqu'un me corrige si c'est le cas.

2
Andy Merrick

Ma solution, en VB.NET:

Pour les objets:

''' <summary>
''' Determines whether an object can be serialized.
''' </summary>
''' <param name="Object">The object.</param>
''' <returns><c>true</c> if object can be serialized; otherwise, <c>false</c>.</returns>
Private Function IsObjectSerializable(ByVal [Object] As Object,
                                      Optional ByVal SerializationFormat As SerializationFormat =
                                                                            SerializationFormat.Xml) As Boolean

    Dim Serializer As Object

    Using fs As New IO.MemoryStream

        Select Case SerializationFormat

            Case Data.SerializationFormat.Binary
                Serializer = New Runtime.Serialization.Formatters.Binary.BinaryFormatter()

            Case Data.SerializationFormat.Xml
                Serializer = New Xml.Serialization.XmlSerializer([Object].GetType)

            Case Else
                Throw New ArgumentException("Invalid SerializationFormat", SerializationFormat)

        End Select

        Try
            Serializer.Serialize(fs, [Object])
            Return True

        Catch ex As InvalidOperationException
            Return False

        End Try

    End Using ' fs As New MemoryStream

End Function

Pour les types:

''' <summary>
''' Determines whether a Type can be serialized.
''' </summary>
''' <typeparam name="T"></typeparam>
''' <returns><c>true</c> if Type can be serialized; otherwise, <c>false</c>.</returns>
Private Function IsTypeSerializable(Of T)() As Boolean

    Return Attribute.IsDefined(GetType(T), GetType(SerializableAttribute))

End Function

''' <summary>
''' Determines whether a Type can be serialized.
''' </summary>
''' <typeparam name="T"></typeparam>
''' <param name="Type">The Type.</param>
''' <returns><c>true</c> if Type can be serialized; otherwise, <c>false</c>.</returns>
Private Function IsTypeSerializable(Of T)(ByVal Type As T) As Boolean

    Return Attribute.IsDefined(GetType(T), GetType(SerializableAttribute))

End Function
0
ElektroStudios

L'objet d'exception peut être sérialisable, mais en utilisant une autre exception qui ne l'est pas. C'est ce que je viens d'avoir avec WCF System.ServiceModel.FaultException: FaultException est sérialisable mais ExceptionDetail ne l'est pas!

J'utilise donc ce qui suit:

// Check if the exception is serializable and also the specific ones if generic
var exceptionType = ex.GetType();
var allSerializable = exceptionType.IsSerializable;
if (exceptionType.IsGenericType)
    {
        Type[] typeArguments = exceptionType.GetGenericArguments();
        allSerializable = typeArguments.Aggregate(allSerializable, (current, tParam) => current & tParam.IsSerializable);
    }
 if (!allSerializable)
    {
        // Create a new Exception for not serializable exceptions!
        ex = new Exception(ex.Message);
    }
0
Eric