Scribd
Cargar
16 vistas33 páginas

Curso C#

Cargado por

p.escarela.rodriguez
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PPTX, PDF, TXT o lee en línea desde Scribd
16 vistas33 páginas

Curso C#

Cargado por

p.escarela.rodriguez
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PPTX, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 33

Introducción a

Microsoft Visual C#
I. Operadores, tipos de datos,
variables y arreglos.
Operadores
Tipos de datos
Intrínsecos (valores) Complejos (referencias)
Tipo Capacidad de almacenamiento Rango

byte 8 bits, sin signo 0 a 255 System.Byte


sbyte 8 bits, con signo -128 a 127 System.Sbyte
short 16 bits, con signo -32,768 a 32767 System.Int16
ushort 16 bits, sin signo 0 a 65,535 System.UInt16
int 32 bits, con signo -2,147,483,648 a 2,147,483,647 System.Int32
uint 32 bits, sin signo 0 a 4,294,967,295 System.UInt32
long 64 bits, con signo -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 System.Int64
ulong 64 bits, sin signo 0 a 18,446,744,073,709,551,615 System.UInt64
float 32 bits, precisión simple ±1.5 × 10⁻⁴⁵ a ±3.4 × 10³⁸ System.Single
double 64 bits, precisión doble ±5.0 × 10⁻³²⁴ a ±1.7 × 10³⁰⁸ System.Double
decimal 128 bits, alta precisión ±1.0 × 10⁻²⁸ a ±7.9 × 10²⁸ System.Decimal
bool 1 bit 0a1 System.Boolean
char 1 byte Un carácter del conjunto Unicode System.Char
string 24 bytes Hasta 2,147,483,648 caracteres Unicode System.String
object Referencia a cualquier tipo System.Object
Enumeraciones

Es un tipo de dato especial (personalizado) que contiene un


conjunto de valores enteros constantes representados por un
nombre simbólico.

enum <nombre>
{
<valor 1>,
.
.
.
<valor n>
}
Ámbito y accesibilidad de las variables
Ámbito:

 Nivel de bloque
 Nivel de método o función
 Nivel de clase

Accesibilidad:

 public
 private
 protected
 internal
Niveles de accesibilidad

Accesibilidad
Significado
declarada

public El acceso no está restringido.

protected
El acceso está limitado a la clase contenedora o a las tipos derivados de la misma (subclases).

internal El acceso está limitado al ensamblado actual.

protected internal
El acceso está limitado al ensamblado actual o a los tipos derivados de la clase contenedora.

private El acceso está limitado al tipo contenedor.

private protected El acceso está limitado a la clase contenedora o a los tipos derivados de la misma que hay en
el ensamblado actual.
Declaración de variables

[alcance] <tipo> <nombre> [ = <valor> ];

Ejemplos:

int x;
int x = 10;
string nombre = null;
public float sueldo = 5000.53;
private int edad;
protected object item = null;
Arreglos
Una dimensión:
|alcance| <tipo>[] <nombre>| = null |;
|alcance| <tipo>[] <nombre> = new <Tipo>[tamaño];
|alcance| <tipo>[] <nombre> = { <elem 1>, …, <elem n>};

Dos o más dimensiones:


|alcance| <tipo>[]…[] <nombre>| = null |;
|alcance| <tipo>[]…[] <nombre> = new <Tipo>[dim 1]…[dim n];
|alcance| <tipo>[]…[] <nombre> = {
{ <elem 1>, …, <elem n>},
…
{ <elem 1>, …, <elem n>}
};
Arreglos unidimensionales (ejemplos)

char[] simbolos = null;

int[] nums = new int[5];


nums[0] = 5;
nums[1] = 3;
nums[2] = 7;
nums[3] = 4;
nums[4] = 2;

int[] nums = { 5, 3, 7, 4, 2 };
Arreglos multidimensionales (ejemplos)

int[][] nums = new int[2][];


nums[0] = new int[]{ 0, 1, 2 };
nums[1] = new int[]{ 3, 4, 5 };

int[][] nums = {
new int[]{ 0, 1, 2 },
new int[]{ 3, 4, 5 }
};
II. Estructuras de control
Condicionales
if( <expresión lógica> ) switch( <expresión> )
{ {
<conjunto de case <valor 1>:
instrucciones>
}[ <instrucciones>
else if( <expresión lógica> ) break;
{ .
<conjunto de .
instrucciones> .
} case <valor n>:
else
{ <instrucciones>
<conjunto de break;
instrucciones> [default:
}]
<instrucciones>]
}
Operador condicional ternario

