2 DAM .

NET IES AL-ndalus

El lenguaje Visual C# (I)

ndice
1 Tipos de datos comunes..........................................................................................................2
1.1 Tipos de datos predefinidos.............................................................................................3
2 Variables.................................................................................................................................4
2.1 Cmo nombrar variables.................................................................................................4
2.2 Declarar variables............................................................................................................5
2.3 mbito de las variables...................................................................................................6
2.4 Convertir tipos de datos..................................................................................................7
2.4.1 Funciones de conversin..........................................................................................7
3 Constantes...............................................................................................................................9
4 Estructuras..............................................................................................................................9
4.1 Cmo declarar Estructuras.............................................................................................9
4.2 Estructuras predefinidas...............................................................................................10
5 Matrices..................................................................................................................................11
5.1 Crear matrices de tamao calculado.............................................................................12
5.2 Mtodos y propiedades interesantes para matrices.....................................................12
6 Enumeraciones......................................................................................................................14
7 Operadores............................................................................................................................15
7.1 Operadores avanzados...................................................................................................16
7.2 Operadores de comparacin..........................................................................................16
7.3 Operadores lgicos........................................................................................................16
7.4 Prioridad de operadores................................................................................................17
7.4.1 Prioridad entre operadores del mismo grupo........................................................17
7.4.2 Prioridad entre operadores de distintos grupos....................................................17
7.3.1 Uso de parntesis para alterar la prioridad de operadores...................................18

1
2 DAM .NET IES AL-ndalus

1 Tipos de datos comunes.

El tipo de datos de un elemento de programacin hace referencia a la clase de datos que puede
contener y a cmo se almacenan los datos.
El sistema de tipos comunes (Common Type System CTS) define cmo se declaran,
utilizan y gestionan los tipos de datos que soporta el CLR. El sistema de tipos comunes
proporciona:
Integracin entre lenguajes.
Cdigo con seguridad de tipos. nicamente se accede a los tipos de forma permisible y bien
definida.
Permiten una ejecucin de alto rendimiento.

SS i s tt e m a dd ee t ii pp oo s cc o m uu nn e s

TT ii pp oo ss vv aa ll oo rr TT iipp oo ss rr ee ff ee rr ee nn cc ii aa

T ip o s d e d a to s p r e d e fin id o s C adenas
E s tr u c tu r a s d e fin id a s p o r e l M a tr ic e s
u s u a r io
C la s e s
E n u m e r a c io n e s

El sistema de tipos comunes soporta 2 categoras generales de tipos:

Tipos valor. Una variable de tipo valor contiene directamente sus datos. Cada una tiene su
propia copia de los datos, por lo que las operaciones efectuadas sobre una variable no pueden
afectar a otra.
Tipos referencia. Las variables de tipos de referencia contienen referencias a sus datos. Los
datos para estas variables se almacenan en un objeto. Es posible que dos variables de tipos de
referencia apunten al mismo objeto, por lo que las operaciones efectuadas sobre una variable
pueden afectar al objeto apuntado por otra variable de referencia.

2
2 DAM .NET IES AL-ndalus

1.1 Tipos de datos predefinidos.

En la siguiente tabla podemos ver los tipos de datos soportados por el CLR:
Nombre
Tipo de datos
Categora de la Descripcin Intervalo de valores
en C#
clase
Integer Byte Entero de 8 bits sin signo. byte 0 a 255 (sin signo)

Int16 Entero de 16 bits con signo. short -32.768 a 32.767 (con signo)

Int32 Entero de 32 bits con signo. int -2.147.483.648 a 2.147.483.647 (con signo)

-9.223.372.036.854.775.808 a
Int64 Entero de 64 bits con signo. long 9.223.372.036.854.775.807 (9,2...E+18 ) (con
signo)

-3,4028235E+38 a -1,401298E-45 para los

Nmero de punto flotante (32 valores negativos;
Punto flotante Sencillo float
bits) de precisin simple.
1,401298E-45 a 3,4028235E+38 para los
valores positivos

