Sintaxis C##

Logo C#

Sintáxis básica de C#

Elementos básicos del lenguaje#

Instalación#

  • Instalación: Mediante Visual Studio o Unity.

  • Instalación Visual Studio 2019 Windows:

    • Descargamos la versión comunity

    • En carga de trabajo seleccionamos Desarrollo de escritorio de .NET y Desarrollo de la plataforma universal de Windows

    • En la siguiente pestaña de componentes individuales seleccionamos la opción Herramientas de LINQ to SQL

  • Instalación Monodevelop Linux:

  • Extensión de archivos: .cs

Comentarios#

1// comentario de una línea
2
3/* Comentario
4multilínea */
5
6/// <summary>
7/// Comentario de documentación XML </summary>

Entrada y salida estandar#

Datos de entrada y salida a través de la consola y/o el navegador.

  • Uso de la clase Console:

 1static void Main(string[] args)
 2    {
 3        // Salida en consola:
 4        Console.Write("Mensaje - ");
 5
 6        // Imprimir y saltar de línea:
 7        Console.WriteLine("Introduce un valor: ");
 8
 9        // Leer valor y lo guarda en formato string:
10        Console.Write("Escribe tu nombre: ");
11        string leerOtroValor = Console.ReadLine();
12        Console.WriteLine("Te llamas {0}", leerOtroValor);
13
14        // Leer valor de consola y guardar en variable en formato ASCII:
15        int leerValor = Console.Read();
16        Console.WriteLine("El valor introducido es: {0}", leerValor);
17
18        // Toma un solo caracter:
19        Console.ReadKey();
20    }

Nota

El uso de Console.Read() es muy útil para evitar que se cierre la consola.

Estructura en C##

  • Crear proyecto: Abrimos VS y pinchamos en Crear un proyecto, luego elegimos Aplicación de consola (.NET Framework o la opción .NET Core si no esta la primera), cambiamos el nombre del proyecto y creamos.

  • Código C# puro:

 1using System;
 2
 3namespace HolaMundo
 4{
 5    class Program
 6    {
 7        static void Main(string[] args)
 8        {
 9            Console.WriteLine("Hola FullCoder!");
10        }
11    }
12}

Concatenación#

Concatenación de variables y cadenas se realiza con +

 1static void Main(string[] args)
 2    {
 3        string nombre = "Guillermo";
 4        int edad = 33;
 5
 6        // uso de +:
 7        Console.WriteLine("Me llamo " + nombre + " y tengo " + edad + " años");
 8
 9        // uso de template:
10        Console.WriteLine("Me llamo {0} y tengo {1} años.", nombre, edad);
11
12        Console.ReadKey();
13    }

C#-CLI - Comandos de C##

Al trabajar con C# es poco probable el uso de CLI, así que por ahora se omitirá este apartado.

Variables y tipos de datos#

  • Declaración, asignación y tipo:

 1using System;
 2using System.Collections.Generic;
 3using System.Linq;
 4using System.Text;
 5using System.Threading.Tasks;
 6
 7namespace Tipos
 8{
 9    class Program
10    {
11        static void Main(string[] args)
12        {
13            // declaración:
14            int numero;
15
16
17            // asignación de valores:
18            int numeroEntero = 10;
19            double comaFlotante = 2.832;
20            float otroFlotante = 3.2f;
21            string cadena = "cadena de texto";
22            bool interruptor = true;
23
24            // Impresión de valores::
25            Console.WriteLine("Valor del número: " + numeroEntero);
26
27            // dejamos el read abierto para que no se cierre la consola:
28            Console.Read();
29        }
30    }
31}

  • Constantes:

 1class Program
 2{
 3    // se declara usando const y además se añade el tipo:
 4    const int fechaNacimiento = 1987;
 5    static void Main(string[] args)
 6    {
 7        Console.WriteLine(fechaNacimiento);
 8        Console.Read();
 9    }
10}

Operadores#

Operadores aritméticos#

  • Operaciones aritméticas:

 1static void Main(string[] args)
 2    {
 3        int operacion;
 4
 5        int sumar = 2 + 2;
 6        int restar = 2 - 2;
 7        int multiplicar = 3 + 5;
 8        int dividir = 2 / 2;
 9        int resto = 2 % 1;
10    }

  • Incremento y decremento:

1static void Main(string[] args)
2    {
3        int valor = 10;
4
5        valor = valor++;
6        valor = ++valor;
7        valor = valor--;
8        valor = --valor;
9    }

  • Asignar operación:

