Question

I’ve got a C# class library with approximately 50 classes with hundreds of properties. It can take a while to instantiate my classes, so as an optimization I was considering having them instantiated on a server and then have the server pass the instantiated classes to a client application via a WCF Service.

Seems like it should work fine. However, from what I understand, if I want to do this I would need to not only mark every class as [DataContract] but also every property as [DataMember]. Is this really true? Seems crazy that this would need to be done, especially on every property. Is there a way to just say the entire class is serializable without having to go through this process?

Answer 1

If you use the [DataContract] you’ll need to specify the [DataMember] for each member too.

Alternatively – mark the class with [Serializable] and the serializer will serialize all the internals for you unless you explicitly say otherwise ([Serializable] works on an opt-out approach whereas [DataContract] works on an opt-in approach).

However – depending on what, exactly, you are trying to do – this approach may be flawed.

When you pass an object over WCF, you are not really passing the object at all – you are passing a copy of the object. In fact, the original object will be serialized, passed down the wire and deserialized at the other end. This means the client still has to instantiate reconstitute an instance of the class and then populate all the properties. You may gain nothing, and potentially have a rather expensive call with a lot of data being passed across the wire.

So it all depends what you are doing. If you don’t mind the clients getting a copy of the instance and if the expense is not due to the sheer amount of data but other things like slow database access, then fine. Otherwise your approach may not buy you anything.

As an aside, in .Net remoting it is possible to have a reference to a remote object (i.e. you client can reference the object on the server) – if the type itself derives from MarshalByRefObject, but that is not the case here with WCF – you end up with your own copy locally.