Pop

Patrones de diseño software 13. Patrón comportamiento Iterator

13. Patrón comportamiento Iterator

  • Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.
  • En esta ocasión veremos el patrón de diseño Iterator. En diseño de software, el patrón de diseño Iterador, define una interfaz que declara los métodos necesarios para acceder secuencialmente a un grupo de objetos de una colección.El patrón surge del deseo de acceder a los elementos de un contenedor de objetos (por ejemplo, una lista) sin exponer su representación interna
  • El modelo de clases que utilizaremos para este ejemplo es el siguiente:
  • En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño
  • Os dejo el código de las diferentes clases vistas en el vídeo:
    •  Clase IteradorOrdenador.cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Iterator
{
    public class IteradorOrdenador
    {
        private ArrayList ordenador;
        private int posicion;

        public IteradorOrdenador(Ordenador o)
        {
            this.ordenador = o.datos;
            posicion = 0;
        }

        public Boolean existeSiguiente()
        {
            if (posicion < ordenador.Count)
                return true;
            else
                return false;
        }

        public Object siguiente()
        {
            object valor = ordenador[posicion];
            posicion++;
            return valor;
        }
    }
}

    •  Clase Ordenador.cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Iterator
{
    public class Ordenador
    {
        public ArrayList datos;

        public Ordenador()
        {
            datos = new ArrayList();
        }

        public Ordenador dameValor(int pos)
        {
            Ordenador o = null;
            if(pos<datos.Count)
                return (Ordenador)datos[pos];

            return o;
        }

        public void añadirValor(string valor)
        {
            datos.Add(valor);
        }

        public int dimension()
        {
            return datos.Count;
        }

        public IteradorOrdenador iterador()
        {
            return new IteradorOrdenador(this);
        }
    }
}
    •  Clase Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Iterator
{
    class Program
    {
        static void Main(string[] args)
        {
            Ordenador lista = new Ordenador();
            lista.añadirValor("Pentium 1");
            lista.añadirValor("Pentium 2");
            lista.añadirValor("Pentium 3");
            lista.añadirValor("Pentium 4");
            IteradorOrdenador iterador = lista.iterador();

            //Recorrido con el iterador
            while (iterador.existeSiguiente())
                Console.WriteLine(iterador.siguiente());

            Console.ReadLine();
        }
    }
}

Patrones de diseño software 12. Patrón comportamiento Strategy

12. Patrón comportamiento Strategy

  • Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.
  • En esta ocasión veremos el patrón de diseño Strategy. El patrón Estrategia (Strategy) es un patrón de diseño para el desarrollo de software. Se clasifica como patrón de comportamiento porque determina cómo se debe  realizar el intercambio de mensajes entre diferentes objetos para resolver una tarea. El patrón Strategy permite mantener un conjunto de algoritmos de entre los cuales el objeto cliente puede elegir aquel que le conviene e intercambiarlo dinámicamente según sus necesidades.
  • El modelo de clases que utilizaremos para este ejemplo es el siguiente:

  • En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño
  • Os dejo el código de las diferentes clases vistas en el vídeo:
    •  Interface IConexion
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Strategy
{
    interface IConexion
    {
        string conectar();

        Boolean conexionEstablecida();
    }
}

    •  Clase GestionarConexiones.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Strategy
{
    class GestionarConexiones
    {
        private IConexion conexion;

        public void ConexionesOracle()
        {
            this.conexion = new Oracle();
        }

        public void ConexionesSQL()
        {
            this.conexion = new SQL();
        }

        public string conectar()
        {
          return  this.conexion.conectar();
        }

        public Boolean conexionCorrecta()
        {
            return this.conexion.conexionEstablecida();
        }
    }
}

    •  Clase Oracle.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Strategy
{
    class Oracle : IConexion
    {
        Boolean conexionCorrecta = false;

        public string conectar()
        {
            conexionCorrecta = true;
            return "Conectando con BBDD ORACLE";
        }

        public Boolean conexionEstablecida()
        {
            return conexionCorrecta;
        }
       
    }
}

    •  Clase SQL.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Strategy
{
    class SQL:IConexion
    {
        Boolean conexionCorrecta = false;

        public string conectar()
        {
            conexionCorrecta = false;
            return "Conectando con BBDD SQL";
        }

        public Boolean conexionEstablecida()
        {
            return conexionCorrecta;
        }
    }
}

    •  Clase Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Strategy
{
    class Program
    {
        static void Main(string[] args)
        {
            GestionarConexiones gesConex = new GestionarConexiones();
            gesConex.ConexionesOracle();
            Console.WriteLine(gesConex.conectar());

            if (!gesConex.conexionCorrecta())
            {
                gesConex.ConexionesSQL();
                Console.WriteLine(gesConex.conectar());
            }

            Console.ReadLine();
            
        }
    }
}

