¿Qué son los tipos de Datos?

Una variable contiene datos de un tipo específico. Cuando declaramos una variable
para almacenar los datos en una aplicación, debemos elegir un tipo de dato
adecuado para los datos. Visual C# es un lenguaje de tipos seguros “Type-Safe”,
esto significa que el compilador garantiza que los valores almacenados en las
variables siempre son del tipo apropiado.

La siguiente tabla muestra los tipos de datos más comunes que son utilizados en
Visual C#.

La siguiente tabla muestra los operadores más comunes que podemos utilizar en
Visual C# agrupados por tipo.

Declaración y asignación de variables

Antes de utilizar una variable, debemos declararla. Al declararla podemos
especificar su nombre y características. El nombre de la variable es referido como
un Identificador. Visual C# tiene reglas específicas relacionadas con el uso de los
identificadores:
• Un identificador solo puede contener letras, dígitos y el carácter guion bajo.
• Un identificador debe iniciar con una letra o un guion bajo.
• Un identificador no debería ser una de las palabras clave que visual C#
reserva para su propio uso.
Visual C# es sensible a mayúsculas y minúsculas, por ejemplo, la variable
IDEmpleado es distinta a la variable idempleado. Nosotros podemos declarar 2
variables llamadas IDEmpleado y idempleado al mismo tiempo y Visual C# no se
confundirá, sin embargo, esta no es una buena práctica de codificación.

Al declarar una variable, debemos elegir un nombre que tenga significado respecto
a lo que almacena, de esta forma, el código será más fácil de entender. Debemos
también adoptar una convención de nombres y utilizarla.

Cuando se declara una variable, se reserva un espacio de almacenamiento en

memoria para esa variable y el tipo de datos que va a contener. Podemos declarar
múltiples variables en una sola declaración utilizando el separador coma (,), todas
las variables declaradas de esta manera, son del mismo tipo de datos. El siguiente
ejemplo, muestra como declarar una nueva variable.
int Precio;
int Impuesto, Descuento;

Después de declarar la variable, podemos asignarle un valor utilizando una

operación de asignación.

Durante la ejecución de la aplicación, podemos cambiar el valor de una variable

tantas veces como queramos. El operador de asignación = nos permite asignar
un valor a una variable.

El siguiente código muestra cómo utilizar el operador = para asignar el valor a una
variable.
Precio = 120;

El valor del lado derecho de la expresión es asignado a la variable que se encuentra

en el lado izquierdo de la expresión.

También es posible declarar una variable y asignar su valor al mismo tiempo. El

siguiente ejemplo declara una variable de tipo entero llamada Precio y le asigna el
valor 120.
int Precio = 120;

Cuando declaramos una variable, esta contiene un valor aleatorio hasta que le
asignamos un valor.

Este comportamiento fue una poderosa fuente de errores en C y C++ que nos
permitían declarar variables y utilizarlas accidentalmente sin haberles asignado
previamente un valor. Visual C# no nos permite utilizar una variable que no haya
sido previamente asignada. Debemos asignar un valor a una variable antes de que
la utilicemos, de lo contrario, la aplicación podría no compilar.

INSTRUCCIONES BÁSICAS

using System;

namespace holamundo
{
class Program
 {
static void Main(string[] args)
{
Console.WriteLine("HOLA MUNDO!");
}
}
}

En este caso, la palabra reservada using actúa como una directiva del compilador,
haciendo que se puedan utilizar tipos definidos en el espacio de nombres importado
sin necesidad de especificarlos de forma explícita en el código.

using System;
using System.Collections;...

En C# los Namespaces se componen de un conjunto de objetos relacionados

como clases, delegados, estructuras, interfaces, etc. Así mismo con los
Namespaces organizamos mejor nuestro código y lo mantenemos bien
limpio y estructurado. Una vez definido el Namespace en un archivo aparte,
podemos acceder a las clases y demás elementos definidos en ello. Una de las
ventajas de usar Namespaces es la rapidez y el ahorro de escritura de código,
ya que evitamos escribir el Namespace completo dentro de nuestro código.

Clases y objetos
Las clases son los tipos más fundamentales de C#. Una clase es una estructura de
datos que combina estados (campos) y acciones (métodos y otros miembros de
función) en una sola unidad. Una clase proporciona una definición para instancias
creadas dinámicamente de la clase, también conocidas como objetos. Las clases
admiten herencia y polimorfismo, mecanismos por los que las clases derivadas
pueden extender y especializar clases base.

Las clases nuevas se crean mediante declaraciones de clase. Una declaración de

clase se inicia con un encabezado que especifica los atributos y modificadores de
la clase, el nombre de la clase, la clase base (si se indica) y las interfaces
implementadas por la clase. Al encabezado le sigue el cuerpo de la clase, que
consta de una lista de declaraciones de miembros escritas entre los delimitadores
{ y }.

Las palabras public y static son atributos del método. La palabra void indica
que el método main no retorna ningún valor. La forma (String args[]) es la
definición de los argumentos que recibe el método main.

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!

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, hay que 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írculo de
radio 10 es el siguiente:

Cálculo 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();
}
}

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:
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.

Estructuras de control

Las estructuras de control de C# son similares a las de C y C++. La diferencia más

notable radica en que la instrucción condicional if y los ciclos while y do están
controlados por una expresión lógica (tipo Boolean).

Esta restricción hace que las instrucciones sean más seguras al evitar posibles
fuentes de error, o al menos, facilitan la legibilidad del código. Por ejemplo, en la
siguiente instrucción (válida en C++):
if (a)

