Adding a way to initialize ServiceClient using provided HttpClient

src/ClientRuntime/Microsoft.Rest.ClientRuntime.Tests/Fakes/FakeServiceClient.cs

@@ -18,6 +18,10 @@ public FakeServiceClient()
             // Prevent base constructor from executing
         }
 
+        public FakeServiceClient(HttpClient httpClient)
+            : base(httpClient)
+        { }
+
         public FakeServiceClient(HttpClientHandler httpMessageHandler, params DelegatingHandler[] handlers)
             : base(httpMessageHandler, handlers)
         {

src/ClientRuntime/Microsoft.Rest.ClientRuntime.Tests/ServiceClientTests.cs

@@ -10,6 +10,7 @@
 using Xunit;
 using System.Net.Http.Headers;
 using System.Diagnostics;
+using Microsoft.Rest.ClientRuntime.Tests.SvcClients;
 
 namespace Microsoft.Rest.ClientRuntime.Tests
 {
@@ -109,6 +110,16 @@ public void RetryHandlerRetriesWith500Errors()
             Assert.Equal(2, attemptsFailed);
         }
 
+        [Fact]
+        public void FakeSvcClientWithHttpClient()
+        {
+            HttpClient hc = new HttpClient(new ContosoMessageHandler());
+            var fakeClient = new FakeServiceClient(hc);
+            HttpResponseMessage response = fakeClient.DoStuffSync("Hello");
+            string responseContent = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+            Assert.Equal("Contoso Rocks", responseContent);
+        }
+
         [Fact]
         public void RetryHandlerRetriesWith500ErrorsAndSucceeds()
         {
@@ -214,7 +225,7 @@ public void AddUserAgentInfoWithVersion()
             Assert.True(testProduct.Product.Name.Equals(testProductName));
             Assert.True(testProduct.Product.Version.Equals(testProductVersion));
         }
-
+        
 #if NET451
         [Fact]
         public void VerifyOsInfoInUserAgent()
@@ -230,6 +241,10 @@ public void VerifyOsInfoInUserAgent()
             Assert.NotEmpty(osProduct.Product.Name);
             Assert.NotEmpty(osProduct.Product.Version);
         }
+
+
+
+
 #endif
     }
 }

src/ClientRuntime/Microsoft.Rest.ClientRuntime.Tests/SvcClientWithHttpClientTests.cs

@@ -0,0 +1,51 @@
+using Microsoft.Rest.ClientRuntime.Tests.SvcClients;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Microsoft.Rest.ClientRuntime.Tests
+{
+    public class SvcClientWithHttpClientTests
+    {
+        [Fact]
+        public void InitializeServiceClientWithHttpClient()
+        {
+            HttpClient hc = new HttpClient();
+            ContosoServiceClient contosoClient = new ContosoServiceClient(hc);
+            HttpResponseMessage response = contosoClient.DoSyncWork();
+            Assert.NotNull(response);
+        }
+
+        [Fact]
+        public void GetInitializedHttpClient()
+        {
+            ContosoServiceClient contosoClient = new ContosoServiceClient(null);
+            HttpResponseMessage response = contosoClient.DoSyncWork();
+            string cont = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+            Assert.NotNull(response);
+        }
+
+        [Fact]
+        public void InitializeMessageHandlerPostContructor()
+        {
+            HttpClient hc = new HttpClient(new ContosoMessageHandler());
+            ContosoServiceClient contosoClient = new ContosoServiceClient(hc);
+            HttpResponseMessage response = contosoClient.DoSyncWork("Hello");
+            string cont = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+            Assert.Equal("Contoso Rocks", cont);
+        }
+
+        [Fact]
+        public void ProvideHttpClientAfterInitialization()
+        {
+            DelegatingHandler[] handlers = new ContosoMessageHandler[] { new ContosoMessageHandler() };
+            ContosoServiceClient contosoClient = new FabricamServiceClient(new HttpClientHandler(), handlers);
+            HttpResponseMessage response = contosoClient.DoSyncWork();
+            string cont = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+            Assert.Equal("Delayed User Provided HttpClient after initialization", cont);
+        }
+    }
+}

src/ClientRuntime/Microsoft.Rest.ClientRuntime.Tests/SvcClients/ContosoServiceClient.cs

