DataContractSerializer，为什么“ this”没有被转换？

Question

I'm working on a server coded with F#. This server connects to a WCF REST service coded with C#.

My F# project is referencing the C# assembly.

In my C# I have namespace GlobalNotificationService.DTO :

public class Producer
{
    [DataMember(Name = "Name", IsRequired = true, Order = 1)]
    public string Name {get; set;}
    ...
    public string Marshal()
    {
        StringBuilder sb = new StringBuilder();
        using (XmlTextWriter textWriter = new XmlTextWriter(new StringWriter(sb)))
        {
            DataContractSerializer serializer = new DataContractSerializer(typeof(DTO.Producer));                
            serializer.WriteObject(textWriter, this); //THIS IS THE LINE THROWING THE EXECPTION
            textWriter.Flush();
            textWriter.Close();
            return sb.ToString();
        }
    }
}

In my F# I have namespace ServiceCore :

type Producer(file_name) as this =
    inherit DTO.Producer()
    ...
    member public this.SerializedXML
        with get() = this.Marshal() //Call to C# assembly

So the code does compile but I get this exception at run time (look for the comment above) .

Type 'ServiceCore.Producer' with data contract name 'Producer:http://schemas.datacontract.org/2004/07/ServiceCore' is not expected. Consider using a DataContractResolver or add any types not known statically to the list of known types - for example, by using the KnownTypeAttribute attribute or by adding them to the list of known types passed to DataContractSerializer.

The question is:

Why is "this" of type ServiceCode.Producer (F#) even though it should have been upcasted to DTO.Producer (C#) since the method is in the DTO.Producer class and that I'm explicitly asking for a DTO.Producer serialization?

Complementary question:

Why do we even care about the fact that the call is coming from a descendant class? Our "this" reference should still be up-casted and be of type DTO.Producer .

It doesn't make a lot of sence to me, am I missing something?

Answer 1

Since you're explicitly instantiating the DCS in Marshal, you could change its definition to to be

public string Marshal<T>() 
...
    new DataContractSerializer(typeof<T>) ...

and then the F# code could call Marshal with its own subtype.

Answer 2

There is no automatic upcast in serialization. You have to tell the serializer explicitly what types are equivalent to other types.

For the base type (DTO.Producer) you have to add a

[KnownType(typeof(ServiceCode.Producer)]

You might also be able to try and explicitly cast the object to DTO.Producer in the Marshal call, but that might not work.