大比速：remoting、WCF(http)、WCF(tcp)、WCF(RESTful)、asp.net core(RESTful) .net core 控制台程序使用依赖注入（Autofac）

大比速：remoting、WCF(http)、WCF(tcp)、WCF(RESTful)、asp.net core(RESTful)

近来在考虑一个服务选型，dotnet提供了众多的远程服务形式。在只考虑dotnet到dotnet的情形下，我们可以选择remoting、WCF(http)、WCF(tcp)、WCF(RESTful)、asp.net core(RESTful)
其中我考察的重点是前4项的效率差异，而在我的测试项目中他们共用同一个接口定义

[ServiceContract]
public interface ICalc
{
    [OperationContract]
    [WebInvoke(Method = "POST",
            RequestFormat = WebMessageFormat.Json,
            ResponseFormat = WebMessageFormat.Json,
            BodyStyle = WebMessageBodyStyle.Bare,
            UriTemplate = "cmd")]
    CalcInfo Calc(CalcInfo pInfo);
}

先来对比传入较为简单的CalcInfo，该类的json只有如下，其中集合Items是空的

{
    "id": 0,
    "method": "test",
    "para1": 0,
    "para2": 0,
    "result": 999,
    "items": []
}

测试从客户端将一个CalcInfo的实例传入服务端，服务端稍加修改Method返回给客户端的过程，主要测试序列化与传输的用时。记录执行10000次请求的总用时

Remoting用时 3.76s
WCF(http) 用时 21.92s
WCF(tcp)用时 5.96s
WCF(RESTful)用时 2.26s
asp.net Core(RESTfull)用时 16.59s

再来一下比较传输一个较大的CalcInfo，该类的json如下，其中items集合有100个子实例

{
    "id": 0,
    "method": "test",
    "para1": 0,
    "para2": 0,
    "result": 999,
    "items": [
        {
            "name": "test 1",
            "para1": 1,
            "para2": 0
        },
        {
            "name": "test 2",
            "para1": 2,
            "para2": 0
        }
//....共有100个子项
    ]
}

Remoting用时 12.94s
WCF(http) 用时  47.38s
WCF(tcp)用时 9.2s
WCF(RESTful)用时 10.67s
asp.net Core(RESTfull)用时 26.08s

把两个时间放在一起对比一下就很有意思了。小流量时remoting比WCF强，WCF(TCP)莫名的高用时，比json的还要高。在大流量的时候WCF的优势体现出来了，基本符合网上大致的观点。其中WCF(RESTful)让kevin-y印象深刻，几乎与TCP一样的成绩

小流量

Remoting用时 3.76s
WCF(http) 用时 21.92s
WCF(tcp)用时 5.96s
WCF(RESTful)用时 2.26s
asp.net Core(RESTfull)用时 16.59s

大流量

Remoting用时 12.94s
WCF(http) 用时  47.38s
WCF(tcp)用时 9.2s
WCF(RESTful)用时 10.67s
asp.net Core(RESTfull)用时 26.83s

测试的源代码来这
https://files.cnblogs.com/files/kevin-Y/SrvSpeed2.zip

 

 

 

.net core 控制台程序使用依赖注入（Autofac）

 

1、Autofac IOC 容器 ，便于在其他类获取注入的对象

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141

