Tag Archive for sockets

Sockets en C# (Parte 2)

Buenas a todos, esta es la segunda parte del tutorial sobre sockets en c#.
Para los que no vieron la primera parte acá se las dejo:

Sockets en C# (Parte 1)

En esta nueva entrega veremos como enviar y recibir texto.

Para ello crearemos el cliente y servidor, y lo conectaremos. Como vimos antes.

Para enviar

Algo ah tener en cuenta, es que el texto que queremos enviar, debe ser convertido en un array de bytes. Para ello utilizamos la clase Encoding.

 
byte[] txtAEnviar;    // creamos una array de byte
 txtAEnviar = Encoding.Default.GetBytes(texto);  // De esa manera pasamos a bytes el texto (string)

Una vez hecho lo anterior lo que queda es enviarlo. Para ello utilizaremos el socket que creamos y usamos su metodo Send().
Este método tiene algunos parametros:

miPrimerSocket.Send(a,b,c,d);
//a -> el array de bytes 
//b -> Posición del array de donde comienza a enviar
//c -> Tamaño del array. Esto se consigue con la propiedad Length
//d -> Especifica los comportamientos de envío y recepción del socket.Nosotros pondremos 0
//Nos quedaria así
miPrimerSocket.Send(txtAEnviar, 0, txtAEnviar.Length,0);

Para recibir

Primero antes que nada debemos crear el array de bytes, en esta primera medida le pondremos una tamaño de 255, Hay que tener en cuenta que si el cliente manda un array mayor habrá un error. Una solución seria primero mandar el tamaño del array y luego el array en sí. Pero ahora no viene al caso ya que es solo un ejemplo

byte[] byARecibir = new byte[255];

Ahora recibimos el array de bytes con el metodo del socket, Receive(). Este metodo devuelve un entero que luego usaremos

int enteroRecibido = miPrimerSocket.Receive(ByRec, 0, ByRec.Length, 0); 
//Los parametros son los mismos que los del metodo Send
//En el servidor usariamos el socket que usamos en la entrega anterior, osea, "Escuchar"

Ahora usariamos el metodo Resize de la clase Array para cambiar el numero de elementos de nuestro array en base al retorno del metodo Receive, ya que antes teniamos 255. Pero debemos pasarle el array por referencia.

Array.Resize(ref ByRec, enteroRecibido);

y listo, solo ahora queda pasar nuestro array de bytes a texto de la siguiente manera

string texto;
texto = Encoding.Default.GetString(ByRec)

Eso es todo por ahora, les dejo el ejemplo. Saludos!

Cliente

class Program
    {
        static void Main(string[] args)
        {
            Conectar();
        }
        public static void Conectar()
        {
            Socket miPrimerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint miDireccion = new IPEndPoint(IPAddress.Parse("192.168.0.11"), 1234);

            string texto;
            byte[] textoEnviar;

            try
            {
                miPrimerSocket.Connect(miDireccion);
                Console.WriteLine("Conectado con exito");

                Console.WriteLine("Ingrese el texto a enviar al servidor: ");
                texto = Console.ReadLine(); //leemos el texto ingresado 
                textoEnviar = Encoding.Default.GetBytes(texto); //pasamos el texto a array de bytes
                miPrimerSocket.Send(textoEnviar, 0, textoEnviar.Length,0); // y lo enviamos
                Console.WriteLine("Enviado exitosamente");

                miPrimerSocket.Close();
            }
            catch (Exception error)
            {
                Console.WriteLine("Error: {0}", error.ToString());
            }
            Console.WriteLine("Presione cualquier tecla para terminar");
            Console.ReadLine();
        }

Servidor

public static void Conectar()
        {
            byte[] ByRec;
            Socket miPrimerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint miDireccion = new IPEndPoint(IPAddress.Any, 1234);

            byte[] ByRec; 
            try
            {
                miPrimerSocket.Bind(miDireccion);
                miPrimerSocket.Listen(1);

                Console.WriteLine("Escuchando...");
                Socket Escuchar = miPrimerSocket.Accept();
                Console.WriteLine("Conectado con exito");

                ByRec = new byte[255]; 
                int a = Escuchar.Receive(ByRec, 0, ByRec.Length, 0);
                Array.Resize(ref ByRec, a);
                Console.WriteLine("Cliente dice: " + Encoding.Default.GetString(ByRec)); //mostramos lo recibido
                miPrimerSocket.Close();

            }
            catch (Exception error)
            {
                Console.WriteLine("Error: {0}", error.ToString());
            }
            Console.WriteLine("Presione cualquier tecla para terminar");
            Console.ReadLine();

        }

Sockets en C# (Parte 1)

Buenas a todos en este “tutorial” voy a tratar de explicar las nociones básicas sobre sockets, ejemplos básicos, teoría, etc. Todo esto adquirido por practicas/errores propios jaja, Lo malo es que soy novato en esto, así que si ven errores o males usos no duden en corregirme, Así que empecemos!!

Los sockets sirven para la comunicación entre programas (en una primera medida), y para comenzar a “dialogar” debemos crear dicho Socket.

1-Agregamos los siguientes Namespaces

System.Net;
System.Net.Sockets;

2-Una vez agregados, procedemos a crearlos de la siguiente manera:

Socket nombre_de_socket = new Socket(AddressFamily, SocketType, ProtocolType);

Socket -> Nombre de la clase
nombre_de_socket -> El nombre que quieras ponerle
AddressFamily -> Indica el servicio de direcciones que el socket debe usar
SocketType ->Especifica el tipo de socket
ProtocolType -> Indica el tipo de protocolo a usar

Nosotros por el momento lo usaremos así:

Socket miPrimerSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);

