C# Tutorial

C # es un moderno, de propósito general, el lenguaje de programación

sencillo, orientado a objetos desarrollado por Microsoft dentro de su
iniciativa .NET dirigido por Anders Hejlsberg. Este tutorial te enseñará
programación C # básica y también le llevará a través de diversos
conceptos avanzados relacionados con el lenguaje de programación C #.

Audiencia
Este tutorial ha sido preparado para los principiantes para ayudarles a
entender de programación C # básica.

Requisitos previos
Programación C # es muy basado en los lenguajes de programación C y C
++, por lo que si usted tiene un conocimiento básico de programación C o
C ++, entonces será divertido para aprender C #.

Ejecutar C # en línea
Para la mayoría de los ejemplos dados en este tutorial encontrará Pruébalo
opción, por lo que sólo hacen uso de esta opción para ejecutar sus
programas de C # en el lugar y disfrutar de su aprendizaje.
Trate siguiente ejemplo usando Inténtelo opción disponible en la esquina
superior derecha del cuadro de código de ejemplo siguiente -

using System;
namespace HelloWorldApplication
{
class HelloWorld
{
static void Main(string[] args)
{
/* my first program in C# */
[Link]("Hello World");
[Link]();
}
}
}
C# Visión de conjunto

C # es un moderno, de propósito general, lenguaje de programación

orientado a objetos desarrollado por Microsoft y aprobado por el European
Computer Manufacturers Association (ECMA) y la Organización Internacional
de Normalización (ISO) .
C # fue desarrollado por Anders Hejlsberg y su equipo durante el desarrollo
de .Net Framework.
C # ha sido diseñado para Common Language Infrastructure (CLI) , que
consiste en el entorno de tiempo de ejecución de código y ejecutable que
permite el uso de diversos lenguajes de alto nivel en las diferentes
plataformas de computación y arquitecturas.
Las siguientes razones hacen que C # un lenguaje profesional ampliamente
utilizado:

 Es una de propósito general lenguaje de programación moderno

 Se orientado a objetos.
 Es orientado a componentes.
 Es fácil de aprender.
 Es un lenguaje estructurado.
 Produce programas eficientes.
 Puede ser compilado en una variedad de plataformas informáticas.
 Es una parte del marco .NET.

Funciones de programación fuertes de C #

Aunque C # construcciones siguen de cerca los lenguajes tradicionales de
alto nivel, C y C ++ y ser un lenguaje de programación orientado a objetos.
Tiene gran parecido con Java, que tiene numerosas funciones de
programación fuertes que hacen más entrañable a un número de
programadores en todo el mundo.
A continuación se presenta la lista de algunas de las características
importantes de C #:

 Condiciones de Boole
 Recogida automática de basura
 Biblioteca estándar
 Asamblea de versiones
 Propiedades y eventos
 Los delegados y Gestión de Eventos
 Los genéricos fácil de usar
 indexadores
  Compilación condicional
 multihilo sencilla
 LINQ y Expresiones Lambda
 Integración con Windows

C# Ambiente
Inténtelo opción en línea
Hemos establecido el entorno de programación C # en línea, de
modo que se puede compilar y ejecutar todos los ejemplos
disponibles en línea. Se le da confianza en lo que está leyendo y le
permite verificar los programas con diferentes opciones. Siéntase
libre de modificar ningún ejemplo y ejecutarlo en línea.
El siguiente ejemplo muestra el uso de nuestro compilador de línea
disponible en CodingGround

using System;
namespace HelloWorldApplication
{
class HelloWorld
{
static void Main(string[] args)
{
/* my first program in C# */
[Link]("Hello World");
[Link]();
}
}
}

Para la mayoría de los ejemplos dados en este tutorial, encontrará

una opción Pruébalo en nuestras secciones de código web en la
esquina superior derecha que le llevará al compilador en línea. Así
que simplemente hacer uso de ella y disfrutar de su aprendizaje.
En este capítulo, discutiremos las herramientas necesarias para la creación
de programación C #. Ya hemos mencionado que C # es parte de .NET
Framework y se utiliza para escribir aplicaciones .NET. Por lo tanto, antes de
discutir las herramientas disponibles para la ejecución de un programa en C
#, vamos a entender la forma en C # se refiere al marco .Net.

.Net Framework
El .NET Framework es una plataforma revolucionaria que le ayuda a escribir
los siguientes tipos de aplicaciones:

 aplicaciones de Windows
 aplicaciones web
 servicios web

Las aplicaciones de .NET Framework son aplicaciones multi-plataforma. El

marco ha sido diseñado de tal manera que se puede utilizar desde
cualquiera de los siguientes lenguajes: C #, C ++, Visual Basic, Jscript,
COBOL, etc. Todos estos idiomas pueden acceder al marco, así como
comunicarse entre sí.
El .NET Framework se compone de una enorme biblioteca de códigos
utilizados por los idiomas de cliente, como C #. Los siguientes son algunos
de los componentes de .NET Framework:

 Common Language Runtime (CLR)

 La biblioteca de clases de .NET Framework
 Common Language Specification
 Sistema de tipos común
 Metadatos y Asambleas
 Windows Forms
 [Link] AJAX y [Link]
 [Link]
 Windows Workflow Foundation (WF)
 Fundación de presentación de Windows
 Windows Communication Foundation (WCF)
 LINQ

Para los trabajos de cada uno de estos componentes a funcionar, consulte

[Link] - Introducción , y para los detalles de cada componente, consulte la
documentación de Microsoft.
Entorno de desarrollo integrado (IDE) para C #
Microsoft proporciona las siguientes herramientas de desarrollo para
programación C #:

 Visual Studio 2010 (VS)

 Visual C # 2010 Express (VCE)
 Visual Web Developer

Los dos últimos son de libre acceso desde el sitio web oficial de Microsoft. El
uso de estas herramientas, se puede escribir todo tipo de programas en C
# desde simples aplicaciones de línea de comandos para las aplicaciones
más complejas. También puede escribir archivos de código fuente C #
usando un editor de texto básico, como el Bloc de notas, y compilar el
código en ensamblados utilizando el compilador de línea de comandos, que
a su vez es una parte de .NET Framework.
Visual C # y Visual Web Developer Express Edition se recortada versiones
de Visual Studio y tiene la misma apariencia. Conservan la mayoría de
características de Visual Studio. En este tutorial, hemos utilizado Visual C #
2010 Express.
Puede descargarla desde Microsoft Visual Studio . Que se instala
automáticamente en su máquina.
Nota: Se necesita una conexión a Internet activa para la instalación de la
edición expresa.

Programas de escritura # C en Linux o Mac OS

Aunque [Link] Framework se ejecuta en el sistema operativo de Windows,
hay algunas versiones alternativas que funcionan en otros sistemas
operativos. Mono es una versión de código abierto de .NET
Framework que incluye un compilador de C # y funciona en varios
sistemas operativos, incluyendo varias versiones de Linux y Mac
OS. Cheque bondadoso Ir Mono .
El propósito declarado de Mono es no sólo para ser capaz de ejecutar
aplicaciones de Microsoft .NET multiplataforma, sino también para crear
mejores herramientas de desarrollo para los desarrolladores de Linux. Mono
puede ejecutarse en muchos sistemas operativos como Android, BSD, iOS,
Linux, OS X, Windows, Solaris y UNIX.

C# Estructura del programa

Antes de estudiar bloques de construcción básicos del lenguaje de
programación C #, veamos una estructura desnuda mínimo C # programa
para que lo podemos tomar como referencia en los próximos capítulos.
La creación del Programa Mundial de Hola
Un programa en C # se compone de las siguientes partes:

 declaración de espacio de nombres

 Una clase
 Los métodos de clase
 Los atributos de clase
 Un método Main
 Las declaraciones y expresiones
 comentarios

Veamos un simple código que imprime las palabras "Hello World" :

using System;
namespace HelloWorldApplication
{
class HelloWorld
{
static void Main(string[] args)
{
/* my first program in C# */
[Link]("Hello World");
[Link]();
}
}
}

Cuando este código se compila y ejecuta, se produce el siguiente resultado:

Hello World

Veamos las diferentes partes del programa dado:

 La primera línea del programa using System; - el using palabras
clave se utiliza para incluir el System espacio de nombres en
el programa. Un programa generalmente tiene múltiples using
declaraciones.
  La siguiente línea tiene el namespace de declaración. Un
namespace es una colección de clases. El HelloWorldApplication
espacio de nombres contiene la clase HelloWorld .
 La siguiente línea tiene una class de declaración, la clase
HelloWorld contiene los datos y definiciones de métodos que
utiliza su programa. Clases generalmente contienen múltiples
métodos. Métodos definen el comportamiento de la clase. Sin
embargo, el HelloWorld clase tiene sólo un método Main .
 La siguiente línea define el Main método, que es el entry point
para todos los programas de C #. El Main método establece lo
que hace la clase cuando se ejecuta.
 La siguiente línea /*...*/ es ignorado por el compilador y se pone
añadir comments en el programa.
 El método principal especifica su comportamiento con la declaración
[Link]("Hello World");
WriteLine es un método de la Console la clase definida en el System
espacio de nombres. Esta declaración hace que el mensaje "Hello,
World!" que se mostrará en la pantalla.
 La última línea [Link](); es para los usuarios de [Link].
Esto hace que la espera para el programa de una pulsación de tecla y
evita que la pantalla se ejecute y cerrar rápidamente cuando el
programa se inicia desde Visual Studio .NET.
Vale la pena tener en cuenta los siguientes puntos:
 C # mayúsculas y minúsculas.
 Todas las declaraciones y expresión deben terminar con un punto y
coma (;) .
 La ejecución del programa se inicia en el método Main.
 A diferencia de Java, el nombre del archivo de programa podría ser
diferente del nombre de la clase.

Compilar y ejecutar el Programa

Si está utilizando Visual [Link] para compilar y ejecutar programas de C
#, siga los siguientes pasos:
 Inicie Visual Studio.
 En la barra de menú, seleccione Archivo -> Nuevo -> Proyecto.
 Elija Visual C # a partir de plantillas y elija de Windows.
 Elegir aplicación de consola.
  Especificar un nombre para el proyecto y haga clic en el botón OK.
 Esto crea un nuevo proyecto en el Explorador de soluciones.
 Escribir código en el Editor de código.
 Haga clic en el botón Ejecutar o presione la tecla F5 para ejecutar el
proyecto. Aparece una ventana del símbolo que contiene la línea de
Hello World.
Puede compilar un programa en C # utilizando la línea de comandos en
lugar de la IDE de Visual Studio:
 Abra un editor de texto y añadir el código antes mencionado.
 Guarde el archivo como [Link]
 Abra la herramienta de línea de comandos y vaya al directorio donde
guardó el archivo.
 Tipo csc [Link] y pulse Intro para compilar el código.
 Si no hay errores en el código, el símbolo del sistema le lleva a la
siguiente línea y genera [Link] archivo ejecutable.
 Tipo helloworld para ejecutar su programa.
 Se puede ver la salida Hello World impreso en la pantalla.

C# sintaxis básica
C # es un lenguaje de programación orientado a objetos. En la metodología
de programación orientada a objetos, un programa consta de varios objetos
que interactúan entre sí por medio de acciones. Las acciones que un objeto
puede tomar son llamados métodos. Los objetos del mismo tipo se dice que
tienen el mismo tipo o, se dice que está en la misma clase.
Por ejemplo, consideremos un objeto rectangular. Tiene atributos tales
como longitud y anchura. Dependiendo del diseño, es posible que tenga
maneras para aceptar los valores de estos atributos, el cálculo del área, y la
visualización de datos.
Veamos implementación de una clase Rectángulo y discutimos C # sintaxis
básica:

