Archivo de la categoría: 100

interfaces


Cuando se trata de generalizar nuestro código, existe otra forma posible de hacer esto, que tiene algunas diferencias en cuanto a su implementación, pero además ciertos usos que nos permiten definir mecánicas, inclusive con actores esto es programadores, externos que usen otros desarrollos.

Es el caso de las interfaces. Por definirlo brevemente, un interfaz es ni más ni menos, un contrato que debemos cumplir nuestro código.

La diferencia fundamental entre un interfaz y una clase base, es que la interfaz en sí misma no contiene código de ejecución. Sencillamente lo que hace este definir cómo se verán los objetos desde fuera.

A diferencia de lo que sucede con una clase base, un objeto definido por nosotros, puede implementar varias interfaces distintas, mientras que sólo puede heredar de una clase base.

Esto ha llevado a muchas discusiones teóricas, dado que en varios entornos se pretenden heredades de múltiples clase base. Aun cuando esto podría ser útil en ciertos y determinados casos, desde mi punto de vista, esto hace que el mantenimiento de ese código resulte mucho más dificultoso.

Llegado el caso de pretenderse heredar de múltiples clases, lo que debiera hacerse es definir en cascada las herencias, de modo tal de poder implementar código del más básico hasta el más especializado, y no hacer que se hereden desde clases base distintas.

Así, en el ejemplo que estábamos utilizando, la clase Vegetal que hereda de la clase SerVivo, podría a su vez ser heredada, por una clase Árbol.

Esta podría definir nueva propiedades, como tipo de raíces, formato de la hoja, cantidad ramificaciones, etc. Y luego tendríamos otras clases que al heredar de Árbol, también estarían heredando en forma indirecta de Vegetal y también de SerVivo.

Uso de Interfaces

Una cosa distinta son las interfaces. Un interfaz es, en definitiva, una especificación de algo que se debe cumplir, esto es, que cada clase  que implementa dicha interfaz, obligatoriamente debe exponer todos y cada uno de los miembros que la interfaz define.

Es en ese sentido que decimos que la interfaz es un contrato. Al existir, una biblioteca de código que conozca la interfaz, podrá acceder a cualquiera de sus métodos, aún sin tener una referencia directa, de la biblioteca de clases que implementa dichos métodos.

Esto se suele utilizar, cuando no podemos tener conocimiento claro o relación directa, con el conjunto de código con el cual vamos a tratar.

Imaginemos que por ejemplo, estamos creando un proceso, que necesita utilizar datos obtenidos de distintos orígenes, y que no sabemos a ciencia cierta, ni cuáles serán, ni cómo serán implementados.

O mejor aún, que estamos creando un componente, que sea capaz de realizar ciertas tareas, y que luego otra programadores pueden utilizar, en futuras aplicaciones o implementaciones de los orígenes de datos.

Inclusive a futuro, otro programadores de otras empresas, podrían implementar sus propios orígenes de datos sin tener que referenciar todo nuestro código, bastando sencillamente que conocieran las interfaces correctas.

Así, las interfaces podrían definirse en una biblioteca, que podría entregarse a cualquier programador externo, para que haga sus propias implementaciones de orígenes de datos, que luego nuestro componente o aplicativo pudiese utilizar sin mayores inconvenientes.

Criterios de definición de un interfaz.

Estos son los criterios básicos para la definición de cualquier interfaz.

  • No contiene código ejecutable.
  • No se pueden definir alcances: todos los miembros declarados en un interfaz son en forma predeterminada, públicos.
  • Se pueden definir tanto propiedades como métodos; si la propiedad es de sólo lectura o sólo escritura quedará consignado en la declaración del interfaz, y luego las clase que implemente solo podrán exponer estos métodos.
  • En la declaración se podrán utilizar tipo de datos personalizados, como podrían ser enumeraciones, clases personalizadas, estructuras, etc. Sin embargo, en dicho caso será conveniente, que estos tipos de datos se encuentran declarados en la misma biblioteca de clases que las interfaces, para mantenerlas aisladas del resto de los componentes, y así poder distribuirlos sin mayores inconvenientes.

Ejemplo.

El siguiente ejemplo muestra cómo sería la interfaz IVida, que se correspondería con nuestra clase base de SerVivo, si quisiéramos definir sus miembros aisladamente de la clase base.

Por convención, se suele definir el nombre de una interfaz, comenzando con I mayúscula.

VB

Public Interface IVida
    Sub Nacer()
    Sub Crecer()
    Sub Reproducir()
    Sub Morir()
    Sub GenerarEnergía()
End Interface

CS

 

interface IVida
{
    void Nacer();
    void Crecer();
        
    void Reproducir();
    void Morir();
        
    void GenerarEnergía();
}

Implementando la interfaz

 

Una vez definida un interfaz, cualquier clase que quiera indicar que cumple este contrato, deberá implementar la interfaz.

Como suele suceder, diferentes lenguajes de programación, utilizan distintos mecanismos para indicar esto. Para Visual Basic existe una palabra reservada, implements, mientras que el C#, se define exactamente igual que una herencia esto es, indicando después del nombre de declaración de la clase, el caracter dos puntos (:) y el nombre de la interfaz o interfaces que se implementan,  separados por comas. En el caso que además de implementar interfaces, se quisiera heredar de otra clase, el César la clase de la cual se hereda debe estar inmediatamente luego del carácter dos puntos.

Así quedaría entonces, la clase vegetal heredando de SerVivo e implementando IVida.

VB

Public Class Vegetal
    Inherits SerVivo
    Implements IVida
    Private Sub Fotosíntesis() Implements IVida.GenerarEnergía
    End Sub
End Class

CS

public class Vegetal : SerVivo,IVida
{
   
