namespace ProxyService.Services
{
    public interface IQueueService : IDisposable
    {
        void Subscribe();
        void UnSubscribe();
    }
}

using System.ComponentModel;
using System.Configuration;

namespace ProxyService
{
    public static class AppSettings
    {
        public static T Get(string key)
        {
            var appSetting = ConfigurationManager.AppSettings[key];
            if (string.IsNullOrWhiteSpace(appSetting)) throw new System.Exception(key);

            var converter = TypeDescriptor.GetConverter(typeof(T));
            return (T)(converter.ConvertFromInvariantString(appSetting));
        }
    }
}

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;

namespace ProxyService.Services
{
    public class RabbitMQQueueService : IQueueService
    {
        private bool disposed = false;

        private IModel _channel;
        private String _consumerTag;
        private IConnection _connection;
        private readonly IConnectionFactory _factory;

        private string WorkQueue { get; set; }

        private string RequestUri { get; set; }
        private AuthenticationHeaderValue authenticationHeader;

        public RabbitMQQueueService(IConnectionFactory factory)
        {
            this._factory = factory;
            this._connection = _factory.CreateConnection();
            this._channel = _connection.CreateModel();
            InitializeService();
        }

        private void InitializeService()
        {
            WorkQueue = AppSettings.Get<string>("WorkQueue");
            RequestUri = AppSettings.Get<string>("RequestUri");

            authenticationHeader = new AuthenticationHeaderValue(
                        "Basic",
                        Convert.ToBase64String(
                            Encoding.ASCII.GetBytes(
                                string.Format("{0}:{1}", AppSettings.Get<string>("UserName"),
                                                         AppSettings.Get<string>("Password")))));
        }

        public void Subscribe()
        {
            var consumer = new EventingBasicConsumer(_channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body;
                var message = Encoding.UTF8.GetString(body);
                using (HttpClient client = new HttpClient())
                {
                    client.DefaultRequestHeaders.Authorization = authenticationHeader;
                    try
                    {
                        using (HttpResponseMessage response = client.PostAsync(RequestUri, new StringContent(message)).Result)
                        {
                            if (!response.IsSuccessStatusCode)
                            {
                                // Log error 
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        // Log exception
                    }
                }
            };

            _consumerTag = _channel.BasicConsume(queue: WorkQueue,
                                noAck: true,
                                consumer: consumer);
        }

        public void UnSubscribe()
        {
            _channel.BasicCancel(_consumerTag);
        }

        ~RabbitMQQueueService()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (this.disposed)
            {
                return;
            }

            if (disposing)
            {
                _channel?.Dispose();
                _connection?.Dispose();
            }

            disposed = true;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Reflection;
using RabbitMQ.Client;

namespace ProxyService.Services
{
    public class RabbitMQConnectionFactory : ConnectionFactory
    {
        public RabbitMQConnectionFactory(Dictionary<string, String> fields)
            : base()
        {
            Type type = base.GetType();
            FieldInfo[] fieldsInfo = type.GetFields();
            foreach (var field in fields)
            {
                FieldInfo result = Array.Find(fieldsInfo,
                                        fi => fi.Name == field.Key);
                if (result != null)
                {
                    string sType = result.FieldType.FullName;
                    result.SetValue(this, Convert.ChangeType(field.Value,
                                            Type.GetType(sType)));
                }
            }
        }
    }
}

using System.ServiceProcess;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.Configuration;

namespace ProxyService
{
    static class Program
    {
        static void Main()
        {
            IUnityContainer container = new UnityContainer();
            container.LoadConfiguration();

            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[]
            {
                container.Resolve()
            };
            ServiceBase.Run(ServicesToRun);
        }
    }
}

using System.ServiceProcess;
using ProxyService.Services;

namespace ProxyService
{
    public partial class ProxyService : ServiceBase
    {
        private readonly IQueueService _queueService;

        public ProxyService(IQueueService queueService)
        {
            this._queueService = queueService;
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            _queueService.Subscribe();
        }

        protected override void OnStop()
        {
            _queueService.UnSubscribe();
        }
    }
}

namespace ProxyService
{
    partial class ProxyService
    {
        private System.ComponentModel.IContainer components = null;

        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }

            if (disposing)
            {
                _queueService?.Dispose();
            }

            base.Dispose(disposing);
        }

        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
            this.ServiceName = "ProxyService";

        }
    }
}

  
    <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/>
  

  
    <add key="WorkQueue"        value="1c-work-queue" />
    <add key="UserName"         value="1c_admin" />
    <add key="Password"         value="1c_password" />
    <add key="RequestUri"       value="http://hostname/1cbase/hs/queue_app/query" />
  
  
   
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
  

  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">

    <alias alias="ISettings" type="System.Collections.Generic.IDictionary`2[[System.String, mscorlib],[System.String, mscorlib]], mscorlib"/>
    <alias alias="Settings" type="System.Collections.Generic.Dictionary`2[[System.String, mscorlib],[System.String, mscorlib]], mscorlib"/>
    
    <alias alias="IConnectionFactory" type="RabbitMQ.Client.IConnectionFactory, RabbitMQ.Client" />
    <alias alias="RabbitMQConnectionFactory" type="ProxyService.Services.RabbitMQConnectionFactory, ProxyService" />

    <alias alias="IQueueService" type="ProxyService.Services.IQueueService, ProxyService" />
    <alias alias="RabbitMQQueueService" type="ProxyService.Services.RabbitMQQueueService, ProxyService" />

    
      
      <register type="ISettings" mapTo="Settings" name="connectionSettings">
        
        <method name="Add">
          <param name="key" type="System.String" value="HostName" />
          <param name="value" type="System.String" value="rabbitmq.local" />
        
        <!--
          
          
        -->
      
      
      <register type="IConnectionFactory" mapTo="RabbitMQConnectionFactory" name="connectionFactory">
        
          <param name="fields">
            <dependency name="connectionSettings" />
          
        
        <property name="UserName" value="rabbitmq_user"/>
        <property name="Password" value="rabbitmq_password"/>
      
 
      <register type="IQueueService" mapTo="RabbitMQQueueService">
        
          <param name="factory">
            <dependency name="connectionFactory" />