Download - Guia basica de referencia del lenguaje c#
Universidad politécnica de Tecámac. Ingeniería en software.
GUIA BASICA DE REFERENCIA DEL LENGUAJE C# Gonzalo santiago martinez.
Contenido Código de inicio de un programa. ................................................................................................... 4
Escribir en la consola:..................................................................................................................... 4
Insertar comentarios: ..................................................................................................................... 4
Tipos de variables disponibles. (Primitivas). ................................................................................... 4
Declaración de variables: ............................................................................................................... 5
Asignación de variables: ................................................................................................................. 5
Declaración y asignación de variables............................................................................................. 5
Declaración de múltiples variables del mismo tipo. ........................................................................ 5
operadores aritméticos: ................................................................................................................. 5
Operador de asignación ( = ) .......................................................................................................... 5
Operadores de incremento y decremento ...................................................................................... 6
Operadores de comparación .......................................................................................................... 6
operadores logicos ......................................................................................................................... 6
Orden de prioridad ........................................................................................................................ 6
STRINGS: ........................................................................................................................................ 7
Declaración y asignación de string:................................................................................................. 7
Concatenación: .............................................................................................................................. 7
Caracteres de escape: .................................................................................................................... 7
Declaración de arreglos:................................................................................................................. 7
Declarar tamaño de arreglo: .......................................................................................................... 7
Asignación de arreglo ..................................................................................................................... 7
Acceso a arreglos. .......................................................................................................................... 8
Condicionales: ............................................................................................................................... 8
IF ................................................................................................................................................... 8
Else if ............................................................................................................................................. 8
Else: ............................................................................................................................................... 8
Sentencia switch ............................................................................................................................ 9
Sentencia while: ............................................................................................................................. 9
Sentencia do-while ........................................................................................................................ 9
Sentencia for: ................................................................................................................................ 9
For each ....................................................................................................................................... 10
Crear métodos: ............................................................................................................................ 10
Llamar métodos: .......................................................................................................................... 10
Métodos con parámetros: ............................................................................................................ 11
Declarar una Clase: ...................................................................................................................... 11
Crear una propiedad: ................................................................................................................... 11
Propiedades de solo lectura o de solo escritura............................................................................ 11
//solo lectura ........................................................................................................................... 11
// solo escritura ....................................................................................................................... 12
Creación de un objeto: ................................................................................................................. 12
Acceder a las propiedades de los objetos: .................................................................................... 12
Método constructor: .................................................................................................................... 12
Lista de comandos abreviados ..................................................................................................... 13
El presente documento fue elaborado con el fin de facilitar el aprendizaje del lenguaje c#.
Código de inicio de un programa. class MyApp
{
static void Main()
{
}
}
Escribir en la consola: class MyApp
{
static void Main()
{
System.Console.WriteLine("Hello World");
}
}
Insertar comentarios: // Comentarios de una línea
/* Expresión de
Comentarios multi-linea */
Tipos de variables disponibles. (Primitivas). no se incluye string,
en la tabla pero
existe, aunado a eso
se pueden crear
variables
personalizadas.
Declaración de variables:
int myInt; //variable de tipo entero
float x; //variable de punto flotante
string a = "Hello";
Asignación de variables: myInt = 10;
Declaración y asignación de variables.
int myInt = 10;
Declaración de múltiples variables del mismo tipo.
int myInt = 10, myInt2 = 20, myInt3;
operadores aritméticos: float x = 3 + 2; // 5 // adición
x = 3 - 2; // 1 // sustracción
x = 3 * 2; // 6 // multiplicación
x = 3 / 2; // 1 // división
x = 3 % 2; // 1 // modulo, (resto de la división).
Operador de asignación ( = ) El igual (=), es el operador de asignación, y “establece” el valor de algúna variable u objeto. Operadores de asignación combinados.
int x = 0;
x += 5; // x = x+5;
x -= 5; // x = x-5;
x *= 5; // x = x*5;
x /= 5; // x = x/5;
x %= 5; // x = x%5;
Operadores de incremento y decremento
x++; // x = x+1;
x--; // x = x-1;
x++; // post-incremento
x--; // post-decremento
++x; // pre-incremento
--x; // pre-decremento
Operadores de comparación
bool x = (2 == 3); // false // igual a
x = (2 != 3); // true // diferente a
x = (2 > 3); // false // mayor que
x = (2 < 3); // true // menor que
x = (2 >= 3); // false // mayor o igual que
x = (2 <= 3); // true // menor o igual que
operadores logicos
bool x = (true && false); // false // operación lógica Y (and)
x = (true || false); // true // operación lógica O (or)
x = !(true); // false // operación lógica not.
Orden de prioridad Las expresiones de c# normalmente se evalúan de izquierda a derecha, pero cuando una
operación contiene muchos operadores se sigue el orden de prioridad de los operadores, es decir,
el orden en que son evaluadas las expresiones.
La columna Pre, es el orden de precedencia o prioridad y está seguido del operador.
bool x = 2+3 > 1*4 && 5/5 == 1; // true
**para hacer las cosas más claras se utilizan los paréntesis, el paréntesis tiene el más alto nivel de prioridad**Ya que son la primer expresión evaluada por el compilador pueden ser usadas para especificar que parte de la expresión debe ser evaluada primero. .
bool x = ((2+3) > (1*4)) && ((5/5) == 1); // true
STRINGS:
Declaración y asignación de string: string a = "Hello";
Concatenación: string a = "Hello";
string b = a + " World"; // Hello World
a += " World"; // Hello World
Caracteres de escape:
tabla de caracteres de escape
\n newline \f form feed \t horizontal tab \a alert sound \v vertical tab \’ single quote \b backspace \” double quote \r carriage return \\ backslash \0 null character \uFFFF Unicode character (4-digit hex number)
Declaración de arreglos: int[] x; // no es: int x[]
Declarar tamaño de arreglo: int[] x = new int[3];
Asignación de arreglo
x[0] = 1;
x[1] = 2;
x[2] = 3;
ó
int[] y = new int[] { 1, 2, 3 }; // ambos casos funcionan.
Acceso a arreglos.
System.Console.Write(x[0] + x[1] + x[2]); // 6
Condicionales:
IF int x = new System.Random().Next(3); // genera un valor aleatorio entre 0, 1 o 2
if (x < 1)
{
System.Console.Write(x + " < 1");
}
Else if Para probar un if en otras condiciones, la sentencia del if puede ser extendida con cualquier
número de else-if. **Cada una de estas condiciones adicionales solo se probarán si la condición
previa es falsa.**
int x = new System.Random().Next(3); // genera un valor aleatorio entre 0, 1 o 2
if (x < 1)
{
System.Console.Write(x + " < 1");
}
else if (x > 1)
{
System.Console.Write(x + " > 1");
}
Else: La sentencia if tiene una clausula else que se ejecuta al final, si todas las condiciones previas son
falsas.
int x = new System.Random().Next(3); // genera un valor aleatorio entre 0, 1 o 2
if (x < 1)
{
System.Console.Write(x + " < 1");
}
else if (x > 1)
{
System.Console.Write(x + " > 1");
}
else
{
System.Console.Write(x + " == 1");
}
Sentencia switch int x = new System.Random().Next(3); // muestra un valor aleatorio entre 0, 1 o 2
switch (x)
{
case 0: System.Console.Write(x + " is 0"); break;
case 1: System.Console.Write(x + " is 1"); break;
default:System.Console.Write(x + " is 2"); break;
}
Sentencia while: int i = 0;
while (i < 10)
{
System.Console.Write(i++); // 0-9
}
Sentencia do-while:
int j = 0;
do {
System.Console.Write(j++);
}
while (j < 10); // 0-9
Sentencia for:
for (int k = 0; k < 10; k++)
{
System.Console.Write(k); // 0-9
}
For each El for each provee una forma fácil de hacer iteraciones en arreglos, en cada iteración el siguiente
elemento del arreglo es asignado a la variable especificada, (iterador) y el proceso se repite hasta
que se recorre todo el arreglo o colección.
La sintaxis es: foreach, seguido de paréntesis, tipo de dato mínimo en el arreglo o colección,
nombre de la variable de iteración, seguido de la palabra reservada “in”, seguido de una colección
de datos (arreglo) y fin de paréntesis.
int[] a = { 1, 2, 3 };
foreach (int n in a) //”int” es el tipo mínimo en un arreglo de enteros, “n” es el iterador y “a” es la colección
{
System.Console.Write(n); // 123
}
Crear métodos: class MyApp
{
void MyPrint()
{
System.Console.Write("Hello World");
}
}
Llamar métodos: class MyApp
{
static void Main()
{
MyApp m = new MyApp();
m.MyPrint(); // Hello World
}
Métodos con parámetros: Los paréntesis que siguen al método son usados para pasar argumentos al método. Deben ser
especificados con el tipo de dato, seguido de nombre de la variable y una coma cuando habrá
multiples declaraciones.
void MyPrint(string s1, string s2)
{
System.Console.Write(s1 + s2);
}
static void Main()
{
MyApp m = new MyApp();
m.MyPrint("Hello", " World"); // Hello World
}
Declarar una Clase: class MyRectangle // declaración de una clase
{
public int x, y;
public int GetArea()
{
return x * y;
}
}
Crear una propiedad: class Time
{
public int sec{get; set;} //va después de la declaración de la clase y utiliza set y get para poder modificar sus valores
}
Propiedades de solo lectura o de solo escritura. //solo lectura
private int sec
{
public get { return seconds; }
}
// solo escritura private int sec
{
public set { seconds = value; }
}
Creación de un objeto: class MyClass
{
static void Main()
{
// Create an object of MyRectangle
MyRectangle r = new MyRectangle();
}
}
Acceder a las propiedades de los objetos: Para acceder a las propiedades de los objetos, simplemente se debe de escribir el nombre del
objeto o variable seguido de un punto(.) y aparecerá una lista con las propiedades.
static void Main()
{
MyRectangle r = new MyRectangle();
r.x = 10;
r.y = 5;
int a = r.GetArea(); // 50
}
Método constructor: Permite definir las propiedades de un objeto desde su creación.
public MyRectangle() { x = 10; y = 5; }
Ejemplo:
class MyRectangle
{
public int x, y;
public MyRectangle(int width, int height) //método constructor
{
x = width; y = height;
}
static void Main()
{
MyRectangle r = new MyRectangle(20, 15); //creo el rectángulo con valores específicos
}
}
Lista de comandos abreviados *for – muestra la sintaxis de for
*switch – muestra la sintaxis de switch
If – muestra la sintaxis de if
While – muestra la sintaxis de while
Prop – asistente para crear propiedad
Ctor – asistente para crear método constructor
Cw – escribe -console.writeline(“”); - ***solo funciona en visual studio**.