fund a mentos dec sharp

Programación Aplicada FundamentosdeCSharp Fundamentos de C#

Universidad Estatal de Sonora 1

Manual que contiene los elementos más básicos para programar en el lenguaje C#

Contenido Comentarios .................................................................................................................................. 2

Tipos de datos básicos ................................................................................................................... 3

Literales................................................................................................................................... 4

Identificadores ....................................................................................................................... 5

Constantes ............................................................................................................................. 6

C# NET DECLARACION Y TIPO DE VARIABLES .................................................................................. 7

OPERADORES ............................................................................................................................... 11

Sentencias en C# .......................................................................................................................... 13

Sentencia if .................................................................................................................................. 13

Do while ...................................................................................................................................... 13

Ciclo for ....................................................................................................................................... 14

Switch .......................................................................................................................................... 15

foreach ........................................................................................................................................ 16

Métodos ...................................................................................................................................... 16

El método Main () ...................................................................................................................... 17

Namespaces ................................................................................................................................ 17



Comentarios Un comentario es texto que se incluye en el código fuente para facilitar su lectura a los programadores y cuyo contenido es, por defecto, completamente ignorado por el compilador. Suelen usarse para incluir información sobre el autor del código, para aclarar el significado o el porqué de determinadas secciones de código, para describir el funcionamiento de los métodos de las clases, etc.

En C# hay dos formas de escribir comentarios. La primera consiste en encerrar todo el texto que se desee comentar entre caracteres /* y */ . Estos comentarios pueden abarcar tantas líneas como sea necesario. Por ejemplo:

/* Texto */ /* Esto es un comentario que ejemplifica cómo se escribe comentarios que ocupen varias líneas*/

Ahora bien, hay que tener cuidado con el hecho de que no es posible anidar comentarios de este tipo. Es decir, no vale escribir comentarios como el siguiente:

NO ES CORRECTO! /* Comentario contenedor /* Comentario contenido */ */

Esto se debe a que como el compilador ignora todo el texto contenido en un comentario y sólo busca la secuencia */ que marca su final, ignorará el segundo /* y cuando llegue al primer */ considerará que ha acabado el comentario abierto con el primer /* (no el abierto con el segundo) y pasará a buscar código. Como el */ sólo lo admite si ha detectado antes algún comentario abierto y aún no cerrado (no mientras busca código), cuando llegue al segundo */ considerará que ha habido un error ya que encontrará el */ donde esperaba encontrar código

Dado que muchas veces los comentarios que se escriben son muy cortos y no suelen ocupar más de una línea, C# ofrece una sintaxis alternativa más compacta para la escritura este tipo de comentarios en las que se considera como indicador del comienzo del comentario la pareja de caracteres // y como indicador de su final el fin de línea. Por tanto, la sintaxis que siguen estos comentarios es:

// <texto>



Y un ejemplo de su uso es:

// Este comentario ejemplifica como escribir comentarios de una sola línea

Estos comentarios de una sola línea sí que pueden anidarse sin ningún problema. Por ejemplo, el siguiente comentario es perfectamente válido:

// Comentario contenedor // Comentario contenido

Tipos de datos básicos Los tipos de datos básicos son ciertos tipos de datos tan comúnmente utilizados en la escritura de aplicaciones que en C# se ha incluido una sintaxis especial para tratarlos. Por ejemplo, para representar números enteros de 32 bits con signo se utiliza el tipo de dato System.Int32 definido en la BCL, aunque a la hora de crear un objeto a de este tipo que represente el valor 2 se usa la siguiente sintaxis:

System.Int32 a = 2;

Como se ve, no se utiliza el operador new para crear objeto System.Int32, sino que directamente se indica el literal que representa el valor a crear, con lo que la sintaxis necesaria para crear entero de este tipo se reduce considerablemente. Es más, dado lo frecuente que es el uso de este tipo también se ha predefinido en C# el alias int para el mismo, por lo que la definición de variable anterior queda así de compacta:

int a = 2;

System.Int32 no es el único tipo de dato básico incluido en C#. En el espacio de nombres System se han incluido todos estos:

Tipo Descripción Bits Rango de valores Alias SByte Bytes con signo 8 [-128, 127] Sbyte Byte Bytes sin signo 8 [0, 255] byte Int16 Enteros cortos con signo 16 [-32.768, 32.767] short UInt16 Enteros cortos sin signo 16 [0, 65.535] Ushort

