NETVFP.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Diagnostics;
using System.Xml;
using System.IO;
using System.Drawing;
using System.Data;
using sage.ew.global;
using sage.ew.db;
using sage.ew.functions;
using sage.ew.ewbase;  // Task 111215. Eliminar sage.ew.license
using System.Text.RegularExpressions;
using sage.ew.objetos;
using sage.ew.usuario;
using sage.ew.functions.Clases.DiccionariosLoader;
using sage.ew.functions.Clases;
using sage.ew.interficies;
using Sage.ES.S50.Addons;

namespace sage.ew.netvfp
{
    public static class NETVFP
    {
        #region DLLimports
        
        [DllImport("user32.dll")]
        public static extern IntPtr RegisterWindowMessageW([MarshalAs(UnmanagedType.LPTStr)]String lpString);    // Pointer to a null-terminated string that specifies the message to be registered. 

        [DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hWnd, IntPtr Msg, int wParam, int lParam);

        [DllImport("user32.dll")]
        public static extern int PostMessage(IntPtr hWnd, IntPtr Msg, int wParam, int lParam);

        [DllImport("user32.dll")]
        public static extern sbyte GetMessage(out Message lpMsg, IntPtr hWnd, uint wMsgFilterMin, uint wMsgFilterMax);

        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern ushort GlobalAddAtom(string lpString);

        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        public static extern ushort GlobalDeleteAtom(ushort nAtom);

        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern uint GlobalGetAtomName(ushort nAtom, char[] lpBuffer, int nSize);

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool IsWindow(IntPtr hWnd);

        [DllImport("user32.dll")]
        public static extern bool EnableWindow(IntPtr hwnd, Boolean bEnable);

        [DllImport("user32.dll")]
        public static extern int GetForegroundWindow();

        [DllImport("user32.dll")]
        public static extern int GetWindowText(int hWnd, StringBuilder text, int count);

        [DllImport("user32.dll")]
        public static extern IntPtr GetTopWindow(IntPtr hWnd);
        
        [DllImport("kernel32.dll")]
        public static extern IntPtr CreateMutex(IntPtr lpMutexAttributes, bool bInitialOwner, string lpName);

        [DllImport("kernel32.dll")]
        public static extern bool ReleaseMutex(IntPtr hMutex);

        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenMutex(uint dwDesiredAccess, bool bInheritHandle, string lpName);

        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool CloseHandle(IntPtr hObject);
        // FI PE-80275

