add annotation

src/ServiceAnt.IocInstaller.Autofac/IocResolver.cs

@@ -15,6 +15,10 @@ public class IocResolver : IIocResolver
  {
  private readonly IComponentContext _componentContext;
 
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="componentContext"></param>
  public IocResolver(IComponentContext componentContext)
  {
  _componentContext = componentContext;

src/ServiceAnt.IocInstaller.Autofac/ServiceAntModule.cs

@@ -44,6 +44,10 @@ public static void RegisterHandlers(IComponentContext container)
  }
  }
 
+ /// <summary>
+ /// Intall dependenies and register handler function
+ /// </summary>
+ /// <param name="builder"></param>
  protected override void Load(ContainerBuilder builder)
  {
  var serviceBus = InProcessServiceBus.Default;

src/ServiceAnt.IocInstaller.Castle/ServiceAntInstaller.cs

@@ -32,6 +32,11 @@ public ServiceAntInstaller(params Assembly[] handlerAssemblies)
  _handlerAssemblies = handlerAssemblies;
  }
 
+ /// <summary>
+ /// Intall dependenies and register handler function
+ /// </summary>
+ /// <param name="container"></param>
+ /// <param name="store"></param>
  public void Install(IWindsorContainer container, IConfigurationStore store)
  {
  _container = container;

src/ServiceAnt/IServiceBus.cs

@@ -6,6 +6,9 @@
 
 namespace ServiceAnt
 {
+ /// <summary>
+ /// It used to publish event or send a request
+ /// </summary>
  public interface IServiceBus : IAddSubscription, IAddRequestHandler
  {
  /// <summary>

src/ServiceAnt/InProcessServiceBus.cs

@@ -11,22 +11,40 @@
 
 namespace ServiceAnt
 {
+ /// <summary>
+ /// The implement that work in-process
+ /// </summary>
  public class InProcessServiceBus : IServiceBus
  {
  private ISubscriptionManager _subcriptionManager;
  private IRequestHandlerManager _requestHandlerManager;
 
+ /// <summary>
+ /// Use to log message of bus
+ /// </summary>
  public event Action<string, string, Exception> OnLogBusMessage;
 
  private static Lazy<InProcessServiceBus> _defaultInstance = new Lazy<InProcessServiceBus>();
+
+ /// <summary>
+ /// Default Instance
+ /// </summary>
  public static InProcessServiceBus Default => _defaultInstance.Value;
 
+ /// <summary>
+ /// Constructor
+ /// </summary>
  public InProcessServiceBus()
  {
  _subcriptionManager = new InMemorySubscriptionsManager();
  _requestHandlerManager = new InMemoryRequestHandlerManager();
  }
 
+ /// <summary>
+ /// It used to inject mock object
+ /// </summary>
+ /// <param name="subcriptionManager"></param>
+ /// <param name="requestHandlerManager"></param>
  public InProcessServiceBus(ISubscriptionManager subcriptionManager, IRequestHandlerManager requestHandlerManager)
  {
  _subcriptionManager = subcriptionManager;
@@ -35,45 +53,80 @@ public InProcessServiceBus(ISubscriptionManager subcriptionManager, IRequestHand
 
  #region Pub/Sub
 
+ /// <summary>
+ /// Add Subscription for event by delegate with dynamic parameter
+ /// </summary>
+ /// <param name="eventName">the name of event(the class name of event type)</param>
+ /// <param name="action">Handler delegate</param>
  public void AddDynamicSubscription(string eventName, Func<dynamic, Task> action)
  {
  _subcriptionManager.AddDynamicSubscription(eventName, action);
  }
 
-
+ /// <summary>
+ /// Add Subscription for event by factory
+ /// </summary>
+ /// <param name="eventType">The type of event must inherit TransportTray</param>
+ /// <param name="factory">The factory of handler</param>
  public void AddSubscription(Type eventType, IHandlerFactory factory)
  {
  _subcriptionManager.AddSubscription(eventType, factory);
  }
 
+ /// <summary>
+ /// Add Subscription for event by delegate
+ /// </summary>
+ /// <typeparam name="TEvent">The event must inherit TransportTray</typeparam>
+ /// <param name="action">Handler delegate</param>
  public void AddSubscription<TEvent>(Func<TEvent, Task> action) where TEvent : TransportTray
  {
  _subcriptionManager.AddSubscription<TEvent>(action);
  }
 
+ /// <summary>
+ /// Add Subscription for event by factory
+ /// </summary>
+ /// <typeparam name="TEvent">The event must inherit TransportTray </typeparam>
+ /// <param name="factory"></param>s
  public void AddSubscription<TEvent>(IHandlerFactory factory) where TEvent : TransportTray
  {
  _subcriptionManager.AddSubscription<TEvent>(factory);
  }
 
+
+ /// <summary>
+ /// Remove subscription from servicebus
+ /// </summary>
+ /// <param name="eventName">the name of event(the class name of event type)</param>
+ /// <param name="action">Handler delegate</param>
  public void RemoveDynamicSubscription(string eventName, Func<dynamic, Task> action)
  {
  _subcriptionManager.RemoveDynamicSubscription(eventName, action);
  }
 
+ /// <summary>
+ /// Remove subscription from servicebus
+ /// </summary>
+ /// <typeparam name="TEvent">The event must inherit TransportTray</typeparam>
+ /// <param name="action">Handler delegate</param>
  public void RemoveSubscription<TEvent>(Func<TEvent, Task> action) where TEvent : TransportTray
  {
  _subcriptionManager.RemoveSubscription<TEvent>(action);
  }
 
+ /// <summary>
+ /// Publish a event
+ /// </summary>
+ /// <param name="event"></param>
+ /// <returns></returns>
  public Task Publish(TransportTray @event)
  {
  var asyncTask = ProcessEvent(_subcriptionManager.GetEventName(@event.GetType()), JsonConvert.SerializeObject(@event));
  return asyncTask;
  }
 
  /// <summary>
- /// It's for Unit test
+ /// Publish a event sync
  /// </summary>
  /// <param name="event"></param>
  public void PublishSync(TransportTray @event)
@@ -115,50 +168,92 @@ private async Task ProcessEvent(string eventName, string message)
  }
  }
 
-#endregion
+ #endregion
 
-#region Req/Resp
+ #region Req/Resp
 
+ /// <summary>
+ /// Register handler with handler factory
+ /// </summary>
+ /// <param name="eventType"></param>
+ /// <param name="factory"></param>
  public void AddRequestHandler(Type eventType, IHandlerFactory factory)
  {
  _requestHandlerManager.AddRequestHandler(eventType, factory);
  }
 
+ /// <summary>
+ /// Register handler with handler factory
+ /// </summary>
+ /// <typeparam name="TEvent"></typeparam>
+ /// <param name="factory"></param>
  public void AddRequestHandler<TEvent>(IHandlerFactory factory)
  where TEvent : TransportTray
  {
  _requestHandlerManager.AddRequestHandler<TEvent>(factory);
  }
 
+ /// <summary>
+ /// Register handler with delegate
+ /// </summary>
+ /// <typeparam name="TEvent"></typeparam>
+ /// <param name="action"></param>
  public void AddRequestHandler<TEvent>(Func<TEvent, IRequestHandlerContext, Task> action)
  where TEvent : TransportTray
  {
  _requestHandlerManager.AddRequestHandler<TEvent>(action);
  }
 
+ /// <summary>
+ /// Register dynamic handler with delegate
+ /// </summary>
+ /// <param name="eventName"></param>
+ /// <param name="action"></param>
  public void AddDynamicRequestHandler(string eventName, Func<dynamic, IRequestHandlerContext, Task> action)
  {
  _requestHandlerManager.AddDynamicRequestHandler(eventName, action);
  }
 
-
+ /// <summary>
+ /// Remove handler by event type
+ /// </summary>
+ /// <typeparam name="TEvent"></typeparam>
+ /// <param name="action"></param>
  public void RemoveRequestHandler<TEvent>(Func<TEvent, IRequestHandlerContext, Task> action)
  where TEvent : TransportTray
  {
  _requestHandlerManager.RemoveRequestHandler(action);
  }
+
+ /// <summary>
+ /// Remove dynamic handler by eventName
+ /// </summary>
+ /// <param name="eventName"></param>
+ /// <param name="action"></param>
  public void RemoveDynamicRequestHandler(string eventName, Func<dynamic, IRequestHandlerContext, Task> action)
  {
  _requestHandlerManager.RemoveDynamicRequestHandler(eventName, action);
  }
 
+ /// <summary>
+ /// Send a request sync
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="event"></param>
+ /// <returns></returns>
  public T Send<T>(TransportTray @event)
  {
  var asyncTask = ProcessRequest<T>(_requestHandlerManager.GetRequestName(@event.GetType()), JsonConvert.SerializeObject(@event));
  asyncTask.ConfigureAwait(false);
  return asyncTask.Result;
  }
 
+ /// <summary>
+ /// Send a request async
+ /// </summary>
+ /// <typeparam name="T"></typeparam>
+ /// <param name="event"></param>
+ /// <returns></returns>
  public async Task<T> SendAsync<T>(TransportTray @event)
  {
  return await ProcessRequest<T>(_requestHandlerManager.GetRequestName(@event.GetType()), JsonConvert.SerializeObject(@event));

src/ServiceAnt/Request/IRequestHandlerManager.cs

@@ -6,11 +6,30 @@
 
 namespace ServiceAnt.Handler.Request
 {
+ /// <summary>
+ /// It used to manage request handle function
+ /// </summary>
  public interface IRequestHandlerManager : IAddRequestHandler
  {
+ /// <summary>
+ /// Get the all handler factory of a request
+ /// </summary>
+ /// <param name="requestName">request name</param>
+ /// <returns></returns>
  List<IHandlerFactory> GetHandlerFactoriesForRequest(string requestName);
+
+ /// <summary>
+ /// Get the all handler factory of a request
+ /// </summary>
+ /// <param name="request">request object</param>
+ /// <returns></returns>
  List<IHandlerFactory> GetHandlerFactoriesForRequest(TransportTray @request);
 
+ /// <summary>
+ /// Get the request name by TransportTray type
+ /// </summary>
+ /// <param name="aType">the class inherited TransportTray</param>
+ /// <returns></returns>
  string GetRequestName(Type aType);
  }
 }