Características del lenguaje C#

 Es homogéneo. El tamaño de los tipos de datos básicos es fijo e independiente

del compilador, sistema operativo o máquina en la que se compile (no ocurre lo
que en C++), lo que facilita la portabilidad del código.

 Es actual. C# incorpora en el propio lenguaje elementos que se han demostrado

ser muy útiles para el desarrollo de aplicaciones como el tipo
básico decimal que representa valores decimales con 128 bits, lo que le hace
adecuado para cálculos financieros y monetarios, incorpora la
instrucción foreach, que permite una cómoda iteración por colecciones de
datos, proporciona el tipo básico string, permite definir
cómodamente propiedades (campos de acceso controlado), etc.

 Está orientado a objetos. C# soporta todas las características propias del

paradigma de la programación orientada a
objetos: encapsulación, herencia y polimorfismo.

 Delega la gestión de memoria. Como todo lenguaje de .NET, la gestión de la

memoria se realiza automáticamente ya que tiene a su disposición el recolector
de basura del CLR. Esto hace que el programador se desentienda de la gestión
directa de la memoria (petición y liberación explícita) evitando que se cometan
los errores habituales de este tipo de gestión en C++, por ejemplo.

 Emplea un sistema de tipos unificado. Todos los tipos de datos (incluidos los
definidos por el usuario) siempre derivarán, aunque sea de manera implícita, de
una clase base común llamada System.Object, por lo que dispondrán de todos
los miembros definidos en ésta clase. Esto también es aplicable, lógicamente, a
los tipos de datos básicos.

 Proporciona seguridad con los tipos de datos. C# no admiten ni funciones ni

variables globales sino que todo el código y datos han de definirse dentro de
definiciones de tipos de datos, lo que reduce problemas por conflictos de nombres
y facilita la legibilidad del código.

C# incluye mecanismos que permiten asegurar que los accesos a tipos de datos
siempre se realicen correctamente:

o No pueden usarse variables que no hayan sido inicializadas.

o Sólo se admiten conversiones entre tipos compatibles
o Siempre se comprueba que los índices empleados para acceder a los
elementos de una tabla (vector o matriz) se encuentran en el rango de
valores válidos.
o Siempre se comprueba que los valores que se pasan en una llamada a
métodos que pueden admitir un número indefinido de parámetros (de un
cierto tipo) sean del tipo apropiado.

 Facilita la extensibilidad de los operadores. C# permite redefinir el

significado de la mayoría de los operadores -incluidos los de conversión, tanto
para conversiones implícitas como explícitas- cuando se aplican a diferentes tipos
de objetos.
 Aspectos Léxicos
Todas las órdenes acaban con el símbolo del punto y coma ( ;). Los bloques de órdenes
(parte iterativa de un ciclo, partes dependientes de una instrucción condicional -
parte if y parte else-, código de un método, etc.) se encierran entre llaves { } y no
se escribe el ; después de la llave de cierre (observar en el ejemplo el método Main).

C# es un lenguaje orientado a objetos y todo está encapsulado en clases, incluso la

función Main que es un método (especial) del objeto aplicación.

Comentarios

Los comentarios tienen como finalidad ayudar a comprender el código fuente y están
destinados, por lo tanto, a los programadores. No tienen efecto sobre el código
ejecutable ya que su contenido es ignorado por el compilador (no se procesa). La
sintaxis de los comentarios en C# es idéntica a la de C++ y se distinguen dos tipos de
comentarios:

 Comentarios de línea. Están precedidos de la construcción // y su efecto (ámbito)

termina en la línea en la que está inmerso.
 Comentarios de formato libre. Están delimitados por las construcciones /* y */ y
pueden extenderse por varias líneas.

Ejemplos de comentarios

// En una línea, al estilo de C++

/*
En múltiples líneas, como se viene
haciendo desde "los tiempos de C"
*/

/* Este tipo de comentario ya no es habitual */

Palabras reservadas

