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 | Falsebyte | 8-bit unsigned integer | 0 a 255 | 0char | 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.0Mdouble | 64-bit double-precision floating point | (+/-)5.0 x 10-324 to (+/-)1.7 x 10308 | 0.0Dfloat | 32-bit single-precision floating point | -3.4 x 1038 a + 3.4 x 1038 | 0.0Fint | 32-bit signed integer | -2\times 10^9 a 2\times 10^9 | 0long | 64-bit signed integer | -9\times 10^18 a 9\times 10^18 | 0Lsbyte | 8-bit signed integer | -128 a 127 | 0short | 16-bit signed integer | -32,768 a 32,767 | 0uint | 32-bit unsigned integer | 0 a 4,294,967,295 | 0ulong | 64-bit unsigned integer | 0 a 10^19 | 0ushort | 16-bit unsigned integer | 0 a 65,535 | 0
ID:(9889, 0)
Definición de variables
Concepto
Definición de variableLa 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 valoresLa 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 variablesDe 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 comentariosPor 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ónLas 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 punteroLa creación se define mediante```structure name = new structure();```Ejemplos```ListItem datos = new ListItem();```Creación de puntero y asignación de datosLos 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 datosTambié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 datosTambié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 sonOperador | Formato origen | Formato resultado-------------|-------------------ToBoolean | cualquiera | BooleanToByte | cualquiera | byteToChar | cualquiera | Unicode characterToDateTime | integer o string | date-time structuresToDecimal | floating point or integer | decimalToDouble | cualquiera | doubleToInt16 | cualquiera | 16-bit integerToInt32 | cualquiera | 32-bit integerToInt64 | cualquiera | 64-bit integerToSbyte | cualquiera | signed byteToSingle | cualquiera | small floating point numberToString | cualquiera | stringToUInt16 | cualquiera | unsigned intToUInt32 | cualquiera | unsigned long typeToUInt64 | cualquiera | unsigned big integerBajo '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éticosOperador | 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-- = 9Operadores relacionadoresOperador | 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
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 particularif simpleEn 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 elseEn 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.whileLos 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);```forEn 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--```foreachExiste otra variante for en que se recorre un arreglo. En ese caso se define como```var lista = new List
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
ID:(9904, 0)