Todas las entradas por Daniel Seara

Ver Acerca de
100

Pero… ¿Que es un programa?

Deja un comentario

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.

Anuncio publicitario
100

Las variables

Deja un comentario

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.

General

[C#] Microsoft Unity I – Introducción a la inyección de dependencias

Deja un comentario

Sumando buenas publicaciones de colegas. (y ahorrándome el tener que escribir :))

Todo en ASP.NET

Post de la serie:

Hola, inicio una serie de post sobre la inyección de dependencias, la inyección de dependencias conocida por las siglas DI por su nombre en inglés Dependency Inyection, es un patrón de diseño altamente utilizado en aplicaciones medianas/grandes que requieren un ciclo de vida especial durante todo su proceso de desarrollo y mantenimiento, en este primer post no vamos a ver código (al menos no mucho), ya que quiero hablar del por qué DI es importante y que beneficios obtenemos al utilizarla.

Durante el proceso de desarrollo de software y espero que no sea tu caso (a mi si que me ha pasado) es posible que algunos requerimientos cambien o bien que se añadan nuevos, esto puede ser dado no solo por el cliente, dichos cambios pueden venir de…

Ver la entrada original 662 palabras más

100

Los datos (por referencia)

Deja un comentario

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.

300

Autenticación Azure y MVC

Deja un comentario

Donde explico como desarrollar e implementar MVC con autenticación en Dominio Azure.

Parte I. Creando el sitio Web

En Visual Studio 2013, hay asistentes que permiten integrar rápida y fácilmente los mecanismos de identificación centralizada provistos por Windows Azure y tus propias aplicaciones MVC.

Para comenzar es útil tener un dominio en una suscripción de Azure. (Obviamente, primero tener una suscripción… :). Hay de prueba, antes que te preocupes.Pero debes planificarlo bien, ya que duran poco http://azure.microsoft.com/es-es/pricing/free-trial/ ).

Entrando al administrador de la suscripción (https://manage.windowsazure.com), en la barra de opciones a la izquierda, selecciona Directorio Activo. Azure Active Directory
Allí podrás agregar un directorio que te permita administrar seguridad.

Al crear un proyecto nuevo, y seleccionar que el mismo será Web, existe la opción de cambiar la forma de identificación (Autenticación) de los usuarios.

Nuevo MVC con Autenticación Azure

Nota: lamentablemente, en ediciones anteriores de VS, era posible hacer esto DESPUÉS de haber comenzado el proyecto. En VS 2013, esa opción no aparece. 😦

Al cambiar la autenticación, permite seleccionar Autenticación de una organización, e indicar el dominio (el que creamos previamente)

Autenticación Organizacional

Esto deja elementos de configuración en el web.config de la aplicación, que configuran la relación entre el directorio de Azure y tu aplicación.

Además, agrega al proyecto, las clases necesarias para configurar dicha relación, establecer los objetos necesarios en la base de datos predeterminada del proyecto y controlar la adecuada identificación en cada parte del sitio (manejable por atributos) .

Por otra parte, establece configuraciones en Azure, que permiten la interrelación entre tu proyecto y el dominio de autenticación, como podemos ver en la imagen 3

App Web en Directorio Azure

Entre dichas configuraciones, quiero remarcar que la url de re direccionamiento post identificación, apunta a tu propio sitio como http://localhost:[puerto] para permitirte hacer todas las pruebas necesarias.

Pasar a producción

Cuando publicamos nuestro desarrollo a un sitio web Azure, el propio proceso de publicación también nos permite relacionar el sitio publicado con nuestro mecanismo de autenticación, por una casilla de selección específica.

App Web Publicación

Sin embargo, el sitio falla ya que intenta redirigir a “localhost” :).

Si investigamos un poco, vemos que se crean entradas para cada aplicación, bajo el “dominio”, y en este caso, hay dos, una para la versión local, y otra para la publicada.

App Web Publicada

Lo que necesitamos es… cambiar el archivo de configuración.

Mantener el orden.

Lo ideal es, siempre, tratar de automatizar estos cambios, de modo de no tener que “recordarlo” cada vez.

Dado que al publicar, se procesa el proyecto en modo “release”, aprovecharemos esa circunstancia para que automáticamente se modifique el archivo de configuración para ello.

En el web.config original, estas entradas definen la autenticación con Azure.

    <add 
      key="ida:FederationMetadataLocation" 
      value="https://login.windows.net/xyz.onmicrosoft.com/../FederationMetadata.xml" />
    <add 
      key="ida:Realm" 
      value="https://UniversidadNet.onmicrosoft.com/UniversidadNet" />
    <add 
      key="ida:AudienceUri" 
      value="https://UniversidadNet.onmicrosoft.com/UniversidadNet" />
    <add 
      key="ida:ClientID" 
      value="z1y3x6ey-y891-991a-a316-36631836x1yx" />
    <add 
      key="ida:Password" 
      value="aA\A1YA8VN5AY80PAqvvcA\l868Yieoz\vfVsFHAs\U=" />

Entonces, editando el archivo web.release.config, podemos hacer que las mismas cambien por los valores correspondientes para la versión “publicada”.