@@ -0,0 +1,167 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Rest.ClientRuntime.Tests.SvcClients
+{
+    /// <summary>
+    /// Customized client that emulates how partners will use Customized code to extend
+    /// generated client.
+    /// </summary>
+    public class ContosoServiceClient : ServiceClient<ContosoServiceClient>
+    {
+        HttpClient _httpClient;
+        /// <summary>
+        /// Constructor that accepts HttpClient
+        /// </summary>
+        /// <param name="httpClient"></param>
+        public ContosoServiceClient(HttpClient httpClient) : base (httpClient)
+        {
+
+        }
+
+        public ContosoServiceClient(HttpClientHandler rootHandler, DelegatingHandler[] handlers) 
+            : base(rootHandler, handlers)
+        { }
+
+        /// <summary>
+        /// Some task emulating getting response back
+        /// </summary>
+        /// <param name="content"></param>
+        /// <returns></returns>
+        public HttpResponseMessage DoSyncWork(string content = null)
+        {
+            return Task.Factory.StartNew(() =>
+            {
+                return DoStuff(content);
+            }).Unwrap().GetAwaiter().GetResult();
+        }
+
+
+        /// <summary>
+        /// Creates request and sends
+        /// </summary>
+        /// <param name="content">string value</param>
+        /// <returns></returns>
+        private async Task<HttpResponseMessage> DoStuff(string content = null)
+        {
+            // Construct URL
+            string url = "http://www.microsoft.com";
+
+            // Create HTTP transport objects
+            HttpRequestMessage _httpRequest = null;
+
+            _httpRequest = new HttpRequestMessage();
+            _httpRequest.Method = HttpMethod.Get;
+            _httpRequest.RequestUri = new Uri(url);
+
+            // Set content
+            if (content != null)
+            {
+                _httpRequest.Content = new StringContent(content);
+            }
+
+            // Set Headers
+            _httpRequest.Headers.Add("x-ms-version", "2013-11-01");
+
+            return await this.HttpClient.SendAsync(_httpRequest, new CancellationToken()).ConfigureAwait(false);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            _httpClient.Dispose();
+            base.Dispose(disposing);
+        }
+    }
+
+    public class FabricamServiceClient : ContosoServiceClient
+    {
+        private HttpClient _httpClient;
+        public FabricamServiceClient(HttpClient httpClient) : base(httpClient)
+        {
+
+        }
+
+        public FabricamServiceClient(HttpClientHandler rootHandler, DelegatingHandler[] handlers) 
+            : base(rootHandler, handlers)
+        { }
+
+        /// <summary>
+        /// The idea is to have customized client override Get in the child class inheriting ServiceClient
+        /// And provide an instance of HttpClient.
+        /// This is yet another way for anyone to use their own HttpClient and override default existing client
+        /// </summary>
+        public override HttpClient HttpClient
+        {
+            get
+            {
+                if (_httpClient == null)
+                {
+                    _httpClient = new HttpClient(new DelayedHandler("Delayed User Provided HttpClient after initialization"));
+                }
+
+                return _httpClient;
+            }
+
+            protected set
+            {
+                base.HttpClient = value;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Custom message handler
+    /// </summary>
+    public class ContosoMessageHandler : DelegatingHandler
+    {
+        public ContosoMessageHandler() : base()
+        {
+            InnerHandler = new HttpClientHandler();
+        }
+
+        /// <summary>
+        /// Returns Contoso Rocks response
+        /// </summary>
+        /// <param name="request">HttpRequestMessage object</param>
+        /// <param name="cancellationToken">CancellationToken</param>
+        /// <returns></returns>
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            StringContent contosoContent = new StringContent("Contoso Rocks");
+            HttpResponseMessage response = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
+            response.Content = contosoContent;
+            return await Task.Run(() => response);
+        }
+    }
+
+    /// <summary>
+    /// Yet another delegating handler for tests    
+    /// </summary>
+    public class DelayedHandler : DelegatingHandler
+    {
+        string _handlerData;
+        private DelayedHandler() : base()
+        {
+            InnerHandler = new HttpClientHandler();
+        }
+
+        public DelayedHandler(string handlerData) 
+            : this()
+        {
+            _handlerData = handlerData;
+        }
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            StringContent contosoContent = new StringContent(_handlerData);
+            HttpResponseMessage response = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
+            response.Content = contosoContent;
+            return await Task.Run(() => response);
+        }
+    }
+}

src/ClientRuntime/Microsoft.Rest.ClientRuntime/ServiceClient.cs

@@ -26,6 +26,7 @@ public abstract class ServiceClient<T> : IDisposable
         private const string FXVERSION = "FxVersion";
         private const string OSNAME = "OSName";
         private const string OSVERSION = "OSVersion";
+        private HttpClient _httpClient;
 
         /// <summary>
         /// Indicates whether the ServiceClient has been disposed. 
@@ -42,6 +43,7 @@ public abstract class ServiceClient<T> : IDisposable
         /// </summary>
         private string _fxVersion;
 
+        #region NET45 specific code
 #if NET45
         /// <summary>
         /// Indicates OS Name
@@ -114,6 +116,7 @@ private string ReadHKLMRegistry(string path, string key)
             catch { return ""; }
         }
 #endif
