fix issue #17.

src/DotNetCore.CAP/Abstractions/ModelBinding/IModelBinder.cs

@@ -7,15 +7,6 @@ namespace DotNetCore.CAP.Abstractions.ModelBinding
     /// </summary>
     public interface IModelBinder
     {
-        /// <summary>
-        /// Attempts to bind a model.
-        /// </summary>
-        /// <param name="bindingContext">The <see cref="ModelBindingContext"/>.</param>
-        /// <returns>
-        /// <para>
-        /// A <see cref="Task"/> which will complete when the model binding process completes.
-        /// </para>
-        /// </returns>
-        Task BindModelAsync(ModelBindingContext bindingContext);
+        Task<ModelBindingResult> BindModelAsync(string content);
     }
 }

src/DotNetCore.CAP/Abstractions/ModelBinding/ModelBindingResult.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DotNetCore.CAP.Abstractions.ModelBinding
+{
+    /// <summary>
+    /// Contains the result of model binding.
+    /// </summary>
+    public struct ModelBindingResult
+    {
+        /// <summary>
+        /// Creates a <see cref="ModelBindingResult"/> representing a failed model binding operation.
+        /// </summary>
+        /// <returns>A <see cref="ModelBindingResult"/> representing a failed model binding operation.</returns>
+        public static ModelBindingResult Failed()
+        {
+            return new ModelBindingResult(model: null, isSuccess: false);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="ModelBindingResult"/> representing a successful model binding operation.
+        /// </summary>
+        /// <param name="model">The model value. May be <c>null.</c></param>
+        /// <returns>A <see cref="ModelBindingResult"/> representing a successful model bind.</returns>
+        public static ModelBindingResult Success(object model)
+        {
+            return new ModelBindingResult(model, isSuccess: true);
+        }
+
+        private ModelBindingResult(object model, bool isSuccess)
+        {
+            Model = model;
+            IsSuccess = isSuccess;
+        }
+
+        /// <summary>
+        /// Gets the model associated with this context.
+        /// </summary>
+        public object Model { get; }
+
+        public bool IsSuccess { get; }
+
+        public override string ToString()
+        {
+            if (IsSuccess)
+            {
+                return $"Success '{Model}'";
+            }
+            else
+            {
+                return $"Failed";
+            }
+        } 
+    }
+}

src/DotNetCore.CAP/CAP.ServiceCollectionExtensions.cs

@@ -35,7 +35,7 @@ public static class ServiceCollectionExtensions
             AddSubscribeServices(services);
 
             services.TryAddSingleton<IConsumerServiceSelector, DefaultConsumerServiceSelector>();
-            services.TryAddSingleton<IModelBinder, DefaultModelBinder>();
+            services.TryAddSingleton<IModelBinderFactory, ModelBinderFactory>();
             services.TryAddSingleton<IConsumerInvokerFactory, ConsumerInvokerFactory>();
             services.TryAddSingleton<MethodMatcherCache>();
 

src/DotNetCore.CAP/Internal/ConsumerInvokerFactory.cs

@@ -10,23 +10,23 @@ public class ConsumerInvokerFactory : IConsumerInvokerFactory
     {
         private readonly ILogger _logger;
         private readonly IServiceProvider _serviceProvider;
-        private readonly IModelBinder _modelBinder;
+        private readonly IModelBinderFactory _modelBinderFactory;
 
         public ConsumerInvokerFactory(
             ILoggerFactory loggerFactory,
-            IModelBinder modelBinder,
+            IModelBinderFactory modelBinderFactory,
             IServiceProvider serviceProvider)
         {
             _logger = loggerFactory.CreateLogger<ConsumerInvokerFactory>();
-            _modelBinder = modelBinder;
+            _modelBinderFactory = modelBinderFactory;
             _serviceProvider = serviceProvider;
         }
 
         public IConsumerInvoker CreateInvoker(ConsumerContext consumerContext)
         {
             var context = new ConsumerInvokerContext(consumerContext)
             {
-                Result = new DefaultConsumerInvoker(_logger, _serviceProvider, _modelBinder, consumerContext)
+                Result = new DefaultConsumerInvoker(_logger, _serviceProvider, _modelBinderFactory, consumerContext)
             };
 
             return context.Result;

src/DotNetCore.CAP/Internal/HashCodeCombiner.cs

@@ -0,0 +1,81 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace DotNetCore.CAP.Internal
+{
+    internal struct HashCodeCombiner
+    {
+        private long _combinedHash64;
+
+        public int CombinedHash
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return _combinedHash64.GetHashCode(); }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private HashCodeCombiner(long seed)
+        {
+            _combinedHash64 = seed;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Add(IEnumerable e)
+        {
+            if (e == null)
+            {
+                Add(0);
+            }
+            else
+            {
+                var count = 0;
+                foreach (object o in e)
+                {
+                    Add(o);
+                    count++;
+                }
+                Add(count);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator int(HashCodeCombiner self)
+        {
+            return self.CombinedHash;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Add(int i)
+        {
+            _combinedHash64 = ((_combinedHash64 << 5) + _combinedHash64) ^ i;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Add(string s)
+        {
+            var hashCode = (s != null) ? s.GetHashCode() : 0;
+            Add(hashCode);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Add(object o)
+        {
+            var hashCode = (o != null) ? o.GetHashCode() : 0;
+            Add(hashCode);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Add<TValue>(TValue value, IEqualityComparer<TValue> comparer)
+        {
+            var hashCode = value != null ? comparer.GetHashCode(value) : 0;
+            Add(hashCode);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static HashCodeCombiner Start()
+        {
+            return new HashCodeCombiner(0x1505L);
+        }
+    }
+}

src/DotNetCore.CAP/Internal/IConsumerInvoker.Default.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Threading.Tasks;
 using DotNetCore.CAP.Abstractions;
-using DotNetCore.CAP.Abstractions.ModelBinding;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
@@ -11,16 +10,16 @@ public class DefaultConsumerInvoker : IConsumerInvoker
     {
         private readonly ILogger _logger;
         private readonly IServiceProvider _serviceProvider;
-        private readonly IModelBinder _modelBinder;
+        private readonly IModelBinderFactory _modelBinderFactory;
         private readonly ConsumerContext _consumerContext;
         private readonly ObjectMethodExecutor _executor;
 
         public DefaultConsumerInvoker(ILogger logger,
             IServiceProvider serviceProvider,
-            IModelBinder modelBinder,
+            IModelBinderFactory modelBinderFactory,
             ConsumerContext consumerContext)
         {
-            _modelBinder = modelBinder;
+            _modelBinderFactory = modelBinderFactory;
             _serviceProvider = serviceProvider;
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
@@ -29,7 +28,7 @@ public class DefaultConsumerInvoker : IConsumerInvoker
                 _consumerContext.ConsumerDescriptor.ImplTypeInfo);
         }
 
-        public Task InvokeAsync()
+        public async Task InvokeAsync()
         {
             using (_logger.BeginScope("consumer invoker begin"))
             {
@@ -43,18 +42,21 @@ public Task InvokeAsync()
                 if (_executor.MethodParameters.Length > 0)
                 {
                     var firstParameter = _executor.MethodParameters[0];
-
-                    var bindingContext = ModelBindingContext.CreateBindingContext(value,
-                        firstParameter.Name, firstParameter.ParameterType);
-
-                    _modelBinder.BindModelAsync(bindingContext);
-                    _executor.Execute(obj, bindingContext.Result);
+                    var binder = _modelBinderFactory.CreateBinder(firstParameter);
+                    var result = await binder.BindModelAsync(value);
+                    if (result.IsSuccess)
+                    {
+                        _executor.Execute(obj, result.Model);
+                    }
+                    else
+                    {
+                        _logger.LogWarning($"Parameters:{firstParameter.Name} bind failed!");
+                    }
                 }
                 else
                 {
                     _executor.Execute(obj);
                 }
-                return Task.CompletedTask;
             }
         }
     }

src/DotNetCore.CAP/Internal/IModelBinder.ComplexType.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+using DotNetCore.CAP.Abstractions.ModelBinding;
+using DotNetCore.CAP.Infrastructure;
+
+namespace DotNetCore.CAP.Internal
+{
+    public class ComplexTypeModelBinder : IModelBinder
+    {
+        private readonly ParameterInfo _parameterInfo;
+
+        public ComplexTypeModelBinder(ParameterInfo parameterInfo)
+        {
+            _parameterInfo = parameterInfo;
+        }
+
+        public Task<ModelBindingResult> BindModelAsync(string content)
+        {
+            try
+            {
+                var type = _parameterInfo.ParameterType;
+                var value = Helper.FromJson(content, type);
+                return Task.FromResult(ModelBindingResult.Success(value));
+            }
+            catch (Exception)
+            {
+                return Task.FromResult(ModelBindingResult.Failed());
+
+            }
+        }
+    }
+}