En el post anterior decíamos que cuando pasamos un arreglo a un método, ‘se pasa la referencia al arreglo por valor’. En este post veremos entonces cual es la diferencia entre pasar la “referencia de un arreglo por valor” y “referencia de un arreglo por referencia”.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
public class EjemploArregloReferencia : Form
{
  private Label labelSalida;
  private Button botonMostrarSalida;
  public EjemploArregloReferencia()
  {
     InitializeComponent();
  }

  private void InitializeComponent()
  {
     this.labelSalida = new Label();
     this.botonMostrarSalida = new Button();
     this.SuspendLayout();
     //
     // labelSalida
     //
     this.labelSalida.Location = new System.Drawing.Point(10, 40);
     this.labelSalida.Name = "labelSalida";
     this.labelSalida.Size = new System.Drawing.Size(272, 280);
     this.labelSalida.TabIndex = 0;
     //
     // botonMostrarSalida
     //
     this.botonMostrarSalida.Location = new System.Drawing.Point(101, 8);
     this.botonMostrarSalida.Name = "botonMostrarSalida";
     this.botonMostrarSalida.Size = new System.Drawing.Size(91, 23);
     this.botonMostrarSalida.TabIndex = 1;
     this.botonMostrarSalida.Text = "Mostrar salida";
     this.botonMostrarSalida.Click += new System.EventHandler(this.botonMostrarSalida_Click);
     //
     // EjemploArregloReferencia
     //
     this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     this.ClientSize = new System.Drawing.Size(292, 325);
     this.Controls.AddRange(new Control[] {
                                                                  this.botonMostrarSalida,
                                                                  this.labelSalida});
     this.Name = "EjemploArregloReferencia";
     this.Text = "EjemploArregloReferencia";
     this.ResumeLayout(false);

  }
  static void Main()
  {
     Application.Run( new EjemploArregloReferencia() );
  }

  private void botonMostrarSalida_Click( object sender,
     System.EventArgs e )
  {
     // crear e iniciar primerArreglo
     int[] primerArreglo = { 1, 2, 3 };

     // copiar primerArreglo en otro arreglo
     int[] copiaPrimerArreglo = primerArreglo;

     labelSalida.Text =
        "Ejemplo pasar la referencia de primerArreglo por valor";

     labelSalida.Text += "\n\nContenido de primerArreglo " +
        "antes de llamar el metodo primerDoblar:\n\t";

     // imprimir el contenido del arreglo primerArreglo
     for ( int i = 0; i < primerArreglo.Length; i++ )
        labelSalida.Text += primerArreglo[ i ] + " ";

     // pasar referencia de primerArreglo por valor a primerDoblar
     primerDoblar( primerArreglo );

     labelSalida.Text += "\n\nContenido de primerArreglo despues " +
        "de llamar el metodo primerDoblar\n\t";

     // imprimir contenido de primerArreglo
     for ( int i = 0; i < primerArreglo.Length; i++ )
        labelSalida.Text += primerArreglo[ i ] + " ";

     // probar si la copia cambio
     if ( primerArreglo == copiaPrimerArreglo )
        labelSalida.Text +=
           "\n\nLa copia fue modificada tambien (porque tiene la referencia a dicho arreglo)\n";
     else
        labelSalida.Text +=
           "\n\nLa copia no fue modificada\n";

     // crear e inciar segundoArreglo
     int[] segundoArreglo = { 1, 2, 3 };

     // crear una copia de segundoArreglo
     int[] copiaSegundoArreglo = segundoArreglo;

     labelSalida.Text += "\nEjemplo, pasar referencia de segundoArreglo " +
        "por referencia";

     labelSalida.Text += "\n\nContenido de segundoArreglo " +
        "antes de llamar el metodo segundoDoblar:\n\t";

     // imprime el contenido de segundoArreglo antes de llamar al metodo
     for ( int i = 0; i < segundoArreglo.Length; i++ )
        labelSalida.Text += segundoArreglo[ i ] + " ";

     segundoDoblar( ref segundoArreglo );

     labelSalida.Text += "\n\nContenido de segundoArreglo " +
        "despues de llamar el metodo segundoDoblar:\n\t";

     // imprimir el contenido de segundoArreglo despues de llamar al metodo
     for ( int i = 0; i < segundoArreglo.Length; i++ )
        labelSalida.Text += segundoArreglo[ i ] + " ";

     // verificar si la copia ha cambiado
     if ( segundoArreglo == copiaSegundoArreglo )
        labelSalida.Text +=
           "\n\nLa copia ha cambiado\n";
     else
        labelSalida.Text +=
           "\n\nLa referencia y el arreglo original son distintos (porque el original cambio de referencia)\n";

  } // fin del metodo botonMostrarSalida_Click