+        #endregion
 
         /// <summary>
         /// Gets the AssemblyInformationalVersion if available
@@ -196,7 +199,7 @@ private string FrameworkVersion
         /// pipeline).
         /// </summary>
         protected HttpClientHandler HttpClientHandler { get; set; }
-
+        
         /// <summary>
         /// Initializes a new instance of the ServiceClient class.
         /// </summary>
@@ -209,6 +212,19 @@ protected ServiceClient()
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the ServiceClient class.
+        /// </summary>
+        /// <param name="httpClient">HttpClient</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Reliability",
+            "CA2000:Dispose objects before losing scope",
+            Justification = "The created objects should be disposed on caller's side")]
+        protected ServiceClient(HttpClient httpClient)
+        {
+            InitializeHttpClient(httpClient, CreateRootHandler());
+        }
+
         /// <summary>
         /// Initializes a new instance of the ServiceClient class.
         /// </summary>
@@ -253,7 +269,7 @@ protected static HttpClientHandler CreateRootHandler()
         /// <summary>
         /// Gets the HttpClient used for making HTTP requests.
         /// </summary>
-        public HttpClient HttpClient { get; protected set; }
+        public virtual HttpClient HttpClient { get; protected set; }
 
         /// <summary>
         /// Gets the UserAgent collection which can be augmented with custom
@@ -344,6 +360,17 @@ protected virtual void Dispose(bool disposing)
             "CA2000:Dispose objects before losing scope",
             Justification = "We let HttpClient instance dispose")]
         protected void InitializeHttpClient(HttpClientHandler httpClientHandler, params DelegatingHandler[] handlers)
+        {
+            InitializeHttpClient(null, httpClientHandler, handlers);
+        }
+
+        /// <summary>
+        /// Initialize service client with provided HttpClient
+        /// </summary>
+        /// <param name="httpClient">HttpClient</param>
+        /// <param name="httpClientHandler">HttpClientHandler</param>
+        /// <param name="handlers">List of handlers from top to bottom (outer handler is the first in the list)</param>
+        protected void InitializeHttpClient(HttpClient httpClient, HttpClientHandler httpClientHandler, params DelegatingHandler[] handlers)
         {
             HttpClientHandler = httpClientHandler;
             DelegatingHandler currentHandler = new RetryDelegatingHandler();
@@ -360,16 +387,23 @@ protected void InitializeHttpClient(HttpClientHandler httpClientHandler, params
                     {
                         handler = handler.InnerHandler as DelegatingHandler;
                     }
+
                     handler.InnerHandler = currentHandler;
                     currentHandler = handlers[i];
                 }
             }
 
-            var newClient = new HttpClient(currentHandler, false);
+            if (httpClient == null)
+            {
+                HttpClient = new HttpClient(currentHandler, false);
+            }
+            else
+            {
+                HttpClient = httpClient;
+            }
+
             FirstMessageHandler = currentHandler;
-            HttpClient = newClient;
-            Type type = this.GetType();
-            SetUserAgent(type.FullName, ClientVersion);
+            SetUserAgent(this.GetType().FullName, ClientVersion);
         }
 
         /// <summary>