Las palabras reservadas son identificadores predefinidos reservados que tienen un

significado especial para el compilador por lo que no se pueden utilizar como
identificadores en un programa a menos que incluyan el carácter @ como prefijo.

Las palabras reservadas en C# son, por orden alfabético:

abstract, as, base, bool, break, byte, case, catch, char, checked, class, con
st, continue, decimal, default, delegate, do, double, else, enum, event, exp
licit, extern, false, finally, fixed, float, for, foreach, goto, if, implici
t, in, int, interface, internal, is, lock, long, namespace, new, null, obje
ct, operator, out, override, params, private, protected, public, readonly,
ref, return, sbyte, sealed, short, sizeof, stackalloc, static, string, stru
 ct, switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, u
short,using, virtual, void, volatile, while

Literales

Un literal es una representación en código fuente de un valor. Todo literal tiene

asociado un tipo, que puede ser explícito (si se indica en el literal, mediante algún
sufijo, por ejemplo) o implícito (se asume uno por defecto).

Los literales pueden ser:

 Literales lógicos.

Existen dos valores literales lógicos: true y false. El tipo de un literal lógico
es bool.

 Literales enteros.

Permiten escribir valores de los tipos enteros: int, uint, long y ulong. Los
literales enteros tienen dos formatos posibles: decimal y hexadecimal. Los
literales hexadecimales tienen el sufijo 0x.

El tipo de un literal entero se determina como sigue:

o Si no tiene sufijo, su tipo es int.

o Si tiene el sufijo U o u, su tipo es uint o ulong.
o Si tiene el sufijo L o l, su tipo es long o ulong.
o Si tiene el sufijo UL, Ul, uL, ul, LU, Lu, lU o lu es de tipo ulong.

A la hora de escribir literales de tipo long se recomienda usar L en lugar

de l para evitar confundir la letra l con el dígito 1.

Literales enteros

123 // int
0x7B // hexadecimal
123U // unsigned
123ul // unsigned long
123L // long

 Literales reales.

Los literales reales permiten escribir valores de los

tipos float, double y decimal.

El tipo de un literal real se determina como sigue:

o Si no se especifica sufijo, el tipo es double.

 o Si el sufijo es F o f es de tipo float.
o Si el sufijo es D o d es de tipo double.
o Si el sufijo es M o m es de tipo decimal.

Hay que tener en cuenta que, en un literal real, siempre son necesarios dígitos
decimales tras el punto decimal. Por ejemplo, 3.1F es un literal real, pero no
así 1.F.

Literales reales

1f, 1.5f, 1e10f, 123.456F, 123f y 1.23e2f // float

1d, 1.5d, 1e10d, 123.456D, 123.0 y 123D // double
1m, 1.5m, 1e10m, 123.456M, 123.456m y 12.3E1M //
decimal.

 Literales de caracteres.

Un literal de caracteres representa un carácter único y normalmente está

compuesto por un carácter entre comillas simples, por ejemplo 'A'.

Una secuencia de escape sencilla representa una codificación de caracteres

Unicode y está formada por el carácter \ seguido de otro carácter. Las secuencias
válidas se describe en la siguiente tabla.

Secuencia de escape Nombre del carácter Codificación Unicode

\' Comilla simple 0x0027

\" Comilla doble 0x0022

\\ Barra invertida 0x005C

\0 Null 0x0000

\a Alerta 0x0007

\b Retroceso 0x0008

\f Avance de página 0x000C

\n Nueva línea 0x000A

\r Retorno de carro 0x000D

\t Tabulación horizontal 0x0009

\v Tabulación vertical 0x000B

El tipo de un literal de caracteres es char.

Literales de caracteres
 'A' // caracter sencillo
'\u0041' // caracter Unicode
'\x0041' // unsigned short hexadecimal
'\n' // caracter de escape: CR+LF

 Literales de cadena.

C# admite dos formatos de literales de cadena: literales de cadena típicos y