Int32 Enteros normales 32 [-2.147.483.648, 2.147.483.647] Int



UInt32 Enteros normales sin signo 32 [0, 4.294.967.295] uint

Int64 Enteros largos 64 [-9.223.372.036.854.775.808,

9.223.372.036.854.775.807] long

UInt64 Enteros largos sin signo 64 [0-18.446.744.073.709.551.615] Ulong

Single Reales con 7 dígitos de precisión 32 [1,5×10-45 - 3,4×1038] Float

Double Reales de 15-16 dígitos de precisión 64 [5,0×10-324 - 1,7×10308] Doublé

Decimal Reales de 28-29 dígitos de precisión 128 [1,0×10-28 - 7,9×1028] Decimal

Boolean Valores lógicos 32 true, false Bool Char Caracteres Unicode 16 [‘\u0000’, ‘\uFFFF’] Char String Cadenas de caracteres Variable El permitido por la memoria String Object Cualquier objeto Variable Cualquier objeto Object

Literales

Un literal es la representación explícita de los valores que pueden tomar los tipos básicos del lenguaje. A continuación se explica cuál es la sintaxis con que se escriben los literales en C# desglosándolos según el tipo de valores que representan:

• Literales enteros: Un número entero se puede representar en C# tanto en formato decimal como hexadecimal. En el primer caso basta escribir los dígitos decimales (0-9) del número unos tras otros, mientras que en el segundo hay que preceder los dígitos hexadecimales (0-9, a-f, A-F) con el prefijo 0x. En ambos casos es posible preceder el número de los operadores + ó – para indicar si es positivo o negativo, aunque si no se pone nada se considerará que es positivo. Ejemplos de literales enteros son 0, 5, +15, -23, 0x1A, -0x1a, etc

En realidad, la sintaxis completa para la escritura de literales enteros también puede incluir un sufijo que indique el tipo de dato entero al que ha de pertenecer el literal. Esto no lo veremos hasta el Tema 7: Variables y tipos de datos.

• Literales reales: Los números reales se escriben de forma similar a los enteros, aunque sólo se pueden escribir en forma decimal y para separar la parte entera de la real usan el tradicional punto decimal (carácter .) También es posible representar los reales en formato científico, usándose para indicar el exponente los caracteres e ó E. Ejemplos de literales reales son 0.0, 5.1, -5.1, +15.21, 3.02e10, 2.02e-2, 98.8E+1, etc.

Al igual que ocurría con los literales enteros, los literales reales también pueden incluir sufijos que indiquen el tipo de dato real al que pertenecen.



• Literales lógicos: Los únicos literales lógicos válidos son true y false, que respectivamente representan los valores lógicos cierto y falso.

• Literales de carácter: Prácticamente cualquier carácter se puede representar encerrándolo entre comillas simples. Por ejemplo, 'a' (letra a), ' ' (carácter de espacio), '?' (símbolo de interrogación), etc. Las únicas excepciones a esto son los caracteres que se muestran en la Tabla 4.1, que han de representarse con secuencias de escape que indiquen su valor como código Unicode o mediante un formato especial tal y como se indica a continuación:

Carácter Código de escape Unicode Código de escape especial Comilla simple \u0027 \' Comilla doble \u0022 \" Carácter nulo \u0000 \0 Alarma \u0007 \a Retroceso \u0008 \b Salto de página \u000C \f Nueva línea \u000A \n Retorno de carro \u000D \r Tabulación horizontal \u0009 \t Tabulación vertical \u000B \v Barra invertida \u005C \\

Identificadores

Al igual que en cualquier lenguaje de programación, en C# un identificador no es más que, como su propio nombre indica, un nombre con el que identificaremos algún elemento de nuestro código, ya sea una clase, una variable, un método, etc.

Típicamente el nombre de un identificador será una secuencia de cualquier número de caracteres alfanuméricos –incluidas vocales acentuadas y eñes- tales que el primero de ellos no sea un número. Por ejemplo, identificadores válidos serían: Arriba, caña, C3P0, áëÎò, etc; pero no lo serían 3com, 127, etc.