    private void Fotosíntesis() 
    {
    }
    void IVida.GenerarEnergía()
    {
        Fotosíntesis();
    }

Deberíamos resaltar que, mientras en Visual Basic la implementación de cada miembro de la interfaz es declarativa, utilizando la palabra reservada “Implements”, en C# la implementación se hace por coincidencia de nombre. Es por eso que, en VB, el método FotoSíntesis puede implementar directamente el GenerarEnergía de la interfaz, mientras que en C# se necesitan ambos métodos, y hacer la llamada en cascada.

Finalmente, un método que Implementa una interfaz en Visual Basic, puede ser privado (y por tanto, solo visible desde la interfaz), mientras que, nativamente, en C# debe cumplir con el alcance.

Sin embargo, como se ve en el ejemplo, el método que implementará interfaz, puedas hacerlo implícitamente, utilizando sólo el nombre del método, o como en este caso, explícitamente antecediendo al nombre del método, el nombre de la interfaz seguido por un punto.

Al hacer la llamada en cascada, el método que realmente posee el código, en nuestro ejemplo FotoSíntesis, queda declarado  igualmente como privado, con lo cual estamos obteniendo el mismo resultado final.

Son sencillamente, diferentes formas de hacer la misma cosa.

En la siguiente publicación, comenzaremos a utilizar combinatoria as de estas características, en un conjunto de bibliotecas que nos permitan realizar finalmente, tareas útiles.

Anuncios

Hablemos de Herencia (2)


Ya hemos visto en Hablemos de Herencia, los conceptos básicos de este tema.

Analicemos entonces como queda el código de lo ya definido, y algunas variantes al respecto.

Ser vivo.

Por recordar, esta era su representación gráfica.

image

Y así quedaría el código:

VB

Public MustInherit Class SerVivo
    Public Sub Nacer()
    End Sub
    Public Sub Crecer()
    End Sub
    Public Sub Reproducir()
    End Sub
    Public Sub Morir()
    End Sub
    Public MustOverride Sub GenerarEnergía()
End Class

CS

public abstract class SerVivo
{
    public void Nacer()
    {
    }
    public void Crecer()
    {
    }
    public void Reproducir()
    {
    }
    public void Morir()
    {
    }
    public abstract void GenerarEnergía();
}

Como vemos, la clase se declara como que debe heredarse (MustInherit en VB, abstract en C#), y luego se definen los distintos métodos.

El método que debe codificarse en las clases derivadas, se declara como MustOverride (VB), abstract (C#).

Presta atención que, en C#, el mismo término significa cosas distintas, dependiendo del entorno. No es muy común, pero a veces pasa.

En ambos casos, los métodos que deben codificarse en los descendientes, no tienen cuerpo (No hay End Sub en VB, ni llaves en C#, donde termina con punto y coma).

Las clases derivadas.

image

VB

Public Class Vegetal
    Inherits SerVivo
    Public Overrides Sub GenerarEnergía()
        Fotosíntesis()
    End Sub
    Private Sub Fotosíntesis()
    End Sub
End Class

CS

public class Vegetal : SerVivo
{
    public override void GenerarEnergía()
    {
        Fotosíntesis();
    }
    private void Fotosíntesis()
    {
    }
}

Como vemos, ese método “no implementado” en la clase base, se debe terminar de definir en las clases derivadas (“sobre escribirse”).

En ambos lenguajes, la definición es casi idéntica.

En Visual Studio, al definir que una clase hereda de otra, el entorno te indica “como error” que deben escribirse esos métodos y hasta se ofrece a generarte el esquema base Sonrisa

Se indica que una clase hereda por distintos mecanismos, según el idioma.

En Visual Basic, se declara taxativamente que hereda “Inherits” de otra clase.

En C#, ese concepto se “entiende” porque luego de la declaración de la clase, se sigue con dos puntos, y el nombre de la clase que se hereda.

A partir de aquí, se podrá seguir heredando para cubrir, progresivamente, mayores especializaciones y características.

Lo interesante, es que cualquier modificación de una clase base, se reflejará (en realidad, se “heredará”), en cualquiera de sus derivadas.

Esto de la herencia, en definitiva, nos permite “comprometer” que nuestro código se vea siempre de la misma forma, en todas las clases derivadas/heredadas. Aún cuando una clase heredada presente más miembros, si la “vemos” como una clase base, siempre encontraremos los mismos métodos.

Una clase vegetal vista como ser vivo

Una clase animal vista como ser vivo

Pero hay otra forma de “comprometer” tu código para cumplir un convenio.

Eso es tema de la siguiente publicación.

Hablemos de Herencia


Una de las características más importantes de la programación orientada a objetos, es la posibilidad de estructurar mostró código en distintos niveles o capas, de modo tal de poder ir encapsulando funcionalidades desde las más básicas hasta las más complejas, incluyendo modificaciones en la funcionalidad de cualquiera en otros objetos, dependiendo de con quién están tratando o qué tipo de datos se van manipular o acciones a realizar.

Sin embargo, esto tiene una contrapartida; si no se piensan adecuadamente las cosas a implementar, se puede caer en una Maraña de códigos que van llamando funcionalidades hay into niveles y por tanto a ser que dicho código resulte un poco inmanejable, o inclusive que tienda a a incrementar las posibilidades de error.

Por tanto, lo más importante de todo, más allá de conocer las distintas te indica y sintaxis respecto escritura de código, es la comprensión clara de que se trata precisamente esto de la herencia.

Desde la realidad.

La mejor manera de comprender esto entonces, es observar que es lo que sucede dentro de la naturaleza. Así por ejemplo, podemos consideran desde el punto de vista biológico, que absolutamente cualquier ente vivo compre cuatro funciones básicas a saber:

  • Nacer
  • Crecer
  • Reproducirse
  • Morir

Cada reino y cada especie a su vez, podrán realizar cualquiera de estas actividades de distinta forma e inclusive podrán incrementar sus características, dependiendo del grado el colectivo.

Tomemos por caso la producción de energía: en todos los seres vivos este hecho en necesario, pero la forma de hacerlo es totalmente diferente cuando hablamos del reino vegetal y el reino animal. Entretanto agreguemos sencillamente esta funcionalidad,  imprescindible en cualquier ente vivo.

  • Generar energía.

Así, el reino vegetal utiliza en General la fotosíntesis, mientras que en el reino animal la generación de energía se produce por mecanismos de digestión de los alimentos. Para decirlo muy genéricamente, los vegetales toman sol, los animales combing.

 

Sin embargo, cualquiera estados acciones están pensadas para obtener el mismo resultado: energía.

 

Si fuésemos must identificó extraterrestre, lo que trataremos de investigar es precisamente, más en estas cosas que están en el planeta tierra para generar energía. Nos encontraríamos entonces que investigando la generación, veríamos dos mecanismos totalmente diferentes entre sí (en realidad no son tan diferentes desde un punto de vista bioquímico dado que termina en procesos bastante similares y que en alguna parte son los mismos).

Podríamos entonces considerar que, cualquiera sea vegetal o animal hereby características que son comunes: las cinco que hemos indicado con viñetas.

Cierto es también, que alguna de esas actividades por ejemplo generar energía, si bien desde fuera (científico extraterrestre) lo veríamos cómo una sola acción, internamente cada uno de los reinos lo estaría realizando de maneras diferentes.

Esto nos lleva a entender algunas definiciones respecto the la exposición de las funcionalidades desde nuestros objetos hacía observadores externos, o para darles un hombre más adecuado a nuestro entorno, llamadores or instanciadores.

Interfaz

Una interfaz es en definitiva, un contrato que los objetos confirman respecto de cómo se exponen a sí mismos y como brindan sus funcionalidades de modo tal que cualquier otro objeto que pretenda utilizar los tenga claro cuáles son los mecanismos y propiedades que podrá encontrar en dichos objetos.

La interfaz en definitiva, es una tipificación de que miembros, entendiendo como miembros el conjunto de propiedades, métodos y eventos, que expone un objeto y cuáles son las posibles formas de utilizarlos en cada caso. Se dice que cada miembro expone una firma o sea el nombre por el que se lo llamará, los argumentos que puede recibir, y el tipo de valor que retornará.

A veces el propio objeto será responsable de exponer su interfaz, mientras que en otros casos la interfaz será declarada en forma independiente y luego implementada por el objeto en cuestión.

 

Además, en términos de herencia, una clase que sirve como base para definir otras puede ser responsable de definir la interfaz que va a ser común a todas ellas, aunque a su vez las descendientes podrán tener miembros agregados que modifiquen o expandan la interfaz de cada uno de ellos.

Ejemplo

En conclusión entonces, podríamos crear una clase para el ejemplo que esté utilizando llamada SerVivo que tendría cinco métodos, como se muestra en el siguiente esquema.

image

Una segunda clase que hereda de esta llamada Vegetal, y que dentro del miembro genera energía utilizará los métodos de fotosíntesis.

image

Y otra clase que hereda también de SerVivo, llamada Animal que en el miembro generar energía utilizará procedimientos de digestión.

image

Algunas cuestiones de imagen.

Tenemos bastante para hablar respecto de cómo se representa las cosas, sin embargo para esta primera entrega quiero dejarle claro los elementos que estamos viendo en estos tres gráficos.

En principio un rectángulo de bordes redondeados representa una clase: lo sabemos además porque debajo del nombre precisamente aparece la palabra class.

Cada método está definido por debajo del grupo métodos, como un cubo con el nombre del método su lado. En el caso de la clase SerVivo, uno de ellos aparece en cursiva porque si bien la clase y lo define, no lo tiene implementado; delega la implementación en cada una de las clases que heredan de esta; decimos entonces que ese método debe heredarse, y normalmente una clase  que tiene métodos con estas características pasa a ser también una clase que obligadamente debe heredarse.

Finalmente, los métodos Fotosíntesis de la clase Vegetal y Digestión de la clase Animal están representadas como métodos con un cubo pero con el icono de un candado abajo la derecha: esto significa que ese método es privado a la clase y por tanto no es accesible desde fuera por parte de ningún otro objeto. Los miembros GenerarEnergía de Animal y de Vegetal internamente deberán llamar cada uno al que le corresponde.

image

En la representación gráfica del conjunto completo, la clase SerVivo tiene un indicador de que debe heredarse y  a su vez las clases Vegetal y Animal indican con una flecha hacia la derecha que heredan de SerVivo. Finalmente el diagrama General no representa esto gráficamente con las flechas que apunta desde las clases derivadas hacia la clase base

En la próxima entrega estaremos analizando cómo quedaría dicho código.

Encapsular en tus clases


Cualquier conjunto de instrucciones que crees, deben estar necesariamente dentro de un miembro (member). Estos conjuntos de código deben estar contenidos en algún archivo que representa una unidad de código.

En Visual Basic, existen los módulos, que pueden cumplir esta función. (En realidad, esto se hereda de las primeras implementaciones del lenguaje, donde los miembros que se utilizaban como genéricos, podían estar en módulos globales).

Por herencia, esa funcionalidad sigue existiendo para el .Net Framework, pero C# no dispone de esa forma de contenedor. Para C# solo existen clases.

Esto no es ni malo, ni bueno.

Si se convierte un módulo de VB, a C#, basta con definir una clase como estática… y lo demás será igual (bueno, los miembros también deben declararse como estáticos).

Por otra parte, en el propio Visual Basic, también es posible declarar métodos estáticos.. pero no tiene la funcionalidad de clase estática.. para ello, ya tiene el módulo.

Considera que, una clase estática, podría ser como una biblioteca (y aclaro, es biblioteca NO “librería” Sonrisa ), de tus funciones personalizadas “de uso directo”. Por ejemplo, si haces muchos programas financieros, podrías tener métodos estáticos para cálculos de interés, de amortización etc.

Sin embargo, en muchas otras oportunidades, una clase podrá representar una entidad de tu problemática y en dicho caso, podrás considerarlas como plantillas para crear distintas ocurrencias de dichas entidades.

Pero, en definitiva, una clase es una plantilla (template), que contiene código relacionado. 

En ella, los miembros podrán ser de distinto tipo:

Propiedades

Representan los “atributos” de cada entidad (instancia). Por ejemplo, si quiero representar un color, podría definir una clase que exponga las propiedades Rojo, verde y azul.

Definirlas como propiedades, permite que se puede ejecutar código dentro de ellas. Así, cuando se le asigna un valor, establecer un cálculo, o validar que el valor esté dentro de un determinado rango.

O asignar un valor predeterminado cuando  otro código reclama el valor.

Estamos entonces definiendo que, en realidad una propiedad es una combinatoria de dos miembros: el de asignar el valor, y el de obtener el valor.

VB

        Private m_Rojo As Integer
        Public Property Rojo() As Integer
            Get
                Return m_Rojo
            End Get
            Set(ByVal value As Integer)
                m_Rojo = value
            End Set
        End Property

CS

        int m_Rojo = 0;
        public int Rojo
        {
            get
            {
                return m_Rojo;
            }
            set
            {
                m_Rojo = value;
            }
        }

 

Si embargo, se puede obviar una de las dos partes.

Dejar la propiedad como de solo lectura.

VB

        Private m_Rojo As Integer
        Public ReadOnly Property Rojo() As Integer
            Get
                Return m_Rojo
            End Get
        End Property

CS

        int m_Rojo = 0;
        public int Rojo
        {
            get
            {
                return m_Rojo;
            }
        }

 

Dejar la propiedad como de solo  escritura

VB

        Private m_Rojo As Integer
        Public WriteOnly Property Rojo() As Integer

            Set(ByVal value As Integer)
                m_Rojo = value
            End Set
        End Property

CS

        int m_Rojo = 0;
        public int Rojo
        {
            set
            {
                m_Rojo = value;
            }
        }

 

O definir la propiedad sin asignar código específico.

VB

Public Property Rojo As Integer

CS

        public int Rojo { get; set; }

Campos.

Son formas especiales de propiedades, que se basan en simplemente definir la variable, su tipo y su “exposición” (que nivel de otros objetos pueden utilizarlo).

Por lo demás, son variables dentro de la clase.

        Public Verde As Integer

        public int Verde;

Métodos.

Son conjuntos de código para ejecutar.

Podemos sub clasificarlos entre los que no retornan ningún valor (procedimientos), y los que si retornan un valor (funciones).

En C#, en realidad, todos retornan un valor (o sea, son funciones). Pero en el caso de no necesitar que retorne nada, se declara el tipo que se retorna como void.

 

        Sub HacerAlgo()

        End Sub
        Function RetornarAlgo() As Integer

        End Function

        public void HacerAlgo()
        {
        }
        public int RetornarAlgo()
        {
        }

Así mismo, un método admite que se le pasen argumentos:

        Sub HacerAlgo(argumento As String)

        End Sub

        public void HacerAlgo(string argumento)
        {
        }

Los argumentos pueden ser opcionales, en cuyo caso, se requiere que se le asigne un valor predeterminado. además, una vez que se declara un argumento como opcional, todos los que siguen deben serlo.

        Sub HacerAlgo(Optional argumento As String = "Valor")

        End Sub

        public void HacerAlgo(string argumento="Valor")
        {
        }

O declarar un conjunto de argumentos de los que no se conoce la cantidad. En este caso, se declara como vector, arreglo (Array), para que se asignen todos los que hagan falta.

        Sub HacerAlgo(ParamArray argumentos() As String)

        End Sub

        public void HacerAlgo(params string[] argumentos)
        {
        }

Dejamos para más adelante, definir otras cosas, como los eventos.

Pero con estos elementos, ya podremos empezar a crear cosas útiles.

Incluido en el envase… (del .Net Framework)


Realizar programas es como cocinar.  (Idea que he “robado” al amigo Miguel Egea, @miguelEgea https://twitter.com/miguelEgea). Combinar distintos ingredientes para obtener un resultado novedoso.

Comenzando con las sentencias, tipos de datos, variables que hemos visto previamente, hasta componentes pre armados “listos para usar”

Sin embargo, mucho de ese código debe realizar tareas complejas, de mucho cuidado, como manipular posiciones de memoria, acceder a recursos de hardware o sencillamente, realizar operaciones complicadas.

Esos conjuntos de códigos vienen pre armados y encapsulados en el .Net Framework,

El .Net Framework.

Podríamos describir el .Net Framework como constituido por 3 partes:

  • El motor de ejecución común (CLR).
  • El Conjunto de clases base
  • Los lenguajes de programación compatibles (en realidad, no solo los lenguajes, sino también sus compiladores)

El Motor de Ejecución Común.

Diagrama del CLR

Como vemos en la imagen, hay una serie de componentes que integran el CLR de modo de implementar en forma encapsulada, las acciones de bajo nivel.

Para destacar que hay un componente responsable de “cargar” los tipos (clases) en memoria asegurándose de darles el espacio suficiente, asignarle un identificador único, etc.

O el compilador de MSIL (que merece una aclaración): Para permitir que el mismo código pueda ejecutarse en distintas configuraciones de computación, éste no se compila en código binario sino en un “lenguaje intermedio” que luego, cuando se comienza a ejecutar, se termina de compilar a código nativo.  Aunque parezca más laborioso y demorado, la realidad es que es imperceptible para el usuario. Además, si realmente es preocupante este hecho (que no se justifica realmente), existe, entre las herramientas del .Net Framework un “compilador a código nativo” que se puede ejecutar en la máquina destino, para dejarlo ya listo. (NGEN.exe).

Otra parte interesante es el GC (Garbage collector, o recolector de residuos). Una de las problemáticas  en los anteriores mecanismos de programación de C++ a Visual Basic, era la posibilidad de “descuidar” las instancias de los objetos creados, que dejaban de ser referenciados por el código del programa… pero nunca se descargaba de memoria. El GC se encarga de ver revisar cada instancia y ver si “hay algún código en ejecución que la conozca”. Si no, se encarga de eliminarla. (En realidad, si la clase utilizara recursos de bajo nivel, primero se encarga de disponer dichos recursos para que no sigan en uso, y luego, descargar la instancia de la memoria). Otra consecuencia de esto, que se debe tener en cuenta, es que si un proceso crea una instancia de una clase, es factible que se le entregue una que está “en espera” en el GC para ser destruida, que es más rápido. Por ello se recomienda que no se asuma que las variables tengan valores predeterminados.  Es importante inicializar las variables en cada creación.

La biblioteca de Clases Base.

Biblioteca de Clases Base

Son todas aquellas clases que nos permiten interactuar directa o indirectamente con los recursos electrónicos de la máquina, memoria, procesador, periféricos, disco, y otros más complejos, pero, en todos los casos, el fundamento sobre el que se basa toda la ejecución.

Por ejemplo, los tipos de datos están todos definidos allí.

Vemos que además de las BCL, existen otros conjuntos ya pre armados, de funcionalidades específicas como manejo de datos, manipulación de XML, y especializaciones para funcionalidades de alto nivel, como formularios de ventanas de Windows, aplicaciones Web, etc.

La siguiente es una lista de los conjuntos de funcionalidades más importantes incluidas en la BCL.

  • Administración de componentes Web que corren tanto en el servidor como en el cliente (ASP.NET)
  • Administración de memoria
  • Aleatoriedad
  • Auto descripción de código
  • Cifrado de datos
  • Compilación de código
  • Generación de código
  • Herramientas de despliegue de gráficos (GDI+)
  • Herramientas de seguridad e integración con la seguridad del sistema operativo
  • Interacción con el API Win32 o Windows API.
  • Interacción con los dispositivos periféricos
  • Interacción con otras aplicaciones
  • Manejo de arreglos de datos y colecciones
  • Manejo de cadenas de caracteres y expresiones regulares
  • Manejo de datos (ADO.NET)
  • Manejo de idiomas
  • Manejo de tipos de datos unificado
  • Manejo del sistema de ventanas
  • Manejo y administración de excepciones
  • Manipulación de archivos de imágenes
  • Manipulación de fechas, zonas horarias y periodos de tiempo
  • Operaciones aritméticas
  • Transmisión y recepción de datos por distintos medios (XML, TCP/IP)

Pero.. ¿Que es una clase?.

En definitiva es la plantilla que incluye variables, propiedades, métodos y eventos relacionados con una funcionalidad específica. 

Cuando necesitas usar una, creas una instancia y luego comienzas a utilizarla.

Existe además una forma especial de clases de instanciación automática, que sirven para realizar tareas. En ellas, cuando se utiliza uno de sus miembros (propiedad o método), se instancia sola y sirve para cualquier otro uso durante la ejecución del programa completo. Se denominan clases estáticas.

Espacios de Nombres. (Namespaces)

Teniendo tantas variedades y posibilidades, se podría transformar en una maraña incontrolable el conjunto de código.

Para mantener el orden, se agrupan en espacios de nombres, que además pueden ser jerárquicos.

Así, por ejemplo, las clases que permiten conectarse con un servidor de datos SQL Server están en:

System.Data.SqlClient

Esto permite además agrupar conjuntos de clases por “autor” (veremos más adelante que los permisos de ejecución de un componente pueden administrarse basados en espacios de nombres y/o ensamblados, que veremos ahora mismo.

Así, cosas que Microsoft ha hecho específicos, están dentro de un espacio de nombres que comienza precisamente por Microsoft como por ejemplo:

Microsoft.Win32.SafeHandles

… y también podremos crear los nuestros.

Ensamblados.

Ensamblado NET

Uno o más espacios de nombres, se compilan en bibliotecas de carga dinámica (archivo de extensión DLL),  que ante tantas combinatorias posibles, necesitan ser más identificables, requieren descriptores de sus contenidos, pueden utilizar textos, imágenes y otros recursos que se utilizan por las clases. El conjunto de todos esos elementos se denomina Ensamblado.

Las descripciones se contienen en un manifiesto, que describen unívocamente el ensamblado completo, y los metadatos de tipo, que contienen la descripción de cada una de las clases (recordemos, una clase es la plantilla de in Tipo), contenidas en el ensamblado.

El ensamblado completo queda entonces contenido dentro del archivo dll.

Un detalle: Nada condiciona que un espacio de nombres este contenido en un ensamblado. así, tipos distintos de un mismo espacio de nombres, pueden estar contenidos en distintos ensamblados. Eso asegura extensibilidad en la funcionalidad. Si yo necesito, digamos, un par de clases del espacio de nombres “espacio1” debo definir una referencia al ensamblado (y su correspondiente dll) que la contiene.

Luego, si necesito otra clase, puede ser que “No la encuentre” dado que su funcionalidad, más específica, se haya incluido en otro ensamblado (aunque pertenezca al mismo espacio de nombres). Deberé entonces agregar una referencia al otro ensamblado.

 

En la próxima entrega, empezaremos ya a recorrer las BCL más importantes y generar código de herramientas útiles en general.

Dando vueltas.. (Repitiendo :))


Sigamos con esto de la lógica. Imaginemos que tenemos que repetir una tarea determinada cantidad de veces (como las tablas de multiplicar).

Tomemos ese ejemplo. Digamos, la tabla del 15 (de las otras imagino, te sabrás varias de memoriaSonrisa ).

Si dibujamos el proceso (imaginando la tabla de los primeros 20 valores), sería algo así:

Diagrama Tabla de Multiplicar

En principio, esto podría codificarse “literalmente”:

 VB

    Private Sub Tabla()
        Dim Contador As Integer = 1
        Dim Resultado As Integer
Seguir:
        If Contador > 20 Then
            Exit Sub
        End If
        Resultado = Contador * 15
        Print(Resultado)
        Contador = Contador + 1
        GoTo Seguir
    End Sub

 

CS

        private void Tabla()
        {
            int Contador = 1;
            int Resultado = 0;
        Seguir:
            if (Contador > 20)
            {
                return;
            }
            Resultado = Contador * 15;
            Print(Resultado);
            Contador = Contador + 1;
            goto Seguir;
        }

Nota: la sentencia Print en C# no existe. ahora vemos como se hace esto en realidad para probar.

Mejor un bucle.

Los lenguajes de programación implementan formas sintácticas optimizadas para estas cosas; los bucles For.

 

 VB

    Private Sub Tabla()
        Dim Resultado As Integer
        For Contador As Integer = 1 To 20
            Resultado = Contador * 15
            Debug.WriteLine(Resultado)
        Next
    End Sub

CS

        private void Tabla()
        {
            int Resultado = 0;
            for (int Contador = 1; Contador <= 20; Contador++)
            {
                Resultado = Contador * 15;
                Debug.WriteLine(Resultado);
            }
        }

La sintaxis de for admite indicar además los “pasos” en los que se ejecutan las  repeticiones, pudiendo hacerse en pasos de más de una unidad (de a dos, de a tres, etc.), o inclusive, en reversa (Indicando el paso como un valor negativo y el valor de inicio mayor que el final)

        For Contador As Integer = 20 To 1 Step -1

            for (int Contador = 20; Contador >= 1; Contador -= 1)

Repitiendo sin contar.

A veces es necesario hacer tareas por  cada uno de los elementos de un conjunto. Por supuesto se podrían contar cuantos son y meterlos dentro de un for.  Pero existe una sintaxis específica para esto, que podríamos parafrasear como “por cada uno de estos cosos…”

VB

        For Each elemento In estalista

        Next

CS

            foreach (elemento in estalista)
            {
                
            }

Repitiendo (mientras haga falta).

Esta sería la otra forma posible de repetición. Mientras se cumpla una condición se debe realizar la tarea.

Esto se realiza con dos palabras reservadas (Do y Loop), donde una (y solo una) de ellas lleva adosada la condición con la expresión While  o la expresión  Until que determinan el “mientras” o el “hasta que”.

VB

       Do While condición

        Loop
        '
        Do Until condición

        Loop
        Do

        Loop While condición
        '
        Do

        Loop Until condición

CS

            while (condición)
            {
            }
            //
            while (!(condición))
            {
            }
            //
            do
            {
            } while (condición);
            //
            do
            {
            } while (!(condición));

Poner la condición en el inicio condiciona si la tarea se realiza o no, ANTES de comenzar.

En cambio,  si la condición está en la instrucción final, significará que al menos una vez se hará, antes de evaluar la condición.

Mejorando la toma de decisiones


Ya vimos como se puede “traducir” de un proceso lógico, a sentencias en los lenguajes más comunes.

Sin embargo, esto, muy lineal, puede mejorarse utilizando las ventajas de los lenguajes. De eso va la publicación de hoy. Distintas formas de establecer lógica.

Los operadores lógicos.

La primera opción de mejora que tenemos, es la de combinar decisiones lógicas entre si: Esto es si tengo que preguntarme, por ejemplo, el tema de los meses:

image

En la publicación anterior, utilizamos 4 sentencias “if”, una detrás de otra. ¡Y sus respectivas acciones!  1530413_690331531007178_1565415261_n

Sin embargo, podríamos encadenar las comparaciones, como diciendo: “si el mes es 4, o es 6, o es 9, o es 11…” y para eso sirven los operadores lógicos.

Esta tabla contiene los más comunes.

Operador VB C# Detalles
Y And & Si ambas condiciones se cumplen
Y también AndAlso && Si la primera se cumple se evalúa la segunda
O Or | Si una u otra
O sino OrElse || Si la primera se cumple, no se llega a evaluar la segunda
O Excluyente Xor ^ Solo una de las condiciones ha de ser verdadera
NO Not ! Negación de la condición

Entonces, la codificación del ejemplo de la publicación, quedaría:

VB

        If mes < 1 
            OrElse mes > 12 
            OrElse día < 1 
            OrElse día < 1 
            OrElse día > 31 
            Then
            EsVálida = False
            Return EsVálida
        End If

CS

            if (mes < 1 || 
                mes > 12 || 
                día < 1 || 
                día < 1 || 
                día > 31)
            {
                EsVálida = false;
                return EsVálida;
            }

Encadenado de condiciones

A veces, no es cuestión de juntar condiciones, sino de establecer acciones dependiendo de distintas condiciones.

Si pasa esto, entonces hago a, pero si no pero pasa esto otro, entonces hago esto otro. A eso, lo podríamos denominar, “decisiones en cascada”.

Si la condición es if, y la acción por el opuesto es else, pero a su vez debo preguntar otra cosa, debería poner uno dentro del otro (anidado). Por ejemplo:

        If condición1 Then
        Else
            If condición2 Then

            End If
        End If

Sin embargo, existen sentencias más precisas para esto:

VB

        If condición1 Then

        ElseIf condición2 Then

        End If

CS

            if (condición1)
            {

            }
            else if (condición2)
            {
            }

Selectores de valor

A veces, las decisiones pasan por coincidencias de una variable con ciertos valores y de acuerdo a ello, se toman distintas acciones (como con los meses de 30 días, por ejemplo).  Para ello existen los “selectores de valor”. En ellos, se permite agrupar sentencias por ciertos valores específicos (uno o más), y además, se da la opción de realizar acciones cuando ninguno coincide.

VB

        Select Case variable
            Case valor1
                acción1()
            Case valor2
                acción2()
            Case valor3
                accion3()
            Case Else
                accionExcluyente()
        End Select

CS

            switch (variable)
            {
                case valor1:
                    acción1();
                    break;
                case valor2:
                    acción2();
                    break;
                case valor3:
                    accion3();
                    break;
                default:
                    accionExcluyente();
                    break;
            }

Los selectores posibilitan además, que una misma acción se aplique a varios valores:

VB

        Select Case variable
            Case valor1, valor2
                acción2()
            Case valor3
                accion3()
            Case Else
                accionExcluyente()
        End Select

CS

            switch (variable)
            {
                case valor1:
                case valor2:
                    acción2();
                    break;
                case valor3:
                    accion3();
                    break;
                default:
                    accionExcluyente();
                    break;
            }

A veces, se puede hacer “trampa” con los selectores.  EL ejemplo de la validación de fecha es un buen caso: hay varios motivos distintos por los cuales una fecha puede ser inválida. Entonces, se puede codificar, dentro del Select, todas ellas. Pero … estamos comparando días y meses… son cosas distintas (“cerdos con velocidad al cuadrado”, decía mi padre Sonrisa ).  Pero funciona.

VB

        Dim EsVálida As Boolean = True
        ' Selecciona cualquier caso que resulte verdadero
        Select Case True
            Case día < 1, día > 31, mes < 1, mes > 12
                EsVálida = False
            Case mes = 4, EsVálida = 6, mes = 9, mes = 11
                EsVálida = día < 31
            Case mes = 2
                If año Mod 4 = 0 Then
                    EsVálida = día < 30
                Else
                    EsVálida = día < 29
                End If
        End Select

CS

¡No Funciona!  En C# no se admite…

Una Nota:  Cuando una condición hace que la salida sea un valor verdadero o falso, no es necesario “encerrarlo” en un if. Como en la sentencia EsVálida = día < 30.

También, si debes preguntar si una variable contiene verdadero o falso, no cometas el error de preguntar si la variable es igual a verdadero. Más pasos del procesador para obtener el mismo resultado.

O sea, las dos sentencias que siguen, son idénticas… pero la de abajo es un poquito más rápida (se notará con muchos usos, no con uno solo).

VB

        If condición = True Then

        End If
        If condición Then

        End If

CS

            if (condición == true)
            {
            }
            if (condición)
            {
            }

En la próxima,  hablaremos de bucles y repetidores.

Pero… ¿Que es un programa?


Acostumbrados estamos a usar programas de todo tipo.

Pero la pregunta del título no es tan fácil de responder.

Los programas, como es obvio, evolucionaron, pero si podemos decir que hay algo básico que sigue siendo cierto:

Un programa es una sucesión de acciones.

Antaño, cuando programar no era tan sencillo (ni barato Sonrisa ), era necesario tener bien claro cada paso. Un programa podían ser de cientos de líneas… o sea cientos de tarjetas perforadas… que si había un error, habría que re codificar. Tiempo, costo, etc.

Por eso, se diseñó una metodología para esquematizar el programa y hacer pruebas de su funcionalidad previas a cualquier codificación.

La diagramación lógica.

Se basa en esquematizar un proceso paso a paso. Hay diseños estándar para representar los distintos tipos de actividades.

image 

Los “terminadores” (Inicio y fin), establecen precisamente eso, los extremos del proceso.

Las acciones, como se ve en el diagrama, se representa por rectángulos.

Por supuesto, a estas alturas, nadie usa diagramación lógica para programar. 

Sin embargo, en este blog haré uso de ellos; de cuando en vez,  echaré mano a ellos, para contarte mejor de que va algo.

Ejemplo simple (y, de paso, sentencias de control de flujo).

Si bien ahora el .Net Framework es capaz de hacer matemática de fechas (en realidad, desde bastante antes, lenguajes como Visual Basic, o los dBase, ya lo tenían), hubo épocas en que las fechas se debían ingresar en campos separados (día, mes y año), y luego validarla adecuadamente. Insisto, no es una problemática actual pero sirve para equiparar diagramas y códigos.

Aunque parezca simple, se lleva varios pasos.

  • El mes no puede ser menor de uno.
  • El mes no puede ser mayor que doce.
  • El día no puede ser menor de uno
  • El día no puede ser mayor que 31
  • Si el mes es abril, junio, setiembre o noviembre, el día no debiera ser mayor que 30.
  • Si el mes es febrero, no debiera ser mayor que 28, excepto si el año es bisiesto, que no podrá ser mayor que 29.

image

Bueno, como se ve, los rombos simbolizan preguntas (en realidad, toma de decisión lógica). No existe un “estándar” para indicar las salidas, aunque suelen marcarse con “si y no”. En el diagrama, usé colores, que también sirve.

La sentencia de decisión lógica.

En definitiva, es una pregunta:

SI sucede esto ENTONCES hacemos esto.

VB

        If condición Then
            acción()
        End If

CS

            if (condición)
            {
                acción;
            }

En ocasiones, es cuestión de tomar acciones alternativas, dependiendo del valor lógico, como la decisión del año bisiesto:

image

VB

        If Bisiesto Then
            If Día > 29 Then
                acción()
            End If
        Else
            If Día > 28 Then
                acción()
            End If
        End If

CS

            if (Bisiesto)
            {
                if (Día>29)
                {
                 acción;           
                }
            }
            else
            {
                if (Día > 28)
                {
                    acción;
                }
            }

En conclusión, el diagrama completo (exceptuando que en realidad las variables no existen), sería

VB

        EsVálida = True
        If Mes < 1 Then
            EsVálida = False
            Return EsVálida
        End If
        If Mes > 12 Then
            EsVálida = False
            Return EsVálida
        End If
        If Día < 1 Then
            EsVálida = False
            Return EsVálida
        End If
        If Día < 1 Then
            EsVálida = False
            Return EsVálida
        End If
        If Día > 31 Then
            EsVálida = False
            Return EsVálida
        End If
        If Mes = 4 Then
            If Día > 30 Then
                EsVálida = False
                Return EsVálida
            End If
        End If
        If Mes = 6 Then
            If Día > 30 Then
                EsVálida = False
                Return EsVálida
            End If
        End If
        If Mes = 9 Then
            If Día > 30 Then
                EsVálida = False
                Return EsVálida
            End If
        End If
        If Mes = 11 Then
            If Día > 30 Then
                EsVálida = False
                Return EsVálida
            End If
        End If
        If Mes = 2 Then
            Bisiesto = (Año Mod 4 = 0)
            If Bisiesto Then
                If Día > 29 Then
                    EsVálida = False
                End If
            Else
                If Día > 28 Then
                    EsVálida = False
                End If
            End If
        End If
        Return EsVálida

CS

            EsVálida = true;
            if (Mes < 1)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Mes > 12)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Día < 1)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Día < 1)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Día > 31)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Mes == 4)
            {
                if (Día > 30)
                {
                    EsVálida = false;
                    return EsVálida;
                }
            }
            if (Mes == 6)
            {
                if (Día > 30)
                {
                    EsVálida = false;
                    return EsVálida;
                }
            }
            if (Mes == 9)
            {
                if (Día > 30)
                {
                    EsVálida = false;
                    return EsVálida;
                }
            }
            if (Mes == 11)
            {
                if (Día > 30)
                {
                    EsVálida = false;
                    return EsVálida;
                }
            }
            if (Mes == 2)
            {
                Bisiesto = (Año % 4 == 0);
                if (Bisiesto)
                {
                    if (Día > 29)
                    {
                        EsVálida = false;
                    }
                }
                else
                {
                    if (Día > 28)
                    {
                        EsVálida = false;
                    }
                }
            }
            return EsVálida;

