¡Hola de nuevo! En esta ocasión me gustaría compartir con ustedes este video tutorial acerca de MonoDevelop. No es nada avanzado, solo muestra algunas características de este IDE. El video en cuestión lo grabé hace más o menos siete meses, pero casualmente había olvidado que lo había grabado Y, aunque ya vamos en la versión 2 de MonoDevelop, no quiero perder el trabajo que alguna vez hice.

Como siempre, pueden encontrar el vídeo en Youtube o en Vimeo. Aunque creo que hay un pedazo que se ve feo y el sonido no es el mejor, espero que les guste y disculpen lo feo

Existen dos maneras de definir constantes en C Sharp: usando const o readonly. Cuando se usa const, es posible acceder a la variable directamente desde la clase (sin instanciar un objeto), como si se tratase de un atributo estático; mientras que con readonly, es un tipo de constantes que funciona como un atributo normal, y que una vez inicializada no se le puede cambiar el valor.

Veamos un ejemplo sencillo para aclararnos:

using System;
public class Constantes {
  // crear constante PI
  public const double PI = 3.14159;
  // radio es una constante esta sin iniciar
  public readonly int radio;
  public Constantes( int radioValue ) {
     radio = radioValue;
  }
}
// Clase UsarConstantes
public class UsarConstantes {
  // metodo Main crea un objeto de tipo 'Constantes'
  // y muestra los valores
  static void Main( string[] args ) {
     Random random = new Random();
     Constantes valoresConstantes =
        new Constantes( random.Next( 1, 20 ) );
     Console.WriteLine( "Radio = " + valoresConstantes.radio +
        "\nCircunferencia = " +
        2 * Constantes.PI * valoresConstantes.radio);
  }
}

Resultado…

Descargar código fuente

Las variables estáticas son atributos de una clase que están disponibles para todas las instancias de dicha clase, y a los cuales puedes acceder directamente (sin instanciar un objeto) de la forma Clase.Variable.

Los destructores son métodos que se ejecutan cuando se elimina un objeto; son especialmente útiles si deseamos hacer algo en particular, antes de eliminar la referencia al objeto. A continuación un sencillo ejercicio, en donde se ejemplifica el uso de las variables estáticas y de los destructores en C Sharp:

using System;
namespace Estatico{
   public class Clase {
      //un atributo normal
      private string variable;
      //esta variable esta disponible para todas
      //las instancias de esta clase
      private static int contador;
      //constructor
      public Clase(string x) {
         variable = x;
         //aumentar valor de la variable estatica
         ++contador;
         Console.WriteLine("Constructor de "+variable);
      }
      ~Clase(){
         --contador;
         Console.WriteLine("Se destruyo una de las instancias ("+variable+")"+contador);
      }
      public static int Contador{
         get{
            return contador;
         }
      }
   }
}

Clase que utiliza los valores estáticos de la clase anterior:

using System;
namespace Estatico{
   public class Principal{
      static void Main(string[] args){
         Console.WriteLine("Contador antes de crear objetos: "+Clase.Contador);
         //crear 2 instancias de la clase
         Clase objeto1 = new Clase("primero");
         Clase objeto2 = new Clase("segundo");
         Console.WriteLine("Contador despues de crear objetos: "+Clase.Contador);
         //eliminar referencias a los objetos
         objeto1 = null;
         objeto2 = null;
         //forzar al recolector de basura a ejecutarse
         System.GC.Collect();
         //esperar hasta que el recolector de basura termine su trabajo
         System.GC.WaitForPendingFinalizers();
         //despues de la recolecta de basura...
         Console.WriteLine("Despues de la recolecta de basura, contador: "+Clase.Contador);
      }
   }
}

Descargar código fuente

Al momento de acceder a los atributos de una clase, podemos usar métodos para asignar y obtener dichos datos (normalmente llamados getters y setters). En C Sharp podemos usar una caracterí­stica llamada ‘propiedades’, por medio de la cual declaramos un alias de acceso público para los atributos de acceso privado.

Me explico. Cuando declaramos atributos en una clase, lo más aconsejable es crearlos con el modificador de acceso private. Por tal motivo no es posible acceder a dichos atributos directamente desde el objeto (de la manera: objeto.atributo), porque como vimos en esta entrada nos arrojará errores de compilación.

Aquí­ es cuando las ‘propiedades’ son especialmente útiles. Una propiedad es como un alias que nos permite acceder a los atributos de manera segura, y con la que nos ahorramos tiempo y espacio en nuestro código. Vamos directamente con un ejemplo, y posteriormente una breve explicación del mismo.

Clase de ejemplo, que implementa una ‘propiedad’ para acceder al atributo:

public class Clase {
	//atributo
	private int variable;
	//constructor
	public Clase(int variable) {
		this.variable = variable;
	}
	//declaracion de la propiedad
	public int atributo{
		//get sirve para devolver el valor del atributo
		get{
			return variable;
		}
		//set sirve para cambiar el valor del atributo
		set{
			variable = value;
		}
	}
}

En la lí­nea 9 tenemos la declaración de la propiedad; en dicha declaración debemos especificar un nombre (diferente al del atributo al que vamos a acceder), y un tipo (en este caso int, entero). Dentro de la propiedad tenemos dos bloques: get y set. Dentro de get debemos poner los valores a retornar cuando se acceda a la propiedad; mientras que en set podemos usar la palabra clave value para asignar un valor al atributo.

