Todas las entradas por Daniel Seara

Ver Acerca de

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.

Anuncios

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.

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


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

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.

Autenticación Azure y MVC


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/

Tipos de datos por valor en el .Net Framework


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.

Las herramientas


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)

Empezando de nuevo.


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.