jueves, 29 de diciembre de 2011
viernes, 16 de diciembre de 2011
Arrays (matrices)
Los arrays (matrices o arreglos) permiten agrupar valores que de alguna forma necesitamos que estén relacionados entre sí.
Una matriz es una estructura de datos que contiene una serie de variables denominadas elementos de la matriz.
Declarar Arrays
En C# los arrays se definen indicando un par de corchetes en el tipo de datos.
Por ejemplo, para indicar que queremos tener un array llamado numeros para almacenar valores de tipo int, lo haremos de esta forma:
int[] numeros;
Esta declaración simplemente indica que la variable numeros "será" un array, pero aún no está inicilizada.
Para iniciarla, al menos con valores cero, podemos hacerlo de estas dos formas, dependiendo de que ya hayamos declarado previamente la variable, (primera línea), o lo queramos hacer al declararla, (segunda línea):
numeros = new int[4];
int[] num2 = new int[3];
En ambos casos debemos usar new seguido del tipo de datos y entre corchetes el número de elementos que tendrá el array. Ese número indicará el total de elementos que tendrá el array, pero debido a como .NET trata los arrays, el índice inferior será cero y el índice superior será uno menos del número de elementos que hemos indicado al crear el array.
Para asignar valores a los elementos de un array, lo haremos como con cualquier variable, pero usando los corchetes y la posición en la que queremos guardar ese valor:
num2[0] = 3;
num2[1] = 22;
Para recorrer todos los elementos que tenga un array podemos hacerlo de la forma tradicional, es decir, usando un bucle for con una variable que recorra todos los índices, en cuyo caso necesitamos averiguar el valor del índice superior del array, cosa que haremos por medio de la propiedad Length, tal como podemos ver en este código:
for (int i = 0; i < num2.Length; i++)
Console.WriteLine(num2[i]);
Como vemos, para acceder a cada uno de los valores, el elemento al que queremos acceder lo indicamos dentro de corchetes.
La otra forma de hacerlo es mediante un bucle foreach, pero debido a que foreach obtiene cada un de los valores que le indiquemos, no necesitamos acceder directamente al array, sino que usaremos el valor obtenido en cada ciclo del bucle, tal como podemos comprobar en este trozo de código:
foreach(int i in num2)
Console.WriteLine(i);
Declarar e inicializar un array
Al igual que podemos declarar variables e inicializarlas al mismo tiempo, con los arrays también podemos hacerlo, aunque la sintaxis es un poco distinta, ya que en esta ocasión debemos indicar varios valores. Esos valores los indicaremos justo después de definir el array:
string[] nombres = {"Pepe", "Juan", "Luisa"};
En este caso, cuando iniciamos el array al declararlo, no debemos indicar el número de elementos que tendrá ese array, ya que ese valor lo averiguará el compilador cuando haga la asignación. Tampoco es válido indicar el número de elementos que queremos que tenga y solo asignarle unos cuantos menos (o más), ya que se producirá un error en tiempo de compilación.
Si el array es bidimensional (o con más dimensiones), también podemos inicializarlos al declararlo, pero en este caso debemos usar doble juego de llaves:
string[,] nombres = { { "Juan", "Pepe" }, { "Ana", "Eva" } };
En este código tendríamos un array bidimensional con los siguientes valores:
nombres[0,0]= Juan
nombres[0,1]= Pepe
nombres[1,0]= Ana
nombres[1,1]= Eva
Como podemos ver en la declaración anterior, si definimos arrays con más de una dimensión, debemos indicarlas, en la declaración del tipo, usando una coma para separar cada dimensión, o lo que es más fácil de recordar: usando una coma menos del número de dimensiones que tendrá el array. En los valores a asignar, usaremos las llaves encerradas en otras llaves, según el número de dimensiones.
Cambiar el tamaño de un array
Visual C# 2010 no nos ofrece una forma fácil de cambiar el tamaño de un array, de hecho no tiene ninguna instrucción que sirva para eso.
Aunque redimensionar un array realmente no tiene ningún problema, ya que simplemente lo haremos de la misma forma que vimos anteriormente:
num2 = new int[4];
E incluso podemos asignarle nuevos valores al "redimensionarlo", usando la misma sintaxis que vimos en la sección anterior:
num2 = new int[] { 6, 7, 8, 9 };
Lo que no podemos hacer en C# es cambiar el tamaño de un array conservando el contenido anterior, algo que en otros lenguajes si es posible. La única forma de conseguirlo es hacer una copia previa de ese array, redimensionarlo al nuevo tamaño y volver a copiar el contenido anterior.
En el siguiente código podemos ver estos pasos:
int[] original = { 1, 2, 3, 4 };
int[] copia = new int[original.Length];
// Copiamos el original en la copia
original.CopyTo(copia, 0);
// Añadimos 5 elementos más
original = new int[original.Length + 5];
// Asignamos nuevamente lo copiado a partir del primer elemento
copia.CopyTo(original, 0);
Para hacer la copia hemos usado el método CopyTo, al que le indicamos el array de destino, (que previamente debe estar dimensionado con el número de elementos que recibirá), y el índice a partir del cual queremos copiar ese array, en nuestro caso le indicamos la primera posición, que como sabemos es la posición cero.
Si el array contiene valores por valor, podemos usar otro método: Clone, ya que este método devuelve una copia "superficial" del objeto en cuestión, en nuestro caso el array; esa copia superficial significa que solo copiará el contenido del array, si este tuviera referencia a objetos, no copiaría los objetos, solo las referencias, (de todo esto de los objetos y referencias a objetos nos ocuparemos en la próxima lección), pero el valor que devuelve ese método es del tipo object, es decir el tipo genérico de .NET, por tanto tendríamos que hacer una conversión al tipo array, tal como vemos en este código:
int[] copia = (int[])original.Clone();
Eliminar el contenido de un array
Una vez que hemos declarado un array y le hemos asignado valores, es posible que nos interese eliminar esos valores de la memoria, para lograrlo, en C# podemos hacerlo de dos formas:
- Redimensionando el array indicando que tiene cero elementos, aunque en el mejor de los casos, si no estamos trabajando con arrays de más de una dimensión, tendríamos un array de un elemento, ya que, como hemos comentado anteriormente, los arrays de .NET el índice inferior es cero.
- Asignar un valor null al array. Esto funciona en C# porque los arrays son tipos por referencia.
Los arrays son tipos por referencia
Como acabamos de ver, en Visual C# 2010 los arrays son tipos por referencia, y tal como comentamos anteriormente, los tipos por referencia realmente lo que contienen son una referencia a los datos reales no los datos propiamente dichos.
¿Cuál es el problema?
Veámoslo con un ejemplo y así lo tendremos más claro.
string[] nombres = { "Juan", "Pepe", "Ana", "Eva" };
string[] otros;
otros = nombres;
nombres[0] = "Antonio";
Console.WriteLine(otros[0]);
En este ejemplo definimos el array nombres y le asignamos cuatro valores. A continuación definimos otro array llamado otros y le asignamos lo que tiene nombres. Por último asignamos un nuevo valor al elemento cero del array nombres.
Si mostramos el contenido de ambos arrays nos daremos cuenta de que realmente solo existe una copia de los datos en la memoria, y tanto nombres[0] como otros[0] contienen el nombre "Antonio".
¿Qué ha ocurrido?
Debido a que los arrays son tipos por referencia, solamente existe una copia de los datos en la memoria y tanto la variable nombres como la variable otros lo que contienen es una referencia (o puntero) a los datos.
Si realmente queremos tener copias independientes, debemos hacer una copia del array utilizando el método CopyTo que ya vimos anteriormente.
Además de los métodos que hemos visto y de la propiedad Length que nos sirve para averiguar cuantos elementos tiene un array, tenemos más métodos y propiedades que podemos usar, por ejemplo para saber cuantas dimensiones tiene un array (Rank) o saber cual es el índice superior de una dimensión determinada (GetUpperBound).
Para finalizar este tema, sólo nos queda por decir, que los arrays de .NET, y por tanto los de C#, realmente son tipos de datos derivados de la clase Array y por tanto disponen de todos los miembros definidos en esa clase, aunque de esto hablaremos en la próxima lección, en la que también tendremos la oportunidad de profundizar un poco más en los tipos por referencia y en cómo podemos definir nuestros propios tipos de datos, tanto por referencia como por valor.
El método Legth
El método Length devuelve el número de elementos de un arreglo o matriz. Nótese que los arreglos comienzan con el elemento cero (0) y siguen sucesivamente hasta el elemento superior que sería n-1. Por ejemplo si se declara un arreglo de 10 elementos, el primer elemento será el elemento número cero de la colección y el último elemento será el elemento nueve de la colección
Ejemplo de uso de array en un Windows Forms
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace Arreglos
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
String[] meses = {"Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio","Julio", "Agosto",
"Septiembre", "Octubre", "Noviembre", "Diciembre"};
foreach (String m in meses)
{
comboBox1.Items.Add(m);
}
comboBox1.SelectedIndex = 0;
}
private void button1_Click(object sender, EventArgs e)
{
label2.Text = "Procesando el mes de : " + comboBox1.Text;
}
}
}
En el código anterior hemos hecho una aplicación en windows forms que asigna el valor de un arreglo a un combobox. También se muestra el uso de la instrucción foreach. La variable m en el ciclo foreach debe ser del mismo tipo del array y lo que hace es almacenar por cada vuelta del ciclo el valor del elemento del arreglo.
El formulario tiene un botón que cuando se presiona muestra el contenido del mes seleccionado en un label (label2).
El formulario ejecutandose se mostrará más o menos como la figura siguiente:
Sentencias de Control en C# - IV Parte
El ciclo while
Otro ciclo dentro del C# es el while. La forma general del while es:
while (condición) sentencia;
donde sentencia puede ser una simple sentencia o un bloque de sentencias y condición define la condición que controla el ciclo y puede ser cualquier expresión booleana válida. Las sentencias son ejecutadas mientras la condición es verdadera. Cuando la condición llega a ser falsa, el control del programa pasa a la línea inmediata que sigue el ciclo (si son más de una sentencias se debe usar un bloque con llaves para que el while sepa que tiene que hacer todas las instrucciones en cada vuelta del ciclo).
// Calcular el orden de magnitud de un número
using System;
class WhileDemo {
static void Main() {
int num;
int mag;
num = 435679;
mag = 0;
Console.WriteLine("Número: " + num);
while(num > 0) {
mag++;
num = num / 10;
};
Console.WriteLine("Magnitud: " + mag);
}
}
La salida del sistema anterior es:
Número : 435679
Magnitud : 6
El ciclo trabaja de la siguiente manera: El valor de num es examinado. Si num es mayor que 0, la variable mag es incrementada y num es divido entre 10. Mientras el valor num sea mayor que 0 el ciclo se repite. Cuando num es igual a cero el ciclo se detiene y mag contiene el orden (cantidad de dígitos ) del valor original.
El ciclo do-while
El tercer ciclo del C# es el ciclo do-while. A diferencia del ciclo for y el ciclo while, en los cuales la condición es examinada y evaluada al inicio del ciclo, el ciclo do-while chequea la condición al final del ciclo. Esto significa que el ciclo do-while siempre se ejecutará al menos una vez. La forma general del ciclo do-while es la siguiente:
do {
sentencias;
} while(condición)
Las llaves no son necesarias si solo hay una sentencia, pero siempre es bueno tenerlas para que la estructura sea más legible.
Por ejemplo el siguiente programa muestra como se imprimen los números en orden inverso mediante un ciclo do-while
// Mostrar los dígitos de un entero en orden inverso
using System;
class DoWhileDemo {
static void Main() {
int num;
int nextdigit;
num = 198;
Console.WriteLine("Número: " + num);
Console.Write("Número en orden inverso: ");
do {
nextdigit = num % 10;
Console.Write(nextdigit);
num = num / 10;
} while(num > 0);
Console.WriteLine();
}
}
La salida del programa será:
Number: 198
Number in reverse order: 891
El ciclo foreach
El ciclo foreach recorre todos los elementos de una colección. Una colección es un grupo de objetos. C# define varios tipos de colecciones, una de las cuales son los Arreglos o Matrices. Examinaremos posteriormente el ciclo foreach cuando describamos los arreglos.
Usando la instrucción break para salir de un ciclo
Es posible forzar una salida inmediata del ciclo, sin pasar por el resto de código en el cuerpo del ciclo y la prueba condición del ciclo,usando la instrucción break. Cuando el ciclo encuentra la instrucción break, el ciclo es terminado, y el control del programa se pasa a la siguiente instrucción después del ciclo. Aquí un ejemplo de su uso.
// Usando break para salir de un ciclo
using System;
class BreakDemo {
static void Main() {
// Usar break para salir del ciclo
for(int i=-10; i <= 10; i++) {
if(i > 0) break; // terminar el ciclo cuando i sea positivo
Console.Write(i + " ");
}
Console.WriteLine("Hecho");
}
}
El break se puede usar en cualquier tipo de ciclo.
Usando continue
Es posible forzar una iteración temprana de un ciclo, sin pasar por la estructura del bucle de control normal. Esto se logra utilizando continue. La sentencia continue obliga a la siguiente iteración de la ciclo que tendrá lugar, saltándose cualquier código en el medio. Por lo tanto, continue es esencialmente el complemento de break. Por ejemplo, el siguiente programa utiliza continue ayudando a imprimir los números pares entre 0 y 100.
// Usar continue.
using System;
class ContDemo {
static void Main() {
// Imprimir número pares del 0 al 100.
for(int i = 0; i <= 100; i++) {
if((i%2) != 0) continue; // iterate
Console.WriteLine(i);
}
}
}
Nótese que en el programa anterior se evalúa si el residuo de la división del número almacenado en la variable i entre 2 es diferente de 0 se fuerza la siguiente iteración, si el valor es cero (el número es par) se imprime el valor del número.
La instrucción return
Esta instrucción muy usada en los programas de C# se utiliza para salir de un método. Este también puede ser usado para regresar un valor.
La sentencia goto
El goto es una sentencia de salto incondicional en C#. Cuando se encuentra el programa salta a una localización definida por el goto. La sentencia cayó en desgracia con muchos programadores años atrás, ya que fomentó la creación de código spaguetti. Sin embargo, el goto es todavía usado en ocasiones y de manera eficiente. No se debe juzgar la forma de programar de algunos pero si se puede reducir su uso es mejor. Un ejemplo de como se utilizaría sería el siguiente fragmento de código. Note que el goto requiere siempre de un label que funciona como un identificador válido de C#.
x = 1;
loop1:
x++;
if(x < 100) goto loop1;
Bueno, ha sido sufiente por el día de hoy. Mañana o más tarde estaré posteando más teoría para que la estudien y avancemos más rápido.
Saludos.
Sentencias de Control en C# – III Parte
El ciclo for
El instrucción for es una de las sentencias más poderosas y flexibles para los ciclos. En su forma general la instrucción para repetir una simple instrucción es:
for(inicialización; condición; iteración) sentencia;
Para repetir un bloque de instrucciones la forma general es:
for(inicialización; condición; iteración)
{
secuencia de instrucciones;
}
La Inicialización es normalmente una sentencia de asignación que fija el valor inicial de la variable que controlará la iteraciones en el ciclo, actuando como contador. La condición es una expresión booleana que determina si el ciclo se repetirá. La expresión iteración define la cantidad por la cual la variable de control cambia cada vez que el ciclo es repetido. Nótese que cada expresión del for debe ser separado por punto y coma. El ciclo for se repite mientras la condición es verdadera. Una vez que la condición llega a ser falsa el ciclo se detiene y se sigue ejecutando la siguiente sentencia después del bloque for. El ciclo puede iniciar de forma positiva o negativa e incrementar los valores en cualquier cantidad entera. Por ejemplo el siguiente programa imprime los números del –100 al 100 con incrementos de –5
// A negatively running for loop.
using System;
class DecrFor {
static void Main() {
int x;
for(x = 100; x > -100; x -= 5)
Console.WriteLine(x);
}
}
}
Algo importante de recalcar es que la condición se evalúa siempre en la parte superior del for. Esto significa que el código dentro del ciclo for puede no ejecutarse si la condición es falsa desde el inicio. Por ejemplo:
int count;
for(count=10; count < 5; count++)
x += count; // Esta instrucción nunca se ejecutará
Note que en los ejemplos anteriores la parte de la inicialización, es decir, donde se define el contador del ciclo, la variable utilizada x = 100, se asume que ya fue declarada anteriormente como una variable del tipo entero. Esto también se puede hacer al momento del ciclo.
// Sumar números del 1 al 100
using System;
class Sumar100 {
static void Main() {
int sum = 0;
for(int i = 1; i <= 100; i++)
sum += i;
Console.WriteLine("La Suma es " + sum);
}
}
En el ejemplo anterior se suman los números del 1 al 100. La variable i se ha declarado e inicializado dentro del ciclo.
El ciclo infinito
Usted puede crear un ciclo infinito (un ciclo que nunca termina) usando el for dejando la expresión de condición vacía. Por ejemplo :
for(;;) // ciclo intencionalmente infinito
{
//...
}
Ciclo sin cuerpo
En C#, el cuerpo asociado con el ciclo for puede ser vacío. Esto es porque un el cuerpo vacío de un for es sintácticamente válido. Los ciclos sin cuerpo son muy útiles. Por ejemplo para el programa usado para sumar los números del 1 al 100 podemos resumirlo como se muestra a continuación:
// El cuerpo del ciclo puede estar vacío
using System;
class Empty3 {
static void Main() {
int i;
int sum = 0;
// Suma los números del 1 al 100.
for(i = 1; i <= 5; sum += i++) ;
Console.WriteLine("La Suma es " + sum);
}
}
En este caso la instrucción de la suma se hace dentro de la instrucción for. ( sum += i++), aquí se acumula el valor de i a la variable sum y además se incrementa la variable. Fíjese además que al terminar la linea del for se colocaron el punto y como para definir que no hay cuerpo,
Bueno, espero que haya sido útil. Nos vemos dentro de un rato para postear otros ciclos.
Sentencias de Control en C# – II Parte
La instrucción Switch
La segunda de las instrucciones de selección en C # es switch. El switch proporciona una rama múltiple de selección, por lo tanto, permite a un programa seleccionar entre varias alternativas. Funciona así: El valor de una expresión se prueba sucesivamente con una lista de las constantes. Cuando se encuentra una coincidencia, la secuencia de instrucciones asociada con esa concordancia es ejecutado. La forma general de la sentencia switch es:
switch(expresión)
{
case constant1:
statement sequence
break;
case constant2:
statement sequence
break;
case constant3:
statement sequence
break;
.
.
.
default:
statement sequence
break;
}
La expresión switch debe ser de un tipo entero, como char, byte, short o int, del un tipo de enumeración, o de tipo cadena. Otras expresiones no están permitidas, como por ejemplo las de punto flotante. Con frecuencia, la expresión de control del switch es simplemente una variable. En el caso de las constantes deben ser de un tipo compatible con la expresión. No pueden haber dos constantes con el mismo valor en la instrucción. La secuencia por defecto ( default ) se ejecuta si ningún caso (case) la expresión coincide con la expresión constante. el valor por defecto es opcional, si no está presente, ninguna acción se lleva a cabo si no hay coincidencias. Cuando un coincidencia es encontrada, las instrucciones asociadas a ese case se ejecutan hasta que la rotura (break) se encuentra
// Demonstrate the switch.
using System;
class SwitchDemo {
static void Main() {
int i;
for(i=0; i<10; i++)
switch(i) {
case 0:
Console.WriteLine("i es cero");
break;
case 1:
Console.WriteLine("i es uno");
break;
case 2:
Console.WriteLine("i es dos");
break;
case 3:
Console.WriteLine("i es tres");
break;
case 4:
Console.WriteLine("i es cuatro");
break;
default:
Console.WriteLine("i es cinco o más");
}
}
}
}
El programa produce la salida siguiente
i es cero
i es dos
i es tres
i es cuatro
i es cinco o más
i es cinco o más
i es cinco o más
i es cinco o más
i es cinco o más
i es cinco o más
Las sentencias switch también pueden ser anidadas al igual que el if.
Hasta dentro de un rato.
Saludos
Sentencias de Control en C#
Hay tres categorías de sentencias de control en C#: Las instrucciones de selección, que son los if y switch, las instrucciones de iteración o ciclos, que consisten en el for, while, do-while y los bucles foreach, y las instrucciones de salto, que incluyen break, continue, goto, return y throw. Explicaremos cada uno de ellos a excepción del throw que forma parte de un mecanismo de excepción que lo postearemos después.
La Sentencia if
La forma completa de esta sentencia es la siguiente:
if (condición) sentencia;
else sentencia;
donde los objetivos de el if y el else son simples sentencias o declaraciones. La cláusula else es opcional. Los objetivos de ambos el if y el else puede ser un bloque se sentencias (recuerde que los bloques de sentencia en C# van entre llaves.
Si la expresión de condición es verdadera, se ejecutarán las secuencias de expresiones del if, en caso contrario si existe la parte del else, estas serán ejecutadas. No se ejecutarán las dos al mismo tiempo. La expresión condicional debe dar como resultado un valor booleano (bool).if (condición)
{
secuencia de expresiones
}
else
{
secuencia de expresiones
}
// Determinar si un valor es positivo o negativo
using System;
class PosNeg
{
static void Main()
{
int i;
for(i = -5; i <= 5; i++)
{
Console.Write("Probando " + i + " : ");
if (i < 0) Console.WriteLine("Negativo");
else Console.WriteLine("Positivo");
}
}
}
El resultado mostrará el resultado siguiente:
Probando –5 : Negativo
Probando –4 : Negativo
Probando –3 : Negativo
Probando –2 : Negativo
Probando –1 : Negativo
Probando 0 : Positivo
Probando 1 : Positivo
Probando 2 : Positivo
Probando 3 : Positivo
Probando 4 : Positivo
Probando 5 : Positivo
If anidados
Las instrucciones if pueden estar anidadas, es decir un if dentro de otro if. Esto es muy común en la programación diaria. Por ejemplo la siguiente instrucción muestra un if anidado
if (i == 10)
{
if (j < 20)
a = b;
if (k > 100)
c = d;
else // este else se refiere al if(k>100)
a = c;
}
else
a = d; // este else se refiere al if( i == 10)
La escalera if-eslse-if
Una estructura común en programación es la escalera if-else-if. Esto luciría de la siguiente manera:
if (condición)
instruccion;
else if (condición)
instrucción;
else if (condición)
instucción;
.
.
.
else
instrucción;
Las expresiones condicionales son evaluadas de arriba hacia abajo. Tan pronto como la condición verdadera se encuentra, la instrucción o instrucciones asociadas son ejecutadas. y el resto de la escalera es omitido. Si no se encuentra una condición verdadera la clausula else es ejecutada. En este caso la claúsula else funciona como una expresión default. Si no existiera una cláusula else y ninguna condición es verdadera, no se tomaría ninguna acción.
El siguiente programa demuestra el uso de la sentencia if-else-if
// Determinar el factor más pequeño
using System;
class Escalera {
static void Main() {
int num;
for(num = 2; num < 12; num++) {
if((num % 2) == 0)
Console.WriteLine("El factor más pequeño de " + num + " es 2.");
else if((num % 3) == 0)
Console.WriteLine("El factor más pequeño de " + num + " is 3.");
else if((num % 5) == 0)
Console.WriteLine("El factor más pequeño de " + num + " is 5.");
else if((num % 7) == 0)
Console.WriteLine("El factor más pequeño de " + num + " is 7.");
else
Console.WriteLine(num + " no es divisible por 2, 3, 5, o 7.");
}
}
}
El programa anterior mostraría la siguiente salida:
El factor más pequeño de 2 es 2.
El factor más pequeño de 3 es 3.
El factor más pequeño de 4 es 2.
El factor más pequeño de 5 es 5.
El factor más pequeño de 6 es 2.
El factor más pequeño de 7 es 7.
El factor más pequeño de 8 es 2.
El factor más pequeño de 9 es 3.
El factor más pequeño de 10 es 2.
11 no es divisible por 2, 3, 5, o 7.
Bueno, continuamos en el siguiente post.
Saludos
El Operador ?
Uno de los operadores más fascinantes en C# es el operador ?, el cual es un operador condicional. Es usado para sustituir ciertos tipos de sentencias if-then-else. El operador ? es llamado operador terciario porque requiere tres operandos. Este toma la forma general:
Exp1 ? Exp2 : Exp3;
donde Exp1 es una expresión del tipo bool y Exp2 y Exp3 son expresiones normales. El tipo de Exp2 y Exp3 deben ser el mismo. Las expresiones 2 y 3 están separadas por dos puntos. El valor de una expresión ? es evaluada así: Exp1 es evaluada, si es verdadera, entonces la Exp2 es evaluada y llega a ser el valor de toda la expresión ?. Si Exp1 es falsa, entonces se evalúa la Exp2 y su valor obtenido llega a ser el valor de toda la expresión ?.
Consideremos el ejemplo siguiente el cual asigna a la variable absval el valor absoluto de la variable val:
absval = val < 0 ? –val : val; // obtner el valor absoluto de la variable val
aquí a la variable absval le será asignado el valor de val si val es cero o mayor que cero. Si val es negativo, entonces a absval se le asigna el valor negativo de val (el cual llega a ser un valor positivo).
Por ejemplo, veamos algo clásico para los estudiantes. Supongamos que queremos asignar a una variable de cadena el valor APROBADO o REPROBADO si un alumno ha obtenido una calificación adecuada en un exámen. Asumiendo que la nota para aprobar es 70.
int nota = 89;
String condicion = nota >= 70 ? "APROBADO" : "REPROBADO";
Estructura de un programa en C#
Volvamos un momento a lo básico, con los ejercicios vistos en clase al momento, nos podemos dar cuenta que la estructura de un programa en C# es a nivel de bloques de código. Cada bloque de código se encierra entre llaves ({ }). Los bloques determinan el ámbito del código.
Los programas en C# pueden constar de uno o varios archivos. Cada archivo puede contener cero o varios espacios de nombres. Un espacio de nombres puede contener tipos como clases, estructuras, interfaces, enumeraciones y delegados, además de otros espacios de nombres. A continuación, se muestra el esqueleto de un programa en C# que contiene todos estos elementos.
using System;
namespace YourNamespace
{
class YourClass
{
}
struct YourStruct
{
}
interface IYourInterface
{
}
delegate int YourDelegate();
enum YourEnum
{
}
namespace YourNestedNamespace
{
struct YourStruct
{
}
}
class YourMainClass
{
static void Main(string[] args)
{
//Your program starts here...
}
}
}
Note que la primera línea de la estructura comienza con la palabra using, la cual se utiliza para definir las librerías a utilizar en el archivo o módulo del programa.
La segunda línea define el espacio de nombre o namespace al que pertenece la clase o clases que seguirán como parte de la definición. El término de espacio de nombres no es complicado de entender, realmente se trata de una forma de organizar el código para que sea más práctico a la hora de ser ubicado, documentado, o utilizado dentro del programa.
Normalmente cuando usted crea un formulario, este es una clase a la cual nos podemos referir posteriormente.
sábado, 10 de diciembre de 2011
Domingo 11 - No hay clases
Saludos y los espero el domingo 17.
domingo, 4 de diciembre de 2011
Ejercicio hecho en clase
Ejercicio
viernes, 2 de diciembre de 2011
Clases el Domingo 4
Saludos y nos vemos el Domingo a las 8:00 am
Posters de Referencia Visual Studio 2010
Primer Presentación del Módulo
Presentación de PowerPoint : Base de datos y Programación Avanzada I