增加InterceptorCleaner

Author: xljiulang

WebApiClient/HttpApiFactory.cs

@@ -1,8 +1,6 @@
 using System;
-using System.Collections.Concurrent;
 using System.Net.Http;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace WebApiClient
 {
@@ -30,32 +28,22 @@ public class HttpApiFactory<TInterface> : IHttpApiFactory<TInterface>, IHttpApiF
  private TimeSpan lifeTime = TimeSpan.FromMinutes(2d);
 
  /// <summary>
- /// 清理handler时间间隔
+ /// 具有生命周期的拦截器延时创建对象
  /// </summary>
- private TimeSpan cleanupInterval = TimeSpan.FromSeconds(10d);
+ private Lazy<LifetimeInterceptor> lifeTimeInterceptorLazy;
 
  /// <summary>
- /// 过期的拦截器
+ /// 拦截器清理器
  /// </summary>
- private readonly ConcurrentQueue<ExpiredInterceptor> expiredInterceptors = new ConcurrentQueue<ExpiredInterceptor>();
-
- /// <summary>
- /// 当前过期的拦截器的数量
- /// </summary>
- private int expiredCount = 0;
-
- /// <summary>
- /// 激活的拦截器
- /// </summary>
- private Lazy<ActiveInterceptor> activeInterceptorLazy;
+ private readonly InterceptorCleaner interceptorCleaner = new InterceptorCleaner();
 
  /// <summary>
  /// HttpApi创建工厂
  /// </summary>
  public HttpApiFactory()
  {
- this.activeInterceptorLazy = new Lazy<ActiveInterceptor>(
- this.CreateActiveInterceptor,
+ this.lifeTimeInterceptorLazy = new Lazy<LifetimeInterceptor>(
+ this.CreateInterceptor,
  LazyThreadSafetyMode.ExecutionAndPublication);
  }
 
@@ -85,7 +73,7 @@ public HttpApiFactory<TInterface> SetCleanupInterval(TimeSpan interval)
  {
  throw new ArgumentOutOfRangeException();
  }
- this.cleanupInterval = interval;
+ this.interceptorCleaner.CleanupInterval = interval;
  return this;
  }
 
@@ -126,15 +114,15 @@ public TInterface CreateHttpApi()
  /// <returns></returns>
  object IHttpApiFactory.CreateHttpApi()
  {
- var interceptor = this.activeInterceptorLazy.Value;
+ var interceptor = this.lifeTimeInterceptorLazy.Value;
  return HttpApiClient.Create(typeof(TInterface), interceptor);
  }
 
  /// <summary>
- /// 创建激活状态的拦截器
+ /// 创建LifetimeInterceptor
  /// </summary>
  /// <returns></returns>
- private ActiveInterceptor CreateActiveInterceptor()
+ private LifetimeInterceptor CreateInterceptor()
  {
  var handler = this.handlerFunc?.Invoke() ?? new DefaultHttpClientHandler();
  var httpApiConfig = new HttpApiConfig(handler, true);
@@ -144,7 +132,7 @@ private ActiveInterceptor CreateActiveInterceptor()
  this.configAction.Invoke(httpApiConfig);
  }
 
- return new ActiveInterceptor(
+ return new LifetimeInterceptor(
  httpApiConfig,
  this.lifeTime,
  this.OnInterceptorDeactivate);
@@ -153,61 +141,15 @@ private ActiveInterceptor CreateActiveInterceptor()
  /// <summary>
  /// 当有拦截器失效时
  /// </summary>
- /// <param name="active">激活的拦截器</param>
- private void OnInterceptorDeactivate(ActiveInterceptor active)
+ /// <param name="interceptor">拦截器</param>
+ private void OnInterceptorDeactivate(LifetimeInterceptor interceptor)
  {
  // 切换激活状态的记录的实例
- this.activeInterceptorLazy = new Lazy<ActiveInterceptor>(
- this.CreateActiveInterceptor,
+ this.lifeTimeInterceptorLazy = new Lazy<LifetimeInterceptor>(
+ this.CreateInterceptor,
  LazyThreadSafetyMode.ExecutionAndPublication);
 
- var expired = new ExpiredInterceptor(active);
- this.expiredInterceptors.Enqueue(expired);
-
- // 从0变为1，要启动清理作业
- if (Interlocked.Increment(ref this.expiredCount) == 1)
- {
- this.RegisteCleanup();
- }
- }
-
-
- /// <summary>
- /// 注册清理任务
- /// </summary>
- private async void RegisteCleanup()
- {
- while (this.Cleanup() == false)
- {
- await Task.Delay(this.cleanupInterval).ConfigureAwait(false);
- }
- }
-
- /// <summary>
- /// 清理失效的拦截器
- /// </summary>
- /// <returns>是否完全清理</returns>
- private bool Cleanup()
- {
- var cleanCount = this.expiredInterceptors.Count;
- for (var i = 0; i < cleanCount; i++)
- {
- this.expiredInterceptors.TryDequeue(out var expired);
- if (expired.CanDispose == false)
- {
- this.expiredInterceptors.Enqueue(expired);
- }
- else
- {
- expired.Dispose();
- if (Interlocked.Decrement(ref this.expiredCount) == 0)
- {
- return true;
- }
- }
- }
-
- return false;
+ this.interceptorCleaner.Add(interceptor);
  }
  }
 }

WebApiClient/Internal/HttpApiFactories/ExpiredInterceptor..cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace WebApiClient
+{
+ /// <summary>
+ /// 表示拦截器清理器
+ /// </summary>
+ class InterceptorCleaner
+ {
+ /// <summary>
+ /// 当前监视生命周期的记录的数量
+ /// </summary>
+ private int trackingEntryCount = 0;
+
+ /// <summary>
+ /// 监视生命周期的记录队列
+ /// </summary>
+ private readonly ConcurrentQueue<TrackingEntry> trackingEntries = new ConcurrentQueue<TrackingEntry>();
+
+ /// <summary>
+ /// 获取或设置清理的时间间隔
+ /// 默认10s
+ /// </summary>
+ public TimeSpan CleanupInterval { get; set; } = TimeSpan.FromSeconds(10d);
+
+ /// <summary>
+ /// 添加要清除的拦截器
+ /// </summary>
+ /// <param name="interceptor">拦截器</param>
+ public void Add(LifetimeInterceptor interceptor)
+ {
+ var entry = new TrackingEntry(interceptor);
+ this.trackingEntries.Enqueue(entry);
+
+ // 从0变为1，要启动清理作业
+ if (Interlocked.Increment(ref this.trackingEntryCount) == 1)
+ {
+ this.StartCleanup();
+ }
+ }
+
+ /// <summary>
+ /// 启动清理作业
+ /// </summary>
+ private async void StartCleanup()
+ {
+ while (this.Cleanup() == false)
+ {
+ await Task.Delay(this.CleanupInterval).ConfigureAwait(false);
+ }
+ }
+
+ /// <summary>
+ /// 清理失效的拦截器
+ /// 返回是否完全清理
+ /// </summary>
+ /// <returns></returns>
+ private bool Cleanup()
+ {
+ var cleanCount = this.trackingEntries.Count;
+ for (var i = 0; i < cleanCount; i++)
+ {
+ this.trackingEntries.TryDequeue(out var entry);
+ if (entry.CanDispose == false)
+ {
+ this.trackingEntries.Enqueue(entry);
+ }
+ else
+ {
+ entry.Dispose();
+ if (Interlocked.Decrement(ref this.trackingEntryCount) == 0)
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+
+ /// <summary>
+ /// 表示监视生命周期的记录
+ /// </summary>
+ private class TrackingEntry : IDisposable
+ {
+ /// <summary>
+ /// 用于释放资源的对象
+ /// </summary>
+ private readonly IDisposable disposable;
+
+ /// <summary>
+ /// 监视对象的弱引用
+ /// </summary>
+ private readonly WeakReference weakReference;
+
+ /// <summary>
+ /// 获取是否可以释放资源
+ /// </summary>
+ /// <returns></returns>
+ public bool CanDispose
+ {
+ get => this.weakReference.IsAlive == false;
+ }
+
+ /// <summary>
+ /// 监视生命周期的记录
+ /// </summary>
+ /// <param name="interceptor">激活状态的拦截器</param>
+ public TrackingEntry(LifetimeInterceptor interceptor)
+ {
+ this.disposable = interceptor.HttpApiConfig;
+ this.weakReference = new WeakReference(interceptor);
+ }
+
+ /// <summary>
+ /// 释放资源
+ /// </summary>
+ public void Dispose()
+ {
+ if (this.CanDispose == true)
+ {
+ this.disposable.Dispose();
+ }
+ }
+ }
+ }
+}

WebApiClient/Internal/HttpApiFactories/InterceptorCleaner.cs

@@ -5,18 +5,18 @@
 namespace WebApiClient
 {
  /// <summary>
- /// 表示激活状态的拦截器
+ /// 表示具有生命周期的拦截器
  /// </summary>
- class ActiveInterceptor : ApiInterceptor
+ class LifetimeInterceptor : ApiInterceptor
  {
  /// <summary>
- /// 激活状态的拦截器
+ /// 具有生命周期的拦截器
  /// </summary>
  /// <param name="httpApiConfig">httpApi配置</param>
- /// <param name="lifeTime">生命周期</param>
- /// <param name="deactivateAction">生效委托</param>
+ /// <param name="lifeTime">拦截器的生命周期</param>
+ /// <param name="deactivateAction">失效回调</param>
  /// <exception cref="ArgumentNullException"></exception>
- public ActiveInterceptor(HttpApiConfig httpApiConfig, TimeSpan lifeTime, Action<ActiveInterceptor> deactivateAction)
+ public LifetimeInterceptor(HttpApiConfig httpApiConfig, TimeSpan lifeTime, Action<LifetimeInterceptor> deactivateAction)
  : base(httpApiConfig)
  {
  if (deactivateAction == null)