Archive for the ‘C# curso’ Category
Definición y Uso:
Una función es un bloque de código que realiza x operaciones y puede devolver o no algún valor.
La principal usabilidad de las funciones y los métodos es aclarar y resusar la programación. Si tuviéramos todo el código de una apicación del tirón sería muy difcícil de leer y de mantener.
Por ejemplo si tenemos un programa en el que hacemos una operación de sumar dos números y luego mostrárla por pantalla, podríamos hacer una función a la que le diéramos los 2 números y ya nos hiciera ella el resto.
La diferencia entre un método y una función es simplemente que los métodos están dentro de las clases, es decir, a las funciones dentro de las clases les llamamos métodos.
Ya que C# sólo admite funciones dentro de clases, todo lo que nos encontramos son métodos.
Declaración:
Sintaxis:
[private/protected/public/internal] [virtual/override/new] [static]
returnType NameOfFunction(
[ref/out] typeParam1 nameParam1,
…
[ref/out] typeParamN nameParamN)
{
// Code
}
Se puede especificar la visibilidad del método (privada/protegida/pública), si no se especifica, los métodos son privados.
Si el keyword static se declara quiere decir que es un método estático. Estos métodos pueden llamarse sin necesidad de tener un objeto de la clase a la que pertencen, aunque no podrán acceder tampoco a los miembros no estáticos de la clase (sean métodos, atributos, propiedades, etc)
También se puede especificar si un método es virtual, sobrecargado o se debe ignorar la virtualidad.
En C# hay que especificar un valor de retorno, aunque si el método no devuelve nada se especifica con el valor void. Si el valor especificado es distinto de void es obligatorio devolver algo en la función (usando return).
Hay que especificar un nombre para los métodos, normalmente es una buena idea que el nombre sea explicatorio de lo que hace la función. También se recomienda escribir un comentario sobre el método explicando su funcionamiento.
Se pueden incluir tantos parámeteros como se quiera (e incluso no poner parámetro). Todos los parámetros especifican primero el tipo y luego el nombre que tienen dentro de la función.
Se puede especificar algunos atributos a los parámetros que se pasan. Vamos a ver 2 posibles valores para estos atributos:
ref: es usado para pasar un parámetro por referencia. Para los tipos por referencia esto significa que se pueden asignar objetos a las variables pasadas. Para los tipos por valor, lo que significa es que pueden ser modificados dentro de la función.
out: es como ref (pasa el valor por referencia) pero además fuerza al método a inicializar el valor antes del final de la función (para cualquier posible punto de retorno).
Como llamar a una función / método en C#:
Sintaxis:
Si el método pertenece a la misma clase:
[val = ]MyFunc([ref/out] param1, [ref/out] param2,…);
Si pertence a otra clase:
[val = ]myObj.MyFunc([ref/out] param1,…);
Si es un método estático (de otra clase):
[val = ]MyClass.MyFunc([ref/out] param1,…);
Si el valor de retorno es void o no es necesario guardarlo, se puede ahorrar esa primera parte. Si la función toma parámetros ref/out éstos deben indicarse también en la llamada a la función.
Ejemplos:
Declaración:
//Funcion que devuelve la suma de los parámetros que le pasamos
public int suma (int operando1, int operando2)
{
int resultado = operando1 + operando2;
return resultado;
}
Utilización:
//Mostramos por pantalla el resultado de la suma de dos números
Console.WriteLine("El resultado de la suma es: " + suma(2,4).ToString());
//Esto tendría como resultado en la consola
//El resultado de la suma es: 6
Tags: c#, c-sharp, declaración, definición, diferencia, funciones, keywords, metodos, out, ref, sintaxis, uso, void
Posted in C# curso |
Los bucles permiten ejecutar un bloque de código varias veces seguidas. Se utilizan para muchas cosas como por ejemplo recorrer arrays y listas de elementos.
Vamos a ver 3, que son los más utilizados y con estos 3 bucles podremos hacer casi todo lo que queramos con relación a los bucles.
- While, el más generico y siempre una buena opción.
- For, muy útil cuando sabes exactamente cuántas veces quieres iterar un bucle.
- Foreach, muy útil para iterar sobre estructuras de datos, aunque presenta ciertas restricciones.
- Un bucle while ejecutará un trozo de código mientras una condición sea true. La condición es comprobada antes de ejecutar el código.
Hay otro tipo de bucle while que comprueba la condición después de ejecutar el código: do/while.
Los bucles while son los más simples y fáciles de entender, pero además, también son los más versátiles.
Cualquier otro tipo de bucle puede ser reescrito como un bucle while.
Sintaxis:
while (condition)
{
// code
}
Ejemplo:
int numero = 0;
while (numero != 7) //mientras la variable numero sea distinta de 7 hara lo que hay entre paréntesis
{
numero++; //sumamos uno a la variable
}
El bucle For es como el bucle while pero teniendo una inicialización y una modificación de la condición formando parte de la sintanxis
Es particularmente útil cuando sabes cuántas veces quieres ejecutar un bloque de código
Y esto es algo muy habitual, especialmente trabajando con datos.
Las variables declaradas en la inicialización tienen como scope el código dentro del bucle y la condición y modificación, no pueden ser accedidas fuera del bucle.
Sintaxis:
for (initialization; condition; modification)
{
// code
}
Ejemplo:
for(int i=0; i<10; ++i)
El bucle foreach sólo se puede usar con colecciones de objetos.
Itera sobre todos los objetos en orden, desde el elemento 0 al último.
Se pueden definir clases que se pueden iterar con el bucle foreach implementando el interfaz IEnumerable.
No se puede cambiar el tamaño de una colección desde dentro del bucle foreach.
No se puede usar foreach para inicializar o modificar el valor de los objetos en la colección.
Usar foreach puede ayudar al compilador a optimizar e incluso a generar código multithread.
Sintaxis:
foreach (Type nameOfObj in arrayToIterate)
{
// code where we can use nameOfObj
}
Ejemplo:
// Declaro el array de 10 elementos de tipo int y le doy los valores de 1 a 10
int[] myArray = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
foreach (int number in myArray)
{ //por cada numero en el array escribo el valor
Console.WriteLine(“myArray has {0} inside”, number);
}
Si en cualquier punto dentro de un bucle se ejecuta un return, se sale de la función.
Hay 2 keywords que se pueden usar dentro de los bucles para modificar su comportamiento por defecto: continue y break.
Continue moverá el puntero de ejecución a la condición del bucle y continuará con la siguiente iteración (si la condición no se cumple), saltándose el resto de código que quede dentro del bucle a ejecutar en esa iteración.
Break saldrá del bucle independientemente de la condición, colocándose en la primera instrucción justo después del bucle
Tags: array, break, bucle, c#, c-sharp, continue, ejemplo, for, foreach while, keywords, listas, sintaxis
Posted in C# curso |
Las estructuras de control en c-sharp es la forma de hacer elecciones entre unas porciones de código u otras. Las 2 más utilizadas son if y switch.
La estructura de control IF permite ejecutar una porción de código sólo si la expresión entre paréntesis () es verdadera. Luego se puede incluir la cláusula else para ejecutar código en caso de que la expresión sea falsa.
int suma = 2 + 2;
if (suma == 4)
{
Console.WriteLine("La suma es cuatro");
}
else
{
Console.WriteLine("La suma es distinta de cuatro");
}
Se pueden anidar varios IF para formar una estrucutra con más opciones.
int suma = 2 + 2;
if (suma == 4)
{
Console.WriteLine("La suma es cuatro");
}else if(suma == 5)
{
Console.WriteLine("La suma es cinco");
}else
{
Console.WriteLine("La suma es distina de cuatro y cinco");
}
Para el ejemplo anterior hay otra opción más económica que es la estructura switch, aunque ésta sólo compara cadenas de texto.
string miCadena = "HolaMundo";
swtich (variable to evaluate):
{
case "HolaMundo":
Console.WriteLine("Ha entrado en este caso");
break;
case "NoEntro":
Console.WriteLine("Ha entrado en este otro caso");
break;
default:
Console.WriteLine("Entraría aquí si no coincide en ningún caso anterior");
break;
}
Tags: c#, c-sharp, estructuras de control, if, switch
Posted in C# curso |
Los arrays se usan para guardar colecciones de un número determinado de objetos del mismo tipo.
Para colecciones de objetos con tamaño variable se pueden utilizar otras clases como List<>, definida en System.Collections.Generic.
Los arrays se pueden definir de varias manera como vemos en estos ejemplos:
Type[] nombreArray = new Type[numeroElementos];
int[] arrayDeEnteros = new int[10];
string[] listaDeFrases = new string[20];
Se pueden definir los miembros de un array en su declaración usando {}:
Type[] nameOfArray = new Type[numElems] { elem1,… }
int[] myArray = new int[5] { 1, 2, 3, 4, 5 };
Para acceder a los miembros de un array se usa el operador []
Se empieza a indexar por el cero.
float[] myArray = new float[4] { 4.0f, 3.0f, 2.0f, 1.0f };
Console.WriteLine(“Mi tercer elemento es: {0}”, myArray[2]); //resultado-> Mi tercer elemento es: 2.0
myArray[1] = 0.0f; //resultado-> { 4.0f, 0.0f, 2.0f, 1.0f }
Se pueden definir arrays multidimensionales:
int[,] my2DArray = new int[2,3] { {1, 2, 3}, {3, 2, 1} };
float[,,] my3DArray = new float[3, 3, 3];
int a = my2DArray[0,2]; // a == 3
También se pueden definir arrays de arrays aunque no tengan todos el mismo tamaño:
int[][] arrayOfArrays = new int[2][] { new int[3] {1, 2, 3}, new int[4] {4, 3, 2, 1} };
int a = arrayOfArrays[1][3]; // a == 1
Al igual que en los Strings los arrays tienen un monton de funciones. Algunas de estas son las más usadas:
La propiedad Length devuelve el tamaño del array
int[] myArray = new int[100];
int arraySize = myArray.Length; // arraySize == 100
Los arrays son tipos por referencia. Si quieres copiar un array entero (con sus valores) se pueden usar las funciones CopyTo() o Copy():
int[] array1 = new int[4] { 1, 2, 3, 4 };
int[] array2 = new int[4];
Array.Copy(array1, array2, array1.Length);
Tags: array, arrays, colecciones, funciones, list, multidimensionales, tamaño, variable
Posted in C# curso |
Sin duda uno de los principales tipos de datos es el tipo de dato String (“cadena de texto”). Por ello C# tiene implementadas un montón de funciones que nos harán la vida mucho más fácil al manejar este tipo de datos.
Vamos a ver algunas de las más “usadas”.
ToLower() y ToUpper(), convierten una string a minúsculas/mayúsculas:
string s = “My String”
s = s.ToUpper(); // s == “MY STRING”
s = s.ToLower(); // s == “my string”
Hay una propiedad Length que devuelve el tamaño de una string:
int numLetters = myString.Length;
Format() se usa para generar una string usando parámetros (al estilo de Write()/WriteLine()):
string s = string.Format(“My number is {0}”, 69);
StartsWith(), EndsWith() se usa para determinar si una string comienza o termina con un determinado texto:
string s = “This is my string”;
bool b = s.StartsWith(“This is”); // b == true
IndexOf() devuelve el índice del primer carácter de la primera aparición de un texto:
string s = “This is my string”;
int index = s.IndexOf(“is”); // index == 5
LastIndexOf() devuelve el índice de la última ocurrencia de un texto o carácter.
string s = “This is a string”;
int index = s.LastIndexOf(‘i’); // index == 13
Replace() permite reemplazar las ocurrencias de un texto por otro
string s = “The teacher is good”;
s = s.Replace(“good”, “crap”);
Casi cualquier objeto en C# puede ser transformado en una string usando la función ToString()
string s1 = myFloat.ToString();
string s2 = myBool.ToString();
Se puede acceder a los caracteres de una string directamente usando el operador [].
string s = “My string”;
char c1 = s[4]; // c1 == ‘s’
Tags: c#, funciones, string, tipo de datos
Posted in C# curso |
Las comparaciones en C-Sharp, son muy útilies para las estructuras de control, como veremos más adelante.
Vamos a aprender a comparar tipos de número, cadenas y booleanos.
Las expresiones de comparación siempre devuelven un boolean
Booleans y números sólo comparten == (es igual que) and != (no es igual que).
bool b = (1 == 5); //el resultado sería falso puesto que 1 es distinto que 5
bool c = (1 != 4); //el resultado sería verdadero puesto que 1 es distino que 4
Hay más operadores de comparación para números:
> y >= la parte de la izq más grande y más grande o igual que la parte de la dch
< y <= la parte de la izq más pequeño y más pequeño o igual que la parte de la dch
El operador de negación se usa con los booleans: !, y nos indica el contrario.
a = !b; // si b fuera verdadero, a sería falso
a = !(1 == c); // a = (1 != c);
En las cadenas también se puede usar los operadores == y != que funcionan como se podría esperar (igualdad y desigualdad). Esto son ‘case sensitive’ es decir discrimina entre mayúsculas y minúsculas:
"hola" == "Hola"; //el resultado sería false
"Hola" == "Hola"; //el resultado sería true
"hola" != "Hola"; //el resultado sería true
C# proporicona un montón de funciones para comparar strings:
Compare() tiene un montón de variantes pero una de las que más se usa es la función Compare (string, string, bool). El último valor que le pasamos a la función es si queremos que ignore las mayúsculas y las minúsculas.
string s1 = “My String”;
string s2 = “my string”;
//haciendo la comparación con operador
bool b1 = (s1 == s2); // b1 sería false
//haciendo la comparación con función
//le pasamos a la función la cadena1, la cadena2 y le decimos que ingore las mayusculas y minusculas
bool b2 = string.Compare(s1, s2, true); // b2 sería true
Tags: aprender, c#, c-sharp, comparaciones, comparar, estructuras de control
Posted in C# curso |
Es muy útil hacer conversiones de tipos en C# y en general en cualquier lenguaje de programación. Para ello C-Sharp tiene unos métodos que nos harán la vida muy fácil.
Objetos a String:
Prácticamente casi todo en C# se puede convertir en una cadena de texto usando el método .ToString(); Vamos a verlo con unos ejemplos con los que lo veremos fácilmente.
int myEntero = 5;
string myCadena = myEntero.ToString();
//podemos concatenar cadenas usando el operador +
myCadena = myCadena + " es un número primo";
Console.WriteLine(myCadena); //el resultado sería 5 es un número primo por pantalla.
String en tipos de datos:
Es muy también pasar cadenas de texto a tipos de datos, por ejemplo para hacer alguna operación, para ello utilizaremos el método .Parse que viene implementado en los tipos de datos. Veremos algún ejemplo.
string myCadena = "3.5";
float myFlotante = float.Parse(myCadena);
float resultado = myFlotante * 2; //la variable resultado tendría 7
Un truco para evitar problemas de ejecución si no se sabe muy bien si va a llegar un dato vacio es añadir una cadena de texto que seá un 0. ej:
string myCadena ="";
float myFlotatnte = float.Parse("0" + myCadena);
Tags: c#, c-sharp, conversiones, objetos, string, tipos
Posted in C# curso |
Los operadores son símbolos que realizan operaciones entre números, variables, constantes, etc. Vamos a ver los más frecuentes en C-Sharp.
Hay unos cuantos operadores matemáticos compartidos por los tipos numéricos (int y float):
Suma: + -> a = 3 + 5; resultado 8
Resta: - -> a = 3.0f – 5.0f; resultado -2.0f
Negación: - -> a = -b; resultado si b = 3, a = -3
Multiplicación: * -> a = 2 * -3; resultado -6
División: / -> a = 34 / 5; resultado 6
Módulo: % -> a = 34 % 5; resultado 4
Los Operadores para booleans siguen las reglas de la lógica matemática:
&& -> y ej: a = true && false; resultado false
|| -> o ej: a = true || false; resultado true
^ -> xor (o exclusivo) ej: a = true ^ false; resultado true
Incremento/decremento de los enteros (ints):
++ -> incremento. Puede colocarse antes o después de la variable
a = 1;
++a; resultado a vale 2.
– -> decremento. Puede colocarse antes o después de la variable
a = 1;
a–; resultado a vale 0
Operadores con asignación:
Si queremos realizar una operación sobre una misma variable podemos utilizar los siguientes operadores:
+= ejemplo: a += 5; resultado a = a + 5;
-= ejemplo: a -= 3.6f; resultado a = a – 3.6f;
*= ejemplo: a *= 2.0f; resultado a = a * 2.0f;
/= ejemplo: a /= 5; resultado a = a / 5;
%= ejemplo: a %= 3; resultado a = a % 3;
También se pueden usar con booleans:
|= ejemplo: a |= (num == 1); resultado a = a | (num == 1);
&= ejemplo: a &= (num == 1); resultado a = a & (num == 1);
^= ejemplo: a ^= (num == 1); resultado a = a ^ (num == 1);
Tags: boolenas, c#, c-sharp, decremento, float, incremento, int, logica, matematica, operadores
Posted in C# curso |
Para empezar a programar en C# es recomendable hacer los testeos, pruebas, ejercicios en Consola, porque no es muy fácil ver los resultados.
Tampoco vamos a entrar mucho en detalle en esta clase, sólo los métodos principales que vamos a utilizar. No obstante si alguien quiere ver más funcionalidades de esta clase puede hacerlo en el MSDN.
Vamos a estudiar una forma muy básica de entrada/salida basada en la consola.
Entrada:
Las 3 funciones principales para entrada son Read(), ReadKey() y ReadLine().
Read() no procesará los resultados hasta que el usuario presione la tecla enter.
ReadKey() procesará los resultados tan pronto como el usuario presione una tecla.
ReadLine() es como Read() pero devuelve la string entera hasta la primera vez que el usuario presiona enter (la linea entera).
ConsoleKeyInfo info = Console.ReadKey();
int firstChar = Console.Read();
string restOfLine = Console.ReadLine();
Lo más usual es el último ejemplo, la función ReadLine().
Salida:
La función más básica es Write() que nos permite escribir cosas (strings, números, booleanos, caracteres, etc) sin cambiar de línea. Alternativamente, se puede usar WriteLine() para añadir un salto de línea al final del texto.
Console.Write("Hola, tengo estos años");
Console.Write(25);
Console.WriteLine(“ Al final de esto que estoy escribiendo hay un salto de linea”);
También se pueden pasar argumentos para cosas que se quieran mostrar:
Console.WriteLine(“Numero 1 es {0} y la variable es {1}”, 3, myNumVar);
Console.Write(“El valor de a es: {0}!”, a);
Tags: c#, c-sharp, clase, consola, programar, read, readkey, readline, write, writeline
Posted in C# curso |
Vamos ahora a ver nuestro primer programa en C-Sharp. Lo vamos a -> descargar aquí.
Este programa ha sido creado como aplicación de consola, por lo que los resultados aparecerán a traves de una consola de MS-Dos.
Como es una aplicación de consola, veremos instrucciones como Console.WriteLine("hola") que significa escribir por la consola una variable o una cadena de texto.(en este caso escribiría hola).
Otra instrucción que aparece es Console.ReadLine() que sigfinica que la consola va a esperar a que pulsemos una tecla que almacenará en la memoria. Se suele utilizar también para hacer pausas como en este ejemplo.
Otra cosa importante que veremos son los comentarios, que aparecerán en verde. Un comentario es una línea que no será interpetrada por el compilador, es decir que no se ejecuta y que sirve para ayudarlos a leer el programa.
Para hacer comentario de una línea ponemos // y para hacer comentarios de varias líneas ponemos /* al principio del comentario y */ al final del mismo.
Es importante que una vez visto el ejemplo, lo estudiemos y comprendamos bien que hace cada cosa.
Tags: aplicacion, c-sharp, comentario, comentarios, consola, ms-dos, programa
Posted in C# curso |