-1,79769313486231570E+308 a
-4,94065645841246544E-324 para los
Tipo Nmero de punto flotante (64 valores negativos;
double
Double bits) de doble precisin. 4,94065645841246544E-324 a
1,79769313486231570E+308 para los valores
positivos

Valor booleano (verdadero o

Lgico Booleano bool true o false
falso).

Otros Tipo Char Carcter Unicode (16 bits). char 0 a 65535 (sin signo)

0 a +/-
79.228.162.514.264.337.593.543.950.335 (+/-
7,9... E+28) sin separador decimal;
0 a +/-7,9228162514264337593543950335
Decimal Valor decimal (128 bits). decimal
con 28 posiciones a la derecha del decimal;
el nmero distinto de cero ms pequeo es +/-
0,0000000000000000000000000001 (+/-
1E-28)

Objetos de Base de la jerarqua de Cualquier tipo puede almacenarse en una

Objecto object
clase objetos. variable de tipo Object

Cadena inmutable de longitud 0 a 2.000 millones de caracteres Unicode

Cadena string
fija de caracteres Unicode. aprox.

En la notacin cientfica, "E" hace referencia a una potencia de 10. Por lo tanto, 3,56E+2 significa 3.56 x 102 o 356, y
3,56E-2 significa 3.56 / 102 o 0,0356.

La especificacin de tipos de datos para todas sus variables se denomina tipado fuerte. Se
recomienda el uso de tipado fuerte porque:
Minimiza la cantidad de memoria que utiliza la aplicacin.
Permite al compilador realizar la verificacin de tipos. Este proceso detecta las instrucciones
que pueden fallar en tiempo de ejecucin debido a variables y valores que no concuerdan.
La ejecucin del cdigo es ms rpida.
Permite el soporte de Microsoft IntelliSense en sus variables. Esta tecnologa permite ver sus

3
2 DAM .NET IES AL-ndalus

propiedades y dems miembros mientras escribe el cdigo.

2 Variables.
Como ya sabemos, las variables almacenan valores que pueden cambiar cuando la aplicacin se
est ejecutando.
Una variable tiene los siguientes elementos:

Elemento Descripcin

Nombre La palabra que utilizamos para hacer referencia a la variable en el cdigo.

Direccin La ubicacin de memoria donde se almacena el valor de la variable.

Tipo de datos El tipo y tamao inicial de datos que la variable puede almacenar.

Valor El valor en la direccin de la variable.

mbito El conjunto de todo el cdigo que puede acceder y utilizar la variable.

Tiempo de vida El intervalo de tiempo durante el cual una variable es vlida y est disponible
para poder ser utilizada. Su valor puede cambiar durante su vida, pero siempre
mantiene alguno mientras existe en memoria.

2.1 Cmo nombrar variables.

Cuando declaramos una variable, es importante desarrollar una estrategia de asignacin de
nombres. Tanto la claridad como la coherencia son importantes, especialmente cuando otros
necesitarn leer o mantener nuestro cdigo.
Debemos tener en cuenta las siguientes reglas:
Iniciar cada nombre de variable con un carcter alfabtico o un guin bajo (_).
No utilizar espacios ni smbolos.
No utilizar palabras clave como int o struct.

Tambin es recomendable:
Dar nombres descriptivos y con significado, como numeroCuenta. Har que el cdigo sea ms
fcil de leer y mantener.
Inicie cada palabra del nombre de una variable pblica con letra mayscula, como
NombreCliente.
Evitar el uso de abreviaturas. Aunque es posible utilizar un nombre de variable como nocta, el
cdigo ser mucho ms fcil de leer si utilizamos el nombre numeroCuenta. En caso de ser
necesario el uso de abreviaturas, debemos asegurarnos de que sean coherentes en toda la

4
2 DAM .NET IES AL-ndalus

aplicacin.
Utilizar un nombre nico dentro del mbito de la variable.
Cuando declaremos variables locales y privadas, iniciaremos la primera palabra con un carcter
en minscula, como en nuevoCliente.

