/**
 * 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!

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!

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

¡Happy coding!

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.

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!

$> 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á 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!

/**
 * 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!

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 ¡Pronto más!

• 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