C#
Introducción
e información general
Historia
C#
es el lenguaje orientado a objetos diseñado por Microsoft para su plataforma
.NET.
struct
YourStruct
interface
IYourInterface
delegate int
YourDelegate();
enum YourEnum
namespace
YourNestedNamespace
class
YourMainClass
Clase
Una clase es una construcción que permite crear tipos
personalizados propios mediante
diferentes.
Una clase
define un tipo de objeto, pero no es propiamente un objeto. Un objeto es
una entidad concreta
basada en una clase y, a veces, se denomina instancia de una clase.
basará el objeto, de
la manera siguiente:
C#
Customer object1 = new Customer();
Cuando
se crea una instancia de una clase, una referencia al objeto se vuelve a pasar
al
programador. En
el ejemplo anterior, object1 es una referencia a un objeto basado
en Customer. Esta referencia apunta al nuevo
objeto, pero no contiene los datos del objeto. De
hecho,
se puede crear una referencia a objeto sin crear un objeto:
C#
Customer object2;
No se
recomienda crear este tipo de referencias que realmente no apuntan a un objeto
existente,
ya que
al intentar el acceso a un objeto a través de esa referencia se producirá un
error en tiempo
de
ejecución. No obstante, este tipo de referencia se puede crear para hacer
referencia a un
objeto,
ya sea creando un nuevo objeto o asignándola a un objeto existente, de la forma
siguiente:
C#
Customer object3 = new Customer();
Este
código crea dos referencias a objeto que se refieren al mismo objeto. Por
consiguiente, los
cambios realizados en el objeto a través de object3 se reflejarán en
los usos
posteriores
de object4. Puesto que el acceso a los objetos basados en clases se
realiza por
referencia, las
clases se denominan tipos por referencia.
La
herencia se realiza a través de una derivación, lo que significa
que una clase se declara
utilizando
una clase base de la cual hereda los datos y el
comportamiento. Una clase base se
especifica
anexando dos puntos y el nombre de la clase base a continuación del nombre de
la
clase
derivada, del modo siguiente:
public class Manager : Employee
Cuando
una clase declara una clase base, hereda todos los miembros de la clase base
excepto los
constructores.
embargo,
dado que una clase base puede heredar de otra clase, una clase puede heredar
indirectamente
de varias clases base. Además, una clase puede implementar directamente
más de
incluyen
una definición de firma pero ninguna implementación. No se pueden crear
instancias de
las clases abstractas. Solo se pueden
utilizar a través de clases derivadas que implementan los
ella. Para
obtener más información, vea Clases
y miembros de clase abstractos y sellados (Guía de programación de C#).
Las
definiciones de clase se pueden dividir entre archivos de código fuente
diferentes. Para
En el
ejemplo siguiente, se define una clase pública que contiene un campo único, un
método y
un
método especial denominado constructor. Para obtener más información,
vea Constructores
C#
public class Person
// Constructor that takes no arguments.
// Constructor that takes one argument.
// Method
person1.SetName("John
Smith");
// Call the constructor that has
one parameter.
// Keep the console window open
in debug mode.
Librerías
Comandos consola
tienen las clases de
“System.Diagnostics” y en particular la clase “Process”, que permite realizar
llamadas a Procesos externos.
Para este ejemplo voy a crear una
aplicación muy simple llamada CMD Executer que su única
función es ejecutar comandos CMD.
Primero vamos a crear una clase
estática llamada “ExecuteCommand” que recibe como
parámetro un comando como cadena de
texto:
static void ExecuteCommand(string _Command)
Nuestro siguiente paso, para que
parezca una consola verdadera es crear un ciclo while infinito, que se detenga
cuando ingresemos el comando “Salir”: static void Main(string[] args)
{
string command = "dir";
Console.WriteLine("CMD Executer V.0.1");
Console.WriteLine("Last Release 05 - Febraury - 2012");
while (true)
{
Console.Write("#:");
command = Console.ReadLine();
if (command == "Salir" || command == "salir")
{
break;
}
ExecuteCommand(command);
}
}
Captura y Lectura de datos
Las propiedades
proporcionan la comodidad de utilizar miembros de datos públicos sin los
riesgos que implica el
acceso no protegido y sin control ni comprobación a los datos de un
objeto. Esto se logra a través de
los descriptores de acceso: métodos especiales que
asignan y
de datos.
y Age (entero). Ambas propiedades proporcionan
descriptores de acceso get y set, por lo que se
consideran propiedades de
lectura y escritura.
Ejemplo
C#
class Person
{
private string name = "N/A";
private int age = 0;
// Declare a Name property of type string:
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}
// Declare an Age property of type int:
public int Age
{
get
{
return age;
}
set
{
age = value;
}
}
public override string ToString()
{
return "Name = " + Name + ", Age = " + Age;
}
}
class TestPerson
{
static void Main()
{
// Create a new Person object:
Person person = new Person();
// Print out the name and the age associated with the person:
Console.WriteLine("Person details - {0}", person);
// Set some values on the person object:
person.Name = "Joe";
person.Age = 99;
Console.WriteLine("Person details - {0}", person);
// Increment the Age property:
person.Age += 1;
Console.WriteLine("Person details - {0}", person);
// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/* Output:
Person details - Name = N/A, Age = 0
Person details - Name = Joe, Age = 99
Person details - Name = Joe, Age = 100
*/
Estructuras repetitivas
Hemos visto cómo comprobar
condiciones, pero no cómo hacer que una cierta parte de un programa se repita
un cierto número de veces o mientras se cumpla una condición (lo que llamaremos
un "bucle"). En C# tenemos varias formas de conseguirlo.
While
Si queremos hacer que una
sección de nuestro programa se repita mientras se cumpla una cierta condición,
usaremos la orden "while". Esta orden tiene dos formatos distintos,
según comprobemos la condición al principio o al final. while (condición)
sentencia;
Es decir, la sentencia se
repetirá mientras la condición sea cierta. Si la condición es falsa ya desde un
principio, la sentencia no se ejecuta nunca. Si queremos que se repita más de
una sentencia, basta agruparlas entre { y }./*---------------------------*/
/* Ejemplo en C# nº 22: */
/* ejemplo22.cs */
/* */
/* La orden "while" */
/* */
/* Introduccion a C#, */
/* Nacho Cabanes */
/*---------------------------*/
using System;
public class Ejemplo22
{
public static void Main()
{
int numero;
Console.Write("Teclea un número (0 para salir): ");
numero = Convert.ToInt32(Console.ReadLine());
while (numero != 0)
{
if (numero > 0) Console.WriteLine("Es positivo");
else Console.WriteLine("Es negativo");
Console.WriteLine("Teclea otro número (0 para salir): ");
numero = Convert.ToInt32(Console.ReadLine());
}
}
}
En este ejemplo, si se
introduce 0 la primera vez, la condición es falsa y ni siquiera se entra al
bloque del "while", terminando el programa inmediatamente.
Do while
Este es el otro formato que
puede tener la orden "while": la condición se comprueba al final. El
punto en que comienza a repetirse se indica con la orden "do", así: do
sentencia;
while (condición);
Al igual que en el caso
anterior, si queremos que se repitan varias órdenes (es lo habitual), deberemos
encerrarlas entre llaves./*---------------------------*/
/* Ejemplo en C# nº 23: */
/* ejemplo23.cs */
/* */
/* La orden "do..while" */
/* */
/* Introduccion a C#, */
/* Nacho Cabanes */
/*---------------------------*/
using System;
public class Ejemplo23
{
public static void Main()
{
int valida = 711;
int clave;
do
{
Console.Write("Introduzca su clave numérica: ");
clave = Convert.ToInt32(Console.ReadLine());
if (clave != valida) Console.WriteLine("No válida!\n");
}
while (clave != valida);
Console.WriteLine("Aceptada.\n");
}
}
En este caso, se comprueba
la condición al final, de modo que se nos preguntará la clave al menos una vez.
Mientras que la respuesta que demos no sea la correcta, se nos vuelve a preguntar.
Finalmente, cuando tecleamos la clave correcta, el ordenador escribe
"Aceptada" y termina el programa./*---------------------------*/
/* Ejemplo en C# nº 24: */
/* ejemplo24.cs */
/* */
/* La orden "do..while" (2) */
/* */
/* Introduccion a C#, */
/* Nacho Cabanes */
/*---------------------------*/
using System;
public class Ejemplo24
{
public static void Main()
{
string valida = "secreto";
string clave;
do
{
Console.Write("Introduzca su clave: ");
clave = Console.ReadLine();
if (clave != valida) Console.WriteLine("No válida!\n");
}
while (clave != valida);
Console.WriteLine("Aceptada.\n");
}
}
For
Ésta es la orden que
usaremos habitualmente para crear partes del programa que se repitan un cierto
número de veces. El formato de "for" es: for (valorInicial; CondiciónRepetición; Incremento)
Sentencia;
Así, para contar del 1 al
10, tendríamos 1 como valor inicial, <=10 como condición de repetición, y el
incremento sería de 1 en 1. Por tanto, el programa quedaría:/*---------------------------*/
/* Ejemplo en C# nº 25: */
/* ejemplo25.cs */
/* */
/* Uso básico de "for" */
/* */
/* Introduccion a C#, */
/* Nacho Cabanes */
/*---------------------------*/
using System;
public class Ejemplo25
{
public static void Main()
{
int contador;
for (contador=1; contador<=10; contador++)
Console.Write("{0} ", contador);
}
}
Recordemos que
"contador++" es una forma abreviada de escribir
"contador=contador+1", de modo que en este ejemplo aumentamos la
variable de uno en uno. for (contador=1; contador<=10; )
la variable
"contador" no se incrementa nunca, por lo que nunca se cumplirá la
condición de salida: nos quedamos encerrados dando vueltas dentro de la orden
que siga al "for". for ( ; ; )
Los bucles "for"
se pueden anidar (incluir uno dentro de otro), de modo que podríamos escribir
las tablas de multiplicar del 1 al 5 con:/*---------------------------*/
/* Ejemplo en C# nº 26: */
/* ejemplo26.cs */
/* */
/* "for" anidados */
/* */
/* Introduccion a C#, */
/* Nacho Cabanes */
/*---------------------------*/
using System;
public class Ejemplo26
{
public static void Main()
{
int tabla, numero;
for (tabla=1; tabla<=5; tabla++)
for (numero=1; numero<=10; numero++)
Console.WriteLine("{0} por {1} es {2}", tabla, numero,
tabla*numero);
}
}
En estos ejemplos que hemos
visto, después de "for" había una única sentencia. Si queremos que se
hagan varias cosas, basta definirlas como un bloque (una sentencia compuesta)
encerrándolas entre llaves. Por ejemplo, si queremos mejorar el ejemplo
anterior haciendo que deje una línea en blanco entre tabla y tabla, sería:/*---------------------------*/
/* Ejemplo en C# nº 27: */
/* ejemplo27.cs */
/* */
/* "for" anidados (2) */
/* */
/* Introduccion a C#, */
/* Nacho Cabanes */
/*---------------------------*/
using System;
public class Ejemplo27
{
public static void Main()
{
int tabla, numero;
for (tabla=1; tabla<=5; tabla++)
{
for (numero=1; numero<=10; numero++)
Console.WriteLine("{0} por {1} es {2}", tabla, numero,
tabla*numero);
Console.WriteLine();
}
}
}
Para "contar" no
necesariamente hay que usar números. Por ejemplo, podemos contar con letras
así:/*---------------------------*/
/* Ejemplo en C# nº 28: */
/* ejemplo28.cs */
/* */
/* "for" que usa "char" */
/* */
/* Introduccion a C#, */
/* Nacho Cabanes */
/*---------------------------*/
using System;
public class Ejemplo28
{
public static void Main()
{
char letra;
for (letra='a'; letra<='z'; letra++)
Console.Write("{0} ", letra);
}
}
En este caso, empezamos en
la "a" y terminamos en la "z", aumentando de uno en uno./*---------------------------*/
/* Ejemplo en C# nº 29: */
/* ejemplo29.cs */
/* */
/* "for" que descuenta */
/* */
/* Introduccion a C#, */
/* Nacho Cabanes */
/*---------------------------*/
using System;
public class Ejemplo29
{
public static void Main()
{
char letra;
for (letra='z'; letra>='a'; letra--)
Console.Write("{0} ", letra);
}
}
Estructura condicional
Una instrucción if identifica que sentencia
se tiene que ejecutar en función del valor de una expresión Boolean. En el ejemplo siguiente,
la variable Booleanresult se establece en true y, a continuación, se
comprueba en la instrucción if. La
salida es The
condition is true.
C#
bool condition = true;
if (condition)
{
Console.WriteLine("The variable is set to true.");
}
else
{
Console.WriteLine("The variable is set to false.");
}
Puede ejecutar los
ejemplos de este tema colocándolos en el método de Main de una aplicación de
consola.
C#
// if-else statement
if (condition)
{
then-statement;
}
else
{
else-statement;
}
// Next statement in the program.
// if statement without an else
if (condition)
{
then-statement;
}
// Next statement in the program.
En una instrucción if-else, si la condición se evalúa como true, se ejecuta la sentencia then-statement. Si condition es false, else-statement ejecuta. Dado que la condición
(condition) no puede ser simultáneamente verdadera (true)
y falsa (false), las sentencias then-statement y else-statement de una instrucción if-else nunca pueden ejecutarse
simultáneamente. Después de then-statement o de las ejecuciones de else-statement, el control se
transfiere a la instrucción siguiente después de la instrucción de if.
C#
// Try with m = 12 and then with m = 8.
int m = 12;
int n = 18;
if (m > 10)
if (n > 20)
{
Console.WriteLine("Result1");
}
else
{
Console.WriteLine("Result2");
}
Si, en su lugar, se desea
que Result2 aparezca cuando (m > 10) es false, puede
especificar que la asociación mediante las llaves para establecer el inicio y
el final de la instrucción anidada de if, como se muestra en el
ejemplo siguiente.
C#
// Try with m = 12 and then with m = 8.
if (m > 10)
{
if (n > 20)
Console.WriteLine("Result1");
}
else
{
Console.WriteLine("Result2");
}
Result2 aparece si la condición (m > 10) evalúa en false.
Ejemplo
En el ejemplo siguiente,
se escribe un carácter de teclado, y el programa utiliza una instrucción anidada
de if para determinar si el
carácter de entrada es un carácter alfabético.Si el carácter de entrada es un
carácter alfabético, el programa comprueba si el carácter se introdujo en
minúsculas o en mayúsculas. Aparecerá un mensaje para cada caso.
C#
Console.Write("Enter a character: ");
char c = (char)Console.Read();
if (Char.IsLetter(c))
{
if (Char.IsLower(c))
{
Console.WriteLine("The character is lowercase.");
}
else
{
Console.WriteLine("The character is uppercase.");
}
}
else
{
Console.WriteLine("The character isn't an alphabetic character.");
}
//Sample Output:
//Enter a character: 2
//The character isn't an alphabetic character.
//Enter a character: A
//The character is uppercase.
//Enter a character: h
//The character is lowercase.
También puede anidar una
instrucción de if dentro de un bloque else,
como el código parcial siguiente. Las instrucciones de if de los nidos de ejemplo
desde dos bloques otros y una continuación bloqueada. Los comentarios
especifican qué condiciones son true o false en cada bloque.
C#
// Change the values of these variables to test the results.
bool Condition1 = true;
bool Condition2 = true;
bool Condition3 = true;
bool Condition4 = true;
if (Condition1)
{
// Condition1 is true.
}
else if (Condition2)
{
// Condition1 is false and Condition2 is true.
}
else if (Condition3)
{
if (Condition4)
{
// Condition1 and Condition2 are false. Condition3 and Condition4 are true.
}
else
{
// Condition1, Condition2, and Condition4 are false. Condition3 is true.
}
}
else
{
// Condition1, Condition2, and Condition3 are false.
}
El ejemplo siguiente
determina si un carácter de entrada es una minúscula, una letra mayúscula, o un
número. Si las tres condiciones son false, el carácter
no es un carácter alfanumérico. El ejemplo muestra un mensaje para cada caso.
C#
Console.Write("Enter a character: ");
char ch = (char)Console.Read();
if (Char.IsUpper(ch))
{
Console.WriteLine("The character is an uppercase letter.");
}
else if (Char.IsLower(ch))
{
Console.WriteLine("The character is a lowercase letter.");
}
else if (Char.IsDigit(ch))
{
Console.WriteLine("The character is a number.");
}
else
{
Console.WriteLine("The character is not alphanumeric.");
}
//Sample Input and Output:
//Enter a character: E
//The character is an uppercase letter.
//Enter a character: e
//The character is a lowercase letter.
//Enter a character: 4
//The character is a number.
//Enter a character: =
//The character is not alphanumeric.
Igual que una instrucción
del bloque else o el bloque then puede ser cualquier instrucción válida, puede
utilizar cualquier expresión booleana válida para la condición. Puede usar operadores
lógicos como &&, y, ||, |y ! para crear condiciones
compuestas. El código siguiente muestra ejemplos.
C#// NOT
bool result = true;
if (!result)
{
Console.WriteLine("The condition is true (result is false).");
}
else
{
Console.WriteLine("The condition is false (result is true).");
}
// Short-circuit AND
int m = 9;
int n = 7;
int p = 5;
if (m >= n && m >= p)
{
Console.WriteLine("Nothing is larger than m.");
}
// AND and NOT
if (m >= n && !(p > m))
{
Console.WriteLine("Nothing is larger than m.");
}
// Short-circuit OR
if (m > n || m > p)
{
Console.WriteLine("m isn't the smallest.");
}
// NOT and OR
m = 4;
if (!(m >= n || m >= p))
{
Console.WriteLine("Now m is the smallest.");
}
// Output:
// The condition is false (result is true).
// Nothing is larger than m.
// Nothing is larger than m.
// m isn't the smallest.
// Now m is the smallest.
Matrices en general
En las matrices de C#, los índices empiezan en
cero. Las matrices de C# funcionan de forma similar a como lo hacen en la
mayoría de los lenguajes populares; existen, sin embargo, algunas diferencias
que se deben conocer.
C#.int[] table; // not int table[];
Otro detalle es que el tamaño de la matriz no
forma parte de su tipo, como ocurre en el lenguaje C. Esto permite declarar una
matriz y asignarle cualquier matriz de objetos int, independientemente de la
longitud de la matriz.
int[] numbers; // declare numbers as an int array of any size
numbers = new int[10]; // numbers is a 10-element array
numbers = new int[20]; // now it's a 20-element array
Declarar matrices
C# admite matrices de una dimensión, matrices
multidimensionales (matrices rectangulares) y matrices de matrices (matrices escalonadas).
El siguiente ejemplo muestra cómo declarar diferentes tipos de matrices:int[] numbers;
Matrices multidimensionales:string[,] names;
Matrices de matrices (escalonadas):byte[][] scores;
La declaración de matrices (como se muestra
arriba) no crea realmente las matrices. En C#, las matrices son objetos (se
explica más adelante en este tutorial) cuyas instancias deben crearse. Los
siguientes ejemplos muestran cómo crear matrices:
int[] numbers = new int[5];
Matrices multidimensionales:string[,] names = new string[5,4];
Matrices de matrices (escalonadas):byte[][] scores = new byte[5][];
for (int x = 0; x < scores.Length; x++)
{
scores[x] = new byte[4];
}
También se pueden utilizar matrices más grandes. Por ejemplo, se
puede utilizar una matriz rectangular de tres dimensiones:int[,,] buttons = new int[4,5,3];
Incluso, se pueden combinar matrices
rectangulares y escalonadas. Por ejemplo, el siguiente código declara una matriz
unidimensional que contiene matrices tridimensionales de matrices
bidimensionales de tipo int:int[][,,][,] numbers;
Ejemplo
El siguiente es un programa completo en C# que
declara y crea instancias de las matrices comentadas anteriormente.
// arrays.cs
using System;
class DeclareArraysSample
{
public static void Main()
{
// Single-dimensional array
int[] numbers = new int[5];
// Multidimensional array
string[,] names = new string[5,4];
// Array-of-arrays (jagged array)
byte[][] scores = new byte[5][];
// Create the jagged array
for (int i = 0; i < scores.Length; i++)
{
scores[i] = new byte[i+3];
}
// Print length of each row
for (int i = 0; i < scores.Length; i++)
{
Console.WriteLine("Length of row {0} is {1}", i, scores[i].Length);
}
}
}
Resultado
Length of row 0 is 3
Length of row 1 is 4
Length of row 2 is 5
Length of row 3 is 6
Length of row 4 is 7
Inicializar matrices
C# proporciona métodos simples y sencillos
para inicializar matrices en el momento de la declaración encerrando los
valores iniciales entre llaves ({}). Los siguientes ejemplos muestran
diferentes modos de inicializar diferentes tipos de matrices.
Matrices
unidimensionales
int[] numbers = new int[5] {1, 2, 3, 4, 5};
string[] names = new string[3] {"Matt", "Joanne", "Robert"};
El tamaño de la matriz se puede omitir, como
se indica a continuación:int[] numbers = new int[] {1, 2, 3, 4, 5};
string[] names = new string[] {"Matt", "Joanne", "Robert"};
También se puede omitir el operador new si se utiliza un inicializador como el
siguiente:int[] numbers = {1, 2, 3, 4, 5};
string[] names = {"Matt", "Joanne", "Robert"};
Matrices
multidimensionales
int[,] numbers = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = new string[2, 2] { {"Mike","Amy"}, {"Mary","Albert"} };
El tamaño de la matriz se puede omitir, como
se indica a continuación:int[,] numbers = new int[,] { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = new string[,] { {"Mike","Amy"}, {"Mary","Albert"} };
También se puede omitir el operador new si se utiliza un inicializador como el
siguiente:int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = { {"Mike", "Amy"}, {"Mary", "Albert"} };
Matriz
escalonada (matriz de matrices)
Las matrices escalonadas se pueden inicializar
como en el siguiente ejemplo:int[][] numbers = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
El tamaño de la primera matriz se puede
omitir, como se indica a continuación:int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
O bienint[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };
Observe que no existe sintaxis de
inicialización para los elementos de una matriz escalonada.
Acceso a miembros de matrices
El acceso a los miembros de una matriz es
sencillo y similar al de los miembros de una matriz de C o C++. Por ejemplo, el
siguiente código crea una matriz denominada numbersy, a
continuación, asigna un 5 al quinto elemento de la matriz:int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
numbers[4] = 5;
El siguiente código declara una matriz
multidimensional y asigna el valor 5 al miembro ubicado en [1, 1]:int[,] numbers = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} };
numbers[1, 1] = 5;
La siguiente es una declaración de una matriz
escalonada de una sola dimensión que contiene dos elementos. El primer elemento
es una matriz de dos enteros, mientras que el segundo es una matriz de tres
enteros:int[][] numbers = new int[][] { new int[] {1, 2}, new int[] {3, 4, 5}
};
La siguiente instrucción asigna 58 al primer
elemento de la primera matriz y 667 al segundo elemento de la segunda matriz:numbers[0][0] = 58;
numbers[1][1] = 667;
numbersy, a
continuación, asigna un 5 al quinto elemento de la matriz:5 al miembro ubicado en [1, 1]:
Las matrices son objetos
En C#, las matrices son realmente objetos. System.Array es el tipo base abstracto de todos los
tipos de matrices. Las propiedades y otros miembros de la clase System.Array se pueden utilizar cuando sea
necesario. Un ejemplo de esto sería utilizar la propiedad Length para obtener la longitud de una
matriz. El siguiente código asigna la longitud de la matriz numbers,
que es 5, a una
variable denominada LengthOfNumbers:int[] numbers = {1, 2, 3, 4, 5};
int LengthOfNumbers = numbers.Length;
La clase System.Array proporciona muchos otros métodos y
propiedades útiles, como métodos para ordenar, buscar y copiar matrices.
numbers,
que es 5, a una
variable denominada LengthOfNumbers:
Usar foreach con matrices
C# dispone de la instrucción foreach. Esta instrucción
proporciona un modo simple y limpio de iterar en los elementos de una matriz.
Por ejemplo, el siguiente código crea una matriz denominada numbers y la recorre mediante la instrucción foreach:int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};
foreach (int i in numbers)
{
System.Console.WriteLine(i);
}
Con matrices multidimensionales, se puede
utilizar el mismo método para recorrer los elementos, por ejemplo:int[,] numbers = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};
foreach(int i in numbers)
{
Console.Write("{0} ", i);
}
El resultado de este ejemplo es:9 99 3 33 5 55
Conexion a base de datos
La conexión a un origen de datos se realiza
fácilmente con Visual C# Express. Puede utilizar herramientas visuales para
buscar una base de datos y agregar una copia local al proyecto. Al instalar SQL
Server Compact 3.5 con Visual C# Express, podrá utilizar una base de datos de
ejemplo denominada Northwind.sdf. Puede conectarse a la base de datos Northwind
mediante la ventana Orígenes de datos.
numbers y la recorre mediante la instrucción foreach:
Para agregar una conexión
a la base de datos Northwind
1.
En el
menú Archivo,
haga clic en Nuevo
proyecto.
Puede conectar a una base de datos de Microsoft
SQL Server utilizando el control SqlDataSource. Para ello, necesita una cadena de conexión y
derechos de acceso a una base de datos de SQL Server. A continuación, puede
utilizar el control SqlDataSource para proporcionar los datos a
cualquier control enlazado a datos que admita la propiedadDataSourceID, por ejemplo, el control GridView.
Para configurar una
cadena de conexión de SQL Server en el archivo Web.config
1.
Abra el
archivo Web.config en el directorio raíz de su aplicación ASP.NET. Si no
dispone de un archivo Web.config, cree uno.o name="CustomerDataConnectionString"
o connectionString Asigne una cadena de
conexión con la ubicación de su SQL Server e información de autenticación, si
existe. La cadena de conexión podría parecerse a la siguiente:o connectionString="Data Source=localhost;Integrated Security=SSPI;Initial Catalog=Northwind"
o providerName Asigne el valor
"System.Data.SqlClient", que especifica que ASP.NET debe utilizar el
proveedor de ADO.NET System.Data.SqlClient al realizar una conexión con esta cadena de
conexión.
<connectionStrings>
<add name="CustomerDataConnectionString"
connectionString="Data Source=localhost;Integrated Security=SSPI;Initial Catalog=Northwind"
providerName="System.Data.SqlClient" />
</connectionStrings>
4.
Guarde el
archivo Web.config y ciérrelo.
Para hacer referencia a
la cadena de conexión de SQL Server desde un control SqlDataSource
1.
Agregue
un control SqlDataSource en la página en la que desea conectar
a la base de datos de SQL Server.o SelectCommand="Select CustomerID, CompanyName From Customers"
o
ConnectionString Establezca el nombre de la cadena de conexión
que ha creado en el archivo Web.config con el formato <%$ ConnectionStrings: connection string name %>.
<asp:SqlDataSource
ID="SqlDataSource1"
runat="server"
ConnectionString="<%$ ConnectionStrings:CustomerDataConnectionString %>"
SelectCommand="SELECT CustomerID, CompanyName FROM Customers" />
<%$ ConnectionStrings: connection string name %>.