2.2 Declarar variables.

Declaramos una variable para especificar su nombre y caractersticas. La instruccin de
declaracin tanto para variables de tipo valor como de tipo referencia es la instruccin
Sintaxis:
tipo nombreVariable;
Ejemplos:
int numberBooks;
float squareFootage;
Form myForm;
string userInput;
Aunque la sintaxis para declarar variables de tipo valor y de tipo referencia es similar, el entorno
de ejecucin los gestiona de modo distinto. Una variable de tipo referencia siempre contiene un
puntero a un valor de ese tipo o una referencia nula. Una variable de tipo valor contiene el valor
real de la variable.

Antes de poder utilizar variables en su aplicacin, debemos asignarles un valor. Podemos

asignar un valor a una variable despus de declararla o mientras la declara.
NombreVariable = Valor;
Ejemplos:
string goodNews = "Su cheque est en el correo.";
bool testCondicion = true;
float dec = 10.345F;
double real = 12345.981723984;
DateTime cumple;
cumple = new DateTime(1974, 9, 3);
//DateTime cumple = new DateTime(1974, 9, 3);
/* sta es equivalente a la anterior pero en una sola lnea
* DateTime es un objeto y para asignarle un valor inicial utilizaremos
* siempre new NombreClase(argumentos); */
En este ejemplo, hemos visto tambin el objeto de tipo DateTime.
Los valores de cadena (string) deben estar encerrados entre comillas (""). Los valores

5
2 DAM .NET IES AL-ndalus

numricos no necesitan delimitadores. Los caracteres irn entre comillas simples (ej: 'a', 'b', '0', '1',
...)
Si necesitamos especificar decimales, utilizaremos el punto (.) como carcter separador para los
decimales. Para las variables de tipo float, tambin tendremos que aadir el sufijo F al final del
literal.
Las variables booleanas podrn tomar el valor true o false.

Ejemplos:
double precio;
string Valor;
bool Correcto;
string NuevaCadena;
precio = 50.75;
Valor = "mesa";
NuevaCadena = Valor; //asignar una variable a otra
Correcto = true;

2.3 mbito de las variables.

Cuando declaramos variables una de las cosas que tenemos que tener en cuenta es su mbito. Ya
que, si intentamos utilizar una variable fuera de su mbito, el compilador, dar un error.
Con respecto al mbito de una variable, tendremos que familiarizarnos con:

Trmino Definicin

mbito de la variable Conjunto de cdigo al que se refiere una variable por su nombre
asignado, sin cualificadores.

Bloque Bloque de cdigo que empieza con { y termina con un }

Procedimiento Bloque de cdigo que empieza con una instruccin de declaracin como
NombreFuncion(..){ y termina con una instruccin }.

Ensamblado Un archivo ejecutable independiente en el que se compilan los diversos

archivos cuando genera una solucin.

Modificador de acceso Palabra clave como public o private que utilizamos para especificar el
nivel de acceso de una variable o su contenedor (mdulo, clase o
estructura).

Asignamos el mbito de una variable cuando la declaramos. Existen tres factores principales
que afectan al mbito de una variable:
Dnde la declaramos: dentro de un bloque, procedimiento, mdulo, clase o estructura.
El nivel de acceso (public o private) del mdulo, clase o estructura en que se declara. El
mbito de una variable no puede exceder el mbito de su contenedor.

6
2 DAM .NET IES AL-ndalus

La sintaxis que utilizamos para declarar la variable (private o public).

Ejemplo, una variable cuyo mbito es su procedimiento:

public void ShowMessage_Click( ) {
string nombre;
nombre = txtNombre.Text;
MessageBox.Show("Bienvenido de nuevo, " + nombre + "!");
}

Las variables declaradas en una clase o estructura pero no dentro de un procedimiento se

denominan variables de mdulo. Despus de declarar una variable de mdulo, podemos asignarle
un valor, asignar su mbito utilizando un modificador de acceso y utilizarla dentro de ese mbito.
Sintaxis:
ModificadorDeAcceso tipo nombreVariable;
Estos son los modificadores de acceso:

