3.

1 Captulo 3: Mtodos, Arreglos y Estructuras

Captulo 3

Mtodos, Arreglos y Estructuras
La mejor estructura no garantizar los resultados ni el rendimiento. Pero la estructura
equivocada es una garanta de fracaso.
Peter Drucker
El xito no se logra slo con cualidades especiales. Es sobre todo un trabajo de constancia, de
mtodo y de organizacin.
J.P. Sergent



Tabla de Contenido
Mtodos ......................................................................................................................................................................................... 3.2
Mtodos Estticos ..................................................................................................................................................................... 3.4
Sobrecarga de Mtodos ......................................................................................................................................................... 3.5
Paso de variables por valor y por referencia. ......................................................................................................... 3.11
Arreglos ...................................................................................................................................................................................... 3.13
Arreglos Unidimensionales .............................................................................................................................................. 3.14
Clase System.Array ............................................................................................................................................................... 3.15
Foreach........................................................................................................................................................................................ 3.27
Arreglos bidimensionales. ................................................................................................................................................. 3.29
Estructuras ..................................................................................................................................... 3.34





3.2 Captulo 3: Mtodos, Arreglos y Estructuras

Mtodos
Hasta ahora todo el cdigo que hemos necesitado para que nuestros programas
funcionen lo hemos insertado, por regla general, en el mtodo Main( ) porque en
realidad se ha tratado de llevar a cabo operaciones bastante sencillas. Sin embargo,
cuando el programa tenga alguna finalidad ms que la simple accin de operaciones
bsicas, comprobacin o prueba de un control, la cantidad de cdigo necesaria
crecer y en ocasiones necesitaremos el mismo cdigo en distintos puntos del
programa. Obviamente la solucin no es introducir una y otra vez todo el cdigo. Para
evitarlo podemos crear nuestros propios mtodos introduciendo en ellas el cdigo que
despus podr ser utilizado con una simple llamada.

En Introduccin a la Programacin manejamos funciones en C# en lugar de funciones
se conocen como mtodos.

La denominacin mtodo se aplica a funciones que forman parte de una clase.
WriteLine( ), por ejemplo, es un mtodo de la clase Consol. Dado que en C# todas las
funciones tienen, obligatoriamente, que pertenecer a alguna clase, podramos decir que
todas las funciones en C# son mtodos. Por ello los trminos funcin y mtodo se
utilizan indistintamente en estecaptuloLa ejecucin de las instrucciones de un mtodo
puede producir como resultado un objeto de cualquier tipo. A este objeto se le llama valor de
retorno del mtodo y es completamente opcional, pudindose escribir mtodos que no
devuelvan ninguno.
La ejecucin de las instrucciones de un mtodo puede depender del valor de unas variables
especiales denominadas parmetros del mtodo, de manera que en funcin del valor que se
d a estas variables en cada llamada la ejecucin del mtodo se pueda realizar de una u otra
forma y podr producir uno u otro valor de retorno.
Para definir un mtodo hay que indicar tanto cules son las instrucciones que forman su cuerpo
como cul es el nombre que se le dar, cul es el tipo de objeto que puede devolver y cules
son los parmetros que puede tomar. Esto se indica definindolo as:
<tipoRetorno><nombreMtodo>(<parmetros>)
{
<cuerpo>
}
En <tipoRetorno> se indica cul es el tipo de dato del objeto que el mtodo devuelve, y si no
devuelve ninguno se ha de escribir void en su lugar.

Como nombre del mtodo se puede poner en <nombreMtodo> cualquier identificador vlido.
Aunque es posible escribir mtodos que no tomen parmetros, si un mtodo los toma se ha de
indicar en <parmetros> cul es el nombre y tipo de cada uno, separndolos con comas si son
ms de uno y siguiendo la sintaxis que ms adelante se explica.



3.3 Captulo 3: Mtodos, Arreglos y Estructuras

El <cuerpo> del mtodo tambin es opcional, pero si el mtodo retorna algn tipo de objeto
entonces ha de incluir al menos una instruccin return que indique cul objeto.
A continuacin se muestra un ejemplo de cmo definir un mtodo de nombre MisDatos() cuyo
cuerpo consiste en escribir en la consola mis datos como nombre, materia, mail, fecha y hora,
no devuelve ningn valor de retorno y tampoco tiene argumentos.
public void MisDatos() //mtodo MisDatos
{Console.WriteLine('UACM IZTAPAPALAPA');
Console.WriteLine('PROGRAMACION ORIENTADA A OBJETOS EN C#');
Console.WriteLine('Armando Valera Paulino');
Console.WriteLine('mail: avalera@hotmail.com');
Console.WriteLine(DateTime.Now); Console.WriteLine('\n');
}
Veamos como quedara el mtodo dentro de un programa:




