我正在寻找一种简单的方法来检查C＃中的对象是否可序列化。
我们知道，通过实现ISerializable接口或将[Serializable]放在类的顶部，可以使对象可序列化。
我正在寻找的是一种快速检查方法，而无需反映类以获得它的属性。 接口可以快速使用is语句。
使用@Flard的建议这是我提出的代码，尖叫是有更好的方法。
1
2
3
4
| private static bool IsSerializable(T obj)
{
return ((obj is ISerializable) || (Attribute.IsDefined(typeof (T), typeof (SerializableAttribute))));
} |
或者甚至更好地获取对象的类型，然后在类型上使用IsSerializable属性：
1
| typeof(T).IsSerializable |
请记住，这似乎只是我们正在处理的类，如果该类包含其他类，您可能想要检查它们或尝试序列化并等待错误，如@pb指出的那样。
你在Type类中有一个名为IsSerializable的可爱属性。
您将不得不检查序列化为serializable属性的对象图中的所有类型。最简单的方法是尝试序列化对象并捕获异常。 (但这不是最干净的解决方案)。 Type.IsSerializable和检查serializalbe属性不会考虑图形。
样品
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| [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);
}
} |
这是一个老问题，可能需要针对.NET 3.5+进行更新。如果类使用DataContract属性，Type.IsSerializable实际上可以返回false。这是我使用的一个片段，如果它发臭，请告诉我:)
1
2
3
4
5
6
7
| public static bool IsSerializable(this object obj)
{
Type t = obj.GetType();
return Attribute.IsDefined(t, typeof(DataContractAttribute)) || t.IsSerializable || (obj is IXmlSerializable)
} |
正如其他人所指出的那样使用Type.IsSerializable。
可能不值得尝试反映并检查对象图中的所有成员是否可序列化。
可以将成员声明为可序列化类型，但实际上将其实例化为不可序列化的派生类型，如下面的设计示例所示：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| [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 |
因此，即使您确定类型的特定实例是可序列化的，通常也不能确定所有实例都是如此。
1
| Attribute.IsDefined(typeof (YourClass), typeof (SerializableAttribute)); |
可能涉及水下反射，但最简单的方法呢？
这是一个3.5变体，它使用扩展方法使所有类都可用。
1
2
3
4
5
6
| public static bool IsSerializable(this object obj)
{
if (obj is ISerializable)
return true;
return Attribute.IsDefined(obj.GetType(), typeof(SerializableAttribute));
} |
我在这个问题和答案中得到了答案，并对其进行了修改，以便获得不可序列化的类型列表。这样你就可以很容易地知道要标记哪些。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| 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))));
} |
然后你称之为......
1
2
| List<string> nonSerializableTypes = new List<string>();
NonSerializableTypesOfParentType(aType, nonSerializableTypes); |
运行时，nonSerializableTypes将具有该列表。除了将空List传递给递归方法之外，可能有更好的方法。如果有的话，有人纠正我。
我的解决方案，在VB.NET中：
对象：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| ''' <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 |
对于类型：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| ''' <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 |
异常对象可能是可序列化的，但使用的是其他异常。
这就是我刚刚使用WCF System.ServiceModel.FaultException：FaultException是可序列化的，但ExceptionDetail不是！
所以我使用以下内容：
1
2
3
4
5
6
7
8
9
10
11
12
13
| // 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);
} |
