Cómo hacer un ping con C#  

A veces es necesario ejecutar un ping desde código para ver si una máquina está viva y responde. Podremos hacerlo con el código siguiente:

/**
 * Comprueba una IP lanzando un ping
 */
private bool comprobarIP(string ip, int timeoutSegs)
{
	// Creamos el objeto base y lo configuramos
	Ping ping = new Ping();

	PingOptions opciones = new PingOptions();
	opciones.DontFragment = true;

	// Añadimos 32 bytes de datos
	string datos = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
	byte[] buffer = Encoding.ASCII.GetBytes(datos);

	try
	{
		// Lanzamos el ping y esperamos la respuesta
		PingReply respuesta = ping.Send(ip, timeoutSegs*1000, buffer, opciones);

		if (respuesta.Status == IPStatus.Success) return true;
		else return false;
	}
	catch(Exception ex)
	{
		// Algo ha pasado...
		return false;
	}
}

He adaptado el código de éste post. ¡Gracias a su autor!

Espero que os sea de utilidad. ¡Happy coding!

Etiquetas: , , ,
Comentarios: No hay comentarios aún

¡Feliz año 2012 desde HijoDeBlog!  

using System;

/// <summary>
/// ¡Feliz año 2012 desde HijoDeBlog!
/// </summary>
public class Felicitacion
{
 /// <summary>
 /// Constructor de la felicitación
 /// </summary>
 public Felicitacion()
 {
 System.Console.WriteLine("¡Feliz año 2012 desde HijoDeBlog!");
 }
}
Etiquetas: , ,
Comentarios: No hay comentarios aún

Accediendo de forma segura a controles Windows Forms entre hebras  

Hemos creado una hebra, y en ella hemos escriot una línea tan sencilla como:

this.richTextBox.Text = "¡Hola, mundo!\r\n";

Y entonces de repente salta ésta excepción:

“Cross-thread operation not valid: Control ‘richTextBox’ accessed from a thread other than the thread it was created on.”

LA explicación es clara, hemos intentado acceder a un control desde fuera de la hebra que lo creó. Para solucionarlo usaremos una de las más interesantes características de C#: los delegados. El código de la solución sería el siguiente:


public class Formulario : Form
{
	// Declaramos el delegado
	delegate void SetTextCallback(string texto);

	// Constructor
	public Form1()
	{
		// Inicializamos los componentes del diseñador
		InitializeComponent();

		// Creamos y ejecutamos la hebra
		Thread hebra = new Thread(new new ThreadStart(this.funcionHebra));
		hebra.Start();
	}

	// Función de la hebra
	public void funcionHebra()
	{
		this.SetTex("¡Hola, mundo!\r\n");
	}

	// Método para hacer la llamada al control entre hebras de forma segura
	private void SetText(string texto)
	{
		if (this.richTextBox.InvokeRequired)
		{
			// Si viene desde la hebra invocamos al delegado con éste método
			SetTextCallback d = new SetTextCallback(SetText);
			this.Invoke(d, new object[] { texto });
		}
		else
		{
			// Si no, usamos el control directamente
			this.richTextBox.Text = texto;
		}
	}
}

Como vemos, con una función que compruebe el origen de la llamada y un delegado para acceder de forma segura a ése método, solucionaremos el problema.

¡Espero que os sea de utilidad! ¡Happy coding!

Aumentando la legibilidad del código fuente C#: Code Foldings  

Cuando el código fuente se hac muy grande es importante contar con herramientas que nos ayuden a aumentar la legibilidad del código. Una de ésas herramientas son los Code Foldings, la capacidad de “plegar” porciones del código fuente de manera que sólo se muestren cuando sea necesario.

En Visual Studio ésto se hace con las siguientes etiquetas:

#region Método que estará plegado

public void MetodoPleado()
{
	// ...
}

#endregion

Probadlo envuestro código, el cambio es radical, ya veréis icon smile Aumentando la legibilidad del código fuente C#: Code Foldings

¡Happy coding!

Tortoise SVN: Resolviendo el error Working copy ‘xxx’ locked  

Los errores de Subversion son un poco raros y a veces incomprensibles. A veces surge éste aleatorio error, no termino de entender muy bien por qué. Si alguno lo sabe agradeceré que me explique un poco más el motivo en los comentarios.

Para resolverlo basta con lo siguiente:

  • Exportar todo el directorio conflictivo (el que ha provocado el error) usando la función export de Tortoise (o arrastrando con el botón derecho del ratón el directorio a otra localización).
  • Ejecutar un SVN cleanup desde el menú contextual de Tortoise SVN.
  • Volver a hacer un SVN Update del repositorio.
  • Copiar de nuevo los datos que hemos exportado previamente y volver a hacer el SVN commit.

Espero que os ayude como a mi me ha ayudado. ¡Happy coding!

