Универсальный обмен данными между приложениями

Клиент
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.IO;
 
namespace Client
{
    class Program
    {
        static void Main(string[] args)
        {
            TcpClient client = new TcpClient();
            client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12000));
 
            StreamWriter sw = new StreamWriter(client.GetStream());
            sw.AutoFlush = true;
            Console.WriteLine("Client : Привет");
            sw.WriteLine("Привет");
 
            StreamReader sr = new StreamReader(client.GetStream());
            Console.WriteLine("Server : " + sr.ReadLine());
 
            Console.WriteLine("Client : Пока");
            sw.WriteLine("Пока");
            Console.WriteLine("Server : " + sr.ReadLine());
            client.Close();
 
            Console.ReadKey();
        }
    }
}
 
Сервер
/*********************/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
 
namespace Server
{
    class Program
    {
        static void Main(string[] args)
        {
            TcpListener listner = new TcpListener(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12000));
            listner.Start();
            while (true)
            {
                TcpClient client = listner.AcceptTcpClient();
 
                StreamReader sr = new StreamReader(client.GetStream());
                Console.WriteLine("Client : " + sr.ReadLine());
 
                StreamWriter sw = new StreamWriter(client.GetStream());
                sw.AutoFlush = true;
                Console.WriteLine("Server : Привет");
                sw.WriteLine("Привет");
 
                Console.WriteLine("Client : " + sr.ReadLine());
                Console.WriteLine("Server : Пока");
                sw.WriteLine("Пока");
 
                client.Close();
            }
        }
    }
}

//сервер
 sw.Write("Привет\nКак дела?");
 
//клиент
Console.Write("Server : " + sr.ReadToEnd());

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 
namespace CyberWinFormTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
 
            Helper.SendStringMessage(this.Handle, IntPtr.Zero, "ПРИУЕТ");//оправляем строку
            Helper.SendDataMessage(this.Handle, IntPtr.Zero, new Data() { Value = 10 });//отправляем структуру
        }
 
        //здесь ловим данные
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == Helper.WM_COPYDATA)
            {
                string message;
                switch(Helper.GetDataType(m.Msg, m.WParam, m.LParam))
                {
                    case Helper.DataType.String:
                        message = Helper.ReceiveStringMessage(m.Msg, m.WParam, m.LParam);
                        break;
 
                    case Helper.DataType.Struct:
                        Data data = Helper.ReceiveDataMessage<Data>(m.Msg, m.WParam, m.LParam);
                        message = data.Value.ToString();
                        break;
 
                    default:
                        message = string.Empty;
                        break;
                }
                
                MessageBox.Show(message);
            }
 
            base.WndProc(ref m);
        }
    }
 
    struct Data
    {
        public int Value { get; set; }
    }
 
    public static class Helper
    {
        [DllImport("User32.dll")]
        private static extern int SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
 
        public enum DataType
        {
            String,
            Struct
        }
 
        [StructLayout(LayoutKind.Sequential)]
        private struct COPYDATASTRUCT
        {
            public IntPtr dwData;
            public int cbData;
            public IntPtr lpData;
        }
 
        [StructLayout(LayoutKind.Sequential)]
        private struct DataStorage
        {
            public DataType Type;
            public IntPtr Data;
        }
 
        private static int SendData(IntPtr ReceivingWindowHandle, IntPtr SendingWindowHanlde, DataStorage data)
        {
            int result = 0;
 
            if (ReceivingWindowHandle != IntPtr.Zero)
            {
                IntPtr DataPointer = Marshal.AllocHGlobal(Marshal.SizeOf(data));
                Marshal.StructureToPtr(data, DataPointer, false);
 
                COPYDATASTRUCT dataStruct = new COPYDATASTRUCT();
                dataStruct.cbData = Marshal.SizeOf(data);
                dataStruct.dwData = IntPtr.Zero;
                dataStruct.lpData = DataPointer;
 
                IntPtr dataStructPointer = Marshal.AllocHGlobal(Marshal.SizeOf(dataStruct));
                Marshal.StructureToPtr(dataStruct, dataStructPointer, false);
 
                result = SendMessage(ReceivingWindowHandle, WM_COPYDATA, SendingWindowHanlde, dataStructPointer);
 
                Marshal.FreeHGlobal(dataStruct.lpData);
                Marshal.FreeHGlobal(dataStructPointer);
            }
 
            return result;
        }
 
        public const int WM_COPYDATA = 0x4A;
 
        public static DataType GetDataType(int msg, IntPtr wParam, IntPtr lParam)
        {
            if (msg != WM_COPYDATA)
                throw new ArgumentException("Message is not WM_COPYDATA");
 
            COPYDATASTRUCT dataStruct = (COPYDATASTRUCT)Marshal.PtrToStructure(lParam, typeof(COPYDATASTRUCT));
            DataStorage storage = (DataStorage)Marshal.PtrToStructure(dataStruct.lpData, typeof(DataStorage));
 
            return storage.Type;
        }
 
        public static int SendStringMessage(IntPtr ReceivingWindowHandle, IntPtr SendingWindowHanlde, string message)
        {
            DataStorage storage = new DataStorage();
            storage.Type = DataType.String;
            storage.Data = Marshal.StringToHGlobalUni(message);
 
            int result = SendData(ReceivingWindowHandle, SendingWindowHanlde, storage);
 
            Marshal.FreeHGlobal(storage.Data);
 
            return result;
        }
 
        public static string ReceiveStringMessage(int msg, IntPtr wParam, IntPtr lParam)
        {
            if (msg != WM_COPYDATA)
                throw new ArgumentException("Message is not WM_COPYDATA");
 
            COPYDATASTRUCT dataStruct = (COPYDATASTRUCT)Marshal.PtrToStructure(lParam, typeof(COPYDATASTRUCT));
            DataStorage storage = (DataStorage)Marshal.PtrToStructure(dataStruct.lpData, typeof(DataStorage));
 
            if (storage.Type != DataType.String)
                throw new ArgumentException("Message not contain string");
 
            return Marshal.PtrToStringUni(storage.Data);
        }
 
        public static int SendDataMessage<T>(IntPtr ReceivingWindowHandle, IntPtr SendingWindowHanlde, T data) where T : struct
        {
            IntPtr dataPointer = Marshal.AllocHGlobal(Marshal.SizeOf(data));
            Marshal.StructureToPtr(data, dataPointer, false);
 
            DataStorage storage = new DataStorage();
            storage.Type = DataType.Struct;
            storage.Data = dataPointer;
 
            int result = SendData(ReceivingWindowHandle, SendingWindowHanlde, storage);
 
            Marshal.FreeHGlobal(storage.Data);
 
            return result;
        }
 
        public static T ReceiveDataMessage<T>(int msg, IntPtr wParam, IntPtr lParam)
        {
            if (msg != WM_COPYDATA)
                throw new ArgumentException("Message is not WM_COPYDATA");
 
            COPYDATASTRUCT dataStruct = (COPYDATASTRUCT)Marshal.PtrToStructure(lParam, typeof(COPYDATASTRUCT));
            DataStorage storage = (DataStorage)Marshal.PtrToStructure(dataStruct.lpData, typeof(DataStorage));
 
            if (storage.Type != DataType.Struct)
                throw new ArgumentException("Message not contain struct");
 
            return (T)Marshal.PtrToStructure(storage.Data, typeof(T));
        }
    }
}