3.4 Captulo 3: Mtodos, Arreglos y Estructuras

Si modificamos el Main agregando las lneas que aparecen sombreadas de la siguiente
manera:
static void Main(string[] args)
{
Program prg=new Program();//Crea un objeto de la clase Program
prg.MisDatos();//Llama al mtodo
// new Program().MisDatos();
}
Aqu creamos un objeto de la clase Program y posteriormente llamamos al mtodo con el
objeto creado.
Mtodos Estticos
Una tercera versin del mismo programa es declarar el mtodo MisDatos() esttico con la
palabra clave static de esta manera al llamar al mtodo simplemente lo realizamos con el
nombre de la clase punto el nombre del mtodo es decir con la instruccin
Program.MisDatos();
static void Main(string[] args)
{
Program.MisDatos();
}

public static void MisDatos() //mtodo MisDatos()
{
}
Los mtodos static, son aquellos que se pueden ejecutar sin necesidad de instanciar la clase
donde est escrito. Un mtodo esttico es un mtodo que existe en una clase como un todo
ms que en una instancia especfica de la clase. Por lo tanto, el hecho de que el mtodo Main
tenga que ser static no es un capricho, ya que, de lo contrario, el CLR no sera capaz de
encontrarlo pues antes de que se ejecute la aplicacin, lgicamente, no puede haber instancias
de ninguna de las clases que la componen.
En cualquiera de las tres versiones del programa el resultado de la ejecucin sera el siguiente:



3.5 Captulo 3: Mtodos, Arreglos y Estructuras



Sobrecarga de Mtodos

La sobrecarga de mtodos consiste en poner varios mtodos con el mismo nombre en la
misma clase, pero siempre que su lista de argumentos sea distinta, es decir, no puede haber
dos mtodos que se llamen igual con la misma lista de argumentos, aunque devuelvan datos
de distinto tipo. El compilador sabra a cul de todas las sobrecargas nos referimos por los
argumentos que se le pasen en la llamada, pero no sera capaz de determinar cul de ellas
debe ejecutar si tienen la misma lista de argumentos. Lo que diferencia las listas de
argumentos de las diferentes sobrecargas no es el nombre de las variables, sino el tipo de cada
una de ellas.
En el siguiente ejemplo Sobrecarga1.cs tenemos tres mtodos llamados Triple dentro de la
clase Principal, lo nico que lo hace diferente es el tipo de argumento que recibe y que
devuelve, cuando se llama al mtodo Triple dentro del mtodo SobreCarga el compilador
sabr cual de los tres ejecutar dependiendo del tipo de dato con que lo llame ya se int, double
o long.





3.6 Captulo 3: Mtodos, Arreglos y Estructuras



Observemos otra caracterstica importante el mtodo Triple es llamado dentro del mtodo
SobreCarga el cual a su vez es llamado desde Main, entonces podemos concluir que dentro
de un mtodo podemos llamar a otro mtodo.

Ejecucin del programa:





3.7 Captulo 3: Mtodos, Arreglos y Estructuras

En el primer caso al mtodo se le llama con la instruccin int y = Triple(x); y
automticamente por el tipo de dato que se le proporciona que en este caso es entero utiliza el
mtodo respectivo private int Triple(int val) lo mismos sucede con los otros dos
mtodos que se invocan.
#region permite especificar un bloque de cdigo que se puede expandir o contraer cuando se
utiliza la caracterstica de esquematizacin del editor de cdigo de Visual C#.

Por ejemplo:
#region
private int Triple(int val)
{
return 3 * val;
}
private long Triple(long val)
{
return 3 * val;
}
private double Triple(double val)
{
return 3 * val;
}
#endregion
Utilizando el compilador observamos como en la lnea 9 aparece en color gris #region aqu
estan ocultos los tres mtodos Triple que corresponde a mtodos sobrecargados para
terminar una regin utilizamos #endregion . De forma predeterminada, todo el texto se
muestra en el editor de cdigo, pero podemos hacer que no se vea parte del mismo. El editor
de cdigo nos permite seleccionar una regin de cdigo y contraerla, de forma que aparezca
debajo de un signo ms (+).



3.8 Captulo 3: Mtodos, Arreglos y Estructuras