NOTA: Este código dista de ser óptimo y NO debe usarse como ejemplo…. solo es útil para entender la lógica. Ya veremos otras versiones.

Hasta la próxima.

Las variables


Cuando empezamos a trabajar en programación, obviamente nos encontramos en la situación que querer guardar valores para usarlos más tarde.

O sea, reservar un espacio en la memoria de la computadora (ordenador), por cada valor que queremos utilizar.

Obviamente, poder identificar cada una de las que quieras usar, implica darles un nombre. Ese es entonces el concepto de variable.

Por otra parte, en muchos (no en todos), los lenguajes de programación se puede decir además, que tipo de dato va a almacenarse allí.

Cada lenguaje de programación utiliza su sintaxis para esto, como los dos siguientes ejemplos, donde vemos declaraciones de una variable de tipo entero y otra para almacenar caracteres.

VB
    Dim Entero As Integer
    Dim Cadena As String

CS

 

        int Entero;
        string Cadena;

También es posible darle a cada variable un valor predeterminado.

(No solo se puede, Es lo recomendado, para que no haya errores) Sonrisa

    Dim Entero As Integer = 0
    Dim Cadena As String = ""
        int Entero = 0;
        string Cadena = "";

Obviamente esto vale para cualquier tipo de dato, inclusive objetos complejos. Y así, se reservan espacios para cualquier uso. Sin embargo, existen algunas cuestiones más para tener en cuenta.