1static void Main(string[] args)
2    {
3        int valor = 10;
4
5        valor += 10;
6        valor -= 5;
7        valor *= 22;
8        valor /= 11;
9    }

Operadores relacionales#

Validación entre dos números.

  • Mayor que: >.

  • Menor que: <.

  • Mayor o igual que: >=.

  • Menor o igual que: <=.

  • Igual que: ==.

Operadores lógicos#

Expresiones de operaciones lógicas.

  • and: &&.

  • or: ||.

  • not: !.

Estructuras de control#

Condicional if#

  • if sencillo:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        int edad = 18;
 6
 7        if(edad >= 18)
 8        {
 9            Console.Write("Eres mayor de edad");
10        }
11
12        Console.Read();
13    }
14}

  • if / else:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        int edad = 11;
 6
 7        if(edad >= 18)
 8        {
 9            Console.Write("Eres mayor de edad");
10        }
11        else
12        {
13            Console.Write("Todavía eres menor");
14        }
15
16        Console.Read();
17    }
18}

  • else-if:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        Console.Write("Introduce tu edad: ");
 6        string leer = Console.ReadLine();
 7
 8        int edad = Convert.ToInt32(leer);
 9
10        if(edad >= 65)
11        {
12            Console.Write("Eres un anciano");
13        }else if(edad >= 18)
14        {
15            Console.Write("Eres mayor de edad");
16        }
17        else
18        {
19            Console.Write("Eres menor de edad");
20        }
21
22        Console.Read();
23    }
24}

  • if alternativo:

 1class Program
 2{
 3
 4    static void Main(string[] args)
 5    {
 6        int edad = 18;
 7
 8        if(edad >= 18)
 9            Console.WriteLine("Eres mayor de edad");
10
11        Console.Read();
12    }
13}

Nota

Aparte de este if, existe for, foreach y while que comparten la misma forma de operar.

  • Operador ternario:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        int cantidad = 200;
 6        string mensaje;
 7
 8        mensaje = cantidad >= 500 ? "es una pechá" : "es una mijita";
 9
10        Console.Write(mensaje);
11        Console.Read();
12
13    }
14}

Condicional Switch#

Estructura de un switch:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        Console.Write("Introduce un comando: ");
 6        string operacion = Console.ReadLine();
 7
 8        switch (operacion)
 9        {
10            case "saludar":
11                Console.WriteLine("Hola amigo");
12                break;
13            case "fecha":
14                Console.WriteLine("Hoy es " + DateTime.Now.ToString());
15                break;
16            case "lenguaje":
17                Console.WriteLine("Esta app esta escrita en C#");
18                break;
19            default:
20                Console.WriteLine("Comando no reconocido...");
21                break;
22        }
23
24        Console.Read();
25    }
26}

Bucle for#

  • for básico:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        for(int i = 1; i <= 10; i++)
 6        {
 7            Console.WriteLine("El valor de contador es: {0}", i);
 8        }
 9        Console.Read();
10    }
11}

  • foreach:

1foreach (string consola in videconsolas)
2{
3    Console.WriteLine("Consola: {0}", consola);
4}

Bucle while#

  • While sencillo:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        int i = 1;
 6        while (i <= 10)
 7        {
 8            Console.WriteLine("El valor de contador es: {0}", i);
 9            i++;
10        }
11
12        Console.Read();
13    }
14}

  • do-while:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        int i = 2;
 6        do
 7        {
 8            Console.WriteLine("El valor de contador es: {0}", i);
 9        } while (i < 1);
10
11        Console.Read();
12    }
13}

Tipos de datos avanzados#

Arrays#

  • Declaración tradicional:

 1// declaración array:
 2string[] videconsolas = new string[3];
 3// creación y asignación:
 4int[] fechas = new int[] {1987, 1983, 1990, 2011 };
 5
 6// carga de elementos manual:
 7videconsolas[0] = "Mega Drive";
 8videconsolas[1] = "Master System";
 9videconsolas[2] = "Saturn";