Podremos expandir u ocultar la seleccin haciendo clic en el signo ms (+) situado junto al
smbolo. El cdigo esquematizado no se elimina, simplemente se oculta.
Si deseamos expandir y ver los mtodos damos clic sobre el cuadro con el simbolo + y
obsevaremos lo siguiente:


Esta caracterstica de esquematizacin es muy til para organizar nuestro cdigo y visualizar el
alcance de cierta seccin de cdigo, tambin en programas muy extensos esta propiedad es de
gran ayuda.




3.9 Captulo 3: Mtodos, Arreglos y Estructuras

Regresando a los mtodos sobrecargados veamos el programa Sobrecarga2.cs,
observemos que los mtodos ahora se encuentran definidos despus del Main como lo
comentamos anteriormente pueden ir antes o despus lo que debemos cuidar es que
pertenezca a la misma clase Principal, el programa muestra la sobrecarga de mtodos
mayor lo nico que cambia es el tipo de argumento y retorno que son int, char y double.



Esta el resultado de la ejecucin del programa:




3.10 Captulo 3: Mtodos, Arreglos y Estructuras

El programa Sobrecarga3.cs es un caso totalmente diferente al anterior se aplica la
sobrecarga de mtodo mayor pero con diferente nmeros de argumentos 2, 3 y 4 argumentos,
ntese que en este caso el tipo de dato no cambia todos son de tipo entero.

Ejecucin:

Si al programa Sobrecarga3.cs agregamos las lneas 13, 14 y 15 en el Main, muestra el titulo
POO en C#, en texto en color verde y fondo blanco.




3.11 Captulo 3: Mtodos, Arreglos y Estructuras

Ejecucin:


Paso de variables por valor y por referencia.
En C# es posible pasar variables a los mtodos de dos maneras: Por referencia y por valor. La
diferencia entre el uno y el otro es bsicamente que:
Cuando una variable es pasada por valor, el mtodo recibe una copia del valor de la variable.
Por lo tanto, los cambios realizados a esa variable dentro del contexto de la funcin, no afecta a
la variable original.
Cuando es pasada por referencia, el mtodo recibe la referencia a la variable original. Por tanto
los cambios realizados a esa variable dentro del contexto de la funcin, afecta a la variable
original.
Cual debo usar?
Eso depende de lo que queramos hacer. Cada una tiene sus ventajas y desventajas. Al pasar
una variable por valor, ests asegurando que dicho valor no va a ser modificado por
equivocacin. Por otro lado, al pasar una variable por referencia, aunque la variable puede ser
modificada por equivocacin, ahorramos tiempo de ejecucin y memoria, puesto que no es
necesario crear una copia de la variable.
Pasar variables por referencia
Todas las variables que pasamos a un mtodo declarado normalmente, son por valor. Para
pasar argumentos por referencia es necesario utilizar las palabras reservada ref o out, tanto al
declarar el mtodo como al invocarlo. Cuando pasamos un argumento usando ref, es necesario
que dicha variable est ya inicializada, de lo contrario obtendremos una excepcin o error. Si la
variable que deseamos pasar por referencia no est inicializada, es nesesario usar out, de tal
manera que podamos inicializar la variable dentro del contexto del mtodo.
En el programa Valor1.cs observamos que al llamar una variable y modificarla el valor dentro
del mtodo cambia a 25, posteriormente el valor despus de llamar al mtodo original no
cambia permanece en 5.




3.12 Captulo 3: Mtodos, Arreglos y Estructuras


Ejecucin:


En contraparte en el programa Referencia1.cs despes de llamar al mtodo y modificar el la
variable el valor si cambi pues permanece en 25, para este caso utilizamos la palabra
reservada ref lneas 12 y 17 para indicar que el valor es pasado por referencia.



3.13 Captulo 3: Mtodos, Arreglos y Estructuras


Ejecucin:


Arreglos

Los tipos de datos que hemos usado hasta ahora, en ejemplos previos, tan solo
pueden contener un dato, ya sea simple: un nmero, un carcter o una cadena.
Cuando se tiene la necesidad de almacenar mltiples valores, del mismo tipo y con
informacin relacionada, se usan los arreglos.
Un arreglo es una lista de variables del mismo tipo que comparten el nombre,
distinguindose unas de otras por un ndice, l o s arreglos tambin son conocidos como
vectores para arreglos de una dimensin o matrices para arreglos de dos dimensiones.
Una variable de tipo arreglo no aloja el valor sino una referencia al bloque de memoria
donde ste se encuentra.

