Communication Protocol Tool

¡Hola a todos!
Hoy quiero compartir con ustedes un proyecto de software en el que he estado trabajando y que me tiene muy emocionado.

Se trata de una herramienta de protocolo de comunicación que utiliza tecnologías modernas para facilitar la interacción entre diferentes sistemas.

Vamos a sumergirnos en los detalles técnicos, pero no se preocupen, lo haremos de una manera accesible y entretenida.

¿De qué se trata este proyecto?

Este proyecto es una herramienta de protocolo de comunicación que permite a los usuarios enviar y recibir datos a través de TCP y UDP.

La interfaz de usuario está construida con WPF (Windows Presentation Foundation), lo que le da un aspecto moderno y una experiencia de usuario fluida.

Tecnologías Utilizadas

• C# y .NET: El lenguaje principal y el framework utilizados para desarrollar la lógica de la aplicación.
• WPF (Windows Presentation Foundation): Utilizado para crear la interfaz de usuario.
• TCP y UDP: Protocolos de comunicación para enviar y recibir datos.
• Newtonsoft.Json: Biblioteca para trabajar con JSON, utilizada para la serialización y deserialización de datos.

Explorando el Código

La Ventana Principal: MainWindow.xaml.cs

La ventana principal de la aplicación (MainWindow.xaml.cs) es donde ocurre la mayor parte de la acción. Aquí es donde se inicializan los componentes y se manejan las interacciones del usuario.

public partial class MainWindow : Window
{
    public TcpClientClass tcpServer;
    public bool tcpClientActive;
    public MainWindow ActualInstance;
    public RootSessions ListSessions;
    private UdpSocket udpSocket;
    private bool ContextMenuLanguageIsOpen;
    Translator translator = new Translator();
    Thread ThreadConnectionClientTCP;
    Thread LoopConnections;

    // Constructor
    public MainWindow()
    {
        InitializeComponent();
        // Inicialización de componentes y lógica adicional
    }

    // Método para mostrar notificaciones
    public void ShowNotification(string Message, string Tittle = "", bool Error = false)
    {
        NotifyWindow notifyWindow = new NotifyWindow(this, Message, Tittle, Error);
        notifyWindow.Show();
    }

    // Otros métodos y lógica...
}

Notificaciones: NotifyWindow.xaml.cs

La clase NotifyWindow se encarga de mostrar notificaciones al usuario. Es una ventana simple que puede mostrar mensajes de error o información.

public partial class NotifyWindow : Window
{
    public MainWindow MainWindow { get; set; }

    public NotifyWindow(MainWindow argMainWindow, string Message, string Tittle = "", bool Error = false)
    {
        MainWindow = argMainWindow;
        InitializeComponent();

        if (Error)
        {
            BorderNotify.BorderBrush = new SolidColorBrush(Colors.Red);
        }

        if (!string.IsNullOrEmpty(Tittle))
        {
            TextBlockTittle.Content = Tittle;
        }

        TextBlockNotify.Text = Message;
    }

    private void ButtonCloseNotify_Click(object sender, RoutedEventArgs e)
    {
        this.Close();
    }
}

Comunicación TCP: TcpClientClass.cs

La clase TcpClientClass maneja la comunicación TCP. Permite conectar, enviar y recibir mensajes a través de una conexión TCP.

public class TcpClientClass
{
    private TcpClient client;
    private NetworkStream stream;
    private Encoding encoding;
    public event EventHandler<MessageReceivedEventArgs> MessageReceived;
    private MainWindow mainWindow;

    public bool Start(string ip, int port, Encoding encoding, MainWindow _mainWindow)
    {
        try
        {
            this.client = new TcpClient(ip, port);
            this.stream = client.GetStream();
            this.encoding = encoding;
            mainWindow = _mainWindow;

            void StartListenerTPCClient()
            {
                while (client.Connected)
                {
                    _ = ReceiveMessageAsync();
                    Thread.Sleep(1000);
                }
            }

            Thread thread = new Thread(StartListenerTPCClient);
            thread.Start();
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error connecting to server: {ex.Message}");
            return false;
        }
    }

    public async Task ReceiveMessageAsync()
    {
        try
        {
            byte[] buffer = new byte[1024];
            int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);

            if (bytesRead == 0)
            {
                Console.WriteLine("Server connection closed.");
                mainWindow.Dispatcher.Invoke(() => mainWindow.ConnectionTCPClientClosed());
                client.Close();
                return;
            }

            string message = mainWindow.GetActualEncoding().GetString(buffer, 0, bytesRead);
            message += "\n";
            MessageReceived?.Invoke(this, new MessageReceivedEventArgs(message));
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error receiving data: {ex.Message}");
        }
    }

    public void SendMessage(string message, bool SendHeaders = false)
    {
        try
        {
            if (SendHeaders)
            {
                message = $"{(char)0x27}{(char)0x01}{(char)0x27}{(char)0x02}{message}{(char)0x27}{(char)0x03}{(char)0x27}{(char)0x04}";
            }

            byte[] data = mainWindow.GetActualEncoding().GetBytes(message);
            stream.Write(data, 0, data.Length);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error sending message: {ex.Message}");
        }
    }

    public void Stop()
    {
        try
        {
            stream.Close();
            client.Close();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error closing socket: {ex.Message}");
        }
    }
}

Conclusión

Este proyecto es una herramienta poderosa para la comunicación entre sistemas utilizando TCP y UDP. La combinación de C#, .NET y WPF proporciona una base sólida y una interfaz de usuario atractiva.

Espero que esta visión general les haya dado una buena idea de cómo funciona el proyecto y las tecnologías que utiliza.

¡Gracias por leer y espero que disfruten explorando el código tanto como yo disfruté escribiéndolo!

¡Hasta la próxima!