using System;
namespace RectangleApplication
{
class Rectangle
{
// member variables
double length;
double width;
public void Acceptdetails()
{
length = 4.5;
width = 3.5;
}

public double GetArea()

{
return length * width;
}

public void Display()

{
[Link]("Length: {0}", length);
[Link]("Width: {0}", width);
[Link]("Area: {0}", GetArea());
}
}

class ExecuteRectangle
{
 static void Main(string[] args)
{
Rectangle r = new Rectangle();
[Link]();
[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Length: 4.5
Width: 3.5
Area: 15.75

El using palabras clave

La primera declaración en cualquier programa de C # es

using System;

El using palabra clave se utiliza para la inclusión de los espacios de

nombres en el programa. Un programa puede incluir múltiples
sentencias que utilizan.

La class de palabras clave

La class palabra clave se utiliza para declarar una clase.

Los comentarios en C #
Los comentarios se utilizan para explicar código. Los compiladores ignoran
las entradas de comentario. Los comentarios de varias líneas en programas
C # comienzan con / * y termina con los caracteres * / como se muestra a
continuación:
/* This program demonstrates
The basic syntax of C# programming
Language */

los comentarios de una sola línea se indican mediante el símbolo '//'. Por
ejemplo,

}//end class Rectangle

Las variables de miembro

Las variables son atributos o miembros de datos de una clase, que se
utilizan para almacenar datos. En el programa anterior, el Rectangle clase
tiene dos variables miembro nombradas length y width .

Las funciones miembro

Las funciones son un conjunto de instrucciones que realizan una tarea
específica. Las funciones miembro de una clase se declaran dentro de la
clase. Nuestra clase de muestra del rectángulo contiene tres funciones
miembro: AcceptDetails , GetArea y Display .

Crear instancias de una clase

En el programa anterior, la clase ExecuteRectangle contiene el Main()
método y crea una instancia del Rectangle clase.

identificadores
Un identificador es un nombre usado para identificar una clase, variable,
función, o cualquier otro elemento definido por el usuario. Las reglas
básicas para la denominación de las clases en C # son los siguientes:
 Un nombre debe comenzar con una letra que podría ser seguido por
una secuencia de letras, dígitos (0 - 9) o un guión. El primer carácter
de un identificador no puede ser un dígito.
 No debe contener ningún espacio o símbolo incrustado como? - +! @
#% ^ & * ( ) [] {}. ; : " '/ Y \ Sin embargo, un subrayado. ( _ ) Se
puede utilizar.
  No debe ser una palabra clave de C #.

Palabras clave de C #
Palabras clave son palabras reservadas predefinidas para el compilador de
C #. Estas palabras clave no se pueden utilizar como identificadores. Sin
embargo, si desea utilizar estas palabras clave como identificadores, puede
prefijar los mensajes con el carácter @.
En C #, algunos identificadores tienen un significado especial en el
contexto de código, como obtener y establecer se llaman palabras clave
contextuales.
La siguiente tabla muestra las palabras clave reservadas y las palabras
claves contextuales en C #:
Reserved Keywords

abstract as base bool break byte case

catch char checked class const continue decimal

default delegate do double else enum event

explicit extern false finally fixed float for

in (generic
foreach goto if implicit in int
modifier)

interface internal is lock long namespace new

out (generic
null object operator out override params
modifier)

private protected public readonly ref return sbyte

sealed short sizeof stackalloc static string struct

switch this throw true try typeof uint

unchecke
ulong unsafe ushort using virtual void
d

volatile while
Contextual Keywords

ascendin descendin
add alias dynamic from get
g g

partial
global group into join let orderby
(type)

partial
remove select set
(method)

C# Tipos de datos

Las varibles en C #, se clasifican en los siguientes tipos:

 Los tipos de valor

 tipos de referencia
 tipos de puntero

Tipo de valor
Las variables de tipo valor se puede asignar un valor directamente. Se
derivan de la clase [Link] .
Los tipos de valor contienen directamente datos. Algunos ejemplos son int,
char, and float , que almacena números, alfabetos, y los números
de coma flotante, respectivamente. Cuando se declara una int tipo, el
sistema asigna memoria para almacenar el valor.
La siguiente tabla muestra los tipos de valor disponibles en C # 2010:
Valor
por
Tipo representa Distancia
defect
o

bool valor booleano True or False False

byte 8 bits entero sin signo 0 to 255 0

char de caracteres Unicode de U +0000 to U +ffff '\0'

 16 bits

128 bits valores

decima decimales precisos con
(-7.9 x 10 28
to 7.9 x 10 28
) / 10 0 to 28
0.0M
l 28-29 dígitos
significativos

64 bits de doble precisión (+/-)5.0 x 10 -324

to (+/-) 1.7 x 10
double 0.0D
el tipo de punto flotante 308

32 bits de precisión
float simple tipo de punto -3.4 x 10 38
to + 3.4 x 10 38
0.0F
flotante

32-bit de tipo entero con

int -2,147,483,648 to 2,147,483,647 0
signo

64-bit de tipo entero con -9,223,372,036,854,775,808 to

long 0L
signo 9,223,372,036,854,775,807

sbyte 8-bit tipo entero con signo-128 to 127 0

16-bit de tipo entero con

short -32,768 to 32,767 0
signo

32-bit de tipo entero sin

uint 0 to 4,294,967,295 0
signo

64-bit de tipo entero sin

ulong 0 to 18,446,744,073,709,551,615 0
signo

16-bit de tipo entero sin

ushort 0 to 65,535 0
signo

Para obtener el tamaño exacto de un tipo o una variable en una plataforma

en particular, se puede utilizar el sizeof método. La expresión sizeof(type)
se obtiene el tamaño de almacenamiento del objeto o del tipo en bytes. A
continuación se presenta un ejemplo para obtener el tamaño de int tipo en
cualquier máquina:

using System;
namespace DataTypeApplication
{
 class Program
{
static void Main(string[] args)
{
[Link]("Size of int: {0}", sizeof(int));
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Size of int: 4

Tipo de referencia
Los tipos de referencia no contienen los datos reales almacenados en una
variable, pero que contienen una referencia a las variables.
En otras palabras, se refieren a una posición de memoria. El uso de
múltiples variables, los tipos de referencia se puede referir a una ubicación
de memoria. Si los datos de la posición de memoria se cambia por una de
las variables, la otra variable refleja automáticamente este cambio de valor.
Ejemplo de built-in los tipos de referencia son: object , dynamic, y
string .
Tipo de objeto
El Object Type es la clase base definitiva para todos los tipos de
datos en C # Common Type System (CTS) . Objeto es un alias para la
clase [Link]. Los tipos de objetos pueden ser valores de cualquier
otro tipo, tipos de valores, tipos de referencia, tipos predefinidos o definidos
por el usuario asignados. Sin embargo, antes de asignar valores, se
necesita la conversión de tipos.
Cuando un tipo de valor se convierte en tipo de objeto, se llama boxing y
por el otro lado, cuando un tipo de objeto se convierte en un tipo
de valor, se llama unboxing .

object obj;
obj = 100; // this is boxing
Tipo dinámico
Se puede almacenar cualquier tipo de valor en la variable tipo de datos
dinámico. La verificación de tipos para estos tipos de variables se lleva a
cabo en tiempo de ejecución.
Sintaxis para declarar un tipo dinámico es:

dynamic <variable_name> = value;

Por ejemplo,

dynamic d = 20;

tipos dinámicos son similares a los tipos de objetos a excepción de que la

comprobación de tipos para las variables de tipo de objeto se lleva a cabo
en tiempo de compilación, mientras que para las variables de tipo dinámico
se lleva a cabo en tiempo de ejecución.
Tipo string
El String Type le permite asignar cualquier valor de cadena a una
variable. El tipo de cadena es un alias de la clase [Link]. Se deriva
de tipo de objeto. El valor de un tipo de cadena se puede asignar con
literales de cadena en dos formas: citó y @quoted.
Por ejemplo,

String str = "Tutorials Point";

Una cadena @quoted miradas literales de la siguiente manera:

@"Tutorials Point";

Los tipos de referencia definidos por el usuario son: clase, interfaz o

delegado. Vamos a discutir este tipo en el capítulo posterior.

Tipo de puntero
Las variables de tipo puntero almacenar la dirección de memoria de otro
tipo. Punteros en C # tienen las mismas capacidades que los punteros en C
o C ++.
Sintaxis para declarar un tipo de puntero es:

type* identifier;

Por ejemplo,
char* cptr;
int* iptr;

Vamos a discutir los tipos de puntero en 'Códigos inseguras' del capítulo.

C# tipo de conversión
Conversión de tipo es la conversión de un tipo de datos a otro tipo. También
se conoce como la conversión de tipos. En C #, el tipo de colada tiene dos
formas:
 Implicit type conversion - Estas conversiones se llevan a cabo
por C # en una forma de tipo seguro. Por ejemplo, son
conversiones de menor a tipos y conversiones integrales de mayor
tamaño de las clases derivadas a clases base.
 Explicit type conversion - Estas conversiones se realizan de
forma explícita por los usuarios utilizando las funciones
predefinidas. Conversiones explícitas requieren un operador de
conversión.
El ejemplo siguiente muestra una conversión de tipo explícito:

using System;
namespace TypeConversionApplication
{
class ExplicitConversion
{
static void Main(string[] args)
{
double d = 5673.74;
int i;

// cast double to int.

i = (int)d;
[Link](i);
[Link]();
}
 }
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

5673

Métodos de conversión de tipo C #

C # proporciona los siguientes métodos de conversión de tipo incorporados:
No
Seño Métodos y descripción
r

ToBoolean
1
Convierte un tipo en un valor booleano, si es posible.
ToByte
2
Convierte un tipo a un byte.
ToChar
3 Convierte un tipo a un solo carácter Unicode, siempre que sea
posible.
ToDateTime
4 Convierte un tipo (integer or string type) a las estructuras de fecha y
hora.
ToDecimal
5
Convierte un punto flotante o tipo entero a un tipo decimal.
ToDouble
6
Convierte un tipo a un tipo doble.
ToInt16
7
Convierte un tipo en un entero de 16 bits.
ToInt32
8
Convierte un tipo en un entero de 32 bits.
9 ToInt64
 Convierte un tipo en un entero de 64 bits.
ToSbyte
10
Convierte un tipo a otro tipo byte con signo.
ToSingle
11
Convierte un tipo a un pequeño número de coma flotante.
ToString
12
Convierte un tipo en una cadena.
ToType
13
Convierte un tipo a un tipo especificado.
ToUInt16
14
Convierte un tipo a un tipo unsigned int.
ToUInt32
15
Convierte un tipo a un tipo largo sin signo.
ToUInt64
16
Convierte un tipo a un gran número entero sin signo.
El ejemplo siguiente convierte varios tipos de valor a tipo de cadena:

using System;
namespace TypeConversionApplication
{
class StringConversion
{
static void Main(string[] args)
{
int i = 75;
float f = 53.005f;
double d = 2345.7652;
bool b = true;

[Link]([Link]());
 [Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]();

}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

75
53.005
2345.7652
True

C# Variables
Una variable es nada más que un nombre dado a un área de
almacenamiento que nuestros programas pueden manipular. Cada variable
en C # tiene un tipo específico, el cual determina el tamaño y el diseño de
la memoria de la variable de la gama de valores que puede ser almacenado
dentro de esa memoria y el conjunto de operaciones que puede ser
aplicado a la variable.
Los tipos de valores básicos ofrecidos en C # se pueden clasificar como:
Tipo Ejemplo

tipos integrales sbyte, byte, short, ushort, int, uint larga, ulong, y Char

Flotante tipos de
flotador y doble
puntos

tipos decimales decimal

tipos de Boole los valores verdadero o falso, como asignado

Los tipos anulablestipos de datos anulables

C # también permite la definición de otros tipos de valores de la variable

como enum y de referencia tipos de variables tales como la class ,
que vamos a cubrir en los capítulos siguientes.

Definición de variables
Sintaxis para la definición de variables en C # es:

<data_type> <variable_list>;

Aquí, data_type debe ser un tipo de datos C # válida incluyendo char, int,
float, doble, o cualquier tipo de datos definido por el usuario, y variable_list
puede consistir de uno o más nombres de identificadores separados por
comas.
Algunas definiciones de variables válidos se muestran aquí:

int i, j, k;
char c, ch;
float f, salary;
double d;

Puede inicializar una variable en el momento de la definición como:

int i = 100;

La inicialización de variables
Las variables se inicializan (assigned a value) con un signo igual seguido de
una expresión constante. La forma general de la inicialización es:

variable_name = value;

Las variables pueden ser inicializadas en su declaración. El inicializador

consta de un signo igual seguido de una expresión constante como:
<data_type> <variable_name> = value;

Algunos ejemplos son:

int d = 3, f = 5; /* initializing d and f. */

byte z = 22; /* initializes z. */
double pi = 3.14159; /* declares an approximation of pi. */
char x = 'x'; /* the variable x has the value 'x'. */

Es una buena práctica de programación para inicializar las variables

correctamente, de lo contrario el programa a veces puede producir
resultados inesperados.
El ejemplo siguiente utiliza varios tipos de variables:

using System;
namespace VariableDefinition
{
class Program
{
static void Main(string[] args)
{
short a;
int b ;
double c;

/* actual initialization */
a = 10;
b = 20;
c = a + b;
[Link]("a = {0}, b = {1}, c = {2}", a, b,
c);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

a = 10, b = 20, c = 30

Aceptan valores de usuario

La Console clase en el System espacio de nombres proporciona una
función de ReadLine() para aceptar la entrada del usuario y lo
almacena en una variable.
Por ejemplo,

int num;
num = Convert.ToInt32([Link]());

La función Convert.ToInt32() convierte los datos introducidos por el

usuario a int tipo de datos, ya que [Link]() acepta los
datos en formato de cadena.

LValue y RValue expresiones en C #:

Hay dos tipos de expresiones en C #:
 lvalue: Una expresión que es un lvalue puede aparecer como
ya sea el izquierdo o lado derecho de una asignación.
 rvalue: Una expresión que es un valor de lado derecho puede
aparecer en la parte derecha, pero no de la izquierda de una
asignación.
Las variables son lvalues y por lo tanto pueden aparecer en el lado
izquierdo de una asignación. Los literales numéricos son rvalues y por lo
tanto no pueden ser asignados y no pueden aparecer en el lado izquierdo.
Lo que sigue es una declaración válida de C #:

int g = 20;

Pero siguientes no es una declaración válida y generaría error de

compilación:

10 = 20;
C# Constantes y literales
Las constantes se refieren a valores fijos que el programa no puede alterar
durante su ejecución. Estos valores fijos son también llamados literales. Las
constantes pueden ser de cualquiera de los tipos de datos básicos como
una constante entera, una constante de coma flotante, una constante de
caracteres, o una cadena literal. También hay constantes de enumeración
también.
Las constantes son tratadas igual que las variables regulares, excepto que
sus valores no pueden ser modificados después de su definición.

Los literales enteros

Un entero literal puede ser un decimal, octal, o constante hexadecimal. Un
prefijo especifica la base o radix: 0x o 0X para hexadecimal, 0 para octal, y
no Identificación del prefijo para decimal.
Un entero literal también puede tener un sufijo que es una combinación de
U y L, para unsigned y largo, respectivamente. El sufijo puede ser en
mayúsculas o minúsculas y puede estar en cualquier orden.
Estos son algunos ejemplos de literales enteros:

212 /* Legal */
215u /* Legal */
0xFeeL /* Legal */
078 /* Illegal: 8 is not an octal digit */
032UU /* Illegal: cannot repeat a suffix */

Los siguientes son otros ejemplos de diversos tipos de literales enteros:

85 /* decimal */
0213 /* octal */
0x4b /* hexadecimal */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
Los literales de punto flotante
A-coma flotante literal tiene una parte entera, un punto decimal, una parte
fraccionaria, y una parte exponente. Puede representar literales de punto
flotante, ya sea en forma decimal o exponencial.
Estos son algunos ejemplos de literales de punto flotante:

3.14159 /* Legal */
314159E-5L /* Legal */
510E /* Illegal: incomplete exponent */
210f /* Illegal: no decimal or exponent */
.e55 /* Illegal: missing integer or fraction */

Si bien representa en forma decimal, se debe incluir el punto decimal, el

exponente, o ambos; y mientras que representa el uso de la forma
exponencial debe incluir la parte entera, la parte fraccional, o ambos. El
exponente firmado se introduce por correo o E.

Las constantes de caracteres

Los literales de caracteres están entre comillas simples. Por ejemplo, 'x' y
puede ser almacenado en una variable simple de tipo char. Un carácter
literal puede ser un carácter liso (such as 'x') , una secuencia de escape
(such as '\t') , o un carácter universal (such as '\u02C0') .
Hay ciertos caracteres en C # cuando están precedidos por una barra
invertida. El tener un significado especial y se utilizan para representar
como nueva línea (\n) o pestaña (\t) . A continuación, se muestra una lista
de algunos de estos códigos secuencia de escape:
Secuencia de
Sentido
escape

\\ \ personaje

\' ' personaje

\" " personaje

\? ? personaje

\a Alerta o campana
\b Retroceso

\f avance de página

\n Nueva línea

\r retorno de carro

\t pestaña horizontal

\v pestaña vertical

\ooo número octal de uno a tres dígitos

\xhh . . . número hexadecimal de uno o más dígitos

El siguiente es el ejemplo para mostrar unos personajes secuencia de

escape:

using System;
namespace EscapeChar
{
class Program
{
static void Main(string[] args)
{
[Link]("Hello\tWorld\n\n");
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Hello World
Los literales de cadena
Cadenas literales o constantes se encierran entre comillas dobles "" o con
@ "". Una cadena contiene caracteres que son similares a los literales de
caracteres: personajes planos, secuencias de escape, y los caracteres
universales.
Puede romper una larga línea en múltiples líneas usando literales de
cadena y que separan las partes que utilizan espacios en blanco.
Estos son algunos ejemplos de literales de cadena. Todas las formas son
tres cadenas idénticas.

"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
@"hello dear"

Definición de Constantes
Las constantes se definen mediante la const palabra clave. Sintaxis para
definir una constante es:

const <data_type> <constant_name> = value;

El programa siguiente muestra la definición y el uso de una constante en su

programa:

using System;
namespace DeclaringConstants
{
class Program
{
static void Main(string[] args)
{
const double pi = 3.14159;

// constant declaration
 double r;
[Link]("Enter Radius: ");
r = [Link]([Link]());
double areaCircle = pi * r * r;
[Link]("Radius: {0}, Area: {1}", r,
areaCircle);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Enter Radius:
3
Radius: 3, Area: 28.27431

C# operadores
Un operador es un símbolo que indica al compilador para realizar
manipulaciones matemáticas o lógicas específicas. C # tiene amplio
conjunto de operadores integrados y ofrece los siguientes tipos de
operadores:

 Operadores aritméticos
 Operadores relacionales
 Operadores logicos
 Los operadores bit a bit
 Operadores de Asignación
 Los operadores misceláneos

Este tutorial explica la aritmética, relacional, lógica, bit a bit, asignación, y

otros operadores de uno por uno.

Operadores aritméticos
La siguiente tabla muestra todos los operadores aritméticos soportados por
C #. Supongamos variable de A tiene 10 y la variable B tiene 20 a
continuación:
Mostrar ejemplos
Operado
Descripción Ejemplo
r

+ Suma dos operandos A + B = 30

- Resta segundo operando de la primera A - B = -10

* Multiplica los dos operandos A * B = 200

/ Divide el numerador por numerador de- B / A = 2

Módulo del operador y de resto de

% B%A=0
después de una división entera

operador de incremento aumenta el

++ A++ = 11
valor de número entero por uno

operador de decremento disminuye

-- A-- = 9
valor entero por uno

Operadores relacionales
La siguiente tabla muestra todos los operadores relacionales con el apoyo
de C #. Supongamos variable de A tiene 10 y la variable B tiene 20,
entonces:
Mostrar ejemplos
Operado
Descripción Ejemplo
r

Comprueba si los valores de los dos

== operandos son iguales o no, si sí, (A == B) is not true.
entonces condición sea verdadera.

Comprueba si los valores de los dos

operandos son iguales o no, si los
!= (A != B) is true.
valores no son iguales, entonces se
convierte en verdadera condición.

> Comprueba si el valor del operando de (A > B) is not true.

la izquierda es mayor que el valor del
 operando de la derecha, si es sí,
entonces condición sea verdadera.

Comprueba si el valor del operando de

la izquierda es menor que el valor del
< (A < B) is true.
operando de la derecha, si es sí,
entonces condición sea verdadera.

Comprueba si el valor del operando de

la izquierda es mayor o igual al valor del
>= (A >= B) is not true.
operando de la derecha, si es sí,
entonces condición sea verdadera.

Comprueba si el valor del operando de

la izquierda es menor o igual al valor del
<= (A <= B) is true.
operando de la derecha, si es sí,
entonces condición sea verdadera.

Operadores logicos
La siguiente tabla muestra todos los operadores lógicos soportados por C #.
Supongamos variable de A tiene un valor booleano verdadero y la
variable B tiene un valor booleano falso, entonces:
Mostrar ejemplos
Operado
Descripción Ejemplo
r

Denominado operador lógico AND. Si

tanto los operandos no son cero,
&& (A && B) is false.
entonces la condición se convierte en
realidad.

Denominado operador lógico OR. Si

cualquiera de los dos operandos es no
|| (A || B) is true.
cero, entonces la condición se convierte
en realidad.

! Llamado Lógico NO operador. Se utiliza !(A && B) is true.

para invierte el estado lógico de su
operando. Si una condición es
verdadera entonces Lógico NO operador
 hará falsa.

Los operadores bit a bit

operador de bits funciona en trozos y realizar poco a poco la operación. Las
tablas de verdad para y, | y ^ son los siguientes:
pag q p&q p|q p^q

0 0 0 0 0

0 1 0 1 1

1 1 1 1 0

1 0 0 1 1

Supongamos que si A = 60; y B = 13; a continuación, en el formato binario

que son los siguientes:
A = 0011 1100
B = 0000 1101
-----------------
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
Los operadores bit a bit con el apoyo de C # se enumeran en la siguiente
tabla. Supongamos variable A posee el 60 y variable B tiene 13, entonces:
Mostrar ejemplos
Operado
Descripción Ejemplo
r

copias binarias y operador un poco al

(A & B) = 12, which is
& resultado si existe en ambos
0000 1100
operadores.

| copias binarias u operador un poco si es (A | B) = 61, which is

 que existe en uno de los operandos. 0011 1101

Binarios copias XOR Operador del bit si

(A ^ B) = 49, which is
^ se establece en un operando, pero no
0011 0001
ambos.

(~A ) = 61, which is

Complemento a binarios operador
1100 0011 in 2's
~ unario es y tiene el efecto de mover de
complement due to a
un tirón bits ''.
signed binary number.

Binaria operador de desplazamiento a la

izquierda. El valor operandos izquierda
A << 2 = 240, which is
<< se mueve la izquierda por el número de
1111 0000
bits especificado por el operando de la
derecha.

Binaria operador de desplazamiento a la

derecha. El valor operandos izquierda
A >> 2 = 15, which is
>> se mueve a la derecha por el número de
0000 1111
bits especificado por el operando de la
derecha.

Operadores de Asignación
Hay siguientes operadores de asignación soportados por C #:
Mostrar ejemplos
Operado
Descripción Ejemplo
r

operador de asignación simple, Asigna

C = A + B assigns value
= valores de operandos lado derecho al
of A + B into C
lado izquierdo del operando

Agregar y operador de asignación, se

añade operando de la derecha a la C += A is equivalent to
+=
izquierda del operando y asigna el C=C+A
resultado a la izquierda del operando

-= Restar y operador de asignación, Resta C -= A is equivalent to C

operando derecho del operando de la
 izquierda y asigna el resultado a la
=C-A
izquierda del operando

Multiplicar y operador de asignación, se

multiplica operando de la derecha con C *= A is equivalent to C
*=
el operando de la izquierda y asigna el = C * A
resultado a la izquierda del operando

Divide y operador de asignación, se

divide operando de la izquierda con el C /= A is equivalent to C
/=
operando derecho y asigna el resultado = C / A
a la izquierda del operando

Módulo y operador de asignación, Toma

módulo utilizando dos operandos y C %= A is equivalent to
%=
asignar el resultado a operando de la C=C%A
izquierda

desplazamiento a la izquierda y C <<= 2 is same as C =

<<=
operador de asignación C << 2

desplazamiento a la derecha Y operador C >>= 2 is same as C =

>>=
de asignación C >> 2

C &= 2 is same as C = C
&= AND bit a bit operador de asignación
&2

bit a bit OR exclusiva y operador de C ^= 2 is same as C = C

^=
asignación ^2

bit a bit OR inclusivo y operador de C |= 2 is same as C = C |

|=
asignación 2

Los operadores miscillaneous

Hay algunos otros operadores importantes, incluyendo sizeof, typeof y ? :
? : El apoyo de C #.
Mostrar ejemplos
Operado
Descripción Ejemplo
r
 Devuelve el tamaño de un tipo de
sizeof() sizeof(int), returns 4.
datos.

typeof() Devuelve el tipo de una clase. typeof(StreamReader);

&a; returns actual

& Devuelve la dirección de una variable.
address of the variable.

*a; creates pointer

* Puntero a una variable.
named 'a' to a variable.

If Condition is true ?
?: La expresión condicional Then value X : Otherwise
value Y

If( Ford is Car) // checks

Determina si un objeto es de un cierto
is if Ford is an object of the
tipo.
Car class.

Object obj = new

Fundido, sin lanzar una excepción si StringReader("Hello") ;
as
falla el reparto.
StringReader r = obj as
StringReader;

Prioridad de los operadores en C #

La precedencia de operadores determina la agrupación de términos en una
expresión. Esto afecta a la evaluación de una expresión. Algunos
operadores tienen mayor prioridad que los demás; Por ejemplo, el operador
de multiplicación tiene mayor precedencia que el operador de suma.
Por ejemplo x = 7 + 3 * 2; aquí, x es asignado 13, no 20 porque operador *
tiene mayor precedencia que +, por lo que la primera evaluación se lleva a
cabo para 3 * 2 y después se añade 7 en él.
Aquí, los operadores con la prioridad más alta aparecen en la parte superior
de la tabla, los que tienen los más bajos aparecen en la parte inferior.
Dentro de una expresión, los operadores de mayor precedencia se evalúan
primero.
Mostrar ejemplos
Categoría Operador asociatividad
Postfix () [] ->. ++ - - Left to right

De derecha a
Unary + - ! ~ ++ - - (type) * & sizeof
izquierda

Multiplicativ De izquierda a
*/%
e derecha

De izquierda a
Additive +-
derecha

De izquierda a
Shift << >>
derecha

De izquierda a
Relational < <= > >=
derecha

De izquierda a
Equality == !=
derecha

De izquierda a
Bitwise AND &
derecha

De izquierda a
Bitwise XOR ^
derecha

De izquierda a
Bitwise OR |
derecha

De izquierda a
Logical AND &&
derecha

De izquierda a
Logical OR ||
derecha

De derecha a
Conditional ?:
izquierda

De derecha a
Assignment = += -= *= /= %=>>= <<= &= ^= |=
izquierda

De izquierda a
Comma ,
derecha
C# Toma de decisiones
Toma de decisiones estructuras requiere que el programador para
especificar una o más condiciones a ser evaluados o probados por el
programa, junto con una declaración o sentencias que se ejecutan si la
condición se determina para ser verdad, y opcionalmente, otras
declaraciones que se ejecutan si la condición se determina que es falsa.
A continuación se presenta lo general de una típica estructura de toma de
decisiones que se encuentra en la mayoría de los lenguajes de
programación:

C # ofrece los siguientes tipos de declaraciones de toma de decisiones.

Haga clic en los siguientes enlaces para ver sus detalles.
Declaración Descripción

Una if statement se compone de una

if statement expresión booleana seguida de una o más
sentencias.
Una if statement puede ser seguido por una
if...else statement opcional else statement , que se ejecuta
cuando la expresión booleana es falsa.
Puede utilizar uno if o else if la declaración
nested if statements
dentro de otro if o else if statement(s) .
 Un switch declaración permite una variable
switch statement a ser probado por la igualdad con una lista
de valores.
Puede utilizar uno switch declaración dentro
nested switch statements
de otro switch statement(s) .

Los ? : Operador:
Hemos cubierto conditional operator ? : conditional operator ? : En el
capítulo anterior que se puede utilizar para reemplazar if...else
declaraciones. Tiene la siguiente forma general:

Exp1 ? Exp2 : Exp3;

Donde Exp1, Exp2, y Exp3 son expresiones. Observe el uso y la colocación

del colon.
El valor de una? expresión se determina como sigue: se evalúa Exp1. Si
bien es cierto, entonces Exp2 se evalúa y se convierte en el valor de la
totalidad? expresión. Si Exp1 es falsa, entonces Exp3 se evalúa y su valor
se convierte en el

C# bucles
Puede haber una situación, cuando se necesita para ejecutar un bloque de
código varias veces. En general, las instrucciones se ejecutan
secuencialmente: La primera sentencia de una función se ejecuta en primer
lugar, seguido por el segundo, y así sucesivamente.
Los lenguajes de programación proporcionan diversas estructuras de
control que permiten rutas de ejecución más complicados.
Una sentencia de bucle nos permite ejecutar una instrucción o un grupo de
instrucciones varias veces y después se lo general de una declaración de
bucle en la mayoría de los lenguajes de programación:
C # proporciona siguientes tipos de bucle para manejar los requerimientos
de bucle. Haga clic en los siguientes enlaces para ver sus detalles.
Tipo de bucle Descripción

Se repite una declaración o un grupo de

instrucciones mientras una condición dada es
while loop
verdadera. Se prueba la condición antes de ejecutar
el cuerpo del bucle.
Se ejecuta una secuencia de instrucciones varias
for loop veces y abrevia el código que gestiona la variable de
bucle.
Es similar a un comunicado mientras que, excepto
do...while loop que se prueba la condición en el extremo del cuerpo
del bucle
Se puede utilizar uno o más de bucle dentro de
nested loops
cualquier otro tiempo, a favor o en do..while bucle.

Proposiciones de control Loop

sentencias de control de bucle cambian la ejecución de su secuencia
normal. Cuando la ejecución deja un ámbito, todos los objetos automáticos
que se crearon en ese ámbito se destruyen.
C # proporciona las siguientes sentencias de control. Haga clic en los
siguientes enlaces para ver sus detalles.
Declaración de
Descripción
control

Termina el loop o switch ejecución de

break statement instrucciones y las transferencias a la cuenta
inmediatamente después del ciclo o.
Hace que el bucle para saltar el resto de su cuerpo e
continue statement inmediatamente volver a probar su condición antes
de reiterar.

Bucle infinito
Un bucle se convierte en bucle infinito si una condición nunca se convierte
en falsa. El for bucle se utiliza tradicionalmente para este propósito.
Dado que ninguna de las tres expresiones que forman el bucle se requieren
para, usted puede hacer un bucle sin fin, dejando la expresión condicional
vacía.
Ejemplo
using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
for (; ; )
{
[Link]("Hey! I am Trapped");
}
}
}
}
Cuando la expresión condicional está ausente, se supone para ser verdad.
Es posible que tenga una inicialización y el incremento de expresión, pero
los programadores más comúnmente utilizar el for(;;) construir para
significar un bucle infinito.

C# La encapsulación
Encapsulation se define 'como el proceso de encerrar uno o más
artículos dentro de un paquete físico o lógico'. Encapsulación, en la
metodología de programación orientada a objetos, impide el acceso a los
detalles de implementación.
La abstracción y la encapsulación son características relacionadas en la
programación orientada a objetos. Abstracción permite hacer visible la
información relevante y la encapsulación permite a un programador para
implement the desired level of abstraction .
La encapsulación se implementa mediante access specifiers . Un access
specifier define el alcance y visibilidad de un miembro de la clase.
C # soporta los siguientes especificadores de acceso:

 Público
 Privado
 Protegido
 Interno
 interna protegida

Acceso Público a quien especifica

especificador de acceso público permite una clase para exponer sus
variables miembro y funciones miembro para otras funciones y objetos.
Cualquier miembro del público puede acceder desde fuera de la clase.
El siguiente ejemplo lo ilustra:

using System;
namespace RectangleApplication
{
class Rectangle
{
//member variables
public double length;
 public double width;

public double GetArea()

{
return length * width;
}
public void Display()
{
[Link]("Length: {0}", length);
[Link]("Width: {0}", width);
[Link]("Area: {0}", GetArea());
}
}//end class Rectangle

class ExecuteRectangle
{
static void Main(string[] args)
{
Rectangle r = new Rectangle();
[Link] = 4.5;
[Link] = 3.5;
[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Length: 4.5
Width: 3.5
Area: 15.75
En el ejemplo anterior, la longitud y anchura variables miembro son
declarados public , por lo que se puede acceder desde la función
Main() utilizando una instancia de la clase Rectángulo, llamado r .
La función miembro Display() y GetArea() también pueden acceder a estas
variables directamente sin utilizar cualquier instancia de la clase.
La funciones miembro Display() también se declara public , por lo que
también se puede acceder desde Main() usando una instancia de la
clase Rectángulo, llamado r .

Privada especificador de acceso

especificador de acceso privado permite una clase para ocultar sus
variables miembro y funciones miembro de otras funciones y objetos. Sólo
funciona de la misma clase pueden acceder a sus miembros privados.
Incluso una instancia de una clase no puede acceder a sus miembros
privados.
El siguiente ejemplo lo ilustra:

using System;
namespace RectangleApplication
{
class Rectangle
{
//member variables
private double length;
private double width;

public void Acceptdetails()

{
[Link]("Enter Length: ");
length = [Link]([Link]());
[Link]("Enter Width: ");
width = [Link]([Link]());
}
public double GetArea()
 {
return length * width;
}
public void Display()
{
[Link]("Length: {0}", length);
[Link]("Width: {0}", width);
[Link]("Area: {0}", GetArea());
}
}//end class Rectangle

class ExecuteRectangle
{
static void Main(string[] args)
{
Rectangle r = new Rectangle();
[Link]();
[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Enter Length:
4.4
Enter Width:
3.3
Length: 4.4
Width: 3.3
Area: 14.52
En el ejemplo anterior, la longitud y anchura variables miembro son
declarados private , por lo que no se puede acceder desde la función
Main() . Las funciones miembro AcceptDetails() y Display() pueden acceder
a estas variables. Dado que las funciones miembro AcceptDetails() y la
Display() se declaran public , que se puede acceder desde Main()
usando una instancia de la clase Rectángulo, llamado r .

Protected Access Especificador

Protegida especificador de acceso permite una clase secundaria para
acceder a las variables miembro y funciones miembro de la clase base. De
esta manera se ayuda en la ejecución de la herencia. Discutiremos esto con
más detalle en el capítulo de la herencia.

El especificador de acceso interno

especificador de acceso interno permite una clase para exponer sus
variables miembro y funciones miembro para otras funciones y objetos en
el conjunto actual. En otras palabras, cualquier miembro con especificador
de acceso interno se puede acceder desde cualquier clase o método
definido dentro de la aplicación en la que se define el miembro.
El programa siguiente ilustra esto:

using System;
namespace RectangleApplication
{
class Rectangle
{
//member variables
internal double length;
internal double width;

double GetArea()
{
return length * width;
}
public void Display()
 {
[Link]("Length: {0}", length);
[Link]("Width: {0}", width);
[Link]("Area: {0}", GetArea());
}
}//end class Rectangle

class ExecuteRectangle
{
static void Main(string[] args)
{
Rectangle r = new Rectangle();
[Link] = 4.5;
[Link] = 3.5;
[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Length: 4.5
Width: 3.5
Area: 15.75

En el ejemplo anterior, observe que la función miembro GetArea() no se

declara con cualquier especificador de acceso. Entonces ¿cuál sería el
especificador de acceso por defecto de un miembro de la clase si no se
menciona ninguna? Es private .

Protegida especificador de acceso interno

El especificador de acceso interno protegido permite una clase para ocultar
sus variables miembro y funciones miembro de la clase de otros objetos y
funciones, a excepción de una clase hija dentro de la misma aplicación.
Esto también se utiliza mientras se implementa la herencia.

C# métodos
Un método es un grupo de instrucciones que juntos realizan una tarea.
Cada programa en C # tiene al menos una clase con un método llamado
Principal.
Para utilizar un método, es necesario:

 Definir el método
 Llamar al método

Métodos de definición en C #
Cuando se define un método, se declara básicamente los elementos de su
estructura. La sintaxis para la definición de un método en C # es la
siguiente:

<Access Specifier> <Return Type> <Method Name>(Parameter List)

{
Method Body
}

A continuación se presentan los diferentes elementos de un método:

 Access Specifier : Determina la visibilidad de una variable o
un método de otra clase.
 Return type : Un método puede devolver un valor. El tipo de
retorno es el tipo de datos del valor el método devuelve. Si el método
no devuelve ningún valor, entonces el tipo de retorno es void .
 Method name : Nombre del método es un identificador único
y que es sensible a mayúsculas. No puede ser el mismo que
cualquier otro identificador declarado en la clase.
 Parameter list : cerrado entre paréntesis, los parámetros se
utiliza para pasar y recibir datos de un método. La lista de
parámetros se refiere al tipo, el orden y número de los parámetros de
un método. Los parámetros son opcionales; es decir, un método
puede contener ningún parámetro.
  Method body : Este contiene el conjunto de instrucciones
necesarias para completar la actividad requerida.

Ejemplo
Después de fragmento de código de muestra una función FindMax que
toma dos valores enteros y devuelve el mayor de los dos. Tiene
especificador de acceso público, por lo que se puede acceder desde fuera
de la clase utilizando una instancia de la clase.

class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* local variable declaration */
int result;

if (num1 > num2)

result = num1;
else
result = num2;

return result;
}
...
}

Llamar a los métodos en C #

Puede llamar a un método que utiliza el nombre del método. El siguiente
ejemplo lo ilustra:

using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* local variable declaration */
int result;

if (num1 > num2)

result = num1;
else
result = num2;
return result;
}
static void Main(string[] args)
{
/* local variable definition */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();

//calling the FindMax method

ret = [Link](a, b);
[Link]("Max value is : {0}", ret );
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Max value is : 200

También puede llamar al método público de otras clases utilizando la

instancia de la clase. Por ejemplo, el método FindMax pertenece a la
NumberManipulator clase, se le puede llamar de otra clase Test .

using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* local variable declaration */
int result;

if(num1 > num2)

result = num1;
else
result = num2;

return result;
}
}

class Test
{
static void Main(string[] args)
{
/* local variable definition */
int a = 100;
int b = 200;
int ret;
 NumberManipulator n = new NumberManipulator();

//calling the FindMax method

ret = [Link](a, b);
[Link]("Max value is : {0}", ret );
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Max value is : 200

Método de llamada recursiva

Un método puede llamarse a sí misma. Esto se conoce como recursion . A
continuación se presenta un ejemplo que calcula factorial para un número
dado usando una función recursiva:

using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int factorial(int num)
{
/* local variable declaration */
int result;
if (num == 1)
{
return 1;
}
 else
{
result = factorial(num - 1) * num;
return result;
}
}

static void Main(string[] args)

{
NumberManipulator n = new NumberManipulator();
//calling the factorial method
[Link]("Factorial of 6 is : {0}",
[Link](6));
[Link]("Factorial of 7 is : {0}",
[Link](7));
[Link]("Factorial of 8 is : {0}",
[Link](8));
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Factorial of 6 is: 720

Factorial of 7 is: 5040
Factorial of 8 is: 40320

Pasar parámetros a un método

Cuando se llama al método con parámetros, es necesario pasar los
parámetros al método. Hay tres formas en que los parámetros pueden ser
pasados a un método:
Mecanismo Descripción
 Este método copia el valor real de un argumento en
el parámetro formal de la función. En este caso, los
parámetros de valor
cambios realizados en el parámetro dentro de la
función no tienen efecto sobre el argumento.
Este método copia la referencia a la ubicación de la
parámetros de memoria de un argumento en el parámetro formal.
referencia Esto significa que los cambios realizados en el
parámetro afectan el argumento.
Los parámetros de
Este método ayuda a devolver más de un valor.
salida

C# nullables
C # proporciona un tipo de datos especiales, los nullable tipos, a los que
puede asignar rango normal de valores, así como los valores nulos.
Por ejemplo, puede almacenar cualquier valor de -2147483648 a
2147483647 o nulo en una variable anulable <Int32>. Del mismo modo,
puede asignar verdadero, falso o nulo en una variable anulable <bool>.
Sintaxis para declarar un nullable tipo es el siguiente:

< data_type> ? <variable_name> = null;

El siguiente ejemplo demuestra el uso de tipos de datos anulables:

using System;
namespace CalculatorApplication
{
class NullablesAtShow
{
static void Main(string[] args)
{
int? num1 = null;
int? num2 = 45;
double? num3 = new double?();
double? num4 = 3.14157;
 bool? boolval = new bool?();

// display the values

[Link]("Nullables at Show: {0}, {1}, {2},

{3}", num1, num2, num3, num4);
[Link]("A Nullable boolean value: {0}",
boolval);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Nullables at Show: , 45, , 3.14157

A Nullable boolean value:

El coalescente operador Null (??)

El operador coalescente nula se utiliza con los tipos de valor que aceptan
valores NULL y los tipos de referencia. Se utiliza para la conversión de un
operando del tipo de otro anulable (or not) operando tipo de valor, donde
una conversión implícita es posible.
Si el valor del primer operando es nulo, entonces el operador devuelve el
valor del segundo operando, de lo contrario, devuelve el valor del primer
operando. El siguiente ejemplo explica esto:

using System;
namespace CalculatorApplication
{
class NullablesAtShow
{
static void Main(string[] args)
 {
double? num1 = null;
double? num2 = 3.14157;
double num3;
num3 = num1 ?? 5.34;
[Link](" Value of num3: {0}", num3);
num3 = num2 ?? 5.34;
[Link](" Value of num3: {0}", num3);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Value of num3: 5.34

Value of num3: 3.14157

C# formación
Una matriz almacena una colección de tamaño fijo secuencial de elementos
del mismo tipo. Una matriz se utiliza para almacenar una colección de
datos, pero a menudo es más útil pensar en una matriz como una colección
de variables del mismo tipo almacenado en ubicaciones de memoria
contiguas.
En lugar de declarar las variables individuales, como Number0,
número1, ..., y number99, se declara una variable de matriz tales como
números y uso de los números [0], números [1], y, números ... [99] para
representar variables individuales. Un elemento específico en una matriz se
accede por un índice.
Todos los arreglos consisten en posiciones de memoria contiguas. La
dirección más baja corresponde al primer elemento y la dirección más alta
hasta el último elemento.
declarar arrays
Para declarar una matriz en C #, puede utilizar la siguiente sintaxis:

datatype[] arrayName;

dónde,
 d atatype se utiliza para especificar el tipo de elementos de la matriz.
 [ ] Especifica el rango de la matriz. El rango especifica el tamaño de
la matriz.
 arrayName especifica el nombre de la matriz.
Por ejemplo,

double[] balance;

La inicialización de una matriz

La declaración de una matriz no inicializa la matriz en la memoria. Cuando
se inicializa la variable de matriz, puede asignar valores a la matriz.
Matriz es un tipo de referencia, por lo que necesita para utilizar la new
palabra clave para crear una instancia de la matriz. Por ejemplo,

double[] balance = new double[10];

Asignación de valores a una matriz

Puede asignar valores a los elementos de la matriz, utilizando el número de
índice, como:

double[] balance = new double[10];

balance[0] = 4500.0;
Puede asignar valores a la matriz en el momento de la declaración, como se
muestra:

double[] balance = { 2340.0, 4523.69, 3421.0};

También puede crear e inicializar una matriz, como se muestra:

int [] marks = new int[5] { 99, 98, 92, 97, 95};

También puede omitir el tamaño de la matriz, como se muestra:

int [] marks = new int[] { 99, 98, 92, 97, 95};

Puede copiar una variable de matriz a otra variable de matriz de destino. En

tal caso, tanto el objetivo y la fuente de punto en la misma ubicación de
memoria:

int [] marks = new int[] { 99, 98, 92, 97, 95};

int[] score = marks;

Cuando se crea una matriz, compilador de C # inicializa implícitamente

cada elemento de la matriz en un valor predeterminado en función del tipo
de matriz. Por ejemplo, para una matriz int todos los elementos se
inicializan a 0.

Acceso a elementos de matriz

Un elemento se accede por la indexación del nombre de la matriz. Esto se
realiza colocando el índice del elemento entre corchetes después del
nombre de la matriz. Por ejemplo,

double salary = balance[9];

El siguiente ejemplo, demuestra la declaración mencionada conceptos,

misiones, y matrices de acceso:

using System;
namespace ArrayApplication
{
class MyArray
{
 static void Main(string[] args)
{
int [] n = new int[10]; /* n is an array of 10
integers */
int i,j;

/* initialize elements of array n */

for ( i = 0; i < 10; i++ )
{
n[ i ] = i + 100;
}

/* output each array element's value */

for (j = 0; j < 10; j++ )
{
[Link]("Element[{0}] = {1}", j, n[j]);
}
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

Utilizando el foreach bucle

En el ejemplo anterior, se utilizó un bucle for para acceder a cada elemento
de la matriz. También puede utilizar un foreach declaración a recorrer
una matriz.

using System;
namespace ArrayApplication
{
class MyArray
{
static void Main(string[] args)
{
int [] n = new int[10]; /* n is an array of 10
integers */

/* initialize elements of array n */

for ( int i = 0; i < 10; i++ )
{
n[i] = i + 100;
}

/* output each array element's value */

foreach (int j in n )
{
int i = j-100;
[Link]("Element[{0}] = {1}", i, j);
i++;
}
 [Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

Arrays de C #
Hay siguiendo algunos conceptos importantes relacionados con la matriz
que debe ser claro para un programador de C #:
Concepto Descripción

C # admite matrices multidimensionales. La forma

Matrices
más simple de la matriz multidimensional es la
multidimensionales
matriz de dos dimensiones.
C # soporta matrices multidimensionales, que son
matrices dentadas
matrices de matrices.

Pasar matrices a Puede pasar a la función de un puntero a una matriz

funciones especificando el nombre de la matriz sin un índice.
Esto se utiliza para el paso número desconocido de
matrices param
parámetros a una función.
La clase Array Definido en espacio de nombres System, es la clase
base para todas las matrices, y proporciona diversas
 propiedades y métodos para trabajar con arrays.

C# Instrumentos de cuerda
En C #, puede utilizar cadenas como un array de caracteres, sin embargo,
la práctica más común es el uso de la string de palabras clave para
declarar una variable de cadena. La palabra clave de cadena es un alias
para el [Link] clase.

Creación de un objeto de cadena

Puede crear objeto de cadena usando uno de los siguientes métodos:
 Mediante la asignación de una cadena literal a una variable String
 Mediante el uso de un constructor de clase String
 Al utilizar el operador de concatenación (+)
 Mediante la recuperación de una propiedad o llamar a un método que
devuelve una cadena
 Al llamar a un método para convertir el formato de un valor o un
objeto a su representación de cadena
El siguiente ejemplo demuestra esto:

using System;
namespace StringApplication
{
class Program
{
static void Main(string[] args)
{
//from string literal and string concatenation
string fname, lname;
fname = "Rowan";
lname = "Atkinson";

string fullname = fname + lname;

 [Link]("Full Name: {0}", fullname);

//by using string constructor

char[] letters = { 'H', 'e', 'l', 'l','o' };
string greetings = new string(letters);
[Link]("Greetings: {0}", greetings);

//methods returning string

string[] sarray = { "Hello", "From", "Tutorials",
"Point" };
string message = [Link](" ", sarray);
[Link]("Message: {0}", message);

//formatting method to convert a value

DateTime waiting = new DateTime(2012, 10, 10, 17, 58,
1);
string chat = [Link]("Message sent at {0:t} on
{0:D}", waiting);
[Link]("Message: {0}", chat);
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Full Name: Rowan Atkinson

Greetings: Hello
Message: Hello From Tutorials Point
Message: Message sent at 5:58 PM on Wednesday, October 10, 2012

Propiedades de la clase String

La clase String tiene las dos propiedades siguientes:
No
Seño Propiedad
r

Chars
1
Obtiene el Char objeto en una posición especificada en la corriente
String objeto.
Length
2
Obtiene el número de caracteres del objeto String actual.

Los métodos de la clase String

La clase String tiene numerosos métodos que ayudan en el trabajo con los
objetos de cadena. La siguiente tabla proporciona algunos de los métodos
más comúnmente utilizados:
No
Seño métodos
r

public static int Compare(string strA, string strB)

1
Compares two specified string objects and returns an integer that
indicates their relative position in the sort order.
public static int Compare(string strA, string strB, bool
ignoreCase )
2
Compares two specified string objects and returns an integer that
indicates their relative position in the sort order. However, it ignores
case if the Boolean parameter is true.
public static string Concat(string str0, string str1)
3
Concatenates two string objects.
public static string Concat(string str0, string str1, string str2)
4
Concatenates three string objects.
public static string Concat(string str0, string str1, string str2,
5 string str3)
Concatenates four string objects.
6 public bool Contains(string value)
 Returns a value indicating whether the specified String object occurs
within this string.
public static string Copy(string str)
7 Creates a new String object with the same value as the specified
string.
public void CopyTo(int sourceIndex, char[] destination, int
destinationIndex, int count)
8
Copies a specified number of characters from a specified position of
the String object to a specified position in an array of Unicode
characters.
public bool EndsWith(string value)
9 Determines whether the end of the string object matches the
specified string.
public bool Equals(string value)
10 Determines whether the current String object and the specified String
object have the same value.
public static bool Equals(string a, string b)
11 Determines whether two specified String objects have the same
value.
public static string Format(string format, Object arg0)
12 Replaces one or more format items in a specified string with the
string representation of a specified object.
public int IndexOf(char value)
13 Returns the zero-based index of the first occurrence of the specified
Unicode character in the current string.
public int IndexOf(string value)
14 Returns the zero-based index of the first occurrence of the specified
string in this instance.
public int IndexOf(char value, int startIndex)

15 Returns the zero-based index of the first occurrence of the specified

Unicode character in this string, starting search at the specified
character position.
16 public int IndexOf(string value, int startIndex)
Returns the zero-based index of the first occurrence of the specified
string in this instance, starting search at the specified character
 position.
public int IndexOfAny(char[] anyOf)
17 Returns the zero-based index of the first occurrence in this instance
of any character in a specified array of Unicode characters.
public int IndexOfAny(char[] anyOf, int startIndex)

18 Returns the zero-based index of the first occurrence in this instance

of any character in a specified array of Unicode characters, starting
search at the specified character position.
public string Insert(int startIndex, string value)
19 Returns a new string in which a specified string is inserted at a
specified index position in the current string object.
public static bool IsNullOrEmpty(string value)
20
Indicates whether the specified string is null or an Empty string.
public static string Join(string separator, params string[]
value)
21
Concatenates all the elements of a string array, using the specified
separator between each element.
public static string Join(string separator, string[] value, int
startIndex, int count)
22
Concatenates the specified elements of a string array, using the
specified separator between each element.
public int LastIndexOf(char value)
23 Returns the zero-based index position of the last occurrence of the
specified Unicode character within the current string object.
public int LastIndexOf(string value)
24 Returns the zero-based index position of the last occurrence of a
specified string within the current string object.
public string Remove(int startIndex)

25 Removes all the characters in the current instance, beginning at a

specified position and continuing through the last position, and
returns the string.
public string Remove(int startIndex, int count)
26 Removes the specified number of characters in the current string
beginning at a specified position and returns the string.
27 public string Replace(char oldChar, char newChar)
 Replaces all occurrences of a specified Unicode character in the
current string object with the specified Unicode character and returns
the new string.
public string Replace(string oldValue, string newValue)
28 Replaces all occurrences of a specified string in the current string
object with the specified string and returns the new string.
public string[] Split(params char[] separator)

29 Returns a string array that contains the substrings in the current

string object, delimited by elements of a specified Unicode character
array.
public string[] Split(char[] separator, int count)
Returns a string array that contains the substrings in the current
30 string object, delimited by elements of a specified Unicode character
array. The int parameter specifies the maximum number of
substrings to return.
public bool StartsWith(string value)
31 Determines whether the beginning of this string instance matches
the specified string.
public char[] ToCharArray()
32 Returns a Unicode character array with all the characters in the
current string object.
public char[] ToCharArray(int startIndex, int length)

33 Returns a Unicode character array with all the characters in the

current string object, starting from the specified index and up to the
specified length.
public string ToLower()
34
Returns a copy of this string converted to lowercase.
public string ToUpper()
35
Returns a copy of this string converted to uppercase.
public string Trim()
36 Removes all leading and trailing white-space characters from the
current String object.
Se puede visitar la biblioteca MSDN para la lista completa de métodos y
constructores de clase String.
Ejemplos
El siguiente ejemplo demuestra algunos de los métodos mencionados
anteriormente:
Comparing Strings:

using System;
namespace StringApplication
{
class StringProg
{
static void Main(string[] args)
{
string str1 = "This is test";
string str2 = "This is text";

if ([Link](str1, str2) == 0)
{
[Link](str1 + " and " + str2 + " are
equal.");
}
else
{
[Link](str1 + " and " + str2 + " are not
equal.");
}
[Link]() ;
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

This is test and This is text are not equal.

String Contains String:

using System;
namespace StringApplication
{
class StringProg
{
static void Main(string[] args)
{
string str = "This is test";
if ([Link]("test"))
{
[Link]("The sequence 'test' was found.");
}
[Link]() ;
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

The sequence 'test' was found.

Getting a Substring:

using System;
namespace StringApplication
{
class StringProg
{
static void Main(string[] args)
{
string str = "Last night I dreamt of San Pedro";
[Link](str);
 string substr = [Link](23);
[Link](substr);
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

San Pedro

Joining Strings:

using System;
namespace StringApplication
{
class StringProg
{
static void Main(string[] args)
{
string[] starray = new string[]{"Down the way nights
are dark",
"And the sun shines daily on the mountain top",
"I took a trip on a sailing ship",
"And when I reached Jamaica",
"I made a stop"};

string str = [Link]("\n", starray);

[Link](str);
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Down the way nights are dark

And the sun shines daily on the mountain top
I took a trip on a sailing ship
And when I reached Jamaica
I made a stop

C# estructuras
En C #, una estructura es un tipo de datos tipo de valor. Se le ayuda a
hacer un solo dato relacionado de mantenimiento variable de distintos tipos
de datos. La struct palabra clave se utiliza para la creación de una
estructura.
Las estructuras se utilizan para representar un registro. Suponga que desea
realizar un seguimiento de sus libros en una biblioteca. Es posible que
desee realizar un seguimiento de los following atributos acerca de cada
libro:

 Título
 Autor
 Tema
 Identificación libro

La definición de una estructura

Para definir una estructura, debe utilizar la instrucción estructura. La
declaración struct define un nuevo tipo de datos, con más de un miembro
de su programa.
Por ejemplo, esta es la forma en que se puede declarar la estructura del
libro:

struct Books
{
public string title;
public string author;
public string subject;
public int book_id;
};
El programa siguiente muestra el uso de la estructura:

using System;
struct Books
{
public string title;
public string author;
public string subject;
public int book_id;
};

public class testStructure

{
public static void Main(string[] args)
{

Books Book1; /* Declare Book1 of type Book */

Books Book2; /* Declare Book2 of type Book */

/* book 1 specification */
[Link] = "C Programming";
[Link] = "Nuha Ali";
[Link] = "C Programming Tutorial";
Book1.book_id = 6495407;

/* book 2 specification */
[Link] = "Telecom Billing";
[Link] = "Zara Ali";
[Link] = "Telecom Billing Tutorial";
Book2.book_id = 6495700;

/* print Book1 info */

 [Link]( "Book 1 title : {0}", [Link]);
[Link]("Book 1 author : {0}", [Link]);
[Link]("Book 1 subject : {0}", [Link]);
[Link]("Book 1 book_id :{0}", Book1.book_id);

/* print Book2 info */

[Link]("Book 2 title : {0}", [Link]);
[Link]("Book 2 author : {0}", [Link]);
[Link]("Book 2 subject : {0}", [Link]);
[Link]("Book 2 book_id : {0}", Book2.book_id);

[Link]();

}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Book 1 title : C Programming

Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Características de C # Estructuras
Ya ha utilizado una estructura simple denominada Libros. Estructuras en C
# son bastante diferente de la tradicional C o C ++. Las estructuras de C #
tienen las siguientes características:
  Las estructuras pueden tener métodos, campos, los indexadores,
propiedades, métodos y eventos operador.
 Las estructuras pueden tener constructores definidos, pero no
destructores. Sin embargo, no se puede definir un constructor por
defecto para una estructura. El constructor por defecto se define
automáticamente y no se puede cambiar.
 A diferencia de clases, estructuras no pueden heredar otras
estructuras o clases.
 Las estructuras no se pueden usar como base para otras estructuras
o clases.
 Una estructura puede implementar una o más interfaces.
 miembros de la estructura no se pueden especificar como abstracto,
virtual o protegido.
 Cuando se crea un objeto struct usando el New operador, que se
crea y el constructor adecuado se llama. A diferencia de clases,
estructuras se pueden crear instancias sin utilizar el nuevo operador.
 Si no se utiliza el operador New, los campos permanecen sin asignar
y el objeto no se pueden utilizar hasta que todos los campos se
inicializan.

Clase frente a la estructura

Las clases y estructuras tienen las siguientes diferencias básicas:
 las clases son los tipos de referencia y las estructuras son tipos de
valor
 estructuras no son compatibles con la herencia
 estructuras no pueden tener constructor por defecto
A la luz de las discusiones anteriores, vamos a reescribir el ejemplo
anterior:

using System;
struct Books
{
private string title;
private string author;
private string subject;
 private int book_id;
public void getValues(string t, string a, string s, int id)
{
title = t;
author = a;
subject = s;
book_id = id;
}
public void display()
{
[Link]("Title : {0}", title);
[Link]("Author : {0}", author);
[Link]("Subject : {0}", subject);
[Link]("Book_id :{0}", book_id);
}

};

public class testStructure

{
public static void Main(string[] args)
{

Books Book1 = new Books(); /* Declare Book1 of type Book

*/
Books Book2 = new Books(); /* Declare Book2 of type Book
*/

/* book 1 specification */
[Link]("C Programming",
"Nuha Ali", "C Programming Tutorial",6495407);
 /* book 2 specification */
[Link]("Telecom Billing",
"Zara Ali", "Telecom Billing Tutorial", 6495700);

/* print Book1 info */

[Link]();

/* print Book2 info */

[Link]();

[Link]();

}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Title : C Programming
Author : Nuha Ali
Subject : C Programming Tutorial
Book_id : 6495407
Title : Telecom Billing
Author : Zara Ali
Subject : Telecom Billing Tutorial
Book_id : 6495700

C# enumeraciones
Una enumeración es un conjunto de constantes enteras con nombre. Un
tipo enumerado se declara utilizando la enum de palabras clave.
C # enumeraciones son de tipo de datos de valor. En otras palabras, la
enumeración contiene sus propios valores y no puede heredar o no puede
pasar a la herencia.

La declaración de enum Variable

La sintaxis general para declarar una enumeración es:

enum <enum_name>
{
enumeration list
};

Dónde,
 El enum_name especifica el nombre del tipo de enumeración.
 La enumeration list es una lista separada por comas de
identificadores.
Cada uno de los símbolos en la lista enumeración representa un valor
entero, uno mayor que el símbolo que precede. Por defecto, el valor del
primer símbolo de enumeración es 0. Por ejemplo:

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

Ejemplo
El siguiente ejemplo demuestra el uso de la variable enum:

using System;
namespace EnumApplication
{
class EnumProgram
{
enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };
 static void Main(string[] args)
{
int WeekdayStart = (int)[Link];
int WeekdayEnd = (int)[Link];
[Link]("Monday: {0}", WeekdayStart);
[Link]("Friday: {0}", WeekdayEnd);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Monday: 1
Friday: 5

C# clases
Cuando se define una clase, se define un modelo para un tipo de datos.
Esto no define ningún dato, pero sí define lo que significa el nombre de la
clase. Es decir, lo que es un objeto de la clase consiste y qué operaciones
se pueden realizar en ese objeto. Los objetos son instancias de una clase.
Los métodos y las variables que constituyen una clase se denominan
miembros de la clase.

Definir una Clase

Una definición de la clase comienza con la palabra clave class seguido por
el nombre de la clase; y el cuerpo de la clase encerrado por un par de
llaves. A continuación se presenta la forma general de una definición de
clase:

<access specifier> class class_name

{
// member variables
 <access specifier> <data type> variable1;
<access specifier> <data type> variable2;
...
<access specifier> <data type> variableN;
// member methods
<access specifier> <return type> method1(parameter_list)
{
// method body
}
<access specifier> <return type> method2(parameter_list)
{
// method body
}
...
<access specifier> <return type> methodN(parameter_list)
{
// method body
}
}

Nota:
 especificadores de acceso especifican las reglas de acceso para los
miembros, así como la propia clase. Si no se menciona, entonces el
especificador de acceso predeterminado para un tipo de clase es
internal . De acceso predeterminado para los miembros es private .
 tipo de datos especifica el tipo de variable, y el tipo de retorno
especifica el tipo de datos de los datos el método devuelve, en su
caso.
 Para acceder a los miembros de la clase, se utiliza el punto (.) Del
operador.
 El operador punto vincula el nombre de un objeto con el nombre de
un miembro.
El siguiente ejemplo ilustra los conceptos discutidos hasta ahora:
using System;
namespace BoxApplication
{
class Box
{
public double length; // Length of a box
public double breadth; // Breadth of a box
public double height; // Height of a box
}
class Boxtester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
double volume = 0.0; // Store the volume of a box
here

// box 1 specification
[Link] = 5.0;
[Link] = 6.0;
[Link] = 7.0;

// box 2 specification
[Link] = 10.0;
[Link] = 12.0;
[Link] = 13.0;

// volume of box 1
volume = [Link] * [Link] * [Link];
[Link]("Volume of Box1 : {0}", volume);
 // volume of box 2
volume = [Link] * [Link] * [Link];
[Link]("Volume of Box2 : {0}", volume);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Volume of Box1 : 210

Volume of Box2 : 1560

Las funciones miembro y encapsulación

Una función miembro de una clase es una función que tiene su definición o
su prototipo dentro de la definición de clase similar a cualquier otra
variable. Está presente en cualquier objeto de la clase de la que es
miembro, y tiene acceso a todos los miembros de una clase de ese objeto.
Variables miembro son los atributos de un objeto (from design perspective)
y que se mantienen en privado para implementar la encapsulación. Estas
variables sólo se puede acceder usando las funciones miembro públicas.
Pongamos conceptos anteriores para establecer y obtener el valor de los
diferentes miembros de la clase en una clase:

using System;
namespace BoxApplication
{
class Box
{
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box
public void setLength( double len )
 {
length = len;
}

public void setBreadth( double bre )

{
breadth = bre;
}

public void setHeight( double hei )

{
height = hei;
}
public double getVolume()
{
return length * breadth * height;
}
}
class Boxtester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box();
double volume;

// Declare Box2 of type Box

// box 1 specification
[Link](6.0);
[Link](7.0);
[Link](5.0);
 // box 2 specification
[Link](12.0);
[Link](13.0);
[Link](10.0);

// volume of box 1
volume = [Link]();
[Link]("Volume of Box1 : {0}" ,volume);

// volume of box 2
volume = [Link]();
[Link]("Volume of Box2 : {0}", volume);

[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Volume of Box1 : 210

Volume of Box2 : 1560

C # constructores
Una clase constructor es una función miembro de una clase especial
que se ejecuta cada vez que se crea nuevos objetos de esa clase.
Un constructor tiene exactamente el mismo nombre que el de la clase y no
tiene ningún tipo de retorno. El siguiente ejemplo explica el concepto de
constructor:

using System;
namespace LineApplication
{
class Line
{
private double length; // Length of a line
public Line()
{
[Link]("Object is being created");
}

public void setLength( double len )

{
length = len;
}

public double getLength()

{
return length;
}

static void Main(string[] args)

{
Line line = new Line();

// set line length

[Link](6.0);
[Link]("Length of line : {0}",
[Link]());
[Link]();
}
}
}
Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Object is being created

Length of line : 6

Un default constructor no tiene ningún parámetro, pero si es

necesario, un constructor puede tener parámetros. Tales
constructores son llamados parameterized constructors . Esta técnica
ayuda a asignar valor inicial a un objeto en el momento de su creación,
como se muestra en el siguiente ejemplo:

using System;
namespace LineApplication
{
class Line
{
private double length; // Length of a line
public Line(double len) //Parameterized constructor
{
[Link]("Object is being created, length =
{0}", len);
length = len;
}

public void setLength( double len )

{
length = len;
}
public double getLength()
{
return length;
}

static void Main(string[] args)

{
 Line line = new Line(10.0);
[Link]("Length of line : {0}",
[Link]());

// set line length

[Link](6.0);
[Link]("Length of line : {0}",
[Link]());
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Object is being created, length = 10

Length of line : 10
Length of line : 6

Los destructores de C #
Un destructor es una función miembro especial de una clase que se
ejecuta cada vez que un objeto de su clase sale del ámbito. Un
destructor tiene exactamente el mismo nombre que el de la clase
con una tilde prefijado (~) y no las puede devolver un valor ni
puede tener ningún parámetro.
Destructor puede ser muy útil para liberar recursos de memoria antes de
salir del programa. Los destructores no pueden ser heredados o
sobrecargados.
El siguiente ejemplo explica el concepto de destructor:

using System;
namespace LineApplication
{
class Line
 {
private double length; // Length of a line
public Line() // constructor
{
[Link]("Object is being created");
}
~Line() //destructor
{
[Link]("Object is being deleted");
}

public void setLength( double len )

{
length = len;
}

public double getLength()

{
return length;
}

static void Main(string[] args)

{
Line line = new Line();

// set line length

[Link](6.0);
[Link]("Length of line : {0}",
[Link]());
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Object is being created

Length of line : 6
Object is being deleted

Los miembros estáticos de una clase C #

Podemos definir como miembros de la clase estática por medio de la static
de palabras clave. Cuando declaramos un miembro de una clase como
algo estático, significa que no importa cómo se crean muchos objetos de la
clase, sólo hay una copia del miembro estático.
La palabra clave static implica que existe sólo una instancia del
miembro de una clase. Las variables estáticas se utilizan para definir las
constantes debido a que sus valores se pueden recuperar mediante la
invocación de la clase sin crear una instancia de la misma. Las variables
estáticas se pueden inicializar fuera de la función de miembro o de
definición de clase. También puede inicializar variables estáticas dentro de
la definición de clase.
El siguiente ejemplo demuestra el uso de static variables :

using System;
namespace StaticVarApplication
{
class StaticVar
{
public static int num;
public void count()
{
num++;
}
public int getNum()
{
return num;
 }
}
class StaticTester
{
static void Main(string[] args)
{
StaticVar s1 = new StaticVar();
StaticVar s2 = new StaticVar();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]("Variable num for s1: {0}",
[Link]());
[Link]("Variable num for s2: {0}",
[Link]());
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Variable num for s1: 6

Variable num for s2: 6

También puede declarar una member function como static . Tales

funciones pueden acceder a las variables estáticas solamente. Existen las
funciones estáticas incluso antes de que se crea el objeto. El siguiente
ejemplo demuestra el uso de static functions :

using System;
namespace StaticVarApplication
{
class StaticVar
{
public static int num;
public void count()
{
num++;
}
public static int getNum()
{
return num;
}
}
class StaticTester
{
static void Main(string[] args)
{
StaticVar s = new StaticVar();
[Link]();
[Link]();
[Link]();
[Link]("Variable num: {0}",
[Link]());
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Variable num: 3
C# heredar
Uno de los conceptos más importantes de la programación orientada a
objetos es la herencia. La herencia nos permite definir una clase en
términos de otra clase, lo que hace que sea más fácil de crear y mantener
una aplicación. Esto también proporciona una oportunidad para volver a
utilizar la funcionalidad de código y acelera el tiempo de aplicación.
Al crear una clase, en lugar de escribir datos miembro y funciones miembro
completamente nuevo, el programador puede designar que la nueva clase
debe heredar los miembros de una clase existente. Esta clase existente se
llama la base la clase, y la nueva clase se conoce como el derived la
clase.
La idea de la herencia implementa el IS-A relación. Por ejemplo, mamífero
IS A animal, perro IS-A mamífero, por tanto, perro IS-A animal, así,
y así sucesivamente.

Base y clases derivadas

Una clase se puede derivar de más de una clase o interfaz, lo que significa
que puede heredar los datos y funciones de varios clases base o interfaces.
La sintaxis utilizada en C # para la creación de las clases derivadas es el
siguiente:

<acess-specifier> class <base_class>

{
...
}
class <derived_class> : <base_class>
{
...
}

Considere una Forma clase base y su rectángulo clase derivada:

using System;
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}

// Derived class
class Rectangle: Shape
{
public int getArea()
{
return (width * height);
}
}

class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();

[Link](5);
 [Link](7);

// Print the area of the object.

[Link]("Total area: {0}", [Link]());
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Total area: 35

Inicializando base de la Clase

La clase derivada hereda las variables miembro de la clase base y métodos
miembros. Por lo tanto el objeto de superclase debe crearse antes de crear
la subclase. Usted puede dar instrucciones para la inicialización superclase
en la lista de miembros de inicialización.
El programa siguiente muestra esto:

using System;
namespace RectangleApplication
{
class Rectangle
{
//member variables
protected double length;
protected double width;
public Rectangle(double l, double w)
{
length = l;
width = w;
}
 public double GetArea()
{
return length * width;
}

public void Display()

{
[Link]("Length: {0}", length);
[Link]("Width: {0}", width);
[Link]("Area: {0}", GetArea());
}
}//end class Rectangle

class Tabletop : Rectangle

{
private double cost;
public Tabletop(double l, double w) : base(l, w)
{ }
public double GetCost()
{
double cost;
cost = GetArea() * 70;
return cost;
}
public void Display()
{
[Link]();
[Link]("Cost: {0}", GetCost());
}
}
 class ExecuteRectangle
{
static void Main(string[] args)
{
Tabletop t = new Tabletop(4.5, 7.5);
[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Length: 4.5
Width: 7.5
Area: 33.75
Cost: 2362.5

La herencia múltiple en C #
C# does not support multiple inheritance . Sin embargo, puede utilizar
las interfaces para implementar la herencia múltiple. El programa siguiente
muestra esto:

using System;
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
 public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}

// Base class PaintCost

public interface PaintCost
{
int getCost(int area);

// Derived class
class Rectangle : Shape, PaintCost
{
public int getArea()
{
return (width * height);
}
public int getCost(int area)
{
return area * 70;
}
}
class RectangleTester
{
static void Main(string[] args)
{
 Rectangle Rect = new Rectangle();
int area;
[Link](5);
[Link](7);
area = [Link]();

// Print the area of the object.

[Link]("Total area: {0}", [Link]());
[Link]("Total paint cost: ${0}" ,
[Link](area));
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Total area: 35
Total paint cost: $2450

C# Polimorfismo
La palabra polymorphism significa tener muchas formas. En
paradigma de programación orientado a objetos, el polimorfismo se
expresa a menudo como "una interfaz, múltiples funciones.
El polimorfismo puede ser estática o dinámica. En static polymorphism ,
la respuesta a una función se determina en el tiempo de
compilación. En dynamic polymorphism , se decide en tiempo de
ejecución.

El polimorfismo estático
El mecanismo de vinculación de una función con un objeto durante el
tiempo de compilación se llama el primer enlace. También se conoce como
enlace estático. C # proporciona dos técnicas para implementar
polimorfismo estático. Son:

 la sobrecarga de funciones
 La sobrecarga de operadores

Discutimos la sobrecarga de operadores en el siguiente capítulo.

Sobrecarga de funciones
Puede tener varias definiciones para el mismo nombre de la función en el
mismo ámbito. La definición de la función debe diferenciarse entre sí por el
tipo y / o el número de argumentos en la lista de argumentos. No se puede
sobrecargar las declaraciones de funciones que se diferencian sólo por el
tipo de retorno.
El siguiente ejemplo muestra el uso de la función print() para imprimir
diferentes tipos de datos:

using System;
namespace PolymorphismApplication
{
class Printdata
{
void print(int i)
{
[Link]("Printing int: {0}", i );
}

void print(double f)
{
[Link]("Printing float: {0}" , f);
}

void print(string s)
{
[Link]("Printing string: {0}", s);
 }
static void Main(string[] args)
{
Printdata p = new Printdata();

// Call print to print integer

[Link](5);

// Call print to print float

[Link](500.263);

// Call print to print string

[Link]("Hello C++");
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Printing int: 5
Printing float: 500.263
Printing string: Hello C++

El polimorfismo dinámico
C # le permite crear clases abstractas que se utilizan para proporcionar
implementación de la clase parcial de una interfaz. Implementación se
completa cuando una clase derivada hereda de ella. Abstract clases
contienen métodos abstractos, que son implementadas por la clase
derivada. Las clases derivadas tienen una funcionalidad más
especializada.
Estas son las reglas sobre las clases abstractas:
 No se puede crear una instancia de una clase abstracta
  No se puede declarar un método abstracto fuera de una clase
abstracta
 Cuando se declara una clase sealed , que no puede ser
heredada, clases abstractas no pueden ser declarados
sellados.
El programa siguiente muestra una clase abstracta:

using System;
namespace PolymorphismApplication
{
abstract class Shape
{
public abstract int area();
}
class Rectangle: Shape
{
private int length;
private int width;
public Rectangle( int a=0, int b=0)
{
length = a;
width = b;
}
public override int area ()
{
[Link]("Rectangle class area :");
return (width * length);
}
}

class RectangleTester
{
static void Main(string[] args)
 {
Rectangle r = new Rectangle(10, 7);
double a = [Link]();
[Link]("Area: {0}",a);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Rectangle class area :

Area: 70

Cuando se tiene una función definida en una clase que desea implementar
en un heredada class(es) , que utilice virtual funciones. Las funciones
virtuales podrían ser implementadas de manera diferente en diferentes
clases heredadas y se decidirá la llamada a estas funciones en tiempo de
ejecución.
Polimorfismo dinámico se implementa abstract classes y virtual
functions .
El programa siguiente muestra esto:

using System;
namespace PolymorphismApplication
{
class Shape
{
protected int width, height;
public Shape( int a=0, int b=0)
{
width = a;
height = b;
}
public virtual int area()
 {
[Link]("Parent class area :");
return 0;
}
}
class Rectangle: Shape
{
public Rectangle( int a=0, int b=0): base(a, b)
{

}
public override int area ()
{
[Link]("Rectangle class area :");
return (width * height);
}
}
class Triangle: Shape
{
public Triangle(int a = 0, int b = 0): base(a, b)
{

}
public override int area()
{
[Link]("Triangle class area :");
return (width * height / 2);
}
}
class Caller
{
 public void CallArea(Shape sh)
{
int a;
a = [Link]();
[Link]("Area: {0}", a);
}
}
class Tester
{

static void Main(string[] args)

{
Caller c = new Caller();
Rectangle r = new Rectangle(10, 7);
Triangle t = new Triangle(10, 5);
[Link](r);
[Link](t);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Rectangle class area:

Area: 70
Triangle class area:
Area: 25

C# La sobrecarga de operadores
Puede redefinir o sobrecargar la mayor parte de los operadores internos
disponibles en C #. Así, un programador puede utilizar operadores con tipos
definidos por el usuario también. Operadores sobrecargados son funciones
especiales con nombres la palabra clave operator , seguido del símbolo
para el operador se está definiendo. similar a cualquier otra función, un
operador sobrecargado tiene un tipo de retorno y una lista de parámetros.
Por ejemplo, pasar por la función siguiente:

public static Box operator+ (Box b, Box c)

{
Box box = new Box();
[Link] = [Link] + [Link];
[Link] = [Link] + [Link];
[Link] = [Link] + [Link];
return box;
}

La función anterior implementa el operador de suma (+) para una caja de la

clase definida por el usuario. Añade los atributos de dos objetos de la caja y
devuelve el objeto caja resultante.

La aplicación de la sobrecarga de operadores

El programa siguiente muestra la implementación completa:

using System;
namespace OperatorOvlApplication
{
class Box
{
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box

public double getVolume()

{
 return length * breadth * height;
}

public void setLength( double len )

{
length = len;
}

public void setBreadth( double bre )

{
breadth = bre;
}

public void setHeight( double hei )

{
height = hei;
}

// Overload + operator to add two Box objects.

public static Box operator+ (Box b, Box c)
{
Box box = new Box();
[Link] = [Link] + [Link];
[Link] = [Link] + [Link];
[Link] = [Link] + [Link];
return box;
}

class Tester
 {
static void Main(string[] args)
{
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
Box Box3 = new Box(); // Declare Box3 of type Box
double volume = 0.0; // Store the volume of a box
here

// box 1 specification
[Link](6.0);
[Link](7.0);
[Link](5.0);

// box 2 specification
[Link](12.0);
[Link](13.0);
[Link](10.0);

// volume of box 1
volume = [Link]();
[Link]("Volume of Box1 : {0}", volume);

// volume of box 2
volume = [Link]();
[Link]("Volume of Box2 : {0}", volume);

// Add two object as follows:

Box3 = Box1 + Box2;

// volume of box 3
 volume = [Link]();
[Link]("Volume of Box3 : {0}", volume);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Volume of Box1 : 210

Volume of Box2 : 1560
Volume of Box3 : 5400

Los operadores sobrecargable y no sobrecargable

La siguiente tabla describe la capacidad de sobrecarga de los operadores
en C #:
operadores Descripción

Estos operadores unitarios toman un operando y se

+, -, !, ~, ++, --
pueden sobrecargar.

Estos operadores binarios tienen un operando y se

+, -, *, /, %
pueden sobrecargar.

==, !=, <, >, <=,

Los operadores de comparación se pueden sobrecargar
>=

Los operadores lógicos condicionales no pueden ser

&&, ||
sobrecargados directamente.

+=, -=, *=, /=,

Los operadores de asignación no se pueden sobrecargar.
%=

=, ., ?:, ->, new, is,

Estos operadores no pueden ser sobrecargados.
sizeof, typeof
Ejemplo
A la luz de las discusiones anteriores, vamos a ampliar el ejemplo anterior,
y la sobrecarga de unos cuantos operadores:

using System;
namespace OperatorOvlApplication
{
class Box
{
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box

public double getVolume()

{
return length * breadth * height;
}

public void setLength( double len )

{
length = len;
}

public void setBreadth( double bre )

{
breadth = bre;
}

public void setHeight( double hei )

{
height = hei;
 }

// Overload + operator to add two Box objects.

public static Box operator+ (Box b, Box c)
{
Box box = new Box();
[Link] = [Link] + [Link];
[Link] = [Link] + [Link];
[Link] = [Link] + [Link];
return box;
}

public static bool operator == (Box lhs, Box rhs)

{
bool status = false;
if ([Link] == [Link] && [Link] ==
[Link] && [Link] == [Link])
{
status = true;
}
return status;
}

public static bool operator !=(Box lhs, Box rhs)

{
bool status = false;
if ([Link] != [Link] || [Link] !=
[Link] || [Link] != [Link])
{
status = true;
}
 return status;
}

public static bool operator <(Box lhs, Box rhs)

{
bool status = false;
if ([Link] < [Link] && [Link] < [Link]
&& [Link] < [Link])
{
status = true;
}
return status;
}

public static bool operator >(Box lhs, Box rhs)

{
bool status = false;
if ([Link] > [Link] && [Link] > [Link]
&& [Link] > [Link])
{
status = true;
}
return status;
}

public static bool operator <=(Box lhs, Box rhs)

{
bool status = false;
if ([Link] <= [Link] && [Link] <=
[Link] && [Link] <= [Link])
{
status = true;
 }
return status;
}

public static bool operator >=(Box lhs, Box rhs)

{
bool status = false;
if ([Link] >= [Link] && [Link] >=
[Link] && [Link] >= [Link])
{
status = true;
}
return status;
}
public override string ToString()
{
return [Link]("({0}, {1}, {2})", length,
breadth, height);
}
}

class Tester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
Box Box3 = new Box(); // Declare Box3 of type Box
Box Box4 = new Box();
double volume = 0.0; // Store the volume of a box
here
// box 1 specification
[Link](6.0);
[Link](7.0);
[Link](5.0);

// box 2 specification
[Link](12.0);
[Link](13.0);
[Link](10.0);

//displaying the Boxes using the overloaded ToString():

[Link]("Box 1: {0}", [Link]());
[Link]("Box 2: {0}", [Link]());

// volume of box 1
volume = [Link]();
[Link]("Volume of Box1 : {0}", volume);

// volume of box 2
volume = [Link]();
[Link]("Volume of Box2 : {0}", volume);

// Add two object as follows:

Box3 = Box1 + Box2;
[Link]("Box 3: {0}", [Link]());

// volume of box 3
volume = [Link]();
[Link]("Volume of Box3 : {0}", volume);

//comparing the boxes

 if (Box1 > Box2)
[Link]("Box1 is greater than Box2");
else
[Link]("Box1 is greater than Box2");

if (Box1 < Box2)

[Link]("Box1 is less than Box2");
else
[Link]("Box1 is not less than Box2");

if (Box1 >= Box2)

[Link]("Box1 is greater or equal to
Box2");
else
[Link]("Box1 is not greater or equal to
Box2");

if (Box1 <= Box2)

[Link]("Box1 is less or equal to Box2");
else
[Link]("Box1 is not less or equal to
Box2");

if (Box1 != Box2)
[Link]("Box1 is not equal to Box2");
else
[Link]("Box1 is not greater or equal to
Box2");
Box4 = Box3;

if (Box3 == Box4)
[Link]("Box3 is equal to Box4");
 else
[Link]("Box3 is not equal to Box4");

[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Box 1: (6, 7, 5)
Box 2: (12, 13, 10)
Volume of Box1 : 210
Volume of Box2 : 1560
Box 3: (18, 20, 15)
Volume of Box3 : 5400
Box1 is not greater than Box2
Box1 is less than Box2
Box1 is not greater or equal to Box2
Box1 is less or equal to Box2
Box1 is not equal to Box2
Box3 is equal to Box4

C# Interfaces
Una interfaz se define como un contrato sintáctica que todas las clases que
heredan de la interfaz deben seguir. La interfaz define el 'what' parte del
contrato sintáctico y las clases derivadas a definir el 'how' parte
del contrato sintáctica.
Interfaces definen propiedades, métodos y eventos, que son los miembros
de la interfaz. Las interfaces sólo contienen la declaración de los miembros.
Es responsabilidad de la clase derivada de definir los miembros. A menudo
ayuda a proporcionar una estructura estándar que seguirían las clases
derivadas.
Las clases abstractas en cierta medida tienen el mismo propósito, sin
embargo, que se utilizan sobre todo cuando sólo unos pocos métodos han
de ser declarada por la clase base y la clase derivada implementa las
funcionalidades.

La declaración de Interfaces
Las interfaces se declaran usando la palabra clave interface. Es similar a la
declaración de la clase. declaraciones de interfaz son públicos por defecto.
A continuación se presenta un ejemplo de una declaración de interfaz:

public interface ITransactions

{
// interface members
void showTransaction();
double getAmount();
}

Ejemplo
El siguiente ejemplo muestra la implementación de la interfaz anterior:

using [Link];
using [Link];
using [Link];
using System;

namespace InterfaceApplication
{
public interface ITransactions
{
// interface members
void showTransaction();
double getAmount();
}

public class Transaction : ITransactions

{
private string tCode;
private string date;
private double amount;
public Transaction()
{
tCode = " ";
date = " ";
amount = 0.0;
}

public Transaction(string c, string d, double a)

{
tCode = c;
date = d;
amount = a;
}

public double getAmount()

{
return amount;
}

public void showTransaction()

{
[Link]("Transaction: {0}", tCode);
[Link]("Date: {0}", date);
[Link]("Amount: {0}", getAmount());
 }
}
class Tester
{
static void Main(string[] args)
{
Transaction t1 = new Transaction("001", "8/10/2012",
78900.00);
Transaction t2 = new Transaction("002", "9/10/2012",
451900.00);
[Link]();
[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Transaction: 001
Date: 8/10/2012
Amount: 78900
Transaction: 002
Date: 9/10/2012
Amount: 451900

C# Los espacios de nombres

Un namespace está diseñado para proporcionar una manera de
mantener un conjunto de nombres separado de otro. Los nombres de
las clases declaradas en un espacio de nombres no entra en conflicto con
los mismos nombres de las clases declaradas en otro.
La definición de un espacio de nombres
Una definición de espacio de nombres comienza con la palabra clave
namespace seguido del nombre de espacio de nombres de la
siguiente manera:

namespace namespace_name
{
// code declarations
}

Para llamar a la versión de espacio de nombres habilitada de cualquiera

función o variable, anteponer el nombre del espacio de nombres de la
siguiente manera:

namespace_name.item_name;

El programa siguiente muestra el uso de espacios de nombres:

using System;
namespace first_space
{
class namespace_cl
{
public void func()
{
[Link]("Inside first_space");
}
}
}

namespace second_space
{
class namespace_cl
{
public void func()
{
 [Link]("Inside second_space");
}
}
}

class TestClass
{
static void Main(string[] args)
{
first_space.namespace_cl fc = new
first_space.namespace_cl();
second_space.namespace_cl sc = new
second_space.namespace_cl();
[Link]();
[Link]();
[Link]();
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Inside first_space
Inside second_space

El using palabras clave

El using la palabra clave indica que el programa está utilizando los
nombres en el espacio de nombres dado. Por ejemplo, estamos
utilizando el System espacio de nombres en nuestros programas. La
consola de clase se define allí. Sólo escribimos:

[Link] ("Hello there");

Podríamos haber escrito el nombre completo como:

[Link]("Hello there");
También puede evitar prepending de espacios de nombres con el using la
directiva espacio de nombres. Esta directiva indica al compilador que el
código subsiguiente está haciendo uso de nombres en el espacio de
nombres especificado. El espacio de nombres es por lo tanto implicaba para
el código siguiente:
Vamos a reescribir nuestro ejemplo anterior, la directiva using:

using System;
using first_space;
using second_space;

namespace first_space
{
class abc
{
public void func()
{
[Link]("Inside first_space");
}
}
}

namespace second_space
{
class efg
{
public void func()
{
[Link]("Inside second_space");
}
}
}
class TestClass
{
static void Main(string[] args)
{
abc fc = new abc();
efg sc = new efg();
[Link]();
[Link]();
[Link]();
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Inside first_space
Inside second_space

Los espacios de nombres anidados

Se puede definir un espacio de nombres dentro de otro espacio de nombres
de la siguiente manera:

namespace namespace_name1
{
// code declarations
namespace namespace_name2
{
// code declarations
}
}

Se puede acceder a los miembros del espacio de nombres anidados

utilizando el punto (.) Operador de la siguiente manera:
using System;
using first_space;
using first_space.second_space;

namespace first_space
{
class abc
{
public void func()
{
[Link]("Inside first_space");
}
}
namespace second_space
{
class efg
{
public void func()
{
[Link]("Inside second_space");
}
}
}
}

class TestClass
{
static void Main(string[] args)
{
abc fc = new abc();
efg sc = new efg();
 [Link]();
[Link]();
[Link]();
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Inside first_space
Inside second_space

C# directivas del preprocesador

Las directivas del preprocesador dan instrucciones al compilador para
preprocesar la información antes de que comience la compilación real.
Todas las directivas del preprocesador comienzan con #, y sólo los
caracteres de espacio en blanco pueden aparecer antes de una directiva de
preprocesador en una línea. Directivas del preprocesador no son
declaraciones, por lo que no terminan con un punto y coma (;) .
Compilador de C # no tiene un preprocesador separada; sin embargo, las
directivas se procesan como si había uno. En C # las directivas del
preprocesador se utilizan para ayudar en la compilación condicional. A
diferencia de C ++ y directivas C, no se utilizan para crear macros. Una
directiva de preprocesador debe ser la única instrucción en una línea.

Directivas del preprocesador en C #

La siguiente tabla muestra las directivas del preprocesador disponibles en C
#:
Directiva del
preprocesado Descripción.
r

#define Se define una secuencia de caracteres, llamado símbolo.

#undef Le permite quitar la definición de un símbolo.

#if Permite probar un símbolo o símbolos para ver si dan como

 resultado true.

Permite crear una directiva condicional compuesto, junto

#else
con #if.

#elif Permite crear una directiva condicional compuesto.

#endif Especifica el final de una directiva condicional.

Se permite modificar el número de línea del compilador y

#line (optionally) la salida de nombre de archivo para los errores
y advertencias.

Permite generar un error desde una ubicación específica en

#error
el código.

Permite generar un nivel de una advertencia desde una

#warning
ubicación específica en el código.

Se le permite especificar un bloque de código que se puede

#region expandir o contraer al usar la función delineando del editor
de código de Visual Studio.

#endregion Que marca el final de un bloque #region.

El preprocesador #define
La directiva #define preprocesador crea constantes simbólicas.
#define permite definir un símbolo de tal manera que, mediante el uso del
símbolo como la expresión pasada a la directiva #if, la expresión se evalúa
como verdadera. Su sintaxis es la siguiente:

#define symbol

El programa siguiente ilustra esto:

#define PI
using System;
namespace PreprocessorDAppl
{
 class Program
{
static void Main(string[] args)
{
#if (PI)
[Link]("PI is defined");
#else
[Link]("PI is not defined");
#endif
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

PI is defined

Directivas condicionales
Puede usar la directiva #if para crear una directiva condicional. directivas
condicionales son útiles para probar un símbolo o símbolos para comprobar
si como resultado true. Si no lo hacen como resultado true, el compilador
evalúa todo el código entre el #if y la siguiente directiva.
Sintaxis para la directiva condicional es:

#if symbol [operator symbol]...

Cuando, symbol es el nombre del símbolo que desea probar. También

puede utilizar verdadero y falso o anteponer el símbolo con el operador de
negación.
El operator symbol es el operador que se utiliza para evaluar el símbolo. Los
operadores podrían ser cualquiera de los siguientes:

 == (equality)
 ! = (inequality)
 && (and)
  || (or)

También puede agrupar símbolos y operadores con paréntesis. directivas

condicionales se utilizan para compilar código para una versión de
depuración o cuando se compila para una configuración específica. Una
directiva condicional a partir de un #if Directiva explícitamente se debe
terminar con un #endif Directiva.
El programa siguiente muestra el uso de directivas condicionales:

#define DEBUG
#define VC_V10
using System;
public class TestClass
{
public static void Main()
{
#if (DEBUG && !VC_V10)
[Link]("DEBUG is defined");
#elif (!DEBUG && VC_V10)
[Link]("VC_V10 is defined");
#elif (DEBUG && VC_V10)
[Link]("DEBUG and VC_V10 are defined");
#else
[Link]("DEBUG and VC_V10 are not defined");
#endif
[Link]();
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

DEBUG and VC_V10 are defined

C# Expresiones regulares
Una regular expression es un patrón que podría ser igualada en
contra de un texto de entrada. El marco .NET proporciona un motor de
expresión regular que permite tal juego. Un patrón consta de literales uno o
más caracteres, operadores, o construcciones.

Las construcciones para definir expresiones regulares

Hay varias categorías de personajes, operadores y construcciones que le
permite definir expresiones regulares. Haga clic en los enlaces follwoing
para encontrar estas construcciones.
 escapes de caracteres
 Las clases de caracteres
 anclas
 La agrupación de construcciones
 cuantificadores
 construcciones de elementos detectados
 construcciones de alternancia
 sustituciones
 Varios construcciones

La clase Regex
La clase Regex se utiliza para representar una expresión regular. Tiene las
siguientes métodos comúnmente utilizados:
No
Seño métodos
r

public bool IsMatch(string input)

1
Indicates whether the regular expression specified in the Regex
constructor finds a match in a specified input string.
public bool IsMatch(string input, int startat)

2 Indicates whether the regular expression specified in the Regex

constructor finds a match in the specified input string, beginning at
the specified starting position in the string.
3 public static bool IsMatch(string input, string pattern)
 Indicates whether the specified regular expression finds a match in
the specified input string.
public MatchCollection Matches(string input)
4 Searches the specified input string for all occurrences of a regular
expression.
public string Replace(string input, string replacement)
5 In a specified input string, replaces all strings that match a regular
expression pattern with a specified replacement string.
public string[] Split(string input)

6 Splits an input string into an array of substrings at the positions

defined by a regular expression pattern specified in the Regex
constructor.
Para una lista completa de métodos y propiedades, por favor lea la
documentación de Microsoft en C #.

Ejemplo 1
El siguiente ejemplo coincide con las palabras que empiezan con 'S':

using System;
using [Link];

namespace RegExApplication
{
class Program
{
private static void showMatch(string text, string expr)
{
[Link]("The Expression: " + expr);
MatchCollection mc = [Link](text, expr);
foreach (Match m in mc)
{
[Link](m);
 }
}

static void Main(string[] args)

{
string str = "A Thousand Splendid Suns";

[Link]("Matching words that start with 'S':

");
showMatch(str, @"\bS\S*");
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Matching words that start with 'S':

The Expression: \bS\S*
Splendid
Suns

Ejemplo 2
El siguiente ejemplo coincide con las palabras que empiezan con 'm' y
termina con 'e':

using System;
using [Link];

namespace RegExApplication
{
class Program
 {
private static void showMatch(string text, string expr)
{
[Link]("The Expression: " + expr);
MatchCollection mc = [Link](text, expr);
foreach (Match m in mc)
{
[Link](m);
}
}
static void Main(string[] args)
{
string str = "make maze and manage to measure it";

[Link]("Matching words start with 'm' and

ends with 'e':");
showMatch(str, @"\bm\S*e\b");
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Matching words start with 'm' and ends with 'e':

The Expression: \bm\S*e\b
make
maze
manage
measure
Ejemplo 3
En este ejemplo se sustituye espacio en blanco adicional:

using System;
using [Link];

namespace RegExApplication
{
class Program
{
static void Main(string[] args)
{
string input = "Hello World ";
string pattern = "\\s+";
string replacement = " ";
Regex rgx = new Regex(pattern);
string result = [Link](input, replacement);

[Link]("Original String: {0}", input);

[Link]("Replacement String: {0}", result);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Original String: Hello World

Replacement String: Hello World

C# Manejo de excepciones
Una excepción es un problema que se presenta durante la ejecución de un
programa. AC # excepción es una respuesta a una circunstancia
excepcional que se produce mientras se ejecuta un programa, como un
intento de dividir por cero.
Excepciones proporcionan una manera de transferir el control de una parte
de un programa a otro. C # manipulación de excepción se basa en cuatro
palabras clave: try , catch , finally , y throw .
 try : Un bloque try identifica un bloque de código para la que
se activa excepciones particulares. Es seguido por uno o más
bloques catch.
 catch : Un programa detecta una excepción con un
controlador de excepciones en el lugar en un programa en el
que desea manejar el problema. La palabra clave de captura
indica la captura de una excepción.
 finally : El bloque finally se utiliza para ejecutar un
determinado conjunto de declaraciones, si se produce una
excepción o sin torcer. Por ejemplo, si abre un archivo, tiene que
ser cerrado si se produce una excepción o no.
 throw : Un programa emite una excepción cuando un
problema aparece. Esto se hace usando una palabra clave tiro.

Sintaxis
Suponiendo un bloque genera una excepción, un método detecta una
excepción utilizando una combinación de las palabras clave try y catch. Un
bloque try / catch se coloca alrededor del código que podría generar una
excepción. Código dentro de un bloque try / catch se conoce como código
protegido, y la sintaxis para usar try / catch tiene el siguiente aspecto:

try
{
// statements causing exception
}
catch( ExceptionName e1 )
{
// error handling code
}
catch( ExceptionName e2 )
{
// error handling code
}
catch( ExceptionName eN )
{
// error handling code
}
finally
{
// statements to be executed
}

Puede enumerar abajo varias instrucciones catch para capturar diferentes

tipos de excepciones en el caso de que su bloque try plantea más de una
excepción en diferentes situaciones.

Las clases de excepciones en C #

C # excepciones están representados por las clases. Las clases de
excepciones en C # son principalmente derivan directa o indirectamente de
la [Link] clase. Algunas de las clases de excepción derivados
de la clase [Link] son los [Link] y
[Link] clases.
El [Link] clase admite excepciones
generadas por los programas de aplicación. De ahí que las
excepciones definidas por los programadores deben derivar de esta clase.
El [Link] clase es la clase base para todos
excepción del sistema predefinido.
La siguiente tabla proporciona algunos de los clases de excepción
predefinidos derivados de la clase [Link]:
Clase excepción Descripción

[Link] Maneja errores de E / S.

Controla los errores generados cuando

[Link] un método se refiere a un índice de
matriz fuera de rango.

[Link] Maneja los errores generados cuando

n el tipo no coincide con el tipo de
 matriz.

Controla los errores generados a partir

[Link]
de deferencing un objeto nulo.

Controla los errores generados a partir

[Link] de la división de un dividendo por
cero.

Maneja los errores generados durante

[Link]
el encasillamiento.

Controla los errores generados a partir

[Link]
de insuficiente memoria libre.

Maneja los errores generados a partir

[Link]
de desbordamiento de pila.

Manejo de excepciones
C # ofrece una solución estructurada para el manejo de excepciones en
forma de bloques try y catch. El uso de estos bloques de los estados del
programa básico se separan de los estados de control de errores.
Estos bloques de tratamiento de errores se implementan utilizando la try ,
catch , y finally palabras clave. Lo que sigue es un ejemplo de lanzar
una excepción cuando se divide por la condición cero ocurre:

using System;
namespace ErrorHandlingApplication
{
class DivNumbers
{
int result;
DivNumbers()
{
result = 0;
}
 public void division(int num1, int num2)
{
try
{
result = num1 / num2;
}
catch (DivideByZeroException e)
{
[Link]("Exception caught: {0}", e);
}
finally
{
.WriteLine("Result: {0}", result);
}
}
static void Main(string[] args)
{
DivNumbers d = new DivNumbers();
[Link](25, 0);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Exception caught: [Link]: Attempted to

divide by zero.
at ...
Result: 0
La creación de excepciones definidas por el usuario
También puede definir su propia excepción. Clases de excepciones
definidas por el usuario se derivan de la Exception clase. El siguiente
ejemplo demuestra esto:

using System;
namespace UserDefinedException
{
class TestTemperature
{
static void Main(string[] args)
{
Temperature temp = new Temperature();
try
{
[Link]();
}
catch(TempIsZeroException e)
{
[Link]("TempIsZeroException: {0}",
[Link]);
}
[Link]();
}
}
}

public class TempIsZeroException: Exception

{
public TempIsZeroException(string message): base(message)
{
}
}
public class Temperature
{
int temperature = 0;
public void showTemp()
{
if(temperature == 0)
{
throw (new TempIsZeroException("Zero Temperature
found"));
}
else
{
[Link]("Temperature: {0}", temperature);
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

TempIsZeroException: Zero Temperature found

Lanzar objetos
Usted puede lanzar un objeto si se deriva directa o indirectamente de la
[Link] clase. Puede utilizar una instrucción throw en el
bloque catch para lanzar el presente objeto como:

Catch(Exception e)
{
...
Throw e
}
C# Puedo presentar de E / S
Un file es una colección de datos almacenados en un disco con un
nombre específico y una ruta de directorio. Cuando se abre un archivo
para lectura o escritura, se convierte en una stream .
La corriente es, básicamente, la secuencia de bytes que pasan a través de
la ruta de comunicación. Existen dos corrientes principales: el input
stream y el output stream . El input stream se utiliza para leer
datos de archivo (read operation) y el output stream se utiliza para
escribir en el archivo (write operation) .

Clases C # E / S
El espacio de nombres [Link] tiene diferentes clases que se utilizan
para realizar numerosas operaciones con archivos, tales como crear y
borrar archivos, leer o escribir en un archivo, cerrar un archivo, etc.
La siguiente tabla muestra algunas clases no abstractos de uso común en el
espacio de nombres [Link]:
I / O Clase Descripción

BinaryReader Lee datos primitivos de un flujo binario.

BinaryWriter Escribe los datos primitivos en formato binario.

BufferedStream Un almacenamiento temporal para un flujo de bytes.

Ayuda en la manipulación de una estructura de

Directory
directorios.

DirectoryInfo Se utiliza para realizar operaciones en directorios.

DriveInfo Proporciona información a las unidades.

File Ayuda en la manipulación de archivos.

FileInfo Se utiliza para realizar operaciones en los ficheros.

Se utiliza para leer y escribir en cualquier lugar en un

FileStream
archivo.
 Se utiliza para el acceso aleatorio a los datos
MemoryStream
transmitidos almacenados en la memoria.

Path Realiza operaciones de información de la ruta.

Se utiliza para la lectura de caracteres de una secuencia

StreamReader
de bytes.

StreamWriter Se utiliza para la escritura de caracteres a un arroyo.

StringReader Se utiliza para la lectura de un búfer de cadena.

StringWriter Se utiliza para escribir en un búfer de cadena.

La clase FileStream
El FileStream clase en el espacio de nombres [Link] ayuda en la
lectura de, la escritura y el cierre de archivos. Esta clase se deriva de
la Corriente clase abstracta.
Es necesario crear un FileStream objeto para crear un nuevo archivo
o abrir un archivo existente. La sintaxis para crear un FileStream
objeto es la siguiente:

FileStream <object_name> = new FileStream( <file_name>,

<FileMode Enumerator>, <FileAccess Enumerator>, <FileShare
Enumerator>);

Por ejemplo, creamos un objeto FileStream F para leer un archivo

llamado [Link] as shown :

FileStream F = new FileStream("[Link]", [Link],

[Link], [Link]);

Parámetro Descripción

FileMode El FileMode empadronador define varios métodos

para la apertura de los archivos. Los miembros del
empadronador FileMode son:
 Append : Se abre un archivo existente y pone el
cursor al final del archivo, o crea el archivo, si
no existe el archivo.
  Create : Se crea un nuevo archivo.
 CreateNew : Se especifica en el sistema
operativo, que debe crear un nuevo archivo.
 Open : Abre un archivo existente.
 OpenOrCreate : Se especifica que el sistema
operativo que se debe abrir un archivo, si
existe, de lo contrario, debe crear un nuevo
archivo.
 Truncate : Se abre un archivo existente y trunca
su tamaño a cero bytes.
FileAccess encuestadores tienen miembros: Read ,
FileAccess
ReadWrite y Write .
FileShare encuestadores tienen los siguientes
miembros:
 Inheritable : Permite un identificador de archivo
para pasar la herencia de los procesos
secundarios
FileShare  None : Declina el intercambio del archivo actual
 Read : Permite abrir el archivo para lectura
 ReadWrite : Permite abrir el archivo para
lectura y escritura
 Write : Permite abrir el archivo para escritura

Ejemplo
El programa siguiente muestra el uso de FileStream clase:

using System;
using [Link];

namespace FileIOApplication
{
class Program
{
static void Main(string[] args)
 {
FileStream F = new FileStream("[Link]",
[Link], [Link]);
for (int i = 1; i <= 20; i++)
{
[Link]((byte)i);
}

[Link] = 0;
for (int i = 0; i <= 20; i++)
{
[Link]([Link]() + " ");
}
[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 -1

Operaciones con archivos avanzados en C #

El ejemplo anterior proporciona operaciones de archivo simples en C #. Sin
embargo, para utilizar los inmensos poderes de las clases C # [Link],
es necesario conocer las propiedades y métodos de estas clases de uso
común.
Tema y Descripción

Leer y escribir en archivos de texto

Se trata de leer y escribir en archivos de texto. El StreamReader y
StreamWriter clase ayuda para lograrlo.
Leer y escribir en archivos binarios
Se trata de leer y escribir en archivos binarios. El BinaryReader y
BinaryWriter clase ayuda a lograr esto.
La manipulación del sistema de archivos de Windows
Se da un C # programamer la capacidad de buscar y localizar los archivos y
directorios de Windows.

C# atributos
Un attribute es una etiqueta declarativa que se utiliza para
transmitir información a tiempo de ejecución sobre los
comportamientos de los diversos elementos como clases, métodos,
estructuras, enumeradores, asambleas, etc., en su programa. Se
puede añadir información declarativa a un programa mediante el uso de un
atributo. Una etiqueta declarativa se representa mediante cuadrados ([ ])
soportes colocados por encima del elemento se utiliza para.
Los atributos se utilizan para añadir metadatos, tales como la instrucción
compilador y otra información como comentarios, descripción, métodos y
clases para un programa. .NET Framework proporciona dos tipos de
atributos: the pre-defined atributos y custom built atributos.

Especificar un atributo
Sintaxis para especificar un atributo es la siguiente:

[attribute(positional_parameters, name_parameter = value, ...)]

element

Nombre del atributo y sus valores se especifican dentro de los corchetes,

antes de que el elemento al que se aplica el atributo. Los parámetros
posicionales especifican la información esencial y los parámetros de
nombre especifican la información opcional.

Los atributos predefinidos

.NET Framework proporciona tres atributos predefinidos:

 AttributeUsage
 Condicional
  Obsoleto

AttributeUsage
El pre-defined atributo AttributeUsage describe cómo se puede
utilizar una clase de atributo personalizado. Especifica los tipos de
elementos a los que se puede aplicar el atributo.
Sintaxis para especificar este atributo es el siguiente:

[AttributeUsage(
validon,
AllowMultiple=allowmultiple,
Inherited=inherited
)]

Dónde,
 El validon parámetro especifica los elementos del lenguaje en el que
se puede colocar el atributo. Es una combinación del valor de un
enumerador AttributeTargets . El valor por defecto es
[Link] .
 El parámetro allowmultiple (optional) proporciona un valor para el
AllowMultiple propiedad de este atributo, un valor booleano. Si esto
es cierto, es el atributo de usos múltiples. El valor predeterminado es
falso (single-use) .
 El parámetro heredado (optional) proporciona un valor para el
Inherited propiedad de este atributo, un valor booleano. Si es verdad,
el atributo es heredado por las clases derivadas. El valor
predeterminado es falso (not inherited) .
Por ejemplo,

[AttributeUsage([Link] |
[Link] |
[Link] |
[Link] |
[Link],
AllowMultiple = true)]
Condicional
Este atributo predefinido marca un método condicional cuya ejecución
depende de un identificador de preprocesamiento especificado.
Hace que la compilación condicional de llamadas a métodos, dependiendo
del valor especificado como Debug o Trace . Por ejemplo, muestra los
valores de las variables durante la depuración de un código.
Sintaxis para especificar este atributo es el siguiente:

[Conditional(
conditionalSymbol
)]

Por ejemplo,

[Conditional("DEBUG")]

El siguiente ejemplo demuestra el atributo:

#define DEBUG
using System;
using [Link];

public class Myclass

{
[Conditional("DEBUG")]
public static void Message(string msg)
{
[Link](msg);
}
}

class Test
{
static void function1()
{
 [Link]("In Function 1.");
function2();
}
static void function2()
{
[Link]("In Function 2.");
}

public static void Main()

{
[Link]("In Main function.");
function1();
[Link]();
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

In Main function
In Function 1
In Function 2

Obsoleto
Este atributo predefinido marca una entidad de programa que no debe ser
utilizado. Se le permite informar al compilador para descartar un elemento
objetivo en particular. Por ejemplo, cuando un nuevo método está siendo
utilizado en una clase y si aún desea conservar el viejo método de la clase,
puede marcarlo como obsoleta mostrando un mensaje del nuevo método se
debe utilizar, en lugar del método de edad.
Sintaxis para especificar este atributo es el siguiente:

[Obsolete(
message
)]
[Obsolete(
message,
iserror
)]

Dónde,
 El parámetro de message , es una cadena que describe la razón por
la que el artículo es obsoleta y lo que debe usar en su lugar.
 El parámetro iserror , es un valor booleano. Si su valor es verdadero,
el compilador debe tratar el uso del artículo como un error. El valor
por defecto es falso (compiler generates a warning) .
El programa siguiente muestra esto:

using System;

public class MyClass

{
[Obsolete("Don't use OldMethod, use NewMethod instead",
true)]
static void OldMethod()
{
[Link]("It is the old method");
}
static void NewMethod()
{
[Link]("It is the new method");
}
public static void Main()
{
OldMethod();
}
}
Cuando intenta compilar el programa, el compilador da un mensaje de error
que indica:

Don't use OldMethod, use NewMethod instead

La creación de atributos personalizados

.Net Framework permite la creación de atributos personalizados que se
pueden utilizar para almacenar información declarativa y se pueden
recuperar en tiempo de ejecución. Esta información puede estar
relacionada con cualquier elemento de destino en función de los criterios de
diseño y necesidades de la aplicación.
Creación y uso de los atributos personalizados involucran cuatro pasos:

 La declaración de un atributo personalizado

 La construcción de la custom atributo
 Aplicar el custom atributo en un elemento de programa de destino
 Acceso a atributos través de la reflexión

El último paso consiste en escribir un programa sencillo para leer los

metadatos para encontrar diversas notaciones. Los metadatos son datos
acerca de datos o información que se utilizan para la descripción de otros
datos. Este programa debe utilizar reflexiones para acceder a atributos en
tiempo de ejecución. Esto es lo que se discutirá en el siguiente capítulo.

La declaración de un atributo personalizado

Un nuevo atributo personalizado debe se deriva de la [Link]
clase. Por ejemplo,

//a custom attribute BugFix to be assigned to a class and its

members
[AttributeUsage([Link] |
[Link] |
[Link] |
[Link] |
[Link],
AllowMultiple = true)]
public class DeBugInfo : [Link]

En el código anterior, hemos declarado un atributo personalizado

denominado DeBugInfo .

Construir el Custom Atributo

Construyamos un atributo personalizado denominado DeBugInfo , que
almacena la información obtenida por la depuración de cualquier programa.
Deje que se almacena la siguiente información:

 El número de código para el error

 Nombre del desarrollador que se identificó el error
 Fecha de la última revisión del código
 Un mensaje de cadena para almacenar los comentarios del
desarrollador

El DeBugInfo clase tiene tres propiedades privadas para almacenar los tres
primeros de la información y una propiedad pública para almacenar el
mensaje. Por lo tanto el número de error, el nombre del desarrollador, y la
fecha de revisión son los parámetros de posición de la clase debuginfo y el
mensaje es un parámetro opcional o denominación.
Cada atributo debe tener al menos un constructor. Los parámetros
posicionales se deben pasar a través del constructor. El código siguiente
muestra la DeBugInfo clase:

//a custom attribute BugFix to be assigned to a class and its

members
[AttributeUsage([Link] |
[Link] |
[Link] |
[Link] |
[Link],
AllowMultiple = true)]

public class DeBugInfo : [Link]

{
private int bugNo;
private string developer;
private string lastReview;
public string message;

public DeBugInfo(int bg, string dev, string d)

{
[Link] = bg;
[Link] = dev;
[Link] = d;
}

public int BugNo

{
get
{
return bugNo;
}
}

public string Developer

{
get
{
return developer;
}
}

public string LastReview

{
get
{
 return lastReview;
}
}

public string Message

{
get
{
return message;
}
set
{
message = value;
}
}
}

Aplicando el Custom Atributo

El atributo se aplica colocándolo inmediatamente antes de su objetivo:

[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type

mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused
variable")]
class Rectangle
{
//member variables
protected double length;
protected double width;
public Rectangle(double l, double w)
{
 length = l;
width = w;
}
[DeBugInfo(55, "Zara Ali", "19/10/2012", Message = "Return
type mismatch")]

public double GetArea()

{
return length * width;
}
[DeBugInfo(56, "Zara Ali", "19/10/2012")]

public void Display()

{
[Link]("Length: {0}", length);
[Link]("Width: {0}", width);
[Link]("Area: {0}", GetArea());
}
}

En el siguiente capítulo, recuperamos la información de atributos utilizando

un objeto de clase Reflexión.

C# Reflexión
Reflection objetos se utilizan para la obtención de información de
tipo en tiempo de ejecución. Las clases que dan acceso a los metadatos
de un programa en ejecución se encuentran en la [Link]
espacio de nombres.
El [Link] espacio de nombres contiene clases que
permiten obtener información sobre la aplicación y permite añadir
dinámicamente tipos, valores y objetos de la aplicación.

Aplicaciones de Reflexión
La reflexión tiene las siguientes aplicaciones:
  Permite a la vista la información de atributos en tiempo de ejecución.
 Permite examinar varios tipos en una asamblea y una instancia de
este tipo.
 Permite el enlace a métodos y propiedades
 Permite la creación de nuevos tipos en tiempo de ejecución y luego
realiza algunas tareas utilizando esos tipos.

visualización de metadatos
Ya hemos mencionado en el capítulo anterior que el uso de la reflexión se
puede ver la información de atributos.
El MemberInfo objeto de la [Link] clase tiene que ser
inicializado para descubrir los atributos asociados a una clase. Para
ello, se define un objeto de la clase de destino, como:

[Link] info = typeof(MyClass);

El programa siguiente muestra esto:

using System;

[AttributeUsage([Link])]
public class HelpAttribute : [Link]
{
public readonly string Url;

public string Topic // Topic is a named parameter

{
get
{
return topic;
}
set
{
topic = value;
 }
}

public HelpAttribute(string url) // url is a positional

parameter
{
[Link] = url;
}
private string topic;
}

[HelpAttribute("Information on the class MyClass")]

class MyClass
{
}
namespace AttributeAppl
{
class Program
{
static void Main(string[] args)
{
[Link] info = typeof(MyClass);
object[] attributes = [Link](true);
for (int i = 0; i < [Link]; i++)
{
[Link](attributes[i]);
}

[Link]();
}
}
}

Cuando se compila y ejecutado, muestra el nombre de los custom atributos

asociados a la clase MyClass :

HelpAttribute

Ejemplo
En este ejemplo, se utiliza el DeBugInfo atributo creado en el capítulo y el
uso previo de reflexión para leer los metadatos en el Rectangle clase.

using System;
using [Link];

namespace BugFixApplication
{
//a custom attribute BugFix to be
//assigned to a class and its members
[AttributeUsage([Link] |
[Link] |
[Link] |
[Link] |
[Link],
AllowMultiple = true)]

public class DeBugInfo : [Link]

{
private int bugNo;
private string developer;
private string lastReview;
public string message;
public DeBugInfo(int bg, string dev, string d)
{
[Link] = bg;
[Link] = dev;
[Link] = d;
}

public int BugNo

{
get
{
return bugNo;
}
}

public string Developer

{
get
{
return developer;
}
}

public string LastReview

{
get
{
return lastReview;
}
}
 public string Message
{
get
{
return message;
}
set
{
message = value;
}
}
}
[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return
type mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused
variable")]

class Rectangle
{
//member variables
protected double length;
protected double width;
public Rectangle(double l, double w)
{
length = l;
width = w;
}
[DeBugInfo(55, "Zara Ali", "19/10/2012", Message = "Return
type mismatch")]
public double GetArea()
{
return length * width;
 }
[DeBugInfo(56, "Zara Ali", "19/10/2012")]
public void Display()
{
[Link]("Length: {0}", length);
[Link]("Width: {0}", width);
[Link]("Area: {0}", GetArea());
}
}//end class Rectangle

class ExecuteRectangle
{
static void Main(string[] args)
{
Rectangle r = new Rectangle(4.5, 7.5);
[Link]();
Type type = typeof(Rectangle);

//iterating through the attribtues of the Rectangle

class
foreach (Object attributes in
[Link](false))
{
DeBugInfo dbi = (DeBugInfo)attributes;
if (null != dbi)
{
[Link]("Bug no: {0}", [Link]);
[Link]("Developer: {0}",
[Link]);
[Link]("Last Reviewed: {0}",
[Link]);
[Link]("Remarks: {0}", [Link]);
 }
}

//iterating through the method attribtues

foreach (MethodInfo m in [Link]())
{
foreach (Attribute a in [Link](true))
{
DeBugInfo dbi = (DeBugInfo)a;
if (null != dbi)
{
[Link]("Bug no: {0}, for Method:
{1}", [Link], [Link]);
[Link]("Developer: {0}",
[Link]);
[Link]("Last Reviewed: {0}",
[Link]);
[Link]("Remarks: {0}",
[Link]);
}
}
}

[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Length: 4.5
Width: 7.5
Area: 33.75
Bug No: 49
Developer: Nuha Ali
Last Reviewed: 10/10/2012
Remarks: Unused variable
Bug No: 45
Developer: Zara Ali
Last Reviewed: 12/8/2012
Remarks: Return type mismatch
Bug No: 55, for Method: GetArea
Developer: Zara Ali
Last Reviewed: 19/10/2012
Remarks: Return type mismatch
Bug No: 56, for Method: Display
Developer: Zara Ali
Last Reviewed: 19/10/2012
Remarks:

C# propiedades
Properties se nombran los miembros de las clases, estructuras e
interfaces. Las variables de miembro o métodos de una clase o
estructuras se llaman Fields . Las propiedades son una extensión de los
campos y se accede utilizando la misma sintaxis. Utilizan accessors a
través del cual los valores de los campos privados pueden ser
leídas, escritas o manipulados.
Propiedades no nombran a los lugares de almacenamiento. En cambio,
tienen accessors que leer, escribir, o calcular sus valores.
Por ejemplo, vamos a tener una clase llamada Student, con los campos
privados de edad, nombre y código. No podemos acceder directamente a
estos campos desde fuera del ámbito de la clase, pero podemos tener
propiedades para acceder a estos campos privados.
accessors
El accessor de una propiedad contiene las sentencias ejecutables
que ayuda a conseguir (reading or computing) o el establecimiento
(writing) la propiedad. Las declaraciones de descriptor de acceso pueden
contener un acceso get, un descriptor de acceso set, o ambos. Por ejemplo:

// Declare a Code property of type string:

public string Code
{
get
{
return code;
}
set
{
code = value;
}
}

// Declare a Name property of type string:

public string Name
{
get
{
return name;
}
set
{
name = value;
}
}

// Declare a Age property of type int:

public int Age
{
get
{
return age;
}
set
{
age = value;
}
}

Ejemplo
El siguiente ejemplo demuestra el uso de propiedades:

using System;
namespace tutorialspoint
{
class Student
{
private string code = "N.A";
private string name = "not known";
private int age = 0;

// Declare a Code property of type string:

public string Code
{
get
{
return code;
 }
set
{
code = value;
}
}

// Declare a Name property of type string:

public string Name
{
get
{
return name;
}
set
{
name = value;
}
}

// Declare a Age property of type int:

public int Age
{
get
{
return age;
}
set
{
age = value;
}
 }
public override string ToString()
{
return "Code = " + Code +", Name = " + Name + ", Age =
" + Age;
}
}

class ExampleDemo
{
public static void Main()
{

// Create a new Student object:

Student s = new Student();

// Setting code, name and the age of the student

[Link] = "001";
[Link] = "Zara";
[Link] = 9;
[Link]("Student Info: {0}", s);

//let us increase age

[Link] += 1;
[Link]("Student Info: {0}", s);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Student Info: Code = 001, Name = Zara, Age = 9
Student Info: Code = 001, Name = Zara, Age = 10

Propiedades abstractos
Una clase abstracta puede tener una propiedad abstracta, que debe ser
implementado en la clase derivada. El programa siguiente ilustra esto:

using System;
namespace tutorialspoint
{
public abstract class Person
{
public abstract string Name
{
get;
set;
}
public abstract int Age
{
get;
set;
}
}

class Student : Person

{

private string code = "N.A";

private string name = "N.A";
private int age = 0;
// Declare a Code property of type string:
public string Code
{
get
{
return code;
}
set
{
code = value;
}
}

// Declare a Name property of type string:

public override string Name
{
get
{
return name;
}
set
{
name = value;
}
}

// Declare a Age property of type int:

public override int Age
{
get
{
 return age;
}
set
{
age = value;
}
}
public override string ToString()
{
return "Code = " + Code +", Name = " + Name + ", Age =
" + Age;
}
}

class ExampleDemo
{
public static void Main()
{
// Create a new Student object:
Student s = new Student();

// Setting code, name and the age of the student

[Link] = "001";
[Link] = "Zara";
[Link] = 9;
[Link]("Student Info:- {0}", s);

//let us increase age

[Link] += 1;
[Link]("Student Info:- {0}", s);
[Link]();
 }
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Student Info: Code = 001, Name = Zara, Age = 9

Student Info: Code = 001, Name = Zara, Age = 10

C# Los indexadores
Un indexer permite que un objeto sea indexado tal como una
matriz. Cuando se define un indexador para una clase, esta clase se
comporta similar a una virtual array . A continuación, puede acceder a la
instancia de esta clase mediante el operador de acceso a conjunto ([ ]) .

Sintaxis
A un indexador dimensional tiene la siguiente sintaxis:

element-type this[int index]

{
// The get accessor.
get
{
// return the value specified by index
}

// The set accessor.

set
{
// set the value specified by index
}
}
El uso de indexadores
Declaración de la conducta de un indexador es en cierta medida similar a
una propiedad. similares a las propiedades, se utiliza get y set métodos
de acceso para definir un indexador. Sin embargo, propiedades
devuelven o establecen un miembro de datos específico, mientras que
indizadores Devuelve o establece un valor particular de la instancia de
objeto. En otras palabras, se rompe los datos de instancia en partes más
pequeñas y los índices de cada parte, obtiene o establece cada parte.
La definición de una propiedad implica proporcionar un nombre de
propiedad. Indexadores no se definen con los nombres, pero con la this
palabra clave, que hace referencia a la instancia del objeto. El
siguiente ejemplo demuestra el concepto:

using System;
namespace IndexerApplication
{
class IndexedNames
{
private string[] namelist = new string[size];
static public int size = 10;
public IndexedNames()
{
for (int i = 0; i < size; i++)
namelist[i] = "N. A.";
}

public string this[int index]

{
get
{
string tmp;

if( index >= 0 && index <= size-1 )

{
 tmp = namelist[index];
}
else
{
tmp = "";
}

return ( tmp );
}
set
{
if( index >= 0 && index <= size-1 )
{
namelist[index] = value;
}
}
}

static void Main(string[] args)

{
IndexedNames names = new IndexedNames();
names[0] = "Zara";
names[1] = "Riz";
names[2] = "Nuha";
names[3] = "Asif";
names[4] = "Davinder";
names[5] = "Sunil";
names[6] = "Rubic";
for ( int i = 0; i < [Link]; i++ )
{
[Link](names[i]);
 }

[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Zara
Riz
Nuha
Asif
Davinder
Sunil
Rubic
N. A.
N. A.
N. A.

Los indexadores sobrecargados

Indexadores se pueden sobrecargar. Indexadores también pueden
declararse con múltiples parámetros y cada parámetro puede ser un tipo
diferente. No es necesario que los índices tienen que ser enteros. C #
permite que los índices sean de otro tipo, por ejemplo, una cadena.
El siguiente ejemplo demuestra indizadores sobrecargados:

using System;
namespace IndexerApplication
{
class IndexedNames
{
private string[] namelist = new string[size];
static public int size = 10;
public IndexedNames()
{
for (int i = 0; i < size; i++)
{
namelist[i] = "N. A.";
}
}

public string this[int index]

{
get
{
string tmp;

if( index >= 0 && index <= size-1 )

{
tmp = namelist[index];
}
else
{
tmp = "";
}

return ( tmp );
}
set
{
if( index >= 0 && index <= size-1 )
{
namelist[index] = value;
 }
}
}
public int this[string name]
{
get
{
int index = 0;
while(index < size)
{
if (namelist[index] == name)
{
return index;
}
index++;
}
return index;
}

static void Main(string[] args)

{
IndexedNames names = new IndexedNames();
names[0] = "Zara";
names[1] = "Riz";
names[2] = "Nuha";
names[3] = "Asif";
names[4] = "Davinder";
names[5] = "Sunil";
names[6] = "Rubic";
 //using the first indexer with int parameter
for (int i = 0; i < [Link]; i++)
{
[Link](names[i]);
}

//using the second indexer with the string parameter

[Link](names["Nuha"]);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Zara
Riz
Nuha
Asif
Davinder
Sunil
Rubic
N. A.
N. A.
N. A.
2

C# Los delegados
C # delegados son similares a los punteros a funciones, en C o C ++. Un
delegate es una variable de tipo de referencia que contiene la
referencia a un método. La referencia se puede cambiar en tiempo de
ejecución.
Los delegados se utilizan sobre todo para la implementación de eventos y
los métodos de rellamada. Todos los delegados se derivan implícitamente
de la [Link] clase.

Los delegados que declaran

declaración de delegado determina los métodos que pueden ser
referenciados por el delegado. Un delegado puede referirse a un método,
que tiene la misma firma que la del delegado.
Por ejemplo, considere un delegado:

public delegate int MyDelegate (string s);

El delegado anterior se puede utilizar para hacer referencia a cualquier

método que tiene una única string parámetro y devuelve un int variable de
tipo.
Sintaxis para la declaración de delegado es:

delegate <return type> <delegate-name> <parameter list>

instanciar delegados
Una vez que se declara un tipo de delegado, un objeto delegado debe ser
creado con la new palabra clave y se asocia con un método
particular. Cuando se crea un delegado, el argumento pasado a la new
expresión se escribe similar a una llamada a un método, pero sin
los argumentos del método. Por ejemplo:

public delegate void printString(string s);

...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);

Siguiente ejemplo demuestra declaración, instanciación, y el uso de un

delegado que se puede utilizar para hacer referencia a métodos que toman
un parámetro entero y devuelve un valor entero.

using System;
delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}

public static int MultNum(int q)

{
num *= q;
return num;
}
public static int getNum()
{
return num;
}

static void Main(string[] args)

{
//create delegate instances
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);

//calling the methods using the delegate objects

nc1(25);
 [Link]("Value of Num: {0}", getNum());
nc2(5);
[Link]("Value of Num: {0}", getNum());
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Value of Num: 35
Value of Num: 175

La multidifusión de un delegado
Objetos de delegado pueden estar compuestos usando el "+" operador. Un
delegado compuesto llama a los dos delegados que se compone de. Sólo
los delegados del mismo tipo pueden estar compuestos. El "-" operador se
pueden utilizar para quitar un delegado componente de un delegado
compuesta.
El uso de esta propiedad de delegados puede crear una lista de invocación
de métodos que serán llamados cuando se invoca un delegado. Esto se
conoce como multicasting de un delegado. El programa siguiente
muestra la multidifusión de un delegado:

using System;

delegate int NumberChanger(int n);

namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
 num += p;
return num;
}

public static int MultNum(int q)

{
num *= q;
return num;
}

public static int getNum()

{
return num;
}

static void Main(string[] args)

{
//create delegate instances
NumberChanger nc;
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
nc = nc1;
nc += nc2;

//calling multicast
nc(5);
[Link]("Value of Num: {0}", getNum());
[Link]();
}
}
}
Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Value of Num: 75

El uso de delegados
El siguiente ejemplo muestra el uso del delegado. El delegado printString
puede ser utilizado para hacer referencia a un método que toma una
cadena como entrada y devuelve nada.
Utilizamos este delegado llamar dos métodos, el primero imprime la cadena
a la consola, y el segundo lo imprime a un archivo:

using System;
using [Link];

namespace DelegateAppl
{
class PrintString
{
static FileStream fs;
static StreamWriter sw;

// delegate declaration
public delegate void printString(string s);

// this method prints to the console

public static void WriteToScreen(string str)
{
[Link]("The String is: {0}", str);
}

//this method prints to a file

public static void WriteToFile(string s)
 {
fs = new FileStream("c:\\[Link]",
[Link], [Link]);
sw = new StreamWriter(fs);
[Link](s);
[Link]();
[Link]();
[Link]();
}

// this method takes the delegate as parameter and uses it

to
// call the methods as required
public static void sendString(printString ps)
{
ps("Hello World");
}
static void Main(string[] args)
{
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);
sendString(ps1);
sendString(ps2);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

The String is: Hello World

C# evento
Events son acciones del usuario tales como pulsar una tecla, clics,
los movimientos del ratón, etc., o algún acontecimiento, como el
sistema genera notificaciones. Las aplicaciones necesitan para
responder a eventos cuando se producen. Por ejemplo, las interrupciones.
Los eventos se utilizan para la comunicación entre procesos.

El uso de los delegados con eventos

Los eventos se declaran y se criaron en una clase y asociados con los
controladores de eventos utilizando los delegados dentro de la misma clase
o alguna otra clase. La clase que contiene el evento se utiliza para publicar
el evento. Esto se llama el publisher clase. Alguna otra clase que acepta
este evento se llama el subscriber clase. Eventos uso del publisher-
subscriber modelo.
Un publisher es un objeto que contiene la definición del evento y el
delegado. La asociación evento de delegado también se define en este
objeto. Un objeto de la clase editor invoca el evento y se notifica a otros
objetos.
Un subscriber es un objeto que acepta el evento y proporciona un
controlador de eventos. El delegado en la clase editor invoca el método
(event handler) de la clase de abonado.

Eventos que declaran

Para declarar un evento dentro de una clase, en primer lugar un tipo de
delegado para el evento debe ser declarada. Por ejemplo,

public delegate void BoilerLogHandler(string status);

A continuación, el evento en sí es declarada, utilizando el event de

palabras clave:

//Defining event based on the above delegate

public event BoilerLogHandler BoilerEventLog;

El código anterior define un delegado llamado BoilerLogHandler y un evento

denominado BoilerEventLog , que invoca el delegado cuando se levanta.
Ejemplo 1
using System;
namespace SimpleEvent
{
using System;

public class EventTest

{
private int value;
public delegate void NumManipulationHandler();
public event NumManipulationHandler ChangeNum;
protected virtual void OnNumChanged()
{
if (ChangeNum != null)
{
ChangeNum();
}
else
{
[Link]("Event fired!");
}
}

public EventTest(int n )
{
SetValue(n);
}

public void SetValue(int n)

{
if (value != n)
 {
value = n;
OnNumChanged();
}
}
}

public class MainClass

{
public static void Main()
{
EventTest e = new EventTest(5);
[Link](7);
[Link](11);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Event Fired!
Event Fired!
Event Fired!

Ejemplo 2
Este ejemplo proporciona una sencilla aplicación para la resolución de
problemas para un sistema de caldera de agua caliente. Cuando el
ingeniero de mantenimiento inspecciona la caldera, la temperatura de la
caldera y la presión se registra automáticamente en un archivo de registro,
junto con las observaciones del ingeniero de mantenimiento.

using System;
using [Link];

namespace BoilerEventAppl
{
// boiler class
class Boiler
{
private int temp;
private int pressure;
public Boiler(int t, int p)
{
temp = t;
pressure = p;
}

public int getTemp()

{
return temp;
}

public int getPressure()

{
return pressure;
}
}

// event publisher
class DelegateBoilerEvent
{
public delegate void BoilerLogHandler(string status);
 //Defining event based on the above delegate
public event BoilerLogHandler BoilerEventLog;

public void LogProcess()

{
string remarks = "O. K";
Boiler b = new Boiler(100, 12);
int t = [Link]();
int p = [Link]();
if(t > 150 || t < 80 || p < 12 || p > 15)
{
remarks = "Need Maintenance";
}
OnBoilerEventLog("Logging Info:\n");
OnBoilerEventLog("Temparature " + t + "\nPressure: " +
p);
OnBoilerEventLog("\nMessage: " + remarks);
}

protected void OnBoilerEventLog(string message)

{
if (BoilerEventLog != null)
{
BoilerEventLog(message);
}
}
}

// this class keeps a provision for writing into the log file
class BoilerInfoLogger
{
 FileStream fs;
StreamWriter sw;
public BoilerInfoLogger(string filename)
{
fs = new FileStream(filename, [Link],
[Link]);
sw = new StreamWriter(fs);
}

public void Logger(string info)

{
[Link](info);
}

public void Close()

{
[Link]();
[Link]();
}
}

// The event subscriber

public class RecordBoilerInfo
{
static void Logger(string info)
{
[Link](info);
}//end of Logger

static void Main(string[] args)

{
 BoilerInfoLogger filelog = new BoilerInfoLogger("e:\\
[Link]");
DelegateBoilerEvent boilerEvent = new
DelegateBoilerEvent();
[Link] += new
[Link](Logger);
[Link] += new
[Link]([Link]);
[Link]();
[Link]();
[Link]();
}//end of main

}//end of RecordBoilerInfo
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Logging info:

Temperature 100
Pressure 12

Message: O. K

C# Colecciones
clases de colección son clases especializadas para el almacenamiento y
recuperación de datos. Estas clases proporcionan soporte para pilas, colas,
listas y tablas hash. La mayoría de las clases de colección aplicar las
mismas interfaces.
clases de colección sirven diversos fines, tales como la asignación de
memoria de forma dinámica a los elementos y acceder a una lista de
artículos sobre la base de un índice etc. Estas clases crean colecciones de
objetos de la clase Object, que es la clase base para todos los tipos de
datos en C #.

Diversas clases de colección y su uso

Las siguientes son las diferentes clases de uso común de la
[Link] espacio de nombres. Haga clic en los siguientes
enlaces para ver sus detalles.
Clase Descripción y Uso del

Representa la colección ordenada de un objeto que puede

ser indexed de forma individual.
Se trata básicamente de una alternativa a una matriz. Sin
embargo, a diferencia de matriz que puede agregar y quitar
ArrayList elementos de una lista en una posición especificada usando
un index y cambia el tamaño de la matriz de forma
automática. También permite la asignación dinámica de
memoria, añadiendo, buscar y ordenar los elementos de la
lista.
Se utiliza una key para acceder a los elementos de la
colección.
Una tabla hash se utiliza cuando se necesita para acceder a
Hashtable los elementos mediante el uso de clave, y se puede
identificar un valor de clave de utilidad. Cada elemento de la
tabla hash tiene una key/value par. La clave se utiliza para
acceder a los elementos de la colección.
Se utiliza una key , así como un index para acceder a
los elementos de una lista.
Una lista ordenada es una combinación de una matriz y una
tabla hash. Contiene una lista de elementos que se pueden
SortedList acceder mediante una clave o un índice. Si tiene acceso a
elementos mediante un índice, es un ArrayList, y si tiene
acceso a elementos mediante una clave, que es una tabla
hash. La colección de artículos siempre se clasifica por el
valor de la clave.
Representa un last-in, first out colección de objetos.
Se utiliza cuando se necesita un último en entrar, primero en
Stack salir el acceso de elementos. Cuando se agrega un elemento
de la lista, se le llama pushing el elemento y cuando lo
saque, se llama popping el artículo.
Queue Representa una first-in, first out colección de objeto.
 Se utiliza cuando se necesita un primero en entrar, primero
en salir el acceso de elementos. Cuando se agrega un
elemento de la lista, se le llama enqueue y cuando se
quita un elemento, que se llama deque .
Representa una matriz de la binary representation
utilizando los valores 1 y 0.

BitArray Se utiliza cuando se necesita para almacenar los bits, pero

no sabe el número de bits por adelantado. Se puede acceder
a los elementos de la colección BitArray mediante el uso de
un integer index , que comienza de cero.

C# Los medicamentos genéricos

Generics le permiten retrasar la especificación del tipo de datos de
elementos de programación en una clase o un método, hasta que
realmente se utiliza en el programa. En otras palabras, los genéricos
permiten escribir una clase o método que puede funcionar con cualquier
tipo de datos.
Se escriben las especificaciones de la clase o el método, con los parámetros
de sustitución para los tipos de datos. Cuando el compilador encuentra un
constructor de la clase o una llamada de función para el método, se genera
código para manejar el tipo de datos específico. Un ejemplo sencillo sería
ayudar a la comprensión del concepto:

using System;
using [Link];

namespace GenericApplication
{
public class MyGenericArray<T>
{
private T[] array;
public MyGenericArray(int size)
{
array = new T[size + 1];
}
 public T getItem(int index)
{
return array[index];
}

public void setItem(int index, T value)

{
array[index] = value;
}
}

class Tester
{
static void Main(string[] args)
{

//declaring an int array

MyGenericArray<int> intArray = new
MyGenericArray<int>(5);

//setting values
for (int c = 0; c < 5; c++)
{
[Link](c, c*5);
}

//retrieving the values

for (int c = 0; c < 5; c++)
{
[Link]([Link](c) + " ");
}
 [Link]();

//declaring a character array

MyGenericArray<char> charArray = new
MyGenericArray<char>(5);

//setting values
for (int c = 0; c < 5; c++)
{
[Link](c, (char)(c+97));
}

//retrieving the values

for (int c = 0; c< 5; c++)
{
[Link]([Link](c) + " ");
}
[Link]();

[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

0 5 10 15 20
a b c d e
Características de los genéricos
Los medicamentos genéricos es una técnica que enriquece sus programas
en las siguientes formas:
 Se le ayuda a maximizar la reutilización de código, la seguridad de
tipos, y el rendimiento.
 Se pueden crear clases de colección genéricos. La biblioteca de
clases de .NET Framework contiene varias nuevas clases de colección
genérica en la [Link] espacio de nombres.
Puedes usar las siguientes clases de colección genéricos en lugar de
las clases de colección en el [Link] espacio de nombres.
 Usted puede crear sus propios genéricos interfaces, clases, métodos,
eventos y delegados.
 Puede crear clases genéricas limitados para permitir el acceso a los
métodos sobre los tipos de datos particulares.
 Usted puede obtener información sobre los tipos utilizados en un tipo
genérico de datos en tiempo de ejecución por medio de la reflexión.

Métodos genéricos
En el ejemplo anterior, hemos utilizado una clase genérica; podemos
declarar un método genérico con un parámetro de tipo. El siguiente
programa ilustra el concepto:

using System;
using [Link];

namespace GenericMethodAppl
{
class Program
{
static void Swap<T>(ref T lhs, ref T rhs)
{
T temp;
temp = lhs;
lhs = rhs;
rhs = temp;
 }
static void Main(string[] args)
{
int a, b;
char c, d;
a = 10;
b = 20;
c = 'I';
d = 'V';

//display values before swap:

[Link]("Int values before calling swap:");
[Link]("a = {0}, b = {1}", a, b);
[Link]("Char values before calling swap:");
[Link]("c = {0}, d = {1}", c, d);

//call swap
Swap<int>(ref a, ref b);
Swap<char>(ref c, ref d);

//display values after swap:

[Link]("Int values after calling swap:");
[Link]("a = {0}, b = {1}", a, b);
[Link]("Char values after calling swap:");
[Link]("c = {0}, d = {1}", c, d);

[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Int values before calling swap:
a = 10, b = 20
Char values before calling swap:
c = I, d = V
Int values after calling swap:
a = 20, b = 10
Char values after calling swap:
c = V, d = I

Los delegados genéricos

Se puede definir un delegado genérico con parámetros de tipo. Por ejemplo:

delegate T NumberChanger<T>(T n);

El siguiente ejemplo muestra el uso de este delegado:

using System;
using [Link];

delegate T NumberChanger<T>(T n);

namespace GenericDelegateAppl
{
class TestDelegate
{
static int num = 10;
public static int AddNum(int p)
{
num += p;
return num;
}

public static int MultNum(int q)

 {
num *= q;
return num;
}
public static int getNum()
{
return num;
}

static void Main(string[] args)

{
//create delegate instances
NumberChanger<int> nc1 = new
NumberChanger<int>(AddNum);
NumberChanger<int> nc2 = new
NumberChanger<int>(MultNum);

//calling the methods using the delegate objects

nc1(25);
[Link]("Value of Num: {0}", getNum());
nc2(5);
[Link]("Value of Num: {0}", getNum());
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Value of Num: 35
Value of Num: 175
C# Métodos anónimos
Hemos discutido que los delegados se utilizan para hacer referencia a
cualquier método que tiene la misma firma que la del delegado. En otras
palabras, se puede llamar a un método que puede ser referenciado por un
delegado de utilizar ese objeto delegado.
Anonymous methods proporcionan una técnica para pasar un
bloque de código como parámetro delegado. métodos anónimos son
los métodos sin un nombre, sólo el cuerpo.
No es necesario especificar el tipo de retorno de un método anónimo; que
se deduce de la sentencia return dentro del cuerpo del método.

Escribiendo un método anónimo

Métodos anónimos se declaran con la creación de la instancia de delegado,
con un delegate de palabras clave. Por ejemplo,

delegate void NumberChanger(int n);

...
NumberChanger nc = delegate(int x)
{
[Link]("Anonymous Method: {0}", x);
};

El bloque de código [Link]("Anonymous Method: {0}", x); es el

cuerpo del método anónimo.
El delegado podría ser llamado tanto con métodos anónimos, así como
métodos llamados de la misma manera, es decir, haciendo pasar los
parámetros del método al objeto delegado.
Por ejemplo,

nc(10);

Ejemplo
El siguiente ejemplo demuestra el concepto:

using System;
delegate void NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
static int num = 10;
public static void AddNum(int p)
{
num += p;
[Link]("Named Method: {0}", num);
}

public static void MultNum(int q)

{
num *= q;
[Link]("Named Method: {0}", num);
}

public static int getNum()

{
return num;
}
static void Main(string[] args)
{
//create delegate instances using anonymous method
NumberChanger nc = delegate(int x)
{
[Link]("Anonymous Method: {0}", x);
};
 //calling the delegate using the anonymous method
nc(10);

//instantiating the delegate using the named methods

nc = new NumberChanger(AddNum);

//calling the delegate using the named methods

nc(5);

//instantiating the delegate using another named

methods
nc = new NumberChanger(MultNum);

//calling the delegate using the named methods

nc(2);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Anonymous Method: 10
Named Method: 15
Named Method: 30

C# Códigos inseguras
C # permite el uso de variables de puntero en función del bloque de código
cuando está marcada por la unsafe modificador. El unsafe code o el
código no administrado es un bloque de código que utiliza un
pointer variable.
Note: Para ejecutar los programas mencionados en este
capítulo en codingground , opción de compilación en favor
de establecer Project >> Compile Options >> Compilation
Command de
mcs *.cs -out:[Link] -unsafe"

punteros
Un pointer es una variable cuyo valor es la dirección de otra
variable de decir, la dirección directa de la posición de memoria.
similar a cualquier variable o constante, debe declarar un puntero antes de
poder utilizarlo para almacenar cualquier dirección variable.
La forma general de una declaración de puntero es:

type *var-name;

Los siguientes son declaraciones de puntero válido:

int *ip; /* pointer to an integer */

double *dp; /* pointer to a double */
float *fp; /* pointer to a float */
char *ch /* pointer to a character */

El siguiente ejemplo ilustra el uso de punteros en C #, usando el

modificador inseguro:

using System;
namespace UnsafeCodeApplication
{
class Program
{
static unsafe void Main(string[] args)
{
int var = 20;
int* p = &var;
[Link]("Data is: {0} ", var);
[Link]("Address is: {0}", (int)p);
[Link]();
 }
}
}

Cuando el wass código compilado y ejecutado, se produce el siguiente

resultado:

Data is: 20
Address is: 99215364

En lugar de declarar un método completo como inseguro, también se puede

declarar una parte del código como inseguro. El ejemplo en la siguiente
sección se muestra esto.

Obtener el valor de los datos mediante un puntero

Se pueden recuperar los datos almacenados en el situado referencia la
variable puntero, utilizando el ToString() método. El siguiente ejemplo
demuestra esto:

using System;
namespace UnsafeCodeApplication
{
class Program
{
public static void Main()
{
unsafe
{
int var = 20;
int* p = &var;
[Link]("Data is: {0} " , var);
[Link]("Data is: {0} " , p->ToString());
[Link]("Address is: {0} " , (int)p);
}
 [Link]();
}
}
}

Cuando el código anterior se compila y se ejecuta, se produce el siguiente

resultado:

Data is: 20
Data is: 20
Address is: 77128984

Pasar punteros como parámetros a métodos

Puede pasar una variable puntero a un método como parámetro. El
siguiente ejemplo lo ilustra:

using System;
namespace UnsafeCodeApplication
{
class TestPointer
{
public unsafe void swap(int* p, int *q)
{
int temp = *p;
*p = *q;
*q = temp;
}

public unsafe static void Main()

{
TestPointer p = new TestPointer();
 int var1 = 10;
int var2 = 20;
int* x = &var1;
int* y = &var2;

[Link]("Before Swap: var1:{0}, var2: {1}",

var1, var2);
[Link](x, y);

[Link]("After Swap: var1:{0}, var2: {1}",

var1, var2);
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

Before Swap: var1: 10, var2: 20

After Swap: var1: 20, var2: 10

El acceso a los elementos de matriz mediante un puntero

En C #, un nombre de matriz y un puntero a un tipo de datos misma que la
matriz de datos, no son del mismo tipo variable. Por ejemplo, int * p y int []
p, no son mismo tipo. Puede incrementar la variable puntero P, ya que no
se fija en la memoria pero una dirección de matriz se fija en la memoria, y
no se puede incrementar eso.
Por lo tanto, si necesita acceder a una serie de datos utilizando una variable
de puntero, como hacemos tradicionalmente en C o C ++ ( please check: C
Pointers ) , que debe arreglar el puntero utilizando el fixed de palabras
clave.
El siguiente ejemplo demuestra esto:

using System;
namespace UnsafeCodeApplication
{
class TestPointer
{
public unsafe static void Main()
{
int[] list = {10, 100, 200};
fixed(int *ptr = list)

/* let us have array address in pointer */

for ( int i = 0; i < 3; i++)
{
[Link]("Address of list[{0}]={1}",i,(int)
(ptr + i));
[Link]("Value of list[{0}]={1}", i, *(ptr
+ i));
}

[Link]();
}
}
}

Cuando el código anterior se compila y se ejecuta, se produce el siguiente

resultado:

Address of list[0] = 31627168

Value of list[0] = 10
Address of list[1] = 31627172
Value of list[1] = 100
Address of list[2] = 31627176
Value of list[2] = 200
La compilación de código no seguro
Para compilar código no seguro, usted tiene que especificar el /unsafe
modificador de línea de comandos con el compilador de línea de
comandos.
Por ejemplo, para compilar un programa [Link] que contienen código no
seguro nombrado, desde la línea de comandos, dar la orden:

csc /unsafe [Link]

Si está utilizando Visual Studio IDE a continuación, necesita habilitar el uso

de código inseguro en las propiedades del proyecto.
Para hacer esto:
 Abrir project properties haciendo doble clic en el nodo
Propiedades del Explorador de soluciones.
 Haga clic en el Build pestaña.
 Seleccionar la opción " Allow unsafe code ".

C# multihilo
Un thread se define como la ruta de ejecución de un programa.
Cada hilo define un flujo único de control. Si su aplicación implica
operaciones complicadas y que requieren mucho tiempo, a continuación, a
menudo es útil para establecer diferentes rutas de ejecución o hilos, con
cada hilo de la realización de un trabajo en particular.
Los hilos son lightweight processes . Un ejemplo común de uso de hilo es
la implementación de la programación concurrente por los sistemas
operativos modernos. El uso de hilos de guarda desperdicio de ciclo de la
CPU y el aumento de la eficiencia de una aplicación.
Hasta ahora hemos escrito los programas en los que una sola hebra se
ejecuta como un proceso único, que es la instancia en ejecución de la
aplicación. Sin embargo, de esta manera la aplicación puede realizar una
tarea a la vez. Para que sea ejecutar más de una tarea a la vez, que se
puede dividir en las discusiones más pequeñas.

Ciclo de Vida de hilo

El ciclo de vida de un hilo comienza cuando se crea un objeto de la clase
[Link] y termina cuando el hilo se termina o finaliza su
ejecución.
A continuación se presentan los diferentes estados del ciclo de vida de un
hilo:
  The Unstarted State : Es la situación en la que se crea la
instancia de la rosca, pero el método de inicio no se llama.
 The Ready State : Es la situación en la que el hilo está listo
para funcionar y de espera CPU ciclo.
 The Not Runnable State : Un hilo no es ejecutable, cuando:
ométodo del sueño se ha llamado
ométodo de espera ha sido llamado
oBloqueado por las operaciones de E / S
 The Dead State : Es la situación en la que el hilo completa su
ejecución o se aborta.

El hilo principal
En C #, el [Link] clase se utiliza para trabajar
con hilos. Permite crear y acceder a hilos individuales en una aplicación de
multiproceso. La primera rosca para ser ejecutado en un proceso se llama
el main hilo.
Cuando un programa en C # inicia la ejecución, el hilo principal se crea
automáticamente. Los hilos creados usando el Thread de clase se llaman
los hilos secundarios del hilo principal. Se puede acceder a un hilo
mediante el CurrentThread propiedad de la clase Thread.
El programa siguiente muestra la ejecución del hilo principal:

using System;
using [Link];

namespace MultithreadingApplication
{
class MainThreadProgram
{
static void Main(string[] args)
{
Thread th = [Link];
[Link] = "MainThread";
[Link]("This is {0}", [Link]);
[Link]();
 }
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

This is MainThread

Propiedades y métodos de la clase Thread

La siguiente tabla muestra algunos más utilizados properties del Thread
de clase:
Propiedad Descripción

Obtiene el contexto actual en el que el hilo está

CurrentContext
ejecutando.

Obtiene o establece la cultura para el subproceso

CurrentCulture
actual.

Obtiene o establece director actual de la rosca (for role-

CurrentPrinciple
based security) .

CurrentThread Obtiene el hilo se está ejecutando actualmente.

Obtiene o establece la cultura actual que utiliza el

CurrentUICulture Administrador de recursos para buscar recursos
específicos de la cultura en tiempo de ejecución.

Obtiene un objeto ExecutionContext que contiene

ExecutionContext información acerca de los diversos contextos de la
rosca actual.

Obtiene un valor que indica el estado de ejecución del

IsAlive
subproceso actual.

Obtiene o establece un valor que indica si o no un hilo

IsBackground
es un hilo de fondo.

IsThreadPoolThreadObtiene un valor que indica si o no un hilo pertenece a

 la agrupación de hebras administrado.

Obtiene un identificador único para el subproceso

ManagedThreadId
administrado actual.

Name Obtiene o establece el nombre de la rosca.

Obtiene o establece un valor que indica la prioridad de

Priority
planificación de un hilo.

Obtiene un valor que contiene los estados de la rosca

ThreadState
actual.

La siguiente tabla muestra algunos de los más comúnmente utilizados

methods de la Thread de clase:
No
métodos
Señor.

public void Abort()

1 Plantea una ThreadAbortException en el hilo en el que se invoca,

para iniciar el proceso de terminación de la rosca. Llamar a este
método generalmente termina la rosca.
public static LocalDataStoreSlot AllocateDataSlot()

2 Asigna una ranura de datos sin nombre en todos los hilos. Para un
mejor rendimiento, campos de uso que están marcados con el
ThreadStaticAttribute atribuyen su lugar.
public static LocalDataStoreSlot
AllocateNamedDataSlot(string name)
3
Asigna una ranura de datos cuyo nombre aparece en todas las
discusiones. Para un mejor rendimiento, campos de uso que están
marcados con el ThreadStaticAttribute atribuyen su lugar.
public static void BeginCriticalRegion()
Notifica un anfitrión que ejecución está a punto de entrar en una
4 región de código en el que los efectos de un hilo o abortan
excepción no controlada podría poner en peligro otras tareas en el
dominio de aplicación.
5 public static void BeginThreadAffinity()
Notifica a un host que el código administrado está a punto de
ejecutar las instrucciones que dependen de la identidad de la
 corriente de hilos del sistema operativo físico.
public static void EndCriticalRegion()

6 Notifica un anfitrión que ejecución está a punto de entrar en una

región de código en el que los efectos de un hilo o abortan
excepción no controlada se limitan a la tarea actual.
public static void EndThreadAffinity()

7 Notifica a un host que el código administrado ha terminado de

ejecutar las instrucciones que dependen de la identidad de la
corriente de hilos del sistema operativo físico.
public static void FreeNamedDataSlot(string name)

8 Elimina la asociación entre un nombre y una ranura, para todos los

hilos en el proceso. Para un mejor rendimiento, campos de uso que
están marcados con el ThreadStaticAttribute atribuyen su lugar.
public static Object GetData(LocalDataStoreSlot slot)
Recupera el valor de la ranura especificada en la rosca actual,
9 dentro del dominio actual del subproceso actual. Para un mejor
rendimiento, campos de uso que están marcados con el
ThreadStaticAttribute atribuyen su lugar.
public static AppDomain GetDomain()
10 Devuelve el dominio actual en la que el hilo actual se está
ejecutando.
public static AppDomain GetDomain()
11
Devuelve una única aplicación de dominio identificador
public static LocalDataStoreSlot GetNamedDataSlot(string
name)
12
Busca una ranura de datos con nombre. Para un mejor rendimiento,
campos de uso que están marcados con el ThreadStaticAttribute
atribuyen su lugar.
public void Interrupt()
13
Interrumpe un hilo que está en el estado hilo WaitSleepJoin.
public void Join()

14 Bloquea el subproceso de llamada hasta que un subproceso

termina, sin dejar de realizar COM estándar y bombeo
SendMessage. Este método tiene diferentes formas sobrecargado.
15 public static void MemoryBarrier()
 Sincroniza acceso a la memoria de la siguiente manera: El
procesador que ejecuta el subproceso actual no se puede cambiar
el orden de las instrucciones de tal manera que los accesos a
memoria antes de la llamada a MemoryBarrier ejecutar después de
accesos a memoria que siguen la llamada a MemoryBarrier.

dieciséi public static void ResetAbort()

s Cancela una Abortar solicitó para el subproceso actual.
public static void SetData(LocalDataStoreSlot slot, Object
data)

17 Establece los datos en la ranura especificada en el hilo actualmente

en ejecución, para el dominio actual de ese hilo. Para un mejor
rendimiento, los campos marcados con el uso ThreadStaticAttribute
atribuyen su lugar.
public void Start()
18
Inicia un hilo.
public static void Sleep(int millisecondsTimeout)
19
Hace que la pausa hilo por un período de tiempo.
public static void SpinWait(int iterations)
20 Causas un hilo para esperar el número de veces definido por el
parámetro iteraciones
public static byte VolatileRead(ref byte address)
public static double VolatileRead(ref double address)
public static int VolatileRead(ref int address)
21 public static Object VolatileRead(ref Object address)
Lee el valor de un campo. El valor es el último escrito en cualquier
procesador de una computadora, sin importar el número de
procesadores o el estado de la caché del procesador. Este método
tiene diferentes formas sobrecargado. Sólo algunos se dan arriba.
22 public static void VolatileWrite(ref byte address,byte value)
public static void VolatileWrite(ref double address, double
value)
public static void VolatileWrite(ref int address, int value)
public static void VolatileWrite(ref Object address, Object
value)
Escribe un valor en un campo de inmediato, por lo que el valor es
visible para todos los procesadores del ordenador. Este método
 tiene diferentes formas sobrecargado. Sólo algunos se dan arriba.
public static bool Yield()

23 Hace que el subproceso de la llamada para dar ejecución a otro hilo

que está listo para funcionar en el procesador actual. El sistema
operativo selecciona el hilo a ceder a.

Creación de Hilos
Los hilos se crean mediante la extensión de la clase Thread. La clase
Thread extendida continuación, llama al Start() método para iniciar la
ejecución del hilo niño.
El programa siguiente muestra el concepto:

using System;
using [Link];

namespace MultithreadingApplication
{
class ThreadCreationProgram
{
public static void CallToChildThread()
{
[Link]("Child thread starts");
}

static void Main(string[] args)

{
ThreadStart childref = new
ThreadStart(CallToChildThread);
[Link]("In Main: Creating the Child
thread");
Thread childThread = new Thread(childref);
[Link]();
[Link]();
 }
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

In Main: Creating the Child thread

Child thread starts

Gestión de Temas
La clase Thread proporciona varios métodos para la gestión de hilos.
El siguiente ejemplo demuestra el uso del sleep() método para hacer
una pausa hilo por un período de tiempo específico.

using System;
using [Link];

namespace MultithreadingApplication
{
class ThreadCreationProgram
{
public static void CallToChildThread()
{
[Link]("Child thread starts");

// the thread is paused for 5000 milliseconds

int sleepfor = 5000;

[Link]("Child Thread Paused for {0}

seconds", sleepfor / 1000);
[Link](sleepfor);
[Link]("Child thread resumes");
 }

static void Main(string[] args)

{
ThreadStart childref = new
ThreadStart(CallToChildThread);
[Link]("In Main: Creating the Child
thread");
Thread childThread = new Thread(childref);
[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

In Main: Creating the Child thread

Child thread starts
Child Thread Paused for 5 seconds
Child thread resumes

La destrucción de Hilos
El Abort() método se utiliza para destruir los hilos.
El tiempo de ejecución aborta el hilo lanzando un
ThreadAbortException . Esta excepción no puede ser capturado, el
control se envía al finally del bloque, en su caso.
El programa siguiente ilustra esto:

using System;
using [Link];

namespace MultithreadingApplication
{
class ThreadCreationProgram
{
public static void CallToChildThread()
{
try
{
[Link]("Child thread starts");

// do some work, like counting to 10

for (int counter = 0; counter <= 10; counter++)
{
[Link](500);
[Link](counter);
}

[Link]("Child Thread Completed");

}

catch (ThreadAbortException e)
{
[Link]("Thread Abort Exception");
}
finally
{
[Link]("Couldn't catch the Thread
Exception");
}
}

static void Main(string[] args)

 {
ThreadStart childref = new
ThreadStart(CallToChildThread);
[Link]("In Main: Creating the Child
thread");
Thread childThread = new Thread(childref);
[Link]();

//stop the main thread for some time

[Link](2000);

//now abort the child

[Link]("In Main: Aborting the Child
thread");

[Link]();
[Link]();
}
}
}

Cuando el código se compila y ejecuta, se produce el siguiente resultado:

In Main: Creating the Child thread

Child thread starts
0
1
2
In Main: Aborting the Child thread
Thread Abort Exception
Couldn't catch the Thread Exception
C# Preguntas y respuestas
C# Questions and Answers ha sido diseñado con una intención
especial de ayudar a los estudiantes y profesionales que se
preparan para varios Certification Exams y Job Interviews . Esta
sección proporciona una útil colección de muestras preguntas de la
entrevista y las preguntas de opción múltiple (MCQs) y sus respuestas con
las explicaciones correspondientes.

S
Pregunta / Tipo Respuestas
N

C # preguntas de la entrevista

1 Esta sección ofrece una gran colección de C # preguntas de la entrevista

con sus respuestas escondidas en una caja a prueba a tener un ir en
ellos antes de descubrir la respuesta correcta.
C # en línea Cuestionario
Esta sección ofrece una gran colección de C # Preguntas de Opción
2 Múltiple (MCQs) en una sola página, junto con sus respuestas y
explicaciones correctas. Si selecciona la opción correcta, se pone en
verde; otra roja.
C # Prueba en línea
Si se está preparando para aparecer para un examen de certificación
relacionados # Java y C, entonces esta sección es una necesidad para
usted. En esta sección se simula una prueba en línea real junto con un
3 contador de tiempo determinado, que te reta a completar la prueba
dentro de un plazo determinado. Por último, puede comprobar su
puntuación global de la prueba y cómo te ha ido entre millones de otros
candidatos que participaron en esta prueba en línea.
4 C # Mock prueba
Esta sección ofrece varias pruebas simuladas que se pueden descargar a
su máquina local y resolver fuera de línea. Cada prueba simulada se
suministra con una clave de prueba falsa para que pueda verificar la
 puntuación final y usted mismo grado.

C# Recursos útiles
Los siguientes recursos contienen información adicional sobre C #. Por
favor usarlos para obtener más conocimiento en profundidad sobre este
tema.

Enlaces de interés sobre C #

 C # Guía de Programación - Esto proporciona información detallada
sobre las características y funciones del lenguaje C # clave
accesibles a través de C # .NET Framework.
 Visual Studio - Descargar la nueva versión de Visual Studio que
funciona como C # IDE.
 Ir Mono - Mono es una plataforma de software diseñado para permitir
a los desarrolladores crear fácilmente aplicaciones de plataforma
cruzada.
 Sostenido de C (programming language) - Wikipedia explica
sostenido de C (programming language) .
Libros útiles en C #






 

Para dar de alta su sitio en esta página, por favor un correo electrónico a
contact@[Link]