Arras Tre

1
Tabla de contenido
1. VARIABLES ..................................................................................................................... 4
1.1. Tipos de datos básicos............................................................................................... 4
1.2. Orden de inicialización de variables .......................................................................... 5
2. OPERADORES Y EXPRESIONES ....................................................................................... 6
2.1. Operadores aritméticos: ........................................................................................... 6
2.2. Operadores relacionales ........................................................................................... 6
2.3. Orden de operación .................................................................................................. 6
3. ESTRUCTURA DE SELECCIÓN ......................................................................................... 9
3.1. Estructura if ............................................................................................................... 9
3.2. Estructura if- else ...................................................................................................... 9
3.3. Estructura switch ..................................................................................................... 10
4. ESTRUCTURAS REPETITIVAS ........................................................................................ 13
4.1. El bucle for............................................................................................................... 15
4.2. El bucle while........................................................................................................... 15
4.3. El bucle do while ..................................................................................................... 16
5. Depuración ...................................................................................................................... 17
6. Métodos .......................................................................................................................... 18
6.1. La estructura de un método ........................................................................................ 18
6.2. Tipos de parámetro ..................................................................................................... 20
7. Argumentos ..................................................................................................................... 23
Main () y argumentos de la línea de comandos ...................................................................... 24
8. Excepciones ..................................................................................................................... 27
8.1. Lanzamiento de Excepciones ...................................................................................... 28
8.2. Captura de excepciones con System.Exception .......................................................... 30
9. Arreglos ........................................................................................................................... 36
9.1. Definición .................................................................................................................... 36
9.2. Declaración de un Arreglo de tipo Vector ................................................................... 40
9.3. Instanciación ............................................................................................................... 40
9.4. Matrices....................................................................................................................... 42
9.5. Declaración de una Matriz en C# ............................................................................... 42
10. Creación de clases ....................................................................................................... 57
10.1. Cómo declarar una clase ......................................................................................... 58
11. ADO.NET ...................................................................................................................... 67
11.1. Proteger aplicaciones de ADO.NET ......................................................................... 68
3
Introducción
C# es un lenguaje elegante, con seguridad de tipos y orientado a objetos, que permite
a los desarrolladores crear una gran variedad de aplicaciones seguras y sólidas que se
ejecutan en .NET Framework .NET. Puede usar C# para crear aplicaciones cliente de
Windows, servicios web XML, componentes distribuidos, aplicaciones cliente-servidor,
aplicaciones de base de datos y muchas, muchas más cosas. Visual C# proporciona un
editor de código avanzado, prácticos diseñadores de interfaz de usuario, un depurador
integrado y muchas otras herramientas que facilitan el desarrollo de aplicaciones
basadas en el lenguaje C# y .NET Framework.

4
1. VARIABLES
Una variable puede verse simplemente como un hueco en el que se puede almacenar
un objeto de un determinado tipo al que se le da un cierto nombre. Para poderla utilizar
solo lo hay que definirla indicando cuál será su nombre y cuál será el tipo de datos que
podrá almacenar, lo que se hace siguiendo la siguiente sintaxis:
<tipoVariable> <nombreVariable>;
1.1. Tipos de datos básicos

5
1.2. Orden de inicialización de variables
Para deducir el orden en que se inicializarán las variables de un tipo de dato basta saber
cuál es el momento en que se inicializa cada una y cuando se llama a los constructores:
• Los campos estáticos sólo se inicializan la primera vez que se accede al tipo al que
pertenecen, pero no en sucesivos accesos. Estos accesos pueden ser tanto para crear
objetos de dicho tipo como para acceder a sus miembros estáticos. La inicialización se
hace de modo que en primer lugar se dé a cada variable el valor por defecto
correspondiente a su tipo, luego se dé a cada una el valor inicial especificado al definirlas,
y por último se llame al constructor del tipo. Un constructor de tipo es similar a un
constructor normal sólo que en su código únicamente puede accederse a miembros static
(se verá en el Tema 8: Métodos).
• Los campos no estáticos se inicializan cada vez que se crea un objeto del tipo de dato al
que pertenecen. La inicialización se hace del mismo modo que en el caso de los campos
estáticos, y una vez terminada se pasa a ejecutar el código del constructor especificado al
crear el objeto. En caso de que la creación del objeto sea el primer acceso que se haga al
tipo de dato del mismo, entonces primero se inicializarán los campos estáticos y luego los
no estáticos.
• Los parámetros se inicializan en cada llamada al método al que pertenecen con los
valores especificados al llamarlo.
• Las variables locales se inicializan en cada llamada al método al cual pertenecen, pero
tras haberse inicializado los parámetros definidos para el mismo. Si no se les da valor
inicial no toman ninguno por defecto, considerándose erróneo todo acceso de lectura que
se haga a las mismas mientras no se les escriba algún valor.

6
2. OPERADORES Y EXPRESIONES
2.1. Operadores aritméticos:
 + suma a+b
 - resta a-b
 * multiplicación: a*b
 / división: a/b
 % resto: a%b
2.2. Operadores relacionales
 == igualdad: a==b
 ¡= desigualdad: a!=b
 < menor que: a<b
 <= menor o igual: a<=b
 > mayor que: a > b
 >= mayor que o igual a: a>=b
 ¡ negación: ¡a
 & and binario: a&b
 | or binario: a|b
 ^ or exclusivo: a^b
 ~ negación binaria: ~à
 && and lógico: a&&b
 || or lógico: a||b
2.3. Orden de operación

7
C# combina los operadores en grupos y aplica un orden de prioridad a cada
grupo. Este orden de prioridad especifica que operadores se evalúan antes que
otros. La lista con el orden de prioridad es la siguiente, ordenados de mayor
prioridad a menor:
 Expresiones primarias
 Operadores unarios + - ¡ ~ ++ - -
 Operadores multiplicativos * / %
 Operadores aditivos + -
 Operadores de desplazamiento << >>
 Operadores relacionales < > <= >=
 Operadores de igualdad -- ¡=
 AND lógico
 OR lógico
 AND condicional
 OR condicional
Ejm 1:
En este ejemplo podemos observar que al colocar o escribir dos números en la caja de
texto nos muestra la diferencia y entre esos números.

