1. Por supuesto, necesitamos exportar ticks y mejor que usemos la estructura nativa MqlTick;
2. Es preferible conocer la lista de símbolos exportados actualmente.

Vamos a empezar...

1. Clases y contratos generales

    [StructLayout(LayoutKind.Sequential)]
    [DataContract]
    public struct MqlTick
    {
        [DataMember] 
        public Int64 Time { get; set; }
        [DataMember]
        public Double Bid { get; set; }
        [DataMember]
        public Double Ask { get; set; }
        [DataMember]
        public Double Last { get; set; }
        [DataMember]
        public UInt64 Volume { get; set; }
    }

    [ServiceContract(CallbackContract = typeof(IExportClient))]
    public interface IExportService
    {
        [OperationContract]
        void Subscribe();

        [OperationContract]
        void Unsubscribe();

        [OperationContract]
        String[] GetActiveSymbols();
    }

    [ServiceContract]
    public interface IExportClient
    {
        [OperationContract(IsOneWay = true)]
        void SendTick(String symbol, MqlTick tick);

        [OperationContract(IsOneWay = true)]
        void ReportSymbolsChanged();
    }

Vamos a crear una nueva construcción con el nombre Qexport.Service.dll para el servicio con la implementación del contrato de servidor.

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
        ConcurrencyMode = ConcurrencyMode.Multiple,
        UseSynchronizationContext = false,
        IncludeExceptionDetailInFaults = true)]
    public class ExportService : IExportService, IDisposable
    {

        public void Open()
        {
            _ExportHost = new ServiceHost(this);

            // point with service
            _ExportHost.AddServiceEndpoint(typeof(IExportService),  // contract
                new NetNamedPipeBinding(),                          // binding
                new Uri(_ServiceAddress));                          // address

            // remove the restriction of 16 requests in queue
            ServiceThrottlingBehavior bhvThrot = new ServiceThrottlingBehavior();
            bhvThrot.MaxConcurrentCalls = Int32.MaxValue;
            _ExportHost.Description.Behaviors.Add(bhvThrot);

            _ExportHost.Open();
        }

        public void Close()
        {
            Dispose(true);
        }
       
        private void Dispose(bool disposing)
        {
            try
            {
                // closing channel for each client
                // ...

                // closing host
                _ExportHost.Close();
            }
            finally
            {
                _ExportHost = null;
            }

            // ...
        }

A continuación la implementación de los métodos IExportService:

        public void Subscribe()
        {
            // get the callback channel
            IExportClient cl = OperationContext.Current.GetCallbackChannel<IExportClient>();
            lock (lockClients)
                _Clients.Add(cl);
        }

        public void Unsubscribe()
        {
            // get the callback chanell
            IExportClient cl = OperationContext.Current.GetCallbackChannel<IExportClient>();
            lock (lockClients)
                _Clients.Remove(cl);
        }

        public String[] GetActiveSymbols()
        {
            return _ActiveSymbols.ToArray();
        }

Ahora necesitamos añadir métodos para enviar ticks y para registrar y borrar los símbolos exportados.

     public void RegisterSymbol(String symbol)
        {
            if (!_ActiveSymbols.Contains(symbol))
                _ActiveSymbols.Add(symbol);

              // sending notification to all clients about changes in the list of active symbols
              //...
        }

        public void UnregisterSymbol(String symbol)
        {
            _ActiveSymbols.Remove(symbol);

             // sending notification to all clients about the changes in the list of active symbols
             //...
        }

        public void SendTick(String symbol, MqlTick tick)
        {
            lock (lockClients)
                for (int i = 0; i < _Clients.Count; i++)
                    try
                    {
                        _Clients[i].SendTick(symbol, tick);
                    }
                    catch (CommunicationException)
                    {
                        // it seems that connection with client has lost - we just remove the client
                        _Clients.RemoveAt(i);
                        i--;
                    }
        }

Vamos a resumir la lista de principales funciones de servidor (solo las que necesitamos):

3. Implementación del cliente

Hemos considerado el servidor, creo que está claro, ahora es el momento de considerar el cliente. Vamos a construir Qexport.Client.dll. El contrato del cliente se implementará aquí. Primero, debe marcarse con el atributo CallbackBehavior, que define su comportamiento. Tiene los siguientes modificadores:

Me resultó interesante medir la velocidad de transferencia entre dos aplicaciones .NET, de hecho, su rendimiento específico medido en ticks por segundo. Escribí varias aplicaciones para medir el rendimiento del servicio: la primera es para el servidor y la segunda para el cliente. Escribí el siguiente código en la función Main() del servidor:

            ExportService host = new ExportService("mt5");
            host.Open();

            Console.WriteLine("Press any key to begin tick export");
            Console.ReadKey();

            int total = 0;

            Stopwatch sw = new Stopwatch();

            for (int c = 0; c < 10; c++)
            {
                int counter = 0;
                sw.Reset();
                sw.Start();

                while (sw.ElapsedMilliseconds < 1000)
                {
                    for (int i = 0; i < 100; i++)
                    {
                        MqlTick tick = new MqlTick { Time = 640000, Bid = 1.2345 };
                        host.SendTick("GBPUSD", tick);
                    }
                    counter++;
                }

                sw.Stop();
                total += counter * 100;

                Console.WriteLine("{0} ticks per second", counter * 100);
            }

            Console.WriteLine("Average {0:F2} ticks per second", total / 10);
            
            host.Close();

5. Crear un "estrato"

Ahora es el momento de pensar cómo conectarlo con el terminal de cliente. Vamos a ver lo que tenemos en la primera llamada de la función en MetaTrader 5: el entorno de ejecución de .NET (CLR) se carga al proceso y se crea el dominio de la aplicación por defecto. Nos interesa que no se descargue después de la ejecución del código.

La única forma de descargar CLR del proceso es finalizándolo (cerrar el terminal de cliente), lo que forzará a Windows a liberar todos los recursos del proceso. Podemos pues crear nuestros objetos y estos existirán hasta que se descargue el dominio de la aplicación o hasta que sea destruido por el recogedor de basura.

Puede parecer bueno, pero si evitamos la destrucción del objeto por el recogedor de basura, no podremos acceder a los objetos desde MQL5. Por suerte, dicho acceso puede organizarse fácilmente. El truco es el siguiente: para cada dominio de la aplicación hay una tabla de controladores del recogedor de basura (tabla de controladores del GC -Garbage Collector), que es usado por la aplicación para seguir la pista de la vida del objeto y permitir su gestión manual.

La aplicación añade y borra elementos de la tabla usando el tipo System.Runtime.InteropServices.GCHandle. Todo lo que necesitamos es envolver nuestro objeto con dicho descriptor y tendremos acceso a él en toda la propiedad GCHandle.Target. De esta forma, podemos obtener la referencia al objeto GCHandle, que está en la tabla de controladores y es seguro que el recogedor de basura no lo moverá ni lo borrará. El objeto envuelto también evitará el reciclado, debido a la referencia del descriptor.

Es el momento de probar la teoría en la práctica. Para hacer esto vamos a crear una nueva win32 dll con el nombre QExpertWrapper.dll y añadir el soporte CLR, System.dll, QExport.dll, Qexport.Service.dll a la referencia construida. También creamos una clase auxiliar ServiceManaged con finalidad de gestión - para llevar a cabo la ordenación, para recibir objetos por los controladores, etc.

ref class ServiceManaged
{
        public:
                static IntPtr CreateExportService(String^);
                static void DestroyExportService(IntPtr);
                static void RegisterSymbol(IntPtr, String^);
                static void UnregisterSymbol(IntPtr, String^);
                static void SendTick(IntPtr, String^, IntPtr);
};

Vamos a ver la implementación de estos métodos. El método CreateExportService crea el servicio, lo envuelve dentro de GCHandle usando GCHandle. Lo ubica y devuelve su referencia. Si algo va mal muestra un MessageBox con un error. Lo he usado con finalidad de depuración, por lo que no estoy seguro de que sea realmente necesario, pero lo dejo ahí por si acaso.

IntPtr ServiceManaged::CreateExportService(String^ serverName)
{
        try
        {
                ExportService^ service = gcnew ExportService(serverName);
                service->Open();
        
                GCHandle handle = GCHandle::Alloc(service);
                return GCHandle::ToIntPtr(handle);
        }
        catch (Exception^ ex)
        {
                MessageBox::Show(ex->Message, "CreateExportService");
        }
}

El método DestroyExportService lleva el puntero al GCHandle del servicio, obtiene el servicio de la propiedadTarget y llama a su método Close(). Es importante liberar el objeto del servicio llamando a su método Free(). De no ser así, se quedaría en la memoria, el recogedor de basura no lo eliminaría.

void ServiceManaged::DestroyExportService(IntPtr hService)
{
        try
        {
                GCHandle handle = GCHandle::FromIntPtr(hService);

                ExportService^ service = (ExportService^)handle.Target;
                service->Close();

                handle.Free();
        }
        catch (Exception^ ex)
        {
                MessageBox::Show(ex->Message, "DestroyExportService");
        }
}

El métodoRegisterSymbol añade un símbolo a la lista de símbolos exportados:

void ServiceManaged::RegisterSymbol(IntPtr hService, String^ symbol)
{
        try
        {
                GCHandle handle = GCHandle::FromIntPtr(hService);
                ExportService^ service = (ExportService^)handle.Target;

                service->RegisterSymbol(symbol);
        }
        catch (Exception^ ex)
        {
                MessageBox::Show(ex->Message, "RegisterSymbol");
        }
}

El método UnregisterSymbol borra un símbolo de la lista:

void ServiceManaged::UnregisterSymbol(IntPtr hService, String^ symbol)
{
        try
        {
                GCHandle handle = GCHandle::FromIntPtr(hService);
                ExportService^ service = (ExportService^)handle.Target;

                service->UnregisterSymbol(symbol);
        }
        catch (Exception^ ex)
        {
                MessageBox::Show(ex->Message, "UnregisterSymbol");
        }
}

Y ahora el método SendTick. Como vemos, el puntero se ha transformado en la estructura MqlTick usando la clase Marshal. Otro punto: no hay ningún código en el bloque de captura, se hace para evitar los retrasos de la cola de tick general en caso de error.

void ServiceManaged::SendTick(IntPtr hService, String^ symbol, IntPtr hTick)
{
        try
        {
                GCHandle handle = GCHandle::FromIntPtr(hService);
                ExportService^ service = (ExportService^)handle.Target;
        
                MqlTick tick = (MqlTick)Marshal::PtrToStructure(hTick, MqlTick::typeid);

                service->SendTick(symbol, tick);
        }
        catch (...)
        {
        }
}

Vamos a ver la implementación de funciones que serán llamadas desde nuestros programas ex5:

#define _DLLAPI extern "C" __declspec(dllexport)

// ---------------------------------------------------------------
// Creates and opens service 
// Returns its pointer
// ---------------------------------------------------------------
_DLLAPI long long __stdcall CreateExportService(const wchar_t* serverName)
{
        IntPtr hService = ServiceManaged::CreateExportService(gcnew String(serverName));
        
        return (long long)hService.ToPointer(); 
}

// ----------------------------------------- ----------------------
// Closes service
// ---------------------------------------------------------------
_DLLAPI void __stdcall DestroyExportService(const long long hService)
{
        ServiceManaged::DestroyExportService(IntPtr((HANDLE)hService));
}

// ---------------------------------------------------------------
// Sends tick
// ---------------------------------------------------------------
_DLLAPI void __stdcall SendTick(const long long hService, const wchar_t* symbol, const HANDLE hTick)
{
        ServiceManaged::SendTick(IntPtr((HANDLE)hService), gcnew String(symbol), IntPtr((HANDLE)hTick));
}

// ---------------------------------------------------------------
// Registers symbol to export
// ---------------------------------------------------------------
_DLLAPI void __stdcall RegisterSymbol(const long long hService, const wchar_t* symbol)
{
        ServiceManaged::RegisterSymbol(IntPtr((HANDLE)hService), gcnew String(symbol));
}

// ---------------------------------------------------------------
// Removes symbol from list of exported symbols
// ---------------------------------------------------------------
_DLLAPI void __stdcall UnregisterSymbol(const long long hService, const wchar_t* symbol)
{
        ServiceManaged::UnregisterSymbol(IntPtr((HANDLE)hService), gcnew String(symbol));
}

El código está listo y ahora necesitamos compilarlo y construirlo. Vamos a especificar el directorio de salida en las opciones del proyecto como "C:\Program Files\MetaTrader 5\MQL5\Libraries". Después de la compilación aparecerán tres librerías en la carpeta especificada.

El programa mql5 solo usa una de ellas, QExportWrapper.dll y las otras dos son usadas por esta. Por esta razón necesitamos poner las librerías Qexport.dll y Qexport.Service.dll en la carpeta raíz de MetaTrader. No es aconsejable.

La solución es crear el archivo de configuración y especificar la ruta para las librerías aquí. Vamos a crear al archivo con el nombre terminal.exe.config en la carpeta raíz de MetaTrader y a escribir ahí los siguientes strings:

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
   <runtime>
      <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
         <probing privatePath="mql5\libraries" />
      </assemblyBinding>
   </runtime>
</configuration>

Está listo. Ahora, CLR buscará las librerías en la carpeta que hemos especificado.

6. Implementación de la parte del servidor en MQL5

Finalmente, hemos llegado a la programación de la parte del servidor en mql5. Vamos a crear un nuevo archivo QService.mqh y a definir las funciones importadas de QExpertWrapper.dll:

#import "QExportWrapper.dll"
   long  CreateExportService(string);
   void DestroyExportService(long);
   void RegisterSymbol(long, string);
   void UnregisterSymbol(long, string);
   void SendTick(long, string, MqlTick&);
#import
 

//+------------------------------------------------------------------+
//|                                                    QExporter.mq5 |
//|                                             Copyright GF1D, 2010 |
//|                                             garf1eldhome@mail.ru |
//+------------------------------------------------------------------+
#property copyright "GF1D, 2010"
#property link      "garf1eldhome@mail.ru"
#property version   "1.00"

#include "QService.mqh"
//--- input parameters
input string  ServerName = "mt5";

QService* service;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   service = new QService();
   service.Create(ServerName);
   return(0);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   service.Close();
   delete service;
   service = NULL;
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   MqlTick tick;
   SymbolInfoTick(Symbol(), tick);
   
   service.SendTick(Symbol(), tick);
}
//+------------------------------------------------------------------+