Added strongly-typed message handler.

Author: Pathoschild

Client/Default/FluentClient.cs

@@ -5,7 +5,9 @@
 namespace Pathoschild.Http.Client.Default
 {
 	/// <summary>Sends HTTP requests and receives responses from a resource identified by a URI.</summary>
-	public class FluentClient : IClient
+	/// <typeparam name="TMessageHandler">The HTTP message handler type.</typeparam>
+	public class FluentClient<TMessageHandler> : IClient<TMessageHandler>
+		where TMessageHandler : HttpMessageHandler
 	{
 		/*********
 		** Accessors
@@ -14,7 +16,7 @@ public class FluentClient : IClient
 		public HttpClient BaseClient { get; protected set; }
 
 		/// <summary>The underlying HTTP message handler.</summary>
-		public HttpClientHandler MessageHandler { get; protected set; }
+		public TMessageHandler MessageHandler { get; protected set; }
 
 		/// <summary>The formatters used for serializing and deserializing message bodies.</summary>
 		public MediaTypeFormatterCollection Formatters { get; protected set; }
@@ -26,20 +28,10 @@ public class FluentClient : IClient
 		/// <summary>Construct an instance.</summary>
 		/// <param name="client">The underlying HTTP client.</param>
 		/// <param name="handler">The underlying HTTP message handler. This should be the same handler used by the <paramref name="client"/>.</param>
-		public FluentClient(HttpClient client, HttpClientHandler handler)
-		{
-			this.MessageHandler = handler;
-			this.BaseClient = client;
-			this.Formatters = new MediaTypeFormatterCollection();
-		}
-
-		/// <summary>Construct an instance.</summary>
 		/// <param name="baseUri">The base URI prepended to relative request URIs.</param>
-		public FluentClient(string baseUri)
+		public FluentClient(HttpClient client, TMessageHandler handler, string baseUri = null)
 		{
-			this.MessageHandler = new HttpClientHandler();
-			this.BaseClient = new HttpClient(this.MessageHandler, true) { BaseAddress = new Uri(baseUri) };
-			this.Formatters = new MediaTypeFormatterCollection();
+			this.Initialize(client, handler, baseUri);
 		}
 
 		/// <summary>Create an asynchronous HTTP DELETE request message (but don't dispatch it yet).</summary>
@@ -113,5 +105,44 @@ public virtual IRequestBuilder Send(HttpRequestMessage message)
 		{
 			return new RequestBuilder(message, this.Formatters, request => this.BaseClient.SendAsync(request.Message));
 		}
+
+
+		/*********
+		** Protected methods
+		*********/
+		/// <summary>Construct an uninitialized instance.</summary>
+		protected FluentClient() {}
+
+		/// <summary>Initialize the client.</summary>
+		/// <param name="client">The underlying HTTP client.</param>
+		/// <param name="handler">The underlying HTTP message handler. This should be the same handler used by the <paramref name="client"/>.</param>
+		/// <param name="baseUri">The base URI prepended to relative request URIs.</param>
+		protected void Initialize(HttpClient client, TMessageHandler handler, string baseUri = null)
+		{
+			this.MessageHandler = handler;
+			this.BaseClient = client;
+			if (baseUri != null)
+				this.BaseClient.BaseAddress = new Uri(baseUri);
+			this.Formatters = new MediaTypeFormatterCollection();
+		}
+	}
+
+	/// <summary>Sends HTTP requests and receives responses from a resource identified by a URI.</summary>
+	public class FluentClient : FluentClient<HttpClientHandler>, IClient
+	{
+		/// <summary>Construct an instance.</summary>
+		/// <param name="client">The underlying HTTP client.</param>
+		/// <param name="handler">The underlying HTTP message handler. This should be the same handler used by the <paramref name="client"/>.</param>
+		/// <param name="baseUri">The base URI prepended to relative request URIs.</param>
+		public FluentClient(HttpClient client, HttpClientHandler handler, string baseUri = null)
+			: base(client, handler, baseUri) { }
+
+		/// <summary>Construct an instance.</summary>
+		/// <param name="baseUri">The base URI prepended to relative request URIs.</param>
+		public FluentClient(string baseUri)
+		{
+			var handler = new HttpClientHandler();
+			this.Initialize(new HttpClient(handler), handler, baseUri);
+		}
 	}
 }

Client/IClient.cs