Tutorial dialogFlow. Como crear un chatbot con inteligencia artificial(3/3)

3. Como crear un chatbot con inteligencia artificial

  • Hola a todos.En esta ocasión continuamos trabajando con Dialogflow. Para los que no lo conozcáis, se trata de un paquete para crear interfaces de conversación en sitios web, aplicaciones de dispositivos móviles, plataformas populares de mensajería y dispositivos de IoT. 
  • Nosotros estamos creando  un chatbot para atender las reservas de un restaurante.En esta ocasión aprendemos a realizar peticiones a la API/REST que tiene disponible esta plataforma para interactuar  desde nuestras diferentes aplicaciones. En nuestro caso el punto de entrada de la API es: https://api.dialogflow.com/api/query?v=20150910
  • Con estas consideraciones, podemos pasar a ver el vídeo donde explico como hacer las peticiones a la API de dialogflow.
  • La petición POST echa en el ejemplo (sin los datos de autenticación) es la siguiente:

{
  'event':{'name': 'welcome'},
  'timezone':'Europe/Madrid',
  'lang':'es',
  'sessionId':'1233845'
}

  • y la respuesta recibida es:
{
"id": "463aaa28-d99b-4d06-83f1-158d2259f98c",
"timestamp": "2019-05-05T11:53:51.364Z",
"lang": "es",
"result":{
"source": "agent",
"resolvedQuery": "welcome",
"action": "input.welcome",
"actionIncomplete": false,
"parameters":{},
"contexts":[],
"metadata":{"intentId": "7b2a8b96-40b0-432f-88d8-3c0ccd4303b9", "webhookUsed": "false", "webhookForSlotFillingUsed": "false",…},
"fulfillment":{
"speech": "Hola futuro cliente",
"messages":[
{"type": 0, "speech": "Hola cartera con patas"}
]
},
"score": 1
},
"status":{
"code": 200,
"errorType": "success"
},
"sessionId": "1233845"
}

Patrones de diseño software 11. Patrón comportamiento Memento

