http://msdn.microsoft.com/en-us/library/system.runtime.serialization.configuration.datacontractserializersection.aspx

[ServiceContract(Namespace = "MyServices")]
public interface ICarService
{
[OperationContract]
//[ServiceKnownType(typeof(PriusCarInfo))] –old / static way of providing type
//[ServiceKnownType(typeof(LexusCarInfo))] –old / static way of providing type
[ServiceKnownType("GetKnownTypes", typeof(ServiceKnownTypeProvider))] –factory will use IOC to resolve types for all discovered RegisterServiceKnownType attributes
[RegisterServiceKnownType(typeof(ICarInfo))] –custom attribute used by ServiceKnownTypeProvider to dynamically register types via IOC
ICarInfo GetCarInfo(int carId);
}

Thank for the reply. To be honest I am new to WCF and not have experience in developing web service and wcf service.
You mean to say I just have to create object with the details i want to send, then wcf will automatically serialize/deserialize it to xml.

why would you send xml yourself?

it’s far easier to just define request/response types with the properties of the data that needs to be included in your calls… WCF will serialize/deserialize to xml (well, soap actually) automatically for you


KnownTypeProvider.RegisterDerivedTypesOf(assembly);



private static IEnumerable GetDerivedTypesOf(Type baseType, IEnumerable types)
{
//return types.Where(t => !t.IsAbstract && t.IsSubclassOf(baseType)).ToList();
return types.Where(t => !t.IsAbstract && baseType.IsAssignableFrom(t)).ToList();
}

This way I can send do something like
KnownTypeProvider(someAssembly);

it might be… i thought that registering the know types before the first service request is received was enough… it might be because i primarily use it with IIS and maybe it creates the service host as late as possible or something (as in: when the first requests is received)

If the assemblies containing the requests and responses are shared between the client and the server, using the NetDataContractSerializer can help since known types must not be declared for operations.
But you need to tweak the serialization in the fault channel since it keeps using the DataContractSerializer to serialize FaultException

if that is the only place where it’s used like that, then why would i? what would be the difference between doing it yourself, or having some other kind of infrastructural library doing it for you?

if you were to do that all over the place, then yeah it would definitely bother me. But if it’s only in one place, in a piece of infrastructural code that you never need to change, then i really don’t think there’s any _real_ problem there.