En el Explorador de Soluciones, hacemos clic en el botón “ver todos los archivos”, VS Ver Todos los archivos   veremos que hay 2 archivos que extienden el web.config, entre ellos, el web.release.config que necesitamos editar.

App Web Configs

Si vamos a la suscripción Azure, específicamente a la aplicación recién generada dentro del Directorio, podremos obtener los valores para el sitio público, en la opción de configuración.

Por cierto, vas a tener que generarte una clave para poder copiarla, ya que la autogenerada queda oculta.

Con esos datos, agregamos entradas en el web.release.config, agregándole los modificadores 

xdt:Transform="SetAttributes" xdt:Locator="Match(name)"

para que reemplacen esos valores en la compilación para publicación (release),  de la siguiente forma:

    <add
      key="ida:FederationMetadataLocation"
      value="https://login.windows.net/xyz.onmicrosoft.com/../FederationMetadata.xml"
      xdt:Transform="SetAttributes" xdt:Locator="Match(name)"
      />
    <add
      key="ida:ClientID"
      value="NUEVOIDy-y891-991a-a316-36631836x1yx"
      xdt:Transform="SetAttributes" xdt:Locator="Match(name)"
    />
    <add
      key="ida:Password"
      value="aA_A1YA8VN5AY80PAqvvcA_l868Yieoz_vfVsFHAs_U="
      xdt:Transform="SetAttributes" xdt:Locator="Match(name)"
    />
  • ida:FederationMetadataLocation
  • ida:ClientID
  • ida:Password

Solo los tres valores mostrados son necesarios, colocándoles los atributos correspondientes a la aplicación de producción

Lo mismo valdrá para cualquier configuración que utilicemos (un ejemplo típico es la cadena de conexión a la base de datos, que aparece como ejemplo en el web.release.config).

Por cierto, Gise @0GiS0 ), está publicando otras cuestiones relacionadas con Aplicaciones en Azure, como por ejemplo, crear una máquina virtual para tu sitio Web, desde Visual Studio.  http://www.returngis.net/2014/04/integracion-de-visual-studio-con-microsoft-azure-virtual-machines/

100

Tipos de datos por valor en el .Net Framework

2 comentarios

Un programa no es ni más ni menos que una automatización que se aplica a un conjunto de información, de datos.

Algunas veces son los datos de un elemento en particular, otras de muchos datos similares. A veces son cosas que pasaron antes, y otras, los sucesos del mismo momento (un juego, por ejemplo).

Sin embargo, sigue siendo, siempre, manipulación de datos.

Los usamos en la vida diaria, los usamos en cada momento en un programa, o en una aplicación que usamos… y sin ton ni son, sin entender muy bien que son, como son, como los entiende un procesador… así que, a ello vamos. A definir los datos.

Empecemos por entender que hace el procesador con los datos.

Calculando. (lo primero que hicieron los procesadores)

Desde el principio de la historia (informática :)), ha sido igual. Empezar por hacer algo del estilo 2+2=4 .. Pero muchas veces y muy rápido.

Eso se hace “moviendo” datos a espacios particulares e la circuitería del procesador, llamados registros. Los procesadores modernos se basan en la arquitectura IA32 (que se extendió este siglo a la IA64) ya que por una parte es eficiente y por otra, mantienen compatibilidad.

Se podría hablar mucho de esto, pero la realidad es que nos importa entender, desde el punto de vista de los datos, algo muy básico. Los datos se cargan y operan en los registros de maneras muy simples.

  1. Se mueve un valor a un registro
  2. Se mueve el otro valor al segundo registro.
  3. Se aplica el operador
  4. Se obtiene un resultado (por ser simple, digamos en el primer registro)

Por ejemplo:

Reg A 2   00000010
Reg B 2   00000010
  + 4 00000100

Esto es fácil de entender, ya que estamos operando con números simples. Y así era, al principio. Números enteros, fáciles de operar.

Otro ejemplo clásico es la operatoria de lógica.

Digamos que tengo un valor de verdad (1) y un valor de falsedad (0) y operamos lógicamente. Esto es:

  AND OR
1 0 1
0 0 1
0 1

Por esto, cada cálculo se optimiza para los registros. En conclusión, los valores numéricos (enteros sobre todo), son los más rápidos y manejables.

Y las operaciones se hacen moviendo los valores de alguna parte de la memoria de trabajo, en los registros, ida y vuelta. Eso es por lo que se suele hablar de “tipos (de datos) por valor”.

En cambio, cuando no es posible utilizar esta operatoria, el procesador utiliza las referencias a los lugares en la memoria (direcciones), donde se encuentra los datos, y opera contra ellos. Más efectivo, pero mucho más lento. Entonces, ante estos datos, se realizan las operaciones pero con “punteros” que dirigen a la memoria (existen registros especiales del procesador para esto). Estos son, entonces, los “tipos por referencia”.

En el .Net Framework, tenemos entonces:

Tipos por Valor

Fe de e-ratas En la tabla, donde dice que char mide 1 byte, debiera decir 2 bytes. (Gracias Ivanov!). Es que son caracteres de doble byte, para que pueda almacenar cualquier idioma (por ejemplo, Klingon Klingon )

