C# Odata v4 open type raw values

<#@ Import Namespace="Microsoft.OData.Edm.Vocabularies.Community.V1" #>

tmp.FindDeclaredValueTerm(AlternateKeysVocabularyConstants.AlternateKeys) != null)

internal abstract void WriteEntityTypeAttribute();

$expand=Building 

[EnableQuery]
public IHttpActionResult GetBuildingDistances()
{
    ...
    var query =
        db.t_building.Select(
            x =>
                new BuildingDistance
                {
                    Id = x.id,
                    Street = x.location_street,
                    Building = x,
                    Distance = x.GeoLocation.Distance(myLocation)
                });
    return Ok(query as IQueryable<BuildingDistance);
}

public class User
{
    public long UserId { get; set; }

    public string UserName { get; set; }
}

public IHttpActionResult Post(User user)

{
    "UserId": "0",
    "UserName": "test",
    "UserPassword": "test"
}

{
    "error": {
        "code": "",
        "message": "The request is invalid.",
        "innererror": {
            "message": "user : Does not support untyped value in non-open type.\r\n",
            "type": "",
            "stacktrace": ""
        }
    }
}

public class MongoDataSerializer: ODataResourceSerializer
{
    public MongoDataSerializer(ODataSerializerProvider serializerProvider)
        : base(serializerProvider)
    {
    }

    /// <summary>
    /// Serializes the open complex type as an <see cref="ODataUntypedValue"/>.
    /// </summary>
    /// <param name="graph"></param>
    /// <param name="expectedType"></param>
    /// <param name="writer"></param>
    /// <param name="writeContext"></param>
    public override void WriteObjectInline(
        object graph,
        IEdmTypeReference expectedType,
        ODataWriter writer,
        ODataSerializerContext writeContext)
    {
        // This cast is safe because the type is checked before using this serializer.
        var mongoData = (MongoData)graph;
        var properties = new List<ODataProperty>();

        foreach (var item in mongoData.Document)
        {
            properties.Add(new ODataProperty
            {
                Name = item.Key,
                Value = new ODataUntypedValue
                {
                    RawValue = JsonConvert.SerializeObject(item.Value),
                },
            });
        }

        writer.WriteStart(new ODataResource
        {
            TypeName = expectedType.FullName(),
            Properties = properties,
        });

        writer.WriteEnd();
    }
}

public class CustomODataSerializerProvider : DefaultODataSerializerProvider
{
    private readonly MongoDataSerializer mongoDataSerializer;

    public CustomODataSerializerProvider(
        IServiceProvider odataServiceProvider)
        : base(odataServiceProvider)
    {
        this.mongoDataSerializer = new MongoDataSerializer(this);
    }

    public override ODataEdmTypeSerializer GetEdmTypeSerializer(IEdmTypeReference edmType)
    {
        if (edmType.FullName() == typeof(MongoData).FullName)
        {
            return this.mongoDataSerializer;
        }

        return base.GetEdmTypeSerializer(edmType);
    }
}

        app.UseMvc(options =>
        {
            var model = builder.GetEdmModel();
            options
                .MapODataServiceRoute(
                    "odata",
                    "odata",
                    b => b
                            .AddService(Microsoft.OData.ServiceLifetime.Scoped, s => model)
                            .AddService<IEnumerable<IODataRoutingConvention>>(
                                Microsoft.OData.ServiceLifetime.Scoped,
                                s => ODataRoutingConventions.CreateDefaultWithAttributeRouting("odata", options))
                            .AddService<ODataSerializerProvider, CustomODataSerializerProvider>(Microsoft.OData.ServiceLifetime.Singleton));
        }