  // modifica elementos del arreglo e intentar modificar la referencia
  void primerDoblar( int[] array )
  {
     // doblar cada elemento del arreglo
     for ( int i = 0; i < array.Length; i++ )
        array[ i ] *= 2;

     // crear una nueva referencia y asignarla al arreglo
     array = new int[] { 11, 12, 13 };
  }

  // modifica elementos del arreglo e intentar modificar la referencia
  void segundoDoblar( ref int[] array )
  {
     // doblar cada elemento del arreglo
     for ( int i = 0; i < array.Length; i++ )
        array[ i ] *= 2;

     // crear una nueva referencia y asignarla al arreglo
     array = new int[] { 11, 12, 13 };
  }
}

Descargar código fuente

Cuando estamos trabajando con arreglos en C#, debemos tener en cuenta algo importante: si pasamos un arreglo entero, éste será pasado por referencia ; mientras que si pasamos uno de los elementos del arreglo, éste es pasado por valor.

¿Qué quiere decir esto exactamente? Pues bien, cuando pasamos un arreglo completo a un método, TODAS las modificaciones que hagamos sobre el arreglo en dicho método se verán reflejadas en el arreglo original. Por otro lado, cuando lo que pasamos es un elemento de un arreglo, las modificaciones que hagamos sobre el elemento serán accesibles únicamente desde dicho método, por lo tanto el valor original del elemento no es modificado.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
public class PasarArreglo : Form
{
  private Button botonMostrarSalida;
  private Label labelSalida;
  public PasarArreglo()
  {
     InitializeComponent();
  }
  private void InitializeComponent()
  {
     this.botonMostrarSalida = new Button();
     this.labelSalida = new Label();
     this.SuspendLayout();
     //
     // botonMostrarSalida
     //
     this.botonMostrarSalida.Location = new System.Drawing.Point(106, 8);
     this.botonMostrarSalida.Name = "botonMostrarSalida";
     this.botonMostrarSalida.Size = new System.Drawing.Size(80, 23);
     this.botonMostrarSalida.TabIndex = 0;
     this.botonMostrarSalida.Text = "Mostrar salida";
     this.botonMostrarSalida.Click += new System.EventHandler(this.botonMostrarSalida_Click);
     //
     // labelSalida
     //
     this.labelSalida.Location = new System.Drawing.Point(8, 48);
     this.labelSalida.Name = "labelSalida";
     this.labelSalida.Size = new System.Drawing.Size(280, 184);
     this.labelSalida.TabIndex = 1;
     //
     // PasarArreglo
     //
     this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     this.ClientSize = new System.Drawing.Size(292, 237);
     this.Controls.AddRange(new Control[] {
          this.labelSalida,
          this.botonMostrarSalida});
     this.Name = "PasarArreglo";
     this.Text = "Pasar Arreglo por valor y referencia";
     this.ResumeLayout(false);

  }
  static void Main()
  {
     Application.Run( new PasarArreglo() );
  }

  private void botonMostrarSalida_Click( object sender,
     System.EventArgs e )
  {
     int[] a = { 1, 2, 3, 4, 5 };

     labelSalida.Text = "Resultado de pasar un arreglo " +
        "por referencia...\n\nLos valores del arreglo original son:\n\t";

     for ( int i = 0; i < a.Length; i++ )
        labelSalida.Text += "   " + a[ i ];

     ModificarArreglo( a );   // el array es pasado por referencia

     labelSalida.Text +=
        "\n\nEl valor de los datos modificados del arreglo son:\n\t";

     // mostrar elementos del array a
     for ( int i = 0; i < a.Length; i++ )
        labelSalida.Text += "   " + a[ i ];

     labelSalida.Text += "\n\nResultado de pasar un elemento del array por valor..." +
        "\n\nvalor de a[ 3 ] (antes de ser pasado a ModificarElemento()) " + a[ 3 ];

     // elemento del array pasado por valor
     ModificarElemento( a[ 3 ] );

     labelSalida.Text +=
        "\na[ 3 ] (despues de ser pasado a ModificarElemento()): " + a[ 3 ];
  }

