Comparto la siguiente clase la cual sirve para crear el xml para la facturación electrónica, igual les recomiendo que vean los videos que se encuentran abajo para que sepan cómo utilizarla.
Etiqueta: POO
¿Cómo recorrer dinámicamente los atributos de un objeto en C#?
En c# existe una manera fácil para recorrer dinámicamente los atributos de un objeto, de la siguiente manera podemos obtener el valor de un objeto dinámicamente y también el nombre de sus atributos en forma de cadena, para ello haremos uso de la clase PropertyInfo con la cual podemos obtener la estructura de nuestro objeto, abajo comento y pongo un ejemplo simple para entenderlo:
Clase para el ejemplo:
public class Auto
{
public string Nombre { get; set; }
public string Marca { get; set; }
public string Modelo { get; set; }
public int Año { get; set; }
}
Y para realizar el recorrido de los atributos lo hacemos de la siguiente manera:
Auto oAuto = new Auto() { Nombre = "Mi auto", Marca = "Honda", Modelo = "Civic", Año = 2018 };
PropertyInfo[] properties = typeof(Auto).GetProperties();
foreach (PropertyInfo property in properties)
{
//así obtenemos el nombre del atributo
string NombreAtributo=property.Name;
//así obtenemos el valor del atributo
string Valor=property.GetValue(oAuto);
Console.WriteLine("El atributo "+NombreAtributo+" tiene el valor: "+ Valor);
}
Y el resultado:
El atributo Nombre tiene el valor: Mi auto
El atributo Marca tiene el valor: Honda
El atributo Modelo tiene el valor: Civic
El atributo Año tiene el valor: 2018
Si agregamos nuevos atributos a nuestra clase este algoritmo seguiría recorriendo dinámicamente todas la nuevas propiedades de nuestra clase.
Abstracción en la Programación – Curso de Programación Orientada a Objetos en 10 minutos #6
La abstracción es un tema poco visto cuando estamos en la universidad y estudiamos programación orientada a objetos. Se nos mencionan las clases abstractas, pero esto solo es parte de lo que es la abstracción. He decidido incluir este tema brevemente en este curso, ya que para mí esto es lo que hace la diferencia de un programador bueno de un programador malo, y no cuantos lenguajes de programación domine.
A lo largo de mi experiencia, he llegado a la conclusión que la abstracción nunca termina por mejorarse, y al momento que miras código tuyo de uno o dos años atrás y ves que es un desorden, esto quiere decir que has mejorado.
En breves palabras la abstracción es resumir o disminuir un elemento a lo que lo define sin incluir otros elementos, en este caso los objetos de la Programación Orientada a Objetos (POO). Para explicar esto siempre recurro al triangulo y al círculo, los dos son figuras geométricas, un triángulo tiene 3 lados y siempre tendrá 3 lados aquí y al otro lado del universo, y un circulo siempre será una línea conectada, esto es abstracción, se definen las figuras en una o dos líneas de descripción sin llegar a meternos en más detalle.
¿Pero esto para que nos sirve o qué? Sirve para hacer la diferencia de un mal programador a un buen o magnifico desarrollador de sistemas.
Ya dejando atrás el círculo y el triángulo veamos un ejemplo de día a día cuando se desarrolla un sistema.
Un sistema de ventas:
- El cliente pide un sistema que tenga usuarios.
- Los usuarios pueden ser clientes o vendedores o administradores.
- Los usuarios tendrán un password para acceder al sistema.
- Los clientes compran, los vendedores venden.
Lo que un programador con bajo nivel de abstracción hará es:
Creará una clase Administrador, una clase Cliente y una clase Vendedor y las tres tendrán el campo password el campo usuario y los métodos para autentificarse.
Por ejemplo:
Clase Administrador
class Administrador{
string usuario="";
string password="";
//todos los atributos de administrador por ejemplo
string nombre;
string apellido;
//etc
public bool Ingresar(string usuario, string password){
//codigo ingreso
}
public bool Salir(){
//codigo salir
}
//aqui metodos de administrador etc...
}
Clase Cliente
class Cliente{
string usuario="";
string password="";
//todos los atributos de cliente por ejemplo
string nombre;
string apellido;
string empresa;
//etc
public bool Ingresar(string usuario, string password){
//codigo ingreso
}
public bool Salir(){
//codigo salir
}
//metodos de cliente
}
Clase Vendedor
class Vendedor{
string usuario="";
string password="";
//todos los atributos de vendedor por ejemplo
string nombre;
string apellido;
string email;
decimal comision;
//etc
public bool Ingresar(string usuario, string password){
//codigo ingreso
}
public bool Salir(){
//codigo salir
}
//metodos de vendedor
}
Y esto es normal, funcionara y el sistema para el usuario estará perfecto, el problema viene cuando vienen los cambios en el sistema, por ejemplo nos piden modificar el método de acceso al sistema, digamos antes se hacía la conexión directa, ahora se hará por un webservice y utilizar un certificado. Entonces la cosa se convierte en un cambio en 3 sitios distintos, más trabajo por falta de abstracción, y si es más trabajo es más tiempo por lo cual es más caro y por lo cual es más crítico a darse errores.
Cuando una persona tiene un nivel más alto de abstracción podrá pensar en métodos alternativos para evitar estos problemas, estos métodos nacen por la experiencia que se tienen en sistemas hechos anteriormente y es cuando hacemos cosas más organizadas con un nivel más alto de abstracción como el siguiente ejemplo, que nos ayudaremos de la herencia:
Clase Usuario
class Usuario{
string usuario="";
string password="";
public bool Ingresar(string usuario, string password){
//codigo ingreso
}
public bool Salir(){
//codigo salir
}
}
Clase Administrador
class Administrador : Usuario{
//todos los atributos de administrador por ejemplo
string nombre;
string apellido;
}
Clase Cliente
class Cliente : Usuario{
//todos los atributos de cliente por ejemplo
string nombre;
string apellido;
string empresa;
//etc
//metodos de cliente
}
Clase Vendedor
class Vendedor : Usuario{
//todos los atributos de vendedor por ejemplo
string nombre;
string apellido;
string email;
decimal comision;
//etc
//metodos de vendedor
}
Nota: Los dos puntos (:) en c# sirven para heredar, lo mismo que en java es extends.
Como vemos los métodos de ingresos quedan en la clase Usuario de la cual todas las otras clases: Cliente, Administrador, Vendedor heredan, y esto ya muestra más madurez que las clases anteriores, ya que si surge un cambio en el ingreso solo tendríamos que modificar el metodo en la clase Usuario. Pero aun así podemos mejorarlo más analizando las similitudes de nuestras clases y viendo cómo podemos crear otra entidad por ejemplo una clase Persona que tenga el atributo nombre y apellido los cuales comparten las otras clases y a su vez que herede de Usuario.
El propósito de esta entrada es que ustedes como programadores no tomen a la ligera la manera que hacen y organizan su código, ya que esto puede ser la diferencia en ser un programador malo a uno bueno, a parte que si su código es formal y elegante puede ser fácil entendible por otro programador.
Con esto doy por terminado este curso de Programación Orientada a Objetos en 10 minutos, cualquier duda o comentario hágamelo saber en el apartado de comentarios o en el formulario de contacto.
Todo esto que hago es para todo los programadores que comienzan o de una u otra forma llegaron a un problema que yo ya solucione, y los comentarios son una motivación para mí. Gracias lector por visitar mi sitio web.
5.- Programación Orientada a Objetos (POO) – Curso Básico De #Javascript #5
La programación orientada a objetos, es el paradigma hoy en día mas utilizado en los lenguajes de programación, esto debido a su facilidad de organizar las cosas, y dividir la funcionalidad. Para aquellos que no han escuchado este término, se los explico brevemente (ya que lo explico en un breve curso: curso de Programación Orientada a Objetos en 1o minutos), la programación orientada a objetos (POO) nace por la necesidad de representar el mundo en el que habitamos (junto a sus problemas) por medio de objetos como nosotros los percibimos, con sus atributos y funcionalidades, por ejemplo un objeto auto, sabemos por sentido común que tiene llantas, tiene volante, tiene ventanas, puertas, a esto le llamamos atributos (variables), los cuales pueden variar de un auto a otro, pero la mayoría de autos deben tener todo esto para ser autos, de igual manera sabemos que un auto camina y frena, y a esto le llamamos funcionalidad la cual se representa por métodos (funciones). Este es un concepto breve y que servirá para el propósito que tenemos en este capítulo, el cual es representar objetos del mundo físico en javascript por medio de la POO(Programación Orientada a Objetos).
Para crear un objeto en javascript necesitamos de lo que en POO, llamamos clase; una clase es el molde para crear el objeto; la clase define que atributos debe tener el objeto y cuál es su funcionalidad y para ello vamos a ver un ejemplo de cómo representaríamos un Libro en javascript utilizando la POO, y la clase Libro se hace de la siguiente manera:
//clase Libro
function Libro(nombre,autor){
this.nombre=nombre;
this.autor=autor;
}
Podemos observar que su sintaxis es la misma que la de una función, excepto que dentro tenemos algo nuevo para nosotros, la palabra this, esto indica que dentro de esta función existen dos atributos, los cuales adquieren su valor por los parámetros enviados al invocar la función, estos atributos pueden ser utilizados posteriormente por nuestro objeto creado, pero para facilitar las cosas vamos a un ejemplo de cómo utilizar la clase creada anteriormente, y como acceder a sus datos:
//Objeto LibroTerror creado con la clase Libro
var LibroTerror= new Libro("En las montañas de la locura","Lovecraft");
alert(LibroTerror.nombre);
//esto mostraría en un alert nombre "En las montañas de la locura"
De esta manera queda claro cómo podemos crear estructuras para plasmar el mundo físico en javascript, pero que pasa con la funcionalidad, también nuestros objetos tienen funcionalidad, para ello vamos a crear una clase biblioteca, a la cual se le agregan libros, y para nuestra ventaja, con un método también podríamos saber que libros hay en la biblioteca(sin estar viendo en todos los libreros de esta, ¡bendita programación!), para ello veamos el siguiente ejemplo:
//clase Biblioteca
function Biblioteca(nombre){
this.nombre=nombre
//atributo arreglo para guardar los libros
this.Libros= new Array();
//metodo que agrega libros a nuestra biblioteca
this.addLibro=function addLibro(libro){
this.Libros.push(libro)
}
//método que muestra todos los libros utilizando un foreach en el arreglo Libros de esta clase
this.muestraTodosLosLibros=function muestraTodosLosLibros(){
var cadenaLibros="";
this.Libros.forEach(function(libro){
cadenaLibros+=libro.nombre+"n";
})
//regresamos los nombres de los libros concatenados
return cadenaLibros;
}
}
Ahora vemos que dentro de una función (que utilizamos como clase), existen otras funciones, estas funciones pueden ser llamadas por el objeto, también en una clase de javascript podemos tener arreglos, y a estos agregarle objetos los cuales nosotros creamos con anterioridad, y si somos cuidadosos, podemos observar que el método muestraTodosLosLibros() utiliza el forEach del capítulo anterior.
Pasemos a la parte divertida, ver como se utiliza la clase Biblioteca, para ello, pondré el código completo, el cual contiene comentarios parte por parte, pueden copiar y pegar en un archivo de texto con extensión html y abrirlo en un navegador, el código es el siguiente:
//clase Libro
function Libro(nombre,autor){
this.nombre=nombre;
this.autor=autor;
}
//clase Biblioteca
function Biblioteca(nombre){
this.nombre=nombre
//atributo arreglo para guardar los libros
this.Libros= new Array();
//metodo que agrega libros a nuestra biblioteca
this.addLibro=function addLibro(libro){
this.Libros.push(libro)
}
//metodo que muestra todos los libros utilizando un foreach en el arreglo Libros de esta clase
this.muestraTodosLosLibros=function muestraTodosLosLibros(){
var cadenaLibros="";
this.Libros.forEach(function(libro){
cadenaLibros+=libro.nombre+"n";
})
//regresamos los nombres de los libros concatenados
return cadenaLibros;
}
}
//creamos libros para nuestra biblioteca
var LibroTerror1= new Libro("En las montañas de la locura","Lovecraft");
var LibroTerror2= new Libro("Llamada del Cthulhu","Lovecraft");
var LibroNegro1= new Libro("El Psicoanalista","John Katzenbach");
//creamos un objeto de tipo Biblioteca
var BibliotecaPublica = new Biblioteca("Biblioteca Publica");
//Agregamos los libros a la biblioteca por medio del metodo addLibro()
BibliotecaPublica.addLibro(LibroTerror1);
BibliotecaPublica.addLibro(LibroTerror2)
BibliotecaPublica.addLibro(LibroNegro1)
//invocamos el metodo muestraTodosLosLibros del objeto Biblioteca
alert(BibliotecaPublica.muestraTodosLosLibros())
Para ver este código en acción den clic aquí.
En este capítulo vimos como crear clases para ser moldes de objetos, también vimos como dentro de nuestras clases podemos agregar atributos simples y complejos (arreglos), otra cosa que resalta es el poder poner funcionalidades a nuestros objetos, y de esta manera organizar nuestro código, de una manera elegante y formal.