[<tipo>] <variable> = <expresión lógica> ?


<alternativa verdadera> : <alternativa
falsa>;

Ejemplo:

int edad = 25;


string msj = edad > 18 ? «mayor» : «menor»;
Repetitivas (for, foreach)

for( <inicialización>; <expresión lógica>; <incremento> )


{
<conjunto de instrucciones>
}

foreach( <elemento> in <colector> )


{
<conjunto de instrucciones>
}
Repetitivas (while, do…while)

while( <expresión lógica> )


{
<conjunto de
instrucciones>
}

do{
<conjunto de
instrucciones>
}while( <expresión lógica> );
Control estructurado de excepciones
try
{
<conjunto de instrucciones>
}
catch[( <TipoExcepción> <identificador> )]
{
<conjunto de instrucciones>
}
[finally
{
<conjunto de instrucciones>
}]
Métodos

[<alcance>] <tipo> <método>( [<parámetros> )


{
<conjunto de instrucciones>
[return( <valor de retorno> );]
}
Ejemplos:

void mensaje(string texto)


{
Console.WriteLine( texto );
}

int suma(int x, int y)


{
return(suma);
}

public int residuo(int dividendo, int divisor)


{
return(dividendo % divisor);
}
Paso de parámetros

Por valor:

<tipo> método( <tipo> <identificador> )

Por referencia:

<tipo> método( ref | out <tipo>


<identificador> )
Lista variable de parámetros y parámetros
opcionales

Lista variable:

<tipo> método( params <tipo>[] <arreglo> )

Opcionales:

<tipo> método( <tipo> <identificador> =


<valor> )
Sobrecarga de métodos
Ejemplo:

void imprimir()
{
. . .
}

void imprimir( object[] datos )


{
. . .
}

string imprimir( int estado )


{
. . .
}
Estructuras
[<alcance>] struct <nombre>
{
<cuerpo>
}

Ejemplo:

public struct Rectangulo


{
public float alto;
public float ancho;
public double area()
{
return(alto * ancho);
}
}
Clases
[alcance] class <nombre>
{
<cuerpo>
}

Ejemplo:

public class Triangulo


{
public float alto;
public float ancho;
public double area()
{
return(alto * ancho);
}
}
Métodos constructores
[alcance] <nombre>( [<parámetros>] )
{
<conjunto de instrucciones>
}

Ejemplo:

class Figura
{
public Figura(int alto, int ancho)
{
//Código a ejecutar
}
}
Clases abstractas

[alcance] abstract class <nombre>


{
<cuerpo>
}
Ejemplo de clase abstracta
public abstract class Figura
{
protected float alto;
protected float ancho;
public abstract double area();
}

public class Rectangulo : Figura


{
public Rectangulo(float alto, float ancho)
{
base.alto = alto;
base.ancho = ancho;
}
public override double area()
{
return(this.alto * this.ancho);
}
}
Interfaces
[alcance] <nombre>
{
<cuerpo>
}

Ejemplo:

public interface ITarea


{
int agregar();
void imprimir();
}
Genéricos
Los genéricos representan una funcionalidad que nos permite
crear código reusable que sea compatible con cualquier tipo de
dato.

[<alcance>] class Clase<T[, U]>

[<alcance>] <tipo> método( T <parámetro> )

[<alcance>] T método( [<parámetros> )

[<alcance>] T método<T>( T <parámetro> )


Delegados
Es un tipo que representa referencias a métodos con una lista de
parámetros determinada y un tipo de valor devuelto.

[<alcance>] delegate <tipo> <nombre>(<parámetros>);


Expresiones lambda
Una expresión lambda es una función anónima que puede
contener expresiones e instrucciones y se puede utilizar para
crear delegados o tipos de árboles de expresión.

([<parámetros>]) => {
<conjunto de
instrucciones>
[return(<valor>);]
}
Hilos
Son unidades de ejecución más pequeñas dentro de un proceso
más grande. Esto significa que un proceso puede dividirse en
múltiples hilos que pueden ejecutarse de forma independiente y
simultánea.

Proceso único Proceso con


múltiples tareas
Hilos
using System.Threading;

Thread <nombre> = new Thread(new ThreadStart(<proceso>));

using System.Threading;
using System.Threading.Tasks;

Task.Factory.StartNew(<delegado>);

También podría gustarte