Contenido de la Serie de artículos

Estos son todos los temas de la serie:

1. 1. La Programacion orientada a objetos (POO) y el diseño orientado a objetos (DOO)
2. 2. Los requerimientos: funcionales y no funcionales
3. 3. Objetos y clases
4. 4. Tipos de datos en C#: Por valor y por referencia
5. 5. Constructores
6. 6. Signaturas e Interfaces
7. 7. Clases especiales: estáticas y abstractas
8. 8. Modificadores de acceso
9. 9. Los 4 Pilares de la POO: Herencia, abstracción, encapsulamiento y polimorfismo
10. 10. Los Principios SOLID

Signaturas

Es el momento de definir lo que es una signatura, y en palabras sencillas, como me caracteriza, es:

Un sello distintivo que tienen los métodos de una clase

Tan sencillo como eso, esto quiere decir también que una firma o signatura está conformada por estos dos elementos:

• Nombre
• Parámetros

En cuanto a parámetros, tiene en cuenta el orden de ellos, su tipo de dato y la cantidad de parámetros que tiene el método.

La firma o signatura de un método no tiene en cuenta ni el modificador de acceso, ni el tipo de retorno en el caso que tuviese uno.

Interfaces

Es un mecanismo de la Programación orientada a objetos que nos permite definir una SIGNATURA de métodos.

En términos prácticos, es un CONTRATO que obliga a una clase a implementar lo que la interfaz defina.

Veamos un ejemplo de una interfaz en C#.

Aquí tenemos la interfaz llamada ILogger

    internal interface ILogger
    {
        void Log(string mensaje);//signaturas
        void LogException(Exception ex);
    }

Y crearé dos clases que implementan la interfaz ILogger, la primera clase la llamaré LoggerArchivo:

   public class LoggerArchivo : ILogger
    {
        public void Log(string mensaje)
        {
            var rutaArchivo = @$"{Directory.GetCurrentDirectory()}\Log.txt";
            using (StreamWriter sw = new StreamWriter(rutaArchivo, append: true))
            {
                sw.WriteLine($"{DateTime.Now} : {mensaje}");
            }
        }
        public void LogException(Exception ex)
        {
            string error = $"ERROR: {ex.Message}";
            Log(error);
        }
    }

De igual forma la otra clase que implemente dicha interfaz la llamaré LoggerConsola y tendría esta apariencia:

   public class LoggerConsola : ILogger
    {
        public void Log(string mensaje)
        {
            Console.WriteLine($"{DateTime.Now} : {mensaje}");
        }
        public void LogException(Exception ex)
        {
            SetColor(ConsoleColor.Red);
            string error = $"ERROR: {ex.Message}";
            Log(error);
            SetColor(ConsoleColor.White);
        }

        private void SetColor(ConsoleColor color)
        {
            Console.ForegroundColor = color;
        }
    }

Como podrás notar crack, las clases que implementaron la interfaz tuvieron que definir los métodos que ella define, en otras palabras la interfaz tiene una signatura la cual se respeta en cada clase que implemente dicha interfaz.

Si esta entrada te ha gustado, compártela en tus redes sociales crack! 😉