Universidad Abierta y a

Distancia de México
Ing. En Desarrollo de Software

Programación Net I.
Unidad 1: Introducción a NET I.
Actividad 2: Tipos de datos y operadores.
Presenta:
David Cruz Orozco
Imparte:
ELVIA SANCHEZ MAGADAN
Matricula:
ES1821004574
Contenido
Introducción ..................................................................................................................................................2
Instrucciones ..................................................................................................................................................2
1. Identifica los tipos de datos manejados por C# y explica su definición, rango de valores y
características. ...........................................................................................................................................2
2. Identifica los operadores aritméticos, lógicos y relacionales y explica su definición,
funcionalidad y características. ................................................................................................................ 3
3. Identifica las conversiones, explícitas e implícitas que puedes realizar .....................................5
4. Ejemplifica la aplicación de los tipos de datos en la declaración de variables y la utilización
de los operadores aritméticos, relacionales y lógicos mediante segmentos de código, así como la
relación entre las conversiones explícitas e implícitas. .........................................................................7
Fuentes .......................................................................................................................................................... 8
Introducción
Identificar los tipos de datos y operadores manejados por el lenguaje de
programación C#, para conocer sus características y forma de aplicación,
mediante segmentos de código. Después de analizar los mecanismos para la
conversión entre los diversos tipos de datos, su sintaxis y restricciones, sigue
estos pasos:

Instrucciones
1. IDENTIFICA LOS TIPOS DE DATOS MANEJADOS POR C# Y EXPLICA SU
DEFINICIÓN, RANGO DE VALORES Y CARACTERÍSTICAS.
Los tipos de datos se clasifican de la siguiente manera:

▪ Datos de tipo entero.

▪ Datos de tipo cadena.
▪ Datos de tipo carácter.
▪ Datos de tipo punto flotante.

Los tipos de datos en C# se clasifican en:

▪ Tipos valor.
▪ Tipos referencia.

Clase .NET Tipo Ancho Intervalo (bits)

Byte Entero sin signo 8 0 a 255
SByte Entero con 8 -128 a 127
signo
Int32 Entero con 32 -2.147.483.648 a
signo 2.147.483.647
UInt32 Entero sin signo 32 0 a 4294967295
 Int16 Entero con 16 -32.768 a 32.767
signo
UInt16 Entero sin signo 16 0 a 65535
Int64 Entero con 64 -922337203685477508
signo a 922337203685477507
UInt64 Entero sin signo 64 0a
18446744073709551615
Single Tipo de punto 32
flotante de -3,402823e38 a
precisión simple 3,402823e38
Double Tipo de punto 64 1,79769313486232e308
flotante de a
precisión doble 1,79769313486232e308
Char Un carácter 16 Símbolos Unicode
Unicode utilizados en el texto
Boolean Tipo Boolean 8 True o false
lógico
Object Tipo base de
todos los otros
tipos
String Una secuencia
de caracteres
Decimal Tipo preciso 128 ±1.0 × 10e−28 a ±7.9 ×
fraccionario o 10e28
integral, que
puede
representar
números
decimales con
29 dígitos
significativos

2. IDENTIFICA LOS OPERADORES ARITMÉTICOS, LÓGICOS Y RELACIONALES Y

EXPLICA SU DEFINICIÓN, FUNCIONALIDAD Y CARACTERÍSTICAS.
C# proporciona una serie de operadores compatibles con los tipos integrados.
Por ejemplo, los operadores aritméticos realizan operaciones aritméticas con
operandos numéricos, y los operadores lógicos booleanos realizan operaciones
lógicas con los operandos bool. Algunos operadores se pueden sobrecargar.
Con la sobrecarga de operadores, puede especificar el comportamiento del
operador para los operandos de un tipo definido por el usuario.

En una expresión, la prioridad y la asociatividad de los operadores determinan el

orden en el que se realizan las operaciones. Puede usar los paréntesis para
cambiar el orden de evaluación impuesto por la prioridad y la asociatividad de
operadores.

var a = 2 + 2 * 2;

Console.WriteLine(a);

Use paréntesis para cambiar el orden de evaluación impuesto por la prioridad de

los operadores:

var a = (2 + 2) * 2;

Console.WriteLine(a);

Operadores Categoría o nombre

x.y, x?.y, x?[y], f(x), a Principal
[i], x++, x--
, new, typeof, checke
d, unchecked, defaul
t, nameof, delegate,
sizeof, stackalloc, x-
>y
+x, -x, !x, ~x, ++x, -- Unario
x, ^x, (T)x, await, &x
, *x, true and false
x..y Intervalo
x * y, x / y, x % y Multiplicativo
x + y, x – y Aditivo
x << y, x >> y Shift
x < y, x > y, x <= Comprobación de tipos y relacional
y, x >= y, is, as
x == y, x != y Igualdad
x&y Operador lógico booleano AND u operador lógico bit a bit
AND
x^y Operador lógico booleano XOR u operador lógico bit a bit XOR
x|y Operador lógico booleano OR u operador lógico bit a bit OR
 x && y AND condicional