10
11// Impresión de elementos:
12Console.WriteLine("Consola de Tercera generación: {0}", videconsolas[1]);

  • Array multidimensional:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        string[] videconsolas = new string[3];
 6        // array multidimensional, cuantos más puntos más dimensiones:
 7        string[,] tabla = new string[,]
 8        {
 9            {"", "Nombre", "Apellidos","Edad"},
10            {"1", "Guillermo", "Granados Gómez", "33" },
11            {"2", "Eduardo", "Lopez Martinez", "34" },
12            {"3", "Alfredo", "Alferez Albeniz", "37" }
13        };
14
15        // imprimir valores:
16        Console.WriteLine("{0}: {1}, {2}: {3}, {4}: {5} ", tabla[0,1], tabla[1,1], tabla[0,2], tabla[1,2], tabla[0,3], tabla[1,3]);
17
18       // insertar datos:
19        tabla[4, 0] = "4";
20        tabla[4, 1] = "Luna";
21        tabla[4, 2] = "García Nuñez";
22        tabla[4, 3] = "23";
23
24        Console.Read();
25    }
26}

  • Array Irregular:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        // definición y asignación de espacio en primera dimension:
 6        string[][] valores = new string[3][];
 7
 8        // en cada dimensión se crea un array:
 9        valores[0] = new string[3];
10        valores[1] = new string[6];
11        valores[2] = new string[8];
12
13        // inserción de registros:
14        valores[0][3] = "Hola amigo";
15
16        Console.Read();
17    }
18}

  • Arrays por parámetros:

 1 class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        // crear el array:
 6        int[] numeros = new int[] { 8, 16 };
 7
 8        // pasar array:
 9        sumar(numeros);
10    }
11
12    // recibir array por funciones:
13    static void sumar(int [] numeros)
14    {
15        int num1 = numeros[0];
16        int num2 = numeros[1];
17        int total = num1 + num2;
18
19        Console.WriteLine("Total de la operación: " + total);
20        Console.Read();
21    }
22}

Control de errores#

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        Console.WriteLine("Por favor introduce un número: ");
 6        string num = Console.ReadLine();
 7        // vamos a evitar caracteres no válidos:
 8        try
 9        {
10            // convertimos el resultado a entero, de modo que si se introduce una letra habrá una excepción:
11            int resultado = int.Parse(num);
12            Console.WriteLine("El valor es: " + resultado);
13        }
14        catch (Exception)
15        {
16            Console.WriteLine("El valor introducido no es un número.");
17        }
18        Console.Read();
19    }
20}

Programación modular#

El paradigma de programación de C# es POO, sin embargo es interesante ver en esta sección como crear métodos y llamarlos desde Main.

Métodos#

  • Método void:

 1class Program
 2{
 3    // En la clase principal existe un método principal:
 4    static void Main(string[] args)
 5    {
 6        // ejecutamos el método:
 7        Mensaje(); // para poder llamarlo debe tener acceso static
 8        Console.Read();
 9    }
10
11    // este es un método que no devuelve nada (void):
12    public static void Mensaje()
13    {
14        Console.WriteLine("Este método devuelve un mensaje");
15    }
16}

  • uso de parámetros:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        // pasamos los parámetros:
 6        Sumar(10, 15);
 7        Console.Read();
 8    }
 9
10    // se define el tipo de parámetro:
11    public static void Sumar(int numUno, int numDos)
12    {
13        int resultado = numUno + numDos;
14        Console.WriteLine("El resultado de {0} + {1} es: {2}", numUno, numDos, resultado);
15    }
16}

  • retorno de valores:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        // Guardamos la operación en una variable:
 6        string resultado = Sumar(12, 26);
 7
 8        Console.WriteLine(resultado);
 9        Console.Read();
10    }
11
12    // Se utiliza string en lugar de void para devolver una cadena:
13    public static string Sumar(int numUno, int numDos)
14    {
15        int resultado = numUno + numDos;
16        // usamos return y aprovechamos el String.Format en este caso:
17        return String.Format("El resultado de {0} + {1} es: {2}", numUno, numDos, resultado);
18    }
19}

  • Ámbito global o atributos estáticos:

 1class Program
 2{
 3    // Los atributos declarados estáticos podemos usarlos en Main:
 4    public static int num1;
 5    public static int num2;
 6    static void Main(string[] args)
 7    {
 8        // asignamos valores y usamos con el método Sumar:
 9        num1 = 10;
10        num2 = 73;
11        string resultado = Sumar(num1, num2);
12
13        Console.WriteLine(resultado);
14        Console.Read();
15    }
16
17    public static string Sumar(int numUno, int numDos)
18    {
19        int resultado = numUno + numDos;
20        return String.Format("El resultado de {0} + {1} es: {2}", numUno, numDos, resultado);
21    }
22}

Programación orientada a objetos#

Para crear una clase en Visual Studio hacemos clic derecho sobre el nombre deel proyecto y le damos a agregar -> clase. Elegimos una clase en blanco.