Los arreglos, al igual que el resto de las variables se identifican con un nombre. Al
emplear ese nombre, se hace referencia a la estructura de datos como un todo, es
decir, con todos sus elementos. El lenguaje interpreta dicho nombre como un puntero.
Para acceder a sus elementos se utiliza el nombre del arreglo en forma indexada, es
decir, combinado con ndices, para acceder a un elemento en particular de un arreglo



3.14 Captulo 3: Mtodos, Arreglos y Estructuras

se usa por lo tanto el nombre del arreglo y un subndice entre corchetes. La direccin
ms baja corresponde al primer elemento que sera el subndice cero y la ms alta al
ltimo que correspondera al subndice n-1, donde n es el nmero total de elementos.

El lenguaje C# no controla la validez de los ndices que se emplean para referenciar
un arreglo. Esto quiere decir que es posible cometer errores graves y difciles de
detectar.

Arreglos Unidimensionales
Los arreglos, al igual que las dems variables deben declararse antes de poder
utilizarlas, los arreglos de una sola dimensin reciben tambin el nombre de vectores.

La sintaxis de la declaracin de un arreglo unidimensional es la siguiente:
<tipo-base>[] <identificador>;
Observaciones:

El <tipo-base> puede ser cualquiera de los tipos bsicos del lenguaje, o incluso
algunos complejos como estructuras.

El <identificador> es el nombre que distinguir el arreglo.

Los corchetes [] son obligatorios y denotan que el identificador descrito, del tipo
de variable indicado, es un arreglo.

En esta declaracin no se define el tamao que tendr el arreglo (aunque se
puede determinar las dimensiones, lo que se ver ms adelante).

El tamao del arreglo se determina en una segunda declaracin, que puede ir en la
siguiente lnea, como se muestra a continuacin.

<identificador> = new <tipo-base> [<NumElementos>]

En esta declaracin, se dimensiona el arreglo con una cantidad determinada de elementos,
todos correspondientes a tipo-base.

Es posible hacer la declaracin del arreglo y su dimensionamiento en una misma sentencia:
<tipo-base>[] <identificador> = new <tipo-base>[<NumElementos>]

Adicionalmente es factible declarar, dimensionar, e inicializar un arreglo con todos sus
elementos, en una sola declaracin:
<tipo-base>[] <identificador> = {valor1, valor2, ..., valorN};

Esta ltima declaracin implcitamente dimensiona el arreglo para almacenar los N elementos
descritos, por lo que no se requiere dimensionarlo aparte.
Es decir:

Con los valores indicados entre llaves { } se inicializarn los elementos del arreglo.




3.15 Captulo 3: Mtodos, Arreglos y Estructuras

Los valores deben ser del <tipo-base> del arreglo.
Tambin es factible declarar, dimensionar, e inicializar un arreglo con todos sus elementos, en
una sola declaracin, pero slo indicando un subconjunto de los valores que el arreglo puede
guardar:

<tipo-base>[] <identificador> = new <tipo-base>[N] {valor1, ..., valorM};
donde M<N, y N debe ser una expresin constante, como por ejemplo 10. Es factible hacer una
declaracin donde M>N, en cuyo caso, el real dimensionamiento del arreglo se regir por M.
Algunos ejemplos:
// Arreglo para 10 enteros
int [] numeros; numeros = new int[10];

// Arreglo para 10 enteros
int [] numeros = new int[10];

// Arreglo para 10 enteros
int [] numeros = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

A continuacin se lista una tabla con los principales operaciones que se pueden realizar a un
arreglo las cuales pertenece a la clase System.Array
Clase System.Array

Mtodo o
Propiedad
Descripcin
IsFixedSize Propiedad que indica si el arreglo es de tamao fijo
Length Propiedad que retorna el tamao del arreglo
Rank Propiedad que retorna el nmero de dimensiones del arreglo
Clear( ) Establece el valor de un rango de elementos de un arreglo
en 0
Copy( ) Copia una seccin de un arreglo a otro arreglo
CopyTo( ) Copia todos los elementos de un arreglo a otro
IndexOf() Retorna el ndice de la primera ocurrencia de un valor en
un arreglo unidimensional
LastIndexOf( ) Retorna el ndice de la ltima ocurrencia de un valor en un



3.16 Captulo 3: Mtodos, Arreglos y Estructuras