Modificador
mbito Descripcin
de acceso

Private Mdulo Accesible desde cualquier lugar del clase o estructura en el que se
declara. Si declaramos una variable de mdulo sin modificador de
acceso, el acceso predeterminado es Private.

Public Solucin Accesible desde cualquier lugar de la solucin. No hay ninguna

restriccin en el uso de variables Pblicas.

El mbito de una variable de mdulo est determinado no slo por el modificador de acceso
utilizado para declararla, sino tambin por el nivel de acceso del mdulo, clase o estructura en el
que se declara. El mbito de la variable no puede ser mayor que el mbito de su contenedor.

2.4 Convertir tipos de datos.

El proceso de convertir el valor de un tipo de datos en otro se denomina conversin o casting.
Podemos convertir explcitamente valores de un tipo en otro antes de que sean utilizados, evitando
as errores en nuestro cdigo y haciendo que ste se ejecute ms rpidamente. Tambin puede
realizar algunas conversiones de tipos de datos automtica o implcitamente, como convertir
algunas cadenas a enteros. Sin embargo, las conversiones implcitas pueden producir resultados
imprevistos.

2.4.1 Funciones de conversin.

Las funciones de conversin permiten convertir explcitamente un valor de un tipo de datos

7
2 DAM .NET IES AL-ndalus

a otro. Utilizamos funciones de conversin para forzar el resultado de una operacin a un tipo de
datos particular en lugar del tipo de datos por defecto.
Algunas funciones de conversin:

Convierte
Tipos de datos para conversin
Funcin en tipo de
permitidos
dato

System.Convert.ToString() String Cualquier tipo numrico, bool, string,

object

System.Convert.ToInt() Integer Cualquier tipo numrico, bool, string,

object

System.Convert.ToDouble() Double Cualquier tipo numrico, bool, string,

object

System.Convert.ToDateTime() DateTime string, int, float, double

System.Convert.ChangeType() Tipo El mismo tipo que el permitido para la

especificado funcin de conversin correspondiente

Para utilizar una funcin de conversin (hacer una conversin explcita), utilizamos la siguiente
sintaxis:
nombreVariable = FuncionDeConversion(Expresion);
El parmetro expresion puede ser cualquier expresin vlida, como una variable, un resultado
de una funcin o un valor constante.
Ejemplos:
double miDoble;
int miEntero;
miDoble = 2345.5678 ;
miEntero = System.Convert.ToInt32(miDoble);
//miEntero tendr el valor 2346
string miCadenaFecha, miCadenaHora;
DateTime miFecha, miHora;
miCadenaFecha = "February 12, 1969";
miCadenaHora = "4:35:47 PM";
miFecha = System.Convert.ToDateTime(miCadenaFecha);
//Convertimos a tipo de dato DateTime
miHora = System.Convert.ToDateTime(miCadenaHora);
MessageBox.Show(miEntero.ToString() + '\n' +
miFecha.ToString() + '\n' + miHora.ToString() + '\n');

8
2 DAM .NET IES AL-ndalus

3 Constantes.
Las constantes almacenan valores que, como su nombre indica, permanecen constantes durante
la ejecucin de una aplicacin. Algunas ventajas de utilizar constantes son:
Hacen que el cdigo sea ms fcil de leer.
Utilizan menos memoria que las variables.
Hacen que los cambios a nivel de aplicacin sean ms fciles de implementar.

Sintaxis:
const tipo nombreConstante = valor;
Ejemplos:
double area, radio = 4, circunferencia;
const double Pi = 3.1415;
area = Pi * radio * radio;
circunferencia = 2 * Pi * radio;
MessageBox.Show(area.ToString() + '\n' + circunferencia.ToString());

