WS-AT en .Net framework v3

WS-AT forma parte de “Windows Communication Foundation” (WCF). Por lo visto el soporte de WS-AT debe habilitarse y configurarse en Windows. Para ello hay un panelito que explican en http://blogs.msdn.com/distilled/archive/2006/05/15/598257.aspx

La documentación sobre “Windows Communication Foundation” está en http://msdn2.microsoft.com/en-us/library/aa388579.aspx y, en concreto, la parte en la que hablan de ws-at es http://msdn2.microsoft.com/en-us/library/ms729784.aspx

Al parecer, crear un “servicio” con este nuevo modelo de programación es algo tan sencillo como esto:

El código:

using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;

[ServiceContract]
public interface IEcho
{
[OperationContract]
string Echo(string s);
}

public class MyService : IEcho
{
public string Echo(string s)
{
return s;
}
}

class Program
{
static void Main(string[] args)
{
string baseAddress = "http://localhost:8080/wcfselfhost/";
ServiceHost host = new ServiceHost(typeof(MyService), new Uri(baseAddress));

// Create a BasicHttpBinding instance
BasicHttpBinding binding = new BasicHttpBinding();

// Add a service endpoint using the created binding
host.AddServiceEndpoint(typeof(IEcho), binding, "echo1");

host.Open();
Console.WriteLine("Service listening on {0} . . .", baseAddress);
Console.ReadLine();
host.Close();
}
}

La configuración (web.config o app.config)

<configuration>
<system.serviceModel>
<services>
<service name="MyService" behaviorConfiguration="HttpGetMetadata">
<endpoint address="echo2" contract="IEcho" binding="basicHttpBinding" />
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="HttpGetMetadata">
<serviceMetadata httpGetEnabled="true" />
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>

Por cierto, MS ha tenido la amabilidad de desarrollar unas “Visual Studio 2005 extensions for .Net framework 3.0” que supongo que facilitarán el desarrollo de estos “servicios”

Miranda IM para Jabber

Miranda es un cliente de IM muy potente. Se puede conectar con AIM, ICQ, MSN, Yahoo, etc... pero en este caso me interesa como cliente de Jabber porque, además, se integra perfectamente con DesktopSidebar (al contrario que PSI).

Para instalarlo no hay más que bajarlo de www.miranda-im.org, desactivar todos los plugins que no usemos (AIM, ICQ...) y configurar la cuenta jabber.

Lo único que eché de menos después es la posibilidad de que me avisase sin incordiar de que hay mensajes nuevos (el típico aviso no-obtrusivo). Para ello hay que instalar dos plugins:

• Message Notify es el plugin que "genera los eventos"
• Popup Plus es el plugin que, cuando se produce un evento, muestra unos bonitos mensajitos emergentes

Si hay que criticarle algo, es que su diseño es demasiado modular. Mira que haber un plugin para generar eventos, y otro para tratarlos... demasiao

Features Provided by System.Transactions

Features Provided by System.Transactions

¿no deberíamos echarle un ojo a esto? ¿incluye a los Enterprise Services?

la burrocracia

por fin he conseguido enterarme de cómo va esto, aunque me ha costado, lo reconozco: 

 

Cómo dar de alta transacciones

Lo mejor es conectarse al cics (CICS1P) y ejecutar el siguiente comando: "cemt i tran inq(cg*)". Eso nos mostrará todas las transacciones CG* y a qué programa llaman. Si la aplicación sigue alguna lógica en la relación programa-transacción, intentamos mantenerla. Si ya la ha perdido, pues buscamos una libre y punto. Ojo, que la serie 90 (CG90, CG91, NC90, NC91,...) están reservadas para los "procesos online".

 

Una vez tengamos claro el código que queremos para nuestra transacción (NC83) y el programa mandamos un correo a "CPD Aplicaciones Desarrollo" solicitando el alta e indicando el programa asociado y, uno o dos días después, nos contestarán algo.

 

 