Alcance. (Ámbito)

Se define como alcance o ámbito, la característica que determina en que parte del código existe realmente cada variable.

Para determinar esto, existen dos mecanismos distintos; uno posicional y otro declarativo.

Declarativo.

En la siguiente tabla vemos los modos posibles:

Tipo
Definición
CS
VB
Público La variable es visible en el mismo módulo de código y puede accederse desde fuera
public
Public
Privado Existe en el mismos segmento de código donde se declara
private
Private
Protegido Es visible para el mismo módulo y cualquiera que herede de él (este concepto es útil entre clases que veremos más adelante)
protected
Protected
Conocido (amigo) Es visible para cualquier conjunto de código dentro del mismo proyecto, pero no desde otros
internal
Friend
Protegido o conocido La combinatoria de ambas anteriores
(Considerando que una clase puede heredar de otra que se haya definido en otro proyecto o biblioteca de carga dinámica)
protected internal
Protected Friend

Posicional.

Por otra parte, una variable tiene el ámbito del conjunto de código dentro del cual se declara.

Cuando la declaración se realiza en el conjunto de código (clase, por ejemplo), estará disponible en todos y cada uno de sus miembros

Si en cambio, se declara dentro de un miembro, solo será hallable dentro del mismo.

Finalmente, si se declara dentro de un bloque de ejecución, por ejemplo, en el interior de un bucle de repetición, o una sentencia condicional, sólo será alcanzable dentro de éste, ni siquiera en el resto del miembro.

