Tag Archive for c sharp

Curso de C# (Tipos de datos)

Tipos de datos

    • CTS (Common Type System)

Define un conjunto común de “tipos” de datos orientado a objetos.
Todo Lenguaje de programación .NET debe implementar los tipos definidos por el CTS.
Todo tipo hereda directa o inderectamente del tipo System.Object.
El CTS define tipos de VALOR y de REFERENCIA.

    • Valores Predeterminados

Enteros -> 0(cero)
Flotantes -> 0(cero)
Lógicos -> False
Referencias -> null
Por ejemplo

 
int soyUnEntero; //soyUnEntero va a ser cero hasta que le asigemos un valor contrario.
bool Prendido; //Prendido va a ser falso
string Hola; //Hola va a ser null
    • Conversiones Básicas en C#

Hay dos tipos de conversiones:
Implicitas -> No interviene el programador
Explicitas -> Interviene el programador, porque puede haber pérdida de datos.

Ejemplos con código:

//Valores Predeterminados
int entero; //Creaamos un entero, en este momento, el valor de entero es 0.
entero = 5; //a ese entero le asignamos el valor 5. 

float flotante; //Crear un un número flotante, en este momento vale 0.
flotante = 4.23231; //Le asigamos el valor 4.23231

bool lampara;  //creamos un valor buleano, en este momento lampara es falso.
lampara = true; // Le cambiamos el valor a verdadero

string Texto; //creamos una cadena de caracteres, texto es null en este momento
texto = "Hola mundo"; //le asigamos la cadena "Hola mundo"

//Conversiones implicitas
Esta es una conversión implicita porque no hay perdida de datos, entonces sólo el compilador hace su trabajo
long valorGrande;
int entero = 5;
valorGrandee = entero;

//Conversiones explicitas
long valorGrande = 5;
int entero;
entero = (int)valorGrande;
//Acá si no colocamos (int) delante de valorGrande habrá un error, porque no podemos albergar un tipo long en un entero. La solución acá es el casteo, osea poner (tipo) delante de la variable que queremos asignar a otra variable,donde tipo es el mismo tipo de la otra variable. Pero habrá perdida de datos

En simples palabras, el tipo de datos es como una “caja”, en la cual ponemos cosas(datos). Pero tenemos distintos tipos de cosas, por lo tanto también habrá distintas cajas.
A partir de ahora a estas cajas la llamaremos Atributos.

Y como creamos un atributo?? De la siguiente manera.

Tipo nombreAtributo;

Donde:
Tipo -> representa el tipo de dato. Ejemplo string
nombreAtributo -> es el nombre de la “caja”. Ejemplo soyEntero.
; -> Algo que siempre debemos recordar que los atributos siempre terminan con punto y coma.

Y como “metemos” cosas dentro de las “cajas”? A esta llamaremos “Asignar” de ahora en adelante y lo haremos así.

nombre = cosa ;

Donde :
nombre -> Es el nombre del atributo.
= -> Es el operador de asignación. Con esto querremos decir de una forma bulgar, que “metemos” lo de la derecha en lo de la izquierda..
cosa -> dato. Ejemplo 5.
; -> Fin de la instrucción.

Pero también podemos hacer las dos cosas en la misma linea.
por ejemplo:

 int nombreEntero = 10;

Bueno esto es todo por hoy, espero haber sido claro.
Hasta la proxima!

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();

        }