Tipos por valor:

Finalmente, existen algunos pocos tipos de datos definidos por el programador que heredan naturalmente de ValueType (no es posible declarar herencia explícita).

Enumeraciones

Un tipo de dato, que naturalmente hereda de alguno de los anteriores, pero que solo exponen algunos valores, por ejemplo

Visual Basic
Enum DíasSemana As SByte
    Domingo
    Lunes
    Martes
    Miércoles
    Jueves
    Viernes
    Sábado
End Enum

C#
    enum DíasSemana : sbyte
    {
        Domingo,
        Lunes,
        Martes,
        Miércoles,
        Jueves,
        Viernes,
        Sábado
    }

Estructuras

Son tipos definidos por el usuario que admiten varios campos en la definición. Llamativamente, heredan de ValueType aun cuando en su definición contengan tipos por referencia. Sin embargo, esos tipos por referencia solo tienen la dirección de OTRA posición de memoria donde se almacena dicho objeto.

Visual  Basic
Structure Estructura
    Public Entero As Integer
    Public Lógico As Boolean
    Public cadena As String
End Structure

C#
    struct Estructura
    {
        public int Entero;
        public bool Lógico;
        public string cadena;
    }

Los tipos por referencia

Hablamos de tipos de datos por referencia, cuando el procesador debe “saltar” de sus registros (especiales para referencias), a la dirección de memoria donde está ubicado el dato y volver luego a seguir con lo suyo. Siendo este proceso más lento es, sin embargo, mucho más versátil.

Por otra parte, los datos por referencia nos permiten mucha mayor versatilidad ya que podemos almacenar información diferente, compuesta y compleja. Obviamente, en la mayoría de los procesos, estos tipos de datos son los más utilizados. Pero recordemos siempre que procesar tipos por valor es más rápido.

En la próxima hablaremos de tipos por referencia en detalle, objetos y… seguimos.

100

Las herramientas

Deja un comentario

La idea es que podamos hacer y probar muchas y variadas cosas. Por ello, estuve buscando que herramientas tenemos disponibles que no impliquen costo alguno, de manera de facilitar la posibilidad de hacer pruebas y entrenar”.

Teniendo la posibilidad de hablar de muchas cosas, se me ocurre que lo mejor es tener una plataforma lo más completa posible.

El equipo

.

Idealmente, Windows 7. Windows Xp puede servir, pero hay muchas cosas que se te van a complicar.

Vamos a comenzar con cosas de código básico, pero tarde o temprano, usaremos datos. Así es que, un servidor de datos nos vendrá bien. Y de paso, hablaremos mucho de datos y demás.

Lo que usaremos

 

  1. SQL Server Express que podrás descargar de aquí http://www.microsoft.com/es-es/download/details.aspx?id=29062
  2. “Los” Visual Studio 2013 Express, que puede descargar aquí: http://www.visualstudio.com/en-us/products/visual-studio-express-vs.aspx

Seguro que usaremos:

  • Express 2013 for Web
  • Express 2013 for Windows Desktop

Y más adelante, seguramente:

  • Express 2013 for Windows

(Pero para este, necesitarás tener Windows 8)

Respecto de las instalaciones, es cosa de instalar. Solo te dejaré algunas recomendaciones

SQL Server 2012 Express

  1. Asegúrate de usar el SQLEXPRADV_x64_ESN (lo de ESN es porque es en español, pero tú verás)
  2. Considera instalar todas las opciones, incluyendo LocalDB, que algo haremos
    Opciones de SQL Express
  3. También, habilita el FileStream, a ver si surge alguna cosa que podamos aprender con él.

100-02_02 Filestream 

VS2013.

Instálalo, así como dice. 🙂 (otra no queda)

General

Empezando de nuevo.

2 comentarios

Hace unos años atrás, (si, si, muchos, ya sé), estábamos hablando de los principios de .Net.

Y las cosas fueron evolucionando, y pasaron ya 4 versiones.

Se agregaron (y desaparecieron algunas también), muchas funcionalidades, y bibliotecas, lenguajes y códigos, sentencias y ejemplos y…

Claro, ahora, por suerte, hay mucha gente publicando muchas cosas. Y da gusto ver cuanta tecnología y cuanta complejidad se publica a diario. Es una ventaja enorme que todos dispongan de tanta información.

Por otra parte, a veces se transforma en una gigantesca aventura entender los principios básicos de todo esto, entre tanta cosa.

Por eso, decidí que lo mejor que podía hacer era… empezar desde el principio.

Algunas cosas podrán parecer demasiado simples… si es así, habré conseguido el objetivo buscado.

Aquí lo que quiero lograr es que encuentres referencia a aquellas cosas que se fueron perdiendo entre tanta especialización.

Por cierto, si echas en falta algo, pues lo pides. Así, sumamos entre todos.

Finalmente, no quiero cerrar esta primera introducción sin agradecer a mi amigo Guille @elGuilleInfo, http://www.elguille.info/ que siempre me insiste en publicar, y me empuja a hacer más.