VB
Public Class Variables
    Private DeLaClase As Integer = 0
    Private Function EstoEsUnaFunción() As String
        Dim DeLaFunción As Integer = 0
        If condición Then
            Dim DelBloque As Integer = 0
        End If
        'Aqui no se ve la variable DelBloque
    End Function
    ' Aquí no se ven ni DelBloque ni DeLaFunción
End Class
    public class Variables
    {
        int DeLaClase = 0;
        string EstoEsUnaFunción()
        {
            int DeLaFunción = 0;
            if (condición)
            {
                int DelBloque = 0;
            }
            //Aqui no se ve la variable DelBloque
        }
        // Aquí no se ven ni DelBloque ni DeLaFunción
    }

Las variables genéricas

Antiguamente, los lenguajes de programación se dividían entre:

los que exigían tipificación de variables como COBOL, C, C++.

Los que no exigían declaración aunque permitían al programador establecer la obligatoriedad, la familia de los Basic: BASIC, BASICA, GWBASIC, Quick Basic, Visual Basic.

Los que no tipificaban las variables como la familia de los xBase, como dBase, Fox, Clipper, Visual Fox.

Cuando surge .Net, se establece la obligatoriedad de tipificar las variables en todos los casos.

Sin embargo, bajo ciertas situaciones, la tipificación estricta puede conllevar imposibilidades programáticas. Desde la aparición de la versión 3 del .net Framework, es factible declara variables no tipificadas, pero que el compilador haga lo necesario para que el código siga siendo estricto.