11. Patrón comportamiento Memento

  • Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.
  • En esta ocasión veremos el patrón de diseño  Memento, que es un patrón de diseño cuyo   objetivo principal es mantener los diferentes estados que puede tener un objeto, permitiendo la recuperación de los mismos en el tiempo.Es decir su  finalidad es almacenar el estado de un objeto (o del sistema completo) en un momento dado de manera que se pueda restaurar en ese punto de manera sencilla. Para ello se mantiene almacenado el estado del objeto para un instante de tiempo en una clase independiente de aquella a la que pertenece el objeto (pero sin romper la encapsulación), de forma que ese recuerdo permita que el objeto sea modificado y pueda volver a su estado anterior.
  • El modelo de clases que utilizaremos para el ejemplo es el siguiente:
  • En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño.
  • Os dejo el código de las diferentes clases vistas en el vídeo:
    • Clase Caretaker
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Memento
{

    //Clase para la gestión de objetos del tipo Memento
    class Caretaker
    {
        
        private ArrayList fechas = new ArrayList();
        public void agregarMemento(Memento m) { fechas.Add(m); }
        public Memento dameMemento(int index) { return ((Memento)fechas[index]); }
    }
}

    • Clase Horas.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Memento
{
    class Horas
    {
  
        private DateTime fecha;

        public  Memento guardarFecha()
        {
            return new Memento(this.fecha);
        }


        public  void restaurarFecha(Memento memento)
        {
            this.fecha = memento.DameFecha();
        }

        public DateTime dameFecha()
        {
            return fecha;
        }

        public void asignarFecha(DateTime f)
        {
            this.fecha = f;
        }
    }
}
    • Clase Memento.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Memento
{

   //ESta clase 
    class Memento
    {
  
        private DateTime fecha;

         public Memento(DateTime tiempo)
        {
            this.fecha = tiempo;
        }
        public  DateTime DameFecha()
        {
            return this.fecha;
        }
    }
}
    • Clase Program.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Memento
{
    class Program
    {
        static void Main(string[] args)
        {
            
            //instaciamos la clase que gesitiona nuestros mementos
            Caretaker caretaker = new Caretaker();
            // Creamos nuestros respectivos backups.
            Horas c1 = new Horas();
            c1.asignarFecha(DateTime.Now);

            System.Threading.Thread.Sleep(5000);

            Horas c2 = new Horas();
            c2.asignarFecha(DateTime.Now);

            //guardamos elementos
            Memento m1 = c1.guardarFecha();
            caretaker.agregarMemento(m1);
            caretaker.agregarMemento(c2.guardarFecha());

            //obtenemos los valores
            Memento memento1 = caretaker.dameMemento(0);
            Memento memento2 = caretaker.dameMemento(1);
            DateTime f1 = memento1.DameFecha();
            DateTime f2 = memento2.DameFecha();

            Console.WriteLine(f1.ToString());
            Console.WriteLine(f2.ToString());
            Console.ReadLine();

        }
    }
}

Tutorial dialogFlow. Como crear un chatbot con inteligencia artificial(2/3)

2. Como crear un chatbot con inteligencia artificial

  • Hola a todos.En esta ocasión continuamos trabajando con Dialogflow. Para los que no lo conozcáis, se trata de un paquete para crear interfaces de conversación en sitios web, aplicaciones de dispositivos móviles, plataformas populares de mensajería y dispositivos de IoT. 
  • Nosotros estamos creando  un chatbot para atender las reservas de un restaurante.En esta ocasión veremos el concepto de contexto. En una comunicación entre dos personas, el Contexto es el conjunto de circunstancias en las cuales se produce la conversación (lugar , tiempo etc.), para no perder el contexto en una conversación siempre es importante tener información de la frase anterior para seguir teniendo una comprensión en el mensaje
  • Con estas consideraciones, vamos a configurar los contextos en DialogFlow. En el siguiente vídeo podemos ver un ejemplo:


Tutorial dialogFlow. Como crear un chatbot con inteligencia artificial(1/3)

1. Como crear un chatbot con inteligencia artificial

  • Hola a todos.En esta ocasión empezamos a trabajar con Dialogflow. Se trata de un paquete para crear interfaces de conversación en sitios web, aplicaciones de dispositivos móviles, plataformas populares de mensajería y dispositivos de IoT. 
  • Nosotros crearemos un chatbot para atender las reservas de un restaurante.Nos servirá de ejemplo para entender su potencia y para aprender a utilizar esta herramienta que nos brinda google. Para empezar a utilizarla solamente necesitamos tener una cuenta de gmail e ir a esta página https://dialogflow.com/.
  • Una vez registrados podemos probar la herramienta.En este primer vídeo empezaremos a crear nuestro agente.Es un robot que nos permitirá atender las múltiples reservas de  nuestro restaurante imaginario:


Tensorflow. Identificación facial con inteligencia artificial (2/2)

2. Reconocimiento facial con inteligencia artificial (2)

  • Hola a todos.Una vez finalizado el curso de google, vamos a entrenar un modelo para hacer un ejemplo de identificación facial.Este ejemplo lo dividiremos en dos vídeos, que estructuraremos de la siguiente manera.
  • En este segundo vídeo vemos un ejemplo en tiempo real donde mi pc me identifica capturando una imagen vía webcam.
  • Os dejo el código visto en el vídeo:
#creamos nuestro reconocedor de imagenes
face_recognizer = cv2.face.LBPHFaceRecognizer_create()

#entrenamos nuestro reconocedor 
face_recognizer.train(caras, np.array(labels))