arreglo unidimensional
Reverse() Invierte el orden de los elementos en un arreglo
unidimensional
Sort ( ) Ordena los elementos (que deben implementar IComparable) de
un arreglo unidimensional usando el algoritmo Quicksort
GetLength() Regresa el nmero de elementos de la dimensin especificada
de un arreglo.
GetLowerBound() Obtiene el ndice del primer elemento del arreglo o lmite
inferior de la dimensin especificada de un array
GetUpperBound() Proporciona el ndice del ltimo elemento del arreglo o
lmite superior de la dimensin especificada de un array
Exists() Determina si el arreglo especificado contiene elementos que
coinciden con las condiciones definidas.
Find() Busca un elemento que coincida con las condiciones
definidas y devuelve la primera aparicin en todo el
arreglo.
FindAll() Encuentra todos los elementos del arreglo que cumplen con
la condicin.
FindIndex() Regresa el ndice del primer elemento que cumple con la
condicin.
FindLast() Regresa el ltimo elemento que cumple con la condicin.
FindLastIndex() Regresa el ndice del ltimo elemento que cumple con la
condicin.
Remove() Elimina el primer elemento que se pasa como parmetro.
RemoveAt() Elimina el elemento de la posicin especificada
RemoveRange() Elimina un rango de elementos
RemoveAll() Elimina todos los elementos que cumplen con la condicin



3.17 Captulo 3: Mtodos, Arreglos y Estructuras






Analicemos el ejemplo del programa Arreglo1.cs:

En la lnea 10 se declara e inicializa el arreglo de tipo entero llamado a con 10 elementos,
observemos que el nmero de elementos que iran entre corchete no contiene la dimensin
est vaco.

En la lnea 11 se declara el arreglo b de diez elementos, pero no se inicializa, por tal razn se
inicializan automticamente con cero.

En la lnea 14 utilizamos un ciclo for para ir sumando cada uno de los elementos del arreglo y
almacenar la suma en la variable total, suma 1+2+3. + 10 que da como resultado 55. En
esta lnea utilizamos a.Length que es el tamao del arreglo a que es 10, el ciclo for empieza
en 0 y termina en 9.

Para usar nmeros aleatorios en C# podemos utilizar la clase Random del namespace System,
de la siguiente manera lnea 20: Random objeto = new Random(); El mtodo Next de la
clase Random genera y devuelve un nmero aleatorio entre 0 y la constante Int32.MaxValue
(2,147,483,647). El nmero es generado utilizando una semilla (seed) que por default es la
hora del sistema. En la lnea 23 {b[i]=objeto.Next(1,99); asignamos a cada elemento del
arreglo un valor generado aleatoriamente entre 1 y 99, por lo que en cada ejecucin los
elementos sern diferentes, el ciclo for de la lnea 22 tambin nos sirve para imprimir cada
elemento del arreglo b.



3.18 Captulo 3: Mtodos, Arreglos y Estructuras




Ejecucin:






3.19 Captulo 3: Mtodos, Arreglos y Estructuras

En el ejemplo Histograma.cs utilizamos un arreglo llamado x de 10 elementos y por cada
valor imprimimos n asteriscos por ejemplo en el primer valor del arreglo se imprimen 17
asteriscos, en el segundo 4 asteriscos, y as sucesivamente, lo realizamos con la ayuda dos
ciclos for el primero imprime el nmero de elemento y su valor, y el segundo ciclo for o el ms
anidado imprime el nmero de asteriscos adecuado, ntese que tambin utilizamos el
parmetro x.Length para determinar el nmero de elementos, la ventaja de utilizarlo de esta
manera es que si aumentan o disminuyen los elementos este parmetro no es necesario
actualizarlo o cambiarlo.





Ejecucin:






3.20 Captulo 3: Mtodos, Arreglos y Estructuras

En el programa Ordenar.cs mostramos el mtodo Array.Sort para ordenar los elementos de
un arreglo, una vez ordenados se imprimen los elementos del arreglo para comprobar que
estn ordenados. Despus de cerrar la llave de la clase Ordenar lnea 17, entre comentarios
aparece la instruccin foreach lnea 19 esta puede ser utilizada en lugar del ciclo for y el
resultado ser el mismo, ms adelante se muestra un ejemplo completo de su uso.



Ejecucin:



En el programa MetodosArray.cs mostramos bsicamente los principales mtodos de la
clase System.Array.
En la lnea 14 Array.Copy(a,b,a.Length); copiamos el contenido del arreglo a en el arreglo
b el cual est vaco, en la lneas 15 y 16 imprimimos cada valor del arreglo b para comprobar
que efectivamente los elementos del arreglo a fueron copiados al arreglo b.
En la lnea 19 Array.Reverse(a); invertimos los elementos del arreglo a, en la lnea 20
copiamos el arreglo a invertido en el arreglo c e imprimimos los valores para comprobar el
resultado.
En las lneas 24 con la instruccin Array.IndexOf(c,5); buscamos la primera posicin o
ndice del valor 5 dentro del arreglo con Array.LastIndexOf(c,5); obtenemos la ltima
posicin.



3.21 Captulo 3: Mtodos, Arreglos y Estructuras

Con la instruccin a.Rank en la lnea 31 determinamos la dimensin del arreglo que es uno
por ser unidimensional. En la lnea 32 la instruccin a.IsFixedSize determina si el arreglo es
de tamao fijo, que en este caso es true o verdadero.
Finalmente en la lnea 35 Array.Clear(a,2,5); a partir del elemento 2 coloca 5 elementos
en cero.






3.22 Captulo 3: Mtodos, Arreglos y Estructuras




En el programa Estadisticas1.cs, creamos e inicializamos un arreglo llamado a el cual
contiene las calificaciones de un grupo de alumnos, el objetivo es determinar la frecuencia o
cuantas veces aparece cada calificacin dentro del arreglo. Creamos un arreglo llamado
frecuencia con 11 elementos, en la lnea 19 con la instruccin
++frecuencia[calificaciones[j]]; almacenos en el arreglo frecuencia cuantas veces
aparece cada calificacin, en la lnea 25 imprimimos el resultado.




3.23 Captulo 3: Mtodos, Arreglos y Estructuras





El programa Estadistica2.cs es similar al programa Estadistica1.cs, agregamos la funcin
calificaciones.Length en la lnea 33 para determinar el nmero total de estudiantes, de la
lnea 43 a 51 creamos un mtodo llamado mximo para determinar dentro del arreglo
frecuencia cual calificacin se repite ms vemos que la funcin regresa el valor del ndice
as en la lnea 36 imprimimos cual calificacin se repite mas que es el 7 y en la lnea 37
frecuencia[indice] imprimimos cuantas veces se repite que son 10 veces.




3.24 Captulo 3: Mtodos, Arreglos y Estructuras









3.25 Captulo 3: Mtodos, Arreglos y Estructuras

Ejecucin:


El programa Estadistica3.cs es muy similar al 2 simplemente movimos la funcin mximo a
la parte de arriba de la clase lneas 8 a 15, y en la funcin mximo en lugar de regresar el
ndice regresamos el valor que en este caso es max lnea 14, con
Array.IndexOf(frecuencia,maximo(frecuencia))) lnea 43 determinamos la calificacin
que se repite ms y para determinar cuanta veces se repite utilizamos maximo(frecuencia)
lnea 44. La ejecucin del programa es exactamente igual a la del programa
Estadistica2.cs.