En C#, por ejemplo, aparece la palabra reservada var, para indicar la declaración de una variable sin tipificar.

            var a = 1;

En Visual Basic, la ya existente sentencia Dim hace las veces de “comodín” declarativo.

Dim a = 1

 

Sin embargo, ten en cuenta que cuando se compila, estas declaraciones “genéricas” se traducen al tipo que el compilador estima debe corresponder.

En General funciona… pero no siempre.

Los datos (por referencia)


Como decíamos en la publicación pasada, los datos simples, se pueden almacenar en tipos por valor. Pero si la cosa se complica un poco, entonces resulta imposible reservar el espacio o equipararlo a registros del procesador.

Tomemos, por ejemplo, las cadenas de caracteres: Si estuviésemos hablando de un caracter (el tipo char), ocupa lo mismo que un byte (en realidad, que 2, dados los caracteres especiales de idiomas no latinos). Cada letra, número o símbolo, se representa por una combinatoria de bits hay estipulada en tablas predefinidas. (Caracteres ANSI, ASCII, Windows.. hay varios ).

PERO, si queremos almacenar palabras (imprescindible), el tema se complica.

Antiguamente, se utilizaban tipos de datos declarados como variables de longitud fija (y lo que sobra, a llenarlo con espacios).

Además de una perdida de espacio, resulta bastante poco eficiente para, por ejemplo, editores de texto, aún cuando diccionarios, listas de palabras etc. .., podrían aprovecharse de ese tamaño fijo para proceder con ordenamientos o búsquedas más rápidas. Pero por lo demás, resulta imposible de administrar en todos los usos posibles.

