How can I add a type constraint to include anything serializable in a generic method?

Question

My generic method needs to serialize the object passed to it, however just insisting that it implements ISerializable doesn't seem to work. For example, I have a struct returned from a web service (marked with SerializableAttribute) that serializes to xml just fine, but, as expected, the C# compiler complains.

Is there a way I can check the object is serializable before attempting to serialize it, or, better still, a way of using the where keyword to check the object is suitable?

Here's my full method:

public static void Push<T>(string url, T message)         where T : ISerializable {     string xml = SerializeMessage(message);      // Send the message to Amazon SQS     SendMessageRequest sendReq = new SendMessageRequest { QueueUrl = url, MessageBody = xml };     AmazonSQSClient client = new AmazonSQSClient(S3User, S3Pass);     client.SendMessage(sendReq); } 

And SerializeMessage:

private static string SerializeMessage<T>(T message) {     XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));     using (StringWriter stringWriter = new StringWriter())     {         xmlSerializer.Serialize(stringWriter, message);         return stringWriter.ToString();     } } 

If this isn't possible, what's the best way to perform a check that an object is serializable at runtime?

Answer 1

You can't do this totally via generic constraints, but you can do a couple things to help:

1) Put the new() constraint on the generic type (to enable the ability to deserialize and to ensure the XmlSerializer doesn't complain about a lack of default ctor):

where T : new() 

2) On the first line of your method handling the serialization (or constructor or anywhere else you don't have to repeat it over and over), you can perform this check:

if( !typeof(T).IsSerializable && !(typeof(ISerializable).IsAssignableFrom(typeof(T)) ) )     throw new InvalidOperationException("A serializable Type is required"); 

Of course, there's still the possibility of runtime exceptions when trying to serialize a type, but this will cover the most obvious issues.