我有一个C#库做一些文件处理.我创建了一个控制台和桌面应用程序,使用该库并在大约1分钟内处理256mb文件.然后,我创建了一个在 Windows服务中托管的WCF服务,该服务使用相同的文件处理库,但是从网站调用时需要10倍的时间来处理相同的256mb文件. Windows服务正在具有管理员权限的域帐户下运行.

调用WCF服务的开销非常快,但是LoadFile方法需要更长的时间.我尝试在启动过程中增加进程优先级

Process.GetCurrentProcess ().PriorityClass = ProcesspriorityClass.High;

无济于事我在Win7 64位桌面系统(6gb),2003 XP 32bit服务器(4gb)和2008 R2 32bit服务器(4bg)上运行此服务,结果类似.控制台和桌面应用程序在上述系统上大约1分钟内处理文件.该进程似乎没有内存限制并进入swapville.

Windows服务是否以某种方式进行限制？在IIS下运行WCF服务可以获得更好的结果吗？

编辑：我尝试从网站调用库目录,也比控制台或桌面应用程序长10倍.

更新：原来是Log4PostSharp.控制台和桌面应用程序在配置文件中没有任何痕迹的log4net,而网站和Windows服务却没有.有一个log4net TraceAppender默默地吃掉了宝贵的cpu周期.

我不明白为什么你所描述的行为正在发生 – 它似乎很奇怪.由于您正在处理内存中较大的文件,垃圾收集器可能会影响它.您可以尝试更改垃圾收集器运行的模式,看是否有任何影响.

垃圾收集器有三种模式 – 工作站,服务器和并发.每个人以不同的方式行事,并针对不同类型的应用进行了优化.工作站模式是默认模式,并且是所有进程运行的,除非配置为使用别的东西.有关模式的更多信息可以找到here.

尝试明确地将垃圾回收器设置为使用服务器模式(它将仅对多处理器计算机有影响).为此,请将以下内容放在您的app.config文件中：

<configuration>
    <runtime>
        <gcServer enabled="true" />
    </runtime>
</configuration>

我试图在 Windows 2008 R2服务器上托管WCF服务作为Windows服务.我按照msdn( found here)提供的指示进行操作.只要所有内容都是Visual Studio中同一解决方案的一部分,一切都可以正常工作.但是,我尝试在不同的解决方案(在同一台机器上)创建客户端,但无法找到该服务.我收到如下所示的“添加服务引用错误”.

我的目标是能够远程访问wcf服务,但我似乎甚至无法在本地访问它,除非客户端是在同一客户端内创建的.是否有任何指南,教程或有用的提示,任何人都可以让我让这个工作？

更新：
似乎即使Windows服务正在运行,WCF服务似乎也没有监听任何端口.这表明它没有运行.这也解释了为什么每个人都认为我没有运行该服务.我曾经假设,因为Windows服务正在运行并且同一个解决方案客户端工作,所以WCF服务也正常运行.事实证明,每当我运行相同的解决方案客户端时,Visual Studio就会启动WCF服务.

那么,为什么Windows服务不启动WCF服务呢？有任何想法吗？

事实证明,MSDN提供的教程存在问题(在上面的问题中提供).他们将Windows服务和WCF服务Service1命名为两者的默认名称.

Windows服务假设启动WCF服务,但它实际上是尝试再次启动,因为两个服务具有相同的名称.

myServiceHost = new ServiceHost(typeof(Service1));

要解决此问题,您可以在Windows服务中引用时重命名其中一个服务或完全限定WCF服务.

myServiceHost = new ServiceHost(typeof(WcfServiceLibrary1.Service1));

有趣的是,提供的代码看起来仍然有效,因为Visual Studio足够聪明,可以注意到WCF服务没有运行,它在幕后启动实例.

修复这是一个简单的错误,但由于Visual Studio隐藏了我的问题,我认为如果没有Espen Burud的帮助我就不会找到它.

我注意到WCF应用程序中存在内存泄漏问题,并设法在一个简单的程序中复制它.从另一个WCF服务中调用WCF服务时会出现此问题.

在下面的示例中,我有两个服务A和B.当我在服务A上调用DoWork方法时,它又调用服务B的DoWork方法.

在下面的示例中,我每次都创建一个新的ChannelFactory,使用它打开一个通道,调用DoWork,然后在最后处理通道和工厂.这样,进程就会开始泄漏内存.

如果我设置其中一个或两个调用,每次重复使用相同的ChannelFactory(注释并取消注释示例中标记的行),泄漏就会停止.

如果我每次调用服务A时都继续创建一个新的ChannelFactory,但是空白了ServiceA的DoWork方法(因此它不会调用ServiceB),则不会发生泄漏.