literales de cadena textuales. El tipo de un literal de cadena es string.

Un literal típico de cadena consta de cero o más caracteres entre comillas dobles y
puede incluir secuencias de escape sencillas y secuencias de escape
hexadecimales y Unicode.

Literales tipicos de cadena

"!Hola, mundo!" // !Hola, mundo!

"!Hola, \t mundo!" // !Hola, mundo!
"" // La cadena vacia

Un literal de cadena textual consta del carácter @ seguido de un carácter de

comillas dobles, cero o más caracteres y un carácter de comillas dobles de cierre.
Por ejemplo, @"Hola". En estos literales los caracteres se interpretan de manera
literal y no se procesan las secuencias de escape, con la única excepción de la
secuencia \". Un literal de cadena textual puede estar en varias líneas.

Literales de cadena textuales

@"!Hola, \t mundo!" // !Hola, \t mundo!

"Me dijo \"Hola\" y me asustó" // Me dijo "Hola" y
me asustó
@"Me dijo ""Hola"" y me asustó" // Me dijo "Hola" y
me asustó
"\\\\servidor\\share\\file.txt" //
\\servidor\share\file.txt
@"\\servidor\share\file.txt" //
\\servidor\share\file.txt
@"uno // Esta es una
cadena distribuida
dos" // en dos lineas.

 Literal null.

Su único valor es null y su tipo es el tipo null.

Aplicaciones en modo consola

 Estas aplicaciones emplean la consola para representar las secuencias de entrada,
salida (y error) estándar.

Una aplicación de consola se crea en Visual Studio .NET

seleccionando Archivo, Nuevo y Proyecto. Cuando aparece la ventana Nuevo
proyectose selecciona Proyectos de Visual C# y Aplicación de consola:

El acceso a la consola lo facilita la clase Console, declarada en el espacio de

nombres System. Esa clase proporciona la compatibilidad básica para aplicaciones que
leen y escriben caracteres en la consola. No es necesario realizar ninguna acción para
poder obtener datos de la consola a partir de la entrada estándar (teclado) o
presentarlos en la salida estándar (consola) ya que estos flujos (junto con el del error
estándar) se asocian a la consola de manera automática, como ocurre en C++, por
ejemplo, con cin, cout y cerr.

Los métodos básicos de la clase Console son WriteLine y ReadLine, junto con sus
variantes Write y Read:

 WriteLine escribe una línea en la salida estándar, entendiendo que escribe el

terminador de línea actual (por defecto la cadena "\r\n").

La versión más simple de este método recibe un único argumento (una cadena)
cuyo valor es el que se muestra:

Console.WriteLine ("!Hola, " + "mundo!");

// Escribe: !Hola, mundo!