Clases y objetos#

  • Estructura clase:

 1using System;
 2
 3namespace Tipos
 4{
 5    class Persona
 6    {
 7        // atributos de la clase:
 8        public string nombre;
 9        public string apellidos;
10        public int edad;
11
12        // metodos:
13        public void saludo()
14        {
15            Console.WriteLine("Hola, soy {0} {1}", this.nombre, this.apellidos);
16        }
17    }
18}

Importante

Respecto a los modificadores de acceso existen 4 tipos en C#. Public (acceso total), Private (solo acceso desde misma clase), Protected (acceso desde la misma clase e hijas), Internal (acceso desde cualquier clase).

  • Constructor:

 1using System;
 2
 3namespace Tipos
 4{
 5    class Persona
 6    {
 7        public string nombre;
 8        public string apellidos;
 9        public int edad;
10
11        // el constructor:
12        public Persona(string nombre, string apellidos, int edad)
13        {
14            // asignar valores a los atributos de clase con this:
15            this.nombre = nombre;
16            this.apellidos = apellidos;
17            this.edad = edad;
18        }
19
20        public void saludo()
21        {
22            Console.WriteLine("Hola, soy {0} {1}", this.nombre, this.apellidos);
23        }
24    }
25}

Nota

Puedes crear varios constructores en una clase que reciban uno o dos parámetros, o todos o ninguno. Esto permite que puedas crear objetos con más o menos información.

  • Get y Set:

 1using System;
 2
 3namespace Tipos
 4{
 5    class Persona
 6    {
 7        public string nombre;
 8        public string apellidos;
 9        public int edad;
10        private string dni;
11        // método rápido de asignar get y set:
12        private string enfermedades { get; set; }
13
14        public Persona(string nombre, string apellidos, int edad)
15        {
16            this.nombre = nombre;
17            this.apellidos = apellidos;
18            this.edad = edad;
19        }
20
21        // Get y set para trabajar con atributos privados:
22        public void SetDNI(string dni)
23        {
24            this.dni = dni;
25        }
26
27        public string GetDNI()
28        {
29            return this.dni;
30        }
31
32        public void saludo()
33        {
34            Console.WriteLine("Hola, soy {0} {1}", this.nombre, this.apellidos);
35        }
36    }
37}

  • Modificar Get y Set de Atributos:

 1// tenemos un atributo declarado vacío:
 2public int edad
 3    {
 4        get
 5        {
 6            return edad;
 7        }
 8        set
 9        {   // podemos decirle que si la edad es menor a 18 que ponga 18 siempre o sino la edad nueva:
10            edad = edad < 18 ? 18 : value;
11        }
12    }
13
14// versión reducida:
15public int edad
16    {
17        get => edad;
18        set => edad = edad < 18 ? 18 : value;
19    }

  • Creación de objeto:

 1class Program
 2{
 3    static void Main(string[] args)
 4    {
 5        // crear objeto de la clase:
 6        Persona guillermo = new Persona("Guillermo", "Granados Gómez", 33);
 7
 8        // uso de atributo público:
 9        guillermo.edad = 34;
10
11        // uso de método público:
12        guillermo.saludo();
13
14        // uso de atributos privados:
15        guillermo.SetDNI("34234234X");
16        Console.WriteLine("El DNI: {0}",guillermo.GetDNI());
17
18
19        Console.Read();
20    }
21}

  • Destructores:

 1using System;
 2// usaremos esta libería para debug:
 3using System.Diagnostics;
 4
 5namespace Tipos
 6{
 7    class Persona
 8    {
 9        public string nombre;
10        public string apellidos;
11        public int edad;
12        private string dni;
13
14        public Persona(string nombre, string apellidos, int edad)
15        {
16            this.nombre = nombre;
17            this.apellidos = apellidos;
18            this.edad = edad;
19        }
20
21        public void SetDNI(string dni)
22        {
23            this.dni = dni;
24        }
25
26        public string GetDNI()
27        {
28            return this.dni;
29        }
30
31        public void saludo()
32        {
33            Console.WriteLine("Hola, soy {0} {1}", this.nombre, this.apellidos);
34        }
35
36        // destructor solo se puede usar desde su clase y solo uno:
37        ~Persona()
38        {
39            // vamos a imprmir por depurador:
40            Debug.Write("Se ha destruido el objeto");
41        }
42    }
43}

Atención

Los destructores solo se deben usar cuando se va a devolver algún valor.