Cómo dar de alta planes (y tablas)

Para incluir programas en el plan de una transacción, hay que saber lo siguiente: todas las transacciones tienen un plan (para la CG01, es el CG01PLAN, y así...) que se pueden consultar (pero no modificar) con el panelito de los planes. Los programas involucrados en una transacción (si no me equivoco) tienen que estar incluidos en su plan.

 

En fin, para solicitar que nos añadan programas al plan de una transacción usaremos la dirección "CPD Aceptacion Aplicaciones".

 

En pruebas no hay problema, vosotros mismos podéis solicitar todas estas cosas, pero... ¡ojo! luego hay que hacer lo mismo para explotación, apuntadlo todo religiosamente en algún sitio, preferiblemente adjunto a los "documentos del proyecto".

 

Un saludo

Visita a microsoft

Visita a microsoft, originally uploaded by sanchon.

El jueves hicimos una visita a los chicos de microsoft en su sede de madrid. La visita fue bastante provechosa.

Un wiki para llevar puesto

Hoy he encontrado algo que me ha dejado atonito: un wiki que consiste en un único fichero html que puedes llevarte a donde quieras: Tiddly Wiki. De hecho hay bastante afición y ya he visto varias variantes:

• Para tomar notas en clase (student edition)
• Con un extraño sistema de tags (tagglytagging)

El truco es que toda la programación está en realidad embebida en el propio HTML en Javascript. ¡Técnicamente brillante!. Si quieres uno vacío bájatelo de aquí (dándole a "guardar destino como..." del fichero TiddlyWikiVacio.html), porque lo que necesitas es guardarte en tu disco el fichero html.

De cualquier manera en las webs anteriores explican cómo usarlo. Teniendo esto... ¿para qué quieres el Word? Si lo piensas, esto equivale a tener ¡¡el propio word incluido en el documento!!!

The LINQ Project

Parece que el LINQ Project va más allá de únicamente suministrar capacidad de querys a los lenguajes .net, además hay dos partes de este proyecto (DLINQ y XLINQ) encaminadas a ayudar a resolver los problemas de "mapping" entre el modelo relacional (SQL), el jerárquico (XML) y los lenguajes orientados a objetos, respectivamente.

Sobre el O/R Mapping, nada nuevo: igual que Java 5 EE, la "solución" pasa por decorar los atributos y métodos con la información necesaria para hacer la correspondencia (véase DLinq Overview.doc)

O/R Mapping: recapitulemos

Estamos en unos momentos importantes: tenemos la oportunidad de definir la forma en la que se van a programar las aplicaciones del futuro. Es conveniente que veamos el state-of-the-art de uno de los principales problemas para programar con orientación a objetos: el trabajo con bases de datos relacionales.

Desde la wikipedia (buen artículo, con decenas de enlaces) he llegado a un artículo que realmente explica en detalle el tema: Mapping Objects to Relational Databases: O/R Mapping In Detail .

Ahora es un poco tarde, pero el fin de semana me lo voy a leer para ver si en el ECC faltan cosas importantes. Además la wikipedia ofrece un montón de enlaces por los que aún no he podido navegar...

Java Expo

[update] Acabo de encontrar las presentaciones

Tino y yo estamos recién llegados de la Java Expo en Madrid. A continuación resumo mis notas de estos tres días:

NetBeans

Con diferencia el producto más publicitado; se nota que el evento estaba dirigido a programadores y que se la herramienta se la han currado bastante.

• Ajax: presente en varios componentes de interfaz de usuario web del netbeans. Recomiendan además usar algún toolkit como Dojo aunque no uses netbeans



• BPEL: El estándar actual es WS-BPEL 2.0 (Oasis). Permite diseñar los procesos de negocio gráficamente y por detrás la herramienta mantiene el BPEL