NOTA: Post simultáneo eny.

Controlando el código fuente con Subversion: Usando el repositorio SVN  

Tras instalar y configurar nuestro repositorio, vamos a empezar a añadir código fuente de una forma adecuada para que nuestro proyecto sea fácilmente mantenible independientemente de cuantos desarrolladores envíen código a él.

Como hemos visto, habrá tres directorios en nuestro repositorio:

  • trunk: Contendrá la versión en desarrollo actual de todos los proyectos que se deseen controlar.
  • branches: Contendrá versiones alternativas de un directorio de la rama TRUNK para hacer desarrollos paralelos. Luego podrán mezclarse unos con otros con el comando MERGE.
  • tags: Contendrá releases finales de cada proyecto, etiquetadas con su código de versión (1.0.0, etc).

Una vez comprendido cómo se estructurará nuestro repositorio, basta con usar herramientas como Tortoise SVN o los clientes SVN integrados en nuestro IDE favorito (Eclipse y NetBeans cuentan con herramientas para ese efecto) para actualizar y enviar nuestro código fuente y ahorrarnos muchos quebraderos de cabeza en desarrollos con un equipo de varios programadores. E incluso para un único programador es de utilidad.

¡Happy coding!

Controlando el código fuente con Subversion: Creando un repositorio SVN  

Todo desarrollo tiene que estar respaldado de un buen control de versiones. Hoy aprenderemos a usar Subversion para llevar ése control de versiones
Empezaremos instalando Subversion en nuestro Ubuntu Server:

$> sudo aptitude install subversion

Una vez instalado, crearemos nuestro repositorio base para todos nuestros proyectos:

$> sudo mkdir /var/lib/svn
$> sudo chmod -R 0777 /var/lib/svn
$> svnadmin create /var/lib/svn

Importamos la estructura base de directorios de todo repositorio SVN. Los explicaremos a continuación:

$> sudo svn mkdir --message="Creando directorios iniciales..." \
	file:///var/lib/svn/ContaWeb/trunk \
	file:///var/lib/svn/ContaWeb/tags \
	file:///var/lib/svn/ContaWeb/branches

Procederemos a configurar el repositorio recién creado a nuestro gusto:

$> nano -w /var/lib/svn/conf/svnserve.conf
$> nano -w /var/lib/svn/conf/passwd

Una vez creado y configurado el repositorio, deberemos iniciar el servidor SVN con el comando siguiente:

$> sudo svnserve -d -r /var/lib/svn

Para que sea más práctico, podremos automatizar éste inicio del servidor SVN creando un script de inicio Linux, aunque no es necesario.

Y ya está icon smile Controlando el código fuente con Subversion: Creando un repositorio SVN Podremos acceder al repositorio con la URL siguiente (cambiando la IP y el usuario por los datos correcto):

svn://usuario@192.168.1.2/var/lib/svn

¡Happy coding!

Como ejecutar cualquier comando a través del Shell de Windows  

Con éste método estático podremos ejecutar cualquier comando a través del Shell de Windows y recoger su salida:

/**
 * Ejecuta un comando usando el shell de Windows
 */
private static string ejecutarComando(string comando)
{
	// Generamos la info de proceso
	System.Diagnostics.ProcessStartInfo procInfo =
		new System.Diagnostics.ProcessStartInfo("cmd", "/c " + comando);

	// Configuramos el proceso para que redirija la salida y no genere ventanas
	procInfo.RedirectStandardOutput = true;
	procInfo.UseShellExecute = false;
	procInfo.CreateNoWindow = true;

	// Creamos el proceso en si
	System.Diagnostics.Process proceso = new System.Diagnostics.Process();
	proceso.StartInfo = procInfo;

	// Lo iniciamos
	proceso.Start();

	// Retornamos la salida del comando
	return proceso.StandardOutput.ReadToEnd();
}

¡Espero que os saque de algún aprieto como a mi!

Sockets en .NET  

Uno de los componentes básicos de las aplicaciones de hoy en día son los sockets, que permiten enviar y recibir datos a través de redes TCP/IP, es decir, permiten que nuestra aplicación se comunique con el mundo que la rodea. Veremos cómo inicializar, finalizar y utilizar éstos importantísimos elementos:

Inicializar un socket

Para inicializar un socket tendremos que usar un código como éste (detallaré cada elemento con los comentarios del código fuente):

// Basta con crear el objeto especificando su configuración con las
// enumeraciones AddressFamily, SocketType y ProtocolType
Socket socket = new Socket
(
AddressFamily.InterNetwork,    // IPv4
SocketType.Stream,             // Basado en streams
ProtocolType.Tcp               // TCP
);

Recibir datos del socket

Para recibir datos del socket tendremos que asociar el socket a un puerto (detallaré cada elemento con los comentarios del código fuente):

