在NancyFX自托管单例

时间：2015-07-14 21:09:13

标签： c# web-services architecture nancy topshelf

我目前正试图找到一种方法来调用在关闭在NancyFX自托管应用程序内的TinyIOC中创建的单例对象时需要调用的任务。

到目前为止，我还没有找到答案，而且我也愿意接受更好的想法来实现我即将描述的情景。

概述

我有一个基于PHP的Web应用程序，我正在研究，因为这是PHP，没有旋转的线程/服务器来监听和处理长时间运行的任务，php代码存在于生活中请求它的浏览器请求的范围。

有问题的应用程序需要向Web服务发出一些可能需要时间才能完成的请求，因此我提出了使用Topshelf在C＃中实现一些后端服务的想法， NancyFX和Stackexchange.Redis。

该服务是标准的NancyFX自主控制台应用程序，如下所示：

Program.cs的 

using Topshelf;

namespace processor
{
  public class Program
  {
    static void Main()
    {
      HostFactory.Run(x =>
      {
        x.UseLinuxIfAvailable();
        x.Service<ServiceApp>(s =>
        {
          s.ConstructUsing(app => new ServiceApp());
          s.WhenStarted(sa => sa.Start());
          s.WhenStopped(sa => sa.Stop());
        });
      });
    }

  }
}

ServiceApp.cs 

using System;
using Nancy.Hosting.Self;

namespace processor
{
  class ServiceApp
  {
    private readonly NancyHost _server;

    public ServiceApp()
    {
      _server = new NancyHost(new Uri(Settings.NancyUrl));
    }

    public void Start()
    {
      Console.WriteLine("processor starting.");

      try
      {
        _server.Start();
      }
      catch (Exception)
      {
        throw new ApplicationException("ERROR: Nancy Self hosting was unable to start, Aborting.");
      }

      Console.WriteLine("processor has started.");
    }

    public void Stop()
    {
      Console.WriteLine("processor stopping.");
      _server.Stop();
      Console.WriteLine("processor has stopped.");
    }

  }
}

ProcessorKernel.cs 

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using StackExchange.Redis;

namespace processor
{
  public class ProcessorKernel
  {
    private readonly ConnectionMultiplexer _redis;
    private ISubscriber _redisSubscriber;

    public ProcessorKernel()
    {
      try
      {
        _redis = ConnectionMultiplexer.Connect(Settings.RedisHost);
      }
      catch (Exception ex)
      {
        throw new ApplicationException("ERROR: Could not connect to redis queue, aborting.");
      }

      RegisterProcessor();

      RedisMonitor();

    }

    ~ProcessorKernel()
    {
      var response = RequestDeregistration();
      // Do some checks on the response here
    }

    private RegistrationResponse RequestRegistration()
    {
      string registrationResponse = string.Empty;

      try
      {
        registrationResponse = Utils.PostData("/processorapi/register", new Dictionary<string, string>
        {
          {"channelname", Settings.ChannelName},
        });
      }
      catch (ApplicationException ex)
      {
        throw new ApplicationException("ERROR: " + ex.Message + " occured while trying to register.  Aborting");
      }

      return JsonConvert.DeserializeObject<RegistrationResponse>(registrationResponse);
    }

    private DeregistrationResponse RequestDeregistration()
    {
      var deregistrationResponse = "";

      try
      {
        deregistrationResponse = Utils.PostData("/processorapi/deregister", new Dictionary<string, string>
        {
          {"channelname", Settings.ChannelName},
        });
      }
      catch (ApplicationException ex)
      {
        throw new ApplicationException("ERROR: " + ex.Message + " occured while trying to deregister.  Aborting");
      }

      return JsonConvert.DeserializeObject<DeregistrationResponse>(deregistrationResponse);
    }

    private void RegisterProcessor()
    {
      Console.WriteLine("Registering processor with php application");

      RegistrationResponse response = RequestRegistration();
      // Do some checks on the response here

      Console.WriteLine("Processor Registered");
    }