#función para dibujar un rectángulo en la imagen según coordenadas
def pintarRectangulo(img, rect):
    (x, y, w, h) = rect
    cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
    
#función que escibe el nombre
def escribirTexto(img, text, x, y):
    cv2.putText(img, text, (x, y), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 255, 0),

# esta función reconoce a la persona en la imagen pasada
#y dibuja un rectángulo alrededor de la cara detectada con el nombre 
def predecir(imagenTest):
    #copia de la imagen original
    img = imagenTest.copy()
    #detectamos cara en la imagen
    cara, rect = dameCaras(img)

    #Predecir la imagen utilizando nuestro reconocedor facial.
    label= face_recognizer.predict(cara)
    #obtenemos nombre de la imagen
    if label is not None:
        label_text = personas[label[0]]
        #dibujar un rectángulo alrededor de la cara detectada
        pintarRectangulo(img, rect)
        #escribir nombre
        escribirTexto(img, label_text, rect[0], rect[1]-5)
    
    return img

#Cargando imagenes de test
testImg0 = cv2.imread("test-data/test0.jpg")
testImg1 = cv2.imread("test-data/test1.jpg")
testImg2 = cv2.imread("test-data/test2.jpg")

#realizar predicción
prediccionImg0 = predecir(testImg0)
prediccionImg1 = predecir(testImg1)
prediccionImg2 = predecir(testImg2)
print("Predicción completa")

#display both images
cv2.imshow(personas[0], prediccionImg0)
cv2.imshow(personas[1], prediccionImg1)
cv2.imshow(personas[2], prediccionImg2)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import time 
from keras.models import load_model
def laptop_camera_go():
    # Crear instancia de captura de video.
    cv2.namedWindow("Deteccion facial")
    vc = cv2.VideoCapture(0)

    # capturamos el primer fotograma.
    if vc.isOpened(): 
        rval, frame = vc.read()
    else:
        rval = False
    
    # mantener el flujo de video abierto
    while rval:
        # trazar la imagen de la cámara con detecciones marcadas
        frame = predecir(frame)
        cv2.imshow("Deteccion facial activada", frame)
        
        # Funcionalidad de salida: presione cualquier tecla para salir del video de 
        #la computadora portátil 
        key = cv2.waitKey(20)
        if key > 0: # exit by pressing any key
            cv2.destroyAllWindows()
            for i in range (1,5):
                cv2.waitKey(1)
            return
        
        # obtener siguinete frame
        time.sleep(0.05)             # controlamos framerate
        rval, frame = vc.read()


laptop_camera_go()

Tensorflow. Identificación facial con inteligencia artificial (1/2)

1. Reconocimiento facial con inteligencia artificial (1)

  • Hola a todos.Una vez finalizado el curso de google, vamos a entrenar un modelo para hacer un ejemplo de identificación facial.Este ejemplo lo dividiremos en dos vídeos, que estructuraremos de la siguiente manera.

  • En este primer vídeo  preparamos la estructura del proyectos y los datos de entrenamiento de nuestro ejemplo:


  
  • Os dejo el código visto en el vídeo:
import cv2 #importamos modulo OpenCV 
import os #importamos módulo de lectura de directorio de datos de formación y rutas
import numpy as np

#Listado de personas a identificar
personas = ["Zidane","JAP SOFTWARE", "Will Smith"]

#funcion para detectar caras
def dameCaras(img):
    #convertimos imagen a la escala de grises
    gris = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # cargo el detector de caras de OpenCV 
    face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt.xml')

    # detectemos la multiescala (algunas imágenes pueden estar más cerca de la cámara que #otras)
    caras = face_cascade.detectMultiScale(gris, scaleFactor=1.2, minNeighbors=5);
    
    #Si no detectamos caras en la imagen devuelvo esto
    if (len(caras) == 0):
        return None, None
    
    #Extraemos el area donde esta la cara
    (x, y, w, h) = caras[0]
    
    #devuelvo la parte de la iamgen donde esta la cara
    return gris[y:y+w, x:x+h], caras[0]

