IHttpApiFactory改为泛型

Author: xljiulang

WebApiClient.Test/HttpApiFactoryTest.cs

@@ -9,30 +9,21 @@
 namespace WebApiClient.Test
 {
  public class HttpApiFactoryTest
- {
- [Fact]
- public void AddHttpApiTest()
- {
- var factory = new HttpApiFactory();
- factory.AddHttpApi<IMyApi>(null, null);
-
- Assert.Throws<InvalidOperationException>(() => factory.AddHttpApi<IMyApi>(null, null));
- }
+ { 
 
  [Fact]
  public void CreateHttpApiTest()
  {
- var factory = new HttpApiFactory { Lifetime = TimeSpan.FromMilliseconds(100) };
- factory.AddHttpApi<IMyApi>(null, null);
-
- var api1 = factory.CreateHttpApi<IMyApi>();
- var api2 = factory.CreateHttpApi<IMyApi>();
+ var factory = new HttpApiFactory <IMyApi>(null, null) { Lifetime = TimeSpan.FromMilliseconds(100) };
+ 
+ var api1 = factory.CreateHttpApi();
+ var api2 = factory.CreateHttpApi();
  Assert.True(IsHttpApiConfigEquals(api1, api2));
  Assert.False(api1 == api2);
 
  Thread.Sleep(TimeSpan.FromMilliseconds(150));
 
- var api3 = factory.CreateHttpApi<IMyApi>();
+ var api3 = factory.CreateHttpApi();
  Assert.False(IsHttpApiConfigEquals(api1, api3));
  }
 

WebApiClient/HttpApiFactory.Static.cs

@@ -1,62 +1,90 @@
 using System;
+using System.Collections.Concurrent;
 using System.Net.Http;
 
 namespace WebApiClient
 {
  /// <summary>
- /// 表示HttpApi创建工厂
+ /// 表示HttpApi创建工厂表示操作
  /// 提供HttpApi的配置注册和实例创建
  /// 并对实例的生命周期进行自动管理
  /// </summary>
- public partial class HttpApiFactory
+ public static class HttpApiFactory
  {
  /// <summary>
- /// 获取默认工厂实例
+ /// 同步锁
  /// </summary>
- public static readonly HttpApiFactory Default = new HttpApiFactory();
+ private static object syncRoot = new object();
 
  /// <summary>
- /// 注册http接口到默认工厂
+ /// 工厂字典
+ /// </summary>
+ private static readonly ConcurrentDictionary<Type, IHttpApiFactory> factories;
+
+ /// <summary>
+ /// 表示HttpApi创建工厂
+ /// </summary>
+ static HttpApiFactory()
+ {
+ factories = new ConcurrentDictionary<Type, IHttpApiFactory>();
+ }
+
+ /// <summary>
+ /// 注册http接口
  /// </summary>
  /// <typeparam name="TInterface"></typeparam>
  /// <returns></returns>
  public static bool Add<TInterface>() where TInterface : class, IHttpApi
  {
- return Add<TInterface>(config: null);
+ return Add<TInterface>(configAction: null);
  }
 
  /// <summary>
- /// 注册http接口到默认工厂
+ /// 注册http接口
  /// </summary>
  /// <typeparam name="TInterface"></typeparam>
- /// <param name="config">HttpApiConfig的配置</param>
+ /// <param name="configAction">HttpApiConfig的配置委托</param>
  /// <returns></returns>
- public static bool Add<TInterface>(Action<HttpApiConfig> config) where TInterface : class, IHttpApi
+ public static bool Add<TInterface>(Action<HttpApiConfig> configAction) where TInterface : class, IHttpApi
  {
- return Add<TInterface>(config, handlerFactory: null);
+ return Add<TInterface>(configAction, handlerFunc: null);
  }
 
  /// <summary>
- /// 注册http接口到默认工厂
+ /// 注册http接口
  /// </summary>
  /// <typeparam name="TInterface"></typeparam>
- /// <param name="config">HttpApiConfig的配置</param>
- /// <param name="handlerFactory">HttpMessageHandler创建委托</param>
+ /// <param name="configAction">HttpApiConfig的配置</param>
+ /// <param name="handlerFunc">HttpMessageHandler创建委托</param>
  /// <returns></returns>
- public static bool Add<TInterface>(Action<HttpApiConfig> config, Func<HttpMessageHandler> handlerFactory) where TInterface : class, IHttpApi
+ public static bool Add<TInterface>(Action<HttpApiConfig> configAction, Func<HttpMessageHandler> handlerFunc) where TInterface : class, IHttpApi
  {
- return Default.AddHttpApi<TInterface>(config, handlerFactory);
+ lock (syncRoot)
+ {
+ var apiType = typeof(TInterface);
+ if (factories.ContainsKey(apiType) == true)
+ {
+ return false;
+ }
+
+ var factory = new HttpApiFactory<TInterface>(configAction, handlerFunc);
+ return factories.TryAdd(apiType, factory);
+ }
  }
 
  /// <summary>
- /// 使用默认工厂创建指定接口的代理实例
+ /// 创建指定接口的代理实例
  /// </summary>
  /// <typeparam name="TInterface"></typeparam>
- /// <exception cref="ArgumentException"></exception>
+ /// <exception cref="InvalidOperationException"></exception>
  /// <returns></returns>
  public static TInterface Create<TInterface>() where TInterface : class, IHttpApi
  {
- return Default.CreateHttpApi<TInterface>();
+ if (factories.TryGetValue(typeof(TInterface), out var factory) == true)
+ {
+ return factory.CreateHttpApi() as TInterface;
+ }
+ throw new InvalidOperationException($"未注册的接口类型：{typeof(TInterface)}");
  }
  }
 }

WebApiClient/HttpApiFactory.cs

@@ -11,37 +11,39 @@ namespace WebApiClient
  /// 提供HttpApi的配置注册和实例创建
  /// 并对实例的生命周期进行自动管理
  /// </summary>
- public partial class HttpApiFactory : IHttpApiFactory, _IHttpApiFactory
+ public class HttpApiFactory<TInterface> : IHttpApiFactory<TInterface>, IHttpApiFactory, _IHttpApiFactory
+ where TInterface : class, IHttpApi
  {
  /// <summary>
- /// handler的生命周期
+ /// HttpApiConfig的配置委托
  /// </summary>
- private TimeSpan lifeTime = TimeSpan.FromMinutes(2d);
+ private readonly Action<HttpApiConfig> configAction;
 
  /// <summary>
- /// 清理handler时间间隔
+ /// HttpMessageHandler的创建委托
  /// </summary>
- private TimeSpan cleanupInterval = TimeSpan.FromSeconds(10d);
+ private readonly Func<HttpMessageHandler> handlerFunc;
 
  /// <summary>
- /// 过期的记录
+ /// handler的生命周期
  /// </summary>
- private readonly ConcurrentQueue<ExpiredEntry> expiredEntries;
+ private TimeSpan lifeTime = TimeSpan.FromMinutes(2d);
 
  /// <summary>
- /// 激活记录的创建工厂
+ /// 清理handler时间间隔
  /// </summary>
- private readonly Func<Type, Lazy<ActiveEntry>> activeEntryFactory;
+ private TimeSpan cleanupInterval = TimeSpan.FromSeconds(10d);
 
  /// <summary>
- /// http接口代理创建选项
+ /// 激活的记录
  /// </summary>
- private readonly ConcurrentDictionary<Type, HttpApiCreateOption> httpApiCreateOptions;
+ private volatile Lazy<ActiveEntry> activeEntryLazy;
 
  /// <summary>
- /// 激活的记录
+ /// 过期的记录
  /// </summary>
- private readonly ConcurrentDictionary<Type, Lazy<ActiveEntry>> activeEntries;
+ private readonly ConcurrentQueue<ExpiredEntry> expiredEntries;
+
 
  /// <summary>
  /// 获取已过期但还未释放的HttpApi实例数量
@@ -95,78 +97,72 @@ public TimeSpan CleanupInterval
  /// HttpApi创建工厂
  /// </summary>
  public HttpApiFactory()
+ : this(configAction: null)
  {
+ }
+
+ /// <summary>
+ /// HttpApi创建工厂
+ /// </summary>
+ /// <param name="configAction">HttpApiConfig的配置委托</param>
+ public HttpApiFactory(Action<HttpApiConfig> configAction)
+ : this(configAction, handlerFunc: null)
+ {
+ }
+
+ /// <summary>
+ /// HttpApi创建工厂
+ /// </summary>
+ /// <param name="configAction">HttpApiConfig的配置委托</param>
+ /// <param name="handlerFunc">HttpMessageHandler的创建委托</param>
+ public HttpApiFactory(Action<HttpApiConfig> configAction, Func<HttpMessageHandler> handlerFunc)
+ {
+ this.configAction = configAction;
+ this.handlerFunc = handlerFunc ?? new Func<HttpMessageHandler>(() => new DefaultHttpClientHandler());
+
  this.expiredEntries = new ConcurrentQueue<ExpiredEntry>();
- this.activeEntries = new ConcurrentDictionary<Type, Lazy<ActiveEntry>>();
- this.httpApiCreateOptions = new ConcurrentDictionary<Type, HttpApiCreateOption>();
- this.activeEntryFactory = apiType => new Lazy<ActiveEntry>(() => this.CreateActiveEntry(apiType), LazyThreadSafetyMode.ExecutionAndPublication);
+ this.activeEntryLazy = new Lazy<ActiveEntry>(this.CreateActiveEntry, LazyThreadSafetyMode.ExecutionAndPublication);
 
  this.RegisteCleanup();
  }
 
  /// <summary>
- /// 注册http接口
+ /// 创建接口的代理实例
  /// </summary>
- /// <typeparam name="TInterface"></typeparam>
- /// <param name="config">HttpApiConfig的配置</param>
- /// <param name="handlerFactory">HttpMessageHandler创建委托</param>
  /// <returns></returns>
- public bool AddHttpApi<TInterface>(Action<HttpApiConfig> config, Func<HttpMessageHandler> handlerFactory) where TInterface : class, IHttpApi
+ public TInterface CreateHttpApi()
  {
- if (handlerFactory == null)
- {
- handlerFactory = () => new DefaultHttpClientHandler();
- }
-
- var options = new HttpApiCreateOption
- {
- ConfigAction = config,
- HandlerFactory = handlerFactory
- };
-
- return this.httpApiCreateOptions.TryAdd(typeof(TInterface), options);
+ return ((IHttpApiFactory)this).CreateHttpApi() as TInterface;
  }
 
  /// <summary>
- /// 创建指定接口的代理实例
+ /// 创建接口的代理实例
  /// </summary>
- /// <typeparam name="TInterface"></typeparam>
- /// <exception cref="ArgumentException"></exception>
  /// <returns></returns>
- public TInterface CreateHttpApi<TInterface>() where TInterface : class, IHttpApi
+ object IHttpApiFactory.CreateHttpApi()
  {
- var apiType = typeof(TInterface);
- var entry = this.activeEntries.GetOrAdd(apiType, this.activeEntryFactory).Value;
- return HttpApiClient.Create(apiType, entry.Interceptor) as TInterface;
+ var interceptor = this.activeEntryLazy.Value.Interceptor;
+ return HttpApiClient.Create(typeof(TInterface), interceptor);
  }
 
  /// <summary>
  /// 创建激活状态的记录
  /// </summary>
- /// <param name="apiType">http接口类型</param>
- /// <exception cref="ArgumentException"></exception>
  /// <returns></returns>
- private ActiveEntry CreateActiveEntry(Type apiType)
+ private ActiveEntry CreateActiveEntry()
  {
- if (this.httpApiCreateOptions.TryGetValue(apiType, out var option) == false)
- {
- throw new ArgumentException($"未注册的接口类型{apiType}");
- }
-
- var handler = option.HandlerFactory.Invoke();
- var httpApiConfig = new HttpApiConfig(handler, false);
+ var httpApiConfig = new HttpApiConfig(this.handlerFunc.Invoke(), true);
  var interceptor = new LifeTimeTrackingInterceptor(httpApiConfig);
 
- if (option.ConfigAction != null)
+ if (this.configAction != null)
  {
- option.ConfigAction.Invoke(httpApiConfig);
+ this.configAction.Invoke(httpApiConfig);
  }
 
  return new ActiveEntry(this)
  {
- ApiType = apiType,
- Disposable = httpApiConfig,
- Interceptor = interceptor
+ Interceptor = interceptor,
+ Disposable = httpApiConfig
  };
  }
 
@@ -176,7 +172,9 @@ private ActiveEntry CreateActiveEntry(Type apiType)
  /// <param name="active">激活的记录</param>
  void _IHttpApiFactory.OnEntryDeactivate(ActiveEntry active)
  {
- this.activeEntries.TryRemove(active.ApiType, out var _);
+ // 切换激活状态的记录的实例
+ this.activeEntryLazy = new Lazy<ActiveEntry>(this.CreateActiveEntry, LazyThreadSafetyMode.ExecutionAndPublication);
+
  var expired = new ExpiredEntry(active);
  this.expiredEntries.Enqueue(expired);
  }
@@ -214,5 +212,6 @@ private void CleanupCallback()
 
  this.RegisteCleanup();
  }
+
  }
 }

WebApiClient/IHttpApiFactory.cs

@@ -6,10 +6,22 @@
  public interface IHttpApiFactory
  {
  /// <summary>
- /// 创建指定接口的代理实例
+ /// 创建接口的代理实例
  /// </summary>
- /// <typeparam name="TInterface"></typeparam>
  /// <returns></returns>
- TInterface CreateHttpApi<TInterface>() where TInterface : class, IHttpApi;
+ object CreateHttpApi();
+ }
+
+ /// <summary>
+ /// 定义HttpApi工厂的接口
+ /// </summary>
+ /// <typeparam name="TInterface"></typeparam>
+ public interface IHttpApiFactory<TInterface> : IHttpApiFactory where TInterface : class, IHttpApi
+ {
+ /// <summary>
+ /// 创建接口的代理实例
+ /// </summary>
+ /// <returns></returns>
+ new TInterface CreateHttpApi();
  }
 }

WebApiClient/Internal/HttpApiFactories/ActiveEntry.cs

@@ -8,11 +8,6 @@ namespace WebApiClient
  /// </summary>
  class ActiveEntry
  {
- /// <summary>
- /// 获取或设置关联的http接口类型
- /// </summary>
- public Type ApiType { get; set; }
-
  /// <summary>
  /// 获取或设置用于释放资源的对象
  /// </summary>