Ahora que el WWF esta disponible, tenemos mucha informacion de que es WWF pero en muy pocos lugares(sobre todo en español) no hay información de cómo consumir un workflow ya sea desde un entorno.Net como fuera de el, para ir directo al grano les mostrare un poco de código que es el resultado de pelear con el WWF por unos días.
Primero vamos a crearnos un WF muy sencillo, un “hola mundo”.
inicio -->CodeActivity1(Comenzando)-->CodeActivity2(Medio)-->CodeActivity(Finalizando)-->end
El código que viene detrás de este WF es este:
Public class Workflow1
Inherits SequentialWorkflowActivity
Private Sub Comenzando(ByVal sender As System.Object, ByVal e As System.EventArgs)
System.Diagnostics.Debug.WriteLine("Comanzando el Workflow")
End Sub
Private Sub Medio(ByVal sender As System.Object, ByVal e As System.EventArgs)
System.Diagnostics.Debug.WriteLine("A Medio Workflow")
End Sub
Private Sub Finalizando(ByVal sender As System.Object, ByVal e As System.EventArgs)
System.Diagnostics.Debug.WriteLine("Finalizando el Workflow")
End Sub
End Class
Como verán nada del otro mundo, ahora para consumir este WF debemos crear un objeto de tipo WorkflowRuntime al que le pasaremos como parámetro en un objeto Type el WorkFlow que queremos ejecutar de la siguiente manera.
Para comenzar definir un objeto runtime de manera shared para toda la clase
Public Shared wr As New System.Workflow.Runtime.WorkflowRuntime
Luego el codigo para iniciar el workflow seria el siguiente:
Dim t As Type = GetType(WFLibrary.Workflow1)
Dim instance As System.Workflow.Runtime.WorkflowInstance = wr.CreateWorkflow(t)
instance.Start()
ahora si necesitan pasarle parametros al momento de crear la instancia le pueden pasar un objeto Dictionary ademas del type con lo que se necesite.
Ahora, este ejemplo funciona bien desde un entorno .Net, pero que pasa si queremos usar el WF desde un entorno COM? Facil, creamos una clase que nos sirva de puente entre COM y .Net, y esta clase se la crea en .Net de tal manera que nos sea util en cualquier parte.
Para poder realizar tal azaña solo se necesita compilar un assembly con las propiedades COMVisible, ademas de unas pocas cosas mas en el codigo.
Para empezar veamos el codigo; necesitamos referenciar un namespace de .net de manera que tengamos disponibles algunas propiedades mas al momento de crear la estructura de la clase.
Imports System.Runtime.InteropServices
Luego creamos nuestra clase especificando el atributo COMVisible en verdadero para las clases que queremos que sean visibles desde COM.
<ComVisible(True)> _
Public Class MyInteropClass
Public Property MyProperty() As String
Get
Return "Hola Mundo...!"
End Get
Set(ByVal value As String)
End Set
End Property
End Class
Con esto estamos casi listos, ahora necesitamos decirle al compilador de .net que haga esta clase visible en un entorno COM, esto es para que se creen todas las entradas de registro del sistema para nuestra libreria(dll)
Menu Project->Properties->Compile
Seleccionar Register for COM Interop
Las pruebas fueron realizadas en vb.net y en c# en un entorno en ingles, y se comprobo que en un vs 2005 en español al momento de registrar la librería no se crea la llave de registro CodeBase en donde se almacena la ruta del dll, si ese fuese el caso hay 2 soluciones, crear la llave de registro o copiar el assembly a la carpeta System32 de Windows.
Bueno con todo esto lo unico que falta es unir la clase COMVisible con el proyecto ya sea web o desktop.
Este post es para mostrar algo de código, como se puede usar el namespace de cryptography para encriptar un mensaje y volverlo a su estado original.
Para este ejemplo he usado DES(Data encription Standard) que es uno de los mas básicos, pero asi como implemente este se puede cambiar a cualquiera de los métodos simetricos de encriptación que vienen con .Net
Para ver mas informacion sobre Criptografia en .Net ver:System.Security.Cryptography
El código es el siguiente:
Imports System.Security.Cryptography
Imports System.IO
''' <summary>
''' permite encriptar un mensaje haciendo uso de uno de los servicios de encriptacion mas básicos
''' </summary>
''' <param name="message">Mensaje a encriptar</param>
''' <param name="key">Llave de encriptacion</param>
''' <param name="iv">Vector de inicializacion</param>
''' <returns>Coleecion de bytes que representan el mensaje encriptado</returns>
''' <remarks>Si bien este código hace uso del metodo DES sobrecargar este con los
''' demas metodos simetricos no implica mayor complejidad</remarks>
Private Function Encrypt(ByVal message() As Byte, ByVal key() As Byte, ByVal iv() As Byte) As Byte()
Dim des As DES = New DESCryptoServiceProvider
Dim crypto As ICryptoTransform = des.CreateEncryptor(key, iv)
Dim cipherstream As New MemoryStream()
Dim cryptostream As New CryptoStream(cipherstream, crypto, CryptoStreamMode.Write)
cryptostream.Write(message, 0, message.Length)
cryptostream.Close()
Return cipherstream.ToArray()
End Function
''' <summary>
''' permite desencriptar un mensaje haciendo uso de uno de los servicios de encriptacion mas básicos
''' </summary>
''' <param name="cypherText">Mensaje Encriptado</param>
''' <param name="iv">Vector de inicializacion</param>
''' <param name="key">Llave de encriptacion</param>
''' <remarks></remarks>
Private Function Decrypt(ByVal cypherText() As Byte, ByVal iv() As Byte, ByVal key() As Byte) As String
Dim des As DES = New DESCryptoServiceProvider()
Dim crypto As ICryptoTransform = des.CreateDecryptor(key, iv)
Dim cipherStream As New MemoryStream(cypherText)
Dim cryptostrm As New CryptoStream(cipherStream, crypto, CryptoStreamMode.Read)
Dim message As String
message = New StreamReader(cryptostrm).ReadToEnd()
Return message
End Function
sub main()
'Usando los métodos creados con un archivo de texto
Dim result() As Byte
Dim algo As New FileStream("prueba.txt", FileMode.Open)
Dim mifile(algo.Length) As Byte
Dim mikey() As Byte = BitConverter.GetBytes(123465789123456789)
Dim miiv() As Byte = BitConverter.GetBytes(987654321987654321)
algo.Read(mifile, 0, algo.Length)
result = Encrypt(mifile, mikey, miiv)
Console.WriteLine("en encrypto")
Console.WriteLine(BitConverter.ToString(result))
Console.Read()
Console.WriteLine(Decrypt(result, miiv, mikey))
Console.Read()
end sub
Entiendase por almacenamiento aislado a la porsión de información (que puede servir como datos de configuración por ejemplo) que podemos almacenar de forma segura en la máquina del cliente (solo para aplicaciones de escritorio), en el ejemplo de código a continuación veran que solo almaceno un string, es demostrativo, se podría guardar tanta información como sea necesaria.
Imports System.IO.IsolatedStorage
Imports System.IO
''' <summary>
''' Permite inicializar un archivo de almacenamiento aislado
''' para la aplicacion
''' </summary>
''' <remarks>si el archivo de almacenamiento ya existe sera
''' actualizado con la nueva información</remarks>
Private Sub SetIsolated()
Dim isoFile As IsolatedStorageFile = IsolatedStorageFile.GetMachineStoreForAssembly()
Dim isoStream As IsolatedStorageFileStream = New IsolatedStorageFileStream("sistem.dat", FileMode.OpenOrCreate, isoFile)
Dim writer As New StreamWriter(isoStream)
writer.WriteLine("esta es la configuracion almacenada")
writer.Close()
End Sub
''' <summary>
''' Permite obtener la información almacenada para este assembly de forma aislada
''' </summary>
''' <remarks>para poder leer el archivo debemos estar seguros que ya existe</remarks>
Private Sub GetIsolated()
Dim isoFile As IsolatedStorageFile = IsolatedStorageFile.GetMachineStoreForAssembly()
Dim isoStream As IsolatedStorageFileStream = New IsolatedStorageFileStream("sistem.dat", FileMode.Open, isoFile)
Dim result As String = New StreamReader(isoStream).ReadToEnd()
Console.Write(result)
End Sub
sub main()
'almacenamiento aislado
SetIsolated()
GetIsolated()
console.read()
end sub
Esta idea tal vez ya paso por la cabeza de alguien mas, no es ninguna novedad, pero es bueno compartir este tipo de "componentes" que nos facilitan la vida al momento de encarar un proyecto.
En el caso especifico de este código, se ha creado una actividad que esta orientada a ser usada con Window Workflow Foundation para el envio de correos electronicos, si bien esta clase es basica, es muy util (asi lo veo yo) y el código puede llegar a crecer de acuerdo a las necesidades propias de su implementación.
Los namespaces necesarios para el proyecto son:
Sin mas preambulo aquí les dejo el código.
using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Collections;
using System.Drawing;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
using System.Workflow.Runtime;
using System.Workflow.Activities;
using System.Workflow.Activities.Rules;
namespace Workflows.Activities
{
public partial class EnviarMail: System.Workflow.ComponentModel.CompositeActivity
{
public EnviarMail()
{
InitializeComponent();
}
[Description("El campo A(dirección destino) del correo electrónico")]
[Category("AddressTo")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string AddressTo
{
get{ return(string)GetValue(AddressToProperty); }
set{ SetValue(AddressToProperty, value); }
}
// DependencyProperty para AddressTo.
public static readonly DependencyProperty AddressToProperty = DependencyProperty.Register("AddressTo", typeof(string), typeof(EnviarMail));
[Description("El campo De(dirección origen) del correo electrónico")]
[Category("AddressFrom")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string AddressFrom
{
get{ return(string)GetValue(AddressFromProperty); }
set{ SetValue(AddressFromProperty, value); }
}
//DependencyProperty para AddressFrom
public static readonly DependencyProperty AddressFromProperty = DependencyProperty.Register("AddressFrom", typeof(string), typeof(EnviarMail));
[Description("El campo asunto del correo electrónico")]
[Category("Subject")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string Subject
{
get{ return(string)GetValue(SubjectProperty); }
set{ SetValue(SubjectProperty, value); }
}
//DependencyProperty para Subject.
public static readonly DependencyProperty SubjectProperty = DependencyProperty.Register("Subject", typeof(string), typeof(EnviarMail));
[Description("El Cuerpo del mensaje")]
[Category("MailMessage")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string MailMessage
{
get{ return(string)GetValue(MailMessageProperty); }
set{ SetValue(MailMessageProperty, value); }
}
//DependencyProperty para MailMessage.
public static readonly DependencyProperty MailMessageProperty = DependencyProperty.Register("MailMessage", typeof(string), typeof(EnviarMail));
[Description("Servidor para envio de correo electronico")]
[Category("SmtpServer")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string SmtpServer
{
get{ return(string)GetValue(SmtpServerProperty); }
set{ SetValue(SmtpServerProperty, value); }
}
//DependencyProperty para SmtpServer.
public static readonly DependencyProperty SmtpServerProperty =
DependencyProperty.Register("SmtpServer", typeof(string), typeof(EnviarMail));
[Description("Puerto por el que se esta presente el servicio de smtp")]
[Category("SmptPort")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public int SmtpPort
{
get{ return(int)GetValue(SmtpPortProperty); }
set{ SetValue(SmtpPortProperty, value); }
}
//DependencyProperty para SmtpPort.
public static readonly DependencyProperty SmtpPortProperty =
DependencyProperty.Register("SmtpPort", typeof(int), typeof(EnviarMail));
[Description("Nombre de usuario para acceder al servidor de SMTP")]
[Category("Username")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string UserName
{
get{ return(string)GetValue(UserNameProperty); }
set{ SetValue(UserNameProperty, value); }
}
//DependencyProperty para UserName.
public static readonly DependencyProperty UserNameProperty =
DependencyProperty.Register("UserName", typeof(string), typeof(EnviarMail));
[Description("Password del usuario para el envio de correo electronico")]
[Category("Password")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public string Password
{
get{ return(string)GetValue(PasswordProperty); }
set{ SetValue(PasswordProperty, value); }
}
// DependencyProperty para Password.
public static readonly DependencyProperty PasswordProperty =
DependencyProperty.Register("Password", typeof(string), typeof(EnviarMail));
[Description("Bandera que determina si se debera proveeder de credenciales para el envio de mails")]
[Category("UseSSL")]
[Browsable(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
public bool UseSSL
{
get{ return(bool)GetValue(UseSSLProperty); }
set{ SetValue(UseSSLProperty, value); }
}
//DependencyProperty para UseSSL.
public static readonly DependencyProperty UseSSLProperty =
DependencyProperty.Register("UseSSL", typeof(bool), typeof(EnviarMail));
protected override ActivityExecutionStatus Execute(ActivityExecutionContextcontext)
{
try
{
System.Net.Mail.MailMessage mimail = newSystem.Net.Mail.MailMessage(AddressFrom, AddressTo, Subject, MailMessage);
System.Net.Mail.SmtpClient mismtp = newSystem.Net.Mail.SmtpClient();
mismtp.Host = SmtpServer;
mismtp.Port = SmtpPort;
mismtp.EnableSsl = UseSSL;
if(UseSSL)
{ mismtp.Credentials = new System.Net.NetworkCredential(UserName,Password); }
mismtp.Send(mimail);
returnActivityExecutionStatus.Closed;
}
catch(System.Net.Mail.SmtpExceptionsmtpEx)
{
return HandleFault(context, smtpEx);
}
}
protected override ActivityExecutionStatus HandleFault(ActivityExecutionContextexecutionContext, Exceptionexception)
{
return base.HandleFault(executionContext, exception);
}
}
}
_513.png){kind=small}