diff --git a/src/ServiceAnt.IocInstaller.Autofac/IocResolver.cs b/src/ServiceAnt.IocInstaller.Autofac/IocResolver.cs
index ba3fa19..5d430f2 100644
--- a/src/ServiceAnt.IocInstaller.Autofac/IocResolver.cs
+++ b/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;
diff --git a/src/ServiceAnt.IocInstaller.Autofac/ServiceAntModule.cs b/src/ServiceAnt.IocInstaller.Autofac/ServiceAntModule.cs
index 65d1f96..184d700 100644
--- a/src/ServiceAnt.IocInstaller.Autofac/ServiceAntModule.cs
+++ b/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;
diff --git a/src/ServiceAnt.IocInstaller.Castle/ServiceAntInstaller.cs b/src/ServiceAnt.IocInstaller.Castle/ServiceAntInstaller.cs
index 0b67229..25aa493 100644
--- a/src/ServiceAnt.IocInstaller.Castle/ServiceAntInstaller.cs
+++ b/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;
diff --git a/src/ServiceAnt/IServiceBus.cs b/src/ServiceAnt/IServiceBus.cs
index 8a9e1a5..6ba5c65 100644
--- a/src/ServiceAnt/IServiceBus.cs
+++ b/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>
diff --git a/src/ServiceAnt/InProcessServiceBus.cs b/src/ServiceAnt/InProcessServiceBus.cs
index 998ef5d..bf8e6f5 100644
--- a/src/ServiceAnt/InProcessServiceBus.cs
+++ b/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,37 +53,72 @@ 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));
@@ -73,7 +126,7 @@ public Task Publish(TransportTray @event)
         }
 
         /// <summary>
-        /// It's for Unit test
+        /// Publish a event sync
         /// </summary>
         /// <param name="event"></param>
         public void PublishSync(TransportTray @event)
@@ -115,43 +168,79 @@ 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));
@@ -159,6 +248,12 @@ public T Send<T>(TransportTray @event)
             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));
diff --git a/src/ServiceAnt/Request/IRequestHandlerManager.cs b/src/ServiceAnt/Request/IRequestHandlerManager.cs
index 8533d4f..7d9d5b7 100644
--- a/src/ServiceAnt/Request/IRequestHandlerManager.cs
+++ b/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);
     }
 }
diff --git a/src/ServiceAnt/Request/InMemoryRequestHandlerManager.cs b/src/ServiceAnt/Request/InMemoryRequestHandlerManager.cs
index bbcb4eb..bcb874f 100644
--- a/src/ServiceAnt/Request/InMemoryRequestHandlerManager.cs
+++ b/src/ServiceAnt/Request/InMemoryRequestHandlerManager.cs
@@ -8,15 +8,26 @@
 
 namespace ServiceAnt.Handler.Request
 {
+    /// <summary>
+    /// It save the handlers in memory
+    /// </summary>
     public class InMemoryRequestHandlerManager : IRequestHandlerManager
     {
         private readonly ConcurrentDictionary<string, List<IHandlerFactory>> _handlerFactories;
 
+        /// <summary>
+        /// Constructor
+        /// </summary>
         public InMemoryRequestHandlerManager()
         {
             _handlerFactories = new ConcurrentDictionary<string, List<IHandlerFactory>>();
         }
 
+        /// <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)
         {
             var eventHandler = new ActionRequestHandler(action);
@@ -24,11 +35,21 @@ public void AddDynamicRequestHandler(string eventName, Func<dynamic, IRequestHan
             DoAddRequestHandler(new SingletonHandlerFactory(eventHandler), eventName: eventName);
         }
 
+        /// <summary>
+        /// Register handler with handler factory
+        /// </summary>
+        /// <param name="eventType"></param>
+        /// <param name="factory"></param>
         public void AddRequestHandler(Type eventType, IHandlerFactory factory)
         {
             DoAddRequestHandler(factory, eventType);
         }
 
+        /// <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
         {
             var eventHandler = new ActionRequestHandler<TEvent>(action);
@@ -36,21 +57,41 @@ public void AddRequestHandler(Type eventType, IHandlerFactory factory)
             AddRequestHandler<TEvent>(new SingletonHandlerFactory(eventHandler, typeof(TEvent)));
         }
 
+        /// <summary>
+        /// Register handler with handler factory
+        /// </summary>
+        /// <typeparam name="TEvent"></typeparam>
+        /// <param name="factory"></param>
         public void AddRequestHandler<TEvent>(IHandlerFactory factory) where TEvent : TransportTray
         {
             DoAddRequestHandler(factory, typeof(TEvent));
         }
 
+        /// <summary>
+        /// Get the all handler factory of a request
+        /// </summary>
+        /// <param name="request">request object</param>
+        /// <returns></returns>
         public List<IHandlerFactory> GetHandlerFactoriesForRequest(TransportTray request)
         {
             return GetOrCreateHandlerFactories(GetRequestName(request.GetType()));
         }
+        /// <summary>
+        /// Get the all handler factory of a request
+        /// </summary>
+        /// <param name="requestName">request name</param>
+        /// <returns></returns>
 
         public List<IHandlerFactory> GetHandlerFactoriesForRequest(string requestName)
         {
             return GetOrCreateHandlerFactories(requestName);
         }
 
+        /// <summary>
+        /// Get the request name by TransportTray type
+        /// </summary>
+        /// <param name="aType">the class inherited TransportTray</param>
+        /// <returns></returns>
         public string GetRequestName(Type aType)
         {
             if (aType.IsGenericType)
@@ -63,6 +104,11 @@ public string GetRequestName(Type aType)
             }
         }
 
+        /// <summary>
+        /// Register dynamic handler with delegate
+        /// </summary>
+        /// <param name="eventName"></param>
+        /// <param name="action"></param>
         public void RemoveDynamicRequestHandler(string eventName, Func<dynamic, IRequestHandlerContext, Task> action)
         {
             GetOrCreateHandlerFactories(eventName)
@@ -87,6 +133,11 @@ public void RemoveDynamicRequestHandler(string eventName, Func<dynamic, IRequest
                 });
         }
 
+        /// <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
         {
             GetOrCreateHandlerFactories(typeof(TEvent).Name)
diff --git a/tools/nupkg/ServiceAnt.1.0.0.zip b/tools/nupkg/ServiceAnt.1.0.0.zip
new file mode 100644
index 0000000..67c8440
Binary files /dev/null and b/tools/nupkg/ServiceAnt.1.0.0.zip differ