using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using Autofac; using Autofac.Core; using Autofac.Extensions.DependencyInjection; using Microsoft.Extensions.DependencyInjection;   namespace BackToCOS.IoC {     /// <summary>     /// Autofac IOC 容器     /// </summary>     public class AutofacContainer     {         private static ContainerBuilder _builder = new ContainerBuilder();         private static IContainer _container;         private static string[] _otherAssembly;         private static List<Type> _types = new List<Type>();         private static Dictionary<Type, Type> _dicTypes = new Dictionary<Type, Type>();           /// <summary>         /// 注册程序集         /// </summary>         /// <param name="assemblies">程序集名称的集合</param>         public static void Register(params string[] assemblies)         {             _otherAssembly = assemblies;         }           /// <summary>         /// 注册类型         /// </summary>         /// <param name="types"></param>         public static void Register(params Type[] types)         {             _types.AddRange(types.ToList());         }         /// <summary>         /// 注册程序集。         /// </summary>         /// <param name="implementationAssemblyName"></param>         /// <param name="interfaceAssemblyName"></param>         public static void Register(string implementationAssemblyName, string interfaceAssemblyName)         {             var implementationAssembly = Assembly.Load(implementationAssemblyName);             var interfaceAssembly = Assembly.Load(interfaceAssemblyName);             var implementationTypes =                 implementationAssembly.DefinedTypes.Where(t =>                     t.IsClass && !t.IsAbstract && !t.IsGenericType && !t.IsNested);             foreach (var type in implementationTypes)             {                 var interfaceTypeName = interfaceAssemblyName + ".I" + type.Name;                 var interfaceType = interfaceAssembly.GetType(interfaceTypeName);                 if (interfaceType.IsAssignableFrom(type))                 {                     _dicTypes.Add(interfaceType, type);                 }             }         }         /// <summary>         /// 注册         /// </summary>         /// <typeparam name="TInterface"></typeparam>         /// <typeparam name="TImplementation"></typeparam>         public static void Register<TInterface, TImplementation>() where TImplementation : TInterface         {             _dicTypes.Add(typeof(TInterface), typeof(TImplementation));         }           /// <summary>         /// 注册一个单例实体         /// </summary>         /// <typeparam name="T"></typeparam>         /// <param name="instance"></param>         public static void Register<T>(T instance) where T:class         {             _builder.RegisterInstance(instance).SingleInstance();         }           /// <summary>         /// 构建IOC容器         /// </summary>         public static IServiceProvider Build(IServiceCollection services)         {             if (_otherAssembly != null)             {                 foreach (var item in _otherAssembly)                 {                     _builder.RegisterAssemblyTypes(Assembly.Load(item));                 }             }               if (_types != null)             {                 foreach (var type in _types)                 {                     _builder.RegisterType(type);                 }             }               if (_dicTypes != null)             {                 foreach (var dicType in _dicTypes)                 {                     _builder.RegisterType(dicType.Value).As(dicType.Key);                 }             }               _builder.Populate(services);             _container = _builder.Build();             return new AutofacServiceProvider(_container);         }           /// <summary>         ///         /// </summary>         /// <typeparam name="T"></typeparam>         /// <returns></returns>         public static T Resolve<T>()         {             return _container.Resolve<T>();         }           public static T Resolve<T>(params Parameter[] parameters)         {             return _container.Resolve<T>(parameters);         }           public static object Resolve(Type targetType)         {             return _container.Resolve(targetType);         }           public static object Resolve(Type targetType, params Parameter[] parameters)         {             return _container.Resolve(targetType, parameters);         }     } }

　　2、用nuget安装

using Microsoft.Extensions.Configuration;
       using Microsoft.Extensions.DependencyInjection;

3、Program类如下

 1 using BackToCOS.IoC;
 2 using log4net;
 3 using Microsoft.Extensions.Configuration;
 4 using Microsoft.Extensions.DependencyInjection;
 5 using Microsoft.Extensions.Logging;
 6 using Myvas.AspNetCore.TencentCos;
 7 using System;
 8 using System.IO;
 9 using Topshelf;
10
11 namespace BackToCOS
12 {
13     class Program
14     {
15         static void Main(string[] args)
16         {
17             var configuration = new ConfigurationBuilder()
18               .SetBasePath(Directory.GetCurrentDirectory())
19               .AddJsonFile("appsettings.json", true, true)
20               .AddJsonFile("appsettings.Development.json", true, true)
21               .Build();
22             IServiceCollection services = new ServiceCollection();
23
24             services.AddTencentCos(options =>
25             {
26                 options.SecretId = configuration["TencentCos:SecretId"];
27                 options.SecretKey = configuration["TencentCos:SecretKey"];
28             });
29             services.AddLogging(builder => builder
30                .AddConfiguration(configuration.GetSection("Logging"))
31                .AddConsole());
32             //注入
33             services.AddSingleton<ITencentCosHandler, TencentCosHandler>();
34             //用Autofac接管
35             AutofacContainer.Build(services);
36             log4net.Config.XmlConfigurator.ConfigureAndWatch(LogManager.CreateRepository("NETCoreRepository"), new FileInfo(AppDomain.CurrentDomain.BaseDirectory + "log4net.config"));
37             HostFactory.Run(x =>
38             {
39                 x.UseLog4Net();
40                 x.Service<BackupServiceRunner>();
41                 x.RunAsLocalSystem();
42                 x.SetDescription("备份到cos的服务");
43                 x.SetDisplayName("备份到cos的服务");
44                 x.SetServiceName("BackToCOS");
45                 x.EnablePauseAndContinue();
46             });
47         }
48     }
49
50 }

4、用容器获取事例（非构造函数）

 1 using log4net;
 2 using Microsoft.Extensions.Options;
 3 using Myvas.AspNetCore.TencentCos;
 4 using Quartz;
 5 using System;
 6 using System.Collections.Generic;
 7 using System.Text;
 8 using System.Threading.Tasks;
 9
10 namespace BackToCOS.Jobs
11 {
12     //DisallowConcurrentExecution属性标记任务不可并行
13     [DisallowConcurrentExecution]
14     public class BackupJob : IJob
15     {
16         private readonly ILog _log = LogManager.GetLogger("NETCoreRepository", typeof(BackupJob));
17         public Task Execute(IJobExecutionContext context)
18         {
19             try
20             {
21                 _log.Info("测试任务,当前系统时间:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
22                 ITencentCosHandler tencentCosHandler = IoC.AutofacContainer.Resolve<ITencentCosHandler>();
23                 var ss = tencentCosHandler.AllBucketsAsync();
24                 return Task.CompletedTask;
25             }
26             catch (Exception ex)
27             {
28                 JobExecutionException e2 = new JobExecutionException(ex);
29                 _log.Error("测试任务异常", ex);
30             }
31             return Task.CompletedTask;
32         }
33     }
34 }