WebAPI Modèle Personnalisé de liaison du complexe objet abstrait

C'est une question difficile. J'ai un problème avec la liaison d'un modèle de JSON. Je suis en essayant de résoudre les polymorphes-allié de l'enregistrement fourni avec le type d'enregistrement qui sera résolu (je veux être en mesure d'ajouter de nombreux types d'enregistrement dans le futur). J'ai tenté d'utiliser le l'exemple suivant pour résoudre mon modèle lors de l'appel de l'extrémité cependant, cet exemple ne fonctionne que pour MVC et Web API des applications.

J'ai tenté de l'écrire à l'aide IModelBinder et BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext). Cependant je ne trouve pas l'équivalent de ModelMetadataProviders dans le Système.Web.Espace de noms Http.

D'apprécier l'aide n'importe qui peut donner.

J'ai une Web API 2 application qui a la suite de la structure de l'objet.

public abstract class ResourceRecord
{
    public abstract string Type { get; }
}

public class ARecord : ResourceRecord
{
    public override string Type
    {
        get { return "A"; }
    }

    public string AVal { get; set; }

}

public class BRecord : ResourceRecord
{
    public override string Type
    {
        get { return "B"; }
    }

    public string BVal { get; set; }
}

public class RecordCollection
{
    public string Id { get; set; }

    public string Name { get; set; }

    public List<ResourceRecord> Records { get; }

    public RecordCollection()
    {
        Records = new List<ResourceRecord>();
    }
}

Structure JSON

{
  "Id": "1",
  "Name": "myName",
  "Records": [
    {
      "Type": "A",
      "AValue": "AVal"
    },
    {
      "Type": "B",
      "BValue": "BVal"
    }
  ]
}

Double Possible de l'Api Web de la Liaison de Modèle et Polymorphe de l'Héritage
C'est l'exemple que j'utilise dans ma question. La réponse à cette question est pour la liaison de modèle MVC et j'ai besoin de l'API Web de la liaison de modèle.

OriginalL'auteur garyamorris | 2016-05-17

Après quelques recherches, j'ai découvert que les fournisseurs de métadonnées n'existent pas au sein de WebAPI, et afin de se lier au complexe abstrait des objets, vous devez écrire votre propre.

J'ai commencé par l'écriture d'un nouveau modèle de liaison de la méthode, avec l'utilisation d'un nom du type personnalisé sérialiseur JSon et enfin j'ai mis à jour mon point de terminaison d'utiliser le classeur personnalisé. Il vaut la peine de souligner ce qui suit ne fonctionne qu'avec les demandes dans le corps, vous aurez à écrire quelque chose d'autre pour les demandes dans l'en-tête. Je suggère une lecture du chapitre 16 d'Adam Freeman Expert ASP.NET Web API 2 pour MVC Développeurs et complexe de liaison de l'objet.

J'ai été en mesure de sérialiser mon objet dans le corps de la demande à l'aide du code suivant.

WebAPI configuration

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        config.Services.Insert(typeof(ModelBinderProvider), 0,
            new SimpleModelBinderProvider(typeof(RecordCollection), new JsonBodyModelBinder<RecordCollection>()));
    }
}

Modèle de liaison personnalisé

public class JsonBodyModelBinder<T> : IModelBinder
{
    public bool BindModel(HttpActionContext actionContext,
        ModelBindingContext bindingContext)
    {
        if (bindingContext.ModelType != typeof(T))
        {
            return false;
        }

        try
        {
            var json = ExtractRequestJson(actionContext);

            bindingContext.Model = DeserializeObjectFromJson(json);

            return true;
        }
        catch (JsonException exception)
        {
            bindingContext.ModelState.AddModelError("JsonDeserializationException", exception);

            return false;
        }


        return false;
    }

