C# es un lenguaje de programación moderno y orientado a objetos que fue creado por Microsoft. Se ejecuta en .NET Framework. C# está muy cerca de los lenguajes de programación C / C++ y Java . Fue desarrollado por Anders Hejlsberg y su equipo dentro de la iniciativa .NET aprobada por la Asociación Europea de Fabricantes de Computadoras (ECMA) y la Organización Internacional de Normalización (ISO). La primera versión de C# se lanzó en 2002 y la última versión es 8.0 lanzada en Septiembre de 2019. Antes de comenzar, debemos aprender sobre .NET Framework y Visual Studio.
Temas:
.NET Framework y sus componentes
.NET es un marco de software diseñado y desarrollado por Microsoft. Es una máquina virtual para compilar y ejecutar programas escritos en diferentes lenguajes como C#, VB.Net, etc. Se utiliza para desarrollar aplicaciones basadas en formularios, aplicaciones basadas en web y servicios web. La primera versión de .NET Framework fue la 1.0 que llegó en el año 2002 y la versión actual es la 4.7.1. .NET Framework admite más de 60 lenguajes de programación en los que C# y VB.Net son los principales lenguajes de programación. A continuación se muestran los componentes principales de .NET Framework
1. Common Language Runtime (CLR): CLR es el componente básico y de máquina virtual del .NETFramework. Es el entorno de tiempo de ejecución en .NET Framework el que ejecuta los códigos y ayuda a facilitar el proceso de desarrollo. Se encarga de gestionar la ejecución de los .NETprogramas independientemente de cualquier lenguaje de programación .NET. También ayuda en la administración del código, ya que el código que se dirige al tiempo de ejecución se conoce como código administrado y el código que no se dirige al tiempo de ejecución se conoce como código no administrado . Para leer más sobre CLR, puede leer el artículo Common Language Runtime (CLR)
2. Framework Class Library (FCL): es la colección de métodos y bibliotecas de clases orientadas a objetos reutilizables, etc., que se pueden integrar con CLR. También llamadas Asambleas. Es como los archivos de encabezado en C/C++ y los paquetes en java. Instalar .NETframework básicamente es la instalación de CLR y FCL en el sistema. Para leer más sobre esto, puede leer el artículo Biblioteca de clases de .NET Framework (FCL)
3. Lenguaje intermedio común: es un conjunto de instrucciones que son independientes de la plataforma y son generadas por el compilador específico del lenguaje a partir del código fuente. También se conoce como Microsoft Intermediate Language (MSIL). Para leer más sobre esto, puede leer el artículo Lenguaje intermedio común (CLI)
4. Garbage Collector (GC): la gestión automática de la memoria es posible gracias a Garbage Collection en .NET Framework. Cuando se crea un objeto de clase en tiempo de ejecución, se le asigna cierto espacio de memoria en la memoria del montón. Sin embargo, después de que todas las acciones relacionadas con el objeto se completan en el programa, el espacio de memoria asignado a él es un desperdicio ya que no se puede utilizar. En este caso, la recolección de elementos no utilizados es muy útil, ya que libera automáticamente el espacio de la memoria cuando ya no se necesita. La recolección de basura siempre funcionará en Managed Heap e internamente tiene un motor que se conoce como motor de optimización. Para leer más sobre esto, puede consultar el artículo Recolección de basura en .NET Framework .
5. Compilador Just-In-Time (JIT): el compilador Just-In-Time (JIT) es una parte de Common Language Runtime (CLR) en .NET que es responsable de administrar la ejecución de programas .NET independientemente de cualquier .NET lenguaje de programación. Un compilador específico del idioma convierte el código fuente al idioma intermedio. El compilador Just-In-Time (JIT) convierte este lenguaje intermedio en el código de máquina. Este código de máquina es específico del entorno informático en el que se ejecuta el compilador JIT. Para leer más sobre esto, puede leer el artículo ¿Qué es el compilador Just-In-Time (JIT) en .NET?
6. Código administrado: un código escrito para obtener los servicios de la ejecución del entorno de tiempo de ejecución administrado como CLR (Common Language Runtime) en .NET Framework se conoce como Código administrado. Siempre lo implementó el entorno de tiempo de ejecución administrado en lugar de ejecutarlo directamente el sistema operativo. Para leer más sobre esto, puede consultar el artículo Código administrado y Código no administrado en .NET .
7. Código no administrado: Un código que es ejecutado directamente por el sistema operativo se conoce como código no administrado. Siempre apuntó a la arquitectura del procesador y depende de la arquitectura de la computadora. Cuando se compila este código, siempre tiende a obtener una arquitectura específica y siempre se ejecuta en esa plataforma. Para leer más sobre esto, puede consultar el artículo Código administrado y Código no administrado en .NET .
Estudio visual
Visual Studio es un entorno de desarrollo integrado (IDE) desarrollado por Microsoft para desarrollar GUI (interfaz gráfica de usuario), consola, aplicaciones web, aplicaciones web, aplicaciones móviles, nube y servicios web, etc. Con la ayuda de este IDE, puede crear código administrado y código nativo. Utiliza las diversas plataformas de software de desarrollo de software de Microsoft, como la tienda de Windows, Microsoft Silverlight y la API de Windows, etc. No es un IDE específico del idioma, ya que puede usarlo para escribir código en C#, C++ , VB (Visual Basic), Python , JavaScript y muchos más lenguajes. Proporciona soporte para 36 lenguajes de programación diferentes. Está disponible tanto para Windows como para macOS. Para saber más sobre esto, puede consultar el artículo Familiarizarse con Visual Studio .
¿Por qué C#?
C# tiene muchas otras razones para ser popular y demandado. Algunas de las razones se mencionan a continuación:
- Fácil de comenzar: C# es un lenguaje de alto nivel, por lo que está más cerca de otros lenguajes de programación populares como C, C++ y Java y, por lo tanto, se vuelve fácil de aprender para cualquiera.
- Ampliamente utilizado para desarrollar aplicaciones web y de escritorio: C# se usa ampliamente para desarrollar aplicaciones web y aplicaciones de escritorio. Es uno de los lenguajes más populares que se utiliza en el escritorio profesional. Si alguien quiere crear aplicaciones de Microsoft, C# es su primera opción.
- Comunidad: cuanto más grande sea la comunidad, mejor será, ya que se desarrollarán nuevas herramientas y software para mejorarla. C# tiene una gran comunidad por lo que se realizan los desarrollos para que exista en el sistema y no se extinga.
- Desarrollo de juegos: C# se usa ampliamente en el desarrollo de juegos y seguirá dominando. C# se integra con Microsoft y, por lo tanto, tiene una gran audiencia objetivo. Las funciones de C#, como la recolección automática de basura, las interfaces, la orientación a objetos, etc., hacen de C# un popular lenguaje de desarrollo de juegos.
Aplicaciones
¿Cómo descargar e instalar C# en Windows?
Paso 1: Descargue la versión de la comunidad de Visual Studio
Paso 2: Ejecute el archivo .exe y siga las instrucciones para instalar Visual Studio Community Version en el sistema.
Paso 3: seleccione .Net Desktop Development de las opciones y haga clic para instalar en la esquina inferior derecha como se muestra a continuación:
Paso 4: ábralo y se le pedirá que inicie sesión por primera vez. El paso de inicio de sesión es opcional, por lo que se puede omitir.
Paso 5: El cuadro de diálogo aparecerá solo por primera vez y le pedirá que elija Configuración de desarrollo y tema de color. Una vez que seleccione las opciones requeridas, haga clic en la opción Iniciar Visual Studio como se muestra a continuación:
.
Paso 6: Para crear una nueva aplicación de consola usando C#, vaya a Archivo -> Nuevo -> Proyecto como se muestra a continuación
Paso 7: elija la aplicación de consola, escriba el nombre del proyecto y seleccione la ruta de ubicación para guardar los archivos del proyecto y luego haga clic en Aceptar como se muestra a continuación.
Paso 8: Después de hacer clic en Aceptar, aparecerá una plantilla predefinida y comenzará a escribir el código C#.
Hola Mundo! Programa
Hola Mundo! El programa es el programa más básico y el primero cuando te sumerges en un nuevo lenguaje de programación. Esto simplemente imprime Hello World! en la pantalla de salida. En C# , un programa básico consta de lo siguiente:
- Una declaración de espacio de nombres
- Declaración y definición de clase
- Miembros de clase (como variables, métodos, etc.)
- Método principal
- Declaraciones o Expresiones
Ejemplo:
// C# program to print Hello World!
using System;
// namespace declaration
namespace HelloWorldApp {
// Class declaration
class Geeks {
// Main Method
static void Main(string[] args)
{
// statement
// printing Hello World!
Console.WriteLine("Hello World!");
// To prevents the screen from
// running and closing quickly
Console.ReadKey();
}
}
}
Hello World!
En general, hay 3 formas de compilar y ejecutar un programa C# de la siguiente manera:
- Para usar un compilador de C# en línea: Puede usar varios IDE en línea . que se puede usar para ejecutar programas C# sin instalar.
- Uso del IDE de Visual Studio: Microsoft ha proporcionado una herramienta IDE (Entorno de desarrollo integrado) denominada Visual Studio para desarrollar aplicaciones utilizando diferentes lenguajes de programación como C#, VB (Visual Basic), etc. Para instalar y utilizar Visual Studio con fines comerciales, debe comprar una licencia de Microsoft. Para fines de aprendizaje (no comerciales), Microsoft proporcionó una versión gratuita de la comunidad de Visual Studio. Para aprender a ejecutar un programa en Visual Studio, puede consultar este .
- Uso de la línea de comandos: también puede usar las opciones de la línea de comandos para ejecutar un programa C#. Los pasos a continuación demuestran cómo ejecutar un programa C# en la línea de comandos en el sistema operativo Windows:
- Primero, abra un editor de texto como Notepad o Notepad++.
- Escriba el código en el editor de texto y guarde el archivo con la extensión .cs .
- Abra el cmd (Símbolo del sistema) y ejecute el comando csc para verificar la versión del compilador. Especifica si ha instalado un compilador válido o no. Puede evitar este paso si confirmó que el compilador está instalado.
- Para compilar el código, escriba csc filename.cs en cmd. Si su programa no tiene ningún error, creará un archivo filename.exe en el mismo directorio donde guardó su programa. Supongamos que guardó el programa anterior como hello.cs . Entonces escribirá csc hello.cs en cmd. Esto creará un hello.exe .
- Ahora tiene formas de ejecutar hello.exe . Primero, simplemente debe escribir el nombre del archivo, es decir, hola en el cmd y le dará la salida. En segundo lugar, puede ir al directorio donde guardó su programa y allí encontrará filename.exe . Simplemente tiene que hacer doble clic en ese archivo y le dará la salida.
Identificadores
En los lenguajes de programación, los identificadores se utilizan con fines de identificación. O en otras palabras, los identificadores son el nombre definido por el usuario de los componentes del programa. En C#, un identificador puede ser un nombre de clase, un nombre de método, un nombre de variable o una etiqueta.
Ejemplo:
public class GFG {
static public void Main ()
{
int x;
}
}
Aquí, el número total de identificadores presentes en el ejemplo anterior es 3 y los nombres de estos identificadores son:
- GFG: Nombre de la clase
- Principal: nombre del método
- x: nombre de la variable
Reglas para definir identificadores en C#:
Hay ciertas reglas válidas para definir un identificador de C# válido. Estas reglas deben seguirse, de lo contrario, obtendremos un error de tiempo de compilación.
- Los únicos caracteres permitidos para los identificadores son todos los caracteres alfanuméricos ( [AZ] , [az] , [0-9] ), ‘ _ ‘ (guion bajo). Por ejemplo, “geek@” no es un identificador de C# válido, ya que contiene el carácter especial ‘@’.
- Los identificadores no deben comenzar con dígitos ([0-9]). Por ejemplo, «123geeks» no es un identificador válido en C#.
- Los identificadores no deben contener espacios en blanco.
- No se permite el uso de identificadores como palabra clave a menos que incluyan @ como prefijo. Por ejemplo, @as es un identificador válido, pero “ as ” no lo es porque es una palabra clave.
- Los identificadores de C# permiten caracteres Unicode.
- Los identificadores de C# distinguen entre mayúsculas y minúsculas.
- Los identificadores de C# no pueden contener más de 512 caracteres.
- Los identificadores no contienen dos guiones bajos consecutivos en su nombre porque este tipo de identificadores se utilizan para la implementación.
Ejemplo:
// Simple C# program to illustrate identifiers
using System;
class GFG {
// Main Method
static public void Main()
{
// variable
int a = 10;
int b = 39;
int c;
// simple addition
c = a + b;
Console.WriteLine("The sum of two number is: {0}", c);
}
}
Producción:
The sum of two number is: 49
La siguiente tabla muestra los identificadores y las palabras clave presentes en el ejemplo anterior:
| Palabras clave | Identificadores |
|---|---|
| usando | GFG |
| público | Principal |
| estático | a |
| vacío | b |
| En t | C |
Palabras clave
Las palabras clave o palabras reservadas son las palabras en un idioma que se utilizan para algún proceso interno o representan algunas acciones predefinidas. Por lo tanto, no se permite el uso de estas palabras como nombres de variables u objetos. Hacer esto resultará en un error de tiempo de compilación .
Ejemplo:
// C# Program to illustrate the keywords
using System;
class GFG {
// Here static, public, void
// are keywords
static public void Main()
{
// here int is keyword
// a is identifier
int a = 10;
Console.WriteLine("The value of a is: {0}", a);
// this is not a valid identifier
// removing comment will give compile time error
// double int = 10;
}
}
Producción:
The value of a is: 10
Hay un total de 78 palabras clave en C#, como se muestra a continuación. Para leer más sobre esto, puede consultar el artículo Palabras clave en C# .
Variables
Una variable es un marcador de posición de la información que se puede cambiar en tiempo de ejecución. Y las variables permiten Recuperar y Manipular la información almacenada.
Sintaxis:
type variable_name = value; or type variable_names;
Ejemplo:
char var = 'h'; // Declaring and Initializing character variable int a, b, c; // Declaring variables a, b and c of int type
Características de las Variables:
- name: Debe ser un identificador válido. En el ejemplo anterior, var es un identificador válido.
- type : Define los tipos de información que se almacenarán en la variable. En el ejemplo anterior, char es un tipo.
- valor: Son los datos reales que se almacenarán en la variable. En el ejemplo anterior, ‘h’ es el valor.
Reglas para nombrar variables
- Los nombres de variables pueden contener las letras ‘a-z’ o ‘A-Z’ o los dígitos 0-9, así como el carácter ‘_’.
- El nombre de las variables no puede comenzar con un dígito.
- El nombre de la variable no puede ser ninguna palabra clave de C#, por ejemplo, int, float, null, String, etc.
Ejemplos:
- Nombres de variables válidos
int age; float _studentname;
- Nombres de variables no válidos
int if; // "if" is a keyword float 12studentname; // Cannot start with digit
Definición o declaración de una variable
Hay algunas reglas que deben seguirse al declarar variables:
- especificar su tipo (como int)
- especificar su nombre (como la edad)
- Puede proporcionar un valor inicial (como 17)
Ejemplo :
int geeks; float interest;
Inicializar variables
El término inicializar significa asignar algún valor a la variable. Básicamente, el uso real de las variables se encuentra en la parte de inicialización. En C#, cada tipo de datos tiene un valor predeterminado que se usa cuando no hay un valor establecido explícitamente para una variable determinada. La inicialización se puede hacer por separado o puede ser con declaración.
Ejemplo :
int y = 7; // Declaring and initializing the variable at same time int x; // Declaring variable x x = 5; // initializing x with value 5
Dos formas de inicialización:
- Inicialización del tiempo de compilación
- Inicialización del tiempo de ejecución
Para leer sobre esto, puede consultar el artículo Variables en C#
literales
Los valores fijos se denominan Literal . Literal es un valor que es utilizado por las variables. Los valores pueden ser enteros, flotantes o strings, etc.
// Here 100 is a constant/literal. int x = 100;
Los literales pueden ser de los siguientes tipos:
- Literales enteros
- Literales de coma flotante
- Literales de caracteres
- Literales de string
- Literales nulos
- Literales booleanos
Ejemplo:
// C# program to illustrate the use of Literals
using System;
class Geeks {
// Main method
public static void Main(String[] args)
{
// decimal-form literal
int a = 101;
// floating-point literal
double b = 101.230;
Console.WriteLine(a);
Console.WriteLine(b);
// character literal within single quote
char ch = 'a';
// Unicode representation
char c = '\u0061';
Console.WriteLine(ch);
Console.WriteLine(c);
// Escape character literal
Console.WriteLine("Hello\n\nGeeks\t!");
}
}
Producción:
101 101.23 a a Hello Geeks !
Para saber más sobre los literales, puede consultar el artículo Literales en C#
Tipos de datos
Los tipos de datos especifican el tipo de datos que puede contener una variable de C# válida. C# es un lenguaje de programación fuertemente tipado porque en C# , cada tipo de datos (como enteros, caracteres, flotantes, etc.) está predefinido como parte del lenguaje de programación y todas las constantes o variables definidas para un programa determinado deben describirse con uno de los tipos de datos. En C#, los tipos de datos se dividen en 3 categorías, como se muestra a continuación:
1. Tipos de datos de valor: en C# , los tipos de datos de valor almacenarán directamente el valor de la variable en la memoria y también aceptarán literales con y sin signo. La clase derivada para estos tipos de datos es System.ValueType . Los siguientes son diferentes tipos de datos de valor en el lenguaje de programación C#
- Tipos integrales con signo y sin signo
- Tipos de punto flotante
- Tipos decimales
- Tipos de caracteres
- Tipos booleanos
Ejemplo 1:
// C# program to demonstrate
// the above data types
using System;
namespace ValueTypeTest {
class GeeksforGeeks {
// Main function
static void Main()
{
// declaring character
char a = 'G';
// Integer data type is generally
// used for numeric values
int i = 89;
short s = 56;
// this will give error as number
// is larger than short range
// short s1 = 87878787878;
// long uses Integer values which
// may signed or unsigned
long l = 4564;
// UInt data type is generally
// used for unsigned integer values
uint ui = 95;
ushort us = 76;
// this will give error as number is
// larger than short range
// ulong data type is generally
// used for unsigned integer values
ulong ul = 3624573;
// by default fraction value
// is double in C#
double d = 8.358674532;
// for float use 'f' as suffix
float f = 3.7330645f;
// for float use 'm' as suffix
decimal dec = 389.5m;
Console.WriteLine("char: " + a);
Console.WriteLine("integer: " + i);
Console.WriteLine("short: " + s);
Console.WriteLine("long: " + l);
Console.WriteLine("float: " + f);
Console.WriteLine("double: " + d);
Console.WriteLine("decimal: " + dec);
Console.WriteLine("Unsigned integer: " + ui);
Console.WriteLine("Unsigned short: " + us);
Console.WriteLine("Unsigned long: " + ul);
}
}
}
Producción :
char: G integer: 89 short: 56 long: 4564 float: 3.733064 double: 8.358674532 decimal: 389.5 Unsigned integer: 95 Unsigned short: 76 Unsigned long: 3624573
Ejemplo 2:
// C# program to demonstrate the
// boolean data type
using System;
namespace ValueTypeTest {
class GeeksforGeeks {
// Main function
static void Main()
{
// boolean data type
bool b = true;
if (b == true)
Console.WriteLine("Hi Geek");
}
}
}
Producción :
Hi Geek
2. Tipos de datos de referencia: los tipos de datos de referencia contendrán una dirección de memoria de valor variable porque los tipos de referencia no almacenarán el valor variable directamente en la memoria. Los tipos de referencia incorporados son string, objeto.
Ejemplo:
// C# program to demonstrate
// the Reference data types
using System;
namespace ValueTypeTest {
class GeeksforGeeks {
// Main Function
static void Main()
{
// declaring string
string a = "Geeks";
// append in a
a += "for";
a = a + "Geeks";
Console.WriteLine(a);
// declare object obj
object obj;
obj = 20;
Console.WriteLine(obj);
// to show type of object
// using GetType()
Console.WriteLine(obj.GetType());
}
}
}
Producción :
GeeksforGeeks 20 System.Int32
3. Tipo de datos de puntero: los tipos de datos de puntero contendrán una dirección de memoria del valor de la variable. Para obtener los detalles del puntero, tenemos dos símbolos ampersand (&) y asterisco (*) .
- ampersand (&) : se conoce como operador de dirección. Se utiliza para determinar la dirección de una variable.
- asterisco (*) : También conocido como Operador de Indirección. Se utiliza para acceder al valor de una dirección.
Sintaxis:
type* identifier;
Ejemplo :
int* p1, p; // Valid syntax int *p1, *p; // Invalid
Ejemplo:
// Note: This program will not work on
// online compiler
// Error: Unsafe code requires the `unsafe'
// command line option to be specified
// For its solution:
// Go to your project properties page and
// check under Build the checkbox Allow
// unsafe code.
using System;
namespace Pointerprogram {
class GFG {
// Main function
static void Main()
{
unsafe
{
// declare variable
int n = 10;
// store variable n address
// location in pointer variable p
int* p = &n;
Console.WriteLine("Value :{0}", n);
Console.WriteLine("Address :{0}", (int)p);
}
}
}
}
Para obtener un conocimiento profundo sobre los tipos de datos, puede leer el artículo Tipos de datos en C#
Operadores
Los operadores son la base de cualquier lenguaje de programación. Por lo tanto, la funcionalidad del lenguaje C# está incompleta sin el uso de operadores. Los operadores nos permiten realizar diferentes tipos de operaciones en los operandos . En C# , los operadores se pueden clasificar en función de sus diferentes funciones :
- Operadores aritméticos
- Operadores relacionales
- Operadores logicos
- Operadores bit a bit
- Operadores de Asignación
- Operador Condicional
En C#, los operadores también pueden categorizarse según el número de operandos:
- Operador unario: Operador que toma un operando para realizar la operación.
- Operador Binario: Operador que toma dos operandos para realizar la operación.
- Operador Ternario: Operador que toma tres operandos para realizar la operación.
Ejemplo:
// C# program to demonstrate
// the use of operators
using System;
class GFG {
// Main Function
static void Main(string[] args)
{
int result1, result4, result5;
bool result2, result3;
int x = 10, y = 5;
// Using Arithmetic operator
result1 = (x + y);
Console.WriteLine("Addition Operator: " + result1);
// Using Relation operator
result2 = (x == y);
Console.WriteLine("Equal to Operator: " + result2);
bool a = true, b = false;
// Using Logical Operator
result3 = a && b;
Console.WriteLine("AND Operator: " + result3);
// Using Bitwise Operator
result4 = x & y;
Console.WriteLine("Bitwise AND: " + result4);
// Using Assignment Operator
// initialize variable m
// using Simple Assignment
// Operator "="
int m = 15;
// it means m = m + 10
m += 10;
Console.WriteLine("Add Assignment Operator: " + m);
// Using Conditional Operator
// To find which value is greater
// Using Conditional Operator
result5 = x < y ? x : y;
// To display the result
Console.WriteLine("Result: " + result5);
}
}
Producción:
Addition Operator: 15 Equal to Operator: False AND Operator: False Bitwise AND: 0 Add Assignment Operator: 25 Result: 5
Para saber más sobre los operadores, puedes leer el artículo Operadores en C#
Enumeración
La enumeración (o enumeración) es un tipo de datos de valor en C#. Se utiliza principalmente para asignar nombres o valores de string a constantes integrales, que hacen que un programa sea fácil de leer y mantener. Por ejemplo, los 4 palos en una baraja de naipes pueden ser 4 enumeradores llamados Trébol, Diamante, Corazón y Pica, pertenecientes a un tipo enumerado llamado Palo. Otros ejemplos incluyen tipos enumerados naturales (como los planetas, días de la semana, colores, direcciones, etc.). El objetivo principal de enum es definir nuestros propios tipos de datos (Tipos de datos enumerados). La enumeración se declara usando la palabra clave enum directamente dentro de un espacio de nombres, clase o estructura.
Sintaxis:
enum Enum_variable
{
string_1...;
string_2...;
.
.
}
En la sintaxis anterior, Enum_variable es el nombre del enumerador, y string_1 se adjunta con el valor 0, string_2 se adjunta el valor 1 y así sucesivamente. Porque de forma predeterminada, el primer miembro de una enumeración tiene el valor 0 y el valor de cada miembro de enumeración sucesivo aumenta en 1. Podemos cambiar este valor predeterminado.
Ejemplo: Considere el siguiente código para la enumeración. Aquí se crea una enumeración con el nombre del mes y sus miembros de datos son el nombre de meses como enero, febrero, marzo, abril, mayo. Ahora intentemos imprimir los valores enteros predeterminados de estas enumeraciones. Se requiere una conversión explícita para convertir de un tipo de enumeración a un tipo integral.
// C# program to illustrate the enums
// with their default values
using System;
namespace ConsoleApplication1 {
// making an enumerator 'month'
enum month {
// following are the data members
jan,
feb,
mar,
apr,
may
}
class Program {
// Main Method
static void Main(string[] args)
{
// getting the integer values of data members
Console.WriteLine("The value of jan in month "
+ "enum is " + (int)month.jan);
Console.WriteLine("The value of feb in month "
+ "enum is " + (int)month.feb);
Console.WriteLine("The value of mar in month "
+ "enum is " + (int)month.mar);
Console.WriteLine("The value of apr in month "
+ "enum is " + (int)month.apr);
Console.WriteLine("The value of may in month "
+ "enum is " + (int)month.may);
}
}
}
The value of jan in month enum is 0 The value of feb in month enum is 1 The value of mar in month enum is 2 The value of apr in month enum is 3 The value of may in month enum is 4
Para leer más sobre esto, puede consultar el artículo Enum en C# .
Declaraciones de toma de decisiones
La toma de decisiones en la programación es similar a la toma de decisiones en la vida real. También en programación, un determinado bloque de código debe ejecutarse cuando se cumple alguna condición.
Un lenguaje de programación utiliza declaraciones de control para controlar el flujo de ejecución del programa en función de ciertas condiciones. Estos se utilizan para hacer que el flujo de ejecución avance y se bifurque en función de los cambios en el estado de un programa. Las principales sentencias condicionales de C#:
Ejemplo 1:
// C# program to illustrate if statement
using System;
public class GFG {
public static void Main(string[] args)
{
string name = "Geek";
if (name == "Geek") {
Console.WriteLine("GeeksForGeeks");
}
}
}
Producción:
GeeksForGeeks
Ejemplo 2:
// C# program to illustrate
// if-else-if ladder
using System;
class GFG {
public static void Main(String[] args)
{
int i = 20;
if (i == 10)
Console.WriteLine("i is 10");
else if (i == 15)
Console.WriteLine("i is 15");
else if (i == 20)
Console.WriteLine("i is 20");
else
Console.WriteLine("i is not present");
}
}
Producción:
i is 20
Declaración de cambio
En C#, la declaración Switch es una declaración de rama multidireccional. Proporciona una forma eficiente de transferir la ejecución a diferentes partes de un código en función del valor de la expresión. La expresión de cambio es de tipo entero, como int, char, byte o short, o de tipo enumeración, o de tipo string. La expresión se verifica para diferentes casos y se ejecuta la única coincidencia.
Sintaxis:
switch (expression) {
case value1: // statement sequence
break;
case value2: // statement sequence
break;
.
.
.
case valueN: // statement sequence
break;
default: // default statement sequence
}
Diagrama de flujo:
Puntos importantes a recordar:
- En C#, no se permiten valores de mayúsculas y minúsculas duplicados.
- El tipo de datos de la variable en el conmutador y el valor de un caso deben ser del mismo tipo.
- El valor de un caso debe ser una constante o un literal. No se permiten variables.
- La sentencia break in switch se usa para terminar la secuencia actual.
- La declaración predeterminada es opcional y se puede usar en cualquier lugar dentro de la declaración de cambio.
- No se permiten declaraciones predeterminadas múltiples.
Ejemplo:
// C# program to illustrate
// switch case statement
using System;
public class GFG {
// Main Method
public static void Main(String[] args)
{
int nitem = 5;
switch (nitem) {
case 1:
Console.WriteLine("case 1");
break;
case 5:
Console.WriteLine("case 5");
break;
case 9:
Console.WriteLine("case 9");
break;
default:
Console.WriteLine("No match found");
break;
}
}
}
case 5
Para obtener más información al respecto, puede consultar el artículo Declaración de cambio en C# .
Bucles
El bucle en un lenguaje de programación es una forma de ejecutar una declaración o un conjunto de declaraciones varias veces según el resultado de la condición que se evaluará para ejecutar declaraciones. La condición de resultado debe ser verdadera para ejecutar sentencias dentro de bucles. Los bucles se dividen principalmente en dos categorías:
- Bucles de Entrada Controlada: Los bucles en los que la condición a probar está presente al comienzo del cuerpo del bucle se conocen como Bucles de Entrada Controlada. while loop y for loop son bucles controlados por entrada.
- Bucles controlados de salida: los bucles en los que la condición de prueba está presente al final del cuerpo del bucle se denominan bucles controlados de salida . do-while es un bucle controlado por salida. En los bucles controlados por salida, el cuerpo del bucle se evaluará al menos una vez, ya que la condición de prueba está presente al final del cuerpo del bucle.
mientras bucle
La condición de prueba se da al comienzo del ciclo y todas las declaraciones se ejecutan hasta que la condición booleana dada se cumple. Cuando la condición se vuelve falsa, el control estará fuera del ciclo while.
Sintaxis:
while (boolean condition)
{
loop statements...
}
Diagrama de flujo:
Ejemplo:
// C# program to illustrate while loop
using System;
class whileLoopDemo {
public static void Main()
{
int x = 1;
// Exit when x becomes greater than 4
while (x <= 4) {
Console.WriteLine("GeeksforGeeks");
// Increment the value of x for
// next iteration
x++;
}
}
}
Producción:
GeeksforGeeks GeeksforGeeks GeeksforGeeks GeeksforGeeks
hacer mientras bucle
do while loop es similar a while loop con la única diferencia de que verifica la condición después de ejecutar las sentencias, es decir, ejecutará el cuerpo del bucle una vez porque verifica la condición después de ejecutar las sentencias.
Sintaxis:
do
{
statements..
}while (condition);
Diagrama de flujo:
Ejemplo:
// C# program to illustrate do-while loop
using System;
class dowhileloopDemo {
public static void Main()
{
int x = 21;
do {
// The line will be printed even
// if the condition is false
Console.WriteLine("GeeksforGeeks");
x++;
} while (x < 20);
}
}
Producción:
GeeksforGeeks
en bucle
for loop tiene una funcionalidad similar a while loop pero con una sintaxis diferente. Se prefieren los bucles for cuando se conoce de antemano el número de veces que se van a ejecutar las sentencias de bucle. La inicialización de la variable de bucle, la condición que se va a probar y el incremento/decremento de la variable de bucle se realizan en una línea en el bucle for, lo que proporciona una estructura de bucle más corta y fácil de depurar.
for (loop variable initialization ; testing condition;
increment / decrement)
{
// statements to be executed
}
Diagrama de flujo:
1. Inicialización de la variable de bucle: Aquí se inicializa la expresión/variable que controla el bucle. Es el punto de partida del bucle for. Se puede usar una variable ya declarada o se puede declarar una variable, solo local para bucle.
2. Condición de prueba: la condición de prueba para ejecutar sentencias de bucle. Se utiliza para probar la condición de salida de un bucle. Debe devolver un valor booleano verdadero o falso . Cuando la condición se vuelve falsa, el control estará fuera del ciclo y el ciclo finaliza.
3. Incremento/Decremento: La variable de lazo se incrementa/decrementa de acuerdo con el requisito y luego el control cambia a la condición de prueba nuevamente.
Nota: La parte de inicialización se evalúa solo una vez cuando se inicia el bucle for.
Ejemplo:
// C# program to illustrate for loop.
using System;
class forLoopDemo {
public static void Main()
{
// for loop begins when x=1
// and runs till x <=4
for (int x = 1; x <= 4; x++)
Console.WriteLine("GeeksforGeeks");
}
}
Producción:
GeeksforGeeks GeeksforGeeks GeeksforGeeks GeeksforGeeks
para cada bucle
El bucle foreach se utiliza para iterar sobre los elementos de la colección. La colección puede ser una array o una lista. Se ejecuta para cada elemento presente en la array.
- Es necesario encerrar las sentencias del bucle foreach entre llaves {}.
- En lugar de declarar e inicializar una variable de contador de bucle, declara una variable que es del mismo tipo que el tipo base de la array, seguida de dos puntos, que luego es seguida por el nombre de la array.
- En el cuerpo del ciclo, puede usar la variable de ciclo que creó en lugar de usar un elemento de array indexado.
Sintaxis:
foreach(data_type var_name in collection_variable)
{
// statements to be executed
}
Diagrama de flujo:
Ejemplo:
// C# program to illustrate the
// use of foreach loop
using System;
class GFG {
// Main Method
static public void Main()
{
Console.WriteLine("Print array:");
// creating an array
int[] a_array = new int[] { 1, 2, 3, 4, 5, 6, 7 };
// foreach loop begin
// it will run till the
// last element of the array
foreach(int items in a_array)
{
Console.WriteLine(items);
}
}
}
Print array: 1 2 3 4 5 6 7
Explicación: el bucle foreach en el programa anterior es equivalente a:
for(int items = 0; items < a_array.Length; items++)
{
Console.WriteLine(a_array[items]);
}
Para saber más sobre Loops puedes consultar los artículos
Salto de declaraciones
En C#, las instrucciones Jump se utilizan para transferir el control de un punto a otro del programa debido a algún código específico mientras se ejecuta el programa. Hay principalmente 4 palabras clave en las declaraciones de salto:
- descanso
- Seguir
- ir
- devolver
romper declaración
La instrucción break se utiliza para terminar el ciclo o la instrucción en la que se presenta. Después de eso, el control pasará a las sentencias que se presenten después de la sentencia break, si está disponible. Si la declaración de ruptura está presente en el bucle anidado, solo finaliza los bucles que contienen la declaración de ruptura.
Diagrama de flujo:
Ejemplo:
// C# program to illustrate the
// use of break statement
using System;
class Geeks {
// Main Method
static public void Main()
{
// GeeksforGeeks is printed only 2 times
// because of break statement
for (int i = 1; i < 4; i++) {
if (i == 3)
break;
Console.WriteLine("GeeksforGeeks");
}
}
}
GeeksforGeeks GeeksforGeeks
continuar declaración
Esta declaración se usa para saltarse la parte de ejecución del bucle en una determinada condición. Después de eso, transfiere el control al comienzo del bucle. Básicamente, omite las siguientes declaraciones y continúa con la siguiente iteración del ciclo.
Ejemplo:
// C# program to illustrate the
// use of continue statement
using System;
class Geeks {
// Main Method
public static void Main()
{
// This will skip 4 to print
for (int i = 1; i <= 10; i++) {
// if the value of i becomes 4 then
// it will skip 4 and send the
// transfer to the for loop and
// continue with 5
if (i == 4)
continue;
Console.WriteLine(i);
}
}
}
1 2 3 5 6 7 8 9 10
ir a declaración
Esta sentencia se utiliza para transferir el control a la sentencia etiquetada en el programa. La etiqueta es el identificador válido y se coloca justo antes de la declaración desde donde se transfiere el control.
Ejemplo:
// C# program to illustrate the
// use of goto statement
using System;
class Geeks {
// Main Method
static public void Main()
{
int number = 20;
switch (number) {
case 5:
Console.WriteLine("case 5");
break;
case 10:
Console.WriteLine("case 10");
break;
case 20:
Console.WriteLine("case 20");
// goto statement transfer
// the control to case 5
goto case 5;
default:
Console.WriteLine("No match found");
break;
}
}
}
case 20 case 5
declaración de devolución
Esta declaración finaliza la ejecución del método y devuelve el control al método de llamada. Devuelve un valor opcional. Si el tipo de método es nulo, entonces se puede excluir la declaración de devolución.
Ejemplo:
// C# program to illustrate the
// use of return statement
using System;
class Geeks {
// creating simple addition function
static int Addition(int a)
{
// add two value and
// return the result of addition
int add = a + a;
// using return statement
return add;
}
// Main Method
static public void Main()
{
int number = 2;
// calling addition function
int result = Addition(number);
Console.WriteLine("The addition is {0}", result);
}
}
The addition is 4
Para leer más sobre esto, puede consultar el artículo Saltar declaraciones en C#
arreglos
Una array es un grupo de variables del mismo tipo a las que se hace referencia con un nombre común. Y cada elemento de datos se llama un elemento de la array. Los tipos de datos de los elementos pueden ser cualquier tipo de datos válido como char, int, float, etc. y los elementos se almacenan en una ubicación contigua. La longitud de la array especifica el número de elementos presentes en la array. En C#, la asignación de memoria para las arrays se realiza de forma dinámica. Y las arrays son una especie de objetos, por lo tanto, es fácil encontrar su tamaño usando las funciones predefinidas. Las variables en la array están ordenadas y cada una tiene un índice que comienza en 0. Las arrays en C# funcionan de manera diferente a como lo hacen en C/C++. La siguiente figura muestra cómo la array almacena valores secuencialmente:
Explicación: el índice comienza desde 0, que almacena valor. también podemos almacenar un número fijo de valores en una array. El índice de la array se incrementará en 1 secuencialmente siempre que no alcance el tamaño de la array.
Ejemplo:
// C# program to creating an array
// of the string as week days, store
// day values in the weekdays,
// and prints each value.
using System;
namespace geeksforgeeks {
class GFG {
// Main Method
public static void Main()
{
// declares a 1D Array of string.
string[] weekDays;
// allocating memory for days.
weekDays = new string[] { "Sun", "Mon", "Tue", "Wed",
"Thu", "Fri", "Sat" };
// Displaying Elements of array
foreach(string day in weekDays)
Console.Write(day + " ");
}
}
}
Producción :
Sun Mon Tue Wed Thu Fri Sat
Para saber más sobre esto, puede consultar el artículo Arrays en C#
Cuerda
En C#, una string es una secuencia de caracteres Unicode o una array de caracteres. El rango de caracteres Unicode será de U+0000 a U+FFFF. La array de caracteres también se denomina texto. Entonces la string es la representación del texto. Una string es un concepto importante y la gente se confunde acerca de si la string es una palabra clave, un objeto o una clase. Así que aclaremos este concepto.
Una string está representada por la clase System.String . La palabra clave «string» es un alias para la clase System.String y, en lugar de escribir System.String, se puede usar String, que es una forma abreviada de clase System.String. Entonces podemos decir que string y String se pueden usar como un alias de la clase System.String. Entonces, la string es un objeto de la clase System.String.
Ejemplo:
string s1 = «GeeksforGeeks»; // creando la string usando la palabra clave string
String s2 = «GFG»; // creando la string usando la clase String
System.String s3 = «Pro Geek»; // creando la string usando la clase String
La clase String se define en la biblioteca de clases base de .NET . En otras palabras, un objeto String es una colección secuencial de objetos System.Char que representa una string. El tamaño máximo del objeto String en la memoria es de 2 GB o alrededor de mil millones de caracteres. La clase System.String es inmutable , es decir, una vez creada, su estado no puede modificarse.
Programa: para ilustrar cómo declarar la string e inicializar la string. Además, el siguiente programa muestra la declaración e inicialización de una string en una sola línea.
// C# program to declare string using
// string, String and System.String
// and initialization of string
using System;
class Geeks {
// Main Method
static void Main(string[] args)
{
// declare a string Name using
// "System.String" class
System.String Name;
// initialization of String
Name = "Geek";
// declare a string id using
// using an alias(shorthand)
// "String" of System.String
// class
String id;
// initialization of String
id = "33";
// declare a string mrk using
// string keyword
string mrk;
// initialization of String
mrk = "97";
// Declaration and initialization of
// the string in a single line
string rank = "1";
// Displaying Result
Console.WriteLine("Name: {0}", Name);
Console.WriteLine("Id: {0}", id);
Console.WriteLine("Marks: {0}", mrk);
Console.WriteLine("Rank: {0}", rank);
}
}
Name: Geek Id: 33 Marks: 97 Rank: 1
Para saber más sobre esto, puede consultar el artículo String en C#
Modificadores de acceso
Los modificadores de acceso son palabras clave que definen la accesibilidad de un miembro, clase o tipo de datos en un programa. Estos se utilizan principalmente para restringir la manipulación de datos no deseados por parte de programas o clases externos. Hay 4 modificadores de acceso (público, protegido, interno, privado) que definen los 6 niveles de accesibilidad de la siguiente manera:
- público
- protegido
- interno
- interno protegido
- privado
- privado protegido
La tabla de accesibilidad de estos modificadores se muestra a continuación:
| público | protegido | interno | interno protegido | privado | privado protegido | |
|---|---|---|---|---|---|---|
| Programa completo | Sí | No | No | No | No | No |
| Clase contenedora | Sí | Sí | Sí | Sí | Sí | Sí |
| Asamblea actual | Sí | No | Sí | Sí | No | No |
| tipos derivados | Sí | Sí | No | Sí | No | No |
| Tipos derivados dentro del ensamblaje actual | Sí | Sí | No | Sí | No | Sí |
Para saber más sobre esto, puede consultar el artículo Modificadores de acceso en C#
Programación orientada a objetos
La programación orientada a objetos tiene como objetivo implementar entidades del mundo real como herencia, ocultación, polimorfismo, etc. en la programación. El objetivo principal de OOP es unir los datos y las funciones que operan en ellos para que ninguna otra parte del código pueda acceder a estos datos excepto esa función.
Clase y Objeto
Clase y Objeto son los conceptos básicos de la Programación Orientada a Objetos que giran en torno a las entidades de la vida real. Una clase es un proyecto o prototipo definido por el usuario a partir del cual se crean objetos. Básicamente, una clase combina los campos y métodos (función miembro que define acciones) en una sola unidad. En C#, las clases admiten polimorfismo, herencia y también proporcionan el concepto de clases derivadas y clases base.
El objeto es una unidad básica de la programación orientada a objetos y representa las entidades de la vida real. Un programa típico de C# crea muchos objetos que, como sabe, interactúan invocando métodos.
Ejemplo:
// C# program to illustrate class and object concept
using System;
// Class Declaration
public class Dog {
// Instance Variables
String name;
String breed;
int age;
String color;
// Constructor Declaration of Class
public Dog(String name, String breed,
int age, String color)
{
this.name = name;
this.breed = breed;
this.age = age;
this.color = color;
}
// Property 1
public String getName()
{
return name;
}
// Property 2
public String getBreed()
{
return breed;
}
// Property 3
public int getAge()
{
return age;
}
// Property 4
public String getColor()
{
return color;
}
// Method 1
public String toString()
{
return ("Hi my name is " + this.getName()
+ ".\nMy breed, age and color are " + this.getBreed()
+ ", " + this.getAge() + ", " + this.getColor());
}
// Main Method
public static void Main(String[] args)
{
// Creating object
Dog tuffy = new Dog("tuffy", "papillon", 5, "white");
Console.WriteLine(tuffy.toString());
}
}
Producción:
Hi my name is tuffy. My breed, age, and color are papillon, 5, white
Para saber más sobre esto, puede consultar el artículo Clase y objeto en C# .
Constructores
Un constructor es un método especial de la clase que se invoca automáticamente cada vez que se crea una instancia de la clase. Al igual que los métodos, un constructor también contiene la colección de instrucciones que se ejecutan en el momento de la creación del objeto. Se utiliza para asignar valores iniciales a los miembros de datos de la misma clase.
Ejemplo:
// C# Program to illustrate the constructors
using System;
namespace ParameterizedConstructorExample {
class Geek {
// data members of the class.
String name;
int id;
// parameterized constructor would
// initialized data members with
// the values of passed arguments
// while object of that class created.
Geek(String name, int id)
{
this.name = name;
this.id = id;
}
// Main Method
public static void Main()
{
// This will invoke parameterized
// constructor.
Geek geek1 = new Geek("GFG", 1);
Console.WriteLine("GeekName = " + geek1.name + " and GeekId = " + geek1.id);
}
}
}
Producción:
GeekName = GFG and GeekId = 1
Para obtener más información sobre los constructores, puede consultar el artículo Constructores en C# .
Destructores
Los destructores en C# son métodos dentro de la clase que se usan para destruir instancias de esa clase cuando ya no se necesitan. El Destructor es llamado implícitamente por el recolector de basura de .NET Framework y, por lo tanto, el programador no tiene control sobre cuándo invocar el destructor. Una variable de instancia o un objeto son aptos para la destrucción cuando ya no se puede acceder a ellos.
Ejemplo:
// C# Program to illustrate how
// a destructor works
using System;
namespace GeeksforGeeks {
class Complex {
// Class members, private
// by default
int real, img;
// Defining the constructor
public Complex()
{
real = 0;
img = 0;
}
// SetValue method sets
// value of real and img
public void SetValue(int r, int i)
{
real = r;
img = i;
}
// DisplayValue displays
// values of real and img
public void DisplayValue()
{
Console.WriteLine("Real = " + real);
Console.WriteLine("Imaginary = " + img);
}
// Defining the destructor
// for class Complex
~Complex()
{
Console.WriteLine("Destructor was called");
}
} // End class Complex
// Driver Class
class Program {
// Main Method
static void Main(string[] args)
{
// Creating an instance of class
// Complex C invokes constructor
Complex C = new Complex();
// Calling SetValue method using
// instance C Setting values of
// real to 2 and img to 3
C.SetValue(2, 3);
// Displaying values of real
// and imaginary parts
C.DisplayValue();
// Instance is no longer needed
// Destructor will be called
} // End Main
} // End class Program
}
Producción:
Real = 2 Imaginary = 3 Destructor was called
Explicación: En el ejemplo anterior, la clase consta de un constructor Complex(), un método SetValue para establecer el valor de la instancia de la clase compleja, un método DisplayValue para mostrar el valor de la instancia y un Destructor ~Complex() para destruir el objeto cuando ya no se requiere la instancia, imprime el mensaje “Se llamó a Destructor”, el cual depende del programador que mensaje quiere mostrar o también se puede dejar en blanco.
Para saber más sobre los destructores, puede consultar el artículo Destructores en C# .
Herencia
La herencia es un pilar importante de OOP (Programación Orientada a Objetos). Es el mecanismo en C# por el cual una clase puede heredar las características (campos y métodos) de otra clase.
Terminología importante:
- Superclase: la clase cuyas características se heredan se conoce como superclase (o una clase base o una clase principal).
- Subclase: la clase que hereda la otra clase se conoce como subclase (o una clase derivada, una clase extendida o una clase secundaria). La subclase puede agregar sus propios campos y métodos además de los campos y métodos de la superclase.
- Reutilización: la herencia admite el concepto de «reutilización», es decir, cuando queremos crear una nueva clase y ya existe una clase que incluye parte del código que queremos, podemos derivar nuestra nueva clase de la clase existente. Al hacer esto, estamos reutilizando los campos y métodos de la clase existente.
Ejemplo:
// C# program to illustrate the
// concept of inheritance
using System;
namespace ConsoleApplication1 {
// Base class
class GFG {
// data members
public string name;
public string subject;
// public method of base class
public void readers(string name, string subject)
{
this.name = name;
this.subject = subject;
Console.WriteLine("Myself: " + name);
Console.WriteLine("My Favorite Subject is: " + subject);
}
}
// inheriting the GFG class using :
class GeeksforGeeks : GFG {
// constructor of derived class
public GeeksforGeeks()
{
Console.WriteLine("GeeksforGeeks");
}
}
// Driver class
class Sudo {
// Main Method
static void Main(string[] args)
{
// creating object of derived class
GeeksforGeeks g = new GeeksforGeeks();
// calling the method of base class
// using the derived class object
g.readers("Kirti", "C#");
}
}
}
Producción:
GeeksforGeeks Myself: Kirti My Favorite Subject is: C#
Para saber más sobre esto, puede consultar el artículo Herencia en C# .
Encapsulación
La encapsulación se define como el empaquetado de datos en una sola unidad. Es el mecanismo que une el código y los datos que manipula. De otra manera, el encapsulamiento es un escudo protector que evita que el código acceda a los datos fuera de este escudo. La encapsulación se puede lograr declarando todas las variables de la clase como privadas y usando las propiedades de C# en la clase para establecer y obtener los valores de las variables.
Ejemplo:
// C# program to illustrate encapsulation
using System;
public class DemoEncap {
// private variables declared
// these can only be accessed by
// public methods of class
private String studentName;
private int studentAge;
// using accessors to get and
// set the value of studentName
public String Name
{
get
{
return studentName;
}
set
{
studentName = value;
}
}
// using accessors to get and
// set the value of studentAge
public int Age
{
get
{
return studentAge;
}
set
{
studentAge = value;
}
}
}
// Driver Class
class GFG {
// Main Method
static public void Main()
{
// creating object
DemoEncap obj = new DemoEncap();
// calls set accessor of the property Name,
// and pass "Ankita" as value of the
// standard field 'value'
obj.Name = "Ankita";
// calls set accessor of the property Age,
// and pass "21" as value of the
// standard field 'value'
obj.Age = 21;
// Displaying values of the variables
Console.WriteLine("Name: " + obj.Name);
Console.WriteLine("Age: " + obj.Age);
}
}
Producción:
Name: Ankita Age: 21
Explicación: En el programa anterior, la clase DemoEncap está encapsulada ya que las variables se declaran como privadas. Para acceder a estas variables privadas, utilizamos los accesores de Nombre y Edad, que contienen el método get y set para recuperar y establecer los valores de los campos privados. Los accesores se definen como públicos para que puedan acceder en otras clases.
Para saber más sobre esto, puede consultar el artículo Encapsulación en C# .
Polimorfismo
El polimorfismo se refiere a la capacidad de los lenguajes de programación OOP para diferenciar entre entidades con el mismo nombre de manera eficiente. Esto lo hace Perl con la ayuda de la firma y declaración de estas entidades.
Ejemplo:
class base_class
{
public void gfg();
}
class derived_class : base_class
{
public void gfg();
}
class Main_Method
{
static void Main()
{
derived_class d = new derived_class();
d.gfg();
}
}
Métodos
Los métodos son generalmente el bloque de códigos o declaraciones en un programa que le brinda al usuario la capacidad de reutilizar el mismo código, lo que finalmente ahorra el uso excesivo de memoria, actúa como un ahorro de tiempo y, lo que es más importante, proporciona una mejor legibilidad del código. Básicamente, un método es una colección de declaraciones que realizan alguna tarea específica y devuelven el resultado a la persona que llama. Un método también puede realizar alguna tarea específica sin devolver nada.
Ejemplo :
// Method Name --> GetCircleArea()
// Return Type ---> double
static double GetCircleArea(double radius)
{
const float pi = 3.14F;
double area = pi * radius * radius;
return area;
}
Declaración de método
La declaración de método significa la forma de construir un método, incluida su denominación.
Sintaxis:
<Access_Modifier> <return_type> <method_name>([<param_list>])
En C#, una declaración de método consta de los siguientes componentes:
- Modificador: Define el tipo de acceso del método, es decir, desde dónde se puede acceder en su aplicación. En C# hay modificadores de acceso Público, Protegido y Privado.
- Nombre del Método: Describe el nombre del método definido por el usuario por el cual el usuario lo llama o lo refiere. P.ej. ObtenerNombre()
- Tipo de retorno: Define el tipo de dato devuelto por el método. Depende del usuario, ya que también puede devolver un valor nulo, es decir, no devolver nada.
- Cuerpo del Método: Se refiere a la línea de código de tareas a realizar por el método durante su ejecución. Está encerrado entre llaves.
- Lista de parámetros: se define una lista separada por comas de los parámetros de entrada, precedidos por su tipo de datos, dentro del paréntesis adjunto. Si no hay parámetros, entonces los paréntesis vacíos() deben agotarse.
Firma del método: la firma del método se define principalmente por dos parámetros (número de parámetros, tipo de parámetros y orden de los parámetros), uno de ellos es el nombre del método y el segundo es su lista de parámetros .
Nombre de método : el nombre de un método o una función en cualquier lenguaje de programación, ya sea en C++, Java o C#, tiene una gran importancia y se utiliza principalmente para llamar a ese método para su ejecución. Por ejemplo, findSum, computeMax, setX y getX, etc. Hay ciertas reglas predefinidas para nombrar métodos que un usuario debe seguir:
- El nombre del método debe ser algún tipo de sustantivo o verbo.
- Su denominación debe hacerse de tal manera que describa el propósito de ese método.
- La primera letra del nombre del método puede ser una letra minúscula o una letra mayúscula, sin embargo, se recomienda utilizar la mayúscula.
Estas reglas no son obligatorias, pero sí recomendables. Generalmente, un método tiene un nombre único dentro de la clase en la que está definido, pero en algún momento un método puede tener el mismo nombre que otros nombres de métodos dentro de la misma clase, ya que C# permite la sobrecarga de métodos.
El cuerpo del método: como se discutió anteriormente, el cuerpo del método consta de declaraciones de código que un usuario desea realizar. Una vez declarado el método, depende del usuario definir su implementación o no. No escribir ninguna implementación, hace que el método no realice ninguna tarea. Sin embargo, cuando el usuario desea realizar ciertas tareas utilizando el método, debe escribir las instrucciones para su ejecución en el cuerpo del método. La siguiente sintaxis describe la estructura básica del cuerpo del método:
Sintaxis:
<return_type> <method_name>(<parameter_list>)
{
// Implementation of the method code goes here.....
}
Método de llamada
La invocación de métodos o la llamada a métodos se realiza cuando el usuario desea ejecutar el método. El método necesita ser llamado para usar su funcionalidad. Un método vuelve al código que lo invocó cuando:
- Completa todas las sentencias del método.
- Llega a una declaración de devolución.
- Lanza una excepción
Ejemplo: en el siguiente código, se llama a un método llamado Sum() .
// C# program to illustrate
// method calling
using System;
namespace ConsoleApplication1 {
class Geeks {
// Here Sum() method asks for two
// parameters from the user and
// calculates the sum of these
// and finally returns the result.
static int Sum(int x, int y)
{
// there are two local variables
// 'a' and 'b' where 'a' is assigned
// the value of parameter 'x' and
// 'b' is assigned the value of
// parameter 'y'
int a = x;
int b = y;
// The local variable calculates
// the sum of 'a' and 'b'
// and returns the result
// which is of 'int' type.
int result = a + b;
return result;
}
// Main Method
static void Main(string[] args)
{
int a = 12;
int b = 23;
// Method Sum() is invoked and
// the returned value is stored
// in the local variable say 'c'
int c = Sum(a, b);
// Display Result
Console.WriteLine("The Value of the sum is " + c);
}
}
}
Producción :
The Value of the sum is 35
Consulte los siguientes artículos para saber más sobre los métodos.
Sobrecarga de métodos
La sobrecarga de métodos es una forma común de implementar polimorfismos. Es la capacidad de redefinir una función en más de una forma. Un usuario puede implementar la sobrecarga de funciones definiendo dos o más funciones en una clase que comparten el mismo nombre. C# puede distinguir los métodos con diferentes firmas de métodos. es decir, los métodos pueden tener el mismo nombre pero con una lista de parámetros diferente (es decir, el número de parámetros, el orden de los parámetros y los tipos de datos de los parámetros) dentro de la misma clase.
Diferentes formas de sobrecargar métodos : la sobrecarga de métodos se puede realizar cambiando:
- El número de parámetros en dos métodos.
- Los tipos de datos de los parámetros de los métodos.
- El Orden de los parámetros de los métodos.
Ejemplo:
// C# program to demonstrate the function
// overloading by changing the Number
// of parameters
using System;
class GFG {
// adding two integer values.
public int Add(int a, int b)
{
int sum = a + b;
return sum;
}
// adding three integer values.
public int Add(int a, int b, int c)
{
int sum = a + b + c;
return sum;
}
// Main Method
public static void Main(String[] args)
{
// Creating Object
GFG ob = new GFG();
int sum1 = ob.Add(1, 2);
Console.WriteLine("sum of the two "
+ "integer value : " + sum1);
int sum2 = ob.Add(1, 2, 3);
Console.WriteLine("sum of the three "
+ "integer value : " + sum2);
}
}
sum of the two integer value : 3 sum of the three integer value : 6
Para saber más sobre esto, puede consultar el artículo Sobrecarga del método C# .
Anulación de métodos
La anulación de métodos en C# es similar a la función virtual en C++ . Method Overriding es una técnica que permite invocar funciones de otra clase (clase base) en la clase derivada. La creación de un método en la clase derivada con la misma firma que un método en la clase base se denomina sobreescritura de métodos.
En palabras simples, Overriding es una función que permite que una subclase o clase secundaria proporcione una implementación específica de un método que ya proporciona una de sus superclases o clases principales. Cuando un método en una subclase tiene el mismo nombre, los mismos parámetros o firma y el mismo tipo de retorno (o subtipo) que un método en su superclase, entonces se dice que el método en la subclase anula el método en la superclase. clase. La anulación de métodos es una de las formas en que C# lograPolimorfismo de tiempo de ejecución (polimorfismo dinámico) .
El método que se anula mediante una declaración de anulación se denomina método base anulado. Un método de anulación es una nueva implementación de un miembro que se hereda de una clase base. El método base invalidado debe ser virtual, abstracto o invalidado.
Ejemplo:
// C# program to demonstrate the method overriding
// without using 'virtual' and 'override' modifiers
using System;
// base class name 'baseClass'
class baseClass
{
public void show()
{
Console.WriteLine("Base class");
}
}
// derived class name 'derived'
// 'baseClass' inherit here
class derived : baseClass {
// overriding
new public void show() {
Console.WriteLine("Derived class");
}
}
class GFG {
// Main Method
public static void Main()
{
// 'obj' is the object of
// class 'baseClass'
baseClass obj = new baseClass();
// invokes the method 'show()'
// of class 'baseClass'
obj.show();
obj = new derived();
// it also invokes the method
// 'show()' of class 'baseClass'
obj.show();
}
}
Base class Base class
Explicación: En este programa, el objeto obj invoca la clase baseClass dos veces y llama al método show() de la clase baseClass . Para evitar este problema, utilizamos la palabra clave virtual y override.
Para saber más sobre esto, puede consultar el artículo Anulación del método C# .
Ocultación de métodos
Como ya sabemos sobre el polimorfismo y la anulación de métodos en C#. C# también proporciona un concepto para ocultar los métodos de la clase base de la clase derivada, este concepto se conoce como Ocultación de métodos. También se conoce como método de sombreado . En la ocultación de métodos, puede ocultar la implementación de los métodos de una clase base de la clase derivada utilizando la nueva palabra clave. O, en otras palabras, en la ocultación de métodos, puede redefinir el método de la clase base en la clase derivada utilizando la nueva palabra clave.
Ejemplo:
// C# program to illustrate the
// concept of method hiding
using System;
// Base Class
public class My_Family {
public void member()
{
Console.WriteLine("Total number of family members: 3");
}
}
// Derived Class
public class My_Member : My_Family {
// Reimplement the method of the base class
// Using new keyword
// It hides the method of the base class
public new void member() {
Console.WriteLine("Name: Rakesh, Age: 40 \nName: Somya, "
+ "Age: 39 \nName: Rohan, Age: 20 ");
}
}
// Driver Class
class GFG {
// Main method
static public void Main()
{
// Creating the object of the derived class
My_Member obj = new My_Member();
// Access the method of derived class
obj.member();
}
}
Producción:
Name: Rakesh, Age: 40 Name: Somya, Age: 39 Name: Rohan, Age: 20
Explicación: En el ejemplo anterior, My_Family es la clase base y My_Member es una clase derivada. En ambas clases tenemos el mismo nombre de método, es decir, el método member() . Pero en la clase derivada, el método member() se declara con la nueva palabra clave. Cuando se llama a este método, imprime el nombre y la edad de los miembros de la familia, no el número total de miembros de la familia. Esto significa que cuando llamamos al método member() con la ayuda del objeto de clase derivado, oculta el mismo método de nombre presente en la clase base debido a la presencia de la nueva palabra clave.
Para saber más sobre esto, puede consultar el artículo Ocultación del método C# .
Colecciones
Las colecciones estandarizan la forma en que su programa maneja los objetos. En otras palabras, contiene un conjunto de clases para contener elementos de manera generalizada. Con la ayuda de las colecciones, el usuario puede realizar varias operaciones en objetos como almacenar, actualizar, eliminar, recuperar, buscar, clasificar, etc.
C# divide la colección en varias clases, algunas de las clases comunes se muestran a continuación:
La colección no genérica en C# se define en el espacio de System.Collectionsnombres. Es una estructura de datos de propósito general que funciona con referencias a objetos, por lo que puede manejar cualquier tipo de objeto, pero no de forma segura. Las colecciones no genéricas están definidas por el conjunto de interfaces y clases. Para saber más sobre esto, puede consultar el artículo Colecciones en C#
La siguiente tabla contiene las clases de uso frecuente del espacio de System.Collectionsnombres:
| Nombre de la clase | Descripción |
|---|---|
| Lista de arreglo | Es una array dinámica, lo que significa que el tamaño de la array no es fijo, puede aumentar y disminuir en tiempo de ejecución. |
| Tabla de picadillo | Representa una colección de pares de clave y valor que se organizan en función del código hash de la clave. |
| Cola | Representa una colección de objetos primero en entrar, primero en salir. Se utiliza cuando necesita un acceso de elementos por orden de entrada. |
| Pila | Es una estructura de datos lineal. Sigue el patrón LIFO (último en entrar, primero en salir) para entrada/salida. |
Lista de arreglo
ArrayList representa una colección ordenada de un objeto que se puede indexar individualmente. Es básicamente una alternativa a una array. También permite la asignación de memoria dinámica, agregando, buscando y ordenando elementos en la lista.
Propiedades de la clase ArrayList:
- Los elementos se pueden agregar o eliminar de la colección Array List en cualquier momento.
- No se garantiza que ArrayList se ordene.
- La capacidad de un ArrayList es el número de elementos que puede contener ArrayList.
- Se puede acceder a los elementos de esta colección mediante un índice entero. Los índices de esta colección están basados en cero.
- También permite duplicar elementos.
- No se admite el uso de arrays multidimensionales como elementos en una colección ArrayList.
Ejemplo:
// C# code to create an ArrayList
using System;
using System.Collections;
using System.Collections.Generic;
class GFG {
// Driver code
public static void Main()
{
// Creating an ArrayList
ArrayList myList = new ArrayList();
// Adding elements to ArrayList
myList.Add("Hello");
myList.Add("World");
Console.WriteLine("Count : " + myList.Count);
Console.WriteLine("Capacity : " + myList.Capacity);
}
}
Producción:
Count : 2 Capacity : 4
Tabla de picadillo
La clase Hashtable representa una colección de pares clave/valor que se organizan en función del código hash de la clave. Esta clase viene bajo el espacio de nombres System.Collections . La clase Hashtable proporciona varios tipos de métodos que se utilizan para realizar diferentes tipos de operaciones en las tablas hash. En Hashtable, las claves se utilizan para acceder a los elementos presentes en la colección. Para objetos Hashtable muy grandes, puede aumentar la capacidad máxima a 2 mil millones de elementos en un sistema de 64 bits.
Características de la clase Hashtable:
- En Hashtable, la clave no puede ser nula, pero el valor puede serlo.
- En Hashtable, los objetos clave deben ser inmutables siempre que se usen como claves en Hashtable.
- La capacidad de un Hashtable es el número de elementos que puede contener Hashtable.
- Cada objeto clave en Hashtable proporciona una función hash.
Ejemplo:
// C# program to create Hashtable
using System;
using System.Collections;
class GFG {
// Main method
static void Main(string[] args)
{
// create and initialize Hash table
// using Add() method
Hashtable g = new Hashtable();
g.Add(1, "welcome");
g.Add(2, "to");
g.Add(3, "tutorials");
g.Add(4, "of");
g.Add(5, "C#");
ICollection key = g.Keys;
// Print Hash table
Console.WriteLine("Hashtable:");
Console.WriteLine();
foreach(var val in key)
{
Console.WriteLine(val + "-" + g[val]);
}
}
}
Producción:
Hashtable: 5-C# 4-of 3-tutorials 2-to 1-welcome
Pila
Stack representa una colección de objetos de último en entrar, primero en salir . Se utiliza cuando necesita un acceso de último en entrar, primero en salir a los elementos. Cuando agrega un elemento en la lista, se le llama empujar el elemento y cuando lo elimina, se le llama sacar el elemento. Esta clase se incluye en el espacio de nombres System.Collections .
Características de la clase de pila:
- La capacidad de una Pila es el número de elementos que la Pila puede contener. A medida que se agregan elementos a una pila, la capacidad aumenta automáticamente según sea necesario mediante la reasignación.
- Si Count es menor que la capacidad de la pila, Push es una operación O(1) . Si es necesario aumentar la capacidad para acomodar el nuevo elemento, Push se convierte en una operación O(n) , donde n es Count. Pop es una operación O(1) .
- Stack acepta nulo como un valor válido y permite elementos duplicados.
Ejemplo:
// C# code to create a Stack
using System;
using System.Collections;
class GFG {
// Driver code
public static void Main()
{
// Creating a Stack
Stack myStack = new Stack();
// Inserting the elements into the Stack
myStack.Push("1st Element");
myStack.Push("2nd Element");
myStack.Push("3rd Element");
myStack.Push("4th Element");
myStack.Push("5th Element");
myStack.Push("6th Element");
// Displaying the count of elements
// contained in the Stack
Console.Write("Total number of elements in the Stack are : ");
Console.WriteLine(myStack.Count);
// Displaying the top element of Stack
// without removing it from the Stack
Console.WriteLine("Element at the top is : " + myStack.Peek());
// Displaying the top element of Stack
// without removing it from the Stack
Console.WriteLine("Element at the top is : " + myStack.Peek());
// Displaying the count of elements
// contained in the Stack
Console.Write("Total number of elements in the Stack are : ");
Console.WriteLine(myStack.Count);
}
}
Producción:
Total number of elements in the Stack are : 6 Element at the top is : 6th Element Element at the top is : 6th Element Total number of elements in the Stack are : 6
Cola
La cola representa una colección de objetos de tipo primero en entrar, primero en salir . Se utiliza cuando necesita un acceso de elementos por orden de entrada. Cuando agrega un elemento en la lista, se llama poner en cola , y cuando elimina un elemento, se llama quitar de la cola . Esta clase se incluye en el espacio de nombres System.Collections e implementa las interfaces ICollection, IEnumerable e ICloneable .
Características de la clase de cola:
- Enqueue agrega un elemento al final de la cola.
- Dequeue elimina el elemento más antiguo del inicio de la cola.
- Peek devuelve el elemento más antiguo que está al comienzo de la Cola pero no lo elimina de la Cola.
- La capacidad de una Cola es el número de elementos que la Cola puede contener.
- A medida que se agregan elementos a una cola, la capacidad aumenta automáticamente según sea necesario mediante la reasignación de la array interna.
- Queue acepta nulo como un valor válido para los tipos de referencia y permite elementos duplicados.
Ejemplo:
// C# code to create a Queue
using System;
using System.Collections;
class GFG {
// Driver code
public static void Main()
{
// Creating a Queue
Queue myQueue = new Queue();
// Inserting the elements into the Queue
myQueue.Enqueue("one");
// Displaying the count of elements
// contained in the Queue
Console.Write("Total number of elements in the Queue are : ");
Console.WriteLine(myQueue.Count);
myQueue.Enqueue("two");
// Displaying the count of elements
// contained in the Queue
Console.Write("Total number of elements in the Queue are : ");
Console.WriteLine(myQueue.Count);
myQueue.Enqueue("three");
// Displaying the count of elements
// contained in the Queue
Console.Write("Total number of elements in the Queue are : ");
Console.WriteLine(myQueue.Count);
myQueue.Enqueue("four");
// Displaying the count of elements
// contained in the Queue
Console.Write("Total number of elements in the Queue are : ");
Console.WriteLine(myQueue.Count);
myQueue.Enqueue("five");
// Displaying the count of elements
// contained in the Queue
Console.Write("Total number of elements in the Queue are : ");
Console.WriteLine(myQueue.Count);
myQueue.Enqueue("six");
// Displaying the count of elements
// contained in the Queue
Console.Write("Total number of elements in the Queue are : ");
Console.WriteLine(myQueue.Count);
}
}
Total number of elements in the Queue are : 1 Total number of elements in the Queue are : 2 Total number of elements in the Queue are : 3 Total number of elements in the Queue are : 4 Total number of elements in the Queue are : 5 Total number of elements in the Queue are : 6
Propiedades
Antes de pasar a las propiedades, echemos un vistazo a por qué el concepto de propiedades entró en C#. El es debido a dos razones:
- Si los miembros de una clase son privados, entonces cómo otra clase en C# podrá leer, escribir o calcular el valor de ese campo.
- Si los miembros de la clase son públicos, otra clase puede hacer un mal uso de ese miembro.
Las propiedades son el tipo especial de miembros de clase que proporciona un mecanismo flexible para leer, escribir o calcular el valor de un campo privado. Las propiedades se pueden usar como si fueran miembros de datos públicos, pero en realidad son métodos especiales llamados accesores . Esto permite acceder fácilmente a los datos y ayuda a promover la flexibilidad y la seguridad de los métodos. La encapsulación y el ocultamiento de información también se pueden lograr usando propiedades. Utiliza métodos predefinidos que son métodos de «obtener» y «establecer» que ayudan a acceder y modificar las propiedades.
Accesores: El bloque de «establecer» y «obtener» se conoce como «Accesorios». Es muy esencial para restringir la accesibilidad de la propiedad. Hay dos tipos de descriptores de acceso, es decir, obtener descriptores de acceso y establecer descriptores de acceso . Hay diferentes tipos de propiedades basadas en los descriptores de acceso «get» y set:
- Propiedades de lectura y escritura: cuando la propiedad contiene métodos get y set.
- Propiedades de solo lectura: cuando la propiedad contiene solo el método get.
- Propiedades de solo escritura: cuando la propiedad contiene solo el método establecido.
- Propiedades implementadas automáticamente: cuando no hay lógica adicional en los accesores de propiedad y se introduce en C# 3.0.
La sintaxis para definir propiedades:
<access_modifier> <return_type> <property_name>
{
get { // body }
set { // body }
}
Donde, <modificador_de_acceso> puede ser público, privado, protegido o interno. <return_type> puede ser cualquier tipo de C# válido. <nombre_propiedad> puede ser definido por el usuario. Las propiedades pueden ser diferentes modificadores de acceso como público, privado, protegido, interno. Los modificadores de acceso definen cómo los usuarios de la clase pueden acceder a la propiedad. Los descriptores de acceso get y set para la misma propiedad pueden tener distintos modificadores de acceso. Una propiedad se puede declarar como propiedad estática mediante la palabra clave estática o se puede marcar como propiedad virtual mediante la palabra clave virtual.
- Get Accessor: Especifica que el valor de un campo se puede acceder públicamente. Devuelve un único valor y especifica la propiedad de solo lectura .
- Set Accessor: Especificará la asignación de un valor a un campo privado en una propiedad. Devuelve un único valor y especifica la propiedad de solo escritura .
Ejemplo:
// C# program to illustrate the
// read and wirte property
using System;
public class Student {
// Declare name field
private string name = "GeeksforGeeks";
// Declare name property
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}
}
class TestStudent {
// Main Method
public static void Main(string[] args)
{
Student s = new Student();
// calls set accessor of the property Name,
// and pass "GFG" as value of the
// standard field 'value'.
s.Name = "GFG";
// displays GFG, Calls the get accessor
// of the property Name.
Console.WriteLine("Name: " + s.Name);
}
}
Producción:
Name: GFG
Para leer más sobre esto, puede consultar el artículo Propiedades en C#
Indexadores
Un indexador permite que una instancia de una clase o estructura se indexe como una array. Si el usuario definirá un indexador para una clase, entonces la clase se comportará como una array virtual. El operador de acceso a la array, es decir ( [ ] ), se usa para acceder a la instancia de la clase que usa un indexador. Un usuario puede recuperar o establecer el valor indexado sin señalar una instancia o un miembro de tipo. Los indexadores son casi similares a las propiedades . La principal diferencia entre los indexadores y las propiedades es que los usuarios de los indexadores tomarán parámetros.
Sintaxis:
[access_modifier] [return_type] this [argument_list]
{
get
{
// get block code
}
set
{
// set block code
}
}
En la sintaxis anterior:
- access_modifier: Puede ser público, privado, protegido o interno.
- return_type: puede ser cualquier tipo de C# válido.
- this: Es la palabra clave que apunta al objeto de la clase actual.
- argument_list: Esto especifica la lista de parámetros del indexador.
- get{ } y set { }: estos son los accesores .
Ejemplo:
// C# program to illustrate the Indexer
using System;
// class declaration
class IndexerCreation {
// class members
private string[] val = new string[3];
// Indexer declaration
// Here pubic is the modifier
// string is the return type of
// Indexer and "this" is the keyword
// having parameters list
public string this[int index]
{
// get Accessor
// retrieving the values
// stored in val[] array
// of strings
get
{
return val[index];
}
// set Accessor
// setting the value at
// passed index of val
set
{
// value keyword is used
// to define the value
// being assigned by the
// set indexer.
val[index] = value;
}
}
}
// Driver Class
class main {
// Main Method
public static void Main()
{
// creating an object of parent class which
// acts as primary address for using Indexer
IndexerCreation ic = new IndexerCreation();
// Inserting values in ic[]
// Here we are using the object
// of class as an array
ic[0] = "C";
ic[1] = "CPP";
ic[2] = "CSHARP";
Console.Write("Printing values stored in objects used as arrays\n");
// printing values
Console.WriteLine("First value = {0}", ic[0]);
Console.WriteLine("Second value = {0}", ic[1]);
Console.WriteLine("Third value = {0}", ic[2]);
}
}
Producción:
Printing values stored in objects used as arrays First value = C Second value = CPP Third value = CSHARP
Para leer más sobre esto, puede consultar el artículo Indexadores en C#
Interfaz
Para leer más sobre esto, puede consultar el artículo Interfaz en C#
Al igual que una clase, la interfaz puede tener métodos, propiedades, eventos e indexadores como miembros. Pero las interfaces contendrán solo la declaración de los miembros. La implementación de los miembros de la interfaz estará dada por la clase que implementa la interfaz implícita o explícitamente.
- Las interfaces especifican qué debe hacer una clase y no cómo.
- Las interfaces no pueden tener miembros privados.
- Por defecto, todos los miembros de Interface son públicos y abstractos.
- La interfaz siempre se definirá con la ayuda de la palabra clave ‘ interfaz ‘.
- La interfaz no puede contener campos porque representan una implementación particular de datos.
- La herencia múltiple es posible con la ayuda de Interfaces pero no con clases.
Sintaxis para la declaración de interfaz:
interface <interface_name >
{
// declare Events
// declare indexers
// declare methods
// declare properties
}
Sintaxis para implementar la interfaz:
class class_name : interface_name
Para declarar una interfaz, use la palabra clave de interfaz . Se utiliza para proporcionar abstracción total. Eso significa que todos los miembros de la interfaz se declaran con el cuerpo vacío y son públicos y abstractos de forma predeterminada. Una clase que implementa una interfaz debe implementar todos los métodos declarados en la interfaz.
Ejemplo:
// C# program to demonstrate working of
// interface
using System;
// A simple interface
interface inter1 {
// method having only declaration
// not definition
void display();
}
// A class that implements interface.
class testClass : inter1 {
// providing the body part of function
public void display()
{
Console.WriteLine("Sudo Placement GeeksforGeeks");
}
// Main Method
public static void Main(String[] args)
{
// Creating object
testClass t = new testClass();
// calling method
t.display();
}
}
Sudo Placement GeeksforGeeks
subprocesos múltiples
Los subprocesos múltiples son un proceso que contiene varios subprocesos dentro de un solo proceso. Aquí cada hilo realiza diferentes actividades. Por ejemplo, tenemos una clase y esta llamada contiene dos métodos diferentes, ahora usando subprocesos múltiples cada método es ejecutado por un subproceso separado. Entonces, la principal ventaja de los subprocesos múltiples es que funciona simultáneamente, lo que significa que se ejecutan varias tareas al mismo tiempo. Y también maximizar la utilización de la CPU porque los subprocesos múltiples funcionan con el concepto de tiempo compartido, lo que significa que cada subproceso toma su propio tiempo de ejecución y no afecta la ejecución de otro subproceso, este intervalo de tiempo lo proporciona el sistema operativo.
Ejemplo:
// C# program to illustrate the
// concept of multithreading
using System;
using System.Threading;
public class GFG {
// static method one
public static void method1()
{
// It prints numbers from 0 to 10
for (int I = 0; I <= 10; I++) {
Console.WriteLine("Method1 is : {0}", I);
// When the value of I is equal to 5 then
// this method sleeps for 6 seconds
if (I == 5) {
Thread.Sleep(6000);
}
}
}
// static method two
public static void method2()
{
// It prints numbers from 0 to 10
for (int J = 0; J <= 10; J++) {
Console.WriteLine("Method2 is : {0}", J);
}
}
// Main Method
static public void Main()
{
// Creating and initializing threads
Thread thr1 = new Thread(method1);
Thread thr2 = new Thread(method2);
thr1.Start();
thr2.Start();
}
}
Producción :
Method1 is : 0 Method1 is : 1 Method1 is : 2 Method1 is : 3 Method2 is : 0 Method2 is : 1 Method2 is : 2 Method2 is : 3 Method2 is : 4 Method2 is : 5 Method2 is : 6 Method2 is : 7 Method2 is : 8 Method2 is : 9 Method2 is : 10 Method1 is : 4 Method1 is : 5 Method1 is : 6 Method1 is : 7 Method1 is : 8 Method1 is : 9 Method1 is : 10
Explicación: Aquí, creamos e inicializamos dos hilos, es decir, thr1 y thr2 usando la clase Thread. Ahora usando thr1.Start();y thr2.Start();comenzamos la ejecución de ambos hilos. Ahora ambos subprocesos se ejecutan simultáneamente y el procesamiento de thr2 no depende del procesamiento de thr1 como en el modelo de un solo subproceso.
Nota: La salida puede variar debido al cambio de contexto.
Para leer más sobre esto, puede consultar el artículo C# Multithreading .
Expresión regular
En C#, la expresión regular es un patrón que se usa para analizar y verificar si el texto de entrada dado coincide o no con el patrón dado. En C#, las expresiones regulares generalmente se denominan C# Regex. .Net Framework proporciona un motor de expresiones regulares que permite la coincidencia de patrones. Los patrones pueden consistir en cualquier literal de carácter, operadores o constructores.
C# proporciona una clase denominada Regex que se puede encontrar en el espacio de nombres System.Text.RegularExpression . Esta clase realizará dos cosas:
- Analizar el texto de entrada para el patrón de expresión regular.
- Identificar el patrón de expresión regular en el texto dado.
Ejemplo: el siguiente ejemplo demuestra el uso de expresiones regulares en la verificación de número móvil. Supongamos que está creando un formulario en el que necesita verificar el número de teléfono móvil ingresado por el usuario, luego puede usar expresiones regulares.
// C# program to validate the Mobile
// Number using Regular Expressions
using System;
using System.Text.RegularExpressions;
class GFG {
// Main Method
static void Main(string[] args)
{
// Input strings to Match
// valid mobile number
string[] str = { "9925612824",
"8238783138", "02812451830" };
foreach(string s in str)
{
Console.WriteLine("{0} {1} a valid mobile number.", s,
isValidMobileNumber(s) ? "is" : "is not");
}
Console.ReadKey();
}
// method containing the regex
public static bool isValidMobileNumber(string inputMobileNumber)
{
string strRegex = @"(^[0-9]{10}$)|(^\+[0-9]{2}\s+[0-9]
{ 2 }[0 - 9]
{
8
}$)|(^[0-9]{3}-[0-9]{4}-[0-9]{
4}$)";
// Class Regex Represents an
// immutable regular expression.
// Format Pattern
// xxxxxxxxxx ^[0 - 9]{ 10}$
// +xx xx xxxxxxxx ^\+[0 - 9]{ 2}\s +[0 - 9]{ 2}\s +[0 - 9]{ 8}$
// xxx - xxxx - xxxx ^[0 - 9]{ 3} -[0 - 9]{ 4}-[0 - 9]{ 4}$
Regex re = new Regex(strRegex);
// The IsMatch method is used to validate
// a string or to ensure that a string
// conforms to a particular pattern.
if (re.IsMatch(inputMobileNumber))
return (true);
else
return (false);
}
}
Producción:
9925612824 is a valid mobile number. 8238783138 is a valid mobile number. 02812451830 is not a valid mobile number.
Para leer más sobre esto, puede consultar el artículo Expresiones regulares .
Manejo de excepciones
Una excepción se define como un evento que ocurre durante la ejecución de un programa que no es esperado por el código del programa. Las acciones a realizar en caso de ocurrencia de una excepción no son conocidas por el programa. En tal caso, creamos un objeto de excepción y llamamos al código del controlador de excepciones. La ejecución de un controlador de excepciones para que el código del programa no falle se denomina manejo de excepciones. El manejo de excepciones es importante porque maneja con gracia un evento no deseado, una excepción para que el código del programa aún tenga sentido para el usuario.
| Palabra clave | Definición |
|---|---|
| probar | Se utiliza para definir un bloque de prueba. Este bloque contiene el código que puede generar una excepción. |
| captura | Se utiliza para definir un bloque catch. Este bloque detecta la excepción lanzada por el bloque try. |
| finalmente | Se utiliza para definir el bloque finalmente. Este bloque contiene el código predeterminado. |
| lanzar | Se utiliza para lanzar una excepción manualmente. |
Tomemos un ejemplo simple para entender qué es una excepción:
// C# program to show how
// Exceptions occur in a program
using System;
class GFG {
static void Main(string[] args)
{
// Declare an array of max index 4
int[] arr = { 1, 2, 3, 4, 5 };
// Display values of array elements
for (int i = 0; i < arr.Length; i++) {
Console.WriteLine(arr[i]);
}
// Try to access invalid index of array
Console.WriteLine(arr[7]);
// An exception is thrown upon executing
// the above line
}
}
Error de tiempo de ejecución:
Excepción no controlada:
System.IndexOutOfRangeException: el índice estaba fuera de los límites de la array.
en GFG.Main (System.String[] args) [0x0002e] en <9fa39b3b4dec49eb8af89dc70d5a0618>:0
[ERROR] EXCEPCIÓN FATAL NO MANEJADA: System.IndexOutOfRangeException: el índice estaba fuera de los límites de la array.
en GFG.Main (System.String[] argumentos) [0x0002e] en <9fa39b3b4dec49eb8af89dc70d5a0618>:0
Producción:
1 2 3 4 5
En el código anterior, la array denominada ‘arr’ se define para 5 elementos, índices 0 a 4. Cuando intentamos acceder al séptimo elemento de la array, que no existe, el código del programa arroja una excepción y el mensaje anterior se visualiza. La excepción se puede controlar mediante la clase System.Exception de C#. Esto se representará en el código que se proporciona a continuación.
Manejo de excepciones usando el bloque try-catch
El código que se muestra a continuación muestra cómo podemos manejar las excepciones usando el bloque try-catch. El código que puede generar una excepción se coloca dentro del bloque de prueba. En este caso, el acceso al 7º elemento se coloca dentro del bloque try. Cuando se ejecuta esa declaración, se genera una excepción, que es capturada por el bloque catch. El objeto del tipo IndexOutOfRangeException se utiliza para mostrar un mensaje al usuario sobre la excepción que se ha producido.
Sintaxis:
try
{
// statements that may cause an exception
}
catch( Exception obj)
{
// handler code
}
// Exception handling of above code
// using try catch blocks
using System;
class Program : System.Exception {
static void Main(string[] args)
{
// Declare an array of max index 4
int[] arr = { 1, 2, 3, 4, 5 };
// Display values of array elements
for (int i = 0; i < arr.Length; i++) {
Console.WriteLine(arr[i]);
}
try {
// Try to access invalid index of array
Console.WriteLine(arr[7]);
// An exception is thrown upon executing
// the above line
}
catch (IndexOutOfRangeException e) {
// The Message property of the object
// of type IndexOutOfRangeException
// is used to display the type of exception
// that has occurred to the user.
Console.WriteLine("An Exception has occurred : {0}", e.Message);
}
}
}
Producción:
1 2 3 4 5 An Exception has occurred : Index was outside the bounds of the array.
Uso de múltiples bloques de intento y captura
En el código que se proporciona a continuación, intentamos generar una excepción en el bloque de prueba y atraparla en uno de los múltiples bloques de captura. Se utilizan varios bloques catch cuando no estamos seguros del tipo de excepción que se puede generar, por lo que escribimos diferentes bloques para abordar cualquier tipo de excepción que se encuentre.
El bloque finalmente es la parte del código que debe ejecutarse independientemente de si la excepción se generó o no. En el programa que se muestra a continuación, los elementos de la array se muestran en el bloque finalmente.
Sintaxis:
try
{
// statements that may cause an exception
}
catch(Specific_Exception_type obj)
{
// handler code
}
catch(Specific_Exception_type obj)
{
// handler code
}
.
.
.
finally
{
//default code
}
// C# Program to show use of
// multiple try catch blocks
using System;
class Program {
static void Main(string[] args)
{
int[] arr = { 19, 0, 75, 52 };
try {
// Try to generate an exception
for (int i = 0; i < arr.Length; i++) {
Console.WriteLine(arr[i] / arr[i + 1]);
}
}
// Catch block for invalid array access
catch (IndexOutOfRangeException e) {
Console.WriteLine("An Exception has occurred : {0}", e.Message);
}
// Catch block for attempt to divide by zero
catch (DivideByZeroException e) {
Console.WriteLine("An Exception has occurred : {0}", e.Message);
}
// Catch block for value being out of range
catch (ArgumentOutOfRangeException e) {
Console.WriteLine("An Exception has occurred : {0}", e.Message);
}
// Finally block
// Will execute irrespective of the above catch blocks
finally {
for (int i = 0; i < arr.Length; i++) {
Console.Write(" {0}", arr[i]);
}
}
}
}
Producción:
An Exception has occurred : Attempted to divide by zero. 19 0 75 52
Para leer más sobre esto, puede consultar el artículo Manejo de excepciones en C#
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA