Usuario:
Main
Concepto 
La estructura básica de un programa C# tiene la estructura
```
using System;
namespace ExampleApplication {
class Example {
static void Main(string[] args) {
/* codigo */
}
}
}
```
El archivo tiene una extensión cs (C sharp), ejemplo example.cs .
En detalle:
Al inicio se listan los namespaces que debe ser incluidos:
```
using System;
```
Los namespaces corresponden a grupos de clases.
En segundo lugar se define el namespace del programa mediante:
```
namespace ExampleApplication {
```
y luego se incluye el nombre de la clase mediante
```
class Example {
```
Finalmente se incluye dentro de la clase el programa main:
```
static void Main(string[] args) {
/* codigo */
}
```
ID:(9887, 0)
Namespace
Concepto
El namespace agrupa distintas clases como por ejemplo
```
using System;
namespace ExampleApplication {
class ExampleClass {
// member variables
/* Variablen definition */
public void FirstMethod() {
/* Code */
}
public double SecondMethod() {
/* Code */
}
}
class ExecuteExampleClass {
static void Main(string[] args) {
ExampleClass p = new ExampleClass();
p.FirstMethod();
}
}
}
```
En el ejemplo se incluye la creación de un objeto:
```
ExampleClass p = new ExampleClass();
```
y la llamada de un método:
```
p.FirstMethod();
```
ID:(9888, 0)
Tipos de variables
Concepto
Las variables pueden tener algunos de los siguientes formatos:
Tipo | Nombre | Rango | Por defecto
-------|------------|-----------|----------------
bool | Boolean value | True o False | False
byte | 8-bit unsigned integer | 0 a 255 | 0
char | 16-bit Unicode character | U +0000 a U +ffff | '\0'
decimal | 128-bit precise decimal values with 28-29 significant digits | -7.9x1028 to 7.9x1028)/100 a 28 | 0.0M
double | 64-bit double-precision floating point | (+/-)5.0 x 10-324 to (+/-)1.7 x 10308 | 0.0D
float | 32-bit single-precision floating point | -3.4 x 1038 a + 3.4 x 1038 | 0.0F
int | 32-bit signed integer | -2\times 10^9 a 2\times 10^9 | 0
long | 64-bit signed integer | -9\times 10^18 a 9\times 10^18 | 0L
sbyte | 8-bit signed integer | -128 a 127 | 0
short | 16-bit signed integer | -32,768 a 32,767 | 0
uint | 32-bit unsigned integer | 0 a 4,294,967,295 | 0
ulong | 64-bit unsigned integer | 0 a 10^19 | 0
ushort | 16-bit unsigned integer | 0 a 65,535 | 0
ID:(9889, 0)
Definición de variables
Concepto
Definición de variable
La definición de las variables se realizan con el nombre del tipo y el de la variable terminado por un punto coma (termino de linea):
```
tipo nombre;
```
Ejemplo
```
int n;
double x;
```
Definición de variables y asignación de valores
La definición también se puede combinar con la asignación de valores:
```
tipo nombre = valor;
```
Ejemplo
```
int n = 1;
double x = 2.5;
```
Definición de multiples variables
De igual forma se puede emplear el método de una lista cuando hay varias variables del mismo tipo.
```
tipo nombre_1, nombre_2, nombre_3;
```
Ejemplo
```
int n, m, k;
double x, y, z;
```
Inclusión de comentarios
Por ultimo se puede y recomienda incluir en la misma linea un comentario que explica el significado de la variable:
```
tipo nombre; /* comentario */
```
ID:(9890, 0)
Constantes
Concepto
Se pueden definir parámetros que no se modifican durante la ejecución del programa y que por ello se definen como constantes. El formato es similar al de la declaración de una variable pero se antepone la palabra 'const':
```
const formato variable = valor;
```
Ejemplo
```
const int n = 1;
const double x=2.5;
```
ID:(9892, 0)
Estructuras
Concepto
Definición
Las estructuras son colecciones de variables que se crea mediante:
```
public class structure
{
public type field1 { get; set; }
public type field2 { get; set; }
}
```
Ejemplos
```
public class ListItem
{
public String Value { get; set; }
public String Label { get; set; }
}
```
Creación de un puntero
La creación se define mediante
```
structure name = new structure();
```
Ejemplos
```
ListItem datos = new ListItem();
```
Creación de puntero y asignación de datos
Los valores pueden ser definidos en la misma creación
```
structure list = new structure() { field1 = value, field2 = value };
```
Ejemplos
```
ListItem list = new ListItem() { Label = 'id', Value = '0' };
```
Agregar datos
También se pueden agregar datos después de la creación mediante un Add
```
list.Add(new structure() { field1 = value, field2 = value });
```
Ejemplos
```
list.Add(new ListItem() { Label = 'id', Value = '0' });
```
Asignar datos
También se pueden asignar datos específicos (después de que fue creado)
```
list.field1 = value;
```
Ejemplos
```
list.Label = 'id';
```
ID:(9905, 0)
Conversión de formatos
Concepto
Existen dos formas de convertir formatos, la explicita y la implicita.
En la explicita simplemente se ante pone el nuevo tipo a la variable:
```
variable_nuevo_tipo = (tipo)variable_original;
```
Ejemplo
```
int n;
double x=2.5;
n = (int)x;
```
En la forma implícita se empela un operador que se aplica con la notación:
```
variable_nuevo_tipo = variable_original.operador;
```
Los operadores son
Operador | Formato origen | Formato resultado
-------------|-------------------
ToBoolean | cualquiera | Boolean
ToByte | cualquiera | byte
ToChar | cualquiera | Unicode character
ToDateTime | integer o string | date-time structures
ToDecimal | floating point or integer | decimal
ToDouble | cualquiera | double
ToInt16 | cualquiera | 16-bit integer
ToInt32 | cualquiera | 32-bit integer
ToInt64 | cualquiera | 64-bit integer
ToSbyte | cualquiera | signed byte
ToSingle | cualquiera | small floating point number
ToString | cualquiera | string
ToUInt16 | cualquiera | unsigned int
ToUInt32 | cualquiera | unsigned long type
ToUInt64 | cualquiera | unsigned big integer
Bajo 'cualquiera' se entiende una variable cuyo valor es posible de ser interpretado según la conversión que se esta realizando.
Ejemplo:
```
int n;
double x=2.5;
n = x.toInt16;
```
ID:(9891, 0)
Operadores
Concepto
Existen distintos operadores. En particular existen:
Operadores aritméticos
Operador | Descripción | Ejemplo (A=10, B=20)
:-----------: | ---------------- | :----------:
+ | Suma dos operadores | A + B = 30
- | Resta el segundo operando del primer | A - B = -10
* | Multiplica ambos operadores | A * B = 200
/ | Divide el numerador por el de-numerador | B / A = 2
% | El operador de módulo que retorna el modulo de base A de B | B % A = 0
++ | El operador de incremento incrementa el valor entero en uno | A++ = 11
-- | El operador de disminución disminuye el valor entero en uno | A-- = 9
Operadores relacionadores
Operador | Descripción | Ejemplo
:------------:|-----------------|:-----------:
== | Comprueba si los valores de dos operadores son iguales o no, si es así, entonces la condición se cumple. | (A == B) is true
!= | Comprueba si los valores de dos operadores son iguales o no, si los valores no son iguales, la condición se vuelve verdadera. | (A != B) is true
> | Comprueba si el valor del operando izquierdo es mayor que el valor del operando derecho, si es así, entonces la condición se vuelve verdadera. | (A> B) is true
< | Comprueba si el valor del operando izquierdo es menor que el valor del operando derecho, si es así, entonces la condición se vuelve verdadera. | (A >= | Comprueba si el valor del operando izquierdo es mayor o igual que el valor del operando derecho, si es así, entonces la condición se vuelve verdadera. | (A >= B) is true <= | Comprueba si el valor del operando izquierdo es menor o igual que el valor del operando derecho, si es así, entonces la condición se vuelve verdadera. | (A <= B) is true Operadores lógicos Operador | Descripción | Ejemplo :------------:|-----------------|:-----------: && | Llamado operador lógico AND. Si ambos operadores son distintos de cero, la condición se cumple. | (A && B) is true `||` | Llamado lógico o operador. Si alguno de los dos operadores es distinto de cero, la condición se cumple. | (A `||` B) is true ! | Llamado operador lógico NO. Se utiliza para invertir el estado lógico de su operando. Si una condición es verdadera, entonces el operador lógico NO lo hará falso. | !(A && B) is true Operadores sobre bits Con las variables A = 0011 1100 y B = 0000 1101 se tiene: Operador | Descripción | Ejemplo :------------:|-----------------|:-----------: & | El operador binario AND copia un poco al resultado si existe en ambos operadores. | (A y B) = 12, que es 0000 1100 `|` | El operador binario OR copia un poco si existe en cualquiera de los operadores. | (A `|` B) = 61, que es 0011 1101 ^ | El operador binario XOR copia el bit si está configurado en un operando pero no en ambos. | (A ^ B) = 49, que es 0011 0001 ~ | El operador binario complementario es unitario y tiene el efecto de 'voltear' los bits. | (~ A) = 61, que es 1100 0011 << | Operador de cambio binario a la izquierda. El valor de los operadores de la izquierda se mueve hacia la izquierda por el número de bits especificado por el operando de la derecha. | A << 2 = 240, que es 1111 0000 >> | Operador de cambio a la derecha binario. El valor de los operadores de la izquierda se mueve a la derecha por el número de bits especificado por el operando de la derecha. | A >> 2 = 15, que es 0000 1111 Operadores de asignación Operador | Descripción | Ejemplo :------------:|-----------------|:-----------: = | Operador de asignación simple, Asigna valores de los operadores del lado derecho al operando del lado izquierdo | C = A + B asigna el valor de A + B a C += | Agregar operador de asignación AND, agrega el operando derecho al operando izquierdo y asigna el resultado al operando izquierdo | C + = A es equivalente a C = C + A -= | Restar Y operador de asignación. Resta el operando derecho del operando izquierdo y asigna el resultado al operando izquierdo | C - = A es equivalente a C = C - A *= | Multiplica el operador de asignación AND, multiplica el operando derecho con el operando izquierdo y asigna el resultado al operando izquierdo | C* = A es equivalente a C = C* A /= | Dividir Y asignar operador, divide el operando izquierdo con el operando derecho y asigna el resultado al operando izquierdo | C/ = A es equivalente a C = C / A %= | Operador de módulo Y asignación. Toma módulo usando dos operadores y asigna el resultado al operando izquierdo | C% = A es equivalente a C = C% A <<= | Operador de asignación Y de desplazamiento a la izquierda | C << = 2 es igual que C = C << 2 >>= | Desplazar a la derecha Y el operador de asignación | C >> = 2 es igual que C = C >> 2 &= | Operador de asignación AND a nivel de bit | C& = 2 es igual que C = C &2 ^= | OR exclusivo a nivel de bit y el operador de asignación | C^= 2 es igual que C = C^2 \|= | OR inclusivo a nivel de bit y el operador de asignación | C\| = 2 es igual que C = C\| 2 Otros operadores Operador | Descripción | Ejemplo :------------:|-----------------|:-----------: sizeof() | Devuelve el tamaño de un tipo de datos. | sizeof(int), devuelve 4. typeof() | Devuelve el tipo de una clase. | typeof(StreamReader); & | Devuelve la dirección de una variable. | &a; Devuelve la dirección real de la variable. * | Puntero a una variable. | *a; crea un puntero llamado 'a' a una variable. ?: | Expresión condicional | ¿Si la condición es verdadera? Entonces valor X: de lo contrario, valor Y is | Determina si un objeto es de un tipo determinado. | If(Ford is Car) // comprueba si Ford es un objeto de la clase Car. as | Reparto sin levantar una excepción si el reparto falla. | Objeto obj = new StringReader ('Hello'); StringReader r = obj como StringReader;
ID:(9893, 0)
Decisiones
Concepto
Para controlar el desarrollo se pueden usar las decisiones como ámbitos o casos.
En el caso de las decisiones como ámbitos se tienen el comando if, en particular
if simple
En este caso se usa una condición lógica (condition) y según esta se procesa o no el correspondiente código:
```
if(condition){
/* code */
}
```
if else
En forma similar se puede procesar alternativamente dos códigos con
```
if(condition){
/* code condition = true */
} else {
/* code condition = false */
}
```
En forma análoga se pueden tener múltiples condiciones y códigos:
```
if(condition_1){
/* code condition_1 = true */
} else if(condition_2){{
/* code condition_1 = false and condition_2 = true */
} else {
/* code condition_1 and condition_2 = false */
}
```
Otro método en que se direcciona a casos específicos es el select.
El formato básico tiene la forma:
```
switch (caseSwitch)
{
case 1:
/* code case 1 */
break;
case 2:
/* code case 2 */
break;
default:
/* code default */
break;
}
```
en que los casos están enumerados.
ID:(9894, 0)
Loop
Concepto
Para realizar multiples operaciones se tienen los comandos while y for.
while
Los comandos while y do while repiten una acción hasta que se cumple una condición. En el caso while el control es antes de la ejecución del código
```
while( condition){
/* code */
}
```
y en el do while después del código:
do while
```
do{
/* code */
} while( condition);
```
for
En el caso del for el proceso se ejecuta un numero definido de operaciones las que son contabilizadas por el indice de la función for:
```
for (initializer; condition; iterator){
/* code */
}
```
El initializer define un entero y le asigna el valor inicial
```
int i = 0;
```
La condition se define como una relación lógica que incluye el contador definido en el initializer, como por ejemplo
```
i < 5
```
El iterator indica como modifica el contador, esto es incrementar o reducir:
```
i++ o i--
```
foreach
Existe otra variante for en que se recorre un arreglo. En ese caso se define como
```
var lista = new List
foreach (int contador in lista)
{
/* code */
}
```
ID:(9895, 0)
Arreglos 1D
Concepto
La definición de arreglos se realiza agregando los paréntesis rectangulares después del tipo de formato:
```
tipo[] nombre_variable;
```
Ejemplos
```
int[] arreglo_enteros;
double[] arreglo_valores;
```
La definición solo crea el puntero y no el espacio para definir los elementos del arreglo. Para crear el arreglo es necesario incluir el comando 'new' y el tamaño del arreglo
```
tipo[] nombre_variable = new tipo[numero];
```
Ejemplos
```
int[] arreglo_enteros = new int[10];
double[] arreglo_valores = double[20];
```
De igual forma se pueden crear los arreglos definiendo valores
```
tipo[] nombre_variable = { lista };
```
Ejemplos
```
int[] arreglo_enteros = { 1, 1, 2, 4, -2 };
double[] arreglo_valores = { 2.5, 1.6, -1.5 };
```
Los elementos se indican con el numero del contador entre corchetes rectangulares
```
arreglo_enteros[contador] = valor;
```
Ejemplos
```
arreglo_enteros[2] = 0;
arreglo_valores[0] = 1.2;
```
ID:(9896, 0)
Arreglos nD
Concepto
La definición de arreglos se realiza agregando los paréntesis rectangulares con comas para indicar el número de variables después del tipo de formato:
```
tipo[,] nombre_variable;
```
Ejemplos
```
int[,] arreglo_enteros;
double[,,] arreglo_valores;
```
La definición solo crea el puntero y no el espacio para definir los elementos del arreglo. Para crear el arreglo es necesario incluir el comando 'new' y el tamaño del arreglo
```
tipo[] nombre_variable = new tipo[dimension_1,dimension_2];
```
Ejemplos
```
int[,] arreglo_enteros = new int[10,20];
double[,,] arreglo_valores = double[20,30,40];
```
De igual forma se pueden crear los arreglos definiendo valores
```
tipo[] nombre_variable = { listas };
```
Ejemplos
```
int[,] arreglo_enteros = new int [2,3] { {1, 1, 2}, {2, 4, 0} };
```
Los elementos se indican con el numero del contador entre corchetes rectangulares
```
arreglo_enteros[contador_1,contador_2] = valor;
```
Ejemplos
```
arreglo_enteros[2,1] = 0;
arreglo_valores[0,2,1] = 1.2;
```
ID:(9898, 0)
Paso de arreglos en argumentos
Concepto
Los arreglos pueden ser parte de los argumentos de las funciones indicando el formato en el argumento:
```
public type function_name(type[] arr) {
/* code */
return value;
};
```
Ejemplos
```
public int functionName(int[] arreglo) {
/* code */
return value;
};
```
ID:(9897, 0)
Arreglos de estructuras 1D
Concepto
En forma mas general se puede definir una estructura de un arreglo de estructura:
```
public class ListResponse
{
public List
}
```
en que la estructura de cada elemento es
```
public class ListItem
{
public String Value { get; set; }
public String Label { get; set; }
}
```
En este caso primero se cera el puntero a la estructura general
```
ListResponse response = new ListResponse();
response.Items = new List
```
y luego se agregan elementos mediante el método Add
```
response.Items.Add(new ListItem()
{
Label = stitle,
Value = skey
});
```
ID:(9904, 0)