# esta función leerá las imágenes de entrenamiento de todas las personas, detectará la cara 
#de cada imagen  y devolverá dos listas del mismo tamaño, una lista
# de caras y otra lista de etiquetas para cada cara
def prepararDatosEntrenamiento(ruta):
    
    #Obtengo la lista de directorios
    directorios = os.listdir(ruta)
    
    #lista para las caras
    caras = []
    #lista para los nombres
    labels = []
    
    #Recorremos la lista de directorios
    for nombreDire in directorios:
        
        #cada nombre de directorio debe ser un número que identifique a 
        #a la persona
        label = int(nombreDire)
        
        #construimos la ruta del directorio de cada persona
        rutaDirectorioPersona = ruta + "/" + nombreDire
        
        #obtenemos las imagens de cada sujeto
        listaImagenesPersona = os.listdir(rutaDirectorioPersona)

        #recorremos las imágenes de cada carpeta
        for nombreImagen in listaImagenesPersona:
            rutaImagen = rutaDirectorioPersona + "/" + nombreImagen
            #leer imagen
            imagen = cv2.imread(rutaImagen)
            
            #mostramos la imagen
            cv2.imshow("Entrenando............", imagen)
            cv2.waitKey(100)
            
            #detectar cara
            face, rect = dameCaras(imagen)
            
            #agregamos las caras detectadas a las lista de imagens y de etiquetas
            if face is not None:
                caras.append(face)
                labels.append(label)
            
    cv2.destroyAllWindows()
    cv2.waitKey(1)
    cv2.destroyAllWindows()
    
    return caras, labels

#obtenemos la listas con las caras y con su nombre
print("Preparandos datos...")
caras, labels = prepararDatosEntrenamiento("training-data")
print("Datos preparados")
print("Total caras: ", len(caras))
print("Total labels: ", len(labels))

Patrones de diseño software 10. Patrón estructural Bridge