3.26 Captulo 3: Mtodos, Arreglos y Estructuras






3.27 Captulo 3: Mtodos, Arreglos y Estructuras


Foreach
La instruccin foreach repite un grupo de instrucciones incluidas en el bucle o ciclo para cada
elemento de una matriz o de un objeto collection. La instruccin foreach se utiliza para
recorrer en iteracin una coleccin de elementos y obtener la informacin deseada, pero no se
debe utilizar para cambiar el contenido de la coleccin, ya que se pueden producir efectos
secundarios imprevisibles. Las instrucciones del bucle o ciclo siguen ejecutndose para cada
elemento de la matriz o la coleccin. Cuando ya se han recorrido todos los elementos de la
coleccin, el control se transfiere a la siguiente instruccin fuera del bloque foreach.
En cualquier punto dentro del bloque foreach, puede salir del ciclo utilizando la palabra clave
break o pasando directamente la iteracin siguiente del ciclo mediante la palabra clave
continue. Tambin se puede salir de un bucle foreach mediante las instrucciones goto,
return, throw.
En el programa Foreach1.cs creamos un arreglo unidimensional con cuatro elementos
llamado calificaciones, en la lnea 18 con un ciclo for imprimimos el arreglo utilizando
GetLowerBound(0) que obtiene el ndice del primer elemento del arreglo y
GetUpperBound(0) nos proporciona el ndice del ltimo elemento del arreglo, el cero
representa la dimensin del arreglo como es unidimensional se utiliza el cero, en la lnea 22
imprimimos el arreglo utilizando foreach, establecemos una variable entera int k para
recorrer los elementos del arreglo y definimos cul arreglo in calificaciones.



3.28 Captulo 3: Mtodos, Arreglos y Estructuras



Ejecucin:





3.29 Captulo 3: Mtodos, Arreglos y Estructuras


Arreglos bidimensionales.

