Générique de la requête POST à l'aide de Microsoft.HttpClient et HttpContentExtensions

Je suis en utilisant le très impressionnant HttpClient fournis dans la WCF REST Kit de démarrage. J'ai la méthode suivante qui va à l'encontre de la HelloTxt API:

public UserValidateResponse Validate()
{
    HttpClient client = new HttpClient(baseUrl);

    HttpMultipartMimeForm form = new HttpMultipartMimeForm();
    form.Add("app_key", this.AppKey);
    form.Add("user_key", this.UserKey);
    HttpResponseMessage response = client.Post("user.validate", form.CreateHttpContent());

    return response.Content.ReadAsXmlSerializable<UserValidateResponse>();
}

J'ai un beau générique GetRequest méthode qui ressemble à ceci:

public T GetRequest<T>(string query)
{
    HttpClient client = new HttpClient(baseUrl);
    client.DefaultHeaders.UserAgent.AddString(@"http://www.simply-watches.co.uk/");

    HttpResponseMessage response = client.Get(query);
    response.EnsureStatusIsSuccessful();

    T data = default(T);
    try
    {
        data = response.Content.ReadAsXmlSerializable<T>();
        return data;
    }
    catch (Exception ex)
    {
        Console.Write(String.Format("{0}: {1}", ex.Message, ex.InnerException.Message));
    }

    return data;
}

L'avantage est que vous pouvez passe-T-il que le type de réponse que par ce aléatoire exemple:

public List<User> GetUsers(int deptid)
{
    string query = String.Format("department.getUsers?api_key={0}&dept_id={1}", this.APIKey, deptId);

    return GetRequest<List<User>>(query);
}

Je veux le même style générique de la méthode POST, plutôt que d'OBTENIR et je suis sûr que je peux utiliser le HttpContentExtensions, mais je ne peux pas comprendre comment transformer la demande en un HttpMultipartMimeForm. c'est ce que j'ai à ce jour:

public T PostRequest<K, T>(string query, K request)
{
    HttpClient client = new HttpClient(baseUrl);
    //the following line doesn't work! Any suggestions?
    HttpContent content = HttpContentExtensions.CreateDataContract<K>(request, Encoding.UTF8, "application/x-www-form-urlencoded", typeof(HttpMultipartMimeForm));

    HttpResponseMessage response = client.Post(query, content);
    response.EnsureStatusIsSuccessful();

    T data = default(T);
    try
    {
        data = response.Content.ReadAsXmlSerializable<T>();
        return data;
    }
    catch (Exception ex)
    {
        Console.Write(String.Format("{0}: {1}", ex.Message, ex.InnerException.Message));
    }

    return data;
}

Il serait appelé comme ceci:

UserValidateResponse response = PostRequest<UserValidateRequest, UserValidateResponse>("user.validate", new UserValidateRequest(this.AppKey, this.UserKey));

C'est de travailler à l'encontre de cette API: http://hellotxt.com/developers/documentation. Toutes les suggestions sont bienvenues! Je pourrais définir une forme différente pour chaque POSTE, mais il serait bien de faire cela d'une manière générique.

  • J'ai le sentiment que la seule façon de le faire est d'utiliser la réflexion et de construire un HttpMultipartMimeForm basé sur le simple des propriétés d'une classe, ou de sérialiser l'objet, puis le premier des enfants en vertu de la racine nœud XML.
InformationsquelleAutor Rebecca | 2011-01-20
  1. 2

    J'ai répondu à ma propre question. Le code peut être vu dans mon .NET wrapper pour la HelloTxt API - HelloTxt.NET, et comme pour mon commentaire ci-dessus, utilise la réflexion pour travailler sur les propriétés de l'objet request, et remplit un HttpMultipartMimeForm() avec les valeurs, tout en vérifiant la Required données annotions sur les propriétés de la classe.

    Le code en question est:

    ///<summary>
///Generic post request.
///</summary>
///<typeparam name="K">Request Type</typeparam>
///<typeparam name="T">Response Type</typeparam>
///<param name="query">e.g. user.validate</param>
///<param name="request">The Request</param>
///<returns></returns>
public T PostRequest<K, T>(string query, K request)
{
using (var client = GetDefaultClient())
{
//build form data post
HttpMultipartMimeForm form = CreateMimeForm<K>(request);
//call method
using (HttpResponseMessage response = client.Post(query, form.CreateHttpContent()))
{
response.EnsureStatusIsSuccessful();
return response.Content.ReadAsXmlSerializable<T>();
}
}
}
///<summary>
///Builds a HttpMultipartMimeForm from a request object
///</summary>
///<typeparam name="T"></typeparam>
///<param name="request"></param>
///<returns></returns>
public HttpMultipartMimeForm CreateMimeForm<T>(T request)
{
HttpMultipartMimeForm form = new HttpMultipartMimeForm();
Type type = request.GetType();
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo property in properties)
{
foreach (Attribute attribute in property.GetCustomAttributes(true))
{
RequiredAttribute requiredAttribute = attribute as RequiredAttribute;
if (requiredAttribute != null)
{
if (!requiredAttribute.IsValid(property.GetValue(request, null)))
{
//Console.WriteLine("{0} [type = {1}] [value = {2}]", property.Name, property.PropertyType, property.GetValue(property, null));
throw new ValidationException(String.Format("{0} [type = {1}] requires a valid value", property.Name, property.PropertyType));
}
}
}
if (property.PropertyType == typeof(FileInfo))
{
FileInfo fi = (FileInfo)property.GetValue(request, null);
HttpFormFile file = new HttpFormFile();
file.Content = HttpContent.Create(fi, "application/octet-stream");
file.FileName = fi.Name;
file.Name = "image";
form.Files.Add(file);
}
else
{
form.Add(property.Name, String.Format("{0}", property.GetValue(request, null)));
}
}
return form;
}
    • Le github lien que vous avez fourni est cassé.
    InformationsquelleAutor Rebecca