En la siguiente clase se utiliza la propiedad de la clase anterior, para obtener y modificar los valores del atributo:

using System;
public class Propiedades {
	public Propiedades() {
		//declaracion del objeto
		Clase objeto = new Clase(5);
		//obteniendo el valor de la variable 'variable'
		//usando la propiedad 'atributo' (se usa el bloque get)
		Console.WriteLine("El atributo del objeto es "+ objeto.atributo);
		Console.WriteLine("Cambiando el valor usando la propiedad 'atributo'...");
		//cambiando el valor de la variable 'variable'
		//usando la propiedad 'atributo' (se usa get)
		objeto.atributo = 10;
		Console.WriteLine("Ahora el atributo del objeto es "+ objeto.atributo);
	}
	static void Main(string[] args){
		new Propiedades();
	}
}

Como puedes observar, es posible obtener y modificar los datos de un atributo privado usando una ‘propiedad’ pública, y todo de una manera totalmente segura, puesto que dentro de la ‘propiedad’ podemos verificar la consistencia de los datos.

El resultado…

Descargar código fuente

En el siguiente ejemplo se muestra cómo realizar búsquedas dentro de un arreglo de manera lineal.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
namespace BusquedaLineal
{
   public class BusquedaLineal : Form
   {
      private Button botonBuscar;
      private TextBox cajaEntrada;
      private Label labelSalida;
      int[] a = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26,
                  28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50 };
      public BusquedaLineal()
      {
         InitializeComponent();
      }
      private void InitializeComponent()
      {
         this.botonBuscar = new Button();
         this.cajaEntrada = new TextBox();
         this.labelSalida = new Label();
         this.SuspendLayout();
         //
         // botonBuscar
         //
         this.botonBuscar.Location = new System.Drawing.Point(8, 8);
         this.botonBuscar.Name = "botonBuscar";
         this.botonBuscar.TabIndex = 0;
         this.botonBuscar.Text = "Buscar";
         this.botonBuscar.Click += new System.EventHandler(this.botonBuscar_Click);
         //
         // cajaEntrada
         //
         this.cajaEntrada.Location = new System.Drawing.Point(96, 9);
         this.cajaEntrada.Name = "cajaEntrada";
         this.cajaEntrada.Size = new System.Drawing.Size(88, 20);
         this.cajaEntrada.TabIndex = 1;
         this.cajaEntrada.Text = "";
         //
         // labelSalida
         //
         this.labelSalida.Location = new System.Drawing.Point(8, 40);
         this.labelSalida.Name = "labelSalida";
         this.labelSalida.Size = new System.Drawing.Size(184, 23);
         this.labelSalida.TabIndex = 2;
         //
         // BusquedaLineal
         //
         this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
         this.ClientSize = new System.Drawing.Size(200, 69);
         this.Controls.AddRange(new Control[] {
                  this.labelSalida,
                  this.cajaEntrada,
                  this.botonBuscar});
         this.Name = "BusquedaLineal";
         this.Text = "BusquedaLineal";
         this.ResumeLayout(false);
      }
      static void Main()
      {
         Application.Run(new BusquedaLineal());
      }
      private void botonBuscar_Click( object sender,
         System.EventArgs e )
      {
         int datoBuscar = Int32.Parse( cajaEntrada.Text );
         int indiceElemento = BuscarLineal( a, datoBuscar );
         if ( indiceElemento != -1 )
            labelSalida.Text =
               "Encontrado en el indice " + indiceElemento;
         else
            labelSalida.Text = "Valor no encontrado";
      } // fin del metodo botonBuscar_Click
      // buscar valor dentro del array
      public int BuscarLineal( int[] array, int dato )
      {
         for ( int n = 0; n < array.Length; n++ )
         {
            if ( array[ n ] == dato )
               return n;
         }
         return -1;
      } // fin del metodo BusquedaLineal
   }
}

Descargar código fuente

En el siguiente ejemplo se muestra cómo realizar el ordenamiento de arreglos de enteros, usando el método burbuja en C#.

Ejemplo…

using System;
public class OrdenamientoBurbuja
{
  static void Main()
  {
     int[] a =  { 54, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
     string salida = "Valores de los items originales\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     // ordenar elementos del arreglo
     OrdenarBurbuja( a );
     salida += "\n\nValores de los items en orden descendente\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     Console.WriteLine(salida);
  } // fin del metodo main
  // ordenar elementos de un arreglo con el metodo burbuja
  static public void OrdenarBurbuja( int[] b )
  {
     for ( int pasadas = 1; pasadas < b.Length; pasadas++ ) // pasadas
        for ( int i = 0; i < b.Length - 1; i++ )
           if ( b[ i ] > b[ i + 1 ] )      // comparar
              intercambio( b, i );         // intercambiar
  }
  // intercambio de dos elementos en un arreglo
  static public void intercambio( int[] c, int primero )
  {
     int temp;      // variable temporal para el intercambio
     temp = c[ primero ];
     c[ primero ] = c[ primero + 1 ];
     c[ primero + 1 ] = temp;
  }
}

Resultado…

Descargar código fuente

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