WCF性能、延迟和可伸缩性

WCF为几乎所有默认值选择非常安全的值。这遵循了不要让新手开发者开枪自杀的原则。但是，如果您知道要更改的限制和要使用的绑定，则可以获得合理的性能和可伸缩性。

在我的核心i5-2400(四核，无超线程，3.10 GHz)上，下面的解决方案将运行1000个客户端，每个客户端有1000个回调，平均总运行时间为20秒。

不幸的是，我不能让你的f#程序运行直接比较。如果你在你的机器上运行我的解决方案，你能发布一些f#和c# WCF性能比较数字吗?

免责声明 :下面是一个概念证明。有些设置对生产环境没有意义。

我做了:

• 删除了双工绑定，并让客户端创建自己的双工绑定接收回调的服务主机。这就是a双面绑定是在幕后进行的。(这也是普拉提的建议)
• 将绑定更改为netTcpBinding。
• 更改的节流值:
  WCF: maxConcurrentCalls, maxconcurrentssessions，maxConcurrentInstances全部设置为1000
• TCP绑定:maxConnections=1000
• 线程池:最小工作线程数= 1000，最小IO线程数= 2000

请注意，在这个原型中，所有的服务和客户端都在同一个App Domain中，并且共享同一个线程池。

我的收获:

• 当客户端收到"无法建立连接，因为目标机器主动拒绝它"异常时
  • 可能的原因:
    1. WCF已达到限值
    2. TCP限制已达到
    没有可用的I/O线程来处理调用。
• #3的解决方案是:
  1. 增加最小IO线程数- or -
  2. 让StockService在工作线程上做回调(这确实增加了总运行时间)

在i5-2400内核上运行的程序输出。请注意，计时器的使用方式与原始问题中的不同(请参阅代码)。

All client hosts open.
Service Host opened. Starting timer...
Press ENTER to close the host one you see 'ALL DONE'.
Client #100 completed 1,000 results in 0.0542168 s
Client #200 completed 1,000 results in 0.0794684 s
Client #300 completed 1,000 results in 0.0673078 s
Client #400 completed 1,000 results in 0.0527753 s
Client #500 completed 1,000 results in 0.0581796 s
Client #600 completed 1,000 results in 0.0770291 s
Client #700 completed 1,000 results in 0.0681298 s
Client #800 completed 1,000 results in 0.0649353 s
Client #900 completed 1,000 results in 0.0714947 s
Client #1000 completed 1,000 results in 0.0450857 s
ALL DONE. Total number of clients: 1000 Total runtime: 19323 msec

在一个控制台应用程序文件中编写所有代码:

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Diagnostics;
using System.Threading;
using System.Runtime.Serialization;
namespace StockApp
{
    [DataContract]
    public class Stock
    {
        [DataMember]
        public DateTime FirstDealDate { get; set; }
        [DataMember]
        public DateTime LastDealDate { get; set; }
        [DataMember]
        public DateTime StartDate { get; set; }
        [DataMember]
        public DateTime EndDate { get; set; }
        [DataMember]
        public decimal Open { get; set; }
        [DataMember]
        public decimal High { get; set; }
        [DataMember]
        public decimal Low { get; set; }
        [DataMember]
        public decimal Close { get; set; }
        [DataMember]
        public decimal VolumeWeightedPrice { get; set; }
        [DataMember]
        public decimal TotalQuantity { get; set; }
    }
    [ServiceContract]
    public interface IStock
    {
        [OperationContract(IsOneWay = true)]
        void GetStocks(string address);
    }
    [ServiceContract]
    public interface IPutStock
    {
        [OperationContract(IsOneWay = true)]
        void PutStock(Stock stock);
    } 
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
    public class StocksService : IStock
    {
        public void SendStocks(object obj)
        {
            string address = (string)obj;
            ChannelFactory<IPutStock> factory = new ChannelFactory<IPutStock>("CallbackClientEndpoint");
            IPutStock callback = factory.CreateChannel(new EndpointAddress(address));
            Stock st = null; st = new Stock
            {
                FirstDealDate = System.DateTime.Now,
                LastDealDate = System.DateTime.Now,
                StartDate = System.DateTime.Now,
                EndDate = System.DateTime.Now,
                Open = 495,
                High = 495,
                Low = 495,
                Close = 495,
                VolumeWeightedPrice = 495,
                TotalQuantity = 495
            };
            for (int i = 0; i < 1000; ++i)
                callback.PutStock(st);
            //Console.WriteLine("Done calling {0}", address);
            ((ICommunicationObject)callback).Shutdown();
            factory.Shutdown();
        }
        public void GetStocks(string address)
        {
            /// WCF service methods execute on IO threads. 
            /// Passing work off to worker thread improves service responsiveness... with a measurable cost in total runtime.
            System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(SendStocks), address);
            // SendStocks(address);
        }
    } 
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
    public class Callback : IPutStock
    {
        public static int CallbacksCompleted = 0;
        System.Diagnostics.Stopwatch timer = Stopwatch.StartNew();
        int n = 0;
        public void PutStock(Stock st)
        {
            ++n;
            if (n == 1000)
            {
                //Console.WriteLine("1,000 results in " + this.timer.Elapsed.TotalSeconds + "s");
                int compelted = Interlocked.Increment(ref CallbacksCompleted);
                if (compelted % 100 == 0)
                {
                    Console.WriteLine("Client #{0} completed 1,000 results in {1} s", compelted, this.timer.Elapsed.TotalSeconds);
                    if (compelted == Program.CLIENT_COUNT)
                    {
                        Console.WriteLine("ALL DONE. Total number of clients: {0} Total runtime: {1} msec", Program.CLIENT_COUNT, Program.ProgramTimer.ElapsedMilliseconds);
                    }
                }
            }
        }
    }
    class Program
    {
        public const int CLIENT_COUNT = 1000;           // TEST WITH DIFFERENT VALUES
        public static System.Diagnostics.Stopwatch ProgramTimer;
        static void StartCallPool(object uriObj)
        {
            string callbackUri = (string)uriObj;
            ChannelFactory<IStock> factory = new ChannelFactory<IStock>("StockClientEndpoint");
            IStock proxy = factory.CreateChannel();
            proxy.GetStocks(callbackUri);
            ((ICommunicationObject)proxy).Shutdown();
            factory.Shutdown();
        }
        static void Test()
        {
            ThreadPool.SetMinThreads(CLIENT_COUNT, CLIENT_COUNT * 2);
            // Create all the hosts that will recieve call backs.
            List<ServiceHost> callBackHosts = new List<ServiceHost>();
            for (int i = 0; i < CLIENT_COUNT; ++i)
            {
                string port = string.Format("{0}", i).PadLeft(3, '0');
                string baseAddress = "net.tcp://localhost:7" + port + "/";
                ServiceHost callbackHost = new ServiceHost(typeof(Callback), new Uri[] { new Uri( baseAddress)});
                callbackHost.Open();
                callBackHosts.Add(callbackHost);            
            }
            Console.WriteLine("All client hosts open.");
            ServiceHost stockHost = new ServiceHost(typeof(StocksService));
            stockHost.Open();
            Console.WriteLine("Service Host opened. Starting timer...");
            ProgramTimer = Stopwatch.StartNew();
            foreach (var callbackHost in callBackHosts)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(StartCallPool), callbackHost.BaseAddresses[0].AbsoluteUri);
            }
            Console.WriteLine("Press ENTER to close the host once you see 'ALL DONE'.");
            Console.ReadLine();
            foreach (var h in callBackHosts)
                h.Shutdown();
            stockHost.Shutdown(); 
        }
        static void Main(string[] args)
        {
            Test();
        }
    }
    public static class Extensions
    {
        static public void Shutdown(this ICommunicationObject obj)
        {
            try
            {
                obj.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Shutdown exception: {0}", ex.Message);
                obj.Abort();
            }
        }
    }
}