        // PE-93758
        [DllImport("User32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern IntPtr SetParent(IntPtr hWndChild, IntPtr hWndParent);

        [DllImport("user32.dll")]
        public static extern int SetWindowLong(IntPtr hWnd, int nIndex, uint dwNewLong);

        [DllImport("user32.dll", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        public static extern IntPtr SetFocus(IntPtr hwnd);

        [DllImport("user32.dll")]
        public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);

        [DllImport("user32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        // <summary>
        // Mostrar una ventana
        // </summary>
        // <param name="hwnd"></param>
        // <param name="nCmdShow"></param>
        // <returns></returns>
       // [DllImport("user32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
      //  public static extern bool ShowWindow(IntPtr hwnd, int nCmdShow);

        [DllImport("user32.dll")]
        private static extern int ShowWindow(IntPtr hWnd, uint Msg);

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
        // FI PE-93758

        [DllImport("User32.dll")]
        private static extern IntPtr GetParent(IntPtr hWnd);

        [DllImport("user32.dll", SetLastError = true)]
        static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);

        #endregion DLLimports


        #region CONSTANTES

        public const char SEPARADOR = '|';
        
        private const string EWVFP_NOTIFICATION = "SAGE_EW_VFP_NET";
        private const string EWNET_NOTIFICATION = "SAGE_EW_NET_VFP";
        private const string SAGE50_NOTIFICATION = "SAGE50_NOTIFICATION";  // PE-93758
        private const string SAGE50_NOTIFICATION2 = "SAGE50_NOTIFICATION2";  // PE-93758
        private const string SAGE50_NOTIFICATION3 = "SAGE50_NOTIFICATION3";  // PE-100744
        private const string SAGE50_NOTIFICATION4 = "SAGE50_NOTIFICATION4";  // PE-100744
        private const string SAGE50_NOTIFICATION5 = "SAGE50_NOTIFICATION5";  // PE-100744

        private const int MINIMO_PARAMETROS = 4;
        private const int RESPONDER_INDEX = 0;
        private const int OPCION_INDEX = 1;
        private const int TIPO_INDEX = 2;
        private const int VALOR_INDEX = 3;
        
        private const int WM_SETREDRAW = 11;

        private const uint SW_MAXIMIZE = 0x03;
        private const uint SW_MINIMIZE = 0x06;
        private const uint SW_RESTORE = 0x09;
        
        #endregion CONSTANTES


        #region PROPIEDADES


        //public static DataTable _dtOpenAllForms = new DataTable();   


        // PE-105604
        public static bool _lNoComInterrupt = false;

        public static bool _plRespuesta = false;

        public static Dictionary<string, object> _Parametros;

        // Identificadores de los mensajes de comunicación
        private static IntPtr msgewvfp_Notification = IntPtr.Zero;
        private static IntPtr msgewnet_Notification = IntPtr.Zero;
        private static IntPtr msgSage50_Notification = IntPtr.Zero;   // CANAL NIVEL 1 (PE-93758)
        private static IntPtr msgSage50_Notification2 = IntPtr.Zero;  // CANAL NIVEL 2 (PE-93758)
        private static IntPtr msgSage50_Notification3 = IntPtr.Zero;  // CANAL NIVEL 3 (PE-100744)
        private static IntPtr msgSage50_Notification4 = IntPtr.Zero;  // CANAL NIVEL 4 (PE-100744)
        private static IntPtr msgSage50_Notification5 = IntPtr.Zero;  // CANAL NIVEL 5 (PE-100744)

        // Propiedad para guardar el indicador del mutex de control de .net (PE-80275)
        private static IntPtr _nhMutexNet = IntPtr.Zero;

        // Nos servirá para averiguar el canal de comunicaciones entre FOX y NET (PE-93758, 100744)                
        private static int _Canales = 0;

        private static readonly string _cNameProd = Convert.ToString(EW_GLOBAL._GetVariable("wc_nameproducto"));

        private static bool _lCerrarFormulariosEWCanal2 = false;
        #endregion PROPIEDADES


        // Constructor estático
        static NETVFP()
        {
            try
            {
                // Registrar los mensajes de comunicacion entre VFP y NET
                RegisterWindowMessages();
                    
                // Inicializo el diccionario de parámetros 
                // Estructura/ejemplo de los parámetros obligatorios
                //_Parametros["responder"]  = false;     -> Indica si hay que enviar/recibir respuesta
                //_Parametros["opcion"]     = "albatpv"; -> Opción general a la que queremos acceder
                //_Parametros["tipo"]       = "valor";   -> Valores fijos (xml o valor).                                 
                //_Parametros["valor"]      = "";        -> Si xml -> Ruta fichero, sino valores de parámetro/parámetros separados por el separador
                _Parametros = new Dictionary<string, object>();

                // PE-103085. Inicializar el cursor donde guardaremos la referencia y hora de las formularios abiertos
                //_dtOpenAllForms.Columns.Add("handle", typeof(IntPtr));
                //_dtOpenAllForms.Columns.Add("hora", typeof(DateTime));
                //_dtOpenAllForms.Columns.Add("tipo", typeof(string));
                //_dtOpenAllForms.PrimaryKey = new DataColumn[] { _dtOpenAllForms.Columns["handle"] };
            }
            catch (Exception lo)
            {
                MessageBox.Show(lo.Message);
            }
        }


        #region METODOS PUBLICOS
        public static bool _SendMessageToVfp()
        {
            bool llSage50 = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")); // PE-100744
            bool llOk = false;
            string lcMensaje = string.Empty;            

            // Antes de enviar un mensaje, forzar a terminar la espera de respuestas por si aún existe alguna activa.
            _plRespuesta = false;

            DB.Registrar_Traza("_SendMessageToVfp - Inicio");

            // Comprobamos que exista el receptor del mensaje
            if (!IsWindow((IntPtr)EW_GLOBAL._nHandleVfp))
                return false;

            DB.Registrar_Traza("_SendMessageToVfp - Handle FOX OK");

            if (_Parametros == null || (_Parametros != null && _Parametros.Count <= 0))
                return false;

            DB.Registrar_Traza("_SendMessageToVfp - Parameters OK");

            // Comprobamos si hay que esperar una respuesta
            _plRespuesta = Convert.ToBoolean(_Parametros["responder"]);
            
            // Preparamos la cadena a enviar como mensaje a VFP                       
            foreach (KeyValuePair<string, object> loClave in _Parametros)
            {
                if (!string.IsNullOrEmpty(lcMensaje))
                    lcMensaje = lcMensaje + SEPARADOR;

                lcMensaje = lcMensaje + loClave.Value.ToString().Trim();
            }

            DB.Registrar_Traza("_SendMessageToVfp - Mensaje= "+ lcMensaje);

            try
            {
                // PE-93758. Tratar los distintos canales de comunicación en sage50. Al tener un sólo un ejecutable de .net, hay que tener un canal distinto para cada nivel. De momento permitimos dos.
                // Enviar mensaje a VFP   
                if (llSage50)
                {                    
                    IntPtr intPtrCanal = IntPtr.Zero;

                    // Bug 153118. Forzar un sólo canal
                    _Canales = _lCerrarFormulariosEWCanal2 ? 2 : 1; // Al cerrar la aplicación si tenemos pantallas de FOX vamos a cerrar por el Canal 2

                    DB.Registrar_Traza("_SendMessageToVfp - Canal " + _Canales.ToString());
                    
                    switch (_Canales)
                    {
                        case 1:
                            intPtrCanal = msgSage50_Notification;
                            break;

                        case 2:
                            intPtrCanal = msgSage50_Notification2;
                            break;

                        case 3:
                            intPtrCanal = msgSage50_Notification3;
                            break;

                        case 4:
                            intPtrCanal = msgSage50_Notification4;
                            break;

                        case 5:
                            intPtrCanal = msgSage50_Notification5;
                            break;

                        default:
                            intPtrCanal = msgSage50_Notification;
                            break;
                    }

                    llOk = (PostMessage((IntPtr)EW_GLOBAL._nHandleVfp, intPtrCanal, GlobalAddAtom(lcMensaje), lcMensaje.Length) != -1);                    
                    // FI PE-100744
                }
                else
                    llOk = (PostMessage((IntPtr)EW_GLOBAL._nHandleVfp, msgewvfp_Notification, GlobalAddAtom(lcMensaje), lcMensaje.Length) != -1);
                // FI PE-93758   
                
                if (llOk)
                {                    
                    // En caso necesario, obtenemos mensaje de respuesta de VFP 
                    if (_plRespuesta)
                    {
                        DB.Registrar_Traza("_SendMessageToVfp - Inicio espera respuesta");

                        // Bucle infinito hasta recibir respuesta
                        while (_plRespuesta)
                        {                            
                            Application.DoEvents();
                        }

                        DB.Registrar_Traza("_SendMessageToVfp - Fin espera respuesta");
                    }
                }
            }
            catch (Exception loEx)
            {
                MessageBox.Show(loEx.Message);
                System.Diagnostics.Debug.WriteLine("Error en SendEventToHostWindow: " + loEx.Message);
                llOk = false;
            }         

            return llOk;
        }

        public static bool _ReceiveMessageFromVfpPasswordInforautFOX(string tcEmpresa,string tcFichero)
        {
            FUNCTIONS._PasswordInforaut(tcEmpresa, tcFichero);
            return true;
        }

        public static bool _ReceiveMessageFromVfp(ref Message msgVfp)
        {
            bool llOk = false;


            if (((IntPtr)msgVfp.Msg == msgewvfp_Notification) || ((IntPtr)msgVfp.Msg == msgewnet_Notification) || ((IntPtr)msgVfp.Msg == msgSage50_Notification) || ((IntPtr)msgVfp.Msg == msgSage50_Notification2) || 
                ((IntPtr)msgVfp.Msg == msgSage50_Notification3) || ((IntPtr)msgVfp.Msg == msgSage50_Notification4) || ((IntPtr)msgVfp.Msg == msgSage50_Notification5))  // PE-93758, 100744
            {
                
                try
                {
                    DB.Registrar_Traza("_ReceiveMessageFromVfp - Inicio");

                    // Obtener los parámetros a partir del mensaje recibido de VFP y cargarlos en el diccionario 
                    string lcCadena = ObtenerCadenaMensaje(msgVfp);                    
                    llOk = (_ObtenerParametros(lcCadena));

                    // Asegurar que nos llegan parámetros
                    if (!llOk)
                        return true;

                    // PE-106613. Optimización
                    string lcOpcion = Convert.ToString(_Parametros["opcion"]).ToLower().Trim();
                    string lcValor  = Convert.ToString(_Parametros["valor"]).Trim();
                    string lcTipo   = Convert.ToString(_Parametros["tipo"]).Trim();


                    DB.Registrar_Traza("_ReceiveMessageFromVfp - Opción: " + lcOpcion);
                    DB.Registrar_Traza("_ReceiveMessageFromVfp - Valor: " + lcValor);
                    DB.Registrar_Traza("_ReceiveMessageFromVfp - Tipo: " + lcTipo);

                    // PE-105604 
                    if (_lNoComInterrupt == false || (_lNoComInterrupt == true && llOk && lcOpcion != "resize"))
                    {
                        // En el caso de ser un mensaje de respuesta, finalizamos el bucle donde espera la respuesta (_SendMessageToVfp)
                        _plRespuesta = false;
                    }


                    #region MENSAJES SAGE50

                    // **** MENSAJES SAGE50 (PE-93758) **** 


                    // Mensaje para imprimir recibos. Task 133717
                    if (llOk && lcOpcion == "imprimirrecibos")
                    {
                        string lcXmlFile = "", lcEmpresa = "", lcFactura = "";
                        int lnEjercicio = 0, lnOrden = 0, lnImpagado = 0, lnPendiente = 0, lnTipoReport= 0;
                        DataTable ldtRecibos = new DataTable();

                        // Fichero xml donde recibimos los recibos a imprimir
                        lcXmlFile = lcValor;

                        // Obtener los valores para enviar el correo
                        FUNCTIONS._Xml2Datatable(lcXmlFile, ref ldtRecibos);
                        File.Delete(lcXmlFile);

                        // Ir imprimiendo los recibos
                        foreach (DataRow loRecibo in ldtRecibos.Rows)
                        {
                            lcEmpresa = Convert.ToString(loRecibo["empresa"]).Trim();
                            lnEjercicio = Convert.ToInt16(loRecibo["periodo"]);
                            lcFactura = Convert.ToString(loRecibo["factura"]).Trim().PadLeft(10,' ');
                            lnOrden = Convert.ToInt16(loRecibo["orden"]);
                            lnImpagado = Convert.ToInt16(loRecibo["impagado"]);
                            lnPendiente = Convert.ToInt16(loRecibo["pendiente"]);
                            lnTipoReport = Convert.ToInt16(loRecibo["tiporep"]);

                            FUNCTIONS._ImprimirRecibo(lcEmpresa,lnEjercicio,lcFactura,lnOrden,lnImpagado,lnPendiente,lnTipoReport);
                        }                                                
                    }

                    // Mensaje para crear una tarea programada (Task 106637)
                    if (llOk && lcOpcion == "tareaprog")
                    {   
                        // Obtener datos enviados en el mensaje desde fox
                        string lcFormParam = lcValor;  // Formulario y parámetros separados por @
                        string lcNombre    = lcTipo;   // Nombre para la tarea

                        // Obtener el nombre del formulario a ejecutar, puede ser que lleve parámetros
                        string lcForm = lcFormParam;
                        if (lcForm.IndexOf('@') > 0)
                        {
                            string[] loPartes = lcForm.Split('@');
                            lcForm = loPartes[0];
                        }
                        // Comprobar acceso al formulario a ejecutar
                        Usuario loSageSystem = new Usuario("SAGESYSTEM", true);
                        loSageSystem._Load();
                        formul._TiposAccesosPantalla loTipoAcceso = loSageSystem._Acceso(lcForm, true);
                        if (loTipoAcceso != formul._TiposAccesosPantalla.Completo)
                            loSageSystem._Acceso_Pantalla(lcForm, formul._TiposAccesosPantalla.Completo, true, EW_GLOBAL._GetVariable("wc_empresa").ToString().Trim());

                        // Parámetros tarea
                        string lcDescripcion = "Tarea programada de "+_cNameProd+" para el formulario " + lcForm;
                        string lcHora = "22:00";
                        List<bool> lstDias = new List<bool>() { true, true, true, true, true, false, false };

                        // Creación tarea
                        Usuario._This._CrearTareaAutomatica(lcNombre, lcDescripcion, lcFormParam, lstDias, lcHora, null, false, loSageSystem);                                                
                    }

                    // Mensaje para abrir albarán de venta relacionado con un servicio (PE-102010)
                    if (llOk && lcOpcion == "albavenservicio")
                    {
                        string lcFormVfp = "ALBAVEN";
                        string[] laParamsVfp = { lcValor };
                        string lcFileReturn = lcTipo;                        

                        FUNCTIONS._Obtener_Formulario_Net("","","", lcFormVfp, laParamsVfp, 0, false);
                        
                        GuardarFicheroXmlRespuesta(lcFileReturn, new string[] { "true" });                               
                    }


                    // Mensaje para comprobar la suscripción de un módulo en sage50 (PE-100885)
                    if (llOk && lcOpcion == "bajasuscripcion")
                    {
                        string lcModulo = lcValor;
                        string lcFileReturn = lcTipo;

                        bool llBaja = LICENCIAS._BajaSuscripcion(lcModulo);

                        GuardarFicheroXmlRespuesta(lcFileReturn, new string[] { llBaja.ToString().Trim().ToLower() });
                    }

                    // Mensaje para comprobar la suscripción de un formulario en sage50 (PE-100885)
                    if (llOk && lcOpcion == "bajasuscripcionform")
                    {
                        string lcForm = lcValor;
                        string lcFileReturn = lcTipo;

                        bool llBaja = LICENCIAS._BajaSuscripcionForm(lcForm);

                        GuardarFicheroXmlRespuesta(lcFileReturn, new string[] { llBaja.ToString().Trim().ToLower() });
                    }

                    // Mensaje de respuesta, aquí sólo lo utilizamos para decrementar los niveles de comunicación FOX-NET (PE-100744)
                    if (llOk && lcOpcion == "retorno")
                    {
                        try
                        {
                            if (EW_GLOBAL._OpenForms != null)
                            {
                                _Canales--;

                                // PE-103236. En caso de cerrar un formulario de fox, si sólo queda abierto el frmPrincipal, refrescamos información de la tabla CONNECT tambien
                                if (EW_GLOBAL._OpenForms.Count == 1)
                                    Usuario._This._Revisar_Connect_Formulario("frmPrincipal", "frmPrincipal");

                                // Recuperar y mostrar el último formulario de net abierto antes de navegar a fox
                                if (EW_GLOBAL._OpenForms.Count > 0)
                                {
                                    Form loForm = EW_GLOBAL._OpenForms.Peek();
                                    if (loForm != null)
                                    {
                                        loForm.BringToFront();
                                        loForm.Focus();
                                    }
                                }
                            }
                        }
                        catch (Exception loEx)
                        {
                            DB.Registrar_Error(loEx);
                        }
                    }

                    //PE-104237: Recepción de un mensaje de fox con un xml de clientes para calcular el riesgo
                    if (llOk && lcOpcion == "recalculoriesgo")
                    {
                        string lcClienteIni = lcTipo;
                        string lcClienteFin = lcValor;

                        // PE-105581, solo se realiza el recalculo de credito si se hace servir Contacts en Overdrive, sino no
                        // debido a que en determinados procesos (factuven, factucuo, rem_banc.) al invocar a este metodo con forma de rango inicial-final podia darse el caso
                        // de que este rango fuese muy amplio y provocaba "cuelgue" aparente, p.e., hacemos facturacion general, acotamos todos los clientes  pero luego en la pantalla
                        // de presentacion de albaranes marcados solamente 2 clientes, el 43.2 y el 43.40000, en este caso reacalcularia el riesgo de todos los clientes que hay en el rango.
                        // Idem en remesa bancaria, al crear remesa con 2 previsiones solamente, una del 43.2 y la segunda del 43.40000 pasaria lo mismo.
                        // 
                        // Hasta que se programe la llamada hacia aqui transfiriendo un XML con los códigos de cliente a recalcular y no un rango inicial-final, como solución provisional se
                        // hace que solo se recalcule si se trabaja con Contacts
                        bool llContacts = Convert.ToBoolean(DB.SQLValor("empresa", "codigo", EW_GLOBAL._GetVariable("wc_empresa").ToString(), "CONTACT"));
                        bool _lEsCentralOffline = Convert.ToBoolean(EW_GLOBAL._ModuloActivo("OFFLINE")) && Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_TipoOffline"));

                        if (llContacts || _lEsCentralOffline)
                        {
                            FUNCTIONS._RecalcularRiesgoDesdeFox(lcClienteIni, lcClienteFin);
                        }
                    }
                    //FI PE-104237

                    // Mensaje para enviar un email directo desde sage50 (PE-99045)
                    if (llOk && lcOpcion == "emaildirecto")
                    {
                        string lcCampo = "",lcValorCampo="";
                        string lcEmail = "", lcFileReturn = "", lcAsunto = "", lcCuerpo = "", lcAdjunto = "";                      
                        bool llResp = true;
                        DataTable ldtCampos = new DataTable();                        

                        // Fichero xml donde recibimos los valores para el email y que luego tambien utilizaremos para enviar la respuesta
                        lcFileReturn = lcValor;

                        // Obtener los valores para enviar el correo
                        FUNCTIONS._Xml2Datatable(lcFileReturn, ref ldtCampos);
                        File.Delete(lcFileReturn);

                        try
                        {
                            foreach (DataRow loCampo in ldtCampos.Rows)
                            {
                                lcCampo = Convert.ToString(loCampo["campo"]).Trim().ToLower();
                                lcValorCampo = Convert.ToString(loCampo["valor"]).Trim();

                                switch (lcCampo)
                                {
                                    case "destino":
                                        lcEmail = lcValorCampo;
                                        break;

                                    case "asunto":
                                        lcAsunto = lcValorCampo;
                                        break;

                                    case "cuerpo":
                                        lcCuerpo = lcValorCampo;
                                        break;

                                    case "adjunto":
                                        lcAdjunto = lcValorCampo;
                                        break;

                                    default:
                                        break;
                                }
                            }

                            //PE-101222: Obtenemos de la variable global tempCliente<usuario> si hay un valor significa que lo hemos establecido antes de llamar
                            //a FOX para poder tener el valor al enviarlo al envio directo del email y el log correspondiente. Lo mismo con proveedor
                            object loCliente = EW_GLOBAL._GetVariable("tmpCliente" + Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario")));
                            string lcCliente = string.Empty;
                            if (loCliente != null && !string.IsNullOrWhiteSpace(Convert.ToString(loCliente)))
                            {
                                lcCliente = Convert.ToString(loCliente);
                                EW_GLOBAL._SetVariable("tmpCliente" + Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario")), "");
                            }

                            object loProveed = EW_GLOBAL._GetVariable("tmpProveed" + Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario")));
                            string lcProveed = string.Empty;
                            if (loProveed != null && !string.IsNullOrWhiteSpace(Convert.ToString(loProveed)))
                            {
                                lcProveed = Convert.ToString(loProveed);
                                EW_GLOBAL._SetVariable("tmpProveed" + Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario")), "");
                            }

                            // Enviar correo directo
                            string lcError = "";
                            llResp = FUNCTIONS._Send_Direct_Email(lcEmail, lcAsunto, lcCuerpo, ref lcError, lcAdjunto, lcCliente, lcProveed);
                            if (!llResp)
                                FUNCTIONS._MessageBox(lcError, "Envío de correo directo", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                        }
                        catch (Exception loEx)
                        {                            
                            MessageBox.Show(loEx.Message + Environment.NewLine + Environment.NewLine + loEx.InnerException, "Envío de correo directo", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                            llResp = false;                            
                        }                        
                        
                        // Crear xml con la respuesta para fox
                        GuardarFicheroXmlRespuesta(lcFileReturn, new string[] { llResp.ToString().Trim().ToLower() });                     
                    }

                    // Mensaje para ejecutar una acción de la comunidad de sage50 (PE-97516)
                    if (llOk && lcOpcion == "comunidad50")
                    {
                        string lcOperacion = lcTipo;
                        string lcParametros = lcValor;

                        FUNCTIONS._Comunidad50_Ejecutar_Operacion(lcOperacion, lcParametros);
                    }
                    

                    // Mensaje para crear un acceso directe a sage50 (PE-95913)
                    if (llOk && lcOpcion == "appshortcut")
                    {
                        string lcCaption = lcTipo;
                        string lcName = lcValor;                   
            
                        FUNCTIONS._CrearAccesoDirecto(lcCaption, lcName);
                    }

                    // Mensaje para crear un nuevo apunte en calendario (PE-97078)
                    if (llOk && lcOpcion == "newcalendarnote")
                    {
                        // En 'tipo' desde FOX hemos pasado el nombre de la pantalla según COMUNES!CALENDAR (el nombre del formulario de FOX sin el .SCX, vaya)
                        string lcPantalla = lcTipo;
                        
                        // En 'valor' desde FOX hemos pasado los valores que identifican al documento que se tiene en pantalla (según campo PROPIEDAD del registro
                        // de COMUNES.CALENDAR correspondiente a la pantalla que solicita crear el apunte de calendario)
                        string lcParametrosDocFox = lcValor;

                        // Pasamos los valores en formato array de strings.
                        string[] laValoresPropiedades = lcParametrosDocFox.Split('@');
                        FUNCTIONS._CrearNuevoApunteCalendario(laValoresPropiedades, lcPantalla);
                    }


                    // Mensaje para redimensionar formulario principal de sage50 (PE-95668)
                    if (llOk && lcOpcion == "resize")
                    {
                        if (Application.OpenForms.Count > 0)
                        {
                            Form loForm = Application.OpenForms["frmPrincipal"];
                            if (loForm != null)
                            {
                                int lnHeight = Convert.ToInt32(lcTipo);
                                int lnWidth  = Convert.ToInt32(lcValor);

                                loForm.Size = new Size(lnWidth,lnHeight);

                                //PE-98258: Al hacer un resize de Sage50 en la integración de FOX, se pierde el refresco de los objetos del top (menú usuario, imagen, etc.)
                                //Forzamos un Refresh() del formulario al hacer un resize y funciona correctamente
                                loForm.Refresh(); 
                            }
                        }
                    }

                    // PARTE 99728. Mensaje para controlar si podemo cerrar sage50
                    if (llOk && lcOpcion == "podemos_cerrar_net")
                    {
                        if (Application.OpenForms.Count > 0)
                        {
                            dynamic loForm = Application.OpenForms["frmPrincipal"]; // PARTE 99728
                            if (loForm != null)
                            {
                                // Si tenemos el diseñador de Sage 50 en modo de edición no podemos cerrar la aplicación
                                if (!loForm._CanClose(true)) // PARTE 101086. Avisamos si debe de cerrar la pantalla
                                {
                                    string lcFichero = lcValor;

                                    // Generamos el fichero
                                    StreamWriter swCargar_Perfil = new StreamWriter(lcFichero);
                                    swCargar_Perfil.Write(loForm.Text); // Pasamos el id del handle por si deseamos realizar algun control
                                    swCargar_Perfil.Close();

                                    return false;
                                }
                            }
                        }

                        return true;
                    }
                    // FPARTE 99728. Mensaje para controlar si podemo cerrar sage50

                    if (llOk && lcOpcion == "passwordinforaut")
                    {
                        _ReceiveMessageFromVfpPasswordInforautFOX(Convert.ToString(lcTipo), Convert.ToString(lcValor));
                        return true;
                    }

                    // Mensaje para cerrar sage50
                    if (llOk && lcOpcion == "cerrar")
                    {
                        if (Application.OpenForms.Count > 0)
                        {
                            dynamic loForm = Application.OpenForms["frmPrincipal"]; // PARTE 99728
                            if (loForm != null)
                            {
                                // PARTE 99728: Si tenemos el diseñador de Sage 50 en modo de edición no podemos cerrar la aplicación
                                if (!loForm._CanClose())
                                    return false;

                                NETVFP.SetParent(loForm.Handle, IntPtr.Zero);
                                loForm.Close();
                            }
                        }
                    }

                    // Mensaje para ejecutar una opción de .net (SAGE50)
                    if (llOk && lcOpcion == "ejecutar")
                    {
                        dynamic loForm = null;
                        
                        // Obtener parámetros del mensaje                        
                        string[] laForms  = lcTipo.Split('@');
                        string[] laParamsVfp = lcValor.Split('@');

                        // Obtener la librería y el formario a ejectuar
                        string lcLibreriaNet = "";
                        string lcFormNet = laForms[0].ToString().Trim();
                        string lcFormVfp = laForms[1].ToString().Trim().ToLower();
                        long lnHandleVfp = Convert.ToInt32(laForms[2]);
                        
                        int lnPos = lcFormNet.IndexOf('.', lcFormNet.IndexOf('.', lcFormNet.IndexOf('.') + 1) + 1);
                        if (lnPos > 0)
                            lcLibreriaNet = lcFormNet.Substring(0, lnPos);

                        // Obtener formulario de net a mostrar
                        loForm = FUNCTIONS._Obtener_Formulario_Net(lcLibreriaNet, lcFormNet, "", lcFormVfp, laParamsVfp, lnHandleVfp);                          

                        if (loForm != null)
                        {
                            // Importante mostrar el formulario mediante SHOW(), ya que con sólo un ejecutable de .net, en sage50 al hacer un SHOWDIALOG() la parte de fox se queda colgada esperando...
                            loForm._Show();
                        }
                    }
                    // **** FIN MENSAJES SAGE50 (PE-93758) ****

                    #endregion MENSAJES SAGE50


                    // PE-85461
                    // Capturamos el nuevo handle de la ventana de fox
                    if (llOk && lcOpcion == "newhandlevfp")
                    {
                        EW_GLOBAL._nHandleVfp = Convert.ToInt32(lcValor);
                    }                                       

                    // PE-88929. Mensaje especial para pasar el foco al txtNumero       
                    if (llOk && lcOpcion == "foco")
                    {
                        if (Application.OpenForms.Count > 0) // PARTE 93552. Certificamos que tengamos una colección de formularios activa
                        {
                            dynamic loForm = Application.OpenForms[0];
                            if (loForm != null)
                            {
                                dynamic[] loControls = loForm.Controls.Find("txtNumDocVen", true);
                                if (loControls.Length > 0)
                                {
                                    loControls[0]._Pasar_Foco_Numero();
                                }
                            }
                        }
                    }
                    // FI PE-88929

                    // Capturamos la carga incial de un documento teniendo el exe ya abierto
                    if (llOk && lcTipo.ToLower().Trim() == "carga_con_exe_abierto" && (lcOpcion == "albatpv" || lcOpcion == "albaven")) // 89286
                    {                                                
                        if (lcValor.Contains("\\"))  
                        {
                            object[] laParams = lcValor.Split('\\');

                            if (Application.OpenForms.Count > 0) // PARTE 93552. Certificamos que tengamos una colección de formularios activa
                            {
                                dynamic loForm = Application.OpenForms[0];
                                loForm._Init(laParams);
                            }
                        }
                    }
                    // FI PE-85461

                    // PARTE 93552 - PARTE 93937
                    if (llOk)
                    {
                        string lcTipoOp = (lcTipo.ToLower().Trim());

                        // escalar_perfil ---> Escalamos el perfil a partir del Resize
                        // integrar_vfp_net_ini y integrar_vfp_net_fin ---> para controlar cuando estamos integrando desde .NET que no se dispare el RESIZE del formulario de .NET hasta que nos interese
                        if (lcTipoOp == "escalar_perfil" || lcTipoOp == "integrar_vfp_net_ini" || lcTipoOp == "integrar_vfp_net_fin")
                        {                            
                            if (lcValor.Contains("#")) // Certificamos que nos llegan los parámetros
                            {
                                object[] laParams = lcValor.Split('#');

                                // Controlamos que nos llega como mínimo los parámetros esperados
                                if (laParams != null && laParams.Length >= 3)
                                {
                                    // Miramos que tengamos una colección de formularios activa
                                    if (Application.OpenForms.Count > 0)
                                    {
                                        dynamic loForm = Application.OpenForms[0];

                                        // Vamos a escalar la pantalla de .NET
                                        loForm._Escalar_Perfil_Desde_VFP(laParams);
                                    }
                                }
                            }
                        }
                    }
                    // FPARTE 93552 - FPARTE 93937


                    // PE-102057, impresión masiva de facturas o albaranes en .NET con el report de .NET, llamada desde FACTUVEN.SCX de FOX, REPEFAC.SCX, IMPALBS.SCX
                    if (llOk && lcOpcion == "printmassivedocument")
                    {
                        string lcFileXml = lcValor;
                        string lcTypePrint = lcTipo.ToLower().Trim();   // Aqui puede llegar "invoices" o "deliverynotes"

                        eTiposDocumentoImpresionMasiva leTipoDocumentoImpresionMasiva = eTiposDocumentoImpresionMasiva.FacturasVenta;

                        switch (lcTypePrint)
                        { 
                            case "invoices":
                                leTipoDocumentoImpresionMasiva = eTiposDocumentoImpresionMasiva.FacturasVenta;
                                break;
                            case "deliverynotes":
                                leTipoDocumentoImpresionMasiva = eTiposDocumentoImpresionMasiva.AlbaranesVenta;
                                break;
                        }

                        // PARTE 103904. Marcamos que se está realizando el envio masivo desde FOX.
                        // Es necesario realizar el envío directamente en .net, en el caso de estar activada la opción de ENVIO DIRECTO
                        EW_GLOBAL.ValorEnClave_VarGlob("wl_printmassivedocument", true);
  
                        sage.ew.functions.FUNCTIONS._Print_Document_Massive(leTipoDocumentoImpresionMasiva, lcFileXml);

                        EW_GLOBAL.ValorEnClave_VarGlob("wl_printmassivedocument", false);
                        // FPARTE 103904
                    }

                    // PE-103206, impresión de montaje 
                    if (llOk && lcOpcion == "printdocument")
                    {

                        string lcTypePrint = lcTipo.ToLower().Trim();   // Aqui puede llegar "montaje" de momento
                        string lcParametros = lcValor;                  // Caso de montajes llega codigomontaje|1 o codigomontaje|0 segun si se han de imprimir costes o no
                        switch (lcTypePrint)
                        {
                            case "montaje":
                                if (!string.IsNullOrWhiteSpace(lcParametros))
                                    sage.ew.functions.FUNCTIONS._Print_Document("montaje", lcParametros);
                                break;

                            case "pedicom": // CCRequest 107065
                                if (!string.IsNullOrWhiteSpace(lcParametros))
                                    sage.ew.functions.FUNCTIONS._Print_Document("pedicom", lcParametros);
                                break;

                        }

                    }

                    // PE-95303. Mostrar el browser de .Net
                    if (llOk && lcOpcion == "shownetbrowser")
                    {                        
                        sage.ew.functions.FUNCTIONS._Show_Browser_For_Fox(lcValor);
                    }

                    // PE-103169. Mostrar el resultado del Ven_Ca de Fox en Google Maps de .Net
                    if (llOk && lcOpcion == "showgooglemaps")
                    {                        
                        functions.FUNCTIONS._Show_GoogleMaps_From_VencaFox(lcValor);
                    }

                    // PARTE 98022
                    if (llOk && lcOpcion == "shownetfavoritos")
                    {                        
                        object[] laParams = lcValor.Split('#');

                        // Controlamos que nos llega como mínimo los parámetros esperados
                        if (laParams != null && laParams.Length >= 2)
                            Usuario._This._Show_Favoritos(Convert.ToString(laParams[0]), Convert.ToString(laParams[1])); 
                    }
                    // FPARTE 98022

                    // PARTE 100996
                    if (llOk && lcOpcion == "shownetaccesos")
                    {                        
                        object[] laParams = lcValor.Split('#');

                        // Controlamos que nos llega como mínimo los parámetros esperados
                        if (laParams != null && laParams.Length >= 2)
                            Usuario._This._Show_Gestion_Accesos(Convert.ToString(laParams[0]), Convert.ToString(laParams[1]));
                    }
                    // FPARTE 100996

                    // PARTE 104973. Al realizar los asientos de cierre y de regularización en la pantalla AS_CIERR.SCX luego no detecta que los meses estan cerrados
                    if (llOk && lcOpcion == "cleanmesescerrados")
                        EW_GLOBAL.ValorEnClave_VarGlob("wo_meses", null); 

                    // PARTE 97053                   
                    if (llOk)
                    {
                        string lcTipoOp = (lcTipo.ToLower().Trim());

                        // truquem per skype                       
                        if (lcTipoOp == "llamada_skype")
                        {                            
                            if (lcValor.Contains("#")) // Certificamos que nos llegan los parámetros
                            {
                                object[] laParams = lcValor.Split('#');

                                // Controlamos que nos llega como mínimo los parámetros esperados
                                if (laParams != null && laParams.Length >= 2)
                                {
                                    // Miramos que tengamos una colección de formularios activa
                                    if (Application.OpenForms.Count > 0)
                                    {
                                        skype.SkypePlugin loSkype = skype.SkypePlugin.Instance;
                                        loSkype._Call(laParams[1].ToString().Trim());                                       
                                    }
                                }
                            }
                        }
                    }

                    //PE-97314                   
                    if (llOk)
                    {                        
                        object[] laParams = null;                        
                        
                        // Si no encuentra el # genera el array laParams con un solo elemento en la posicion 0
                        // si encuentra el # genera el array normalmente.
                        laParams = lcValor.Split('#');
                       
                        switch(lcTipo)
                        {
                            //Abrimos el FileDialog  en modo "selección carpetas"
                            case "OneDrive_FolderDialog":
                                
                                if (laParams != null && laParams.Length >= 1)
                                {
                                    IFileDialog365 loFileDialog = EW_GLOBAL._FileDialog365;
                                    llOk = loFileDialog._OpenAndSavePath(Convert.ToString(laParams[0]) , 0);
                                }
                                break;
                            //Abrimos el FileDialog  en modo "selección ficheros"
                            case "OneDrive_FileDialog":

                                if (laParams != null && laParams.Length >= 1)
                                {
                                    IFileDialog365 loFileDialog = EW_GLOBAL._FileDialog365;
                                    llOk = loFileDialog._OpenAndSavePath(Convert.ToString(laParams[0]), 1);
                                }

                                break;

                            case "OneDrive_Upload":

                                if (laParams != null && laParams.Length >= 2)
                                {
                                    IFileDialog365 loFileDialog = EW_GLOBAL._FileDialog365;
                                    llOk = loFileDialog._UploadFile(Convert.ToString(laParams[0]), Convert.ToString(laParams[1]));
                                }
                                break;
                        }
                    }
                    //FIN PE-97314   

                    // 100587
                    if (llOk)
                    {
                        string lcTipoOp = (lcTipo.ToLower().Trim());

                        // Volem forçar un recalcul d'stock després de rebre dades del OFFLINE
                        if (lcTipoOp == "offline_recstock")
                        {
                            stocks.Recalculo_Stocks loRecalcul = new stocks.Recalculo_Stocks();
                            loRecalcul._Recalcular_Stocks();
                        }
                    }
                    // fi 100587

                    // S50MIG-2623
                    if (llOk && lcOpcion.ToLower().Trim() == "enviarusopantalla" && !string.IsNullOrWhiteSpace(lcValor))
                    {
                        FUNCTIONS._EnviarDatosUsoPantalla(lcValor, lcTipo);
                    }
                    // FS50MIG-2623

                }
                catch (Exception loEx)
                {
                    MessageBox.Show(loEx.Message);
                    llOk = false;
                }
                finally
                {
                    EliminarMensaje(ref msgVfp); 
                }
            }

            return llOk;
        }

        public static bool _ObtenerParametros(string tcParametros)
        {
            // Ponemos los parámetros en un array
            string[] lcParametros = tcParametros.Split(SEPARADOR);            

            // Si no llegan los mínimos parámetros obligatorios, salimos
            if (lcParametros.Length < MINIMO_PARAMETROS)
                return false;

            // Obtenemos los parámetros obligatorios
            _Parametros.Clear();
            _Parametros["responder"] = lcParametros[RESPONDER_INDEX];
            _Parametros["opcion"]    = lcParametros[OPCION_INDEX];
            _Parametros["tipo"]      = lcParametros[TIPO_INDEX];
            _Parametros["valor"]     = lcParametros[VALOR_INDEX];
            
            // Obtenemos el resto de parámetros opcionales
            int i = 0;
            for (int lnPar = 4; lnPar < lcParametros.Length; lnPar++)
            {
                i++;
                _Parametros["paradi" + i.ToString().Trim()] = lcParametros[lnPar];                
            }
            
            // Disparamos la carga inicial
            if (_Parametros["opcion"].ToString().ToLower().Trim() == "inicial")
                CargaInicial(_Parametros["valor"].ToString());


            return true;
        }

        public static string _Abrir_Formulario_VFP(string tcFormulario, object[] toParametros = null)  
        {            
            return Ejecutar_VFP("crear", tcFormulario, toParametros, true);
        }

        public static string _Abrir_Formulario_VFP(string tcFormulario, object[] toParametros, bool tlRespuesta=true)  
        {            
            return Ejecutar_VFP("crear", tcFormulario, toParametros, tlRespuesta);
        }

        public static string _Abrir_Formulario_VFP(string tcFormulario, object[] toParametros, Form toForm)
        {
            string lcRetorn = "";
            
            // En modo sage50 no es necesario (PE-93758)
            if (!Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")))
            {
                EnableWindow((IntPtr)EW_GLOBAL._nHandleVfp, false);
                if (toForm != null)
                    EnableWindow(toForm.Handle, false);
            }

            lcRetorn = Ejecutar_VFP("crear", tcFormulario, toParametros);

            // En modo sage50 no es necesario (PE-93758)
            if (!Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")))
            {
                if (toForm != null)
                    EnableWindow(toForm.Handle, true);
                EnableWindow((IntPtr)EW_GLOBAL._nHandleVfp, true);
            }

            // PE-78759. Forzamos el foco al formulario para que el programa no se quede en el limbo
            if (toForm != null)
            {
                toForm.Focus();
            }

            return lcRetorn;
        }

        //PE-75517 Se añade un tercer parametro opcional para poder trabajar con funciones fox que esperen arrays como parámetros.
        public static string _Ejecutar_Funcion_VFP(string tcFuncion, object[] toParametros, bool tlArray, Form toForm)
        {
            string lcRetorn = "";            

            if (toForm != null)
                EnableWindow(toForm.Handle, false);
            EnableWindow((IntPtr)EW_GLOBAL._nHandleVfp, false);

            if (tlArray)
            {
                string lcNombreXml = GenerarParametrosXml(tcFuncion, toParametros);
                lcRetorn = Ejecutar_VFP("funcion", "EJECUTARXML", new Object[] { lcNombreXml.ToString().Trim() });
            }
            else lcRetorn = Ejecutar_VFP("funcion", tcFuncion, toParametros);

            if (toForm != null)
                EnableWindow(toForm.Handle, true);
            EnableWindow((IntPtr)EW_GLOBAL._nHandleVfp, true);

            // PE-78759. Forzamos el foco al formulario para que el programa no se quede en el limbo
            if (toForm != null)
            {
                toForm.Focus();
                toForm.BringToFront();
            }

            return lcRetorn;
        }

        //PE-75517 Se añade un tercer parametro opcional para poder trabajar con funciones fox que esperen arrays como parámetros.
        public static string _Ejecutar_Funcion_VFP(string tcFuncion, object[] toParametros = null, bool tlArray = false)
        {
            if (tlArray)
            {
                string lcNombreXml = GenerarParametrosXml(tcFuncion, toParametros);
                return Ejecutar_VFP("funcion", "EJECUTARXML", new Object[] { lcNombreXml.ToString().Trim() });
            }
            else return Ejecutar_VFP("funcion", tcFuncion, toParametros);           
        }

        public static string _Ejecutar_Funcion_VFP(string tcFuncion, object[] toParametros, bool tlArray, bool tlRespuesta=true)
        {
            if (tlArray)
            {
                string lcNombreXml = GenerarParametrosXml(tcFuncion, toParametros);
                return Ejecutar_VFP("funcion", "EJECUTARXML", new Object[] { lcNombreXml.ToString().Trim() }, tlRespuesta);
            }
            else return Ejecutar_VFP("funcion", tcFuncion, toParametros, tlRespuesta);
        }

        public static string _Ejecutar_Funcion_VFP_Menu50(string tcFuncion)
        {
            string lcFunction = string.Empty;
            object[] loParametros = new object[0];
            //Miren que ens arribi algo i tingui parentesis
            if (!string.IsNullOrWhiteSpace(tcFuncion) && tcFuncion.IndexOf("(") >= 0)
            {
                // PE-103996. Caso especial para controlar que no exista ningun formulario abierto antes de ejecutar temas de apertura.
                // TODO: Cuando se incorpore la apertura en .net revisar esta comprobación
                if (tcFuncion == "opcAperNuevo()" || tcFuncion == "opcAperTraspDoc")
                {
                    if (!FUNCTIONS._ComprobarFormulariosAbiertos())
                    {
                        MessageBox.Show("Para realizar cualquier operación de apertura es necesario cerrar los formularios abiertos.", "Apertura", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
                        return "";
                    }
                }
                // FI PE-103996

                //Exp regular per recuperar el nom de la funció
                //PE-103318: incluir el . para que parsee el nombre de función cuando tiene un objeto más .funcion
                Match loMatchFunc = Regex.Match(tcFuncion, @"^\s*([\w\.]+)\s*\((.*)\)");
                if (!string.IsNullOrWhiteSpace(loMatchFunc.Value))
                {
                    //Nom de la funció
                    lcFunction = loMatchFunc.Groups[1].Value.ToString().Trim();
                    if (!string.IsNullOrWhiteSpace(loMatchFunc.Groups[2].Value))
                    {
                        //Exp regular per recuperar els parametres de la funció
                        MatchCollection loMatchParams = Regex.Matches(loMatchFunc.Groups[2].Value, @"([^,]+\(.+?\))|([^,]+)");
                        if (loMatchParams.Count > 0)
                        {
                            int lnPos = 0;
                            //Recuperem els parametres de la funció
                            loParametros = new object[loMatchParams.Count];
                            foreach (var item in loMatchParams)
                            {
                                loParametros[lnPos] = item.ToString().Replace("\"", "").Replace("'", "");
                                lnPos++;
                            }
                        }
                    }
                }
            }
            else
            {
                //Entenem que el que s'ha passat es una funció sense parametres
                if (!string.IsNullOrWhiteSpace(tcFuncion))
                    lcFunction = tcFuncion;
            }

            //Comprobació final de nom de funció
            if (string.IsNullOrWhiteSpace(lcFunction))
                return "0";

            // PE-103236. Actualizar tabla CONNECT
            Usuario._This._Revisar_Connect_Formulario(lcFunction, lcFunction);

            //Tot correcte ... executem el metode estandar per funcions de VFP
            return _Ejecutar_Funcion_VFP(lcFunction, loParametros);
        }

        public static string _Obtener_Valor_VFP(string tcValor, object[] toParametros = null)
        {
            return Ejecutar_VFP("valor", tcValor, toParametros);
        }

        public static void _CerrarAplicacion()
        {
            Application.ExitThread();
            Application.Exit();
        }


        public static void _CerrarHandle(int lnHandle)
        {            
            if (!IsWindow((IntPtr)lnHandle))
                return;

            // A partir del handle de fox, obtener el identificador del proceso y a partir de este el handle de la ventata principal
            GetWindowThreadProcessId((IntPtr)lnHandle, out uint processId);
            Process processSage50 = Process.GetProcessById(Convert.ToInt32(processId));
            IntPtr lnHandleSage50 = processSage50.MainWindowHandle;
            if (lnHandleSage50 == IntPtr.Zero)
                return;

            // Matar el proceso asociado a la ventanda de sage50
            Process[] runingProcess = Process.GetProcesses();
            for (int i = 0; i < runingProcess.Length; i++)
            {
                if (runingProcess[i].MainWindowHandle == lnHandleSage50)                                    
                    runingProcess[i].Kill();                
            }
        }

        public static string _ToString(object txValor)
        {
            // String que devolveremos
            string lcValor = string.Empty;

            try
            {
                // Obtenemos el tipo del parámetro que nos han pasado
                string lcTipo = txValor.GetType().ToString().Trim().ToLower();

                switch (lcTipo)
                {
                    case "system.boolean":
                        if ((bool)txValor == true)
                            lcValor = ".T.";
                        else
                            lcValor = ".F.";

                        break;

                    case "system.datetime":
                        DateTime ltFecha = (DateTime)txValor;
                        lcValor = "{^" +ltFecha.Year.ToString().Trim() + "-" + ltFecha.Month.ToString().Trim() +"-" + ltFecha.Day.ToString().Trim() + "}";
                        break;

                    case "system.decimal":
                    case "system.double":
                    case "system.int16":
                    case "system.int32":
                    case "system.int64":
                    case "system.uint16":
                    case "system.uint32":
                    case "system.uint64":
                        lcValor = txValor.ToString().Replace(",", ".").Trim();
                        break;

                    case "system.string":                        
                        lcValor = "'" + txValor.ToString().Replace("'", "''") + "'";                                              
                        break;

                    default:
                        break;
                }
            }
            catch (Exception loEx)
            {
                DB.Registrar_Error(loEx);
                return string.Empty;
            }

            return lcValor;
        }


        public static void _ComprobarReceptor(long tnHwnd)
        {
            if (!IsWindow((IntPtr)tnHwnd))
                _CerrarAplicacion();
        }

        public static string _Abrir_Mante_VFP(string tcFormulario, string tcCodigo)
        {
            string lcRetorno = "";            

            // Indicamos las propiedades de comunicación
            _Parametros["responder"] = true;
            _Parametros["opcion"]    = "mante";
            _Parametros["tipo"]      = "valor";
            _Parametros["valor"]     = tcFormulario + NETVFP.SEPARADOR + tcCodigo + NETVFP.SEPARADOR;

            // Enviar mensaje a VFP 
            if (_SendMessageToVfp())
            {
                // PE-80428. Comprobamos si en _Parametros todavía esta "valor". Hay veces que parece se ha perdido... 
                if (NETVFP._Parametros.ContainsKey("valor"))
                    lcRetorno = NETVFP._Parametros["valor"].ToString();
            }

            // Vaciar el diccionario de parametros una vez utilizado
            _Parametros.Clear();

            return lcRetorno;
        }

        public static void _Set_Form_AlwaysOnTop(IntPtr tnHandle)
        {
            IntPtr HWND_TOPMOST = new IntPtr(-1);
            const UInt32 SWP_NOSIZE = 0x0001;
            const UInt32 SWP_NOMOVE = 0x0002;
            const UInt32 SWP_SHOWWINDOW = 0x0040;

            SetWindowPos(tnHandle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);            
        }

        #endregion METODOS PUBLICOS


        #region METODOS PRIVADOS
        private static string Ejecutar_VFP(string tcOpcion, string tcFormFunc, object[] toParametros = null, bool tlRespuesta=true)  // PE-93758
        {
            string lcRetorno = "", lcParametros = "";               

            // PE-80275. Añadir control mediante CREATEMUTEX, OPENMUTEX para asegurar que desde FOX y NET estamos apunto para comunicar.
            if (!string.IsNullOrWhiteSpace(EW_GLOBAL._GetVariable("wc_iniservidor").ToString())
                && !string.IsNullOrWhiteSpace(EW_GLOBAL._GetVariable("wc_pathinicio").ToString())   // PE-91526. Comprobar si hay path inicio para enlazar
                && (tcFormFunc.ToUpper().Trim() == "FRM_NET"))
            {   
                string lcFuncion = toParametros[0].ToString().ToUpper().Trim();

                if (lcFuncion == "INTEGRAR") 
                {
                    // Crear mutex para indicar que desde .NET estamos apunto para iniciar comunicación            
                    _nhMutexNet = CreateMutex(IntPtr.Zero, true, "SAGETPV_NET");                

                    // Comprobar/esperar que desde FOX estan apunto para comunicar
                    IntPtr lnhMutexFox = IntPtr.Zero;
                    uint MUTEX_ALL_ACCESS = 0x001F0001;
                    bool llFoxOk = false;
                    int lnTemps = 0;
                    // PARTE 82286
                    int lnTempsEspera = 60;

                    string lcPathInicio = EW_GLOBAL._GetVariable("wc_pathinicio").ToString();

                    // Certificamos que tenemos la ruta donde tenemos el CONFIG.INI
                    if (string.IsNullOrWhiteSpace(lcPathInicio) == false)
                    {
                        string lcEnlace_Net = FUNCTIONS.LeerConfigIni("[ENLACE_NET]", lcPathInicio).Trim();

                        // Primero certificamos que tiene la entrada en el CONFIG.INI no podemos realizar el ConvertToInt32
                        if (string.IsNullOrWhiteSpace(lcEnlace_Net) == false)
                        {
                            int lnTempsENLACE_NET = Convert.ToInt32(lcEnlace_Net);

                            // Si es superior a 60 lo tendremos en cuenta, no permitiremos un tiempo inferior a 60
                            if (lnTempsENLACE_NET > 60)
                            {
                                lnTempsEspera = lnTempsENLACE_NET;
                            }
                        }
                    }
                    // FPARTE 82286

                    DateTime lnTempsIni = DateTime.Now;

                    while (!llFoxOk && lnTemps < lnTempsEspera) // PARTE 82286
                    {
                        // Consultar si el mutex de FOX ya está activo
                        lnhMutexFox = OpenMutex(MUTEX_ALL_ACCESS, false, "SAGETPV_FOX");
                        llFoxOk = (lnhMutexFox != IntPtr.Zero);

                        // En caso que encontremos el mutex de FOX, ya lo descargamos de memoria
                        if (llFoxOk)
                        {
                            ReleaseMutex(lnhMutexFox);
                            CloseHandle(lnhMutexFox);
                        }

                        // En caso de no encontrar el mutex de fox en 1 minuto salimos
                        lnTemps = (DateTime.Now - lnTempsIni).Seconds;

                        Application.DoEvents();
                    }
                }

                _lCerrarFormulariosEWCanal2 = (lcFuncion == "CERRAR");

                if ((lcFuncion == "CERRAR") && (_nhMutexNet != IntPtr.Zero))
                {
                    // Eliminar de memoria el mutex de NET
                    ReleaseMutex(_nhMutexNet);
                    CloseHandle(_nhMutexNet);
                }
            }
            // FI PE-80275

            if (tcOpcion == "crear")
            {
                // PE-103236. Actualizar tabla CONNECT
                Usuario._This._Revisar_Connect_Formulario(tcFormFunc, tcFormFunc);

                tcFormFunc = "'" + tcFormFunc + "'";
            }

            // Minimizar formularios .net abiertos para ver el formulario de fox que se abre en primer plano. Task 143679
            if (tcOpcion == "crear" || CasosEspecialesMinimizar(tcFormFunc))                               
                MinimizarFormsNetAbiertos();            

            // Preparamos los parámetros con el formato correcto en caso necesario
            if (toParametros != null)
            {
                foreach (object loPar in toParametros)
                {
                    lcParametros = lcParametros + _ToString(loPar) + NETVFP.SEPARADOR;
                }
            }

            // Indicamos las propiedades de comunicación
            _Parametros["responder"] = (tlRespuesta ? true : false);
            _Parametros["opcion"]    = tcOpcion;
            _Parametros["tipo"]      = "valor";
            _Parametros["valor"]     = tcFormFunc + NETVFP.SEPARADOR + lcParametros;

            // Enviar mensaje a VFP 
            if (_SendMessageToVfp())
            {
                // PE-80428. Comprobamos si en _Parametros todavía esta "valor". Hay veces que parece se ha perdido... 
                if (NETVFP._Parametros.ContainsKey("valor"))
                    lcRetorno = NETVFP._Parametros["valor"].ToString();
            }

            // Vaciar el diccionario de parametros una vez utilizado
            _Parametros.Clear();

            // Restaurar formularios .net abiertos al cerrar formulario de fox. Task 143679
            if (tcOpcion == "crear" || CasosEspecialesMinimizar(tcFormFunc))
                RestaurarFormsNetMinimizados();            

            return lcRetorno;
        }

        private static bool CasosEspecialesMinimizar(string tcFormFunc)
        {
            bool llCasoEspecial = false;

            string lcCasosEspeciales = "RIESGO_CLIENTE_NET,GENERAR_SEPA_REMCOBRO_NET,GENERAR_SEPA_REMPAGO_NET,SAGE50_ENLACE_COMUNICADOS";

            tcFormFunc = tcFormFunc.ToUpper().Trim();
            llCasoEspecial = lcCasosEspeciales.Contains(tcFormFunc);

            return llCasoEspecial;
        }

        private static void MinimizarFormsNetAbiertos()
        {            
            // Los formularios ActiveMenuImp son los pequeños formularios que se incrustan en las captions de los formularios con los "...", no minimizarlos
            string lcFormsExcluidos = "frmprincipal,activemenuimpl";

            // Si tenemos el widget de listas previas, este no hay que minimizarlo.  Bug 146238. 
            if (FUNCTIONS._CheckWidgetExists(new WidgetFormTabs()))
                lcFormsExcluidos += ",formtabs,browsertab";

            foreach (Form frm in Application.OpenForms)
            {
                string lcForm = frm.Name.ToLower().Trim();

                if (!lcFormsExcluidos.Contains(lcForm))
                    ShowWindow(frm.Handle, SW_MINIMIZE);
            }
        }

        private static void RestaurarFormsNetMinimizados()
        {
            // Bug 146157. No hay que restaurar el formulario de listas previas(FormTabs), ya que en su propia gestión se realiza.
            string lcFormsExcluidos = "frmprincipal,activemenuimpl,formtabs";
            foreach (Form frm in Application.OpenForms)
            {
                string lcForm = frm.Name.ToLower().Trim();

                if (!lcFormsExcluidos.Contains(lcForm) && frm.WindowState == FormWindowState.Minimized)
                    ShowWindow(frm.Handle, SW_RESTORE);
            }
        }

        private static void RegisterWindowMessages()
        {            
            // Mensaje Generico desde el Eurowin (VFP) al .Net
            if (msgewvfp_Notification == IntPtr.Zero)
                msgewvfp_Notification = RegisterWindowMessageW(EWVFP_NOTIFICATION);

            // Mensaje Generico desde el .Net al Eurowin (VFP)
            if (msgewnet_Notification == IntPtr.Zero)
                msgewnet_Notification = RegisterWindowMessageW(EWNET_NOTIFICATION);

            // Mensaje Generico SAGE50 NIVEL 1 (PE-93758)
            if (msgSage50_Notification == IntPtr.Zero)            
                msgSage50_Notification = RegisterWindowMessageW(SAGE50_NOTIFICATION);

            // Mensaje Generico SAGE50 NIVEL 2 (PE-93758)
            if (msgSage50_Notification2 == IntPtr.Zero)
                msgSage50_Notification2 = RegisterWindowMessageW(SAGE50_NOTIFICATION2);

            // Mensaje Generico SAGE50 NIVEL 3 (PE-100744)
            if (msgSage50_Notification3 == IntPtr.Zero)
                msgSage50_Notification3 = RegisterWindowMessageW(SAGE50_NOTIFICATION3);

            // Mensaje Generico SAGE50 NIVEL 4 (PE-100744)
            if (msgSage50_Notification4 == IntPtr.Zero)
                msgSage50_Notification4 = RegisterWindowMessageW(SAGE50_NOTIFICATION4);

            // Mensaje Generico SAGE50 NIVEL 5 (PE-100744)
            if (msgSage50_Notification5 == IntPtr.Zero)
                msgSage50_Notification5 = RegisterWindowMessageW(SAGE50_NOTIFICATION5);  
        }

        private static void EliminarMensaje(ref Message msgEliminar)
        {
            GlobalDeleteAtom((ushort)msgEliminar.WParam);
        }

        private static string ObtenerCadenaMensaje(Message msgParam)
        {
            char[] swParam = new char[(int)msgParam.LParam];
            GlobalGetAtomName((ushort)msgParam.WParam, swParam, (int)msgParam.LParam);
            string lcCadena = new string(swParam);

            return lcCadena;
        }

        private static bool CargaInicial(string tcRutaXml)
        {            
            // Hacer una copia del xml para volver a cargar los valores después de la carga de los diccionarios 
            bool llAlbatpv = false;
            bool llOk = false; // PE-85575
            string lcMensaje = string.Empty;
            string lcCopiaXml = tcRutaXml.Replace(".xml", "copia.xml");
            File.Copy(tcRutaXml, lcCopiaXml);

            // Realizar la carga de las distintas variables que nos indiquen en el diccionario global
            if (!EW_GLOBAL._CargarVarExtra(tcRutaXml))
            {
                MessageBox.Show("No se ha podido cargar en el diccionario las variables globales extra.", "EW_GLOBAL._CargarVarExtra", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }
            
            // Obtenemos las variables del diccionario global
            string lcUsuario  = EW_GLOBAL._GetVariable("wc_usuario").ToString().Trim();
            string lcEmpresa  = EW_GLOBAL._GetVariable("wc_empresa").ToString().Trim();            
            string lcCajaTpv  = EW_GLOBAL._GetVariable("wc_cajatpv").ToString().Trim();
            string lcComunes  = EW_GLOBAL._GetVariable("wc_concomunes").ToString().Trim();
            string lcServer   = EW_GLOBAL._GetVariable("server").ToString().Trim();
            string lcUser     = EW_GLOBAL._GetVariable("user").ToString().Trim();
            string lcPassword = EW_GLOBAL._GetVariable("password").ToString().Trim();
            string lcLibreria = EW_GLOBAL._GetVariable("libreria").ToString().Trim();
            string lcForm     = EW_GLOBAL._GetVariable("formulario").ToString().Trim();
            string lcOpcion   = EW_GLOBAL._GetVariable("opcion").ToString().Trim();

            // PE-102233 - Si ejecutamos las gráficas no hace comprobar nada
            // PE-88209
            // Si venimos de las graficas de FOX llamadas desde Eurowin, no hace falta connectarse, ni cargar diccionarios, ni nada más.
            if (lcForm == "sage.ew.Forms.VerGraficas")
                return true;


            // Controlamos si entramos en la pantalla de albatpv
            llAlbatpv = (lcOpcion == "albatpv" || lcOpcion == "albaven");

            // Comprobar que nos llegan los valores obligatorios
            if (string.IsNullOrWhiteSpace(lcEmpresa) || string.IsNullOrWhiteSpace(lcComunes) ||
                string.IsNullOrWhiteSpace(lcServer) || string.IsNullOrWhiteSpace(lcUser) || string.IsNullOrWhiteSpace(lcPassword) ||
                string.IsNullOrWhiteSpace(lcLibreria) || string.IsNullOrWhiteSpace(lcForm) || string.IsNullOrWhiteSpace(lcUsuario) ||
               (llAlbatpv && (string.IsNullOrWhiteSpace(lcCajaTpv)))) // Solo controlaremos el controls de la caja actiav si entramos a la pantalla albatpv
            {
                // De momento la caja solo la controlaremos en la pantalla de ALBATPV
                if (llAlbatpv)
                    lcMensaje = " wc_cajatpv,";

                MessageBox.Show("Deben indicarse las siguientes etiquetas obligatoriamente:"+System.Environment.NewLine+
                                "wc_usuario, wc_empresa," + lcMensaje + " wc_concomunes, server, user, password, libreria, formulario","Etiquetas obligatorias",MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }
            
            // Conectar a la base de datos
            if (!DB.SQLConnect(lcServer, lcUser, lcPassword, lcComunes, tcAliasConexion: "eurowin"))
            {
                MessageBox.Show("No se ha podido realizar la conexión a la base de datos.", "DB.SQLConnect", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }
            
            // PE-87417. Mover la predeterminación de la bd de gestión antes de realizar la Carga de diccionarios, sino en la carga de diccionarios sigue apuntando al ejercicio anterior...
            //PE-84869: predeterminamos como gestión el ejercicio que nos viene definido por la variable wc_any (por ejemplo por cambiar de ejercicio desde el desplegable de Eurowin)
            //ya que si no siempre se ejecutaba el TPV de .NET en el ejercicio predeterminado de Comunes!ejercici, lo cual no es correcto si hemos cambiado el ejercicio de trabajo en Eurowin
            if (EW_GLOBAL._GetVariable("wc_any") != null)
            {                
                DB.SQLPredeterminarGestion(Convert.ToString(EW_GLOBAL._GetVariable("wc_any")));
            }

            // PE-85575. En caso de abrir un formulario de graficas no es necesario tener el módulo de tpv
            // Cargar las variables globales 
            if (lcForm.ToLower().Trim().Contains("grafica") && string.IsNullOrWhiteSpace(lcCajaTpv))
                llOk = DiccionariosLoader.CargarDiccionarios(lcEmpresa);
            else
                llOk = DiccionariosLoader.CargarDiccionarios(lcEmpresa, lcCajaTpv);

            if (!llOk)
            {
                MessageBox.Show("No se han podido cargar los diccionario de variables globales.", "EW_GLOBAL._CargarDiccionarios", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }
            // FI PE-85575

            // Volvemos a cargar las distintas variables que nos indiquen en el diccionario global ya que en la carga de diccionarios se han machacado
            if (!EW_GLOBAL._CargarVarExtra(lcCopiaXml))
            {
                MessageBox.Show("No se ha podido cargar en el diccionario las variables globales extra.", "EW_GLOBAL._CargarVarExtra", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }

            // PE-106793. Sino estamos en sage50 tenemos que cargar y validar la licencia de suscripción de sagelic.         
            if ( !Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_sage50")) && !LICENCIAS._Validar_Licencia_Suscripcion() )
            {
                MessageBox.Show(LICENCIAS._MensajeError, "LICENCIAS._Validar_Licencia_Suscripcion", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return false;
            }
            
            // PE-89537: Asignamos el valor proviniente de la variable SQL_LOG del config.ini
            // [SQL_LOG] en Config.ini, "wc_sql_log" en .NET
            string lcSqlLog = Convert.ToString(FUNCTIONS.LeerConfigIni("[SQL_LOG]")).ToUpper().Trim();

            EW_GLOBAL._SetVariable("wc_sql_log", lcSqlLog);
            //FI PE-89537            

            // PE-85745. Asignamos si trabajamos con PRUEVAS SI
            // La variable de Eurowin y de .NET. es "wl_prueva"
            // En el Config.INI tenemos [PRUEVAS]
            string lcPrueva = Convert.ToString(FUNCTIONS.LeerConfigIni("[PRUEVAS]")).ToUpper();

            bool llPrueva = (lcPrueva == "SI" || lcPrueva == "PERMANENTE");

            EW_GLOBAL._SetVariable("wl_prueva", llPrueva);
            // FPE-85745

            // PE-96322. Cargamos los addons (modulos, pam)
            if (!AddonsController.Instance.AddonsManager._CargarAddOns(new FunctionsDependencies()
            {
                GenerarChecksumOpciones = Criptografia.GenerarChecksumOpciones,
                GetSage50PathLibrerias = FUNCTIONS.GetSage50PathLibrerias,
                CodigoLicencia = LICENCIAS._CodigoLicencia
            }))
            {
                MessageBox.Show("Uno o más de los AddOn instalados no se han cargado correctamente.", "EW_GLOBAL._CargarAddOns", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
            
            return true;
        }

        private static string GenerarParametrosXml(string tcFuncion, object[] toParametros, string tcNomCursor="net2vfp") 
        {

            //Genero un nombre aleatorio.
            string lcNombreFichero = Path.GetTempPath() + System.Guid.NewGuid().ToString() + ".xml";

            // Preparamos los parámetros con el formato correcto en caso necesario
            if (toParametros != null)
            {

                string lcNodo = string.Empty, lcValor = string.Empty;
                int lnTotalElementos = 0;
                int lnElementoActual = 0;
                int lnXElem = 0;
                int lnYElem = 0;

                //Creo la parte fija del fichero XML que voy a generar
                XmlTextWriter xmlParan = new XmlTextWriter(lcNombreFichero, Encoding.UTF8)
                {
                    Formatting = Formatting.Indented
                };
                xmlParan.WriteStartDocument();
                xmlParan.WriteStartElement("VFPData");

                //Recupero los parámetros recibidos
                foreach (object loPar in toParametros)
                {

                    //Evito los valores nulos pero al ser un array continuo buscando valores válidos
                    if (loPar != null) 
                    {

                        xmlParan.WriteStartElement(tcNomCursor.ToString().Trim()); //Creo nodo NombreCursor

                        //Funcion
                        xmlParan.WriteElementString("funcion", tcFuncion.ToString().ToUpper());

                        //Capturo el tipo
                        string lcTipo = loPar.GetType().ToString().Trim().ToLower();

                        switch (lcTipo)
                        {

                            #region Matrices [x,y]

                            #region MatrizStrings
                            case "system.string[,]":

                                //Variables para el doble recorrido
                                lnXElem = ((string[,])loPar).GetLength(0);        //Numero de dimensiones
                                lnYElem = ((string[,])loPar).Length / lnXElem;    //Numero de elementos (total/dimensiones)

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "STRING:ARRAY[" + lnXElem.ToString() + "," + lnYElem.ToString() + "]");

                                //Recorro las N dimensiones de la matriz
                                for (int lnXindex = 0; lnXindex < lnXElem; lnXindex++)
                                {
                                    //Preparo la concatenacion de valores
                                    for (int lnYIndex = 0; lnYIndex < lnYElem; lnYIndex++)
                                    {
                                        lcValor = lcValor + "'" + ((string[,])loPar)[lnXindex, lnYIndex].ToString().Replace("'", "''") + "'";
                                        if (lnYIndex != lnYElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    }

                                    if (lnXindex != lnXElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    //Reinicio para siguiente elemento
                                    //lcValor = string.Empty;
                                }
                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());


                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnXElem = lnYElem = 0;

                                break;
                            #endregion MatrizStrings

                            #region MatrizDecimal
                            case "system.decimal[,]":

                                //Variables para el doble recorrido
                                lnXElem = ((decimal[,])loPar).GetLength(0);        //Numero de dimensiones
                                lnYElem = ((decimal[,])loPar).Length / lnXElem;    //Numero de elementos (total/dimensiones)

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "DECIMAL:ARRAY[" + lnXElem.ToString() + "," + lnYElem.ToString() + "]");

                                //Recorro las N dimensiones de la matriz
                                for (int lnXindex = 0; lnXindex < lnXElem; lnXindex++)
                                {
                                    //Preparo la concatenacion de valores
                                    for (int lnYIndex = 0; lnYIndex < lnYElem; lnYIndex++)
                                    {
                                        lcValor = lcValor + ((decimal[,])loPar)[lnXindex, lnYIndex].ToString().Replace(",", ".").Trim();
                                        if (lnYIndex != lnYElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    }

                                    if (lnXindex != lnXElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    //Reinicio para siguiente elemento
                                    //lcValor = string.Empty;
                                }
                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnXElem = lnYElem = 0;

                                break;
                            #endregion MatrizDecimal

                            #region MatrizInt32
                            case "system.int32[,]":

                                //Variables para el doble recorrido
                                lnXElem = ((Int32[,])loPar).GetLength(0);        //Numero de dimensiones
                                lnYElem = ((Int32[,])loPar).Length / lnXElem;    //Numero de elementos (total/dimensiones)

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT32:ARRAY[" + lnXElem.ToString() + "," + lnYElem.ToString() + "]");

                                //Recorro las N dimensiones de la matriz
                                for (int lnXindex = 0; lnXindex < lnXElem; lnXindex++)
                                {
                                    //Preparo la concatenacion de valores
                                    for (int lnYIndex = 0; lnYIndex < lnYElem; lnYIndex++)
                                    {
                                        lcValor = lcValor + ((Int32[,])loPar)[lnXindex, lnYIndex].ToString().Replace(",", ".").Trim();
                                        if (lnYIndex != lnYElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    }
                                    if (lnXindex != lnXElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    //Asigno el valor
                                    //xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());
                                    //Reinicio para siguiente elemento
                                    //lcValor = string.Empty;
                                }
                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnXElem = lnYElem = 0;

                                break;
                            #endregion MatrizInt32

                            #region MatrizInt16
                            case "system.int16[,]":

                                //Variables para el doble recorrido
                                lnXElem = ((Int16[,])loPar).GetLength(0);        //Numero de dimensiones
                                lnYElem = ((Int16[,])loPar).Length / lnXElem;    //Numero de elementos (total/dimensiones)

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT16:ARRAY[" + lnXElem.ToString() + "," + lnYElem.ToString() + "]");

                                //Recorro las N dimensiones de la matriz
                                for (int lnXindex = 0; lnXindex < lnXElem; lnXindex++)
                                {
                                    //Preparo la concatenacion de valores
                                    for (int lnYIndex = 0; lnYIndex < lnYElem; lnYIndex++)
                                    {
                                        lcValor = lcValor + ((Int16[,])loPar)[lnXindex, lnYIndex].ToString().Replace(",", ".").Trim();
                                        if (lnYIndex != lnYElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    }
                                    if (lnXindex != lnXElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    //Asigno el valor
                                    //xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());
                                    //Reinicio para siguiente elemento
                                    //lcValor = string.Empty;
                                }
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnXElem = lnYElem = 0;

                                break;
                            #endregion MatrizInt16

                            #region MatrizInt64
                            case "system.int64[,]":

                                //Variables para el doble recorrido
                                lnXElem = ((Int64[,])loPar).GetLength(0);        //Numero de dimensiones
                                lnYElem = ((Int64[,])loPar).Length / lnXElem;    //Numero de elementos (total/dimensiones)

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT64:ARRAY[" + lnXElem.ToString() + "," + lnYElem.ToString() + "]");

                                //Recorro las N dimensiones de la matriz
                                for (int lnXindex = 0; lnXindex < lnXElem; lnXindex++)
                                {
                                    //Preparo la concatenacion de valores
                                    for (int lnYIndex = 0; lnYIndex < lnYElem; lnYIndex++)
                                    {
                                        lcValor = lcValor + ((Int64[,])loPar)[lnXindex, lnYIndex].ToString().Replace(",", ".").Trim();
                                        if (lnYIndex != lnYElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    }
                                    if (lnXindex != lnXElem - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                    //Asigno el valor
                                    //xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());
                                    //Reinicio para siguiente elemento
                                   // lcValor = string.Empty;
                                }
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnXElem = lnYElem = 0;

                                break;
                            #endregion MatrizInt64

                            #endregion Matrices [x,y]

                            #region Arrays

                            #region ArrayStrings
                            case "system.string[]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "STRING:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((string[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + "'" + ((string[])loPar)[lnIndex].ToString().Replace("'", "''") + "'";
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;

                                break;
                            #endregion ArrayStrings

                            #region ArrayBoleanos
                            case "system.boolean[]":

                                //Preparo el nombre 
                                lcNodo = ((bool[])loPar)[0].GetType().ToString().Trim().ToUpper().Substring(7);
                                xmlParan.WriteElementString("tipo_param", "BOOLEAN:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((bool[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {

                                    if (((bool[])loPar)[lnIndex]) { lcValor = lcValor + ".T."; }
                                    else { lcValor = lcValor + ".F."; }
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayBoleanos

                            #region ArrayDateTime
                            case "system.datetime[]":

                                //Preparo el nombre 
                                lcNodo = ((DateTime[])loPar)[0].GetType().ToString().Trim().ToUpper().Substring(7);
                                xmlParan.WriteElementString("tipo_param", "DATETIME:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((DateTime[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + "{^" + ((DateTime[])loPar)[lnIndex].Year.ToString().Trim() + "-" +
                                                                ((DateTime[])loPar)[lnIndex].Month.ToString().Trim() + "-" +
                                                                ((DateTime[])loPar)[lnIndex].Day.ToString().Trim() + "}";
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDateTime

                            #region ArrayDecimal
                            case "system.decimal[]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "DECIMAL:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((decimal[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((decimal[])loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDecimal

                            #region ArrayDeDouble
                            case "system.double[]":

                                //Preparo el nombre 
                                lcNodo = ((double[])loPar)[0].GetType().ToString().Trim().ToUpper().Substring(7);
                                xmlParan.WriteElementString("tipo_param", lcNodo + ":ARRAY");

                                lnTotalElementos = ((double[])loPar).Length;

                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((double[])loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lcNodo = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDeDouble

                            #region ArrayDeInt32
                            case "system.int32[]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT32:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((Int32[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((Int32[])loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDeInt32

                            #region ArrayDeInt16
                            case "system.int16[]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT16:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((Int16[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((Int16[])loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDeInt16

                            #region ArrayDeInt64
                            case "system.int64[]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT32:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((Int64[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((Int64[])loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDeInt64

                            #region ArrayDeUInt16
                            case "system.uint16[]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT16:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((UInt16[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((UInt16[])loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDeUInt16

                            #region ArrayDeUInt32
                            case "system.uint32[]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT32:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((UInt32[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((UInt32[])loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDeUInt32

                            #region ArrayDeUInt64
                            case "system.uint64[]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT64:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((UInt64[])loPar).Length;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((UInt64[])loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ArrayDeUInt64

                            #endregion Arrays

                            #region Listas (List<T>)

                            #region ListaDeStrings
                            case "system.collections.generic.list`1[system.string]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "STRING:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((List<string>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + "'" + ((List<string>)loPar)[lnIndex].ToString().Replace("'", "''") + "'";
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeStrings

                            #region ListaDeBoleanos
                            case "system.collections.generic.list`1[system.boolean]":

                                //Preparo el nombre 
                                lcNodo = ((List<bool>)loPar)[0].GetType().ToString().Trim().ToUpper().Substring(7);
                                xmlParan.WriteElementString("tipo_param", "BOOLEAN:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((List<bool>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {

                                    if (((List<bool>)loPar)[lnIndex]) { lcValor = lcValor + ".T."; }
                                    else { lcValor = lcValor + ".F."; }
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeBoleanos

                            #region ListaDeDateTime
                            case "system.collections.generic.list`1[system.datetime]":

                                //Preparo el nombre 
                                lcNodo = ((List<DateTime>)loPar)[0].GetType().ToString().Trim().ToUpper().Substring(7);
                                xmlParan.WriteElementString("tipo_param", "DATETIME:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((List<DateTime>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + "{^" + ((List<DateTime>)loPar)[lnIndex].Year.ToString().Trim() + "-" +
                                                                ((List<DateTime>)loPar)[lnIndex].Month.ToString().Trim() + "-" +
                                                                ((List<DateTime>)loPar)[lnIndex].Day.ToString().Trim() + "}";
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeDateTime

                            #region ListaDeDecimal
                            case "system.collections.generic.list`1[system.decimal]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "DECIMAL:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((List<decimal>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((List<decimal>)loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeDecimal

                            #region ListaDeDouble
                            case "system.collections.generic.list`1[system.double]":

                                //Preparo el nombre 
                                lcNodo = ((List<double>)loPar)[0].GetType().ToString().Trim().ToUpper().Substring(7);
                                xmlParan.WriteElementString("tipo_param", lcNodo + ":ARRAY");

                                lnTotalElementos = ((List<double>)loPar).Count;

                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((List<double>)loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lcNodo = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeDouble

                            #region ListaDeInt16
                            case "system.collections.generic.list`1[system.int16]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT16:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((List<Int16>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((List<Int16>)loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeInt16

                            #region ListaDeInt32
                            case "system.collections.generic.list`1[system.int32]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT32:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((List<Int32>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((List<Int32>)loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeInt32

                            #region ListaDeInt64
                            case "system.collections.generic.list`1[system.int64]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT64:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((List<Int64>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((List<Int64>)loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeInt64

                            #region ListaDeUInt16
                            case "system.collections.generic.list`1[system.uint16]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT16:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((List<UInt16>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((List<UInt16>)loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeUInt16

                            #region ListaDeUInt32
                            case "system.collections.generic.list`1[system.uint32]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT32:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((List<UInt32>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((List<UInt32>)loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeUInt32

                            #region ListaDeUInt64
                            case "system.collections.generic.list`1[system.uint64]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT64:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((List<UInt64>)loPar).Count;
                                //Preparo la concatenacion de valores
                                for (int lnIndex = 0; lnIndex < lnTotalElementos; lnIndex++)
                                {
                                    lcValor = lcValor + ((List<UInt64>)loPar)[lnIndex].ToString().Replace(",", ".").Trim();
                                    if (lnIndex != lnTotalElementos - 1) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                break;

                            #endregion ListaDeUInt64

                            #endregion Listas (List<T>)

                            #region Listas Ordenadas (SortedList<TKey,TValue>)

                            #region SortedList<int,string>
                            case "system.collections.generic.sortedlist`2[system.int32,system.string]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "STRING:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((SortedList<int, string>)loPar).Count;
                                //Preparo la concatenacion de valores

                                foreach (string lcValorCampo in ((SortedList<int, string>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + "'" + lcValorCampo.ToString().Replace("'", "''") + "'";
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,string>

                            #region SortedList<int,decimal>
                            case "system.collections.generic.sortedlist`2[system.int32,system.decimal]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "DECIMAL:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((SortedList<int, decimal>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (decimal lcValorCampo in ((SortedList<int, decimal>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + lcValorCampo.ToString().Replace(",", ".").Trim();
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,decimal>

                            #region SortedList<int,bool>
                            case "system.collections.generic.sortedlist`2[system.int32,system.boolean]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "BOOLEAN:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((SortedList<int, bool>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (bool lcValorCampo in ((SortedList<int, bool>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    if (lcValorCampo) { lcValor = lcValor + ".T."; }
                                    else { lcValor = lcValor + ".F."; }
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,bool>

                            #region SortedList<int,DateTime>
                            case "system.collections.generic.sortedlist`2[system.int32,system.datetime]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "DATETIME:ARRAY");

                                //Numero de elementos 
                                lnTotalElementos = ((SortedList<int, DateTime>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (DateTime lcValorCampo in ((SortedList<int, DateTime>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + "{^" + lcValorCampo.Year.ToString().Trim() + "-" +
                                                                lcValorCampo.Month.ToString().Trim() + "-" +
                                                                lcValorCampo.Day.ToString().Trim() + "}";
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,DateTime>

                            #region SortedList<int,double>
                            case "system.collections.generic.sortedlist`2[system.int32,system.double]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "DOUBLE:ARRAY");

                                lnTotalElementos = ((SortedList<int, double>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (double lcValorCampo in ((SortedList<int, double>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + lcValorCampo.ToString().Replace(",", ".").Trim();
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,double>

                            #region SortedList<int,Int16>
                            case "system.collections.generic.sortedlist`2[system.int32,system.int16]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT16:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((SortedList<int, Int16>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (Int16 lcValorCampo in ((SortedList<int, Int16>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + lcValorCampo.ToString().Replace(",", ".").Trim();
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,Int16>

                            #region SortedList<int,Int32>
                            case "system.collections.generic.sortedlist`2[system.int32,system.int32]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT32:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((SortedList<int, Int32>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (Int32 lcValorCampo in ((SortedList<int, Int32>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + lcValorCampo.ToString().Replace(",", ".").Trim();
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,Int32>

                            #region SortedList<int,Int64>
                            case "system.collections.generic.sortedlist`2[system.int32,system.int64]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "INT64:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((SortedList<int, Int64>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (Int64 lcValorCampo in ((SortedList<int, Int64>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + lcValorCampo.ToString().Replace(",", ".").Trim();
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,Int64>

                            #region SortedList<int,UInt16>
                            case "system.collections.generic.sortedlist`2[system.int32,system.uint16]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT16:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((SortedList<int, UInt16>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (UInt16 lcValorCampo in ((SortedList<int, UInt16>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + lcValorCampo.ToString().Replace(",", ".").Trim();
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,UInt16>

                            #region SortedList<int,UInt32>
                            case "system.collections.generic.sortedlist`2[system.int32,system.uint32]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT32:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((SortedList<int, UInt32>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (UInt32 lcValorCampo in ((SortedList<int, UInt32>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + lcValorCampo.ToString().Replace(",", ".").Trim();
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,UInt32>

                            #region SortedList<int,UInt64>
                            case "system.collections.generic.sortedlist`2[system.int32,system.uint64]":

                                //Preparo el nombre 
                                xmlParan.WriteElementString("tipo_param", "UINT64:ARRAY");

                                //Numero de elementos
                                lnTotalElementos = ((SortedList<int, UInt64>)loPar).Count;
                                //Preparo la concatenacion de valores
                                foreach (UInt64 lcValorCampo in ((SortedList<int, UInt64>)loPar).Values)
                                {
                                    lnElementoActual++;
                                    lcValor = lcValor + lcValorCampo.ToString().Replace(",", ".").Trim();
                                    if (lnElementoActual != lnTotalElementos) lcValor = lcValor + NETVFP.SEPARADOR;
                                }

                                //Asigno el valor
                                xmlParan.WriteElementString("parametros", lcValor.ToString().Trim());

                                //Vacio para el siguiente elemento
                                lcValor = string.Empty;
                                lnTotalElementos = 0;
                                lnElementoActual = 0;
                                break;

                            #endregion SortedList<int,UInt64>

                            #endregion Listas Ordenadas (SortedList<TKey,TValue>)

                            default: //Tratamiento parametros ordinarios (tipos simples)

                                //Tipo parametros
                                xmlParan.WriteElementString("tipo_param", lcTipo.ToString().Trim().ToUpper().Substring(7));
                                //Valor
                                xmlParan.WriteElementString("parametros", _ToString(loPar));
                                break;

                        }

                        xmlParan.WriteEndElement(); //cierro nombre cursor

                    }
                    
                }

                xmlParan.WriteEndElement(); //Cierro VFPData
                xmlParan.WriteEndDocument();
                xmlParan.Close();
                
            }

            return lcNombreFichero;

        }


        private static void GuardarFicheroXmlRespuesta(string tcRutaFicheroXml, string[] tcValores)
        {
            // Crear xml con la respuesta para fox
            XmlDocument xmlReturn = new XmlDocument();                        
            xmlReturn.LoadXml("<?xml version = \"1.0\" encoding=\"Windows-1252\" standalone=\"yes\"?><returnvalues> </returnvalues>");
            XmlNode loNodeA = xmlReturn.SelectSingleNode("returnvalues");

            // Añadir los valores de respuesta al fichero
            foreach (string lcValor in tcValores)
            {
                XmlNode loNode = xmlReturn.CreateElement("return");
                loNode.InnerText = lcValor;
                loNodeA.AppendChild(loNode);    
            }
                                    
            // Guardar xml
            xmlReturn.PreserveWhitespace = true;
            xmlReturn.Save(tcRutaFicheroXml);  
        }

        #endregion METODOS PRIVADOS
    }

}