PROGRAMACIÓN
.NET CORE C#
7 DE ENERO DE 2025
DANIEL ROMAN TERRAZAS
UNIVERSIDAD PRIVADA DOMINGO SAVIO
Contenido
Tipos de datos ............................................................................................................................ 2
Números.................................................................................................................................. 3
Integer Types ............................................................................................................................ 3
Int ......................................................................................................................................... 3
Tipos de Punto Flotante ......................................................................................................... 3
¿Cuándo usar float o double? .............................................................................................. 4
Cadenas (String) ...................................................................................................................... 5
Valores Booleanos (bool) en C#........................................................................................... 6
Operadores Aritméticos en C# ................................................................................................. 7
Operadores Relacionales en C# .......................................................................................... 9
Operadores Lógicos en C#................................................................................................. 10
1
Tipos de datos
Un tipo de datos especifica el tamaño y el tipo de valores de variables.
Es importante utilizar el tipo de datos correcto para la variable correspondiente;
para evitar errores, ahorrar tiempo y memoria, pero también hará que su código
sea más fácil de mantener y legible. Los tipos de datos más comunes son:
Data Type Size Description y rango
int 4 bytes -2,147,483,648 a 2,147,483,647
long 8 bytes -9,223,372,036,854,775,808 to
9,223,372,036,854,775,807
float 4 bytes Almacena números fraccionarios. Suficiente
para almacenar de 6 a 7 dígitos decimales
double 8 bytes Almacena números fraccionarios. Suficiente
para almacenar 15 dígitos decimales
bool 1 bit Almacena valores verdaderos o falsos
char 2 bytes Almacena un solo carácter/letra, entre comillas
simples.
string 2 bytes per Almacena una secuencia de caracteres, entre
character comillas dobles.
2
Números
Los tipos de números se dividen en dos grupos:
Tipos enteros: almacenan números enteros, positivos o negativos (como 123
o -456), sin decimales. Los tipos válidos son int y long. El tipo que debas usar
depende del valor numérico.
Tipos de punto flotante: representan números con una parte fraccionaria, que
contienen uno o más decimales. Los tipos válidos son float y double.
Integer Types
Int
El tipo de dato int puede almacenar números enteros desde -2147483648 hasta
2147483647. En general, y a lo largo de nuestro tutorial, el tipo de dato int será
el preferido cuando creemos variables con un valor numérico.
Long
El tipo de dato long puede almacenar números enteros desde -
9223372036854775808 hasta 9223372036854775807. Se utiliza cuando el tipo
int no es lo suficientemente grande para almacenar el valor. Ten en cuenta que
para indicar que se trata de un literal long, debes agregar una "L" al final del
valor:
Tipos de Punto Flotante
Los tipos de punto flotante se utilizan para representar números con decimales,
es decir, valores que tienen una parte entera y una parte decimal. Si necesitas
almacenar números con decimales, como 9.99 o 3.14515, deberás usar un tipo
de punto flotante.
En C#, existen dos tipos de punto flotante principales:
• float: Este tipo de dato puede almacenar números con decimales con
una precisión de aproximadamente 7 dígitos decimales significativos.
Para indicar que un literal es un float, debes agregar una "F" al final del
valor. Por ejemplo:
3
• double: Este tipo de dato ofrece mayor precisión que float, ya que
puede almacenar números con decimales con una precisión de
aproximadamente 15 dígitos decimales significativos. Para indicar que
un literal es un double, debes agregar una "D" al final del valor. Por
ejemplo:
¿Cuándo usar float o double?
En general, se recomienda utilizar float como el tipo de punto flotante
predeterminado debido a que ocupa menos memoria que double. Sin embargo,
si necesitas una mayor precisión en tus cálculos o estás trabajando con valores
muy grandes o muy pequeños, entonces deberías usar double.
Ten en cuenta:
• Agregar la "F" o "D" al final del valor es solo necesario cuando estás
asignando un literal directamente a una variable. Si realizas cálculos con
variables de tipo float o double, no necesitas agregar la "F" o "D".
• Aunque double ofrece mayor precisión, ten en cuenta que la precisión de
los números de punto flotante es finita. En algunos casos, puede haber
pequeñas inexactitudes en los cálculos debido a la forma en que se
almacenan estos números en la memoria de la computadora.
4
Cadenas (String)
Las cadenas de texto (strings) en C# representan secuencias de caracteres. Se
utilizan para almacenar y manipular datos de texto. A continuación, se detalla el
uso de cadenas de texto en C#:
Declaración e Inicialización de Cadenas:
• Puedes declarar una variable de cadena utilizando la palabra clave
string seguida del nombre de la variable.
• Para asignar un valor a una variable de cadena, se encierra el texto
entre comillas dobles ("").
Acceso a Caracteres Individuales:
• Las cadenas están indexadas desde cero, lo que significa que el primer
carácter tiene un índice de 0.
• Puedes acceder a caracteres individuales utilizando la notación de
corchetes [] con el índice del carácter dentro de la cadena.
Concatenación de Cadenas:
• Puedes combinar varias cadenas utilizando el operador +.
Longitud de la Cadena:
• La propiedad Length devuelve el número de caracteres en una cadena.
Métodos Comunes de Cadenas:
C# proporciona varios métodos para manipular cadenas:
5
• ToUpper() y ToLower(): Convierte la cadena a mayúsculas o
minúsculas, respectivamente.
• Trim(): Elimina los espacios en blanco iniciales y finales.
• IndexOf() y LastIndexOf(): Encuentra la primera o última aparición de
un carácter o subcadena dentro de la cadena.
• Contains(): Comprueba si existe una subcadena dentro de la cadena.
• StartsWith() y EndsWith(): Comprueba si la cadena comienza o
termina con una subcadena específica.
• Replace(): Reemplaza todas las ocurrencias de una subcadena con otra
cadena.
• Split(): Divide una cadena en una matriz de subcadenas según un
delimitador (por ejemplo, coma, espacio).
Ejemplo:
Valores Booleanos (bool) en C#
Los valores booleanos en C# representan valores lógicos que pueden ser true
(verdadero) o false (falso). Son fundamentales para tomar decisiones y
controlar el flujo del programa en base a ciertas condiciones.
Declaración e Inicialización de Variables Booleanas:
• Utiliza la palabra clave bool para declarar una variable booleana.
• Asigna true o false a la variable para inicializar su valor.
Uso de Expresiones Booleanas:
• Las expresiones booleanas combinan variables, operadores y valores
para evaluarse como true o false. Los operadores de comparación
válidos incluyen:
o == (igual a)
o != (diferente a)
o > (mayor que)
6
o < (menor que)
o >= (mayor o igual que)
o <= (menor o igual que)
• Los operadores lógicos combinan múltiples expresiones booleanas:
o && (Y): Ambas expresiones deben ser verdaderas para que el
resultado sea verdadero.
o || (O): Al menos una expresión debe ser verdadera para que el
resultado sea verdadero.
o ! (NO): Invierte el valor de una expresión simple.
Operadores Aritméticos en C#
Los operadores aritméticos en C# se utilizan para realizar operaciones
matemáticas con números. Estos operadores permiten sumar, restar,
multiplicar, dividir, obtener el resto de una división, e incluso realizar
operaciones más complejas como la potenciación.
Tipos de Operadores Aritméticos:
C# ofrece una variedad de operadores aritméticos que se pueden clasificar en
diferentes categorías:
7
Operadores básicos:
• Suma (+): Suma dos operandos.
• Resta (-): Resta el segundo operando del primero.
• Multiplicación (*): Multiplica dos operandos.
• División (/): Divide el primer operando por el segundo.
• Residuo (%): Obtiene el resto de la división del primer operando por el
segundo.
Operadores unarios:
• Negación (-): Invierte el signo del operando.
• Incremento (++): Incrementa el valor del operando en 1.
• Decremento (--): Decrementa el valor del operando en 1.
Operadores de potencia:
• Potenciación (^): Eleva el primer operando a la potencia del segundo.
Orden de Operaciones:
Es importante seguir el orden de operaciones al realizar cálculos con múltiples
operadores. El orden de precedencia predeterminado en C# es el siguiente:
1. Potenciación
2. Multiplicación y División (de izquierda a derecha)
3. Suma y Resta (de izquierda a derecha)
Para modificar el orden de evaluación, puedes utilizar paréntesis. Los
paréntesis se evalúan primero, seguidos del orden de precedencia normal.
Operadores Aritméticos Compuestos:
8
C# también proporciona operadores aritméticos compuestos que combinan una
operación aritmética con una asignación. Estos operadores permiten realizar
una operación y asignar el resultado a una variable en un solo paso.
• +=: Suma y asigna.
• -=: Resta y asigna.
• *=: Multiplica y asigna.
• /=: Divide y asigna.
• %=: Obtiene el residuo y asigna.
Operadores Relacionales en C#
Los operadores relacionales en C# se utilizan para comparar valores y
determinar si son iguales, diferentes, mayores que, menores que, mayores o
iguales que, o menores o iguales que. Estos operadores juegan un papel
crucial en las sentencias condicionales y expresiones lógicas, permitiéndote
tomar decisiones y controlar el flujo de tu programa en base a la comparación
de valores
Uso de Operadores Relacionales:
Los operadores relacionales se utilizan para comparar dos valores, dando
como resultado un valor booleano (verdadero o falso) que indica el resultado de
la comparación. Estos operadores se pueden usar en varios contextos,
incluyendo:
9
1. Sentencias Condicionales: Las sentencias condicionales como if, else
if y switch utilizan operadores relacionales para evaluar condiciones y
determinar qué bloques de código se ejecutan.
2. Expresiones Lógicas: Las expresiones lógicas combinan múltiples
operadores relacionales usando operadores lógicos (Y, O, NO) para
crear reglas de comparación más complejas.
3. Ordenar y Filtrar Datos: Los operadores relacionales se emplean en
algoritmos de ordenamiento y operaciones de filtrado de datos para
organizar o seleccionar datos según criterios específicos.
Operadores Lógicos en C#
Los operadores lógicos en C# se utilizan para combinar dos o más expresiones
booleanas en una sola expresión booleana más compleja. Estos operadores
permiten crear reglas de decisión más elaboradas y controlar el flujo del
programa con mayor precisión.
Tipos de Operadores Lógicos:
C# ofrece tres operadores lógicos fundamentales:
1. AND (&&): La conjunción lógica. Devuelve true solo si ambas
expresiones booleanas son true.
2. OR (||): La disyunción lógica. Devuelve true si al menos una de las
expresiones booleanas es true.
3. NOT (!): La negación lógica. Invierte el valor de la expresión booleana a
la que se aplica.
10