x || y OR condicional
x ?? y Operador de uso combinado de null
c?t:f Operador condicional
x = y, x += y, x -= Asignación y declaración lambda
y, x *= y, x /= y, x
%= y, x &= y, x |=
y, x ^= y, x <<= y, x
>>= y, x ??= y, =>

Operadores Númericos.

Tipo de Operador Operadores asociados

Cambio de signo -,+
Aritméticos +,-,*, /, %
Incremento y decremento ++, -

Operadores de Comparación

Operador Significado
> Mayor que
< Menor que
== Igual a
>= Mayor o igual que
<= Menor o igual que
!= Distinto que

3. IDENTIFICA LAS CONVERSIONES, EXPLÍCITAS E IMPLÍCITAS QUE PUEDES

REALIZAR

Conversiones de tipo implícitas:

Cuando una expresión contiene operandos de diferentes tipos integrados y no hay
conversiones explícitas presentes, el compilador utiliza conversiones estándar
integradas para convertir uno de los operandos de modo que coincidan con los
tipos. El compilador intenta las conversiones en una secuencia bien definida hasta
que una sea correcta.

No se requiere ninguna sintaxis especial porque la conversión tiene seguridad de

tipos y no se perderá ningún dato. Los ejemplos incluyen conversiones de tipos
enteros más pequeños a más grandes, y conversiones de clases derivadas a
clases base.
int num = 2147483647;
long bigNum = num;

El compilador de C# realiza automáticamente las conversiones implícitas.

Ejemplo:

int IntergerVariable;

long LongVAriable;

IntergerVariable = 123;

LongVariable = IntergerVariable;

En este código, a una variable de tipo entero se le asigna el valor 123 y a una
variable long se le asigna el valor de la variable de tipo entero. Cuando se ejecute
este código, el valor de LongVariable es 123.

El compilador de C# convierte el valor de la variable de tipo entero a un valor long

porque la conversión de un valor int a un valor long es una de las conversiones
implícitas permitidas por C#.

Conversiones de tipo explicitas:

Mediante una operación de conversión, puede indicar al compilador que convierta
un valor de un tipo a otro tipo. El compilador generará un error en algunos casos
si los dos tipos no tienen ninguna relación entre sí, pero en otros casos no
generará un error, aunque la operación no tenga seguridad de tipos.

Las conversiones explícitas requieren el operador de conversión (). La conversión

es necesaria si es posible que se pierda información en la conversión, o cuando
es posible que la conversión no sea correcta por otros motivos. Entre los ejemplos
típicos están la conversión numérica a un tipo que tiene menos precisión o un
intervalo más pequeño, y la conversión de una instancia de clase base a una clase
derivada.
double x = 1234.7;
int a;
// Cast double to int.
a = (int)x;
System.Console.WriteLine(a);

Si escribe código que intente convertir un valor que use tipo no administrados por
una conversión implícita, el compilador de C# genera un error, como muestra el
siguiente código:

char CharacterVariable;

int IntergerVariable;

IntergerVariable = 9;

CharacterVariable = IntergerVariable;

El compilador de C# produce el siguiente error:

error CS0029: No se puede convertir implícitamente el tipo 'int' a 'char'

Este error se produce porque ninguna conversión implícita admite la conversión

de una variable int a una variable char variable.

Si realmente necesita hacer esta conversión, tiene que realizar una conversión
explicita. Las conversiones explicitas se escriben en su código fuente y el dicen al
compilador "haz que se produzca esta conversión, aunque no pueda ser realizada
implícitamente".

4. EJEMPLIFICA LA APLICACIÓN DE LOS TIPOS DE DATOS EN LA

DECLARACIÓN DE VARIABLES Y LA UTILIZACIÓN DE LOS OPERADORES
ARITMÉTICOS, RELACIONALES Y LÓGICOS MEDIANTE SEGMENTOS DE
CÓDIGO, ASÍ COMO LA RELACIÓN ENTRE LAS CONVERSIONES EXPLÍCITAS
E IMPLÍCITAS.
int x = 123456;
long y = x; // implicita
short z = (short) x; // explicita (riesgo)

float f1 = 40.0F;
long l1 = (long) f1; // explicita (riesgo por redondeo)
short s1 = (short) l1; // explicita (riesgo por desbordamiento)
int i1 = s1; // implicita, no hay riesgo
uint i2 = (uint) i1; // explicita (riesgo de error por signo)

La relación que existe en las conversaciones de implícitas a explicitas es que para

poder hacer las conversiones de un valor de una variable sin que te de algún error,
se tiene que crear primero la conversión implícita.

Fuentes
• Introducción a Net I. (2015). Recuperado 27 enero 2020, desde
https://ceit.unadmexico.mx/contenidos/DCEIT/BLOQUE1/DS/05/DPRN1/U1/descarga
bles/Unidad%201.%20Introduccion%20a%20.NET.pdf
• Operadores de C#: referencia de C#. (2020). Recuperado 27 enero 2020, desde
https://docs.microsoft.com/es-es/dotnet/csharp/language-reference/operators/
• Conversiones de tipos: Guía de programación de C#. (2020). Recuperado 27 enero
2020, desde https://docs.microsoft.com/es-es/dotnet/csharp/programming-
guide/types/casting-and-type-conversions