4 Estructuras.
Una estructura es una combinacin de tipos de datos que se crea combinando otros tipos de
datos. Las estructuras son de tipo valor (es decir, una variable de tipo estructura contiene los datos
de la estructura, en lugar de una referencia a los datos como hace el tipo referencia). Las
estructuras pueden tener datos, propiedades, mtodos y procedimientos y pueden invocar y
manipular eventos.
El uso ms simple y habitual de las estructuras es encapsular variables relacionadas, creando un
tipo de datos definido por el usuario. Por ejemplo, es posible que deseemos guardar juntos el
nombre, fecha de contratacin, cargo y salario de un empleado. Podramos utilizar varias variables
para esta informacin, o podemos definir una estructura y utilizarla como la variable de un nico
empleado. La ventaja de la estructura se hace patente cuando tiene muchos empleados y, por
tanto, muchas instancias de la estructura.

4.1 Cmo declarar Estructuras.

El primer paso para crear una estructura es declararla. Podemos declarar estructuras en un
archivo fuente o dentro de un mdulo o clase, pero no dentro de un procedimiento.
Sintaxis:
modificadorDeAcceso structure nombreDeLaestructura
{

9
2 DAM .NET IES AL-ndalus

// Declaracin de los miembros de la estructura

}
Debemos declarar cada miembro de los datos de una estructura y especificar un nivel de acceso.
Esto significa que cada sentencia de la seccin de declaracin de variable de la estructura debe
utilizar private o public.
No podemos inicializar ninguno de los miembros de datos en la declaracin de la estructura. Al
declarar una variable de tipo estructura, asignamos valores a los miembros accediendo a ellos a
travs de la variable.
Puede accederse a las estructuras desde cualquier lugar del archivo, mdulo o clase en el que
estn declaradas. Podemos especificar el nivel de acceso de una estructura como se describe en la
siguiente tabla:

Modificador
Nivel de acceso
de acceso

Public Accesible desde cualquier lugar de la solucin o desde cualquier lugar que haga
referencia al proyecto

Private Accesible nicamente desde el mdulo, archivo u otro elemento de programacin

en el que est declarada, incluyendo desde miembros de cualquier tipo anidado,
como procedimientos.

Ejemplo:
public struct Empleado
{
public string Nombre;
public string Apellido;
public string FechaAlta;
public string Puesto;
public string NumeroEmpleado;
public string Sueldo;
}
//...
Empleado empleado1 = new Empleado();
empleado1.Nombre = "Luis";
MessageBox.Show(empleado1.Nombre);
//...

4.2 Estructuras predefinidas.

Visual C# tambin proporciona numerosas estructuras predefinidas que podemos utilizar. Por

10
2 DAM .NET IES AL-ndalus

ejemplo, la siguiente lista describe varias estructuras existentes:

La estructura Point representa un par ordenado de coordenadas x e y de enteros que define un
punto en un plano bidimensional. Podemos utilizar la estructura Point para capturar la
ubicacin del ratn cuando el usuario hace clic en nuestra aplicacin.
La estructura Color representa un color ARGB (alpha, red, green, blue). Utilizamos la
estructura Color cuando modificamos el color de un formulario o de un control.
La estructura DateTime, en la que a travs de sus miembros compartidos y de instancia, nos
provee de diversas operaciones para el manejo de fechas, como son, saber cual es la fecha
actual, sumar meses o das a una fecha, etc.

5 Matrices.
Una matriz es una secuencia de elementos de datos del mismo tipo. Podemos acceder a
elementos individuales de una matriz utilizando el nombre de la matriz y un ndice o ndices
(empezando por 0) para especificar la posicin del elemento en la matriz. Una matriz tiene una o
ms dimensiones con uno o ms elementos en cada dimensin.
Sintaxis:
modificadorDeAcceso tipo [] NombreDelArray = new tipo[tamao];
El argumento Tamao especifica el nmero inicial de elementos de la matriz. En ocasiones, no
es necesario especificar un modificador de acceso debido a que el mbito de la matriz est
determinado por su ubicacin en el cdigo.
Ejemplo:
float [] gastoDiario = new float[30] ;
int num;
for (num = 0; num < 30; num++)
gastoDiario[num] = 100;
Podemos asignar valores a los elementos de la matriz despus de declararla, o inicializarla
cuando la declaremos, encerrando los valores entre los llaves, como se muestra en el siguiente
ejemplo:
public int [] contadores = new int[]{1, 2, 3, 4, 5, 6, 7};
Para declarar una variable de una matriz multidimensional, aadiremos un par de
corchetes detrs del nombre de la variable y coloque comas dentro del parntesis para separar las
dimensiones, como en el siguiente ejemplo:
public int [,,,] matrizMultidimensional = new int[2,6,4,1];