Herencia#

  • Clase padre:

 1using System;
 2
 3namespace Tipos
 4{
 5    // clase padre:
 6    class Vehiculo
 7    {
 8        // crear atributos privados con getter y setters:
 9        protected int idVehiculo { get; set; }
10        protected string marca { get; set; }
11        protected string modelo { get; set; }
12
13        // creamos un constructor por defecto por si no establecemos valores en los parámetros:
14        public Vehiculo()
15        {
16            this.idVehiculo = 000000;
17            marca = "Marca vehículo";
18            modelo = "Modelo del vehículo";
19        }
20
21        // constructor parametrizado:
22        public Vehiculo(int id, string marca, string modelo)
23        {
24            this.idVehiculo = id;
25            this.marca = marca;
26            this.modelo = modelo;
27        }
28
29        // arrancar el vehiculo:
30        public void Arrancar()
31        {
32            Console.WriteLine("El vehículo {0} {1} se ha puesto en marcha", this.marca, this.modelo);
33            Console.Read();
34        }
35    }
36}

  • Clase hija que hereda:

 1using System;
 2
 3namespace Tipos
 4{// con : le decimos la clase de donde debe heredad:
 5    class Formula:Vehiculo
 6    {
 7        public int velocidadMax { get; set; }
 8
 9        // podemos usar los métodos del padre sin problemas:
10        public Formula(int id, string marca, string modelo) {
11            this.idVehiculo = id;
12            this.marca = marca;
13            this.modelo = modelo;
14
15        }
16        // métodos propios de la clase hija:
17        public void Turbo()
18        {
19            Console.WriteLine("El {0} {1} ha metido el turbo!", this.marca, this.modelo);
20            Console.Read();
21        }
22    }
23}

  • Creando objetos:

 1using System;
 2
 3namespace Tipos
 4{
 5    class Program
 6    {
 7        static void Main(string[] args)
 8        {
 9            Vehiculo ford = new Vehiculo(073233, "Ford", "Mustang");
10            ford.Arrancar();
11
12            Formula mclaren = new Formula(234323, "Mercedes", "McLaren");
13            mclaren.Arrancar();
14            mclaren.Turbo();
15        }
16    }
17}

Interfaces#

 1interface IPersona
 2{
 3    // definir métodos que tendrán la clase:
 4    void Comer();
 5    string Saludar();
 6
 7}
 8
 9class Gente : IPersona
10{
11    public string nombre;
12
13    Gente(string nombre)
14    {
15        this.nombre = nombre;
16    }
17    public void Comer()
18    {
19        Console.WriteLine("{0} va a comer", this.nombre);
20        Console.Read();
21    }
22
23    public string Saludar()
24    {
25        return String.Format("{0} dice hola.", this.nombre);
26    }
27}

Nota

En Visual Studio se puede crear una interfaz haciendo click derecho en el nombre del proyecto, agregar y seleccionamos interfaz.

Structs#

 1using System;
 2using System.IO;
 3
 4namespace Tipos
 5{
 6    class Program
 7    {
 8        // creamos la estructura en la clase:
 9        struct Videoconsola
10        {
11            // atributos del struct:
12            public string marca;
13            public string modelo;
14
15            // constructor:
16            public Videoconsola(string marca, string modelo)
17            {
18                this.marca = marca;
19                this.modelo = modelo;
20            }
21
22            // metodos del struct:
23            public void ImprimirMensaje()
24            {
25                Console.WriteLine("La videoconsola es {0} {1}", this.marca, this.modelo);
26            }
27        }
28
29        static void Main(string[] args)
30        {
31            // declaramos el struct:
32            Videoconsola megadrive;
33
34            // asignamos valores y se quita el error:
35            megadrive.marca = "Sega";
36            megadrive.modelo = "Mega Drive";
37
38            // la diferencia con las clases es que hasta que no asignamos valores a los atributos no podemos usar sus métodos:
39            megadrive.ImprimirMensaje();
40
41            Console.Read();
42        }
43    }
44}

Enums#

 1using System;
 2
 3namespace Tipos
 4{
 5    // los enum se declaran a nivel de namespace:
 6    enum Semana { L, M, X, J, V, S, D=0}; // podemos reorganizar asignando indices numéricos
 7    class Program
 8    {
 9        static void Main(string[] args)
10        {
11            // asignar un día:
12            Semana lunes = Semana.L;
13            // imprimir valor:
14            Console.WriteLine(lunes);
15            // imprimir posición:
16            Console.WriteLine((int)Semana.D);
17            Console.Read();
18        }
19    }
20}

Importar y exportar#

Namespace#

Los namespace o espacios de nombre en C# sirven para organizar sus clases. Puedes ver más detalles en su documentación oficial: https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/namespaces/