Otra versión permite mostrar variables de diferentes tipos (sin necesidad de

convertirlas a string. La llamada tiene un número indeterminado de
argumentos: el primero es una cadena de formato en la que las variables a
mostrar se indican con {0}, {1}, etc. y a continuación se enumeran las variables
a mostrar, entendiendo que la primera se "casa" con {0}, la segunda con {1},
etc. Esta manera de mostrar los datos recuerda a la instrucción printf de C, que
cayó en desuso con C++ ...

int TuEdad = 25;

string TuNombre = "Pepe";
Console.WriteLine ("Tienes {0} años, {1}.", TuEdad, TuNombre);
// Escribe: Tienes 25 años, Pepe.

 El método Write hace lo mismo que WriteLine aunque no escribe el terminador

de línea.
 ReadLine lee la siguiente línea de caracteres de la secuencia de entrada estándar
(el teclado, por defecto), eliminando del buffer de entrada el terminador de línea.
Devuelve la cadena leida, que no contiene el carácter o los caracteres de
terminación.
 Read lee el siguiente carácter de la secuencia de entrada estándar y devuelve un
valor de tipo int. La lectura se realiza del buffer de entrada y no se termina (no
devuelve ningún valor) hasta que se encuentra al caracter de terminación (cuando
el usuario presionó la tecla ENTER). Si existen datos disponibles en el buffer, la
secuencia de entrada contiene los datos introducidos por el usuario, seguidos del
carácter de terminación.

Veamos un sencillo ejemplo sobre el uso de estos métodos.

E/S simple

using System;

class PideNombre
{
static void Main(string[] args)
{
Console.Write ("Introduzca su nombre: ");
// 1
string nombre = Console.ReadLine();
// 2

Console.WriteLine ("Su nombre es: " + nombre);

// 3
Console.ReadLine();
// 4
}
}

La instrucción 1 muestra la cadena Introduzca su nombre: pero no avanza a la

siguiente línea de la consola, por lo que cuando se ejecuta la instrucción 2 lo que
escribe el usuario se muestra a continuación, en la misma línea. La cadena que escribe
el usuario se guarda en la variable nombre y se elimina del buffer de entrada el
terminador de línea. Cuando se valida la entrada (al pulsar ENTER) se avanza a la
siguiente línea. La instrucción 3 muestra una cadena, resultado de concatenar un
literal y la cadena introducida por el usuario. Finalmente, la instrucción 4 es necesaria
para detener la ejecución del programa (realmente, la finalización del mismo) hasta
que el usuario pulse ENTER. Observar que aunque el método Readline devuelva una
cadena, éste valor devuelto no es usado. En la siguiente figura mostramos dos
ejemplos de ejecución.
Aplicaciones Windows

Una aplicación basada en ventanas (aplicación Windows, en lo que sigue) utilizan

ventanas y componentes específicos para interactuar con el usuario. Las peticiones de
datos se realizan con componentes de entrada de texto (por ejemplo, con
un TextBox) o mediante la selección en una lista de posibilidades (por ejemplo, con
un ComboBox). Las salidas pueden realizarse de múltiples maneras, empleando
componentes Label, ventanas de mensajes MessageBox, etc.

Por ejemplo, en la figura siguiente mostramos una aplicación que responde mostrando
una ventana de mensaje (MessageBox) cuando se pincha sobre el botón
titulado Saludo. Basta con ejecutar este código cada vez que se pinche en dicho
botón:

MessageBox.Show ("¡Hola, mundo!", "Un saludo típico");

(en realidad, System.Windows.Forms.MessageBox.Show (...);)

Una aplicación más compleja podría pedir el nombre del usuario en un

componente TextBox y mostrarlo empleando un componente Label cuando se pincha
en el botón titulado Saludo:
 Una aplicación de ventanas se crea fácilmente en Visual Studio .NET
seleccionando Archivo, Nuevo y Proyecto. En la ventana Nuevo proyecto se
selecciona ahora Proyectos de Visual C# y Aplicación para Windows.

Tipos de datos
Los tipos de datos ofrecidos por C# al programador forman parte de un sistema
unificado en el que todos los tipos de datos (incluidos los definidos por el usuario)
derivan, aunque sea de manera implícita, de la clase System.Object. Por herencia
dispondrán de todos los miembros definidos en ésta clase, en particular los útiles
métodos Equals(), GetHashCode(), GetType() y ToString() .

Los tipos de datos en C# pueden clasificarse en dos grandes categorías:

 tipos valor
 tipos referencia

y pueden caracterizarse como sigue:

Tipos valor Tipos referencia

La variable contiene un valor La variable contiene una referencia

El dato se almacena en la pila El dato se almacena en el heap

Una asignación copia el valor Una asignación copia la referencia

int i = 123; // tipo valor

string s = "Hello world"; // tipo referencia

Tipos valor

Los tipos básicos son tipos valor. Si una variable es de un tipo valor contiene
únicamente un valor del tipo del que se ha declarado.
Los tipos predefinidos de C# son tipos disponibles en la plataforma .NET y que, por
comodidad, en C# se emplean usando un alias. En la tabla siguiente enumeramos los
tipos simples detallando su nombre completo, su alias, una breve descripción, el
número de bytes que ocupan y el rango de valores.

Nombre (.NET Tamaño

Alias Descripción Rango
Framework) (bytes)

Bytes con
System.Sbyte sbyte 1 -128 ... 127
signo

Enteros
System.Int16 short 2 -32.768 ... 32.767
cortos

-2.147.483.648 ...
System.Int32 int Enteros 4
2.147.483.647

-9.223.372.036.854.775.808
Enteros
System.Int64 long 8 ...
largos
9.223.372.036.854.775.807

Bytes (sin
System.Byte byte 1 0 ... 255
signo)

Enteros
System.Uint16 ushort cortos (sin 2 0 ... 65.535
signo)

Enteros (sin 0 ...

System.UInt32 uint 4
signo) 18.446.744.073.709.551.615

Enteros
0 ...
System.Uint64 ulong largos (sin 8
18.446.744.073.709.551.615
signo)

Reales (7 ±1.5 x 10-45 ... ±3.4 x

System.Single float 4
decimales) 10+38

Reales (15-
±5.0 x 10-324 ... ±1.7 x
System.Double double 16 8
10+308
decimales)

Reales (28-
±1.0 x 10-28 ... ±7.9 x
System.Decimal decimal 29 12
10+28
decimales)

Caracteres
System.Char char 2 Cualquier carácter Unicode
Unicode

Valores
System.Boolean bool 1 true ó false
lógicos

Tipos referencia

Si un dato es de un tipo referencia contiene la dirección de la información, en

definitiva, una referencia al objeto que contiene los datos y/o métodos. En definitiva,
distinguimos:
 La referencia o un nombre por el que nos referimos al objeto y que utilizamos
para manipularlo.
 El objeto referenciado, que ocupa lugar en memoria (en el heap) y que
almacenará el valor efectivo del objeto.

En definitiva: la variable y su contenido "lógico" están en posiciones de memoria

diferentes. El valor almacenado en una variable de tipo referencia es la dirección de
memoria del objeto referenciado (es una referencia) o tiene el valor null (no
referencia a nada). Observe que pueden existir dos variables que referencien al mismo
objeto (pueden existir dos referencias a la misma zona de memoria).

C# proporciona dos tipos referencia predefinidos: object y string. Todos los demás
tipos predefinidos son tipos valor.

El tipo object es el tipo base del cual derivan todos los tipos básicos predefinidos y
los creados por el usuario.

Los objetos de las clases creadas por el usuario son siempre de tipo referencia. El
operador new permite la creación de instancias de clases definidas por el
usuario. new es muy diferente en C# y en C++:

 En C++ indica que se pide memoria dinámica.

 En C# indica que se llama al constructor de una clase.

El tipo string es un tipo especial de tipo referencia. De hecho, parece más un tipo
valor ante la asignación. Observe el ejemplo:

string s1 = "Hola";
string s2 = s1;

En este punto s2 referencia al mismo objeto que s1. Sin embargo, cuando el valor
de s1 es modificado, por ejemplo con:

s1 = "Adios";

lo que ocurre es que se crea un nuevo objeto string referenciado por s1. De esta
forma, s1 contiene "Adios" mientras que s2 mantiene el valor "Hola". Esto es así
porque los objetos string son immutables, por lo que, para cambiar lo que
referencia una variable string debe crearse un nuevo objeto string.
 Variables y constantes

Variables

Una variable permite el almacenamiento de datos en la memoria. Es una abstracción

que permite referirnos a una zona de memoria mediante un nombre (su identificador).
Todas las variables tienen asociadas un tipo que determina los valores que pueden
almacenarse y las operaciones que pueden efectuarse con los datos de ese tipo.
Además, el término variable indica que el contenido de esa zona de memoria puede
modificarse durante la ejecución del programa.

Nombres de variables

Los nombres que pueden asignarse a las variables deben regirse por unas normas
básicas:

 Pueden contener letras, dígitos y el caracter de subrayado (_).

 No pueden empezar con un número: deben comenzar por una letra letra o con el
carácter de subrayado (_).

Finalmente, recordar que, como identificador que es, el nombre de una variable es
sensible a las mayúsculas y no pueden coincidir con una palabra reservada a no ser
que tenga el prefijo @, aunque no es una práctica recomendada.

Declaración de variables

Antes de usar una variable se debe declarar. La declaración de una variable indica
al compilador el nombre de la variable y su tipo. Una declaración permite que se pueda
reservar memoria para esa variable y restringir el espacio (cantidad de memoria) que
requiere, los valores que pueden asignarsele y las operaciones en las que puede
intervenir.

La sintaxis de una declaración es sencilla: tan sólo hay que especificar el tipo de la
variable y el nombre que se le asocia. La declaración debe concluir con el carácter
punto y coma. Por ejemplo, si vamos a emplear una variable para guardar en ella el
valor del área de un círculo debemos:

 Darle un nombre significativo: Area

 Asociarle un tipo: dado que puede tener decimales y no se requiere una gran
precisión, bastará con el tipo float.

float Area;

Cuando se van a declarar múltiples variables del mismo tipo no es necesario que cada
declaración se haga por separado, pueden agruparse en la misma línea compartiendo
el tipo. Por ejemplo, las declaraciones:
 float Radio;
float Area;

pueden simplificarse en una línea:

float Radio, Area;

De la misma manera pueden declararse e inicializarse variables en una sola línea:

int a=1, b=2, c, d=4;

No existe ninguna zona predeterminada en el código para la declaración de variables,

la única restricción es que la declaración debe realizarse antes de su uso.

No es conveniente abusar de la declaración múltiple de variables en una línea. Desde

el punto de vista de la legibilidad es preferible, por regla general, que cada variable se
declare separadamente y que la declaración vaya acompañada de un breve
comentario:

float Radio; // Radio del circulo del cual se calcula

el area.
float Area; // Area del circulo

Acceso a variables

Una variable se usa para asignarle un valor (acceso de escritura) o para utilizar el valor
almacenado (acceso de lectura).

Una vez declarada una variable debe recibir algún valor (es su misión, después de
todo). Este valor lo puede recibir de algún dispositivo (flujo de entrada) o como
resultado de evaluar una expresión. La manera más simple de proporcionar un valor a
una variable es emplear la instrucción de asignación:

Radio = 10.0F;

En el ejemplo se asigna el valor (literal entero) 10 a la variable Radio. El valor que

tuviera almacenado la variable Radio se pierde, quedando fijado a 10.

En la misma línea de la declaración puede asignarse un valor a la variable, por lo que

declaración e inicialización:
 float Radio; // Declaracion
Radio = 10.0F; // Inicializacion

pueden simplificarse en una sola línea:

float Radio = 10.0F; // Declaracion e Inicializacion

La manera más simple de leer el valor de una variable es emplearla como parte de una
expresión, por ejemplo, en la parte derecha de una instrucción de asignación:

Area = 2 * 3.1416F * Radio * Radio;

La variable Radio (su valor) se emplea en la expresión 2 * 3.1416 * Radio *

Radio para calcular el área de un círculo de radio Radio. Una vez calculado el valor
de la expresión, éste se asigna a la variable Area.

Otra manera de acceder al valor de una variable para lectura es emplearla como el
argumento de una instrucción de escritura WriteLine. Por ejemplo,

Console.WriteLine(Area);
mostrará en la consola el valor de la variable Area.

Leer el valor de una variable no modifica el contenido de la variable.

A modo de resumen, un programa que calcula y muestra el área de un círulo de

radio 10 es el siguiente:

Calculo del área de un círculo (1)

using System;

class Area1
{
static void Main(string[] args)
{
float Radio = 10.0F;
float Area = 2 * 3.1416F * Radio * Radio;
Console.WriteLine(Area);
Console.ReadLine();
}
}

Como puede parecer evidente, emplear una variable que no ha sido declarada produce
un error en tiempo de compilación. En C#, además, hay que asignarle un valor antes
de utilizarla. Si no se hace se genera un error en tiempo de compilación ya que esta
comprobación (igual que ocurre en Java) se efectúa por el compilador.
 void f()
{
int i;
Console.WriteLine(i); // Error: uso de la variable
local no asignada 'i'
}

Constantes

Una constante se define de manera parecida a una variable: modeliza una zona de
memoria que puede almacenar un valor de un tipo determinado. La diferencia reside
en que esa zona de memoria (su contenido) no puede modificarse en la ejecución del
programa. El valor de la constante se asigna en la declaración.

Sintácticamente se especifica que un dato es constante al preceder con la palabra

reservada const su declaración. Por ejemplo, para declarar un a constante de
tipo float llamada PI y asignarle el valor (constante) 3.1416 se escribirá:

const float PI = 3.1416F;

Solo se puede consultar el valor de una constante, nunca se debe intentar modificarlo
porque se produciría un error en tiempo de compilación. Por ejemplo, la siguiente
instrucción:

Area = 2 * PI * Radio * Radio;

utiliza la constante PI declarada anteriormente, usando su valor para evaluar una
expresión.

Podemos modificar el programa anterior para que utilice la constante PI:

Calculo del área de un círculo (2)

using System;

class Area2
{
static void Main(string[] args)
{
const float PI = 3.1416F;
float Radio = 10.0F;
float Area = 2 * PI * Radio * Radio;
Console.WriteLine(Area);
Console.ReadLine();
}
}
Ámbito de variables y constantes

El ámbito (del inglés scope) de una variable y/o constante indica en qué partes del
código es lícito su uso.

En C# el ámbito abarca desde el lugar de su declaración hasta donde termina el bloque

en el que fue declarada.

En el ámbito de una variable no puede declararse otra variable con el mismo nombre
(aunque sea en un bloque interno, algo que si está permitido en C++):

static void Main(string[] args)

{
float Radio = 10.0F;
...
if (Radio > 0){
float Radio = 20.0F; // Error: No se puede
declarar una variable
// local denominada
'Radio' en este ámbito.
}
...
}

Operadores y expresiones
Un operador está formado por uno o más caracteres y permite realizar una
determinada operación entre uno o más datos y produce un resultado. Es una manera
simbólica de expresar una operación sobre unos operandos.

C# proporciona un conjunto fijo, suficiente y completo de operadores. El significado de

cada operador está perfectamente definido para los tipos predefinidos, aunque algunos
de ellos pueden sobrecargarse, es decir, cambiar su significado al aplicarlos a un tipo
definido por el usuario.

C# dispone de operadores aritméticos, lógicos, relacionales, de manipulación de bits,

asignación, para acceso a tablas y objetos, etc. Los operadores pueden presentarse
por diferentes criterios, por ejemplo, por su funcionalidad:

Categorías Operadores

+ - * /
Aritméticos
%
& | ^ ! ~ &&
Lógicos (booleanos y bit a bit)
||
Concatenación de cadenas +
Incremento y decremento ++ --
 Desplazamiento << >>
Relacionales == != < > <= >=
= += -= *= /=
Asignación %= &=
|= ^= <<= >>=
Acceso a miembros .
Acceso por índices []
Conversión de tipos explícita ()
Conditional ? :
Creación de objetos new
Información de tipos as is sizeof typeof
Control de excepciones de
checked unchecked
desbordamiento

Direccionamiento indirecto y
* -> [] &
dirección

 Los operadores aritméticos de C# son los que se emplean comúnmente en otros

lenguajes: + (suma), - (resta), * (multiplicación), /(división) y % (módulo o resto
de la división).

Son operadores binarios y se colocan entre los argumentos sobre los que se
aplican, proporcionando un resultado numérico (Por ejemplo, 7+3.5, 66 % 4).

 Los operadores lógicos proporcionan un resultado de tipo lógico ( bool) y

los operadores a nivel de bit actúan sobre la representación interna de sus
operandos (de tipos enteros) y proporcionan resultados de tipo numérico.

Los operadores binarios son: & (operación Y lógica entre argumentos lógicos u
operación Y bit a bit entre operandos numéricos), |(operación O, lógica ó bit a bit,
dependiendo del tipo de los argumentos) , ^ (O exclusivo, lógico ó bit a bit), && (Y
lógico, que evalúa el segundo operando solo cuando es necesario) y || (O lógico,
que evalúa el segundo operando solo cuando es necesario).

Los operadores unarios son: ! (negación o complemento de un argumento lógico)

y ~ (complemento bit a bit de un argumento numérico).

 El operador + para la concatenación de cadenas es un operador binario.

Cuando al menos uno de los operandos es de tipo stringeste operador actúa
uniendo las representaciones de tipo string de los operandos.
 Operadores de incremento y decremento. El operador de incremento (++)
incrementa su operando en 1 mientras que el de decremento ( --) decrementa su
 operando en 1. Puede aparecer antes de su operando: ++v (incremento prefijo) o
después: v++(incremento postfijo).

El incremento prefijo hace que el resultado sea el valor del operando después de
haber sido incrementado y el postfijo hace que el resultado sea valor del operando
antes de haber sido incrementado.

Los tipos numéricos y de enumeración poseen operadores de incremento y

decremento predefinidos.

 Los operadores de desplazamiento son operadores binarios. Producen un

desplazamiento a nivel de bits de la representación interna del primer operando
(de un tipo entero), a la izquierda (<<) o a la derecha (>>) el número de bits
especificado por su segundo operando.
 Los operadores relacionales proporcionan un resultado lógico, dependiendo de
si sus argumentos son iguales (==), diferentes (!=), o del orden relativo entre
ellos (<, >, <= y >=).
 La asignación simple (=) almacena el valor del operando situado a su derecha en
una variable (posición de memoria) indicada por el operando situado a su
izquierda.

Los operandos deben ser del mismo tipo o el operando de la derecha se debe
poder convertir implícitamente al tipo del operando de la izquierda).