La expresión a podría ser una expresión boolean pero también de tipo int, char,
float *... y la condición se evalúa como true cuando a es distinto de cero (valor
entero 0, carácter 0).
Estructuras condicionales
if, if-else

La estructura condicional tiene la sintaxis clásica, con la diferencia indicada

anteriormente acerca del tipo de la expresión. Si debe ejecutar más de una
instrucción, se encierran en un bloque, delimitado por las llaves { y }.

Si sólo se actúa cuando la condición es cierta:

Si se actúa cuando la condición es falsa se emplea la palabra reservada else:

Puede escribirse una instrucción condicional dentro de otra instrucción condicional,

lógicamente:

La concordancia entre if y else se establece de manera sencilla: cada else se asocia

al último if que no tenga asociado un bloque else.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraCondicionalCompuesta2
{
class Program
{
static void Main(string[] args)
{
int num1, num2;
string linea;
Console.Write("Ingrese primer valor:");
linea = Console.ReadLine();
num1 = int.Parse(linea);
Console.Write("Ingrese segundo valor:");
linea = Console.ReadLine();
num2 = int.Parse(linea);
if (num1 > num2)
{
int suma, diferencia;
suma = num1 + num2;
diferencia = num1 - num2;
Console.Write("La suma de los dos valores es:");
Console.WriteLine(suma);
Console.Write("La diferencia de los dos valores es:");
Console.WriteLine(diferencia);
}
else
{
int producto, division;
producto = num1 * num2;
division = num1 / num2;
Console.Write("El producto de los dos valores es:");
Console.WriteLine(producto);
Console.Write("La división de los dos valores es:");
Console.WriteLine(division);
}
Console.ReadKey();
}
}
}

Segundo ejercicio:
using System.Text;
namespace EstructuraCondicionalCompuesta3
{
class Program
{
static void Main(string[] args)
{
int num;
string linea;
Console.Write("Ingrese un valor entero de 1 o 2 dígitos:");
linea = Console.ReadLine();
 num = int.Parse(linea);
if (num < 10)
{
Console.Write("Tiene un dígito");
}
else
{
Console.Write("Tiene dos dígitos");
}
Console.ReadKey();
}
}
}

switch
La estructura de selección múltiple switch funciona sobre cualquier tipo predefinido
y debe indicar explícitamente cómo terminar cada caso generalmente, con break
en situaciones "normales"
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace pruebacaso
{
class Program
{
static void Main(string[] args)
{
int num;
string linea, numero;
Console.Write("Ingrese un valor entero: ");
linea = Console.ReadLine();
num = int.Parse(linea);
switch(num)
{
case 1:
numero="uno";
break;
case 2:
numero="dos";
break;
case 3:
numero="tres";
break;
case 4:
numero="cuatro";
break;
case 5:
numero="cinco";
break;
default:
numero="error";
 break;
}

Console.Write("El numero es: "+numero);

Console.ReadKey();
}
}
}

Estructuras repetitivas
Las estructuras repetitivas de C# (while, do...while, for) no presentan grandes
diferencias respecto a las de otros lenguajes

While

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaWhile
{
class Program
{
static void Main(string[] args)
{
int fac=1,x,n;
string linea;
x = 1;
Console.Write("Ingrese un numero entero: ");
linea = Console.ReadLine();
n = int.Parse(linea);
while (x <= n)
{
fac = fac * x;
x = x + 1;
}
Console.Write("La factorial es: "+fac);
Console.ReadKey();
}
}
}
Ejercicio 2
Desarrollar un programa que permita ingresar n números enteros y luego nos
imprima cuántos valores fueron pares y cuántos impares.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaWhile
{
class Program
{
static void Main(string[] args)
{
int n, x, valor, pares, impares;
string linea;
x = 1;
pares = 0;
impares = 0;
Console.Write("Cuantos el valor de n:");
linea = Console.ReadLine();
n = int.Parse(linea);
while (x <= n)
{
Console.Write("Ingrese el valor "+x+": ");
linea = Console.ReadLine();
valor = int.Parse(linea); ;
if (valor % 2 == 0)
{
pares = pares + 1;
}
else
{
impares = impares + 1;
}
x = x + 1;
}
Console.Write("Cantidad de pares:");
Console.WriteLine(pares);
Console.Write("Cantidad de impares:");
Console.Write(impares);
Console.ReadKey();
}
}
}
do...while

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile
{
class Program
{
static void Main(string[] args)
{
int suma, cant, valor, promedio;
string linea;
suma = 0;
cant = 0;
do
{
Console.Write("Ingrese un nimero (0 para finalizar):");
linea = Console.ReadLine();
valor = int.Parse(linea);
if (valor != 0)
{
suma = suma + valor;
cant++;
}
} while (valor != 0);
if (cant != 0)
{
promedio = suma / cant;
Console.Write("El promedio de los valores ingresados es:");
Console.Write(promedio);
}
else
{
Console.Write("No se ingresaron valores ");
}
Console.ReadLine();
}
}
}

For
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaWhile
{
class Program
{
static void Main(string[] args)
{
int fac=1,n;
string linea;
Console.Write("Ingrese un numero entero: ");
linea = Console.ReadLine();
n = int.Parse(linea);
for(int i=1; i<=n; i++ ) {
fac = fac * i;
}
Console.Write("La factorial es: "+fac);
Console.ReadKey();
}
}
}