Nagornev.Querer.Http 1.1.1

Nagornev.Querer.Http

Information

This library was created to simplify working with the HTTP protocol by creating and handling requests in isolation.

Installation

Install the current version with dotnet:

dotnet add package Nagornev.Querer.Http

Usage

Quick start

Use this code to send an HTTP GET-request to the server httpbin. You will receive data about your request in JSON format.

QuererHttpClient client = new QuererHttpClient();


QuererHttpRequestMessageCompiler compiler = QuererHttpRequestMessageCompilerBuilder
                                                .Create()
                                                    .UseMethod(c => c.Set(HttpMethod.Post))
                                                    .UseUrl(c => c.Set("http://httpbin.org/post"))
                                                    .UseHeaders(c => c.Set(new Dictionary<string, string>()
                                                                           {
                                                                               { "Quick-Start-Header-Key", "QuickStartHeaderValue"}    
                                                                           }))
                                                    .UseContent(c => c.Set(new Dictionary<string, string>()
                                                                           {
                                                                              { "quickStartContentKey", "QuickStartContentValue"} 
                                                                           }))
                                                    .UseScheme(s => s.Default())
                                                .Build();

QuererHttpResponseMessageHandler<string> handler = QuererHttpResponseMessageHandlerBuilder<string>
                                                       .Create()
                                                           .UseConfigure(h => h.SetFailure(options => options.AddFailure<Exception>((response, excepion) => "Failure content"))
                                                                               .SetLogger(options=> options.AddConsole()))
                                                           .UsePreview(h => h.Set(response => response.StatusCode == HttpStatusCode.OK))
                                                           .UseContent(h => h.Set(response => response.GetText())
                                                                             .Confirm(content => !string.IsNullOrEmpty(content)))
                                                           .UseScheme(s => s.Default())
                                                       .Build();

await client.SendAsync(compiler, handler);

Console.WriteLine(handler.Content);

How to use it?

The main advantages of using Nagornev.Querer.Http is the creation requests and handing responses in isolation.

Request:

You can create a class for the request implementing QuererHttpRequestMessageCompiler:

public class Request : QuererHttpRequestMessageCompiler
{
    protected override void SetMethod(MethodCompiler compiler)
    {
        compiler.Set(HttpMethod.Get);
    }

    protected override void SetUrl(UrlCompiler compiler)
    {
        compiler.Set(new Uri("https://httpbin.org/get"));
    }

    protected override void SetContent(ContentCompiler compiler)
    {
        compiler.Set(new Dictionary<string, string>()
        {
            { "ContentKey", "ContentValue" }
        });
    }

    protected override void SetHeaders(HeadersCompiler compiler)
    {
        compiler.Set(new Dictionary<string, string>()
        {
            { "HeaderKey", "HeaderValue" }
        });
    }

    protected override void SetRequest(RequestCompiler compiler)
    {
        compiler.Set(request =>
        {
            //Do something with HttpRequestMessage
        });
    }

    protected override IEnumerable<Scheme.Set> SetScheme(Scheme scheme)
    {
        return scheme.Configure(scheme.Method, scheme.Url, scheme.Content, scheme.Headers, scheme.Request);
    }
}

To configure the request, you can override the following methods:

• SetMethod(compiler) - sets request method;
• SetUrl(compiler) - sets request url;
• SetContent(compiler) - sets request content;
• SetHeaders(compiler) - sets request headers;
• SetRequest(compiler) - sets any parameters HttpRequestMessage;
• SetScheme(schme) - sets compilation order;

Response:

You can create a class for the response implementing QuererHttpResponseMessageHandler<T>:

public class Response : QuererHttpResponseMessageHandler<string>
{
    protected override void Configure(InvokerOptionsBuilder options)
    {
        options.SetFailure(options =>
                           {
                               options.AddFailure<Exception>((response, exception) =>
                               {
                                   return "Failure content.";
                               });
                           })
               .SetLogger(options => options.AddConsole());
    }

    protected override void SetPreview(PreviewHandler handler)
    {
        handler.Set(response => response.StatusCode == HttpStatusCode.OK);
    }

    protected override void SetContent(ContentHandler handler)
    {
        handler.Set(response => response.GetText())
               .Confirm(content => !string.IsNullOrEmpty(content));
    }

    protected override IEnumerable<Scheme.Set> SetScheme(Scheme scheme)
    {
        return scheme.Configure(scheme.Preview, scheme.Content);
    }
}

To configure the response, you can override the following methods:

• Configure(options) - sets handling options. SetFailure(IvokerOptionsBuilder) - sets the methods to handle unhandled exceptions. SetLogger(QuererLoggerBuilder) - sets the handling loggers.
• SetPreview(handler) - sets HttpResponseMessage confirmations. This handler is needed to make sure that the response from the server is correct;
• SetContent(handler) - sets property QuererHttpResponseMessageHandler<T>.Content;
• SetScheme(scheme)- sets compilation order;

Sending:

You can send request and handle response with method QuererHttpClient.SendAsync():

var compiler = new Request();
var handler = new Response();

var client = new QuererHttpClient();

await client.SendAsync(compiler, handler);