  // metodo que modifica el arreglo que recibe
  // (el original será modificado)
  public void ModificarArreglo( int[] b )
  {
     for ( int j = 0; j < b.Length; j++ )
        b[ j ] *= 2;
  }

  // metodo que modifica el entero recibido
  // (el original no será modificado)
  public void ModificarElemento( int e )
  {
     labelSalida.Text +=
        "\nvalor recibido por el metodo: " + e;
     e *= 2;
     labelSalida.Text +=
        "\nvalor modificado dentro del metodo: " + e;
  }
}

Descargar código fuente

Ejemplos básicos de manipulación de arreglos en C#

Sumar elementos de un array

Sinopsis: hacer la sumatoria de los elementos de un arreglo.

using System;
class SumarArreglo
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     int total = 0;
     for ( int i = 0; i < a.Length; i++ )
        total += a[ i ];
     Console.WriteLine( "Suma de todos los elementos del array: " + total);
  } // fin de Main
} // fin de la clase SumarArreglo

Resultado…

Descargar código fuente

Creacion de histogramas

Sinopsis: crear un histograma (barras a base de asteriscos) a partir de unos datos.

using System;
class Histograma
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] n = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
     string salida = "Elemento\tValor\tHistograma\n";
     // construir salida
     for ( int i = 0; i < n.Length; i++ )
     {
        salida += "\n" + i + "\t\t\t" + n[ i ] + "\t\t";
        for ( int j = 1; j <= n[ i ]; j++ ) // imprimir una barra
           salida += "*";
     }
     Console.WriteLine( salida);
  } // fin Main
} // fin de la clase Histograma

Resultado…

Descargar código fuente

Estadisticas de notas de estudiantes

Sinopsis: apartir de un arreglo de notas (puntajes) identificar la frecuencia de cada una de ellas entre todos los estudiantes.

using System;
class EncuestaEstudiantes
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] respuestas = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1,
        6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7,
        5, 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };

     int[] frecuencia = new int[ 11 ];
     string salida = "";

     // incrementar la frecuecia de para cada respuesta
     for ( int j = 0; j < respuestas.Length; j++ )
        ++frecuencia[ respuestas[ j ] ];

     salida += "Puntaje\tFrecuencia\n";

     // resultados
     for ( int puntaje = 1; puntaje < frecuencia.Length; puntaje++ )
        salida += puntaje + "\t\t" + frecuencia[ puntaje ] + "\n";

     Console.WriteLine( salida);

  } // fin Main

} // fin de la clase EncuestaEstudiantes

Resultado…

Descargar código fuente

La creación y manipulación de arrays en C# es similar a la de cualquier otro lenguaje de programación, aunque difiere un poco en cuanto a sintaxis (desde la perspectiva de un programador en Java).

Tenemos entoces 2 maneras básicas de iniciar un arreglo:

• Al asignarle un tamaño estamos iniciándolo con los valores por defecto (en el caso de enteros, es cero)
• En el momento de la declaración podemos asignar directamente los valores, poniéndolos dentro de corchetes ({ … }), separados por comas.

Ejemplo…

using System;
class InitArray
{
	// metodo main
	static void Main( string[] args )
	{
	   string salida = "";
	   int[] x;            // declarar el array
	   x = new int[ 10 ];  // y asignarle un tamanio
     // iniciar un arreglo con tamanio y datos especificos
	   int[] y = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
	   const int TAMANIO_ARRAY = 10; // crear una constante
	   int[] z;                   // declarar un array de enteros
	   // asignar el tammanio con la constante
	   z = new int[ TAMANIO_ARRAY ];
	   // asignar valores al array
	   for ( int i = 0; i < z.Length; i++ )
	      z[ i ] = 2 + 2 * i;
	   salida += "Indice\tArray x\tArray y\tArray z\n";
	   // poner los valores del array en el string de salida
	   for ( int i = 0; i < TAMANIO_ARRAY; i++ )
	      salida += i + "\t\t" + x[ i ] + "\t\t" + y[ i ] +
	         "\t\t" + z[ i ] + "\n";
	Console.WriteLine(salida);
	} // fin de Main
} // fin de la clase IniciarArray

Salida del programa…

Descargar código fuente

Descargar código fuente

La generación de números aleatoreos es una de las prácticas más importantes en cualquier lenguaje de programación, sobre todo cuando deseamos desarrollar juegos, por ejemplo. Para usar números aleatorios en C# podemos utilizar la clase Random del namespace System, de la siguiente manera:

Random objeto = new Random();
int numero = objeto.Next();