El operador de asignación = produce los siguientes resultados:

o En tipos simples el funcionamiento es similar al de C++, copia el contenido

de la expresión de la derecha en el objeto que recibe el valor.
o En datos struct realiza una copia directa del contenido, como en C++.
o En clases se copia la referencia, esto es, la dirección del objeto, provocando
que el objeto sea referenciado por más de una referencia.

Este comportamiento es distinto al que se produce en C++, en el que se

copia el contenido del objeto. Si el objeto contiene estructuras más
complejas, C++ requiere normalmente la sobrecarga del operador para
personalizar la manera en que se realiza la copia para que cada instancia de
la clase (fuente y destino) maneje su propia zona de memoria. En C# no se
permite la sobrecarga del operador =

Los otros operadores de esta categoría realizan, además de la asignación otra

operación previa a la asignación. Por ejemplo,

a += 22;

equivale a

a = a + 22;
 o sea, primero se calcula la expresión a+22 y posteriormente,ese valor se
almacena en a.

De la misma manera actúan los demás operadores de asignación: -

=, *=, /=, %=, &=, |=, ^=, <<= y >>=.

 El operador de acceso a miembros es el operador punto (.) y se emplea para

acceder a los miembros (componentes) de una clase, estructura o espacio de
nombres.
 El operador de acceso por índices es el tradicional, formado por la pareja de
caracteres [ y ]. En C# también se emplea para especificar atributos.
 El operador de conversión explícita de tipos (casting) es el clásico, formado
por la pareja de caracteres ( y ).
 Creación de objetos (new). El operador new permite crear instancias de una clase
definida por el usuario.
 Control de excepciones de desbordamiento: checked y unchecked