Un arreglo bidimensional tiene dos dimensiones, en C# las dimensiones se manejan por medio
de un par de corchetes, dentro de los que se escriben, separados por comas, los valores de las
dos dimensiones.

La declaracin de un arreglo consiste en establecer las caractersticas del arreglo y sus
elementos, por medio de la siguiente sintaxis:
<tipo> [ , ] < identificador > ;

Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y encierra dos
nmeros enteros, cuyo producto corresponde al nmero de elementos del arreglo.

Ejemplos:
int [ , ] matriz ;
double [ , ] posicion ;
Chasis [ , ] automovil; // Chasis es una clase.

Observe que, en la declaracin, el espacio entre los corchetes est vaco. Esto se debe a que,
durante dicha operacin, no se reserva espacio en la memoria.

La creacin de un arreglo bidimensional consiste en reservar espacio en la memoria para
todos sus elementos, utilizando la siguiente sintaxis:

< identificador > = new <tipo> [ dim1, dim2 ] ;

Donde:

new es el operador para gestionar espacio de memoria, en tiempo de ejecucin,

dim1 y dim2 son valores enteros que representan las dimensiones del arreglo.

El tamao del arreglo es el resultado de multiplicar los valores de las dimensiones y representa
el nmero de elementos del arreglo.

Ejemplos:

matriz = new int [2, 3] ; // Se crea el arreglo matriz, con 6 elementos de tipo entero
posicion = new double[4,2] ; // Se crea el arreglo posicion, con 8 elementos tipo doble
automovil= new Chasis[5,2] ; // Se crea el arreglo , Chasis con 10 objetos de la clase
automvil.






3.30 Captulo 3: Mtodos, Arreglos y Estructuras


Las operaciones de declaracin y creacin anteriores se pueden agrupar en una sola
instruccin, como se muestra enseguida:
int [ , ] matriz = new int [2,3] ;
double [ , ]posicion = new double[4, 2] ;
Chasis [ , ] automovil = new Chasis[5,2] ;


Inicializacin.
Un arreglo es un objeto que, cuando es creado por el compilador, se le asignan
automticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a
los siguientes criterios:

Si el tipo del arreglo es numrico, a sus elementos se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.

Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible
agrupar las operaciones de declaracin, creacin e inicializacin en una sola instruccin, por
ejemplo:

int [ , ] matriz = { {1,5, 2 } , {3, 9, 4} };
double [,] posicion = { {5.2, 6.0} , {7.6, 9.2} , {3.7, 10.1}, {5.4 , 1.8}};
string [ , ]RFC ={{"VAPA760912D55", "CBCD880101B89"} , { "CGTI992012",
"MESL700719"}};



Acceso.
Se puede acceder a los valores de los elementos de un arreglo bidimensional a travs del
nombre del arreglo y dos subndices. Los subndices deben escribirse entre corchetes y
representa la posicin del elemento en el arreglo. As, podemos referirnos a un elemento del
arreglo escribiendo el nombre del arreglo y los subndices del elemento entre corchetes. Los
valores de los subndices empiezan en cero para el primer elemento, hasta el tamao del
arreglo menos uno.

Ejemplo:
double [ , ] posicion = new double[4,3] ;
// Crea el arreglo posicion, con 12 elementos de tipo double
posicion[ 2, 1] = 9.8 ;
double p = posicin[ 2, 1] ;
// Asigna a la variable p el valor de 9.8, el mismo valor del arreglo en la
posicin [2, 1]

En el siguiente ejemplo Matriz1.cs creamos un arreglo del 6 elementos del tipo string es
decir podemos almacenar en este cadenas de texto, consta de 3 filas y 2 columnas, con un
ciclo for anidado capturamos el nombre de 6 materias que deseamos inscribir en un
semestre, posteriormente con otro ciclo for anidado imprimimos los valores almacenados.



3.31 Captulo 3: Mtodos, Arreglos y Estructuras



Ejecucin:


En el ejemplo Matriz2.cs declaramos un arreglo de 4 filas, 3 columnas con un total de 12
elementos de tipo entero, a diferencia del anterior en este arreglo se declaran e inicializa al
mismo tiempo cada elemento, esto se efecta en la lnea 14, posteriormente con el ciclo for
anidado imprimimos el valor de cada elementos as como la posicin que le corresponde.




3.32 Captulo 3: Mtodos, Arreglos y Estructuras







