完善HttpApiClientFactory

Author: xljiulang

Demo/Program.cs

@@ -2,28 +2,36 @@
 using Demo.HttpServices;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Net.Http;
 using System.Threading.Tasks;
 using WebApiClient;
 using WebApiClient.Parameterables;
 
 namespace Demo
 {
+ class MyHandler : System.Net.Http.DelegatingHandler
+ {
+ protected override void Dispose(bool disposing)
+ {
+ Console.WriteLine($"{DateTime.Now } 我被调用disposing了");
+ base.Dispose(disposing);
+ }
+ }
+
  class Program
  {
  static void Main(string[] args)
  {
  HttpServer.Start(9999);
 
- var config = new HttpApiConfig
+ HttpApiClientFactory.Add<IUserApi>(c =>
  {
- HttpHost = new Uri("http://localhost:9999/"),
- LoggerFactory = new LoggerFactory().AddConsole()
- };
-
- var userApi = HttpApiClient.Create<IUserApi>(config);
+ c.HttpHost = new Uri("http://localhost:9999/");
+ c.LoggerFactory = new LoggerFactory().AddConsole();
+ });
+ 
+ var userApi = HttpApiClientFactory.Create<IUserApi>();
  Program.RequestAsync(userApi).Wait();
- userApi.Dispose();
-
  Console.ReadLine();
  }
 

WebApiClient/HttpApiClientFactory.Static.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Net.Http;
+
+namespace WebApiClient
+{
+ /// <summary>
+ /// 表示HttpApiClient创建工厂
+ /// </summary>
+ public partial class HttpApiClientFactory
+ {
+ /// <summary>
+ /// 获取默认实例
+ /// </summary>
+ public static readonly HttpApiClientFactory Default = new HttpApiClientFactory();
+
+ /// <summary>
+ /// 注册HttpApiClient对应的http接口到默认实例
+ /// </summary>
+ /// <typeparam name="TInterface"></typeparam>
+ /// <exception cref="InvalidOperationException"></exception>
+ public static void Add<TInterface>() where TInterface : class, IHttpApi
+ {
+ Add<TInterface>(config: null);
+ }
+
+ /// <summary>
+ /// 注册HttpApiClient对应的http接口到默认实例
+ /// </summary>
+ /// <typeparam name="TInterface"></typeparam>
+ /// <param name="config">HttpApiConfig的配置</param>
+ /// <exception cref="InvalidOperationException"></exception>
+ public static void Add<TInterface>(Action<HttpApiConfig> config) where TInterface : class, IHttpApi
+ {
+ Add<TInterface>(config, handlerFactory: null);
+ }
+
+ /// <summary>
+ /// 注册HttpApiClient对应的http接口到默认实例
+ /// </summary>
+ /// <typeparam name="TInterface"></typeparam>
+ /// <param name="config">HttpApiConfig的配置</param>
+ /// <param name="handlerFactory">HttpMessageHandler创建委托</param>
+ /// <exception cref="InvalidOperationException"></exception>
+ public static void Add<TInterface>(Action<HttpApiConfig> config, Func<HttpMessageHandler> handlerFactory) where TInterface : class, IHttpApi
+ {
+ Default.AddTypedClient<TInterface>(config, handlerFactory);
+ }
+
+ /// <summary>
+ /// 使用默认实例创建实现了指定接口的HttpApiClient实例
+ /// </summary>
+ /// <typeparam name="TInterface"></typeparam>
+ /// <returns></returns>
+ public static TInterface Create<TInterface>() where TInterface : class, IHttpApi
+ {
+ return Default.CreateTypedClient<TInterface>();
+ }
+ }
+}

WebApiClient/HttpApiClientFactory.cs

@@ -1,9 +1,6 @@
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -12,32 +9,87 @@ namespace WebApiClient
  /// <summary>
  /// 表示HttpApiClient创建工厂
  /// </summary>
- public class HttpApiClientFactory : IHttpApiClientFactory
+ public partial class HttpApiClientFactory : IHttpApiClientFactory
  {
  /// <summary>
- /// 获取默认的实例
+ /// handler的生命周期
  /// </summary>
- public static readonly HttpApiClientFactory Default = new HttpApiClientFactory();
+ private TimeSpan lifeTime = TimeSpan.FromMinutes(2d);
 
- private readonly TimeSpan defaultCleanupInterval = TimeSpan.FromSeconds(10d);
+ /// <summary>
+ /// 清理handler时间间隔
+ /// </summary>
+ private TimeSpan cleanupInterval = TimeSpan.FromSeconds(10d);
 
+ /// <summary>
+ /// 过期的记录
+ /// </summary>
  private readonly ConcurrentQueue<ExpiredHandlerEntry> expiredEntries;
 
+ /// <summary>
+ /// 激活记录的创建工厂
+ /// </summary>
  private readonly Func<Type, Lazy<ActiveHandlerEntry>> activeEntryFactory;
 
- private readonly ConcurrentDictionary<Type, Action<HttpApiConfig>> configs;
+ /// <summary>
+ /// http接口客户端选项
+ /// </summary>
+ private readonly ConcurrentDictionary<Type, TypedClientOption> typedClientOptions;
 
+ /// <summary>
+ /// 激活的记录
+ /// </summary>
  private readonly ConcurrentDictionary<Type, Lazy<ActiveHandlerEntry>> activeEntries;
 
 
- public TimeSpan Lifetime { get; set; } = TimeSpan.FromMinutes(2d);
+ /// <summary>
+ /// 获取或设置HttpMessageHandler的生命周期
+ /// </summary>
+ /// <exception cref="ArgumentOutOfRangeException"></exception>
+ public TimeSpan Lifetime
+ {
+ get
+ {
+ return this.lifeTime;
+ }
+ set
+ {
+ if (value <= TimeSpan.Zero)
+ {
+ throw new ArgumentOutOfRangeException();
+ }
+ this.lifeTime = value;
+ }
+ }
 
+ /// <summary>
+ /// 获取或设置清理过期的HttpMessageHandler的时间间隔
+ /// </summary>
+ /// <exception cref="ArgumentOutOfRangeException"></exception>
+ public TimeSpan CleanupInterval
+ {
+ get
+ {
+ return this.cleanupInterval;
+ }
+ set
+ {
+ if (value <= TimeSpan.Zero)
+ {
+ throw new ArgumentOutOfRangeException();
+ }
+ this.cleanupInterval = value;
+ }
+ }
 
+ /// <summary>
+ /// HttpApiClient创建工厂
+ /// </summary>
  public HttpApiClientFactory()
  {
  this.expiredEntries = new ConcurrentQueue<ExpiredHandlerEntry>();
- this.configs = new ConcurrentDictionary<Type, Action<HttpApiConfig>>();
  this.activeEntries = new ConcurrentDictionary<Type, Lazy<ActiveHandlerEntry>>();
+ this.typedClientOptions = new ConcurrentDictionary<Type, TypedClientOption>();
  this.activeEntryFactory = apiType => new Lazy<ActiveHandlerEntry>(() => this.CreateActiveEntry(apiType), LazyThreadSafetyMode.ExecutionAndPublication);
 
  this.RegisteCleanup();
@@ -47,69 +99,102 @@ public HttpApiClientFactory()
  /// 注册HttpApiClient对应的http接口
  /// </summary>
  /// <typeparam name="TInterface"></typeparam>
- /// <param name="config">配置</param>
- /// <returns></returns>
- public bool AddHttpApiClient<TInterface>(Action<HttpApiConfig> config) where TInterface : class, IHttpApi
+ /// <param name="config">HttpApiConfig的配置</param>
+ /// <param name="handlerFactory">HttpMessageHandler创建委托</param>
+ /// <exception cref="InvalidOperationException"></exception>
+ public void AddTypedClient<TInterface>(Action<HttpApiConfig> config, Func<HttpMessageHandler> handlerFactory) where TInterface : class, IHttpApi
  {
- return this.configs.TryAdd(typeof(TInterface), config);
+ if (handlerFactory == null)
+ {
+ handlerFactory = () => new DefaultHttpClientHandler();
+ }
+
+ var options = new TypedClientOption
+ {
+ ConfigAction = config,
+ HandlerFactory = handlerFactory
+ };
+
+ var state = this.typedClientOptions.TryAdd(typeof(TInterface), options);
+ if (state == false)
+ {
+ throw new InvalidOperationException($"接口{typeof(TInterface)}不能重复注册");
+ }
  }
 
  /// <summary>
  /// 创建实现了指定接口的HttpApiClient实例
  /// </summary>
  /// <typeparam name="TInterface"></typeparam>
  /// <returns></returns>
- public TInterface CreateHttpApiClient<TInterface>() where TInterface : class, IHttpApi
+ public TInterface CreateTypedClient<TInterface>() where TInterface : class, IHttpApi
  {
  var apiType = typeof(TInterface);
  var entry = this.activeEntries.GetOrAdd(apiType, this.activeEntryFactory).Value;
  return HttpApiClient.Create<TInterface>(entry.HttpApiConfig);
  }
 
+ /// <summary>
+ /// 创建激活状态的Handler记录
+ /// </summary>
+ /// <param name="apiType">http接口类型</param>
+ /// <returns></returns>
  private ActiveHandlerEntry CreateActiveEntry(Type apiType)
  {
- var handler = new LifeTimeTrackingHandler(new DefaultHttpClientHandler());
- var httpApiConfig = new HttpApiConfig(handler, false);
-
- if (this.configs.TryGetValue(apiType, out Action<HttpApiConfig> config) == false)
+ if (this.typedClientOptions.TryGetValue(apiType, out var option) == false)
  {
  throw new ArgumentException($"未注册的接口类型{apiType}");
  }
- else if (config != null)
+
+ var innder = option.HandlerFactory.Invoke();
+ var handler = new LifeTimeTrackingHandler(innder);
+ var httpApiConfig = new HttpApiConfig(handler, false);
+
+ if (option.ConfigAction != null)
  {
- config.Invoke(httpApiConfig);
+ option.ConfigAction.Invoke(httpApiConfig);
  }
 
  return new ActiveHandlerEntry(this)
  {
  ApiType = apiType,
- HttpApiConfig = httpApiConfig,
- InnerHandler = handler.InnerHandler
+ Disposable = innder,
+ HttpApiConfig = httpApiConfig
  };
  }
 
+ /// <summary>
+ /// 当有记录失效时
+ /// </summary>
+ /// <param name="active">激活的记录</param>
  void IHttpApiClientFactory.OnEntryDeactivate(ActiveHandlerEntry active)
  {
  this.activeEntries.TryRemove(active.ApiType, out var _);
  var expired = new ExpiredHandlerEntry(active);
  this.expiredEntries.Enqueue(expired);
  }
 
+ /// <summary>
+ /// 注册清理任务
+ /// </summary>
  private void RegisteCleanup()
  {
- Task.Delay(this.defaultCleanupInterval)
+ Task.Delay(this.cleanupInterval)
  .ConfigureAwait(false)
  .GetAwaiter()
  .OnCompleted(this.CleanupCallback);
  }
 
+ /// <summary>
+ /// 清理任务回调
+ /// </summary>
  private void CleanupCallback()
  {
  var count = this.expiredEntries.Count;
  for (var i = 0; i < count; i++)
  {
  this.expiredEntries.TryDequeue(out var entry);
- if (entry.CanDispose() == true)
+ if (entry.CanDispose == true)
  {
  entry.Dispose();
  }
@@ -118,6 +203,8 @@ private void CleanupCallback()
  this.expiredEntries.Enqueue(entry);
  }
  }
+
+
  this.RegisteCleanup();
  }
  }

WebApiClient/Internal/HttpApiClientFactorys/ActiveHandlerEntry.cs

@@ -1,17 +1,32 @@
 using System;
-using System.Net.Http;
 using System.Threading.Tasks;
 
 namespace WebApiClient
 {
+ /// <summary>
+ /// 表示激活状态的Handler记录
+ /// </summary>
  class ActiveHandlerEntry
  {
+ /// <summary>
+ /// 获取或设置关联的http接口类型
+ /// </summary>
  public Type ApiType { get; set; }
 
+ /// <summary>
+ /// 获取或设置http接口配置
+ /// </summary>
  public HttpApiConfig HttpApiConfig { get; set; }
 
- public HttpMessageHandler InnerHandler { get; set; }
+ /// <summary>
+ /// 获取或设置用于释放资源的对象
+ /// </summary>
+ public IDisposable Disposable { get; set; }
 
+ /// <summary>
+ /// 激活状态的Handler记录
+ /// </summary>
+ /// <param name="factory">httpApiClient工厂</param>
  public ActiveHandlerEntry(IHttpApiClientFactory factory)
  {
  Task.Delay(factory.Lifetime)