Así, se define teóricamente una cadena de caracteres como… bueno, casi eso. Un arreglo, vector, matriz o tabla (array) de caracteres. Cada una, de su propia cantidad de elementos (dependiendo de las letras a almacenar).

EL procesador no se “copia” el dato… usa un puntero hacia donde se encuentre dicha cadena en memoria y utiliza la misma… asunto resuelto…

Hasta que hay que agregar caracteres. La memoria se reserva para los caracteres que contiene la variable. Si agrego caracteres, “más allá” de lo previsto puedo reemplazar parte de la memoria de otras cosas.. (¿Les suena “se ha producido un error de protección general y el programa se apagará?.. eso es, cuando “el Windows se cuelga” es porque alguien no controló este tipo de cuestiones).

Incrementar, reemplazar partes, reducir cadenas de caracteres es una operación de 3 pasos: copio la original en otra, insertando donde sea, cambio el puntero a la nueva dirección de memoria, y descarto el espacio anterior (o le digo al sistema, sencillamente, que puede usarlo).

Vamos, se complica. Y si encima, empezamos a definir tipos de datos más complejos, con mayor razón se deben operar como referenciados. Es lo que sucede con todos los otros tipos de datos.

Y si lo vemos desde la perspectiva del .Net Framework, hay algunas otras definiciones a tener en cuenta.

