Console.WriteLine("******************CARATULA****************");
Console.WriteLine("***NOMBRE:"); Console.WriteLine(" MERCY LOPEZ");
Console.WriteLine("***ASIGNATURA:"); Console.WriteLine("
PROGRAMACION .NET"); Console.WriteLine("***COLEGIO:");
Console.WriteLine(" JBV");
Console.WriteLine("***PROFESOR:"); Console.WriteLine(" ING. JUAN
ESPINOZA"); Console.WriteLine("");
Console.WriteLine("****************2013-2014****************");
//mayor de tres numeros
e igual de ellos mismos Console.WriteLine("***********Mayor e Igual de 3
Numeros************"); int numero1, numero2, numero3, mayor, igual;
//ingresamos los tres numeros Console.Write("Ingrese Numero 1:");
numero1 = int.Parse(Console.ReadLine()); Console.Write("Ingrese Numero
2:"); numero2 = int.Parse(Console.ReadLine()); Console.Write("Ingrese
Numero 3:"); numero3 = int.Parse(Console.ReadLine()); //calculamos el
mayor if (numero1 > numero2 && numero1 > numero3) mayor =
numero1; else if (numero2 > numero1 && numero2 > numero3) mayor =
numero2; else mayor = numero3; //igual if (numero1 == numero2 &&
numero1 == numero3) igual = numero1; else if (numero2 == numero1 &&
numero2 == numero3) igual = numero2; else igual = numero3; //mostramos el mayor
e igual Console.WriteLine("El Mayor es :{0}", mayor);
Console.WriteLine("El igual es :{0}", igual); Console.Read()
TIPOS DE CONVERSIONES
Dado que a C# se le asignan tipos estáticos en
tiempo de compilación, después de declarar una variable, no se puede volver a
declarar ni tampoco utilizar para almacenar valores de otro tipo, a menos que
dicho tipo pueda convertirse en el tipo de la variable. Por ejemplo, no
existe conversión de un entero a una cadena arbitraria cualquiera. Por lo
tanto, después de declarar i como entero, no puede asignarle la cadena
"Hello", como se muestra en el código siguiente.
C#
int i;
i = "Hello"; // Error: "Cannot implicitly convert type 'string' to 'int'"
Sin embargo, en ocasiones puede que sea necesario
copiar un valor en un parámetro de método o variable de otro tipo.
Por ejemplo, puede que tenga una variable de
tipo entero que deba pasar a un método cuyo parámetro es de tipo double. O
bien, puede que necesite asignar una variable de clase a una variable de un
tipo de interfaz. Estos tipos de operaciones se denominan conversiones
de tipos. En C#, puede realizar los siguientes tipos de conversiones:
- Conversiones
implícitas: no
se requiere una sintaxis especial porque la conversión se realiza con
seguridad de tipos y no se perderán datos. Entre los ejemplos se
incluyen las conversiones de tipos enteros de menor a mayor y las
conversiones de clases derivadas en clases base.
- Conversiones
explícitas (conversiones de tipos): las conversiones explícitas requieren un
operador de conversión. La conversión se requiere cuando es posible
que se pierda información en el proceso o cuando esta puede no realizarse
correctamente por otras razones. Entre los ejemplos habituales se incluye
la conversión en un tipo con menor precisión o un intervalo menor, y la
conversión de una instancia de clase base en una clase derivada.
- Conversiones
definidas por el usuario: las conversiones definidas por el usuario se
realizan a través de métodos especiales que puede definir para habilitar
las conversiones explícitas e implícitas entre tipos personalizados que no
tienen una relación de clase base-clase derivada. Para obtener más
información, vea Operadores
de conversión (Guía de programación de C#).
- Conversiones
con clases auxiliares: para realizar conversiones entre tipos no
compatibles, como los enteros y los objetos System.DateTime,
o bien cadenas hexadecimales y matrices de bytes, puede utilizar la clase System.BitConverter,
la clase System.Convert y
los métodos Parse de los tipos numéricos integrados, como Int32.Parse.
En los tipos numéricos integrados, puede realizarse
una conversión implícita cuando el valor que se va a almacenar puede ajustarse
a la variable sin necesidad de truncamiento o redondeo. Por ejemplo, una
variable de tipo long (entero
de 8 bytes) puede almacenar cualquier valor que pueda almacenar a su vez un
elemento int (4
bytes en un equipo de 32 bits). En el ejemplo siguiente, el compilador
convierte implícitamente el valor de la derecha en un tipolong antes
de asignarlo a bigNum.
C#
// Implicit conversion. num long can
// hold any value an int can hold, and more!
int num = 2147483647;
long bigNum = num;
Para obtener una lista completa de todas las
conversiones numéricas implícitas, vea Tabla de
conversiones numéricas implícitas (Referencia de C#).
En los tipos de referencia, siempre existe una
conversión implícita desde una clase a cualquiera de sus interfaces o clases
base directas o indirectas. No se requiere una sintaxis especial, ya que
una clase derivada siempre contiene todos los miembros de una clase base.
Derived d = new Derived();
Base b = d; // Always OK.
Sin embargo, si no se puede realizar una conversión
sin riesgo de perder información, el compilador requiere que se realice una
conversión explícita, denominada conversión de tipo. Una
conversión de tipo es una manera de informar al compilador de forma explícita
de que pretende realizar la conversión y que está al tanto de que puede
producirse una pérdida de datos. Para realizar una conversión de tipo,
especifique entre paréntesis el tipo al que se va a aplicar dicha conversión
delante del valor o la variable que se va a convertir. El programa
siguiente convierte un tipo double a
un tipo int. El
programa no se compilará sin el operador de conversión de tipo.
C#
class Test
{
static void Main()
{
double x = 1234.7;
int a;
// Cast double
to int.
a = (int)x;
System.Console.WriteLine(a);
}
}
// Output: 1234
Para obtener una lista de las conversiones
numéricas explícitas permitidas, vea Tabla de
conversiones numéricas explícitas (Referencia de C#).
En los tipos de referencia, se requiere una
conversión explícita si debe convertir de un tipo base a un tipo derivado:
C#
// Create a new derived type.
Giraffe g = new Giraffe();
// Implicit conversion to base type is safe.
Animal a = g;
// Explicit conversion is required to cast back
// to derived type. Note: This will compile but will
// throw an exception at run time if the right-side
// object is not in fact a Giraffe.
Giraffe g2 = (Giraffe) a;
Una operación de conversión entre tipos de
referencia no cambia el tipo en tiempo de ejecución del objeto subyacente; solo
cambia el tipo del valor que se utiliza como referencia para ese objeto. Para
obtener más información, vea Polimorfismo
(Guía de programación de C#).
En algunas conversiones de tipos de referencia, el
compilador no puede determinar si será válida una conversión de tipo. Es
posible que una operación de conversión de tipo que se compila correctamente
provoque un error en tiempo de ejecución. Como se muestra en el ejemplo
siguiente, una conversión de tipo que origine un error en tiempo de ejecución
hará que se produzca una excepción InvalidCastException.
C#
class Animal
{
public void Eat() { Console.WriteLine("Eating."); }
public override string ToString()
{
return "I am an animal.";
}
}
class Reptile : Animal { }
class Mammal : Animal { }
class UnSafeCast
{
static void Main()
{
Test(new Mammal());
// Keep the
console window open in debug mode.
System.Console.WriteLine("Press any key to exit.");
System.Console.ReadKey();
}
static void Test(Animal a)
{
// Cause
InvalidCastException at run time
// because
Mammal is not convertible to Reptile.
Reptile r = (Reptile)a;
}
}
SINTAXIS DEL CONDICIONAL IF
Una instrucción if identifica
que sentencia se tiene que ejecutar en función del valor de una expresión Boolean. En
el ejemplo siguiente, la variableBooleanresult se establece en true y, a continuación,
se comprueba en la instrucción if. La salida es The condition is true.
C#
bool condition = true;
if (condition)
{
Console.WriteLine("The variable is set to true.");
}
else
{
Console.WriteLine("The variable is set to false.");
}
Puede ejecutar los ejemplos de este tema
colocándolos en el método de Main de una aplicación de
consola.
Una instrucción if en C# puede tomar dos
formas, como se muestra en el ejemplo siguiente.
C#
// if-else statement
if (condition)
{
then-statement;
}
else
{
else-statement;
}
// Next statement in the program.
// if statement without an else
if (condition)
{
then-statement;
}
// Next statement in the program.
En una instrucción if-else, si la
condición se evalúa como true, se ejecuta la sentencia then-statement. Si condition es false, else-statement ejecuta. Dado
que la condición (condition) no puede ser simultáneamente verdadera (true)
y falsa (false), las sentencias then-statement y else-statement de
una instrucción if-elsenunca pueden ejecutarse simultáneamente. Después
de then-statement o de las
ejecuciones de else-statement, el control se transfiere a la instrucción siguiente después de la
instrucción de if.
En una instrucción de if que no
incluya una instrucción de else, si condition es true, then-statement ejecuta. Si condition es false, el
control se transfiere a la instrucción siguiente después de la instrucción de if.
then-statement y else-statement pueden constar de una sola instrucción o varias instrucciones que
se agrega entre llaves ({}). Para una sola instrucción, las llaves
son opcionales pero recomendados.
La instrucción o instrucciones en then-statement y else-statement puede ser de
clase, incluso otra instrucción de if anidada dentro de la
instrucción original de if. En instrucciones anidadas de if,
cada cláusula de else pertenece a if último
que no tiene else correspondiente. En el ejemplo
siguiente, Result1 aparece si m > 10 y n > 20 se evalúan como true. Si m > 10 es true pero n > 20 es false, Result2 aparece.
C#
// Try with m = 12 and then with m = 8.
int m = 12;
int n = 18;
if (m > 10)
if (n > 20)
{
Console.WriteLine("Result1");
}
else
{
Console.WriteLine("Result2");
}
Si, en su lugar, se desea que Result2 aparezca
cuando (m > 10) es false, puede especificar que la asociación mediante las llaves
para establecer el inicio y el final de la instrucción anidada de if,
como se muestra en el ejemplo siguiente.
C#
// Try with m = 12 and then with m = 8.
if (m > 10)
{
if (n > 20)
Console.WriteLine("Result1");
}
else
{
Console.WriteLine("Result2");
}
Result2 aparece si la
condición (m > 10) evalúa en false.
No hay comentarios:
Publicar un comentario