8
namespace WindowsFormsApp1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
string cadena="";
private void button1_Click(object sender, EventArgs e)
{
int N1 = Convert.ToInt32(textBox1.Text);
int N2 = Convert.ToInt32(textBox2.Text);
if (N1==N2)
{
cadena = "son iguales \n";
}
if (N1!=N2)
{
cadena += "son difernetes \n";
}
if (N1>N2)
{
cadena = "N1 es mayor a N2 \n";
}
if (N1<N2)
{
cadena += "N1 es menor a N2 \n";
}
label3.Text = cadena;
}
}
}
9
3. ESTRUCTURA DE SELECCIÓN
3.1. Estructura if
La instrucción if realiza (selecciona) una acción si una condición es verdadera, o
ignora la acción si la condición es falsa.
Una instrucción if simple responde a la siguiente sintaxis:
if (expresión booleana)
Instrucción(es) de condición verdadera.
3.2. Estructura else -if
La instrucción if solo garantiza la ejecución de determinadas acciones basándose en
una condición verdadera (true). Se ejecutan o no se ejecutan. Para controlar tanto la
condición true como la falsa (false) es necesario utilizar la instrucción if…else. Su
sintaxis en la siguiente:
if (expresión booleana)
Instrucción(es) de condición verdadera.
Else
{
10
Instrucción(es) de condición falsa.
3.3. Estructura switch
Cuando hay muchas condiciones a evaluar, la instrucción if…else puede resultar
demasiado compleja de manejar. Una solución mucho más limpia en estos casos consiste
en usar la instrucción switch. La instrucción switch permite cualquier valor entero o de
cadena con múltiples valores. Cuando se produce una coincidencia se ejecutan todas las
instrucciones asociadas con ella. Esta estructura es muy utilizada a la hora de trabajar con
menú dentro de las aplicaciones. La sintaxis es la siguiente:
switch (opcion)
case valor1;
sentencia11;
sentencia12;
...
break
case valor2;
sentencia21;
sentencia22;
...
break
Default:
sentencia1;
11
sentencia2;
...
break;
Ejm 1:
En este ejemplo nos indica que al ingresar un número del uno al cinco nos muestra en el
label el que se ingresó en letras.
{
{
public Form1()
{
}

{
int valor = Convert.ToInt32(textBox1.Text);
switch (valor)
{
case 1:
label2.Text = "UNO";
break;
case 2:
label2.Text = "DOS";
break;
case 3:
label2.Text = "TRES";
break;
case 4:
label2.Text = "CUATRO";
break;
case 5:
label2.Text = "CINCO";
12
break;
default:
label2.Text = " ERROR";
break;
}
}
}
}
Ejm 2:
El siguiente ejemplo se trata sobre login básico para poder ingresar su acceso al programa.
{
{
public Form1()
{
}

{
if (textBox1.Text=="valeria"&& textBox2.Text=="amendano")
{
MessageBox.Show("Datos bien ingresado");
}
else
{
MessageBox.Show("Acceso denegado");
}
}
}
}
13
4. ESTRUCTURAS REPETITIVAS
Los bucles o ciclos repiten una sentencia o una secuencia de sentencias un número
de veces. A dichas sentencias se les conoce como cuerpo del bucle. A cada repetición
del bucle se le llama iteración.
Ejm 1:
En este ejemplo nos indica los número divisibles para 2 en sí que tengan un residuo de 0.
{
{
public Form1()
{
}

{
numero nume = new numero();
nume.p_num_set(int.Parse(textBox1.Text));
nume.ejemplo();
}
}
}
///CLASE
{
class numero
{
int num1;
public void p_num_set(int valor)
{
num1 = valor;
14
}
public void ejemplo ()
{
int i;
for ( i = 0; i <= 10 ; i=i+1)
{
if (i%2==0)
{
MessageBox.Show("los numeros son==>>" + i);
}
}
}
}
}
Ejm 2:
En este ejemplo nos indica el nombre de la columna y el número de filas que se han
ingresado en el datagridview.
{
{
public Form1()
{
}

{
int i = 1;
do
{
dataGridView1.Rows.Add("NUMERO" + i++);
} while (i<=4);
15
}
}
}
4.1. El bucle for
Ejecuta una sentencia o conjunto de sentencias un número finito de veces.
En inicialización se escribe una variable de control de bucle (la cual actúa como
un contador), con su valor inicial. La condición iteración contiene una expresión
lógica que hace que el bucle realice las iteraciones de las sentencias mientras sea
verdadera. Finalmente, en incremento se modifica la variable de control.
for (inicialización; condición_iteración; incremento o decremento)
Sentencia 1...;
Sentencia 2…;
….
Sentencia n;
4.2. El bucle while
Repite la ejecución de una sentencia o de un grupo de sentencias mientras la
condición que se evalúa (al principio del bucle) sea verdadera.
while (condición de bucle)
Sentencias;
}
16
4.3. El bucle do while
Repite le ejecución de una sentencia o de un grupo de sentencias mientras se
cumpla la condición especificada (al menos una vez). La condición del do while
evalúa al final del bucle.
 Contadores: un contador es una variable casi siempre de tipo entero cuyo valor
se incrementa o decrementa en cada repetición del bucle. Es habitual llamar a esta
variable “cont” (contador) o “i” (índice); El contador suele utilizarse de este modo:
1. Se inicializa antes de que comience el bucle. Es decir, se le da un valor inicial Por
ejemplo: cont = 1
2. Se modifica dentro del cuerpo del bucle. Lo más habitual es que se incremente su
valor en una unidad:
Por ejemplo: cont = cont + 1;
Esto quiere decir que el valor de la variable cont se incrementa en una unidad
y es asignado de nuevo a la variable contador. Es decir, si cont valía 1 antes de
esta instrucción, cont valdrá 2 después. Otra forma típica del contador es: cont =
cont – 1.
Formas de incrementar los contadores:
 Acumuladores: Las variables acumuladoras tienen la misión de almacenar los
resultados sucesivos, es decir, de acumular resultados.

17
Las variables acumuladoras también deben ser inicializadas. Si llamamos “acum”
a un acumulador, escribiremos antes de iniciar el bucle algo como esto: acum = 0.
Por supuesto, el valor inicial puede cambiar, dependiendo de la naturaleza del
problema. Más tarde, en el cuerpo del bucle, la forma en la que solemos encontrarla es:
acum = acum + N; otra manera de escribir esta sentencia sería: acum += N.
5. Depuración
Definición
Los errores (sintácticos y semánticos) pueden aparecer en el código de forma
inesperada. Visual Studio ofrece potentes y eficaces herramientas para la depuración de
los errores. El depurador de Visual Studio proporciona un menú Depurar que ofrece
acceso a las herramientas del depurador. Además, el lenguaje C# incorpora técnicas
para controlar las posibles situaciones de error en tiempo de ejecución.
Cuando una aplicación se ejecuta en modo de depuración VS es capaz de conocer qué
ocurre exactamente en cada línea de código. Esa información de depuración está
contenida en los ficheros. En modo depuración podremos:
 Consultar y modificar el valor de las variables,
 Detener un momento la ejecución Editar el código y continuar la ejecución,
 Parar la ejecución en un lugar concreto,
 Ejecutar el programa línea a línea

18
 Realizar llamadas de prueba a métodos en la ventana Inmediato sin ejecutar la
aplicación,
 Etc.
6. Métodos
Definición
Son bloques de instrucciones que devuelven algún tipo de valor cuando se ejecutan.
Pueden ser llamados mediante el nombre y llamar a un método hace que las instrucciones
del método se ejecuten. El uso de métodos mantiene el código legible porque las
instrucciones se colocan en bloques más pequeños, en lugar de un gran bloque de código.
Los métodos también permiten tomar instrucciones que pueden ser ejecutadas varias
veces y colocarlas en un bloque de código que pueden ser llamados todas las veces que
haga falta.
6.1. La estructura de un método
Como mínimo un método está compuesta de las siguientes partes:
 Tipo devuelto
 Nombre del método
 Lista de parámetros
 Cuerpo del método
Todos los métodos se encierran en una clase. Un método no puede existir fuera de una
clase.
Tipo devuelto
Un método comienza definiendo el tipo de datos que devolverá cuando se le llame.

19
Csharp permite escribir un método que no devuelva nada.
Si se quiere devolver un valor de un método se usa la palabra clave return para especificar
el valor que quiere devolverse, la palabra clave va seguida de una expresión que evalúa
el tipo de valor que debe devolverse . Esta expresión puede ser un valor literal, una
variable o una expresión más compleja.
Nombre del método
Todos los métodos deben tener un nombre. Un nombre de método es un identificador
y los nombres del método deben seguir las reglas de nomenclatura de cualquier
identificador.
Lista de parámetros
Se pueden llamar a métodos con los parámetros que se usan para pasar los datos al
método. La lista de parámetros del método aparece entre paréntesis y sigue al nombre del
método. Cada parámetro de la lista de parámetros está separado por una coma e incluye
el tipo de parámetro seguido por su nombre. También se pueden prefijar los parámetros
de la lista de parámetros con modificadores que especifican como se usan sus valores
dentro del método.
Cuerpo del método
El cuerpo del método es el bloque de instrucciones que compone el código del método.
El cuerpo del método esta entre llaves. La llave de apertura se incluye tras la lista de
parámetros del método y la llave de cierre se coloca detrás de la última instrucción del
cuerpo del método.
Como llamar a un método

20
Para llamar a un método se escribe su nombre en el lugar donde debería ejecutarse el
código de este método. Después del nombre del método se escriben dos paréntesis. Como
en todas las instrucciones de C# la instrucción de llamada al método debe terminar con
un punto y coma.
6.2. Tipos de parámetro
C# permite cuatro tipos de parámetros en una lista de parámetros:
 Parámetros de entrada
 Parámetros de salida
 Parámetros de referencia
 Matrices de parámetros
Parámetros de entrada
Los parámetros de entrada son parámetros cuyo valor es enviado al método.
Todos los parámetros que se han usado hasta ahora han sido parámetros de entrada. Los
valores de estos parámetros de entrada se envían a la función, pero el cuerpo del método
no puede cambiar permanentemente sus valores.
Parámetros de salida
Los parámetros de salida son parámetros cuyos valores no se establecen cuando se
llama al método. En su lugar el método establece los valores y los devuelve al elemento
que hace la llamada mediante el parámetro de salida.
Parámetros de referencia
Los parámetros de referencia proporcionan valores por referencia. En otras palabras
el método recibe una referencia a la variable especificada cuando se llama al método. El