El método Next de la clase Random genera y devuelve un número aleatorio entre 0 y la constante Int32.MaxValue (2,147,483,647). El número es generado después de (como decía mi profesora de matemáticas) complejos procesos matemáticos, y como en casi todos los lenguajes necesitan de una semilla (seed) para ser generados, que por defecto es la hora del sistema.

Aún así, muchas veces necesitamos que el número sea generado en un rango específico de valores. Por ejemplo, para una aplicación que simule el lanzamiento de un dado de seis caras necesitamos generar números entre 1 y 6. Para lograr esto, el método Next puede recibir además un entero que indica el rango máximo del número aleatorio. Por ejemplo, el código:

Random objeto = new Random();
int numero = objeto.Next(6);

generaría un número aleatorio entre 0 y 7 (pero no 6), es decir, seis posibles números. Pero, si desearamos algún rango más exacto, podríamos hacer algo como:

Random objeto = new Random();
int numero = objeto.Next(1, 7);

lo que generaría números entre 1 y 7 (pero no 7), de nuevo seis números posibles.

Ejemplo completo…

En el siguiente ejemplo se utilizará la clase Random para generar una serie de números aleatorios cada vez que se presiona un botón:

El código lo pongo para su descarga abajo, ya que lo hice con Gtk# usando MonoDevelop, y sería engorroso poner todo el código. Así que solo pondré la parte del código que nos interesa:

    private Random obj = new Random();
    //Método ejecutado al presionar el botón
    protected virtual void generar_Click (object sender, System.EventArgs e)
    {
        etiqueta.Text = "";
        for(int i = 0; i < 4 ; i++)
        {
            for(int j = 0; j < 4 ; j++)
                etiqueta.Text += obj.Next(1, 10) +"\t\t";
            etiqueta.Text += "\n\n";
        }
    }

Enlaces y descargas