    private void RedisMonitor(string channelName)
    {
      _redisSubscriber = _redis.GetSubscriber();
      _redisSubscriber.Subscribe(channelName, (channel, message) =>
      {
        RedisMessageHandler(message);
      });
    }

    private void RedisMessageHandler(string inboundMessage)
    {
      RedisRequest request = JsonConvert.DeserializeObject<RedisRequest>(inboundMessage);
      // Do something with the message here
    }
  }
}

除了这三个类之外，我还有一些标准的NancyFX路由模块，用于处理各种端点等。

如果这很有效，正如您从 ProcessorKernel 中看到的那样，我调用了一个名为 RegisterProcessor 的方法，请联系负责管理此方法的Web应用程序处理器实例和注册本身，基本上是对网络应用程序说，嘿，我在这里，并准备好通过redis队列向我发送请求。

然而， ProcessorKernel 使用Nancy Bootstrapper实例化为单例：

using Nancy;
using Nancy.Bootstrapper;
using Nancy.TinyIoc;

namespace processor
{
  public class Bootstrapper : DefaultNancyBootstrapper
  {
    protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
    {
      base.ApplicationStartup(container, pipelines);
      container.Register<ProcessorKernel>().AsSingleton();
    }

  }
}

它必须是单例的原因是因为它必须接受来自redis的排队请求，然后处理它们并将它们发送到不同位置的各种Web服务。

有几个不同的频道，但一个处理器一次只能收听一个频道。这最终意味着当 ProcessorKernel 关闭时，它必须调用PHP Web应用程序以“去注册”＆＃34;本身，并告知应用程序没有任何东西正在为该频道提供服务。

它找到了一个很好的挂钩点，称这种取消注册会导致我的问题。

尝试的方法

从上面的代码中可以看出，我尝试过使用类析构函数，虽然不是世界上最好的解决方案，但它确实被调用了，但是类在它返回之前被拆除了，所以实际的注销永远不会完成，因此永远不会正确注销。

我还试图让单例类成为IDisposable，并查看是否将取消注册代码放入＆＃34; Destroy＆＃34;，但这根本没有被调用。

因为我使用Topshelf并且我在 ServiceApp 中有启动/停止方法我知道我可以在那里调用我的例程，但我无法访问单例此时 ProcessorKernel 因为它不是南希模块，因此TinyIOC无法解决依赖关系。

我最初还尝试在 Program.cs 中创建 ProcessorKernel ，然后通过 ServiceApp 构造函数传递它，同时创建了一个服务，它没有注册为单例，并且在Nancy Route模块内无法访问，因此状态端点无法查询创建的实例以进行状态更新，因为它们只获得了TinyIOC创建的单例。

如果我可以访问Start / Stop中的单例，那么我可以轻松地在其上放置几个公共方法来调用寄存器/注销函数。

为了完整起见，我用于将帖子请求发送到PHP Web应用程序的代码如下：

Utils.cs 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Text;

namespace processor
{
  public class Utils
  {
    public static string PostData(string url, Dictionary<string, string> data)
    {
      string resultContent;

      using (var client = new HttpClient())
      {
        client.BaseAddress = new Uri(Settings.AppBase);
        var payload = new List<KeyValuePair<string, string>>();

        foreach (var item in data)
        {
          payload.Add(new KeyValuePair<string, string>(item.Key, item.Value));
        }

        var content = new FormUrlEncodedContent(payload);

        var result = client.PostAsync(url, content).Result;
        resultContent = result.Content.ReadAsStringAsync().Result;
        var code = result.StatusCode;

        if (code == HttpStatusCode.InternalServerError)
        {
          Console.WriteLine(resultContent);
          throw new ApplicationException("Server 500 Error while posting to: " + url);
        }

        if (code == HttpStatusCode.NotFound)
        {
          Console.WriteLine(resultContent);
          throw new ApplicationException("Server 404 Error " + url + " was not a valid resource");
        }
      }

      return resultContent;
    }
  }
}