11
2 DAM .NET IES AL-ndalus

5.1 Crear matrices de tamao calculado.

Nos puede suceder que no sepamos el nmero de elementos que debe tener un array, hasta que
tengamos que crearlo (cuando se est ejecutando nuestro programa), por ejemplo, porque
tengamos que preguntarle al usuario/a cuntos elementos debe tener, o porque el tamao de
pende de cualquier otro tipo factores que se conocern durante la ejecucin de nuestra aplicacin.
En ese caso, podemos proceder como el el siguiente ejemplo:
// 1.- Definimos sin crear el array
string [] nombresEmpleados;
//...
// 2.- Creamos el array con el tamao que nos indique el usuario
nombresEmpleados = new string[int.Parse(this.txtTam.Text)];
// 3.- Introducimos los elementos en el array
for (int i = 0; i < nombresEmpleados.Length; i++)
nombresEmpleados[i] = elementoPedidoAlUsuario();
Podemos ver cmo la declaracin de la matriz es independiente de su creacin. txtTam es un
cuadro de texto en el que el usuario/a escribe el nmero de elementos que debe tener la matriz.
Podemos recorrer todos los elementos de la matriz gracias a su propiedad Length, que siempre
nos indicar cuntos elementos tiene.

5.2 Mtodos y propiedades interesantes para matrices

En el uso de matrices, nos sern de gran utilidad las siguientes propiedades:
Length. Nos indicar el nmero de elementos total de la matriz. Si la matriz tiene varias
dimensiones, ser la suma de todos los elementos de todas sus dimensiones.
Rank. Nos indicar el rango de la matriz (el nmero de dimensiones).
string[] nombresEmpleados;
//...
MessageBox.Show( "El nmero de elementos de la matriz es: "
+ nombresEmpleados.Length.ToString() + '\n'
+ "Y, el nmero de dimensiones es: " +
nombresEmpleados.Rank.ToString());
Adems de las propiedades anteriores, sern tiles los siguientes mtodos:
Sort(tabla). Realiza una ordenacin en contexto de la tabla pasada como argumetno. Se
puede utilizar para ordenar tablas de estructuras y clases que admitan la interfaz Icomparable.
string[] nombresEmpleados;
int[] datos = {3,5,1,2,6,7};
System.Array.Sort(datos);
string resultado = "";

12
2 DAM .NET IES AL-ndalus

foreach (int elemento in datos)

resultado += elemento.ToString() + " ";
MessageBox.Show("El array ordenado ascendentemente es: " + resultado);
// El array ordenado ascendentemente es: 1 2 3 5 6 7
Clear(tabla, inicio, nmeroDeElementos). Cambia el valor de un rango de elementos de
la tabla a 0 (para tipos por valor) o null (para tipos de referencia).
string[] nombresEmpleados;
int[] datos = {3,5,1,2,6,7};
System.Array.Sort(datos, 2, 4);
string resultado = "";
foreach (int elemento in datos)
resultado += elemento.ToString() + " ";
MessageBox.Show("El contenido del array es: " + resultado);
// El array ordenado ascendentemente es: 3 5 0 0 0 0
Clone(). Crea una nueva tabla cuyos elementos son copias de los elementos de la tabla
original. Se puede utilizar para clonar tablas de estructuras y clases definidas por el usuario.
string resultado = "";
int[] datos = {3,5,1,2,6,7};
int[] datosClonado;
datosClonado = (int []) datos.Clone();
string resultado = "";
foreach (int elemento in datosClonado)
resultado += elemento.ToString() + " ";
MessageBox.Show("El contenido del array es: " + resultado);
// El array ordenado ascendentemente es: 3 5 1 2 6 7
Precaucin: el mtodo Clone realiza una copia superficial. Si la tabla contiene referencias a
objetos, se copiarn las referencias pero no los objetos (las dos tablas apuntarn a los mismos
objetos).
GetLength(dimensin). Devuelve la longitud de la matriz en una dimensin (el nmero de
elementos que tiene la matriz en una determinada dimensin).
string resultado = "";
int[,] datos = { { 0, 1, 2, 3 }, { 4, 5, 6, 7 } };
int dim0 = datos.GetLength(0); // == 2
int dim1 = datos.GetLength(1); // == 4
IndexOf(matriz, elemento). Devuelve el ndice entero de la primera vez que aparece un
valor pasado como argumento, o -1 si el valor no est presente. Slo se puede utilizar con tablas
unidimensionales.