• Web: Soporta Struts y WSF en la versión 5.0, que son los frameworks más usados para desarrollo de páginas JSP. Pensados para que se siga el patrón Model-View-Controller. El más reciente es JSF (Java Server Faces) por cierto



• Plugins: Es totalmente extensible y modular. Se pueden encontrar plugins de todo tipo en netbeans.org, nbextras.org y en blogs.sun.com/scblog o este otro blog.
  
  
• Otras virguerías: (algunas son packs que hay que instalar) Profiling, UML sincronizado con el código, editor de aplicaciones Swing (Matisse) muy mejorado, muchos refactorings, utilidades de colaboración y trabajo en grupo, prueba unitaria con JUnit, los proyectos son archivos ANT para permitir fácilmente la integración continua....

Java 5

Se enfoca sobre todo en la facilidad de desarrollo, ya que J2EE 1.4 obliga a conocer muchas APIs y ficheros de configuración y deployment.

• Es más facil desarrollar: APIs más sencillas, anotaciones y uso de POJO (Plain Old Java Objects)


• O/R Mapping: gracias al uso de anotaciones es posible especificar en el código la información suficinente para que un EJB sea persistente en una b.d. relacional


• Web-Services: también simplificados gracias a las anotaciones

Glassfish

Es el servidor de aplicaciones gratuito que implementa Java EE 5.0. Consúltese The Aquarium

Preguntas

• El nuevo servidor de aplicaciones GlassFish de Sun, es gratis, pero... ¿es posible usarlo en producción o daría algún problema?


• ¿cómo gana dinero Sun, si todos sus productos son gratuitos y open source?

Fotos

---

Prueba de video en YouTube

Probando los vídeos de YouTube...

abrir un fichero con process start