3-Luego necesitamos una direccion ip y un puerto para realizar la conección, para ello contamos con una clase llamada IPEndPoint

IPEndPoint direccion = new IPEndPoint(IPAddress.Parse(ip),puerto);

ip -> Se pone entre comillas, por ejemplo, “192.168.0.1”
puerto -> Se pone directamente (sin comillas), por ejemplo, 1234

Nos quedaria así

IPEndPoint direccion = new IPEndPoint(IPAddress.Parse("192.168.0.1"),1234);

4-Listo ahora crearemos un servidor, por el momento sera con aplicaciones de consola 

Realizamos los 3 primeros items, y ahora tendremos que asociar el socket con la direccion, usando el metodo Bind

miPrimerSocket.Bind(direccion);  
//cabe destacar que la direccion es la propia del servidor

Luego lo debemos poner a la escucha con el metodo Listen

miPrimerSocket.Listen(numero)   
// numero -> es la longitud maxima de la cola de conecciones, por el momento pondremos 1

5-Ahora debemos Crear un segundo Socket para comenzar a interactuar 

Socket OtroNombre = miPrimerSocket.Accept();  
// Acá debemos usar el anterior Socket

Listo una vez echo esto, la aplicación queda suspendida hasta que el cliente se conecta. Esto se debe a que es un Servidor Sincrónico.

Hay dos modos: sincrónicos y asincrónicos, el primero ya está explicado y el segundo caso no queda suspendido. Pero por el momento seguiremos con el sincrónico, ya que es más fácil de enterder.

6-Ahora crearemos un cliente

Realizamos los 3 primeros pasos, pero en la dirección debemos poner la del servidor, y el mismo puerto

7-Conectaremos el socket

miPrimerSocket.Connect(direccion);

Y listo, ahora las aplicaciones estarán conectadas. Obviamente con esto solamente no sirve de nada, pero en los próximos tutoriales veremos como pasar texto, fotos, archivos, etc.

Algo a tener en cuenta ahora es que primero debe ejecutarse el servidor, pero solo por ahora, más adelante, como dije antes, se irá acomplejando y haciendo más útiles los ejemplos!
Y por si alguno no entendió que hacen estas dos aplicaciones, les digo que solo se conectan y nada más. Es solo una introducción.

Muchas Gracias y les dejo los codigos:

Servidor

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;               //   Paso 1
using System.Net.Sockets;       //   Paso 1

namespace Servidor
{
    class Program
    {
        static void Main(string[] args)
        {
            Conectar();  //Llamar a función Conectar, es ajeno al tema
        }
        public static void Conectar()  
        {
            Socket miPrimerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);   
            // paso 2 - creamos el socket
            IPEndPoint miDireccion = new IPEndPoint(IPAddress.Any, 1234);
            //paso 3 -IPAddress.Any significa que va a escuchar al cliente en toda la red 
            try
            { 
                // paso 4
                miPrimerSocket.Bind(miDireccion); // Asociamos el socket a miDireccion
                miPrimerSocket.Listen(1); // Lo ponemos a escucha

                Console.WriteLine("Escuchando...");
                Socket Escuchar = miPrimerSocket.Accept(); 
                 //creamos el nuevo socket, para comenzar a trabajar con él
                 //La aplicación queda en reposo hasta que el socket se conecte a el cliente
                 //Una vez conectado, la aplicación sigue su camino  
                Console.WriteLine("Conectado con exito"); 

                /*Aca ponemos todo lo que queramos hacer con el socket, osea antes de 
                cerrarlo je*/
                miPrimerSocket.Close(); //Luego lo cerramos

            }
            catch (Exception error)
            {
                Console.WriteLine("Error: {0}", error.ToString());
            }
            Console.WriteLine("Presione cualquier tecla para terminar");
            Console.ReadLine();

        }
    }
}

cliente

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;            //   Paso 1
using System.Net.Sockets;    //   Paso 1

namespace Cliente
{
    class Program
    {
        static void Main(string[] args)
        {
            Conectar();
        }
        public static void Conectar()
        {
            Socket miPrimerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            // paso 2 - creamos el socket
            IPEndPoint miDireccion = new IPEndPoint(IPAddress.Parse("192.168.0.11"), 1234);
            //paso 3 - Acá debemos poner la Ip del servidor, y el puerto de escucha del servidor
            //Yo puse esa porque corrí las dos aplicaciones en la misma pc
            try
            {
                miPrimerSocket.Connect(miDireccion); // Conectamos                
                Console.WriteLine("Conectado con exito");
                miPrimerSocket.Close();
            }
            catch (Exception error)
            {
                Console.WriteLine("Error: {0}",error.ToString());
            }
            Console.WriteLine("Presione cualquier tecla para terminar");
            Console.ReadLine();
        }
    }
}