@@ -4,7 +4,9 @@
 namespace Pathoschild.Http.Client
 {
 	/// <summary>Sends HTTP requests and receives responses from a resource identified by a URI.</summary>
-	public interface IClient
+	/// <typeparam name="TMessageHandler">The HTTP message handler type.</typeparam>
+	public interface IClient<out TMessageHandler>
+		where TMessageHandler : HttpMessageHandler
 	{
 		/*********
 		** Accessors
@@ -13,7 +15,7 @@ public interface IClient
 		HttpClient BaseClient { get; }
 
 		/// <summary>The underlying HTTP message handler.</summary>
-		HttpClientHandler MessageHandler { get; }
+		TMessageHandler MessageHandler { get; }
 
 		/// <summary>The formatters used for serializing and deserializing message bodies.</summary>
 		MediaTypeFormatterCollection Formatters { get; }
@@ -67,4 +69,7 @@ public interface IClient
 		/// <returns>Returns a request builder.</returns>
 		IRequestBuilder Send(HttpRequestMessage message);
 	}
+
+	/// <summary>Sends HTTP requests and receives responses from a resource identified by a URI.</summary>
+	public interface IClient : IClient<HttpClientHandler> { }
 }

README.md

@@ -50,7 +50,7 @@ And you can do everything asynchronously:
         .AsAsync<Idea>();
 ```
 
-And you can access the [underlying HTTP message handler][HttpClientHandler], or inject your own to do pretty much whatever you want. The default handler lets you configure a range of features like authentication, cookies, and proxying:
+And you can configure a range of features like credentials and cookies using the default [HTTP message handler][HttpClientHandler]:
 ```c#
      client.MessageHandler.Credentials = new NetworkCredential("username", "password");
      client.MessageHandler.CookieContainer.Add(new Cookie(...));
@@ -59,23 +59,32 @@ And you can access the [underlying HTTP message handler][HttpClientHandler], or
 
 The code documentation provides more details on usage: see [IClient][], [IRequestBuilder][], and [IResponse][].
 
-## Configurable formatting
-The client uses .NET's [MediaTypeFormatter][]s for serializing and deserializing HTTP messages. This is the same type used by the underlying HttpClient and the .NET Web API, and the client uses Microsoft's default formatters out of the box. When creating a client for an ASP.NET Web API, this lets you seamlessly use the same formatters on both sides.
+## Extension
+### Custom formats
+The client uses .NET's [MediaTypeFormatter][]s for serializing and deserializing HTTP messages — the same ones used by the HttpClient itself and the ASP.NET Web API. The client uses Microsoft's default formatters by default. When creating a client for an ASP.NET Web API, this lets you seamlessly use the same formatters on both sides.
 
-You can use any of the many implementations already available, create your own ([MediaTypeFormatterBase][] might help), or use one of the formatters below. For example, to replace the default JSON formatter with the formatter below:
+You can use any of the many implementations already available (including the Json.NET formatters below), or create your own ([MediaTypeFormatterBase][] might help). For example, to replace the default JSON formatter with the formatter below:
 ```c#
      IClient client = new FluentClient("http://example.org/api/");
      client.Formatters.Remove(client.Formatters.JsonFormatter);
      client.Formatters.Add(new JsonNetFormatter());
 ```
 
-### Json.NET
+#### Json.NET
 The [Pathoschild.Http.Formatters.JsonNet][] package provides three formats using [Json.NET][]: [BSON][] (`application/bson`), [JSON][] (`application/json`, `text/json`), and [JSONP][] (`application/javascript`, `application/ecmascript`, `text/javascript`, `text/ecmascript`). JSONP requests can include an optional `callback` query parameter that specifies the JavaScript method name to invoke.
 ```c#
      client.Formatters.Add(new JsonNetBsonFormatter());
      client.Formatters.Add(new JsonNetFormatter());
 ```
 
+### Custom message handler
+You can inject your own [HTTP message handler][HttpClientHandler] to do pretty much anything you want. For example, you could easily create a custom handler for unit tests which talks directly to a mock without actual HTTP calls:
+```c#
+     UnitTestHandler handler = new UnitTestHandler() { WasCalled = false };
+     IClient<UnitTestHandler> client = new FluentClient(new HttpClient(handler), handler);
+     bool wasCalled = client.MessageHandler.WasCalled; // strongly-typed access to the handler
+```
+
 [HttpClient]: http://code.msdn.microsoft.com/Introduction-to-HttpClient-4a2d9cee
 [HttpClientHandler]: http://msdn.microsoft.com/en-us/library/system.net.http.httpclienthandler.aspx
 [HttpRequestMessage]: http://msdn.microsoft.com/en-us/library/system.net.http.httprequestmessage.aspx

Tests/Default/ClientTests.cs

@@ -1,6 +1,7 @@
 using System.Net.Http;
 using NUnit.Framework;
 using Pathoschild.Http.Client;
+using Pathoschild.Http.Client.Default;
 
 namespace Pathoschild.Http.Tests.Default
 {
@@ -149,7 +150,7 @@ protected IClient ConstructClient(string baseUri = "http://example.com/", bool i
 			try
 			{
 				// execute
-				IClient client = new Client.Default.FluentClient(baseUri);
+				IClient client = new FluentClient(baseUri);
 
 				// verify
 				Assert.NotNull(client.BaseClient, "The base client is null.");