Archive for October, 2007
October 30, 2007 a las 6:56 pm por Edwin Plauchu · Archivado en Programacion
Google ofrece un webservice en la siguiente URL http://api.google.com/GoogleSearch.wsdl
Para hacer uso de esto, basta con generar el codigo fuente de este servicio en c#, con la utileria en linea de comando “wsdl”:
wsdl GoogleSearch.wsdl
Esto nos dara como resultado “GoogleSearchService.cs”.
El cual compilaremos de la siguiente manera con el mcs:
mcs /target:library GoogleSearchService.cs
-r:System.Web.Services
En tan solo un par de lineas el compilador ha generado un libreria, con referencia(-r:) a la libreria System.Web.Services.
Listo, ahora tiene una libreria final: “GoogleSearchService.dll” que le permitira consumir el servicio web que google le ofrece.
October 30, 2007 a las 6:52 pm por Edwin Plauchu · Archivado en Programacion
Como enlazar una dll (LibreriaExterna.dll) que maquile en visual studio a mi codigo c#, usando mcs ?
Solucion:
mcs -out:salida.exe -target:exe -r LibreriaExterna.dll
Fuente1.cs Fuente2.cs
En MonoDevelop usa References en boton derecho sobre el proyecto y agrega la dll como referencia.
October 30, 2007 a las 5:58 pm por Edwin Plauchu · Archivado en Programacion
Consideremos que Python implementa algo parecido de lo que es la reflexion sobre otros lenguajes como java. En pYthon veremos una implementacion donde los MOP( meta-objectos), y objetos base son compilados dentro de una entidad, la Clase Object del lenguaje Python. En la implementacion, todas las funciones para agregar/modificar/borrar atributos y metodos son encapsulados en el archivo classobject.c (con este encabezado). En Python, El cambio de esencia, sobre la estructura general de lo que es un interprete, perdidademente corresponde a la “Reflexion”, a razon de que la implementacion de la misma permite el cambiar la instancia de objeto durante su ejecucion.
Expliquemoslo con algo de codigo…….
>>> #Definimos la ClassA
>>> class ClassA:
def setdata(self, value):
self.data = value
def display(self):
print 'Class A data: %s' % self.data
>>> # Definimos la ClassB
>>> class ClassB:
def output(self):
print 'Class B data: %s ' % self.data
>>> # Creamos una nueva instancia para la ClassA
>>> newobject = ClassA()
>>> # Establecemos data para la instancia a 23
>>> newobject.setdata(23)
>>> # Usamos un metodo de la ClassA
>>> newobject.display()
>>> Class A data: 23
>>> # Cambiamos este objeto para la clase ClassB!
>>> newobject.__class__=ClassB
>>># Usamos el metodo de la ClassB
>>> newobject.output()
Class B data: 23
>>> newobject.display() # metodo no existe en ClassA
Traceback (most recent call last): # Retorna error
File "", line 1, in ?
newobject.display()
AttributeError: ClassB instance has no attribute 'display'
>>> # Hacemos el cambio a la ClassA
>>> newobject.__class__=ClassA
>>> # Usamos un metodo de la ClassA
>>> newobject.display()
Class A data: 23
Observen la magia!, la clase de un objeto es accesible para los programas en Python mediante el atributo __class__ y puede ser cambiada simplemente asignando un nuevo valor a dicho atributo. Esto permite a programas a desarrolladores Python, reasignar en tiempo de ejecucion alguna instancia de objeto diferente.
October 17, 2007 a las 11:29 am por Edwin Plauchu · Archivado en Varios
Tu que piensas ?
Anexo la siguiente direccion de radio psyco
October 17, 2007 a las 10:19 am por Edwin Plauchu · Archivado en Programacion
Buenas tardes, hace unos dias escribi un poco sobre la Reflexión en java, pero acaso la Reflexión en C# es lo mismo ?
La Reflexión es la capacidad de algunos lenguajes de acceder a su estructura mediante su metadata. Los lenguajes de .NEt Framework 2.0 proveen esta funcionalidad mediante el assembly System.Reflection.
En este namespace podemos encontrar clases que hacen referencia al contenido de un Assembly, Tipo de Datos, Propiedades, miembros, métodos, etc.
using System.Reflection;
Utilizando reflexión podemos consultar los tipos contenidos en un assembly, sus miembros, propiedades y métodos, asi como sus permisos de acceso, entre otras características.
La reflexión nos proporciona objetos del tipo Type.
“La capacidad de la reflexión de la plataforma .NET (similar a la de la plataforma Java) nos permite explorar información sobre los tipos de los objetos en tiempo de ejecución.”
El primer ejemplo que expondré sobre la utilización de Reflexión será reconocer el tipo de un assembly y listar su contenido. Se puede obtener un assembly de varias maneras, las más comunes son obtener el assembly que se está ejecutando (actual) y obtener un assembly en base a su nombre (puede ser una librería de clases). A continuación se listan ambas opciones:
//Carga el Assembly en ejecución actual.
Assembly actual = Assembly.GetExecutingAssembly();
// Carga un Assembly en base a su nombre
// (Sin la extension .dll, .exe, etc.)
Assembly asm = Assembly.Load("LibreriaDeTesting");
Ahora que tenemos una referencia al assembly podemos inspeccionar su contenido y obtener información relevante
// Carga un Assembly en base a su nombre
// (Sin la extension .dll, .exe, etc.)
Assembly asm = Assembly.Load("LibreriaDeTesting");
Type[] tipos = asm.GetTypes();
foreach (Type tipo in tipos)
{
// Imprimimos los nombres de las clases solamente.
if (tipo.IsClass)
System.Console.WriteLine("Clase : " + tipo.Name);
}
Se puede consultar si un tipo es una clase, enum, interfaz, clase abstracta, tipo primitivo, elemento público, arreglo, tipo genérico, puntero, serializable, entre otras propiedades posibles. Estas consultas se hacen en base a propiedades de la forma tipo.IsXXXX, donde XXXX será: Class, Enum, Interface, etc.
Ahora que sabemos como acceder a los tipos de un assembly, podemos obtener información específica de cada tipo:
// Carga un Assembly en base a su nombre
// (Sin extension .dll, .exe, etc.))
Assembly asm = Assembly.Load("LibreriaDeTesting");
Type[] tipos = asm.GetTypes();
foreach (Type tipo in tipos)
{
// Imprimimos los nombres de las clases solamente.
if (tipo.IsClass){
System.Console.WriteLine("nClase : " + tipo.Name);
PropertyInfo[] propiedades = tipo.GetProperties();
System.Console.WriteLine("Propiedades:");
foreach (PropertyInfo prop in propiedades)
{
string nombre = prop.Name;
string tipoCampo = prop.PropertyType.Name;
System.Console.WriteLine("t-Propiedad:" + nombre +
", tipo:" + tipoCampo);
}
MethodInfo[] metodos = tipo.GetMethods();
System.Console.WriteLine("Metodos:");
foreach (MethodInfo met in metodos)
{
string nombre = met.Name;
string tipoCampo = met.ReturnType.Name;
System.Console.WriteLine("t-Metodo:" + nombre + ", tipo:" +
tipoCampo);
}
}
También es posible saber si una clase define o no un atributo en particular.
// Carga un Assembly en base a su nombre
// (Sin extension .dll, .exe, etc.)
Assembly asm = Assembly.Load("LibreriaDeTesting");
Type[] tipos = asm.GetTypes();
foreach (Type tipo in tipos)
{
// Imprimimos los nombres de las clases solamente.
if (tipo.IsClass){
System.Console.Write("nClase : " + tipo.Name);
if (tipo.IsDefined(typeof(Serializable), false))
{
System.Console.Write(" – Es Serializable!");
}
System.Console.WriteLine();
}
}
El alcance de esto en realidad es .. la posibilidad de definir nuestros propios atributos para luego consultar qué clases, métodos, miembros o propiedades definen dichos atributos y realizar las acciones que estimemos pertinentes.
Si deseamos llamar a un método en especifico…
string tipo = “ClaseQueContieneElMetodo”;
string ensamblado = “NombreEnsamblado”;
Assembly a = Assembly.Load(ensamblado);
//Obtenemos una instáncia del objeto
Type typeT = a.GetType(ensamblado + “.” + tipo);
MethodInfo methodinf = typeT.GetMethod("Metodo_a_llamar");
October 16, 2007 a las 11:14 am por Edwin Plauchu · Archivado en Varios
Dejo a su disposicion el album Homonimo de Bella indiferencia, agrupacion a la que pertenesco.
El proyecto actualmente se encuentra en Stand by………. algunos dicen que murio..
te invito a escuchar nuestro material.
Lo puedes descargar de esta liga
October 15, 2007 a las 1:22 pm por Edwin Plauchu · Archivado en Programacion
En ocaciones no te has sentido raro (como diria el noeito… como bichopalo), o algo marginadito por tu codigo, ya que el lenguaje que mas quieres y que mas te gusta, en tu ambiente laboral, no vale mucho la pena “para nadie”, ya que todo tu gremio laboral es .Net.
Creo que con IronPython, te llegaras a sentir un poquito mas motivado.
Analicemos un pedacito de codigo IronPython:
import clr
from System.IO import *
fichero = File.OpenText("mifichero.txt")
linea = fichero.ReadLine()
while s:
print linea
Sencillo ?
Para utilizar bibliotecas de .NET adicionales, deberas importar el módulo CLR y, posteriormente, ensamblados específicos a los que se hara referencia. Los ensamblados de bibliotecas adicionales se pueden importar y utilizar sin ningún tipo de problema.
import clr
clr.AddReference("System.Xml")
from System.Xml import *
d = XmlDocument()
Ampliar IronPython con C# es muy fácil. Puedes cargar una DLL que ya has creado con c# en mi caso “csextend.dll.
Este es el codigo de csextend.dll
using System;
using System.Collections;
public class Simple {
private int data;
public Simple(int data) {
this.data = data;
}
public override string ToString() {
return String.Format("Simple<{0}>“, data);
}
}
Ahora lo incorporamos a IronPython… de super lujo ……
>>> import clr
>>> clr.AddReferenceToFile("csextend.dll")
>>> import Simple
>>> dir(Simple)
['Equals', 'GetHashCode', 'GetType', 'ToString',
'__new__', '__repr__']
Ahora que tienes mas idea de Iron
Un ejemplo que correo sobre Windows (Lo saque de la revista linux magazine):
import clr
clr.AddReference('System.Drawing')
clr.AddReference('System.Windows.Forms')
from System.Drawing import Color, Point
from System.Windows.Forms import (Application, BorderStyle, Button, Form, FormBorderStyle, Label, Panel, Screen)
class HolaMundo(Form):
def __init__ (self):
self.Text = "Hola Linux Magazine"
self.FormBorderStyle = FormBorderStyle.FixedDialog
pantalla = Screen.GetWorkingArea(self)
self.Height = pantalla.Height / 5
self.Width = pantalla.Width / 5
self.panel1 = Panel()
self.panel1.Location = Point (0,0)
self.panel1.Width = self.Width
self.panel1.Height = self.Height
self.generaSaludo()
self.panel1.Controls.Add(self.label1)
self.Controls.Add(self.panel1)
def generaSaludo(self):
self.label1 = Label()
self.label1.Text = "Hola lectores de Linux Magazine"
self.label1.Location = Point(20,20)
self.label1.Height = 25
self.label1.Width = self.Width
form = HolaMundo()
Application.Run(form)
Conclusion
Los lenguajes dinámicos son los que hacen que el desarrollo de software sea más rápido y que los procesos iterativos funcionen correctamente. Su naturaleza, que ofrece posibilidades de investigación, los hace más atractivos para los desarrolladores y para aquellos que pueden disfrutar de ellos simplemente con una consola interactiva.
Como puedes empezar con iron…. mas informacion aqui http://www.codeplex.com/IronPython/Release/ProjectReleases.aspx?ReleaseId=47
October 15, 2007 a las 11:27 am por Edwin Plauchu · Archivado en Programacion
El presente artículo es una introducción a la reflexión en Java. Esta técnica permite “destripar” las clases de Java, obteniendo la información de su estructura a bajo nivel. ¿Qué ventajas tiene ésto?. La verdad es que muchas, ilustremos con un ejemplo.
Imaginemos el desarrollo de un servidor de aplicaciones que está basado en servicios. Cada servicio es atendido por una clase especializada, dependiendo de un tipo de mensaje.
Si queremos ejecutar un servicio específico que atienda una solicitud determinada, lo normal es hacer un anidamiento de sentencias IF para que instancie y ejecute cada clase según el caso. Esto tiende a complicar el desarrollo, hace ilegible el código, no es óptimo, y para integrar este servidor de aplicaciones en otros proyectos, habrá que borrar IF’s y crear otros para las clases de servicio que correspondan.
Pero si utilizamos la reflexión, este anidamiento de IF’s desaparece, dejando lugar a una única instanciación dinámica, que puede ser recogida de una base de datos o de un archivo. ¿Suena bien, verdad?
Para simplificar este caso, se ha realizado una simulación con clases básicas.
Lo primero es definir una interfaz, la cual servirá para definir la estructura de las clases que harán de servicio, creando los métodos por los cuales se invocan.
public interface IInterface
{
public int operacion(int a, int b);
}
Una vez definida la interfaz, se crean las clases servicio basadas en dicha interfaz:
Clase A
public class A implements IInterface
{
private int s1, s2;
public A()
{
s1 = 0;
s2 = 0;
}
public A(int a, int b)
{
s1 = a;
s2 = b;
}
public int operacion(int a, int b)
{
return a+b;
}
}
Clase B
public class B implements IInterface
{
public int operacion (int a, int b)
{
return a-b;
}
}
Para obtener un objeto a partir de una clase, de la cual no se conoce el nombre, se utiliza el siguiente código:
String clase = "A";
Class c = Class.forName(clase);
A partir de ahora, el objeto “c” contendrá la información referida a dicho objeto. A partir de aquí se podrá saber si es una clase, una interfaz, si es pública, privada, protegida, sincronizada, abstracta, etc. Se podrá acceder a todos sus constructores, métodos, parámetros, etc. (mirar código de ejemplo más abajo).
Lo realmente importante para nuestro ejemplo, es poder instanciar dicha clase y ejecutar sus métodos. Para ello se crea la instancia mediante la interfaz, que define el tipo de clase, y a través del objeto obtenido anteriormente:
String clase = "A";
Class c = Class.forName(clase);
// Instanciacion dinamica
IInterface objeto = (IInterface) c.newInstance();
System.out.println("Resultado: " + objeto.operacion(3, 2));
Como se puede apreciar, ya no estamos limitados por los nombres de las clases escritos estáticamente en el código, si no que podemos obtenerlos de un archivo o de una tabla de base de datos, e ir instanciando dinámicamente.
October 8, 2007 a las 2:45 pm por Edwin Plauchu · Archivado en Programacion
El siguiente Script nos ayuda a respaldar una base de datos Mysql(tipo ISAM) de tamaño moderado(Max 10Mb), dicho respaldo sera depositado en la bandeja de correo que el Sysadmin crea conveniente.
Nota: Si este respaldo se realiza de manera frecuente, recomiendo que se anexe como una tarea semanal en el cron
#!/usr/bin/perl
use Archive::Zip;
use MIME::Lite;
use Net::SMTP;
#### Llenar por usuario ######
my $from_address = 'edwinplauchu@micronesia.com';
my $to_address = 'edson.estrella@microsiga.com';
my $mail_host = 'pop3.microsiga.com.br';
my $subject = 'Microsiga Wiki Backup...';
my $message_body = "Anexo a este correo el respaldo semanal de nuestro amado wiki";
##############################
### Aqui inicia el codigo perl ofuscado 
####
#BEGIN #######################
#01.- Mysqldump ZIP
system("/usr/bin/mysqldump -u root -ph1st3r14 mediawiki > mediawiki.sql");
$obj = Archive::Zip->new(); # new instance
@files = ('mediawiki.sql'); # files to store
foreach $file (@files){
$obj->addFile($file);
}
if ($obj->writeToFileNamed('my_file.zip') != AZ_OK)
{ # write to disk
print "Error in archive creation!";}
else { print "Archive created successfully!"; }
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=localtime(time);
$year += 1900;
$mon += 1;
my $my_file_zip = 'my_file.zip';
my $your_file_zip = "mediawiki-mysql-" . $mon . "-" . $mday . "-" . $year . ".sql.zip";
#02.- Send Mail with ZIP
### Create the multipart container
$msg = MIME::Lite->new (
From => $from_address,
To => $to_address,
Subject => $subject,
Type =>'multipart/mixed'
) or die "Error no puede crearce el respaldo del wiki: $!n";
### Add the text message part
$msg->attach (
Type => 'TEXT',
Data => $message_body
) or die "Error adding the text message part: $!n";
### Add the ZIP file
$msg->attach (
Type => 'application/zip',
Path => $my_file_zip,
Filename => $your_file_zip,
Disposition => 'attachment'
) or die "Error adding $file_zip: $!n";
MIME::Lite->send('smtp', $mail_host, Timeout=>60);
$msg->send;
#END #########################