21
método puede leer el valor original de la variable y también modificar el valor original
como si fuera un parámetro de salida. Los parámetros de referencia se especifican en listas
de parámetros con la palabra clave ref.
Matrices de parámetros
Los métodos suelen escribirse para recibir un número específico de parámetros. Un
método con una lista de parámetros siempre espera ser llamada con tres parámetros, ni
más ni menos. Sin embargo a veces puede ocurrir que un método no conozca cuantos
parámetros debe aceptar al ser diseñado.
Ejm 1:
En este ejemplo nos indica tres clases de perros diferentes, su altura y su comedia
respectiva a la raza. En si con los datos más importantes del perro.
{
{
public Form1()
{
}

{
perro perrito = new perro();
perrito.nombre = "Boster ";
22
perrito.raza = " pastor Aleman ";

perrito.altura = " 0.50 ";
textBox1.Text = perrito.comer(" ==>CROQUETAS");

{
perrito.nombre = " MONA ";
perrito.raza = " LABRADOR ";
perrito.altura = " 1 M ";
textBox1.Text = perrito.comer(" ==>CARNE");
}

{
perrito.nombre = " FIRULAIS ";
perrito.raza = " SAN BERNARDO ";
perrito.altura = " 1.30 ";
textBox1.Text = perrito.comer(" ==>SOPA");
}
}
}
///CLASE
{
class perro
{
public string nombre;
public string raza;
public string altura;
public string comer(string croquetas)
{
return this.nombre + "mide" + this.altura + "y va a comer" +
croquetas;
}
public void dormir()
{
}
public void ladrar()
{
}
}
Conclusión
C# permite escribir métodos en sus clases de c#. Los métodos pueden ayudar a dividir el
código en partes fáciles de entender y pueden brindar un lugar único en el que almacenar
código que puede ser llamado varias veces.

23
7. Argumentos
Definición
En programación, los argumentos son los valores realmente suministrados a
un procedimiento cuando éste es invocado o llamado. En ocasiones se considera
sinónimo de parámetro, pero técnicamente no significan lo mismo.
Los argumentos pueden (y a menudo es así) variar de llamado en llamado (a diferencia
de los parámetros, que forman parte de la definición estática de un procedimiento).
Un parámetro es una propiedad intrínseca de un procedimiento, dado que está incluido
en su definición. En tanto, los argumentos son más bien los valores actuales asignados a
los parámetros variables cuando la subrutina es llamada. En la práctica no se suele
distinguir tajantemente entre ambos términos.
Argumentos por defecto (omisión)
Una mejora de las funciones en C++ es que se pueden especificar los valores por
defecto para los argumentos cuando se proporciona un prototipo de una función. Cuando
se llama a una función se pueden omitir argumentos e inicializarlos a un valor por defecto.
Un argumento por defecto u omisión es un parámetro que el llamado a una función no va
a proporcionar. Los argumentos por defecto también pueden ser parámetros opcionales.
Si se pasa un valor a uno de ellos, se utiliza ese valor. Si no se pasa un valor a un parámetro
opcional, se utiliza un valor por defecto como argumento.
Todos los argumentos por defecto deben estar situados al final del prototipo o cabecera
de la función. Después del primer argumento por defecto, todos los argumentos
posteriores deben incluir también valores por defecto.

24
Los autores de actividad usan argumentos para definir la manera en que los datos fluyen
hacia dentro de la actividad y fuera de ella. Cada argumento tiene una dirección
especificada: In, Out o InOut.
El tiempo de ejecución del flujo de trabajo garantiza lo siguiente sobre el control de
tiempo del movimiento de los datos dentro y fuera de las actividades:
1. Cuando una actividad empieza a ejecutarse, se calculan los valores de todos sus
argumentos de entrada y de entrada/salida. Por ejemplo, independientemente de
cuándo se llame a Get, el valor devuelto lo calculará el tiempo de ejecución antes
de la invocación de Execute.
2. Cuando se llama a Set, el tiempo de ejecución establece el valor inmediatamente.
3. Los argumentos pueden opcionalmente tener especificado su EvaluationOrder.
EvaluationOrder es un valor basado en cero que especifica el orden en el que se
evalúa el argumento. De forma predeterminada, el orden de evaluación del
argumento no está especificado y es igual al valor de
UnspecifiedEvaluationOrder. Para especificar un orden de evaluación para este
argumento, establezca la propiedad EvaluationOrder con un valor mayor o igual
que cero. Windows Workflow Foundation evalúa argumentos con un orden de
evaluación especificado en orden ascendente. Tenga en cuenta que los argumentos
que no tienen orden de evaluación especificada se evalúan antes que los que tienen
especificado un orden de evaluación.
Main () y argumentos de la línea de comandos

25
El método Main es el punto de entrada de una aplicación de C# (las bibliotecas y los
servicios no requieren un método Main como punto de entrada). Cuando se inicia la
aplicación, el método Main es el primero que se invoca.
Solo puede haber un punto de entrada en un programa de C#. Si hay más de una clase que
tiene un método Main, debe compilar el programa con la opción del
compilador /main para especificar qué método Main desea utilizar como punto de
entrada. Para obtener más información, consulte /main (Opciones del compilador de C#).
C#Copiar
class TestClass
static void Main(string[] args)
// Display the number of command line arguments:
System.Console.WriteLine(args.Length);
 El método Main es el punto de entrada de un programa ejecutable; es donde se inicia
y finaliza el control del programa.
 Main se declara dentro de una clase o estructura. El valor de Main debe
ser estático y no público. (En el ejemplo anterior, recibe el acceso predeterminado
de privado). La clase o estructura envolvente no debe ser estático.
 Main puede tener un tipo de valor devuelto void, int o, a partir de C#
7.1, Task o Task<int>.

26
 Solo si Main devuelve un tipo de valor devuelto Task o Task<int>, la declaración
de Main puede incluir el modificador async, pero tenga en cuenta que se excluirá
de forma específica un método async void Main.
 El método Main se puede declarar con o sin un parámetro string [ ] que contiene los
argumentos de línea de comandos. Al usar Visual Studio para crear aplicaciones de
Windows, se puede agregar el parámetro manualmente o usar la
clase Environment con el fin de obtener los argumentos de la línea de
comandos. Los parámetros se leen como argumentos de línea de comandos
indizados con cero. A diferencia de C y C++, el nombre del programa no se trata
como el primer argumento de línea de comandos.
Introducción
Con esta entrada doy inicio a la serie de artículos de Excepciones en C#. Sin lugar a dudas,
este mecanismo de gestión o control de excepciones que provee el lenguaje de
programación representa el medio para lograr la escritura de programas más robustos y
tolerantes a fallas. El propósito de la serie es que usted aprenda los esenciales de la
manipulación, creación, y control de excepciones (parte 1). A medida que avancemos
(parte 2), también comprenderemos cómo usar excepciones con más precaución (efecto
secundario sobre el rendimiento global de la aplicación), descubrimiento del patrón de
métodos TryXXX, y las alternativas propuestas al uso de excepciones. Inclusive (parte
3), usted aprenderá a crear sus propias excepciones para casos muy específicos requeridos
por el diseño del sistema. En la parte 4, exploraremos las propiedades interesantes de la
clase System.Exception. Finalmente, en la parte 5, introduciré varios ejemplos de las
excepciones más comunes en el Framework .NET.

27
8. Excepciones
Definición
Las excepciones en C# ofrecen un modo estructurado, uniforme y con seguridad de
tipos para el manejo de situaciones de error tanto a nivel de sistema como a nivel de
aplicación.
El mecanismo de excepciones de C# es similar al de C++, con las siguientes diferencias:
 En C#, las excepciones son instancias de tipos clase derivados de la clase
System.Exception
 En C++, cualquier valor de cualquier tipo puede ser utilizado para representar una
excepción.
 En C#, un bloque finally puede ser utilizado para escribir código que se ejecute
tanto si se da una excepción como si no se da. En C++ no existe esa posibilidad si
no es duplicando código.
 En C#, las excepciones de sistema tales como desbordamiento, división por cero
y de referencias nulas tienen clases de excepción bien definidas y condiciones de
error a nivel de aplicación asociadas.
La clase System.Exception
La clase System.Exception es el tipo base de todas las excepciones. Entre sus
propiedades más importantes están:
 Message: es una propiedad de sólo lectura que contiene una descripción de la
causa de la excepción (en forma de cadena legible por el ser humano).
 InnerException: es una propiedad de sólo lectura que contiene la excepción
interna de la excepción. Si su valor es distinto de null, indica que la excepción

28
actual ha sido lanzada en respuesta a otra excepción (que es a la que se llama la
excepción interna).
El valor de estas propiedades puede ser especificado en el constructor de la clase
System.Exception.
8.1. Lanzamiento de Excepciones
Las excepciones pueden ser lanzadas de dos modos:
 Mediante la sentencia throw: Lanza la excepción de modo inmediato e
incondicional. En ningún caso vuelve el control a la sentencia siguiente al throw.
 Durante la ejecución de sentencias y expresiones C# se pueden dar situaciones en
las que la operación no pueda completarse de modo normal y se lance una
excepción.
Por ejemplo, una división entera por cero lanza la excepción
System.DivideByZeroException.
Cuando se lanza una excepción desde el código que está entre las llaves de la cláusula
try, el sistema busca la primera cláusula catch que pueda manejar el tipo de excepción
que se ha lanzado (el tipo de excepción ha de coincidir con el del parámetro que espera
la cláusula catch o bien ser de un tipo derivado al que espera la cláusula catch). Si no se
encuentra la cláusula catch adecuada se sigue buscando la excepción en el punto del
código desde el que se ha llamado al método que contiene la cláusula try donde se ha
lanzado la excepción. Esta operación se repite hasta encontrar una cláusula Catch que
maneje (también se dice “capture”) la excepción.
Es importante tener en cuenta que si se desea que una cláusula Catch capture cualquier
excepción ha de definirse sin parámetros. Una vez se ha encontrado la cláusula catch que
29
maneja la excepción, se transfiere el control a la primera sentencia de tal cláusula. Antes
de ejecutar la primera sentencia de la cláusula catch, se ejecutan todas las cláusulas finally
de las sentencias try anidadas a la que captura la excepción.
Si no se encuentra una cláusula catch puede ocurrir una de las dos opciones siguientes:
 Si la búsqueda llega a un constructor Static o a un inicializador de campos static,
se lanza una excepción System.TypeInicializationException en el punto en el que
se invocó al constructor. El campo InnerExceptio de la excepción
TypeInicializationException contiene la excepción originalmente lanzada.
 Si la búsqueda llega al código que inicialmente comenzó el thread o el proceso, la
ejecución del thread o el proceso finaliza.
La sentencia try-catch está compuesta por un bloque de sentencias proclives a generar
situaciones inesperadas o excepcionales; este bloque (try) se encierra entre corchetes
([try]), y va seguido por una o más clausulas catch. Cada una de las clausulas corresponde
con un tipo de excepción. Debido a que las excepciones integradas en la biblioteca base
de clases y las creadas por el propio programador derivan de la clase base
System.Exception , el orden (arriba-abajo) en que deben organizarse las excepciones ha
de empezar por el tipo de excepción más específico (o con el orden jerarquía menor).
Continuando, el bloque try contiene la sentencia o el conjunto de sentencias proclives
a generar una excepción. En este bloque pueden ocurrir dos situaciones:
 El bloque genera una excepción.
 Finaliza satisfactoriamente y pasa al bloque finally (si ha sido declarado) o la
sentencia inmediata después del bloque try.
Asumamos el siguiente fragmento de código:

30
objeto = null;
try
inti = (int) 0;
// Error
La cláusula catch captura una excepción de tipo InvalidCastException. Esta captura
es tratada en el bloque subsiguiente; en donde podemos mostrar mensajes de error y/o
crear un archivo de registro de los problemas generados en el flujo de ejecución de la
aplicación.
Un bloque try, puede estar seguido por una o más clausulas y deben seguir el orden
(arriba-abajo) de tipos de excepciones específicos a más generales. El compilador de C#,
generará un error al declarar una clausula catch con un tipo general y más adelante uno
específico.
8.2. Captura de excepciones con System.Exception
Con el tipo de excepción System.Exception se captura cualquier tipo de excepción que
produzca dentro de la sentencia try. Indican que esto es útil en las siguientes situaciones:
 Recuperación de la ejecución del programa independiente del tipo específico que
se haya generado.
 Volver a lanzar la excepción, lo anterior sin antes crear un registro.
 Último recurso del manejador de errores antes de la terminación del programa.
bloque finally
31
Esta sección opcional de la sentencia try-catch se ejecutará independiente de si se ha
completado satisfactoriamente el bloque try (es decir, sin generar ninguna excepción),
como no (es decir cuando alguno de los bloques catch ha atrapado (capturado) una
excepción.
En general, el bloque finally se ejecutan en cualquier de las siguientes situaciones:
 Al finalizar el bloque try.
 Uso de las sentencias de salto (goto o return) localizadas en el bloque try.
 Después de finalizar un bloque catch.
Sentencia using
Aquellas clases que implementan la interfaz System.IDisposable encapsulan recursos
no administradores por la CLR, como: archivos, gráficos, o bases de datos. Estas clases
implementan al método abstracto Dispone para la liberación de los recursos (ej.
Memoria) ocupados en su manejo. Para este tipo de clases, la sentencia using provee una
sintaxis más cómoda y versátil que usar la sentencia try-catch-finally.
try
// ...
finally
if (sr != null)
((IDisposable)sr).Dispose();
32
podemos usar la sentencia using:
using (StreamReader sr = File. Open ("archivo.txt"));
// ...
Ejemplo 1:
En este ejemplo podemos observar que nos permite guardar datos sobre un producto.
private StreamWriter escribir;

33
private StreamWriter leer;
public Form1()
int numaux;
if (int.TryParse(textBox2.Text,out numaux))
if (int.TryParse(textBox3.Text,out numaux))
try
double x = Convert.ToDouble(textBox1.Text);
MessageBox.Show("EL NOMBRE DEL PRODUCTO ES
INVALIDO");
textBox1.Text = "";
textBox1.Focus();
catch (FormatException x)
escribir = new StreamWriter("frutalis.text");

34
escribir.WriteLine(textBox1.Text);
escribir.Close();
MessageBox.Show("ARCHIVO GUARDADO");
else
MessageBox.Show("EL PRECIO DEL PRODUCTO NO ES VALIDO");
textBox3.Text = "";
textBox3.Focus();
else
MessageBox.Show("EL PRECIO DEL PRODUCTO NO ES VALIDO");
textBox2.Text = "";
textBox2.Focus();
}
35
dataGridView1.Rows.Add(textBox1.Text, textBox2.Text, textBox3.Text);
Ejemplo 2:
En este ejemplo podemos observar como el de tema de excepciones nos ayuda a pasar el
error de un programa en la cual mientras se ponga dos números estará todo bien pero
sino nos saldrá un error

36
public Form1()
try
textBox3.Text = (Convert.ToDecimal(textBox1.Text) +
Convert.ToDecimal(textBox2.Text)).ToString();
catch (Exception)
MessageBox.Show("NO SE PUEDE HACER CALCULOS");
MessageBox.Show("SOLO NUMEROS!!!!");
9. Arreglos
9.1. Definición
37
Arreglos Un arreglo es un grupo de variables (llamadas elementos) que contienen
valores y todos son del mismo tipo.
Declaración
[[atributos]] [modificadores] tipo [ ] nombre;
 Los [ ] indican al compilador que se está declarando un arreglo, y se los conoce
como el operador índice.
 El tipo indica el tipo de elementos que puede contener el arreglo
 Se instancian usando la palabra clave new
 Los arreglos son tipos referencia y se crean en el heap. Los elementos del arreglo
se crean en la pila o en el heap, según se traten de tipos valor o tipos referencia
respectivamente.
Recordemos que los tipos se dividen en dos categorías: por valor y por referencia. Los
elementos de un arreglo pueden ser tipos por valor o referencia. Para referirnos a un
elemento en especial dentro de un arreglo, especificamos el nombre de la referencia al
arreglo y el número de la posición de este elemento en el arreglo. Al número de la posición
se le conoce como índice del elemento. Una aplicación hace referencia a cualquier
elemento del arreglo mediante una expresión de acceso al arreglo, la cual incluye el
nombre del arreglo, seguido el índice del elemento específico entre corchetes ([ ]). El
primer elemento en cualquier arreglo tiene el índice cero, el cual se conoce como
elemento cero.
Las instancias de los arreglos ocupan espacio en memoria. Al igual que los objetos,
los arreglos se crean con la palabra clave new. Para crear una instancia de un arreglo, se
especifica el tipo y el número de elementos del arreglo, número de elementos como parte
de una expresión de creación de arreglos, que utiliza la palabra clave new. Dicha
38
expresión devuelve una referencia que puede almacenarse en una variable tipo arreglo.
La siguiente expresión de declaración y creación de arreglos crea un objeto que contiene
12 elementos int, y almacena la referencia al arreglo en la variable C.
Int [ ] C = new int [12]
Cabe mencionar, que la expresión anterior puede dividirse en dos partes, así:
Int [ ] C;
C = new int [12];
Ejemplo 1. Se desea guardar los sueldos de 5 empleados de una fábrica X. Según lo que
hemos estudiado hasta el momento, deberíamos definir 5 variables si queremos tener en
un cierto momento los 5 sueldos almacenados en memoria. Empleando un vector, solo se
requiere definir un único nombre y accedemos a cada elemento por medio del subíndice.
1 namespace Ejemplo1
2{
3 class Program
4{
5 static void Main (string [ ] args)
6 { 7 Double[] Sueldos;
8 Sueldos = new Double[5];
9 for (int i = 0; i < 5; i++)
10 {
11 Console.WriteLine("Ingrese el sueldo del empleado" + (i + 1) + ":");

39
12 Sueldos[i] = Double.Parse(Console.ReadLine());
13 }
14 Mostrar(Sueldos);
15 Console.ReadKey();
16}
17 static void Mostrar (Double[] Sueldos)
18 {
19 Console.WriteLine("Los sueldos ingresados son:");
20 for (int i= 0;
Los Arrays se dividen en 2 grupos:
Los Vectores y las Matrices.
Los vectores son arreglos que contienen una sola dimensión y las matrices 2 o más
dimensiones.
ARRAYS UNIDIMENSIONALES (Vectores)
Los arreglos son estructuras de datos complejas (en el sentido de que no son atómicas)
que agrupan datos de un mismo tipo en particular, llamado el tipo base del arreglo. El tipo
base de un arreglo puede ser cualquiera de los tipos básicos de C#, o incluso algunos tipos
complejos como las clases. Un arreglo es también ejemplo de un modelo. Un arreglo
puede considerarse como ejemplo de una variable compuesta capaz de almacenar uno o
más datos al mismo tiempo.

40
9.2. Declaración de un Arreglo de tipo Vector
//Declaración errónea
int valores[ ] ;
//Declaración valida
int [ ] valores;
9.3. Instanciación
Para crear un arreglo haremos uso de la palabra reservada new y los corchetes
cuadrados [ ], también es necesario conocer el tamaño que necesitaremos, puesto que
como ya lo mencioné, no es posible cambiar el tamaño una vez creado:
char [] vocales = new char [5];
int [] conteo = new int [10];
object [] misObjetos = new object[3];

41
Si creamos arreglos de esa manera, cada posición tendrá el valor por default del tipo de
dato del arreglo… bueno, mejor usamos nuestro ejemplo:
 El arreglo de vocales contendrá 5 \0, que es el valor por default de un char.
 El arreglo conteo contendrá 10 0, que es el valor por default de un entero.
 El arreglo misObjetos contendrá 3 null, que es el valor por default de un
object.
Además de la instanciación tradicional, también podemos emplear la instanciación de
colecciones, la cual nos permite inicializar un arreglo asignándole valores inmediatamente:
 char [] vocales = new char[5] { 'a', 'e', 'i', 'o', 'u' };
 int [] conteo = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 object [] misObjetos = { "3", 1, 99.99 };
Como podemos ver, tenemos varias opciones para inicializar arreglos unidimensionales:
1. new char [5] {..., nos permite indicar el tamaño y el tipo explícitamente y
posteriormente indicar los valores, si cambiáramos el 5 por un 7sin aumentar la
cantidad de valores obtendríamos un error de compilación.
2. new int [] {1, 2,..., nos permite indicar solamente el tipo de dato de los elementos,
la cantidad es inferida por el compilador, en este caso podemos incrementar o
reducir la cantidad de elementos al momento de inicializar sin ningún problema.
3. { "3", 1, 99.99 }, al inicializar de esta manera estamos dejándole al compilador
la tarea de inferir tanto el tipo de dato del arreglo como la cantidad de elementos
42
que contiene. Dicho sea de paso, el declarar un arreglo así puede resultar un
poco confuso de leer.
9.4. Matrices
Una matriz es una estructura de datos que permite almacenar un conjunto de datos del
mismo tipo.
Con un único nombre se define la matriz y por medio de DOS sub índices hacemos
referencia a cada elemento de la misma (componente)
Hemos graficado una matriz de 3 filas y 5 columnas. Para hacer referencia a cada
elemento debemos indicar primero la fila y luego la columna, por ejemplo en la
componente 1,4 se almacena el valor 97.
En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz deben
ser del mismo tipo (int, float, string etc.)
Las filas y columnas comienzan a numerarse a partir de cero, similar a los vectores.
9.5. Declaración de una Matriz en C#
 Matrices multidimensionales:
43
 Matrices de matrices (escalonadas):
 Matrices multidimensionales:
 Matrices de matrices (escalonadas):
Matrices unidimensionales:
int[ ] números;
string[,] nombre;
byte[ ][ ] puntuaciones;
Ejemplo 1:
int[] nombres= new int[5];
string[,] nombres= new string[5,4];
byte[][] puntuaciones= new byte[5][];
for (int x = 0; x < puntuaciones.Length; x++)
[x] = new byte[4];
Ejemplo 2. Programa que carga una matriz de una dimensión establecida y muestra los
valores en pantalla.
1 namespace Matrices_Ejemplo1
2{
3 class Program
4{
5 static void Main (string [] args)

44
6{
7 Console.Title = "Ejemplo1 de una matriz 3x4";
8 int [,] Matriz;
9 Matriz = new int[3, 4];
10 //Cargar y visualizar una matriz
11 for (int filas = 0; filas < 3; filas++)
12 {// for externo para filas
13 for (int columnas = 0; columnas < 4; columnas++)
14 {// for interno para columnas
15 Console.Write ("Ingrese el valor de la posición [" + filas + "," + columnas + "]: ");
16 Matriz [filas, columnas] = int.Parse (Console.ReadLine());
17}
18}
19 Console.Write("\n");
20 Console.Write ("Ahora visualizamos la matriz digitada....");
21 Imprimir (Matriz);
22 Console.ReadKey ();
23}
24 static void Imprimir (int [,] Matriz)
25 {
45
26 for (int filas = 0; filas < 3; filas++)
27 {
28 Console.Write ("\n");
29 for (int columnas = 0; columnas < 4; columnas++)
30 {
31 Console.Write("\t" + Matrix[filas, columnas] + "\t");
Ejemplos:
En este ejemplo podemos ver que nos permite ingresar los platos de comida que se
desea vender o buscar el nombre de un plato disponible.
public Form1()
{
46
button3.Enabled = false;
private string[,] mPlatos;
private int cantPlatos;
private int index;
private int encuentra = 0;
private void groupBox2_Enter(object sender, EventArgs e)
private void textBox2_TextChanged(object sender, EventArgs e)
private void Form1_Load(object sender, EventArgs e)
//Entrada de Datos
cantPlatos = Convert.ToInt32(textBox2.Text);
//Inicializamos la matriz
mPlatos = new string[cantPlatos, 3];

47
//Ingresamos datos a la matriz con un inputBox
//Para ingresar datos a la matriz
for (int i = 0; i < cantPlatos; i++)
mPlatos[i, 0] = Microsoft.VisualBasic.Interaction.InputBox("Ingrese Nombre
del plato " + (i + 1), "Restaurant");
mPlatos[i, 1] = Microsoft.VisualBasic.Interaction.InputBox("Ingrese Precio
del plato " + (i + 1), "Restaurant");
mPlatos[i, 2] = Microsoft.VisualBasic.Interaction.InputBox("Ingrese Cantidad
disponible del plato " + (i + 1), "Restaurant");
//Declaración de variables
string plato;
//Entrada de Datos
plato = textBox3.Text;
//Filtramos el plato en la matriz
for (int i = 0; i < cantPlatos; i++)
if (mPlatos[i, 0].Equals(plato))
textBox4.Text = mPlatos[i, 1];
textBox5.Text = mPlatos[i, 2];

48
index = i;
button3.Enabled = true;
encuentra = 1;
if (encuentra == 0)
MessageBox.Show("No existe el plato", "Restaurant",
MessageBoxButtons.OK, MessageBoxIcon.Error);
button3.Enabled = false;
//Declaración de variables
int cant, stock;
//Entrada de Datos
cant = Convert.ToInt32(textBox2.Text);
stock = Convert.ToInt32(textBox5.Text);
if (cant <= stock)
//Disminuimos el stock de ese plato
mPlatos[index, 2] = Convert.ToString(stock - cant);
else
49
MessageBox.Show("No hay Suficiente Stock", "Restaurant",
MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
Ejemplo:
En este ejemplo podemos observar que se utilizó el método de GAUSJORDAN.
namespace GaussJordan
double[,] matriz = new double[3, 4];
public Form1()
}
50
private void btnResolver_Click(object sender, EventArgs e)
//verificamos informacion de matriz
if (verificarInfo())
//leemos informacion de textbox y generamos la matriz.
if (obtenerMatriz())
//Verificar si existe algun pivote en las filas que se pueda intercambiar
buscarPivoteIntercambiar(matriz);
//comenzamos a checar matriz para ir determinando matriz invertida
algoritmoGauss(matriz);
//dibujar matriz final y valores de las incognitas
dibujarResultado(matriz);
else { MessageBox.Show("Favor de rellenar informacion de matriz."); }
private Boolean verificarInfo()
//Verificamos que contenga informacion en todos los datos de matriz
foreach (Control txt in tlpMatriz.Controls)
if (txt is TextBox)
51
if (txt.Text == "")
return false;
return true;
private Boolean obtenerMatriz()
try
rchTeOperaciones.Text = "* Obteniendo Matriz ..." + Environment.NewLine;
foreach (Control txt in tlpMatriz.Controls)
if (txt is TextBox)
//obtenemos nombre de textbox
string nom = txt.Name;
int posX = Convert.ToInt32(nom.Substring(1, 1));
int posY = Convert.ToInt32(nom.Substring(2, 1));
matriz[posX, posY] = Convert.ToDouble(txt.Text);
}
52
//dibujamos matriz en textbox
int tamMatrizX = matriz.GetUpperBound(1);
int tamMatrizY = matriz.GetUpperBound(0);
for (int i = 0; i <= tamMatrizY; i++)
for (int j = 0; j <= tamMatrizX; j++)
rchTeOperaciones.Text += "" + Environment.NewLine + "Elemento [" +
i + "," + j + "]" + " : " + matriz[i, j];
rchTeOperaciones.Text += "" + Environment.NewLine +
Environment.NewLine;
rchTeOperaciones.Text += "* La matriz aumentada es : " +
Environment.NewLine + Environment.NewLine;
for (int i = 0; i <= tamMatrizY; i++)
for (int j = 0; j <= tamMatrizX; j++)
rchTeOperaciones.Text += " " + matriz[i, j] + " ";
}
53
rchTeOperaciones.Text += Environment.NewLine;
return true;
catch (Exception)
return false;
private void buscarPivoteIntercambiar(Double[,] matriz)
//obtenemos el tamaño de la matriz
int tamMatriz = matriz.GetUpperBound(1);
int pivote = 0;
rchTeOperaciones.Text += " " + Environment.NewLine +
for (int i = 0; i < tamMatriz; i++)
rchTeOperaciones.Text += "* Buscando elementos que sirvan de pivote ,
Columna : " + i + Environment.NewLine;
//verificamos si elemento pivote ya contiene un 1

54
if (matriz[pivote, pivote] != 1)
for (int r = 0; r < tamMatriz; r++)
if (Convert.ToString(matriz[r, i]) == "1" && ((r + i) != (pivote +
pivote)))
rchTeOperaciones.Text += "* Se localizo un pivote en la columna :" +
i + Environment.NewLine;
for (int j = 0; j < tamMatriz + 1; j++)
Double temp = matriz[pivote, j];
matriz[pivote, j] = matriz[r, j];
matriz[r, j] = temp;
rchTeOperaciones.Text += "* Se cambia renglon : " + i + " por
renglon :" + r + Environment.NewLine;
rchTeOperaciones.Text += "" + Environment.NewLine +
rchTeOperaciones.Text += "* La nueva matriz aumentada es : " +
Environment.NewLine + Environment.NewLine;
for (int re = 0; re <= 2; re++)
{
55
for (int j = 0; j <= 3; j++)
rchTeOperaciones.Text += " " + matriz[re, j] + " ";
buscarPivoteIntercambiar(matriz);
pivote++;
private void dibujarResultado(Double[,] matriz)
rchTeOperaciones.Text += "* Resultados Finales : " + Environment.NewLine;
for (int i = 0; i <= tamMatriz - 1; i++)

56
rchTeOperaciones.Text += "Valor x" + i + " : " + matriz[i, tamMatriz] +
rchTeOperaciones.Text += "Proceso terminado" + Environment.NewLine;
private void algoritmoGauss(Double[,] matriz)
int pivote = 0;
for (int i = 0; i <= tamMatriz - 1; i++)
if (matriz[i, i] == 0)
rchTeOperaciones.Text += "Error: " + "no es posible resolver ecuacion";
else
if (matriz[i, i] != 1)
Double divisorPiv = matriz[i, i];
for (int col = 0; col <= tamMatriz; col++)
{
57
matriz[i, col] = matriz[i, col] / divisorPiv;
for (int ren = 0; ren < tamMatriz; ren++)
if (ren != pivote)
Double val0 = -Convert.ToDouble(matriz[ren, i]);
for (int col = 0; col <= tamMatriz; col++)
matriz[ren, col] = matriz[i, col] * val0 + matriz[ren, col];
pivote++;
10. Creación de clases
Una clase es una construcción que permite crear tipos personalizados propios mediante
la agrupación de variables de otros tipos, métodos y eventos. Una clase es como un plano.
Define los datos y el comportamiento de un tipo. Si la clase no se declara como estática,

58
el código de cliente puede utilizarla mediante la creación de objetos o instancias que se
asignan a una variable. La variable permanece en memoria hasta que todas las referencias
a ella están fuera del ámbito. En ese momento, CLR la marca como apta para la
recolección de elementos no utilizados. Si la clase se declara como estática, solo existe
una copia en memoria y el código de cliente solo puede tener acceso a ella a través de la
propia clase y no de una variable de instancia.
 Una clase es básicamente un plano para un tipo de datos personalizado.
 Cuando se define una clase, se utiliza cargándola en la memoria.
 Una clase que se ha cargado en la memoria se denomina objeto o instancia.
 Se crea una instancia de una clase utilizando la palabra clave de C# new.
Cada clase se representa en un rectángulo con tres compartimentos:
 Nombre
 Atributos
 Métodos y propiedades
10.1. Cómo declarar una clase
class nombre_de_la_clase
… contenido de la clase …
Dentro de la clase
Se pueden declarar variables, propiedades, métodos, delegados, eventos, etc.
Cada elemento puede tener un modificador de acceso.

59
Un modificador de acceso especifica quienes están autorizados a “ver” ese elemento.
Si no se especifica ningún modificador de acceso, se asume que se trata de un elemento
“private”.
Modificadores de acceso
 public Accesible a todos los elementos
 private Accesible solo a esa misma clase
 protected Accesible solo a la misma clase y métodos de sus clases derivadas. No
accesible desde el exterior.
 internal Accesible solo a ese ensamblado.
 protected internal Accesible desde el mismo ensamblado, la misma clase y
métodos de sus clases derivadas.
Miembro estático (static):
Sólo se crea una copia del miembro de la clase. Se crea cuando se carga la aplicación
que contiene la clase y existe mientras se ejecute la aplicación
Miembro de instancia
Se crea por default. Se crea una copia para cada instancia de la clase.
Miembros estáticos y de instancia
Un miembro estático es un método o campo al que se puede obtener acceso sin hacer
referencia a una instancia determinada de una clase.
No es necesario crear una instancia de la clase contenedora para llamar al miembro
estático.
60
Cuando se tiene acceso a métodos estáticos, puede utilizar el nombre de clase, no el
nombre de instancia.
Declaración de miembros estáticos
Cuando declara un campo de clase estático, todas las instancias de esa clase
compartirán ese campo.
Una clase estática es una cuyos miembros son todos estáticos.
static void Main(string[] args)
Console.WriteLine(“Tec Laredo”);
Ejemplo 1:
En este ejemplo nos ayuda calcular lo que un empleado se gana al dia por el numero de
días trabajados.
61
EMPLEADO miempleado = new EMPLEADO();
NOMINA minomina = new NOMINA();
public Form1()
if (textBox1.Text == "")
errorProvider1.SetError(textBox1, "debe ingresar un nombre");
textBox1.Focus();
return;
errorProvider1.SetError(textBox1, "");
miempleado.pnombre = textBox1.Text;
miempleado.pidentificacion = textBox2.Text;
62
miempleado.pasignacion = Convert.ToDecimal(textBox3.Text);
minomina.pdialaborados = Convert.ToInt32(textBox4.Text);
MessageBox.Show("se guardo el registro correctamente");
textBox5.Text =
minomina.calcularnomina(Convert.ToInt32(minomina.pdialaborados),
Convert.ToInt32(miempleado.pasignacion)).ToString();
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox5.Clear();
this.Close();
}
63
/////CLASES
class NOMINA
private int dialaborados;
public int pdialaborados { get; set; }
public decimal calcularnomina(int diaslab, decimal valordia)
decimal totalSalario = diaslab * valordia;
return totalSalario;
///
class EMPLEADO
private string nombre;
private string identificacion;
private decimal asignacion;
public string pnombre { get; set; }
public string pidentificacion { get; set; }

64
public decimal pasignacion { get; set; }
Ejemplo 2:
En este ejemplo podemos observar la información de diferentes dispositivos
public Form1()

65
if (radioButton1.Checked)
ARTICULOS computadoras = new ARTICULOS();
computadoras.mostrarmensajes("computadoras");
else if (radioButton2.Checked)
ARTICULOS computadoras = new ARTICULOS();
computadoras.mostrarmensajes("celulares");
///CLASE
class ARTICULOS
public void mostrarmensajes(string nombre)
MessageBox.Show("A CONTINUACION VISUALIZAREMOS
INFORMACION DE=>" + nombre);
}
66
}
67
11.ADO.NET
Es un conjunto de clases que exponen servicios de acceso a datos para programadores
de .NET Framework. ADO.NET ofrece abundancia de componentes para la creación de
aplicaciones de uso compartido de datos distribuidas. Constituye una parte integral de
.NET Framework y proporciona acceso a datos relacionales, XML y de
aplicaciones. ADO.NET satisface diversas necesidades de desarrollo, como la creación
de clientes de base de datos front-end y objetos empresariales de nivel medio que utilizan
aplicaciones, herramientas, lenguajes o exploradores de Internet.
ADO.NET proporciona acceso coherente a orígenes de datos como SQL Server y
XML, así como a orígenes de datos expuestos mediante OLE DB y ODBC. Las
aplicaciones de consumidor que comparten datos pueden utilizar ADO.NET para
conectar a estos orígenes de datos y recuperar, controlar y actualizar los datos contenidos.
Separa el acceso a datos de la manipulación de datos y crea componentes discretos que
se pueden utilizar por separado o conjuntamente. ADO.NET incluye proveedores de
datos .NET Framework para conectarse a una base de datos, ejecutar comandos y
recuperar resultados. Los resultados se procesan directamente o se colocan en un
objeto Data Set de ADO.NET con el fin de exponerlos al usuario para un propósito
específico, combinados con datos de varios orígenes, o de pasarlos entre niveles. El
objeto Data Set de ADO.NET también puede utilizarse independientemente de un
proveedor de datos .NET Framework para administrar datos que son locales de la
aplicación o que proceden de un origen XML.
Las clases de ADO.NET se encuentran en System.Data.dll y se integran con las clases
de XML incluidas en System.Xml.dll. Para código de ejemplo que se conecta a una base
68
de datos, recupera datos de ésta y, a continuación, se muestra que los datos en una ventana
de consola.
ADO.NET proporciona funcionalidad a los desarrolladores que escriben código
administrado similar a la funcionalidad que los objetos ADO (ActiveX Data Objects)
proporcionan a los desarrolladores de modelo de objetos componentes (COM) nativo. Se
recomienda utilizar ADO.NET, y no ADO, para obtener acceso a datos de aplicaciones
.NET.
ADO.NET proporciona el método más directo de acceso a datos de .NET
Framework. Para una abstracción de alto nivel que permite a las aplicaciones para que
funcione en un modelo conceptual en lugar del modelo de almacenamiento subyacente,
consulte el ADO.NET Entity Framework.
11.1. Proteger aplicaciones de ADO.NET
Para escribir una aplicación de ADO.NET segura es necesario algo más que evitar los
errores de codificación más comunes, como no validar los datos proporcionados por el
usuario. Una aplicación que tiene acceso a datos tiene muchos puntos débiles potenciales
que un agresor puede aprovechar para obtener, manipular o destruir datos
confidenciales. Por eso es importante comprender todos los aspectos de la seguridad,
desde el proceso de modelo de amenazas durante la fase de diseño de su aplicación hasta
la implementación y el posterior mantenimiento.NET Framework ofrece muchas clases,
servicios y herramientas que resultan muy útiles para proteger y administrar aplicaciones
de base de datos. Common Language Runtime (CLR) proporciona un entorno de
seguridad de tipos en el que ejecutar el código, junto con la seguridad de acceso del código
(CAS) para restringir aún más los permisos del código administrado. Si se siguen las
69
recomendaciones de codificación del acceso seguro a datos, se reduce el daño que podría
provocar un posible agresor.
El código seguro no protege de la vulnerabilidad de seguridad que provoca el propio
usuario cuando trabaja con recursos no administrados como bases de datos. La mayoría
de las bases de datos, como SQL Server, tienen sus propios sistemas de seguridad, que
contribuyen a mejorarla cuando se implementan correctamente. Sin embargo, incluso un
origen de datos con un robusto sistema de seguridad puede sufrir un ataque si no se ha
configurado correctamente.
Acceso a datos con ADO.NET
 ADO.NET es una tecnología de acceso a datos que se basa en los objetos ADO
(Objetos de Datos ActiveX) anteriores.
 Es una manera nueva de acceder a los datos construida sobre ADO. ADO.NET
puede coexistir con ADO.
 También podemos decir que ADO.NET es un conjunto de clases que exponen
servicios de acceso a datos al programador de .NET.
 ADO.NET proporciona un conjunto variado de componentes para crear
aplicaciones distribuidas de uso compartido de datos. Forma parte integral de
.NET Framework, y proporciona acceso a datos relacionales, datos XML y datos
de aplicaciones.
 ADO.NET es compatible con diversas necesidades de programación, incluida la
creación de clientes de bases de datos clientes y objetos empresariales de nivel
medio utilizados por aplicaciones, herramientas, lenguajes o exploradores de
Internet.
70
 ADO.NET utiliza un modelo de acceso pensado para entornos desconectados.
Esto quiere decir que la aplicación se conecta al origen de datos, hace lo que tiene
que hacer, por ejemplo seleccionar registros, los carga en memoria y se desconecta
del origen de datos.
 ADO.NET es un conjunto de clases que usted utiliza para acceder y manipular
orígenes de datos como por ejemplo, una base de datos en SQL Server o una
planilla Excel.
 ADO.NET utiliza XML como el formato para transmitir datos desde y hacia su
base de datos y su aplicación Web.
 Hay 3 espacios de nombres que se importará en un formulario Web o formulario
Windows si está usando ADO.NET:
 System.Data.
 System.Data.SqlClient.
 System.Data.OleDb.
Espacios de nombres para datos en el .NET Framework
Entre los espacios de nombres de .NET Framework relativos a datos y XML se incluyen:
System.Data: consiste en las clases que constituyen la arquitectura ADO.NET, que es el
método primario para tener acceso a los datos de las aplicaciones administradas. La
arquitectura ADO.NET permite crear componentes que administran eficientemente datos
procedentes de múltiples orígenes. ADO.NET también proporciona las herramientas
necesarias para solicitar, actualizar y reconciliar datos en aplicaciones distribuidas.
System.Data.Common: contiene las clases que comparten los proveedores de datos
.NET Framework. Dichos proveedores describen una colección de clases que se utiliza
71
para obtener acceso a un origen de datos, como una base de datos, en el espacio
administrado.
System.Xml: clases que proporcionan funcionalidad basada en estándares para procesar
código XML.
System.Data.OleDb: clases que componen el proveedor de datos de .NET Framework
para orígenes de datos compatibles con OLE DB. Estas clases permiten conectarse a un
origen de datos OLE DB, ejecutar comandos en el origen y leer los resultados.
System.Data.SqlClient: clases que conforman el proveedor de datos de .NET
Framework para SQL Server, que permite conectarse a un origen de datos SQL Server
7.0, ejecutar comandos y leer los resultados. El espacio de nombres
System.Data.SqlClient es similar al espacio de nombres System.Data.OleDb, pero
optimizado para el acceso a SQL Server 7.0 y versiones posteriores.
System.Data.SqlTypes: proporciona clases para tipos de datos nativos de SQL Server.
Estas clases ofrecen una alternativa más segura y más rápida a otros tipos de datos.
System.Data.OleDb: clases que componen el proveedor de datos de .NET Framework
para OLE DB. Estas clases permiten el acceso a orígenes de datos ODBC en el espacio
administrado.
System.Data.OracleClient: clases que componen el proveedor de datos de .NET
Framework para Oracle. Estas clases permiten el acceso a orígenes de datos Oracle en el
espacio administrado.
La mayoría de las aplicaciones se escriben para que procesen información que está
almacenada o lo estará en un soporte concreto: una hoja de cálculo, una base de datos o
72
un RDBMS. Es fundamental contar con servicios que hagan posible conectar con esos
recursos y transferir la información desde y hacia la aplicación.
En la plataforma .NET, esos servicios reciben la denominación genérica de
ADO.NET, ha llegado a su versión 2.0 con Visual Studio 2005. Esta nueva iteración
aporta una serie de interfaces y objetos, así como nuevos controles y mejoras en las clases
ya existentes, y también en el propio motor que se encarga de la manipulación de los datos
en el cliente, incrementando su rendimiento considerablemente.
ADO.NET es un conjunto de componentes de software que pueden ser usado por los
programadores para acceder a datos y servicios de datos. Es una parte de la biblioteca de
clases base que están incluidas en el Microsoft .NET Framework. Incorpora varios
proveedores de datos, entre ellos dos que permiten conectar con SQL Server y Oracle, así
como otros que facilitan el uso de controladores ODBC y OLE DB para acceder a aquellos
provenientes de Excel, Access, MySQL, etc. ADO.NET es a veces considerado como una
evolución de la tecnología ActiveX Data Objects (ADO)
Arquitectura de ADO .NET
Tradicionalmente, el procesamiento de datos ha dependido principalmente de un
modelo de dos niveles basado en una conexión. A medida que el procesamiento de datos
utiliza cada vez más arquitecturas de varios niveles, los programadores están pasando a
un enfoque sin conexión con el fin de proporcionar una escalabilidad mejor para sus
aplicaciones.
ADO .NET consiste en dos partes primarias:

73
Proveedor de Datos
Estas clases proporcionan el acceso a una fuente de datos como Microsoft SQL Server,
Oracle, etc. Cada fuente de datos tiene su propio conjunto de objetos de proveedor.
Data Set
Los objetos DataSets, un grupo de clases que describen una base de datos relacional
en memoria. Está conformado por una colección de uno o más objetos Data Table
formado por filas y columnas de datos. Así como información sobre claves principales,
restricciones y relaciones relativas a los datos incluidas en los objetos DataTable.
Un Data Set es llenado desde una base de datos por un Data Adapter cuyas propiedades
Connection y Command han sido inicializados. Sin embargo un DataSet puede guardar
su contenido a XML o llenarse desde un XML, haciendo esto excepcionalmente útil para
los servicios web, aplicaciones distribuidas, aplicaciones de Windows, etc.

74
Bibliografías
Programación en c#. (s.f). El lenguaje c#. Recuperado de:
http://users.dsic.upv.es/~jlinares/csharp/Tema%203.pdf
Main. (s.f). Argumentos main. Recuperado de: https://docs.microsoft.com/es-
es/dotnet/csharp/programming-guide/main-and-command-args/
Anaya. (s.f). La biblia de c#. Recuperado de:
http://engineersofsystems.blogspot.com/2014/07/la-biblia-de-c-anaya-espanol-pdf.html
C#. (s.f.). Instrucciones en c#. Recuperado de: https://docs.microsoft.com/es-
es/dotnet/csharp/language-reference/keywords/selection-statements
González.M. (s.f.). C#. Recuperado de:
http://users.dsic.upv.es/~jlinares/csharp/lenguajeCsharp.pdf
Lopez.B. (s.f.). Introducción en c#. Recuperado de:
http://www.itnuevolaredo.edu.mx/takeyas/apuntes/poo/Apuntes/05.-
%20Excepciones.pdf
Ortizol. (s.f). Introducción a las excepciones. Recuperado de:
https://ortizol.blogspot.mx/2014/06/excepciones-en-csharp-parte-1-introduccion-a-las-
excepciones.html?_escaped_fragment_#
Ecured. (s.f). Lenguaje de programación en c#. Recuperado de:
https://www.ecured.cu/Lenguaje_de_Programaci%C3%B3n_C_Sharp
Artículo. (s.f.). Programación. Recuperado de:
http://programacionjand.blogspot.com/p/arreglos-vectores-y-matrices-en-c.html
75
Aguilar.Joyanes. (s.f.). Programación en C#. Recuperado de:
http://www.tel.uva.es/personales/josdie/fprog/Material/FP06_Tema09_Arrays.pdf
Artículo. (s.f.). Ejercicios resueltos de c#. Recuperado de:
http://ejerciciosresueltosdecsharp.blogspot.com/2014/03/matrices-en-c-sharp.html
Artículo. (s.f.).Arreglos en c#. Recuperado de:
https://thatcsharpguy.com/post/arreglos-en-c-sharp-parte-1/
Microsoft. (s.f.). .Net. Recuperado de: https://docs.microsoft.com/es-
es/dotnet/framework/data/adonet/dataset-datatable-dataview/annotating-typed-datasets
Gassman.A. (s.f.). Ado.net. Recuperado de: https://docs.microsoft.com/es-
es/dotnet/framework/data/adonet/dataset-datatable-dataview/annotating-typed-datasets
Besteiro.M. (s.f.).Programacion.net. Recuperado de:
http://www.ehu.eus/mrodriguez/archivos/csharppdf/ADONET/ADONET.pdf

Arras Tre

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Arras Tre

Încărcat de

Drepturi de autor:

Formate disponibile

1

C# es un lenguaje elegante, con seguridad de tipos y orientado a objetos, que permite

Windows, servicios web XML, componentes distribuidos, aplicaciones cliente-servidor,

aplicaciones de base de datos y muchas, muchas más cosas. Visual C# proporciona un

editor de código avanzado, prácticos diseñadores de interfaz de usuario, un depurador

integrado y muchas otras herramientas que facilitan el desarrollo de aplicaciones

basadas en el lenguaje C# y .NET Framework.

un objeto de un determinado tipo al que se le da un cierto nombre. Para poderla utilizar

podrá almacenar, lo que se hace siguiendo la siguiente sintaxis:

1.1. Tipos de datos básicos

1.2. Orden de inicialización de variables

correspondiente a su tipo, luego se dé a cada una el valor inicial especificado al definirlas,

y por último se llame al constructor del tipo. Un constructor de tipo es similar a un

(se verá en el Tema 8: Métodos).

valores especificados al llamarlo.

se haga a las mismas mientras no se les escriba algún valor.

2.1. Operadores aritméticos:

2.2. Operadores relacionales

 < menor que: a<b

 <= menor o igual: a<=b

 > mayor que: a > b

 >= mayor que o igual a: a>=b

 & and binario: a&b

 && and lógico: a&&b

2.3. Orden de operación

C# combina los operadores en grupos y aplica un orden de prioridad a cada

otros. La lista con el orden de prioridad es la siguiente, ordenados de mayor

 Operadores de desplazamiento << >>

 Operadores relacionales < > <= >=

texto nos muestra la diferencia y entre esos números.

La instrucción if realiza (selecciona) una acción si una condición es verdadera, o

ignora la acción si la condición es falsa.

Una instrucción if simple responde a la siguiente sintaxis:

Instrucción(es) de condición verdadera.

3.2. Estructura else -if

La instrucción if solo garantiza la ejecución de determinadas acciones basándose en

una condición verdadera (true). Se ejecutan o no se ejecutan. Para controlar tanto la

condición true como la falsa (false) es necesario utilizar la instrucción if…else. Su

Instrucción(es) de condición verdadera.

Instrucción(es) de condición falsa.

3.3. Estructura switch

Cuando hay muchas condiciones a evaluar, la instrucción if…else puede resultar

en usar la instrucción switch. La instrucción switch permite cualquier valor entero o de

menú dentro de las aplicaciones. La sintaxis es la siguiente:

label el que se ingresó en letras.

private void button1_Click(object sender, EventArgs e)

private void button1_Click(object sender, EventArgs e)

del bucle se le llama iteración.

private void button1_Click(object sender, EventArgs e)

private void button1_Click(object sender, EventArgs e)

4.1. El bucle for

Ejecuta una sentencia o conjunto de sentencias un número finito de veces.

un contador), con su valor inicial. La condición iteración contiene una expresión

verdadera. Finalmente, en incremento se modifica la variable de control.

for (inicialización; condición_iteración; incremento o decremento)

4.2. El bucle while

Repite la ejecución de una sentencia o de un grupo de sentencias mientras la

condición que se evalúa (al principio del bucle) sea verdadera.

while (condición de bucle)

4.3. El bucle do while

Repite le ejecución de una sentencia o de un grupo de sentencias mientras se

evalúa al final del bucle.

se incrementa o decrementa en cada repetición del bucle. Es habitual llamar a esta

1. Se inicializa antes de que comience el bucle. Es decir, se le da un valor inicial Por