• Descargar código fuente del ejemplo (usando Gtk#)
• Descargar proyecto similar en inglés (usando Windows Forms)
• Aplicaciones con GUI en .NET: ¿Gtk# o Windows Forms?

Nota: este es un artículo que escribí hace mucho tiempo, y que decidí rescatar y actualizar un poco. Si se dan cuenta habla sobre RCS y CVS en vez de SVN y GIT, pero bueno, a alguien le servirá. Pueden descargar la versión PDF con todos los artículos incluidos.

Este artículo pretende orientar un poco acerca de lo que es la programación en C++ sobre linux. Esto NO es un tutorial de referencia de C++, si lo que buscas es eso puedes buscar en el google que hay bastantes. Posiblemente ya hayas programado en C++ sobre Windows, y has utilizado algún compilador como el C++ Builder de Borland, el Visual Studio de Microsoft o en el mejor de los casos DevC++.

Ok, esto es un buen comienzo. Pero lo que aquí vamos a ver es: qué nos proporciona Linux para programar en C++. Como sabes en Linux las cosas ya no son tan fáciles, pero tampoco difíciles; de hecho C++ es famoso gracias a Linux, son como uña y mugre. La cuestión es que nos centraremos en la programación desde la consola. Si lo tuyo no es la consola puedes echarle un vistazo a la sección que trata sobre Anjuta, que es un IDE para C++ en Linux, pero te recomiendo que leas todo el artículo, te aseguro que te servirá.

Vamos a tratar los siguientes temas (y talvez algunos más):

• Editores
• Compiladores
• Bibliotecas y enlace
• Creación de archivos ejecutables con make
• Depuración con gdb
• Control de versiones con RCS y CVS
• Creación de documentación para el comando man
• Anjuta, un IDE para Linux

Esta es realmente la base de la programación en C++: cruda, sin vestimentos, tal como es.

Descargar el tutorial completo en PDF

En C#, como en Java, u otros lenguajes de programación, es posible pasar variables a los métodos (funciones) de dos maneras: Por referencia y Por valor. La diferencia entre el uno y el otro es básicamente que:

• Cuando una variable es pasada por valor, el método recibe una copia del valor de la variable. Por lo tanto, los cambios realizados a esa variable dentro del contexto de la función, NO afecta a la variable original. Pero…
• Cuando es pasada por referencia, el método recibe la referencia a la variable original. Por tanto los cambios realizados a esa variable dentro del contexto de la función, AFECTA a la variable original.

¿Cual debo usar?

Eso depende de lo que quieras hacer. Cada una tiene sus ventajas y desventajas. Al pasar una variable por valor, estás asegurando que dicho valor no va a ser modificado por equivocación. Por otro lado, al pasar una variable por referencia, aunque la variable puede ser modificada por equivocación, ahorramos tiempo de ejecución y memoria, puesto que no es necesario crear una copia de la variable.

Pasar variables por referencia

Todas las variables que pasamos a un método declarado normalmente, son por valor. Para pasar argumentos por referencia es necesario utilizar las palabras reservada ref o out, tanto al declarar el método como al invocarlo. Cuando pasamos un argumento usando ref, es necesario que dicha variable esté ya inicializada, de lo contrario obtendremos una excepción. Si la variable que deseamos pasar por referencia no está inicializada, es nesesario usar out, de tal manera que podamos inicializar la variable dentro del contexto del método.

Ejemplo…

En el siguiente ejemplo tenemos dos variables (y Y z), las cuales son procesadas por métodos que reciben variables por valor y por referencia. El resultado y el código son:

// Demostración de paso por valor y referencia
using System;
using System.Drawing;
using System.Windows.Forms;
namespace ValorReferencia
{
   public class ValorReferencia : Form
   {
      private Button mostrarSalida;
      private Label etiquetaResultado;
      public ValorReferencia()
      {
         this.mostrarSalida = new Button();
         this.etiquetaResultado = new Label();
         this.SuspendLayout();
         //Boton
         this.mostrarSalida.Location = new Point(105, 8);
         this.mostrarSalida.Name = "mostrarSalida";
         this.mostrarSalida.Size = new Size(130, 23);
         this.mostrarSalida.TabIndex = 0;
         this.mostrarSalida.Text = "Mostrar salida";
         this.mostrarSalida.Click += new System.EventHandler(this.mostrarSalida_Click);
         //Label
         this.etiquetaResultado.Location = new Point(10, 40);
         this.etiquetaResultado.Name = "etiquetaResultado";
         this.etiquetaResultado.Size = new Size(272, 104);
         this.etiquetaResultado.TabIndex = 1;
         this.AutoScaleBaseSize = new Size(5, 13);
         this.ClientSize = new Size(292, 175);
         this.Controls.AddRange(new Control[] {
            this.etiquetaResultado,
            this.mostrarSalida});
         this.Name = "Formulario";
         this.Text = "Valor vs Referencia";
         this.ResumeLayout(false);
      }
      static void Main()
      {
         Application.Run(new ValorReferencia());
      }
      // x es pasado por referencia y el metodo modifica
      // el valor original de la variable
      void CuadradoRef( ref int x )
      {
         x = x * x;
      }
      // x es pasado con el parametro out que inicializa y
      // modifica el valor original de la variable
      void CuadradoOut( out int x )
      {
         x = 6;
         x = x * x;
      }
      // x pasado por valor y el metodo NO modifica
      // el valor original de la variable
      void Cuadrado( int x )
      {
         x = x * x;
      }
      private void mostrarSalida_Click(
         object sender, System.EventArgs e )
      {
         int y = 5; // crear nuevo entero e inicializarlo a 5
         int z;     // declarar z, pero no incializarlo
         // mostrar valores originales de 'y' y 'z'
         etiquetaResultado.Text = "Valor original de y: " + y + "\n";
         etiquetaResultado.Text += "Valor original de z: uninitialized\n\n";
         // pasar 'y' y 'z' por referencia
         CuadradoRef( ref y );
         CuadradoOut( out z );
         // mostrar valores de 'y' y 'z' despues
        // de ser modificados por CuadradoRef y CuadradoOut
         etiquetaResultado.Text += "Valor de y despues de CuadradoRef: " + y + &uot;\n";
         etiquetaResultado.Text += "Valor de z despues de CuadradoOut: " + z + "\n\";
         // pasar y y z por valor
         Cuadrado( y );
         Cuadrado( z );
         // mostrar que los valores no han cambiado
         etiquetaResultado.Text += "Valor de y despues de Cuadrado: " + y + &uot;\n";
         etiquetaResultado.Text += "Valor de z despues de Cuadrado: " + z + "\n";
      } // end method mostrarSalida_Click
   }
}

Descargar

• Código fuente simplificado
• Código fuente original

Hace tiempo discutía con algunas personas la mejor manera de usar Mono tanto en el escritorio Linux como en Windows. Me refiero al momento de escoger entre Windows Forms y Gtk#, para desarrollar aplicaciones con interfaz gráfica. Personalmente pienso que la mejor opción es, inclinándome hacia el lado del software libre, usar Mono + Gtk#. Claro, eso también depende de tus gustos como desarrollador y, más importante aún, de las necesidades del proyecto a realizar.

Lo que quiero enseñarles en esta entrada es cómo se pueden tomar diferentes caminos, y aclarar algunas dudas que me han planteado ciertos lectores. Siendo así, vamos a tomar como ejemplo a dos programas sencillos: el primero usando Gtk# y corriendo tanto en Linux como Windows, y el otro usando Windows Forms corriendo tanto en Windows como Linux.

Desarrollando y ejecutando aplicaciones Gtk# y Windows Forms usando Mono

Antes de comenzar con los ejercicios, veamos qué necesitamos para desarrollar y ejecutar aplicaciones que usen Gtk# y Windows Forms. Es necesario (obviamente) tener dicho framework instalado; afortunadamente, la mayoría de las distribuciones Gnu/Linux actuales tienen los paquetes necesarios en los repositorios, e incluso vienen con lo necesario para ejecutar aplicaciones desarrolladas con Mono (como Tomboy, Fspot o Banshee). Para compilar aplicaciones C# para mono es necesario utilizar el CSharp Compiler (cms).

También, es posible descargar mono para los más importantes sistemas operativos, incluyendo por supuesto sistemas Microsoft Windows. Para tal caso es posible descargar una versión completa (Mono + Gtk# + XSP), o tan solo el intérprete + Gtk# para un Framework .NET ya instalado sobre el ordenador.

Código del programa que usa Gtk#

//Ejemplo GTK (EjemploGtk.cs)
using Gtk;
using System;
class EjemploGtk {
static void Main()
{
Application.Init ();
//Crear el boton
Button btn = new Button (“Hola monito!”);
//Asignar un evento al evento Clic del boton
btn.Clicked += new EventHandler (hola);
//Crear el objeto ventana
Window ventana = new Window (“Lindo primate!”);
//Asignar un metodo al evento Cerrar ventan
ventana.DeleteEvent += new DeleteEventHandler (cerrar_ventana);
//Asigna el ancho y alto de la ventana
ventana.DefaultWidth = 200;
ventana.DefaultHeight = 60;
//Anyadir el boton a la ventana
ventana.Add (btn);
//Mostrar la ventana
ventana.ShowAll ();
//Ejecutar la aplicacion
Application.Run ();
}
static void cerrar_ventana (object obj, DeleteEventArgs args)
{
Application.Quit ();
}
static void hola (object obj, EventArgs args)
{
Console.WriteLine(“Lindo monito!”);
Application.Quit ();
}
}

Para compilarlo y ejecutarlo puedes usar los siguientes comandos:

mcs -pkg:gtk-sharp-2.0 EjemploGtk.cs
mono EjemploGtk.exe

El resultado es el mismo tanto en Linux como en Windows:

Código del programa que usa Windows Forms

Este programa hace exactamente lo mismo que el anterior, pero esta vez usando Windows Forms para la interfaz gráfica:

//Ejemplo Windows Forms (EjemploWinForms.cs)
using System.Drawing;
using System.Windows.Forms;
using System;
class EjemploWinForms : Form{
static void Main(){
Application.Run(new EjemploWinForms());
}
public EjemploWinForms() {
//Crear e iniciar el boton, y sus propiedades
Button boton = new Button();
boton.Location = new Point(0, -1);
boton.Name = “boton”;
boton.Size = new System.Drawing.Size(193, 60);
boton.TabIndex = 0;
boton.Text = “Botoncito”;
//Asignar un evento al evento Clic del boton
boton.Click += new System.EventHandler(hola);
//Indicar el tamanyo de la ventana
ClientSize = new System.Drawing.Size(193, 60);
//Anyadir el boton
Controls.Add(boton);
Text = “Ventanita”;
ResumeLayout(false);
}
private void hola(object sender, EventArgs e) {
Console.WriteLine(“Un mensajito!”);
Close ();
}
}

Para compilarlo y ejecutarlo puedes usar los siguientes comandos:

mcs -r:System.Drawing.dll,System.Windows.Forms.dll EjemploWinForms.cs
mono EjemploWindowsForms.exe

El resultado es el mismo tanto en Linux como en Windows:

Consideraciones a tener en cuenta

Al momento de desarrollar aplicaciones con GUIs en C# de manera rápida, tenemos basicamente dos opciones:

• Podemos usar Monodevelop que incluye un editor de interfaces gráficas basado en Stetic y que por supuesto desarrolla dichas interfaces bajo Gtk#.
• O usar el editor de interfaces de Microsoft Visual Studio que, aunque no es libre, he de reconocer que es bastante bueno y completo. En este caso las aplicaciones correrían usando Windows Forms.

Por supuesto, si deseamos usar Mono como plataforma de desarrollo no vale la pena usar herramientas Microsoft. De hecho, opino que el framework de Mono incluye librerías para ejecutar aplicaciones que usen Windows Forms, no con el fin de desarrollar aplicaciones que usen dichas librerías, sino para facilitar la migración de proyectos existentes hacia Mono.

Enlaces interesantes

• Página oficial del proyecto Mono
• Página oficial de Monodevelop
• Ejemplos de programación C#

Descargar código fuente de los ejemplos

De nuevo online, después de que de nuevo se me agotara el ancho de banda (puto hosting). Al grano… desde hace un tiempo que he seguido por el lector de feeds al blog Gigacode, y la verdad me parece que Carlos (colombiano como yo!) hace un trabajo realmente estupendo. De sus últimas entradas interesantes destaco:

• Coleccion de manuales de linux pdf
• Programación en C++ para principiantes
• Coleccion de Manuales,Tutoriales en java , J2ME
• 8 lenguajes de programación que deberías aprender

Sin duda un gran sitio para iniciarse en el maravilloso mundo de la programación!

Enlace directo: Gigacode | Feeds

En ejemplos anteriores hemos creado clases que heredan de la clase Thread las cuales soportan subprocesamiento múltiple; y sobreescribimos el método run para especificar las tareas a realizar concurrentemente. Sin embargo, puesto que en Java NO existe la herencia múltiple (como en C++) ¿cómo podemos hacer entonces que una clase, que ya hereda de otra distinta a Thread, soporte subprocesamiento múltiple? La respuesta es sencilla: implementar la interfaz Runnable. De hecho la clase Thread implementa a Runnable.

Al implementar la interfaz Runnable en una clase, un objeto puede manipular objetos de esa clase como objetos Runnable. Y tal como cuando heredamos de Thread, debemos declarar y sobrecargar el método run().

Cuando una clase utiliza un objeto Runnable para manipular subprocesos, este crea un objeto Thread y asocia el objeto Runnable con ese objeto Thread (¿enredado? para nada; sigue leyendo y verás que es muy sencillo). La clase Thread posee constructores que pueden recibir objetos Runnable, por ejemplo el constructor

public Thread(Runnable objetoRunnable)

especifica que el método run() del objeto objetoRunnable es el que debe invocarse cuando el subproceso comience a ejecutarse. Por otro lado, el construtor

public Thread(Runnable objetoRunnable, String nombreHilo)

crea un objeto Thread con el nombre nombreHilo, y especifica que el método run() del objeto objetoRunnable es el que debe invocarse cuando el subproceso comience a ejecutarse. ¡Veamos un ejemplo para entender mejor!

Código fuente

El siguiente applet (CaracteresAleatorios.java) demuestra el uso de la interfaz Runnable:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class CaracteresAleatorios extends JApplet implements ActionListener {
   private String alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   private final static int TAMANIO = 3;
   private JLabel salidas[];
   private JCheckBox casillasVerificacion[];
   private Thread subprocesos[];
   private boolean suspendido[];
   // configurar la GUI y establecer arreglos
   public void init()
   {
      salidas = new JLabel[ TAMANIO ];
      casillasVerificacion = new JCheckBox[ TAMANIO ];
      subprocesos = new Thread[ TAMANIO ];
      suspendido = new boolean[ TAMANIO ];
      Container contenedor = getContentPane();
      contenedor.setLayout( new GridLayout( TAMANIO, 2, 5, 5 ) );
      // crear componentes de la GUI, registrar componentes de escucha y adjuntar
      // componentes al panel de contenido
      for ( int cuenta = 0; cuenta < TAMANIO; cuenta++ ) {
         salidas[ cuenta ] = new JLabel();
         salidas[ cuenta ].setBackground( Color.GREEN );
         salidas[ cuenta ].setOpaque( true );
         contenedor.add( salidas[ cuenta ] );
         casillasVerificacion[ cuenta ] = new JCheckBox( "Suspendido" );
         casillasVerificacion[ cuenta ].addActionListener( this );
         contenedor.add( casillasVerificacion[ cuenta ] );
      }
   } // fin del método init
   // crear e iniciar subprocesos cada vez que se hace una llamada a start (es decir, después de
   // init y cuando el usuario vuelve a visitar la página Web que contiene a este subprograma)
   public void start()
   {
      for ( int cuenta = 0; cuenta < subprocesos.length; cuenta++ ) {

         // crear objeto Thread; inicializar objeto que implementa a Runnable
         subprocesos[ cuenta ] =
            new Thread( new ObjetoRunnable(), "Subproceso " + ( cuenta + 1 ) );

         subprocesos[ cuenta ].start(); // empezar la ejecución del objeto Thread
      }
   }
   // determinar ubicación del subproceso en el arreglo subprocesos
   private int obtenerIndice( Thread actual )
   {
      for ( int cuenta = 0; cuenta < subprocesos.length; cuenta++ )
         if ( actual == subprocesos[ cuenta ] )
            return cuenta;

      return -1;
   }
   // este método se llama cuando el usuario cambia de páginas Web; detiene todos los subprocesos
   public synchronized void stop()
   {
      // establecer referencias en null para terminar el método run de cada subproceso
      for ( int cuenta = 0; cuenta < subprocesos.length; cuenta++ )
         subprocesos[ cuenta ] = null;
      notifyAll(); // notificar a todos los subprocesos en espera, para que puedan terminar
   }
   // manejar eventos de botón
   public synchronized void actionPerformed( ActionEvent evento )
   {
      for ( int cuenta = 0; cuenta < casillasVerificacion.length; cuenta++ ) {
         if ( evento.getSource() == casillasVerificacion[ cuenta ] ) {
            suspendido[ cuenta ] = !suspendido[ cuenta ];
            // cambiar color de la etiqueta al suspender/reanudar
            salidas[ cuenta ].setBackground(
               suspendido[ cuenta ] ? Color.RED : Color.GREEN );
            // si el subproceso se reanudó, asegurarse de que empiece a ejecutarse
            if ( !suspendido[ cuenta ] )
               notifyAll();
            return;
         }
      }
   } // fin del método actionPerformed
   // clase interna privada que implementa a Runnable para controlar los subprocesos
   private class ObjetoRunnable implements Runnable {
      // colocar caracteres aleatorios en la GUI, las variables subprocesoActual e
      // indice son finales, para poder usarlas en una clase interna anónima
      public void run()
      {
         // obtener referencia al subproceso en ejecución
         final Thread subprocesoActual = Thread.currentThread();
         // determinar la posición del subproceso en el arreglo
         final int indice = obtenerIndice( subprocesoActual );
         // la condición del ciclo determina cuándo debe detenerse el subproceso; el ciclo
         // termina cuando la referencia subprocesos[ indice ] se vuelve null
         while ( subprocesos[ indice ] == subprocesoActual ) {
            // estar inactivo de 0 a 1 segundo
            try {
               Thread.sleep( ( int ) ( Math.random() * 1000 ) );
               // determinar si el subproceso debe suspender su ejecución;
               // sincronizar con el objeto de subprograma CaracteresAleatorios
               synchronized( CaracteresAleatorios.this ) {
                  while ( suspendido[ indice ] &amp;&amp;
                     subprocesos[ indice ] == subprocesoActual ) {
                     // suspender temporalmente la ejecución del subproceso
                     CaracteresAleatorios.this.wait();
                  }
               } // fin del bloque synchronized
            } // fin de bloque try
            // si el subproceso se interrumpió durante su espera/inactividad, imprimir el rastreo de la pila
            catch ( InterruptedException excepcion ) {
               excepcion.printStackTrace();
            }
            // mostrar caracter en objeto JLabel correspondiente
            SwingUtilities.invokeLater(
               new Runnable() {
                  // elegir caracter aleatorio y mostrarlo
                  public void run()
                  {
                     char mostrarChar =
                        alfabeto.charAt( ( int ) ( Math.random() * 26 ) );
                     salidas[ indice ].setText(
                        subprocesoActual.getName()  + ": " + mostrarChar );
                  }
               } // fin de la clase interna
            ); // fin de la llamada a SwingUtilities.invokeLater
         } // fin de instrucción while
         System.err.println( subprocesoActual.getName() + " terminando" );
      } // fin del método run
   } // fin de la clase interna privada ObjetoRunnable
} // fin de la clase CaracteresAleatorios

El código del archivo HTML que ejecuta el applet de Java es:

<html>
<applet code="CaracteresAleatorios.class" width=275 height=90>
</applet>
</html>

Descargar código fuente