10. Patrón estructural  Bridge

  • Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.
  • En esta ocasión veremos el patrón de diseño  Bridge que es un patrón parecido al patrón Adapter. Es útil cuando tenemos la necesidad de que la implementación de una abstracción sea modificada en tiempo de ejecución. Lo podemos aplicar cuando  queremos que los cambios en la implementación de una abstracción no afecten al cliente ó necesitamos que la implementación de una característica sea compartida entre múltiples objetos.
  • El modelo de clases que utilizaremos para el ejemplo es el siguiente:


  • En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño.
  • Os dejo el código de las diferentes clases vistas en el vídeo:
    • InterfaceEnvio:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bridge
{
    public interface InterfaceEnvio
    {
       string poocesarPedido();
       string enviar();
       string Entregar();
    }
}
    • Clases EnvioEspaña , EnvioMexico y EnvioPortugal:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bridge
{
    class EnvioEspaña:InterfaceEnvio
    {
        public EnvioEspaña()
        {

        }
        public string poocesarPedido()
        {
            return "Pedido procesado España";
        }

        public string enviar()
        {
            return "Pedido enviado España";
        }
        public string Entregar()
        {
            return "Pedido entregado España";
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bridge
{
    class EnvioMexico:InterfaceEnvio
    {
        public string poocesarPedido()
        {
            return "Pedido procesado Mexico";
        }

        public string enviar()
        {
            return "Pedido enviado Mexico";
        }
        public string Entregar()
        {
            return "Pedido entregado Mexico";
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bridge
{
    class Envioportugal:InterfaceEnvio
    {
        public string poocesarPedido()
        {
            return "Pedido procesado Portugal";
        }

        public string enviar()
        {
            return "Pedido enviado Portugal";
        }
        public string Entregar()
        {
            return "Pedido entregado Portugal";
        }
    }
}


    • Clase Amazon:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bridge
{
    public abstract class Amazon
    {
        protected InterfaceEnvio interfaceEnvio;
        public Amazon(InterfaceEnvio envio)
        {
           interfaceEnvio = envio;
        }
        public string  poocesarPedido()
        {
           return  interfaceEnvio.poocesarPedido();

        }

        public string enviarPaquete()
        {
            return interfaceEnvio.enviar();
        }

        public string entregarPaquete()
        {
            return interfaceEnvio.Entregar();
        }
        public void asignarEnvio(InterfaceEnvio envio)
        {
            interfaceEnvio = envio;
        }
        public InterfaceEnvio obtenerEnvio()
        {
            return interfaceEnvio;
        }
    }
}
    • Clase RepartoAmazon:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bridge
{
    class RepartoAmazon:Amazon
    {
        private String numPedido;
        
        public RepartoAmazon(String idPedido):base(new EnvioEspaña())
        {
                   this.numPedido = idPedido;
        }

        public RepartoAmazon(String idPedido, InterfaceEnvio envio):base(envio)
        {
            this.numPedido = idPedido;

        }
        public string  idPedido()
        {
            return "Nuestro pedido es " + this.numPedido;

        }
}
}

    • Clase Program:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bridge
{
    class Program
    {
        static void Main(string[] args)
        {

            // En primer lugar crearemos el objeto que representa a la emrpesa de mensajerio
            RepartoAmazon reparto  = new RepartoAmazon("123456");

            // Enviaremos el paquete a España por defecto
            Console.WriteLine(reparto.poocesarPedido());
            Console.WriteLine(reparto.enviarPaquete()); 
            Console.WriteLine(reparto.entregarPaquete());
            Console.ReadLine();
            //// Ahora queremos enviar a Mexico
            reparto.asignarEnvio(new EnvioMexico());
            Console.WriteLine(reparto.poocesarPedido());
            Console.WriteLine(reparto.enviarPaquete());
            Console.WriteLine(reparto.entregarPaquete());

            Console.ReadLine();
        }
    }
}


Patrones de diseño software 9. Patrón estructural Proxy

9. Patrón estructural  Proxy

  • Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.
  • En esta ocasión veremos el patrón de diseño  Proxy.  El patrón Proxy proporciona un objeto intermediario entre el cliente y el objeto a utilizar, que permite configurar ciertas características (como el acceso) sin necesidad de modificar la clase original. Podríamos definir a un Proxy como una clase o componentes que hace el papel de intermediario entre la clase que queremos utilizar el cliente que la esta utilizando.
  • Vamos a ver un ejemplo típico que consistirá en control de acceso mediante un proxy de protección.  Para ello vamos a imaginar un escenario en el que se desea realizar la descarga de cierto material que, pese a estar disponible públicamente,  no está permitida su posesión en el país del cliente.
  • El modelo de clases que utilizaremos para el ejemplo es el siguiente:

  • En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño.
  • Os dejo el código de las diferentes clases vistas en el vídeo:
    • Clases Servidor, ProxyMiServidor y MiServidor:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Proxy
{
    public abstract class Servidor
    {
        public abstract string descargar(String url);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Proxy
{
    public abstract class Servidor
    {
        public abstract string descargar(String url);
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Proxy
{
    class ProxyMiServidor:Servidor
    {
        MiServidor miServidor;
        private int puerto;
        private String host;
        public ProxyMiServidor(int p, String h)
        {
            puerto = p;
            host = h;
            miServidor = null;
        }
        public override string descargar(String url)
        {
            string resultado = String.Empty;
            if (restringido(url))
            {
                if (miServidor == null)
                    miServidor = new MiServidor(puerto, host);

                resultado= miServidor.descargar(url);
                
            }
            else
              resultado=  "Desde esta ubicación no puedes descargar.";

        

        return resultado; 
        }



        public Boolean restringido(string ruta)
        {
            Boolean descargaPermitida = false;
            if (ruta == "descargaPermitida")
                descargaPermitida = true;
            return descargaPermitida;
        }
    }
}

  • Clases Program:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Proxy
{
    class Program
    {
        static void Main(string[] args)
        {
            // Creamos el proxy a la página de descargas
            Servidor servidor = new ProxyMiServidor(20, "https://cursoprogramacioncsharptutoriales.blogspot.com/");
            // Descargamos un archivo permitido
            Console.ForegroundColor = ConsoleColor.Green;
           Console.WriteLine(  servidor.descargar("descargaPermitida"));
           Console.ReadLine();
            // Vamos a probar ahora con una descarga restringida
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(servidor.descargar("descargaDenegada"));
            Console.ReadLine();
        }
    }
}


Patrones de diseño software 8. Patrón estructural Facade

8. Patrón estructural  Facade

  • Hola a todos.Seguimos con  nuestro  curso dedicado a los patrones de diseño software.Los patrones de diseño son unas técnicas para resolver problemas comunes en el desarrollo de software y otros ámbitos  referentes al diseño de interacción o interfaces.
  • En esta ocasión veremos el patrón de diseño  Facade. Este patrón busca simplificar el sistema, desde el punto de vista del cliente, proporcionando una interfaz unificada para un conjunto de subsistemas.  Se debe utilizar cuando:
    • Se quiera proporcionar una interfaz sencilla para un subsistema complejo.
    • Se quiera desacoplar un subsistema de sus clientes y de otros subsistemas, haciéndolo más independiente y portable.
  • El modelo de clases que utilizaremos para el ejemplo es el siguiente:

  • En el siguiente  vídeo tenéis un ejemplo de este patrón de diseño.
    • Os dejo el código de las diferentes clases vistas en el vídeo:
      • Clases persona, Desarrollador, comercial y comprador:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    namespace Facade
    {
        public abstract class Persona
        {
        }

        class Desarrollador:Persona
        {
        }

        class Comercial:Persona
        {
        }

        class Comprador:Persona
        {
        }
    }

      • Clase Quejas:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    namespace Facade
    {
        class Quejas
        {
            public  string quejas(Comprador comprador)
            {
                return ("Escuchando quejas comprador");
            }
            public string quejas(Comercial comercial)
            {
                return ("Escuchando quejas comercial");
            }

            public string quejas(Desarrollador desarrollador)
            {
                return ("Escuchando quejas desarrollador");
            }
        }
    }

      • Clase Pedidos:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    namespace Facade
    {
        class Pedidos
        {
            public int precioProducto(Comprador comprador)
            {
                return 10;
            }
            public int comisionPedido(Comercial comercial)
            {
                return 5;
            }
        }
    }

      • Clase Empresa:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    namespace Facade
    {
        class Empresa
        {
            public  Quejas q;
            public Pedidos p;

               
            public Empresa()
            {
            
                q = new Quejas();
                p = new Pedidos();
            }

            private string quejas(Comprador comprador)
            {
                return q.quejas(comprador);
            }
            private string quejas(Comercial comercial)
            {
                return q.quejas(comercial);
            }

            private string quejas(Desarrollador desarrollador)
            {
                return q.quejas(desarrollador);
            }

            public void EscucharQuejas(Persona p)
            {
                if (p is Comprador)
                    quejas((Comprador)p);
                else if (p is Desarrollador)
                    quejas((Desarrollador)p);
                else
                    quejas((Comercial)p);
            }

            public int  hacerPedido(Comercial comercial, Comprador cliente)
            {
                return p.comisionPedido(comercial)+ p.precioProducto(cliente);
            }

            


        }
    }

      • Clase Program:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    namespace Facade
    {
        class Program
        {
            static void Main(string[] args)
            {
                Desarrollador programador = new Desarrollador();
                Comprador cliente = new Comprador();
                Comercial comercial = new Comercial();

        
                //SIN FACADE 
                Quejas queja = new Quejas();
                queja.quejas(comercial);
                queja.quejas(programador);
                queja.quejas(cliente);
                Pedidos pedido = new Pedidos();
                int totalPrecioPedido = 0;
                totalPrecioPedido = pedido.comisionPedido(comercial);
                totalPrecioPedido += pedido.precioProducto(cliente);

                //CON FACADE
                Empresa empresa = new Empresa();
                empresa.EscucharQuejas(programador);
                empresa.EscucharQuejas(comercial);
                empresa.EscucharQuejas(programador);
                totalPrecioPedido= empresa.hacerPedido(comercial, cliente);
        

            }
        }
    }





    Curso .NET Core en C# - 34.Creamos nuestro propio log

    34.Creamos nuestro propio log Hola a todos. En este curso, analizaremos todos los conceptos básicos, intermedios y avanzados de  ASP.NET...