我正在运行针对.NET 3.5的程序.奇怪的是,如果我切换到.NET 4,4.5或4.5.1,该过程会更快地泄漏内存.

任何人都可以理解为什么会这样,也许可以解决它(或至少解决它)？

示例代码如下：

using System;
using System.ServiceModel;

namespace memoryleak
{
    internal class Program
    {
        private static void Main()
        {
            using (var hostA = new ServiceHost(new ServiceA(),new Uri("net.pipe://localhost")))
            using (var hostB = new ServiceHost(new ServiceB(),new Uri("net.pipe://localhost")))
            {
                hostA.AddServiceEndpoint(typeof (ContractA),new NetNamedPipeBinding(),"test_service_a");
                hostA.open();
                hostB.AddServiceEndpoint(typeof (ContractB),"test_service_b");
                hostB.open();

                while(true)dowork();
            }
        }

        //CALLING SERVICE A

        //uncomment the following line to reuse the same ChannelFactory each time
        //private static readonly ChannelFactory<ContractA> pipeFactory=new ChannelFactory<ContractA>(new NetNamedPipeBinding(),new EndpointAddress("net.pipe://localhost/test_service_a"));

        private static void dowork()
        {
            //comment the following line to reuse the same ChannelFactory each time
            var pipeFactory = new ChannelFactory<ContractA>(new NetNamedPipeBinding(),new EndpointAddress("net.pipe://localhost/test_service_a"));

            ContractA provider = null;
            try
            {
                provider = pipeFactory.CreateChannel();
                provider.DoWork();
            }
            catch
            {
            }
            finally
            {
                CloseChannel(provider);

                //comment the following line to reuse the same ChannelFactory each time
                try { pipeFactory.Close(); }catch{pipeFactory.Abort();}
            }
        }

        private static void CloseChannel(ContractA provider)
        {
            try
            {
                if (provider == null)
                    return;
                try
                {
                    ((IClientChannel) provider).Close();
                }
                catch
                {
                    ((IClientChannel) provider).Abort();
                }
                ((Idisposable) provider).dispose();
            }
            catch (Exception ex)
            {
                throw new Exception("Error while closing channel",ex);
            }
        }
    }

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,ConcurrencyMode = ConcurrencyMode.Multiple)]
    public class ServiceA : ContractA
    {
        //CALLING SERVICE B


        //uncomment the following line to reuse the same ChannelFactory each time
        //private readonly ChannelFactory<ContractB> pipeFactory=new ChannelFactory<ContractB>(new NetNamedPipeBinding(),new EndpointAddress("net.pipe://localhost/test_service_b"));

        public void DoWork()
        {
            //comment the following line to reuse the same ChannelFactory each time
            var pipeFactory=new ChannelFactory<ContractB>(new NetNamedPipeBinding(),new EndpointAddress("net.pipe://localhost/test_service_b"));

            ContractB provider = null;
            try
            {
                provider = pipeFactory.CreateChannel();
                provider.DoWork();
            }
            catch
            {
            }
            finally
            {
                CloseChannel(provider);

                //comment the following line to reuse the same ChannelFactory each time
                try { pipeFactory.Close(); } catch { pipeFactory.Abort(); }
            }
        }

        private void CloseChannel(ContractB provider)
        {
            try
            {
                if (provider == null)
                    return;
                try
                {
                    ((IClientChannel) provider).Close();
                }
                catch
                {
                    ((IClientChannel) provider).Abort();
                }
                ((Idisposable) provider).dispose();
            }
            catch (Exception ex)
            {
                throw new Exception("Error while closing channel",ex);
            }
        }

    }

    [ServiceContract]
    public interface ContractA
    {
        [OperationContract]
        void DoWork();
    }

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,ConcurrencyMode = ConcurrencyMode.Multiple)]
    public class ServiceB : ContractB
    {
        public void DoWork()
        {
        }
    }

    [ServiceContract]
    public interface ContractB
    {
        [OperationContract]
        void DoWork();
    }
}

可能发生的是,您创建的对象比默认工作站垃圾收集器可以摆脱它们更快. .net 3.5 GC的默认延迟模式是交互式的,这意味着如果为了保持UI响应而收集时间过长则会放弃. GC在.net 4& 4.5这可能是你看到不同增长率的原因.

尝试在App.config中打开服务器垃圾回收模式,看看行为是否发生了变化.这应该允许GC工作直到完成.

<configuration>
   <runtime>
      <gcServer enabled="true"/>
   </runtime>
</configuration>

我假设你使用的是多核系统,否则这将是零影响.