Sin embargo, y aunque por motivos de legibilidad del código no se recomienda, C# también permite incluir dentro de un identificador caracteres especiales imprimibles tales como símbolos de diéresis, subrayados, etc. siempre y cuando estos no tengan un significado especial dentro del lenguaje. Por ejemplo, también serían identificadores válidos, _barco_, c¨k y A·B; pero no C# (# indica inicio de directiva de preprocesador) o a!b (! indica operación lógica “not”)



Constantes

Las clases y las estructuras pueden declarar las constantes como miembros. Las constantes son valores que se conocen en tiempo de compilación y no cambian. (Para crear un valor constante que se inicializa en el tiempo de ejecución, utilice la palabra clave readonly.) Las constantes se declaran como campo utilizando la palabra clave const antes del tipo del campo. Las constantes se deben inicializar tal como se declaran. Por ejemplo:

C#

class Calendar1

{

public const int months = 12;

}

En este ejemplo, la constante months siempre será 12 y no se puede cambiar, ni siquiera puede hacerlo la propia clase. Las constantes tienen que ser de un tipo integral (sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool o string), una enumeración o una referencia a null.

Se pueden declarar varias constantes del mismo tipo al mismo tiempo, por ejemplo:

C#

class Calendar2

{

const int months = 12, weeks = 52, days = 365;

}

La expresión utilizada para inicializar una constante puede hacer referencia a otra constante siempre que no cree una referencia circular. Por ejemplo:

C#

class Calendar3

{

const int months = 12;



const int weeks = 52;

const int days = 365;

const double daysPerWeek = days / weeks;

const double daysPerMonth = days / months;

}

Las constantes se pueden marcar como public, private, protected, internal o protectedinternal. Estos modificadores de acceso definen cómo los usuarios de la clase pueden tener acceso a la constante.

Es posible tener acceso a las constantes como si fueran campos estáticos, aunque no pueden utilizar la palabra clave static. Las expresiones que no están contenidas dentro de la clase que define la constante deben usar el nombre de la clase, un punto y el nombre de la constante para tener acceso a la constante. Por ejemplo:

C#

int birthstones = Calendar.months;

C# NET DECLARACION Y TIPO DE VARIABLES A toda variable que se use en un programa, se deberá declarar de preferencia al principio del programa.



En particular cada tipo de dato que se menciona aquí es en realidad un OBJETO, que se deriva a su vez de una clase que provee el framework de microsoft net es por eso que se incluye la clase de la cual proviene el tipo de dato.

Es decir en un programa se podrá declarar una variable por ejemplo float pi; o tambien se podra declarar y crear un objeto derivado de esa clase, por ejemplo System.Float alfa = new System.Float(); para este caso observar y tener en cuenta dos cosas:

Observar como se declara y crea un objeto (este formato de creación de objetos aprenderlo bien).

Como objeto alfa podrá usar todas las propiedades y métodos asociadas al objeto. Signed significa que se puede usar el signo + o - al usar la variable.

Por último variables strings o variables cadena, se podrán crear usando la clase STRING que creara un objeto de dicho tipo.

Para declarar un variable en un script o programa solo usar el siguiente formato:

Tipo de dato lista de variables ; ejemplo:

string nombre, ciudad;

int alfa, beta;

string ciudad=“tijuana”;

float pi=3.1416;

OPERADORES ARITMÉTICOS:

Los operadores aritméticos incluidos en C# son los típicos de

• Suma (+) • Resta (-) • Producto (*) • División (/) • Módulo (%)

También se incluyen operadores de "menos unario" (-) y "más unario" (+) Relacionados con las operaciones aritméticas se encuentran un par de operadores llamados checked y unchecked que permiten controlar si se desea detectar los desbordamientos que puedan producirse si al realizar este tipo de operaciones el



resultado es superior a la capacidad del tipo de datos de sus operandos. Estos operadores se usan así: checked (<expresiónAritmética>) unchecked(<expresiónAritmética>) Ambos operadores calculan el resultado de <expresiónAritmética> y lo devuelven si durante el cálculo no se produce ningún desbordamiento. Sin embargo, en caso de que haya desbordamiento cada uno actúa de una forma distinta: checked provoca un error de compilación si <expresiónAritmética> es una expresión constante y una excepción System.OverflowException si no lo es, mientras que unchecked devuelve el resultado de la expresión aritmética truncado para modo que quepa en el tamaño esperado. Por defecto, en ausencia de los operadores checked y unchecked lo que se hace es evaluar las operaciones aritméticas entre datos constantes como si se les aplicase checked y las operaciones entre datos no constantes como si se les hubiese aplicado unchecked.