Primero lo intentamos abrir con "Process.Start", y luego usamos el handle que devuelve para poner la ventana delante. El problema es que si la aplicación ya estaba abierta, no devuelve nada así que lo que hacemos es buscar una ventana en cuyo título aparezca el fichero que queremos abrir...

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace cancelarConexiondeRed
{
        /// <summary>
        /// Descripción breve de Class1.
        /// </summary>
        class Class1
        {

                [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
                public static extern bool SetWindowPos(
                        IntPtr hWnd,               // window handle
                        IntPtr hWndInsertAfter,    // placement-order handle
                        int X,                  // horizontal position
                        int Y,                  // vertical position
                        int cx,                 // width
                        int cy,                 // height
                        uint uFlags);           // window positioning flags

                public const int HWND_TOP            = 0x0;
                public const int HWND_TOPMOST    = -1;
                public const int HWND_BOTTOM     = 0x1;
                public const uint SWP_NOSIZE     = 0x1;
                public const uint SWP_NOMOVE     = 0x2;
                public const uint SWP_SHOWWINDOW = 0x40;

               
                [DllImport("user32.dll")]
                static extern IntPtr SetActiveWindow(IntPtr hWnd);
                [DllImport("user32.dll", SetLastError=true)]
                static extern void SwitchToThisWindow(IntPtr hWnd, bool fAltTab);

                [STAThread]
                static void Main(string[] args)
                {
                        Process ventana = Process.Start(@"u:\teclas.txt");
                        Console.ReadLine();
                        if (ventana!=null)
                                SwitchToThisWindow(ventana.MainWindowHandle, true);
                        else
                        {

                                Process[] myProcesses = Process.GetProcesses();
                                foreach(Process myProcess in myProcesses)
                                {
                                        if (myProcess.MainWindowTitle.IndexOf(@"u:\teclas.txt") != -1)
                                        {
                                                SwitchToThisWindow(myProcess.MainWindowHandle, true);
                                                break;
                                        }
                               
                                }
                        }
                }

        }

Mejoras de seguridad en Service Pack 2

Sólo por poneros al tanto de lo que llevo investigado esta mañana. A ver qué nos cuentan los de Microsoft...

- "Mi PC" ahora es una nueva zona, y tiene mayores restricciones de seguridad aún que la zona de internet, es decir: una página HTML que se abra desde c:\ no podrá hacer prácticamente nada. Hasta ahora esto no era así, y los hackers buscaban agujeros del windows o del explorer que dieran acceso a la zona de Mi PC para desde ahí hacer sus guarrerías. Microsoft, en vez de preocuparse por arreglar los agujeros de windows o del explorer, lo que hace es convertir la zona en super-restringida y punto. No es mala idea: para evitar los virus podrían hacer lo mismo e impedir la ejecución de ficheros .exe en windows.

- Por otra parte hay una opción de seguridad que tienen todas las zonas (la opción 2101, "Zone elevation") que impide que desde otra zona se haga link a esta. La opción es "Zone elevation" y la tiene la zona de "intranet local" para impedir que, por ejemplo, desde un web de internet se pueda hacer link a una página de la intranet. La zona de Mi PC, como esta restringidísima también tiene activa esta opción: es una zona más y tiene restringido el hacer link a ella desde las demás.

- La zona de Mi PC no está accesible en las opciones de seguridad del Explorer; pero hay una clave del registro que la haría visible (http://www.phdcc.com/xpsp2.htm)

Todo esto está explicado (más o menos) en http://www.microsoft.com/technet/prodtechnol/winxppro/maintain/sp2brows.mspx#ECAA

En resumen: ¿es peligroso activar la opción 2101 en la zona de mi pc? esa opción lo único que impide es la "zone elevation", es decir, el poder hacer link a una página local desde otra que no es local; todas las otras opciones de seguridad que ahora tiene la zona de mi PC seguirían activas (nada de scripts, nada de activex, nada de nada). Creo que no es peligroso a menos que haya algún otro agujero de seguridad, de la misma forma que la habilidad de windows para ejecutar programas exe no es peligrosa a menos que haya algún otro agujero que permita a alguien meter un exe no deseado en la máquina... Es cierto que desde una web maliciosa se podría abrir o hacer link a un contenido que resida en mi pc, pero me lo abriría a mí; de ahí a que alguien "de fuera" pueda acceder entiendo que hay una gran diferencia.

Lo dicho, esperaremos a que los de microsoft digan algo y ya veremos. Un saludo

prueba

Esto es una prueba:

copiar ficheros en plan guay...

Bueno chicos, un amable señor del msdn magazine se ha dignado implementar en .net una llamada elegante a la función de windows CopyFileEx. La cosa no es fácil porque la función es ultra-guay: tiene para reanudar la copia desde donde falló y permite pasarle una función de callback a la que ella llama para informar del progreso de la copia (que nosotros no vamos a usar, pero molar, mola) y otras tremendas opciones.

Me he hecho una aplicacioncita de consola que va copiando un fichero e imprimiendo el progreso y la verdad es que mola; sería algo así:

class Class1
{

[STAThread]
static void Main(string[] args)
{
FileRoutines.CopyFile(new FileInfo(@"U:\Correo\P5567backup.pst"),
new FileInfo(@"\\vclsfls1\rpos\RPOS103\prueba\P5567.pst"),
CopyFileOptions.Restartable,
new CopyFileCallback(ActualizarProgresoDeCopia)); //este nosotros no lo usaremos, aunque mola!
}


public static CopyFileCallbackAction ActualizarProgresoDeCopia(FileInfo source, FileInfo destination, object state, long totalFileSize, long totalBytesTransferred)
{
Console.WriteLine("Bytes copiados: " + totalBytesTransferred.ToString());
return CopyFileCallbackAction.Continue;
}

}

He comprobado que, efectivamente, si lo cortas a la mitad (paras el programa) y luego simplemente vuelves a intentar la copia, el proceso continúa desde donde lo dejó.

Ahí va la clase "FileRoutines", muy elegantemente implementada...


public sealed class FileRoutines
{
public static void CopyFile(FileInfo source, FileInfo destination)
{
CopyFile(source, destination, CopyFileOptions.None);
}

public static void CopyFile(FileInfo source, FileInfo destination, CopyFileOptions options)
{
CopyFile(source, destination, options, null);
}

public static void CopyFile(FileInfo source, FileInfo destination, CopyFileOptions options, CopyFileCallback callback)
{
CopyFile(source, destination, options, callback, null);
}

public static void CopyFile(FileInfo source, FileInfo destination, CopyFileOptions options, CopyFileCallback callback, object state)
{
if (source == null) throw new ArgumentNullException("source");
if (destination == null)
throw new ArgumentNullException("destination");
if ((options & ~CopyFileOptions.All) != 0)
throw new ArgumentOutOfRangeException("options");

new FileIOPermission(FileIOPermissionAccess.Read, source.FullName).Demand();
new FileIOPermission(FileIOPermissionAccess.Write, destination.FullName).Demand();

CopyProgressRoutine cpr = callback == null ? null : new CopyProgressRoutine(new CopyProgressData(source, destination, callback, state).CallbackHandler);

bool cancel = false;
if (!CopyFileEx(source.FullName, destination.FullName, cpr, IntPtr.Zero, ref cancel, (int)options))
{
throw new IOException(new Win32Exception().Message);
}
}

private class CopyProgressData
{
private FileInfo _source = null;
private FileInfo _destination = null;
private CopyFileCallback _callback = null;
private object _state = null;

public CopyProgressData(FileInfo source, FileInfo destination, CopyFileCallback callback, object state)
{
_source = source;
_destination = destination;
_callback = callback;
_state = state;
}

public int CallbackHandler(
long totalFileSize, long totalBytesTransferred,
long streamSize, long streamBytesTransferred,
int streamNumber, int callbackReason,
IntPtr sourceFile, IntPtr destinationFile, IntPtr data)
{
return (int)_callback(_source, _destination, _state, totalFileSize, totalBytesTransferred);
}
}

private delegate int CopyProgressRoutine(
long totalFileSize, long TotalBytesTransferred, long streamSize,
long streamBytesTransferred, int streamNumber, int callbackReason,
IntPtr sourceFile, IntPtr destinationFile, IntPtr data);

[SuppressUnmanagedCodeSecurity]
[DllImport("Kernel32.dll", CharSet=CharSet.Auto, SetLastError=true)]
private static extern bool CopyFileEx(
string lpExistingFileName, string lpNewFileName,
CopyProgressRoutine lpProgressRoutine,
IntPtr lpData, ref bool pbCancel, int dwCopyFlags);
}

public delegate CopyFileCallbackAction CopyFileCallback(FileInfo source, FileInfo destination, object state, long totalFileSize, long totalBytesTransferred);

public enum CopyFileCallbackAction
{
Continue = 0,
Cancel = 1,
Stop = 2,
Quiet = 3
}

[Flags]
public enum CopyFileOptions
{
None = 0x0,
FailIfDestinationExists = 0x1,
Restartable = 0x2,
AllowDecryptedDestination = 0x8,
All = FailIfDestinationExists Restartable AllowDecryptedDestination
}

}

Para leer: Novedades de .net

Dos artículos del msdn para ir entrando en detalle en las novedades de c# y del .net framekork 2.0:

• Métodos anónimos, iteradores y clases parciales
• Generics
  

FREE PDF Reader for Everyday Use

FoxIt Reader es rápido, pequeño, no requiere instalación... ¡que le den al adobe acrobat reader! yo ya me he cambiado

MSDN .NET Framework Developer Center: The LINQ Project

Este es el tremendo artículo (espeso como él solo) de las grandes mentes pensantes de Microsoft sobre las nuevas características del c# 3.0. La coña es la cantidad nueva de inventos que hay que meterle al lenguaje (lambda-expresiones, bla, bla...) para poder integrar una especie de SQL en él.