¡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

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?

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

Me entero en Barrapunto que el desarrollo de WinForms 2.0 para Mono ya se ha completado y que los 12,776 métodos que constituyen su API pública son exactamente los mismos que los de .NET. El toolkit está compuesto por 115.000 líneas de código fuente y ha costado 4 años de desarrollo (desde el 8 de julio de 2004). Actualmente están soportados los backends para X11, OSX y Win32. WinForms 2.0 era la última pieza del puzzle que había que completar antes de la publicación de Mono 2.0.

Sin duda una excelente noticia para el mundo del software libre, y para la gente que está pensando en migrar las aplicaciones que usen WindowsForms a entornos libres.

Relacionadas:

•  Aplicaciones con GUI en .NET: ¿Gtk# o Windows Forms?

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

El equipo de desarrollo de MonoDevelop ha liberado la versión 1.0 de este IDE para Mono, un implementación libre de .NET para plataformas Linux y MacOSX. Sin duda una buena noticia para los usuarios de esta plataforma, y en general para la comunidad de software libre.

Anuncio |  Ver las características de este IDE

Demostración de un metodo definido por el usuario para elevar al cuadrado un número

Lo que es interesante aquí, es ver como la aplicación corre de igual forma tanto en Windows como en Gnu/Linux:

Código fuente:

// Demostracion de un metodo definido por el usuario para elevar al cuadrado un numero.
using System;
using System.Windows.Forms;
namespace ElevarCuadrado
{
    public class Ventana : Form
    {
        private Button botonCalcular;
        private Label labelSalida;

        public Ventana()
        {
            InitializeComponent();
        }

        private void InitializeComponent()
        {
            this.botonCalcular = new Button();
            this.labelSalida = new Label();
            this.SuspendLayout();
            //
            // botonCalcular
            //
            this.botonCalcular.Location = new System.Drawing.Point(32, 8);
            this.botonCalcular.Name = "botonCalcular";
            this.botonCalcular.Size = new System.Drawing.Size(120, 23);
            this.botonCalcular.TabIndex = 0;
            this.botonCalcular.Text = "Calcular Cuadrados";
            this.botonCalcular.Click += new System.EventHandler(this.botonCalcular_Click);
            //
            // labelSalida
            //
            this.labelSalida.Location = new System.Drawing.Point(16, 48);
            this.labelSalida.Name = "labelSalida";
            this.labelSalida.Size = new System.Drawing.Size(152, 144);
            this.labelSalida.TabIndex = 1;
            //
            // Ventana
            //
            this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
            this.ClientSize = new System.Drawing.Size(189, 201);
            this.Controls.Add(this.labelSalida);
            this.Controls.Add(this.botonCalcular);
            this.Name = "Ventana";
            this.Text = "Elevar al cuadrado";
            this.ResumeLayout(false);

        }

        [STAThread]
        static void Main()
        {
            Application.Run(new Ventana());
        }

        // Definicion del metodo ElevarCuadrado
        int ElevarCuadrado(int y)
        {
            return y * y; // retornar cuadrado de y

        } // fin del metodo ElevarCuadrado

        private void botonCalcular_Click(object sender, System.EventArgs e)
        {
            labelSalida.Text = "";

            // repetir diez veces
            for (int contador = 1; contador <= 10; contador++)
            {
                // calcular cuadrado de contador y guardar en resultado
                int resultado = ElevarCuadrado(contador);

                // añadir resulatdo a labelSalida
                labelSalida.Text += "El cuadrado de " + contador +
                   " es " + resultado + "\n";
            }

        } // fin del metodo botonCalcular_Click

    } // fin de la clase
}

Descargar código fuente

Desarrollo de aplicaciones .NET usando el Entorno de Desarrollo Integrado: MonoDevelop

Continuando con el tema del desarrollo de aplicaciones en la plataforma .NET, específicamente usando el lenguaje de programación C#, les mostraré un ejemplo del uso de MonoDevelop, un IDE de programación especial para trabajar con la plataforma libre .NET: Mono.

La idea de este documento es mostrar algunas características importantes para el desarrollo de aplicaciones usando este IDE de programación, para lo cual vamos a crear paso a paso una aplicación muy bí¡sica, en donde aprenderemos a implementar clases y a referenciar librerías.

Lo primero es descargar el MonoDevelop. Puedes descargar las fuentes y compilarlas tu mismo, o buscar algún paquete para tu distribución (.deb, .rpm, etc.), aunque si no quieres liarte tal vez querrás usar openSuse, que te permite instalarlo desde los CDs de instalación. Una vez instalado, lo ejecutamos y veremos algo como lo siguiente:

Como puedes ver su interfaz es limpia y agradable, y si ya has usado cualquier otro IDE te resultará bastante fácil acostumbrarte a éste. Ahora, vamos a crear un nuevo proyecto: “Archivo >> Nuevo Proyecto“. En esta parte debemos seleccionar el tipo de proyecto a desarrollar (en este caso va a ser un Proyecto vacío de C#), su nombre, la ubicación donde lo guardaremos, etc.:

Le damos clic en Adelante, y luego en Finalizar (en esta parte habrá aparecido algunas otras opciones avanzadas que no trataremos en este documento). Ahora vamos a crear un nuevo archivo: Clic derecho en la raíz de la solución, Añadir >> Nuevo archivo…:

En este punto podemos escoger varios tipos de archivo, pero para este ejemplo seleccionamos General, luego Clase vacía y digitamos el nombre de nuestra nueva clase:

MonoDevelop creará el archivo y escribirá una estructura base para la aplicación (importar el namespace System, crear nuestro namespace, crear la clase, crear el constructor). Ahora ya podemos comenzar a editar nuestra clase:

Nuestro clase tendrá, al principio, lo siguiente:

// Ejemplo.cs creado con MonoDevelop
// Usuario: casidiablo a las 14:48 de la fecha 15/12/2007
//

using System;

namespace EjemploMono
{
    public class Ejemplo
    {

        public Ejemplo()
        {
            Console.WriteLine("Este es el constructor");
        }
        static void Main(string[] args)
        {
            new Ejemplo();
        }
    }
}

Vamos entonces a ver algunas características interesantes que nos ofrece MonoDevelop al codificar nuestras clases:

Auto-completamiento de código en clases del estándar:

Luego de escribir una clase, en este caso la clase Console, al teclear la tecla punto (para llamar a alguna función de esa clase) se desplegará un menú donde aparecerá la lista de los métodos de la clase:

Compilando el código

Para compilar nuestro proyecto: Proyecto >> Construir solución o presionamos F8, con lo cual podremos probar y depurar nuestra solución:

En la parte de abajo podremos ver información acerca de la compilación del archivo:

Si por ejemplo tenemos un error en el código fuente, veremos algo como lo siguiente:

Ejecutar nuestra aplicación

Para probar nuestro proyecto: Proyecto >> Ejecutar o presionamos F5, con lo cual podremos ejecutar nuestra solución:

¡ Ahora usemos el API de Windows Forms para mostrar un cuadro de dialogo !

Vamos a modificar nuestra aplicación para usar el API de Windows Forms, con la cual podremos crear aplicaciones con interfaces gráficas que podrán correr sin ningún problema sobre plataformas Windows.

Lo primero es añadir la referencia a las librerías de Windows Forms (System.Windows.Forms), para lo cual le damos clic derecho en la carpeta Referencias en el visor de la solución y luego clic en Editar referencias…:

Seleccionamos el paquete System.Windows.Forms y damos clic en Aceptar:

Debemos usar el namespace System.Windows.Forms, y podemos darnos cuenta que, después de referenciar el paquete, al declarar el paquete podemos usar el auto-completamiento de código:

Además, el auto-completamiento de código lo podemos usar para ver lo métodos de una determinada clase, y los parámetros que debemos enviarle. Por ejemplo, vamos a crear un método llamado mostrarMensaje(), en donde usaremos la clase MessageBox para mostrar un cuadro de dialogo. Fijémonos cómo MonoDevelop nos indica los parámetros que debemos pasarle al método Show():

MonoDevelop no solo te ayuda auto-completando los métodos de librerías ajenas, sino que nos proporciona esta útil funcionalidad en nuestros propios métodos:

Al final nuestro código tendrá el siguiente contenido:

// Ejemplo.cs creado con MonoDevelop
// Usuario: casidiablo a las 14:48 de la fecha 15/12/2007
//

using System;
using System.Windows.Forms;

namespace EjemploMono
{
    public class Ejemplo
    {

        public Ejemplo()
        {
            Console.WriteLine("Este es el constructor");
        }
        public void mostrarMensaje()
        {
            MessageBox.Show("Este es el texto", "Y este el titulo");
        }
        static void Main(string[] args)
        {
            new Ejemplo().mostrarMensaje();
        }
    }
}

Al ejecutarlo veremos lo siguiente:

¿Porqué usar Windows Forms en vez de Gtk? ¿Qué no te gustaba el software libre y tal?

Como programadores, y aunque amemos las filosofías del software libre, tenemos que estar al tanto de todo cuanto nos sea posible, y esto irremediablemente nos “obliga” a que aprendamos a desarrollar software para sistemas Microsoft Windows. Desafortunadamente, Microsoft tiene una GRAN cuota en el mercado, y por tanto debemos estar preparados para crear e implementar aplicaciones compatibles con sus sistemas operativos.

Si estás interesado en estos temas, seguro tienes una gran ventaja sobre los desarrolladores de software pro-Microsoft, que solo aprenden lo estrictamente necesario. Usando herramientas como Mono, no solo eres LIBRE sino que tienes un panorama muchísimo más amplio para el desarrollo de soluciones de software. No desaproveches la oportunidad.

Un saludo!

Descagas:

• Descargar este artículo en formato PDF
• Descargar este artículo en formato ODT, para que puedas editarlo

Ya tratabamos antes la instrucción if y while en C#… ahora vamos a tratar más instrucciones de control. Los programas corren tanto en plataformas Microsoft usando Visual Studio, como en cualquier otra plataforma usando Mono. Tal vez quieras visitar leer estas entradas: Cómo crear aplicaciones en C# usando Visual Studio o C#, crear una aplicación usando Mono.Tal como pueden apreciar, los en ejemplos se muestra cómo compilar y ejecutar con Mono, pero si lo que quieres es hacerlo con Visual Studio, no te preocupes, aquí te explico como se hace.

Repeticion controlada por contador usando While

using System;
class ContadorWhile
{
	static void Main( string[] args )
	{
		int contador = 1;          // initialización
		while ( contador <= 5 )    // repetición condition
		{
			Console.WriteLine( contador );
			contador++;             // incremento
		} // end while
	} // fin del método Main
} // fin de la clase ContadorWhile

casidiablo@punko:~/c#> mcs ContadorWhile.cs
casidiablo@punko:~/c#> mono ContadorWhile.exe
1
2
3
4
5

Descargar código fuente

Repetición controlada por contador usando la estructura for

using System;
class ContadorFor
{
   static void Main( string[] args )
   {
      // inicialización ; condición de repetición ; incremento
      for ( int contador = 1; contador <= 5; contador++ )
         Console.WriteLine( contador );
   }
}

casidiablo@punko:~/c#> mcs ContadorFor.cs
casidiablo@punko:~/c#> mono ContadorFor.exe
1
2
3
4
5

Descargar código fuente

Sumatoria usando la estructura for

using System;
using System.Windows.Forms;
class SumaDialogo
{
	static void Main( string[] args )
	{
		int suma = 0;
		for ( int numero = 2; numero <= 100; numero += 2 )
			suma += numero;
		MessageBox.Show( "La suma es " + suma,
				 "Sumando cada entero desde 2 hasta 100",
				 MessageBoxButtons.OK,
				 MessageBoxIcon.Information );
	} // fin del método Main
} // fin de la clase SumaDialogo

casidiablo@punko:~/c#> mcs -reference:/usr/lib/mono/1.0/System.Windows.Forms.dll SumaDialogo.cs
casidiablo@punko:~/c#> mono SumaDialogo.exe

Descargar código fuente

Calculando el incremento del interés usando el for

using System;
using System.Windows.Forms;
class Interes
{
	static void Main( string[] args )
	{
		decimal cantidad, principal = ( decimal ) 1000.00;
		double porcentaje = .05;
		string salida;
		salida = "Año       Cantidad del Depósito\n";
		for ( int anio = 1; anio <= 10; anio++ )
		{
			cantidad = principal *
					( decimal ) Math.Pow( 1.0 + porcentaje, anio );
			salida += anio + "             " +
					String.Format( "{0:C}", cantidad ) + "\n";
		}
		MessageBox.Show( salida, "Aumento del Interes",
				 MessageBoxButtons.OK, MessageBoxIcon.Information );
	} // fin del método Main
} // fin de la clase Interes

casidiablo@punko:~/c#> mcs -reference:/usr/lib/mono/1.0/System.Windows.Forms.dll Interes.cs
casidiablo@punko:~/c#> mono Interes.exe

Descargar código fuente

Uso de la sentecia switc: Contando letras

using System;
class TestSwitch
{
	static void Main( string[] args )
	{
		char letra;      // una letra
		int aContador = 0, // numero de As
		bContador = 0, // numero de Bs
		cContador = 0, // numero de Cs
		dContador = 0,  // numero de Ds
		fContador = 0;  // numero de Fs
		for ( int i = 1; i <= 10; i++ )
		{
			Console.Write( "Enter a letter letra: " );
			letra = Char.Parse( Console.ReadLine() );
			switch ( letra )
			{
				case 'A':   // letra está en mayúscula A
				case 'a':   // o miníscula a
					++aContador;
					break;
				case 'B':   // letra está en mayúscula B
				case 'b':   // o miníscula b
					++bContador;
					break;
				case 'C':   // letra está en mayúscula C
				case 'c':   // o miníscula c
					++cContador;
					break;
				case 'D':   // letra está en mayúscula D
				case 'd':   // o miníscula d
					++dContador;
					break;
				case 'F':   // letra está en mayúscula F
				case 'f':   // o miníscula f
					++fContador;
					break;
				default:    // processes all other characters
					Console.WriteLine(
							"Ha digitado una letra incorrecta." +
							"\nDigite una nueva letra" );
					break;
			} // fin switch
		} // fin for
		Console.WriteLine(
				"\nLos totales para cada letra son:\nA: {0}" +
				"\nB: {1}\nC: {2}\nD: {3}\nF: {4}", aContador, bContador,
		cContador, dContador, fContador );
	} // fin del metodo Main
} // fin de la clase TestSwitch

casidiablo@punko:~/c#> mcs TestSwitch.cs
casidiablo@punko:~/c#> mono TestSwitch.exe
Enter a letter letra: a
Enter a letter letra: b
Enter a letter letra: a
Enter a letter letra: f
Enter a letter letra: c
Enter a letter letra: e
Ha digitado una letra incorrecta.
Digite una nueva letra
Enter a letter letra: A
Enter a letter letra: B
Enter a letter letra: c
Enter a letter letra: d

Los totales para cada letra son:
A: 3
B: 2
C: 2
D: 1
F: 1

Descargar código fuente

La estructura de repetición do/while

using System;
class PruebaDoWhile
{
	static void Main( string[] args )
	{
		int contador = 1;
		do
		{
			Console.WriteLine( contador );
			contador++;
		} while ( contador <= 5 );
	} // fin del método Main
} // fin de la clase PruebaDoWhile

casidiablo@punko:~/c#> mcs PruebaDoWhile.cs
casidiablo@punko:~/c#> mono PruebaDoWhile.exe
1
2
3
4
5

Descargar código fuente

Usando la sentencia break para romper un for

using System;
using System.Windows.Forms;
class PruebaBreak
{
	static void Main( string[] args )
	{
		string salida = "";
		int contador;
		for ( contador = 1; contador <= 10; contador++ )
		{
			if ( contador == 5 )
				break;           // romper el ciclo si contador == 5
			salida += contador + " ";
		} // fin del ciclo
		salida += "\nSe rompió el ciclo cuando el contador era = " + contador;
		MessageBox.Show( salida, "Demostracion de la sentencia break",
				 MessageBoxButtons.OK, MessageBoxIcon.Information );
	} // fin del método Main
} // fin de la clase PruebaBreak

casidiablo@punko:~/c#> mcs -reference:/usr/lib/mono/1.0/System.Windows.Forms.dll PruebaBreak.cs
casidiablo@punko:~/c#> mono PruebaBreak.exe

Descargar código fuente

Usando la sentencia continue en una estructura for

using System;
using System.Windows.Forms;
class PruebaContinue
{
	static void Main( string[] args )
	{
		string salida = "";
		for ( int contador = 1; contador <= 10; contador++ )
		{
			if ( contador == 5 )
				continue;       // si contador es 5 saltarse el resto
			salida += contador + " ";
		}
		salida += "\ncontinue usado cuando contador = 5";
		MessageBox.Show( salida, "Usando la sentencia continue",
		       MessageBoxButtons.OK, MessageBoxIcon.Information );
   } // fin del método Main
} // fin de la clase PruebaContinue

casidiablo@punko:~/c#> mcs -reference:/usr/lib/mono/1.0/System.Windows.Forms.dll PruebaContinue.cs
casidiablo@punko:~/c#> mono PruebaContinue.exe

Descargar código fuente

Demostracón de los operadores lógicos

using System;
class OperadoresLogicos
{
	static void Main( string[] args )
	{
		// probando el operador condicional AND (&&)
		Console.WriteLine( "Condicional AND (&&)" +
				"\nfalse && false: " + ( false && false ) +
				"\nfalse && true: " + ( false && true ) +
				"\ntrue && false: " + ( true && false ) +
				"\ntrue && true:   " + ( true && true ) );
		// probando el operador condicional OR (||)
		Console.WriteLine( "\n\nConditional OR (||)" +
				"\nfalse || false: " + ( false || false ) +
				"\nfalse || true: " + ( false || true ) +
				"\ntrue || false: " + ( true || false ) +
				"\ntrue || true:   " + ( true || true ) );
		// probando el operador logico AND (&)
		Console.WriteLine( "\n\nOperador Logico AND (&)" +
				"\nfalse & false: " + ( false & false ) +
				"\nfalse & true: " + ( false & true ) +
				"\ntrue & false: " + ( true & false ) +
				"\ntrue & true:   " + ( true & true ) );
		// probando el operador logico OR (|)
		Console.WriteLine( "\n\nOperador Logico OR (|)" +
				"\nfalse | false: " + ( false | false ) +
				"\nfalse | true: " + ( false | true ) +
				"\ntrue | false: " + ( true | false ) +
				"\ntrue | true:   " + ( true | true ) );
		// probando el operador logico exclusivo OR (^)
		Console.WriteLine( "\n\nLogico exclusivo OR (^)" +
				"\nfalse ^ false: " + ( false ^ false ) +
				"\nfalse ^ true: " + ( false ^ true ) +
				"\ntrue ^ false:  " + ( true ^ false ) +
				"\ntrue ^ true:   " + ( true ^ true ) );
		// probando el operador logico NOT (!)
		Console.WriteLine( "\n\nLogical NOT (!)" +
				"\n!false: " + ( !false ) +
				"\n!true: " + ( !true ) );
	}
}

casidiablo@punko:~/c#> mcs OperadoresLogicos.cs
casidiablo@punko:~/c#> mono OperadoresLogicos.exe
Condicional AND (&&)
false && false: False
false && true: False
true && false: False
true && true: True


Conditional OR (||)
false || false: False
false || true: True
true || false: True
true || true: True


Operador Logico AND (&)
false & false: False
false & true: False
true & false: False
true & true: True


Operador Logico OR (|)
false | false: False
false | true: True
true | false: True
true | true: True


Logico exclusivo OR (^)
false ^ false: False
false ^ true: True
true ^ false: True
true ^ true: False


Logical NOT (!)
!false: True
!true: False

Descargar código fuente

(anterior) En esta entrada pondré el código fuente de algunos programas muy básicos desarrollados en C#. Los programas corren tanto en plataformas Microsoft usando Visual Studio, como en cualquier otra plataforma usando Mono. Tal vez quieras visitar leer estas entradas: Cómo crear aplicaciones en C# usando Visual Studio o C#, crear una aplicación usando Mono.

Tal como pueden apreciar, los en ejemplos se muestra cómo compilar y ejecutar con Mono, pero si lo que quieres es hacerlo con Visual Studio, no te preocupes, aquí te explico como se hace.

Calcular promedios con contador de repeticion controlado (usando while)

using System;
class Promedios
{
	static void Main(string[] args)
	{
		int total = 0,	//resultado total de la suma de los datos
		cantidad,	//cantidad de datos a procesar
		contador=1,
		dato,		//para almacenar el dato actual dentro del ciclo
		promedio;	//promedio de los datos

		//Preguntar por el número de datos a procesar
		Console.WriteLine("¿Qué cantidad de datos vas a procesar?");
		cantidad = Int32.Parse(Console.ReadLine());

		//Iterar 'cantidad' de veces
		while(contador <= cantidad)
		{
			//Capturar dato
			Console.WriteLine("Digite el dato número "+contador+":");
			dato = Int32.Parse(Console.ReadLine());

			//Acumular los datos
			total = total + dato;

			//Aumentar el contador
			contador = contador + 1;
		}

		//Calcular el promedio
		promedio = total / cantidad;

		//Mostrar el resultado
		Console.WriteLine("El promedio de los datos ingresados es: "+promedio);
	} //fin del Main
}//fin de la clase Promedios

casidiablo@punko:~/c#> mcs Promedios.cs
casidiablo@punko:~/c#> mono Promedios.exe
¿Qué cantidad de datos vas a procesar?
6
Digite el dato número 1:
20
Digite el dato número 2:
10
Digite el dato número 3:
60
Digite el dato número 4:
80
Digite el dato número 5:
50
Digite el dato número 6:
62
El promedio de los datos ingresados es: 47

Descargar código fuente

Calcular promedios con contador de repeticion controlado por centinela (usando while)

using System;
class Promedios2
{
	static void Main(string[] args)
	{
		int total = 0,	//resultado total de la suma de los datos
		contador=1,
		dato,		//para almacenar el dato actual dentro del ciclo
		promedio;	//promedio de los datos

		//Capturar dato
		Console.WriteLine("Digite el dato número "+contador+": (-1 para detener el ciclo)");
		dato = Int32.Parse(Console.ReadLine());

		//Iterar 'cantidad' de veces
		while( dato != -1 )
		{
			//Acumular los datos
			total = total + dato;

			//Aumentar el contador
			contador = contador + 1;

			//Capturar dato
			Console.WriteLine("Digite el dato número "+contador+": (-1 para detener el ciclo)");
			dato = Int32.Parse(Console.ReadLine());
		}

		//Calcular el promedio
		promedio = total / contador;

		//Mostrar el resultado
		Console.WriteLine("El promedio de los datos ingresados es: "+promedio);
	} //fin del Main
}//fin de la clase Promedios2

casidiablo@punko:~/c#> mcs Promedios2.cs
casidiablo@punko:~/c#> mono Promedios2.exe
Digite el dato número 1: (-1 para detener el ciclo)
32
Digite el dato número 2: (-1 para detener el ciclo)
23
Digite el dato número 3: (-1 para detener el ciclo)
54
Digite el dato número 4: (-1 para detener el ciclo)
32
Digite el dato número 5: (-1 para detener el ciclo)
25
Digite el dato número 6: (-1 para detener el ciclo)
36
Digite el dato número 7: (-1 para detener el ciclo)
-1
El promedio de los datos ingresados es: 28

Descargar código fuente

Análisis de Resultados de Examenes

using System;
class Analisis
{
	static void Main( string[] args )
	{
		int bien = 0,            // numero de
		fallas = 0,          // numero de fallas
		estudiantes = 1,           // contador de estudiantes
		resultado;                // resultado de los examenes
		// procesar 10 estudiantes; loop controlado por contador
		while ( estudiantes <= 10 )
		{
			Console.Write( "Digite los resultados (1=pasó, 2=falló): " );
			resultado = Int32.Parse( Console.ReadLine() );
			if ( resultado == 1 )
				bien = bien + 1;
			else
				fallas = fallas + 1;
			estudiantes = estudiantes + 1;
		}
		// mostrar los resultados
		Console.WriteLine();
		Console.WriteLine( "Pasaron: " + bien );
		Console.WriteLine( "Fallaron: " + fallas );
	} // fin del método Main
} // fin de la clase Analisis

casidiablo@punko:~/c#> mcs Analisis.cs
casidiablo@punko:~/c#> mono Analisis.exe
Digite los resultados (1=pasó, 2=falló): 1
Digite los resultados (1=pasó, 2=falló): 2
Digite los resultados (1=pasó, 2=falló): 1
Digite los resultados (1=pasó, 2=falló): 2
Digite los resultados (1=pasó, 2=falló): 1
Digite los resultados (1=pasó, 2=falló): 2
Digite los resultados (1=pasó, 2=falló): 1
Digite los resultados (1=pasó, 2=falló): 2
Digite los resultados (1=pasó, 2=falló): 2
Digite los resultados (1=pasó, 2=falló): 1

Pasaron: 5
Fallaron: 5

Descargar código fuente

Preincremento y postincremento

using System;
class Incremento
{
	static void Main( string[] args )
	{
		int c;
		c = 5;
		Console.WriteLine( c );   // imprimir 5
		Console.WriteLine( c++ ); // imprimir 5 entonces postincremento
		Console.WriteLine( c );   // imprimir 6
		Console.WriteLine();      // saltar una línea
		c = 5;
		Console.WriteLine( c );   // imprimir 5
		Console.WriteLine( ++c ); // preincremento, entonces imprimir 6
		Console.WriteLine( c );   // imprimir 6
	} // fin del método method Main
} // fin de la clase Incremento

casidiablo@punko:~/c#> mcs Incremento.cs
casidiablo@punko:~/c#> mono Incremento.exe
5
5
6

5
6
6

Descargar código fuente