OPERADORES RELACIONALES:

Se han incluido los tradicionales operadores

• Igualdad (==) • Desigualdad (!=) • "mayor que" (>) • "menor que" (<) • "mayor o igual que" (>=) • "menor o igual que" (<=)

OPERADORES LÓGICOS:

Se incluyen operadores que permiten realizar las operaciones lógicas típicas:



• "and" (&& y &) • "or" (|| y |) • "not" (!) • "xor" (^)

Los operadores && y || se diferencia de & y | en que los primeros realizan evaluación perezosa y los segundos no. La evaluación perezosa consiste en que si el resultado de evaluar el primer operando permite deducir el resultado de la operación, entonces no se evalúa el segundo y se devuelve dicho resultado directamente, mientras que la evaluación no perezosa consiste en evaluar siempre ambos operandos. Es decir, si el primer operando de una operación && es falso se devuelve false directamente, sin evaluar el segundo; y si el primer operando de una || es cierto se devuelve true directamente, sin evaluar el otro.

Operadores unuarios.

Son los que realizan una operación sobre una única expresión a cualquiera de los tipos de datos numéricos.

+, -, ~, ++, --, (T).

Operadores a nivel de bits.

Son los que utilizan, And (&), or (|), not (~), xor(^), desplazamiento a la izquierda(<<) y el desplazamiento a la derecha(>>).

Operaciones de asignación

Para realizar asignaciones se usa en C# el operador =, operador que además de realizar la asignación que se le solicita devuelve el valor asignado.

(el operador = es asociativo por la derecha).

Existen también las asignaciones compuestas que son las sig.

+=, -=, *=, /=, %=, &=, |=, ^=, <<= y >>=.



Operador condicional

Devuelve uno de dos valores según el valor de una expresión. Este es el único operador que toma 3 operandos y se usa asi:

<Condicion> .? <expresión>: <expresión>

PRIORIDAD Y ORDEN DE EVALUACION

Los operandos pueden ser nombres que denoten objetos variables o constantes, funciones, literales de cualquier tipo adecuado de acuerdo con los operadores u otras expresiones más simples.

Las expresiones se evalúan de acuerdo con la precedencia de los operadores. Ante una secuencia de operadores de igual precedencia, la evaluación se realiza según el orden de escritura, de izquierda a derecha. El orden de evaluación puede modificarse usando paréntesis.

Normalmente, las expresiones con operadores se evalúan de izquierda a derecha, aunque no todos, ciertos operadores que se evalúan y se asocian de derecha a izquierda. Además no todos los operadores tienen la misma prioridad, algunos se evalúan antes que otros, de hecho, existe un orden muy concreto en los operadores en la evaluación de expresiones. Esta propiedad de los operadores se conoce como precedencia o prioridad.

El compilador de C# tiene designado cuales signos operadores va tener mas prioridad y como se van a ejecutar si en una expresión se encuentran varios signos, a continuación se describen los signos y su prioridad poniendo primero el que es de mayor a menor. OPERADORES En la tabla siguiente se resumen todos los operadores, en orden de prioridad de mayor a menor:

Categoría Operadores

Principal x.y f(x) a[x] x++ x-- ne

Unario + - ! ~ ++x --x (T)x

Multiplicativo * / %

Sumatorio + -



Desplazamiento << >>

Comprobación de tipos y relacionales

< > <= >= is as

Igualdad == !=

AND lógico &

XOR lógico ^

OR lógico |

AND condicional &&

OR condicional ||

Condicional ?:

Asignación = *= /= %= += -= <<= >>= &= ^= |=

Todos los operadores son evaluados de izquierda a derecha

Cuando un operando se encuentra entre dos operadores con igual grado de prioridad, la asociatividad de los operadores controla el orden en que se ejecutan las operaciones.

• A excepción de los operadores de asignación, todos los operadores binarios son asociativos por la izquierda, lo que significa que las operaciones se realizan de izquierda a derecha. Por ejemplo, x + y + z se evalúa como (x + y) + z.

• Los operadores de asignación y el operador condicional (?:) son asociativos por la derecha, lo que significa que las operaciones se ejecutan de derecha a izquierda. Por ejemplo, x = y = z se evalúa como x = (y = z).