Dado que en el .Net Framework se utiliza mucho la herencia, (de la cual hablaremos más adelante), todos los tipos de datos tienen relación entre sí. De momento, digamos en general que, todo dato (tipo desde ahora) que se pueda almacenar hereda de un tipo súper básico: objeto (object).

Esto es tan así, que hasta los tipos por valor, que hablamos anteriormente, en la definición del .Net Framework, heredan de object.

Es por eso que todos los tipos de datos poseen algunos métodos que son comunes.

clip_image001

Y vamos a definir cada uno de estos métodos, para ir entendiendo como se hacen las cosas en .Net.

Equals

Compara el objeto actual con otro para evaluar si son iguales. Sin embargo, depende del tipo de dato que estemos hablando.

En el caso de los tipos por referencia, la comparativa se realiza utilizando ReferenceEquals.

Si los tipos son por valor, lo que se comparan son los valores.

GetHashCode

Obtiene el valor identificativo único de una instancia, específicamente pensado para ser manipulada dentro de una tabla o lista hash (como podría ser un diccionario)

Esto implica que no se puede confiar en este valor como identificativo único en el tiempo, ni entre aplicaciones. En realdad, salvo para el caso puntual de las listas mencionadas, no debiera considerarse dicho valor como útil.

GetType

Existe un tipo de dato en el .Net Framework que permite identificar cualquier otro. Esto es, cada tipo de datos es de un Tipo, y por lo tanto, hay un Type que lo representa.

El método GetType, nos permite obtener el tipo que define esta instancia en particular.

A su vez, el Type obtenido, nos permite identificar los miembros (Propiedades, campos, métodos, eventos) que ese tipo implementa.

MemberwiseClone

Crea una copia “superficial” del objeto en otro.

En tipos por valor, copia el valor bit a bit.

En tipos por referencia, copia el valor de la referencia, bit a bit… o sea que ambos apuntan a la misma instancia.

Si lo que se quiere es hacer una copia independiente (también llamada profunda), es necesario transferir todos los valores desde el origen al destino.

Algunos tipos implementan un método específico (CopyTo), para esto.

ReferenceEquals

Establece si el objeto referencia a la misma posición de memoria del objeto pasado como argumento. Así, sabremos exactamente si son el mismo, o no, aun cuando los valores de todas sus propiedades sean idénticos.

ToString

Genera una representación en cadena de caracteres del contenido del objeto. En muchos casos, lo que se retorna es el valor de dicha variable, representado como cadena (como es el caso de los tipos por valor en general). En cambio, en otros, la mayoría de los tipos por referencia, se retorna el nombre del tipo.

Sin embargo, muchos exponen formas complejas como ser tipo y valor principal… Esto depende de cómo se haya diseñado el objeto.

Pero, en sí mismos, se asume que el método ToString siempre retorna un valor significativo.

Así entonces, toda tipo, (insisto inclusive los que son por valor), heredan, directa o indirectamente, de Object y, por tanto, comparten estos métodos. Y aquí empieza la “magia” de esta historia.

Tenemos mucho que ver respecto de las herencias.

Hasta la siguiente.