    private static T DeserializeObjectFromJson(string json)
    {
        var binder = new TypeNameSerializationBinder("");

        var obj = JsonConvert.DeserializeObject<T>(json, new JsonSerializerSettings
        {
            TypeNameHandling = TypeNameHandling.Auto,
            Binder = binder
        });
        return obj;
    }

    private static string ExtractRequestJson(HttpActionContext actionContext)
    {
        var content = actionContext.Request.Content;
        string json = content.ReadAsStringAsync().Result;
        return json;
    }
}

La Sérialisation personnalisée de liaison

public class TypeNameSerializationBinder : SerializationBinder
{
    public string TypeFormat { get; private set; }

    public TypeNameSerializationBinder(string typeFormat)
    {
        TypeFormat = typeFormat;
    }

    public override void BindToName(Type serializedType, out string assemblyName, out string typeName)
    {
        assemblyName = null;
        typeName = serializedType.Name;
    }

    public override Type BindToType(string assemblyName, string typeName)
    {
        string resolvedTypeName = string.Format(TypeFormat, typeName);

        return Type.GetType(resolvedTypeName, true);
    }
}

Définition du point final

    [HttpPost]
    public void Post([ModelBinder(BinderType = typeof(JsonBodyModelBinder<RecordCollection>))]RecordCollection recordCollection)
    {
    }

N'est pas le dernier return false; instruction dans le BindModel la mise en œuvre du code inaccessible?

OriginalL'auteur garyamorris

La TypeNameSerializationBinder classe n'est plus nécessaire, ainsi que la WebApiConfig de configuration.

Tout d'abord, vous devez créer enum pour le type d'enregistrement:

public enum ResourceRecordTypeEnum
{
    a,
    b
}

Ensuite, modifiez votre champ "Type" dans ResourceRecord à l'énumération que nous venons de créer:

public abstract class ResourceRecord
{
    public abstract ResourceRecordTypeEnum Type { get; }
}

Maintenant, vous devez créer ces 2 classes:

Modèle De Classeur

public class ResourceRecordModelBinder<T> : IModelBinder
{
    public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
    {
        if (bindingContext.ModelType != typeof(T))
            return false;

        try
        {
            var json = ExtractRequestJson(actionContext);
            bindingContext.Model = DeserializeObjectFromJson(json);
            return true;
        }
        catch (JsonException exception)
        {
            bindingContext.ModelState.AddModelError("JsonDeserializationException", exception);
            return false;
        }
    }

    private static T DeserializeObjectFromJson(string json)
    {
        //This is the main part of the conversion
        var obj = JsonConvert.DeserializeObject<T>(json, new ResourceRecordConverter());
        return obj;
    }

    private string ExtractRequestJson(HttpActionContext actionContext)
    {
        var content = actionContext.Request.Content;
        string json = content.ReadAsStringAsync().Result;
        return json;
    }
}

Classe de convertisseur de

public class ResourceRecordConverter : CustomCreationConverter<ResourceRecord>
{
    private ResourceRecordTypeEnum _currentObjectType;

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var jobj = JObject.ReadFrom(reader);
        //jobj is the serialized json of the reuquest
        //It pulls from each record the "type" field as it is in requested json,
        //in order to identify which object to create in "Create" method
        _currentObjectType = jobj["type"].ToObject<ResourceRecordTypeEnum>();
        return base.ReadJson(jobj.CreateReader(), objectType, existingValue, serializer);
    }

    public override ResourceRecord Create(Type objectType)
    {
        switch (_currentObjectType)
        {
            case ResourceRecordTypeEnum.a:
                return new ARecord();
            case ResourceRecordTypeEnum.b:
                return new BRecord();
            default:
                throw new NotImplementedException();
        }
    }
}

Contrôleur

[HttpPost]
public void Post([ModelBinder(BinderType = typeof(ResourceRecordModelBinder<RecordCollection>))] RecordCollection recordCollection)
{ 
}

OriginalL'auteur MasterPiece

Vous devez vous connecter pour publier un commentaire.