摘要

我所需要的只是一种可靠的方式来调用取消注册代码，并确保服务通知php-app它已经消失，因为php-app的性质我可以＆＃39; t使用redis将消息发回给它，因为它只是没有收听，该应用程序是在Apache Web服务器下运行的标准线性php应用程序。

只要只有一个实际的 ProcessorKernel 实例运行，我就可以提供更好的方法来解决这个问题。一旦注册，它必须处理发送到其通道的每个请求，并且由于处理的请求可能被访问多次并由几个不同的Web服务处理，因此这些请求需要保存在内存中，直到它们的处理完全完整。

提前感谢您对此的任何想法。

更新 - 第二天： - ）

所以在看到下面的Kristian的回答，看到他/ GrumpyDev's和Phillip Haydon在我的Twitter流媒体上的回复后，我将我的Singleton课程改回了IDisposable，摆脱了~Finalizer，然后更改 ServiceApp.cs ，以便它调用 Host.Dispose（）而不是 Host.Stop（）

然后在我的单例类中正确调用了 Dispose 例程，这使我能够正确关闭。

我也提出了另一种解决方法，我不得不承认

  • a）很难看
  • b）现已被删除

然而，本着分享（并有尴尬的风险）的精神，我将在此处详细说明注意：我实际上并不建议这样做

首先我调整了 ServiceApp.cs ，现在看起来像是：

using System;
using Nancy.Hosting.Self;
using Nancy.TinyIoc;

namespace processor
{
  class ServiceApp
  {
    private readonly NancyHost _server;
    private static ProcessorKernel _kernel;

    public static ProcessorKernel Kernel { get { return _kernel;}}

    public ServiceApp()
    {
      _server = new NancyHost(new Uri(Settings.NancyUrl));
    }

    public void Start()
    {
      Console.WriteLine("Processor starting.");

      _kernel = TinyIoCContainer.Current.Resolve<ProcessorKernel>();

      try
      {
        _server.Start();
      }
      catch (Exception)
      {
        throw new ApplicationException("ERROR: Nancy Self hosting was unable to start, Aborting.");
      }

      _kernel.RegisterProcessor();

      Console.WriteLine("Processor has started.");
    }

    public void Stop()
    {
      Console.WriteLine("Processor stopping.");

      _kernel.DeRegisterProcessor();
      _server.Dispose();

      Console.WriteLine("Processor has stopped.");
    }

  }
}

正如您所看到的，这使我能够使用TinyIOC在服务应用程序中获取对我的单例的引用，这允许我保留在启动/停止服务例程中调用Reg / DeReg的引用。

然后添加公共静态内核属性，以便我的Nancy Modules可以调用 ServiceApp.Kernel ... 来获取他们响应查询所需的状态信息南希终点。

正如我所说的那样，这种改变现在已经被取消，有利于回到IDisposable的做事方式。

感谢所有花时间回复的人。

1 个答案:

答案 0 :(得分：3)

有一种标准的方式来处理＆＃34;清理＆＃34;在.NET中 - 它被称为IDisposable，Nancy（以及它的核心组件，如IoC容器）广泛使用它。

只要在顶层调用对象correctly implements IDisposable和Dispose方法（最好通过using块），就应该在正确的时间处理对象。 / p>

您应该致电Stop，而不是在NancyHost上致电Dispose。这将导致以下结果：

  • 停止NancyHost（就像你已经做的那样）
    • 处理引导程序
      • 处理应用程序容器（在本例中为TinyIoCContainer）
        • 处理实施IDisposable
          • 的所有单例实例

为了让处理一直到ProcessorKernel，您必须确保它实现IDisposable并将代码从终结器移动到Dispose方法。< / p>

PS！除非您正在处理非托管资源，否则您永远不应该实现终结器。这是some reasons。如果你谷歌的话，我相信你会发现更多。

相关问题
最新问题