En el programa Matriz3.cs declaramos tres matrices de tipo entero, ambas con el mismo
nmero de filas y de columnas que se piden previamente. En las dos primeras matrices
almacenamos los valores que deseamos y en la tercera matriz almacenamos el resultado de la
suma de las dos primeras matrices. Al final solo imprimimos el valor de la matriz resultante.
Observemos que utilizamos tres ciclos for anidados en todo el programa, los dos primeros
para leer los valores de las dos primeras matrices y el tercer ciclo for anidado suma las
matrices A y B elemento por elemento y al mismo tiempo imprime el resultado.




3.33 Captulo 3: Mtodos, Arreglos y Estructuras



















3.34 Captulo 3: Mtodos, Arreglos y Estructuras


Ejecucin:



Estructuras
Una estructura es muy similar a una clase la cual puede contener campos, propiedades y
mtodos, de hecho una estructura es un tipo especial de clase pensada para representar
objetos ligeros. Es decir, que ocupen poca memoria y deban ser manipulados con velocidad,
como objetos que representen puntos, fechas, etc. Ejemplos de estructuras son la mayora de
los tipos bsicos (excepto string y object).

Listamos las cosas habituales en las clases que no se pueden hacer con las estructuras:
Puede escribir constructores, pero estos han de tener argumentos. Dicho de otro modo, no se
puede escribir un constructor sin argumentos para una estructura.
Lgicamente, al tratarse de un tipo valor que se almacena en la pila, las estructuras no admiten
destructores.
No soportan herencia, lo cual implica que no pueden ser utilizadas como clases base ni como
clases derivadas. No obstante, s pueden implementar interfaces, y lo hacen igual que las
clases.
Los campos de una estructura no pueden ser inicializados en la declaracin. O sea, por
ejemplo, no se vale decir int a=10; porque tendramos un error de compilacin.



3.35 Captulo 3: Mtodos, Arreglos y Estructuras


Las estructuras, si no se especifican los modificadores ref o out, se pasan por valor, mientras
que las clases se pasan siempre por referencia. No es necesario instanciar una estructura para
poder usar sus miembros.
En el siguiente programa Estructura1.cs declaramos una estructura de tipo entero en el cual
definimos la propiedad Valor para establecer los valores, dentro del cdigo set hacemos
referencia al valor que se solicita, asignando a travs de un parmetro especial del mismo tipo
de dato que la propiedad llamado value, posteriormente con el mtodo Leer se utiliza para
Leer el dato. En el Main() creamos un objeto de tipo Natural que viene siendo una estructura
lnea 25, en la lnea 28 accedemos a la propiedad de la estructura y en la lnea 30 llamamos al
mtodo de la estructura para leer un valor, por ltimo en la lnea 32 imprimimos el valor ledo.




3.36 Captulo 3: Mtodos, Arreglos y Estructuras

Ejecucin:

En el programa Estructura2.cs creamos una estructura llamada Real para establecer y leer
los valores de un nmero real, posteriormente creamos otra estructura llamada Rectangulo
con dos propiedades para establecer el ancho y alto, y un mtodo llamado CrearRectangulo
para leer los valores. En el Main() lnea 49 creamos una variable del tipo Rectngulo, que en
realidad es una estructura, la palabra var puede ser reemplazado por Rectngulo, en las
lneas 55 a 60 accedemos a las caractersticas del rectngulo y calculamos el rea y permetro.
C# 3.0 ofrece inferencia de tipos que es una magnifica caracterstica de cualquier Lenguaje.
Conserva la seguridad del tipo, mientras nos permite escribir un cdigo ms "relajado". En otras
palabras, podemos definir variables y utilizarlas sin preocuparnos demasiado acerca de los
tipos, dejando que el compilador determine el tipo correcto de una variable por inferencia a
partir de la expresin de asignacin a la variable misma. Nos permite definir una variable
mediante el uso de la palabra reservada var en lugar de un tipo especfico. Cuando se utiliza
var, el compilador infiere el tipo de la expresin utilizada para inicializar las variables. El cdigo
generado por el compilador contiene tipo inferido.




3.37 Captulo 3: Mtodos, Arreglos y Estructuras





3.38 Captulo 3: Mtodos, Arreglos y Estructuras


Ejecucin:
















3.39 Captulo 3: Mtodos, Arreglos y Estructuras


En el programa Estructura3.cs establece una estructura llamada Localizacion y un mtodo
llamado MiFunc esta se encuentra en la clase Principal, en la estructura sobre escribimos el
mtodo ToString() para imprimir dos valores, en el Main() creamos dos objeto uno del tipo
estructura el cual llamamos dos veces y otro del tipo Myfunc el cual se llama una sola vez entre
los dos anteriores para comparar como se imprimen ambos valores.