13
2 DAM .NET IES AL-ndalus

int[] data = { 4, 6, 3, 8, 9, 3 };
int donde = System.Array.IndexOf(data, 9); // == 4

6 Enumeraciones.
Los tipos de datos comunes permiten que una variable tome un valor de un valor de una lista
ms o menos limitada. Una variable de tipo byte, por ejemplo, puede contener un nmero entre 0 y
255, un bool slo puede tener los valores True o False, y lo mismo ocurre con los tipos enteros y el
tipo Char.
Siempre que necesitemos una variable que deba tomar un valor de una lista limitada, no
existente en ninguno de los tipos comunes ni enumeraciones predefinidas, podemos crear nuestra
propia enumeracin. Por ejemplo: supongamos que en una aplicacin mdica necesitamos
variables que contengan n valores que representan msculos, huesos y otros elementos, podramos
definir las enumeraciones apropiadas. Una de ellas podra ser la siguiente:
enum Dedo
{
Pulgar,
Indice,
Corazn,
Anular,
Meique
}
El identificador Dedo es un nuevo tipo de datos. Podemos utilizarlo como cualquier otro int,
string, double, etc., para declarar variables. Las variables de tipo Dedo tan slo podrn contener
uno de los valores que aparecen en la enumeracin. El editor, al efectuar una asignacin de una
variable de este tipo se ocupa de mostrar la lista de posibles valores.

14
2 DAM .NET IES AL-ndalus

No obstante, manipular una enumeracin va mucho ms all de la asignar y recuperar las

constantes que componen la enumeracin. Cuando declaramos una variable de una enumeracin,
el contenido real de dicha variable es un objeto de la clase enum; por lo tanto, podemos utilizar los
mtodos de dicho objeto, para realizar diversas operaciones.
Ejemplo:
enum Dedo
{
Pulgar,
Indice,
Corazn,
Anular,
Meique
}
private void procedimiento()
{
Dedo dedoAfectado = Dedo.Corazn;
MessageBox.Show(dedoAfectado.ToString());
}
Este ejemplo, mostrar en un cuadro de mensaje la cadena Corazn.

7 Operadores.
Los operadores son aquellos elementos del lenguaje que nos permiten combinar variables,
constantes, valores literales, instrucciones, etc., para obtener un valor numrico, lgico, de cadena,
etc., como resultado.
La combinacin de operadores con variables, instrucciones, etc., se denomina expresin,
mientras que a los elementos integrantes de una expresin y que no son operadores, se les
denomina operandos.

Operador Descripcin

+ Suma o concatenacin de cadenas de caracteres.

- Resta, cambia el signo de un nmero de positivo a negativo o viceversa.

* Multiplicacin.

/ Divisin real. Devuelve el resultado con precisin decimal.

% Resto de la divisin entera.

+ Concatenacin de cadenas de caracteres.

15
2 DAM .NET IES AL-ndalus

7.1 Operadores avanzados.