// Determinamos el punto final al que llegarán las peticiones
// y nos ponemos a escuchar
socket.Bind(new IPEndPoint(IPAddress.Any, Int32.Parse(textBoxPuertoEscucha.Text)));
socket.Listen(5); // Número máximo de peticiones en cola

Luego, para recibir en si, tendremos que usar un código como éste:

// Esperamos una conexión entrante
while (!socket.Poll(socket.ReceiveTimeout, SelectMode.SelectRead))
{
	// Aún no ha llegado, haremos lo que sea necesario aquí
	// ...
}

// Aceptamos la conexión
Socket cliente = socket.Accept();
if (cliente != null)
{
	// Recibimos datos
	try
	{
		int numLeidos = cliente.Receive(buffer, 0, 256, SocketFlags.None);
		recibido += ASCIIEncoding.ASCII.GetString(buffer, 0, numLeidos);
	}
	catch (Exception ee)
	{
		// Algo ha sucedido...
	}

	// Registramos lo recibido
	if (recibido != "")
	{
		// Procesamos aquí lo recibido como sea necesario
		// ...
	}
}

Enviar datos por el socket

Para enviar datos por el socket tendremos que usar un código como éste (detallaré cada elemento con los comentarios del código fuente):

// Creamos un socket de envío
Socket socketEnvio = new Socket
(
	AddressFamily.InterNetwork,
	SocketType.Stream,
	ProtocolType.Tcp
);

// Conectamos a una IP y un puerto concreto
IPAddress[] direcciones = Dns.GetHostEntry("SERVIDOR").AddressList;
IPAddress direccionRemota = null;

foreach (IPAddress d in direcciones)
{
	if (d.AddressFamily == AddressFamily.InterNetwork)
	{
		direccionRemota = d;
	}
}

socketEnvio.Connect(new IPEndPoint(direccionRemota, Int32.Parse("PUERTO")));

// Enviamos los datos
socketEnvio.Send(System.Text.Encoding.ASCII.GetBytes(paqueteAEnviar));

// Desconectamos
socketEnvio.Close();

Finalizar un socket

Para finalizar un socket tendremos que usar un código como éste (detallaré cada elemento con los comentarios del código fuente):

// Desconectamos
socket.Close();

Conclusión

Hemos visto un componente muy importante que nos abre un mundo de posibilidades. Una pieza más para el puzzle que son nuestras aplicaciones icon smile Sockets en .NET ¡Pronto más!

Usando algo parecido al ClassPath en C#  

Para incluir y usar librerías que estén en rutas diferentes al binario de la aplicación (por ejemplo, un directorio de librerías común), deberemos hacer lo siguiente:

  • Incluir en nuestro proyecto los ensamblados. En las propiedades de las referencias , especificar que NO se copiarán al directorio destino al compilar.

  • La librería debe estar firmada con un Strong Name. Si no lo está, lo añadiremos y recompilaremos la librería.

  • Obtener el Public Token de la librería a importar con el comando siguiente (el comando viene con una instalación normal del SDK de Windows):

“C:\Archivos de programa\Microsoft SDKs\Windows\v6.0A\bin\sn.exe” -T C:\Lib\MiLibreria.dll

  • Obtener también la versión del ensamblado.

  • Agregar con el asistente de ‘Nuevo Archivo’ un ‘Archivo de configuración’ al proyecto, de nombre ‘App.config’. Dentro de el anotar lo siguiente (cambiando por la versión y el Public Token obtenidos antes:

<?xml version=”1.0″ encoding=”utf-8″ ?>

<configuration>

<runtime>

<assemblyBinding xmlns=”urn:schemas-microsoft-com:asm.v1″>

<dependentAssembly>

<assemblyIdentity name=”MiLibreria” culture=”neutral” publicKeyToken=”1a7ca47513ea9b60″ />

<codeBase version=”0.2.1.21660″ href=”FILE://C:/Lib/MiLibreria.dll”/>

</dependentAssembly>

</assemblyBinding>

</runtime>

</configuration>

  • Repetir éste proceso por cada librería necesaria, añadiéndola al App.config con su configuración correcta.

  • Compilar la aplicación y ejecutar de forma normal.

Si deseas saber más, consulta http://support.microsoft.com/kb/837908.

Y recordad, Code is Poetry icon smile Usando algo parecido al ClassPath en C#


Disclaimer: Las imágenes mostradas en ésta página web se utilizan sólamente con propósitos ilustrativos, y son propiedad de sus respectivos autores (cuando es aplicable).
Hijo de Blog es un producto del Dr. SeROne

Los contenidos se ofrecen bajo una licencia de Creative Commons
Attribution-NonCommercial-NoDerivs 3.0 Unported

salvo que se indique lo contrario

Licencia de Creative Commons