Archive for the “C#” Category

La verdad es que la curva de aprendizaje, al menos para mí, de C# está siendo bastante rápida, más que nada por el conocimiento que tengo sobre JAVA ya que, como he dicho otras veces, sus semejanzas en su sintaxis son impresionantes.

A continuación voy a describir como se estructuran los bucles for, while y do-while en C#, aunque os avanzo de que son idénticos a JAVA.

Bucle FOR.

1
2
3
4
for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("Linea numero {0}", i);
            }

 

Bucle WHILE.

1
2
3
4
5
6
int i = 0;
            while(i<10)
            {
                Console.WriteLine("Linea numero {0}", i);
                i++;
            }

Bucle DO-WHILE.

1
2
3
4
5
6
int i = 0;
            do
            {
                Console.WriteLine("Linea numero {0}", i);
                i++;
            } while (i < 10);

La sentencia condicional IF en C# es como detallo a continuación.

 

1
2
3
4
5
6
7
8
if (a == 0)
            {
                /*Se ejecuta si la condición se cumple*/
            }
            else
            {
                /*Se ejecuta si la condición principal NO se cumple*/
            }

 

Operadores lógicos.

== igual qué
!= distinto de
> Mayor qué
<>= Mayor o igual
! No

Comments No Comments »

Cuantos quebraderos de cabeza ha llegado a dar el paso de parámetros por referencia a los estudiantes de C.

Aquel elemento conocido como puntero que hacía que la asistencia a clase se dividiese por dos, y esto son palabras textuales del profesor que tuve en primero de carrera…, lo gracioso de todo es que fue verdad.

El paso de parámetros por valor en C# la verdad es que es algo muy sencillo.

Cuando pasamos un parámetro por valor, este tendrá un valor antes de la llamada del método, dentro del método será modificado (en realidad, el compilador realiza una copia del dato original y se modifica esta copia) y tras la ejecución, el parámetro tendrá su valor original.

Lo más sencillo es velor con un ejemplo.

Programa principal.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace ConsoleApplication1
 {
 class Program
 {
 static void Main(string[] args)
 {
 int num = 0;
 Console.WriteLine("Antes del metodo: {0}",num);
 Class1 clase = new Class1();
 clase.metodo(num);
 Console.WriteLine("Despues del metodo: {0}", num);
 string a = Console.ReadLine();
 }
 }
 }

Clase.

1
2
3
4
5
6
7
8
9
10
11
namespace ConsoleApplication1
{
 class Class1
 {
 public void metodo(int num)
 {
 num = num + 5;
 Console.WriteLine("Dentro del metodo: {0}", num);
 }
 }
}

Como podemos observar, en el programa principal declaramos una variable entera, la cual pasamos a un método que la modifica y, finalmente, obtenemos el siguiente resultado.


El paso de datos por referencia en C# es tan fácil como poner out o ref delante del parámetros que estemos utilizando. De esta forma, a diferencia del método anterior, las modificaciones se hacen sobre el mismo valor original que tenemos en memoria.

La diferencia entre ref y out es que, el valor que pasemos con ref debe ser inicializado antes de mandarlo al método, con out, el dato puede pasarse sin inicializar no tomando el cuenta el valor original del dato y actuando como si dicho dato no estuviese inicializado.

Programa principal.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace ConsoleApplication1
{
 class Program
 {
 static void Main(string[] args)
 {
 int num = 0;
 Console.WriteLine("Antes del metodo: {0}",num);
 Class1 clase = new Class1();
 clase.metodo(ref num);
 Console.WriteLine("Despues del metodo: {0}", num);
 string a = Console.ReadLine();
 }
 }
}

Clase:

1
2
3
4
5
6
7
8
9
10
11
namespace ConsoleApplication1
{
 class Class1
 {
 public void metodo(ref int num)
 {
 num = num + 5;
 Console.WriteLine("Dentro del metodo: {0}", num);
 }
 }
}

Resultado:

Como ya se ha comentado, podemos utilizar out con variables no inicializadas. Como es lógico, si intentamos trabajar con dicha variable sin haberle asignado ningún valor, el compilador arrojará un error. Dicha asignación debe hacerse antes de que el método que lo llama retorne, si no, ¿que significado tendría?.

Al ser el paso de parámetro por referencia, una vez terminada la ejecución del método, la variable original tendrá el valor que se le haya asignado dentro de la función.

Comments 2 Comments »

Como se puede ver en el título del post, me estoy aventurando a aprender C# por mí mismo ya que durante toda la carrera, en lo que se refiere a orientación a objetos, nos hemos centrado en JAVA.

La verdad es que lo poco que llevo visto, no está siendo para nada complicado, es más, parece más un Déjà vu que el aprendizaje de un lenguaje de programación nuevo pues su similitud con JAVA es impresionante (por no decir, por ahora, calcado).

Para empezar podría soltar una retahíla de conceptos del lenguaje y de .NET que, sinceramente, poco aportan ahora mismo.

Lo primero que debe hacer uno a la hora de adentrarse en un nuevo lenguaje es, como no, conseguir que aparezca una ventanita de fondo negro (o blanco si usamos una terminal en Linux) en las que aparezcan las palabras…, a ver si lo adivina alguien…, ‘Hola Mundo’. Aún recuerdo mis dos primeros ‘Hola Mundo’ en JAVA y C hace ya seis años al comienzo de mi carrera, y como me quedé asombrado con algo tan insignificante.

1
2
3
4
5
6
7
8
9
10
11
namespace ConsoleApplication1
{
 class Program
 {
 static void Main(string[] args)
 {
 Console.WriteLine("Hola Mundo");
 string a = Console.ReadLine();
 }
 }
}

Este código se trata de un método main (o programa principal) el cual, su único cometido es imprimir por consola la cadena “Hola Mundo”. Se puede observar que la forma de construir la clase es prácticamente idéntica a como se haría en JAVA.

Con respecto a la última línea, esta sirve para que la consola no se cierre rápidamente y no nos deje ver nada. Esto es algo con lo que me he topado varias veces en distintos lenguajes. También cabe decir que el IDE que estoy usando es Visual Studio 2010, el cual, si ejecutamos el programa con las opciones de depuración activadas, obtenemos lo que he comentado (una ventana abriéndose y cerrándose más veloz que incluso Usain Bolt). Existe la opción de poder eliminar dicha línea y que la consola no se nos cierre al terminar la ejecución, que sería desactivando las opciones de depuración…, aunque esto es algo no recomendable por lo que significa poder depurar cualquier programa.

Para no dejar esto es un simple ‘Hola Mundo’, he hecho un pequeño programa (bastante simple la verdad) con una clase main donde creamos un objeto, damos un valor a una variable e imprimimos dicho valor, y otra donde tenemos la variable a modificar y el metodo consultor y modificador.

En concreto, dicha clase es esta:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace ConsoleApplication1
{
 class Coche
 {
 private int velocidad;
 
 public void setVelocidad(int vel)
 {
 this.velocidad = vel;
 }
 
 public int getVelocidad()
 {
 return this.velocidad;
 }
 }
}

Y el programa principal el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
namespace ConsoleApplication1
{
 class Program
 {
 static void Main(string[] args)
 {
 Coche coche = new Coche();
 coche.setVelocidad(100);
 Console.WriteLine("El coche va a {0} km/h", coche.getVelocidad());
 string a = Console.ReadLine();
 }
 }
}

El resultado que obtenemos es el siguiente:

El coche va a 100 km/h

Como ya he dicho, el ejemplo es bastante simple y como pequeña inmersión creo que está bien, sobre todo, haber descubierto que es muy parecido a JAVA, con lo que ganamos bastante tiempo con ello (si dominamos JAVA claro xD).

Comments No Comments »

   Beat diabetes   Diabetes diet