Estos operadores simplifican la escritura de expresiones, facilitando la creacin de nuestro
cdigo. El resultado empleado operadores abreviados en una expresin, es el mismo que utilizando
la sintaxis normal, pero con un pequeo ahorro en la escritura de cdigo.

Operador Sintaxis en formato largo Sintaxis reducida

+ X=X+6 X += 6

- X=X-6 X -= 6

* X=X*6 X *= 6

/ X=X/6 X /= 6

+ X = X + VB X += VB

7.2 Operadores de comparacin.

Estos operadores permiten comprobar el nivel de igualdad o diferencia existente entre los
operandos de una expresin. El resultado obtenido ser un valor lgico, true (Verdadero) o false
(Falso). La siguiente tabla muestra la lista de los operadores disponibles de este tipo.

Operador Descripcin

> Menor que.

>= Menor o igual.

< Mayor.

<= Mayor o igual.

== Igual.

!= Distinto.

7.3 Operadores lgicos.

C# permitir comprobar ms de una expresin condicional en las estructuras de decisin y
bucles, en el caso de que quiera incluir ms de un criterio. Las condiciones adicionales se enlazarn
mediante el uso de uno o ms de los siguientes operadores lgicos:

Operador Significado

&& Si ambas expresiones condicionales son verdaderas, el resultado es Verdadero.

|| Si alguna de las 2 expresiones es Verdadera, el resultado es Verdadero.

16
2 DAM .NET IES AL-ndalus

! Si la expresin condicional es Falsa, el resultado es Verdadero. Si la expresin

condicional es Verdadera, el resultado es Falso.

Ejemplo:
string vehiculo = "Moto";
int precio= 200;
if (vehiculo == "Moto" && precio < 300)
//las 2 condiciones son ciertas
if (vehiculo == "Coche" || precio < 500)
//por lo menos una de las condiciones es cierta
if (!(precio < 100))
//El resultado es verdadero, porque la condicin es Falsa

7.4 Prioridad de operadores.

Dentro de una lnea de cdigo que contenga varias operaciones, estas se resolvern en un orden
predeterminado conocido como prioridad de operadores.

7.4.1 Prioridad entre operadores del mismo grupo.

La prioridad de los operadores aritmticos se muestra en la siguiente tabla:
Prioridad de operadores aritmticos
Negacin (-)
Multiplicacin y divisin real (*,/)
Resto de divisin (%)
Suma y resta (+,-)
En el caso de operadores con idntica prioridad como multiplicacin y divisin, se resolvern en
el orden de aparicin, es decir, de izquierda a derecha.
Los operadores de comparacin tienen todos la misma prioridad, resolvindose en el
orden de aparicin dentro de la expresin.
La prioridad de los operadores lgicos, podemos verla en esta tabla:
Prioridad de operadores lgicos
Negacin (!)
Conjuncin (&&)
Disyuncin (||)

7.4.2 Prioridad entre operadores de distintos grupos.

Cuando una expresin contenga operadores de distintos grupos, estos se resolvern en el orden

17
2 DAM .NET IES AL-ndalus

marcado en la siguiente tabla:

Prioridad entre operadores de distintos grupos
Aritmticos
Concatenacin
Comparacin
Lgicos

7.3.1 Uso de parntesis para alterar la prioridad de operadores.

Podemos alterar el orden natural de prioridades entre operadores utilizando los parntesis,
encerrando entre ellos los elementos de una expresin que queramos sean resueltos en primer
lugar. De esta forma, se resolvern en primer lugar las operaciones que se encuentren en los
parntesis ms interiores, finalizando por las de los parntesis exteriores. Es importante tener en
cuenta, que dentro de los parntesis se seguir manteniendo la prioridad explicada anteriormente.
El siguiente cdigo fuente en condiciones normales, devolvera false como resultado. Sin
embargo, gracias al uso de parntesis, cambiamos la prioridad predeterminada, obteniendo
finalmente true.
bool resultado;
resultado = ((30 + 5) * 5 > 100) && (52 > 200 / (2 + 5));

18