La precedencia y asociatividad pueden controlarse mediante el uso de paréntesis. Por ejemplo, x + y * z primero multiplica y por z y después suma el resultado a x, pero (x + y) * z primero suma x e y, y después multiplica el resultado por z.



Sentencias en C# Las sentencias pueden ocupar más de una línea y deben terminarse con un ;

Grupos de sentencias se pueden agrupar en bloques con { y }

E.j:

int i, j;

// un sentencia simple

i=1;

// un bloque de sentencias

{

j=2;

i=i+j;

} Sentencia if sirve para saltar en base a una condición:

if (i<5) // una sentencia sólo parte if

System.Console.WriteLine("i < 5");

if (i<5) // una sentencia con parte if y else

System.Console.WriteLine("i<5");

else

System.Console.WriteLine("i>=5);

Do while



Sirve para repeticiones de sentencia que se ejecutan al menos una vez:

int i=1;

do

System.Console.WriteLine(i++);

While (i<=5);

while, para repeticiones de 0 a N veces

int i=1;

While (i<=5)

System.Console.WriteLine(i++);

Ciclo for Se usa cuando el número de repeticiones se conoce a priori

for (int i=1; i<=5; i++)

System.Console.WriteLine(i); // Visualiza digitos 1 a 5

//La primera expresión es de inicialización, declara un entero

//La segunda la condición del bucle

//La tercera es la expresión del iterador

Un bucle infinito se podría codificar como:

for (;;) {

// bucle infinito

... }

Se pueden insertar múltiples expresiones:

for (int i=1, j=2; i<=5; i++, j+=2) {

System.Console.WriteLine("i=" + i + ", j=" + j);



}

continue, se usa para saltar el resto de la iteración y comenzar la siguiente

for (int i=1; i<=5; i++) {

if (i==3)

continue;

System.Console.WriteLine(i);

}

break se usa para salir de un bucle:

for (int i=1; i<=5; i++) {

if (i==3)

break;


} Switch Sirve para seleccionar entre múltiples opciones posibles

uint i=2;

switch(i) {

case 0:

goto case 2; // para permitir varios casos usar goto

case 1:

goto case 2;

case 2:

System.Console.WriteLine("i<3");

break; // el uso de goto o break es obligatorio



case 3:

System.Console.WriteLine("i==3"),

break;

default:

System.Console.WriteLine("i>3");

break;

} foreach Representa un interesante caso para iterar sobre un array:

int[] arr = {2, 4, 6, 8};

foreach (int i in arr) // Visualizará 2, 4, 6 y 8


goto transfiere control a una instrucción que contiene una etiqueta

throw sirve para lanzar una excepción

if (val > max) throw new Exception("Valor excede máximo");

Métodos Los métodos acceptan parámetros y devuelven un resultado

int Add(int x, int y) {

return x+y;

}

Los parámetros x e y se pasan por valor, se recibe una copia de ellos



Si queremos modificar dentro de una función un parámetro y que el cambio se refleje en el código de invocación de la función, usaremos ref, tanto en la declaración del método como en su invocación.

El método Main ()

Cada aplicación de C# debe contener un método Main único, que especifique dónde debe comenzar la ejecución del programa. En C#, Main se pone en mayúsculas, mientras que Java utiliza main en minúscula.

Main puede devolver sólo int o void y tiene un argumento de matriz de cadena opcional para representar parámetros de línea de comandos:

Namespaces • System

• System.CodeDom

• System.CodeDom.Compiler

• System.Collections

• System.Collections.Specialized

• System.ComponentModel

• System.ComponentModel.Design

• System.ComponentModel.Design.Serialization

• System.Configuration

• System.Configuration.Assemblies

• System.Data

• System.Data.Common

• System.Data.Odbc

• System.Data.OleDb

• System.Data.SqlClient

• System.Data.SqlTypes

• System.Design

• System.Diagnostics

• System.Diagnostics.Design



• System.Diagnostics.SymbolStore

• System.Drawing

• namespace Autos1 • { • public class Mustang • { • • • //··· • //··· • } • • public class VW_Escarabajo • { • • //··· • //··· • } • } • • • namespace Autos2 • { • • public class Mustang • { • • • //··· • //··· • } • • public class VW_Escarabajo • { • • • //··· • //··· • } • } • using Autos1 • '... • '... • • Sub Main() • Mustang ObjAuto1 = New Mustang • '... • End Sub

fund a mentos dec sharp

Documents