app.config:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="StockApp.StocksService">
        <host>
          <baseAddresses>
            <add baseAddress="net.tcp://localhost:8123/StockApp/"/>
          </baseAddresses>
        </host>
        <endpoint address="" binding="netTcpBinding" bindingConfiguration="tcpConfig" contract="StockApp.IStock">
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>
      </service>
      <service name="StockApp.Callback">
        <host>
          <baseAddresses>
            <!-- Base address defined at runtime. -->
          </baseAddresses>
        </host>
        <endpoint address="" binding="netTcpBinding" bindingConfiguration="tcpConfig" contract="StockApp.IPutStock">
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>
      </service>
    </services>
    <client>
      <endpoint name="StockClientEndpoint"
                address="net.tcp://localhost:8123/StockApp/"
                                binding="netTcpBinding"
                bindingConfiguration="tcpConfig"
                                contract="StockApp.IStock" >
      </endpoint>
      <!-- CallbackClientEndpoint address defined at runtime. -->
      <endpoint name="CallbackClientEndpoint"
                binding="netTcpBinding"
                bindingConfiguration="tcpConfig"
                contract="StockApp.IPutStock" >
      </endpoint>
    </client>
    <behaviors>
      <serviceBehaviors>
        <behavior>
          <!--<serviceMetadata httpGetEnabled="true"/>-->
          <serviceDebug includeExceptionDetailInFaults="true"/>
          <serviceThrottling maxConcurrentCalls="1000" maxConcurrentSessions="1000" maxConcurrentInstances="1000" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <bindings>
      <netTcpBinding>
        <binding name="tcpConfig" listenBacklog="100" maxConnections="1000">
          <security mode="None"/>
          <reliableSession enabled="false" />
        </binding>
      </netTcpBinding>
    </bindings>
  </system.serviceModel>
</configuration>

:我刚刚尝试了上面的解决方案与netNamedPipeBinding:

  <netNamedPipeBinding >
    <binding name="pipeConfig" maxConnections="1000" >
      <security mode="None"/>
    </binding>
  </netNamedPipeBinding>

它实际上慢了3秒(从20秒到23秒)。因为这个特殊的例子都是进程间的，我不确定为什么。如果有人有什么见解，请评论。

首先回答您的第二个问题，与原始套接字相比，WCF总是有开销。但与原始套接字相比，它具有大量的功能(如安全性、可靠性、互操作性、多种传输协议、跟踪等)，您是否可以接受这种权衡取决于您的场景。看起来你正在做一些金融交易应用程序，WCF可能不适合你的情况(尽管我不是在金融行业，没有经验来证明这一点)。

对于你的第一个问题，尝试在客户端托管一个单独的WCF服务，而不是双重http绑定，这样客户端可以自己成为一个服务，如果可能的话，使用netttcp绑定。调整服务行为中的serviceThrottling元素的属性。在。net 4之前，默认值更低。

我有一些关于f#中socket的帖子:http://moiraesoftware.com

我正在做一些正在进行的工作与一个库称为骨折io在这里:https://github.com/fractureio/fracture

你可能想看看这些想法…