Si quieres meter las dll en el GAC para que sean compartidos por todas las aplicaciones de la maquina tienes que tener en cuenta un par de cosas:

• Las dll que pongas en el GAC tienen que estar firmadas, el proceso es sencillo, vas a las propiedades del proyecto y la firmas, todo visual.
• Todas las referencias que use tu dll tienen que estar firmadas también, todas las del Framework lo están ya, así que solo te tienes que preocupar de las tuyas y de las de 3ros que estés usando.
• Tienes que poner una versión fija a la dll (que no se autoincremente en cada compilación, eso lo haces en AssemblyInfo quitando el * en la versión) ya que las aplicaciones quedaran referenciadas a esa versión y así no necesitaras actualizar las aplicaciones cuando actualices la dll en el GAC.

No es un tema complicado, el único “problema” que encontramos fue cuando generamos una dll de serializarión con los tipos con el sgen, ya que esa dll tiene que estar firmada también, para eso tienes que firmar  primero la dll sin las referencias a la dll de serializacion, después generar la dll de serializacion firmada y volver a poner las referencias, eso solo es necesaria hacerlo la primera vez, después cuando modifiquemos algún tipo y queramos actualizar la dll de serialización como están las dos firmadas no importa quitar referencias.

Para generar la dll de serializacion firmada el comando es este:

sgen.exe /assembly:”$(TargetDir)$(TargetFileName)” /compiler:”\”/keyfile:$(ProjectDir)Signature.snk”\” /force

Para meterlas en el GAC basta que las arrastres a la carpeta Windows/Assembly.

Aquí vemos como capturar el evento del botón derecho en silverlight.

Este evento desde la salida de silverlight ha estado inactivo, y dicen que en la siguiente versión, silverlight 4, estará disponible (también dijeron eso en la versión 3).

Cuando haces click derecho en la aplicación Silverlight te muestra un menú contextual y un dialogo de configuración.

¿Y si quieres usar el botón derecho en tu aplicación silverlight? El proceso es muy sencillo, y aquí os detallare unos pasos que deberéis de seguir para poder utilizar dicho evento y mostrar un menú contextual propio.

Paso 1: Tenemos que establecer el control de Silverlight para ventanas. En la pagina web del proyecto (suele ser default.aspx) que contiene el control Silverlight añadir la etiquetawindowless=”true”.

Paso 2: Introducimos el contextmenu donde queramos capturar el evento click derecho. Dentro del xaml creamos una nueva clase llamada ContextMenuInterceptor. En el constructor de esta clase capturamos un evento llamado “OnContextMenu” con HtmlPage.Document.AttachEvent (deberás agregar la referencia System.Window.Browser).

Dentro de este evento llamamos a e.PeventDefault(). Esto cancela la propagación del evento click derecho para que silverlight no lo reciba (así no mostrará su menu contextual).

En este punto, es cuando usted esta capturando el evento y podra mostrar o hacer cualquier cosa. En el ejemplo que pongo a continuación utilizo yo un TextBlock para mostrar cuando capturamos el click derecho.

Page.xml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Windows.Browser;

namespace SilverlightApplication15
{
    public partial class Page : UserControl
    {
        ContextMenuInterceptor _cmi = null;
        public Page()
        {
            InitializeComponent();
            _cmi = new ContextMenuInterceptor(MyField);
        }
    }       

    public class ContextMenuInterceptor
    {
        TextBlock TextField;

        public ContextMenuInterceptor(TextBlock textField)
        {
            TextField = textField;
            HtmlPage.Document.AttachEvent("oncontextmenu", this.OnContextMenu);
        }

        private void OnContextMenu(object sender, HtmlEventArgs e)
        {
            TextField.Text = "Right Clicked Blocked at "+e.OffsetX+","+e.OffsetY;
            e.PreventDefault();
        }
    }
}

Microsoft.Practices.Unity  nos permite mapear una Clase a un Interface a través de una configuración en el .config de la aplicación, de esta manera podemos cambiar el comportamiento o el escenario en el que esta se ejecuta la aplicación tocando solo esa configuración.

Aquí dejo un ejemplo básico:

1-Creamos el Interface

public interface IMessage
{
    string Get();
}

2-Creamos las clases que implementan el interface

public class Message1 : IMessage
{
    public string Get()
    {
        return "Desde Message 1";
    }
}

public class Message2 : IMessage
{
    public string Get()
    {
        return "Desde Message 2";
    }
}

3-Creamos la clase donde usaremos el Interface, en esta debemos definir un campo del tipo del interface marcado como [Dependency] y un método de load para cargar la clase que corresponde en el interface

public class Message
{
    [Dependency]
    public IMessage IMessage { get; set; }

    public static Message Instance
    {
        get
        {
            using (IUnityContainer container = new UnityContainer())
            {
                UnityConfigurationSection ConfigurationSection =
                    (UnityConfigurationSection)
                    ConfigurationManager.GetSection("DITest");
                ConfigurationSection.Containers.Default.Configure(container);
                Message objMessage = container.Resolve<Message>();
                return objMessage;
            }
        }
    }
}

4-Creamos el archivo de configuración donde hacemos el mapeo

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
  <section name="DITest"
           type="Microsoft.Practices.Unity.Configuration.
                       UnityConfigurationSection,
                 Microsoft.Practices.Unity.Configuration"/>
  </configSections>
  <DITest>
    <containers>
      <container>
        <types>
          <type type="DITest.IMessage,DITest"
                mapTo="DITest.Message2,DITest"/>
        </types>
      </container>
    </containers>
  </DITest>
</configuration>

5-Probamos el código desde la consola y vamos cambiando el “mapTo” del archivo de configuración para ir viendo el cambio

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(Message.Instance.IMessage.Get());
        Console.ReadLine();
    }
}

La gente de dawliasoft anuncio hace poco que publicaban la nueva versión de Sculpture, así que me la voy bajando a ver que tal …

Nuevas funcionalidades en esta reléase

• Documentación completa en PDF
• Soporte para Oracle
• Herencia multinivel en NHibernate y Entity Framework
• Soporta los mas comunes escenarios de concurrencia (All, Dirty, y Version) para NHibernate
• Soporta vistas en MSSQL y MySQL

Puedes descargarla desde Aquí.

Hace unos días Jordi escribió sobre las SoapExtensions y yo sobre las SoapHeaders, hoy le añadimos herencia y vemos como ahorrarnos bastante código y trabajo en una capa de servicios.

La idea es que todos los métodos de todos los servicios web de la aplicación se autentifiquen en el mismo sitio y no tener que poner el código de autentificación en cada método, además no queremos usar cookies ni mantenimiento de sesión.

Para esto usaremos una Cabecera Soap donde el cliente nos enviara Usuario y Contraseña, debemos crear la clase cabecera:

public class SoapHeaderCredentials : SoapHeader
{
    public string Password = "";
    public string UserName = "";
}

Cada servicio web tiene que tener una propiedad con la Cabecera, para ahorrarnos el escribirlo cada vez, creamos una clase que herede de WebService, que contenga la propiedad y heredamos los servicios web de esa clase:

public class MyWebService : System.Web.Services.WebService
{
    public SoapHeaderCredentials soapHeaderCredentials;
}

public class Service : MyWebService

Después creamos una Extensión Soap de autentificación (en este caso la llamamos AuthenticationExtension), Jordi ya explica aquí como crearlas así que solo pongo el código que nos interesa, que es donde buscamos la Cabecera Soap en el Método ProcessMessage:

case SoapMessageStage.AfterDeserialize:
{
    var o = from h in message.Headers.Cast<SoapHeader>()
            where h.GetType() == typeof(SoapHeaderCredentials)
            select h ;
    SoapHeaderCredentials soapHeaderCredentials =
        (SoapHeaderCredentials) o.First();
    AuthenticateUser(
        new Credentials()
        {
          UserName = soapHeaderCredentials.UserName,
          Password = soapHeaderCredentials.Password,
        }, 

      );
    break;
}

Después solo queda añadir los dos atributos [SoapHeader("soapHeaderCredentials")]  y [AuthenticationExtension()] a nuestros WebMethods, eso hará que los métodos tengan la cabecera de usuario y contraseña y que ejecuten el código de autentificación al recibir un mensaje:

[WebMethod]
[SoapHeader("soapHeaderCredentials")]
[AuthenticationExtension()]
public string HelloWorld()
{
    return "Hello World";
}

Y listo

Es sencillo obtener una representación XML de nuestras clases con el método ToString, solo hemos de sobrescribirlo por este:

public override string ToString()
{
    XmlSerializer ser = new XmlSerializer(this.GetType());
    StringWriter sw = new StringWriter();

    ser.Serialize(sw, this);

    sw.Flush();
    sw.Close();
    return sw.ToString();
}

También podemos crearlas desde su representación XML:

public static MyClass CreateFromXml(string xml)
{
    XmlSerializer ser = new XmlSerializer(typeof(MyClass));
    StringWriter sw = new StringWriter();

    return (MyClass) ser.Deserialize(new StringReader(xml));
}

Todo el Código de ejemplo:

public class MyClass
{
    public string Data1 { get; set; }
    public string Data2 { get; set; }

    public static MyClass CreateFromXml(string xml)
    {
        XmlSerializer ser = new XmlSerializer(typeof(MyClass));
        StringWriter sw = new StringWriter();

        return (MyClass) ser.Deserialize(new StringReader(xml));
    }

    public override string ToString()
    {
        XmlSerializer ser = new XmlSerializer(this.GetType());
        StringWriter sw = new StringWriter();

        ser.Serialize(sw, this);

        sw.Flush();
        sw.Close();
        return sw.ToString();
    }

    public void Test()
    {
        MyClass c = new MyClass();
        c.Data1 = "Hola";
        c.Data2 = "Como Estas";

        string xMyClass = c.ToString();

        MyClass copy = MyClass.CreateFromXml(xMyClass);
    }
}

Nos puede ser muy útil para temas de log, guardar los datos en las desconexiones, para debugear o para transportar la clases en XML entre aplicaciones.

Añadir cabeceras personalizadas a los mensajes de nuestros servicios web es realmente sencillo, en esas cabeceras podemos transportar cualquier dato que nos interese tokens, usuario y contraseña, lo que sea..

Hay que hacer lo siguiente:

1- Crear la clase con los datos que herede de SoapHeader

public class SoapHeaderData: SoapHeader
{
    public string Data1;
    public string Data2;
    public string Data3;
}

2- Crear una propiedad en el servicio web con esa clase y la etiqueta SoapHeader con el nombre de la propiedad al método web, en esa propiedad tendremos los datos

[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
    public SoapHeaderData HeaderData;

    [WebMethod]
    [SoapHeader("HeaderData")]
    public string HelloWorld() {
        return "Hello World " + HeaderData.Data1 + ", " +
                                HeaderData.Data2 + ", " +
                                HeaderData.Data3;
    }
}

Solo haciendo esto ya tenemos la cabecera en nuestra petición SOAP:

Cada vez queda menos para que tengamos disponible la nueva versión de VS, junto con .NET Framework 4.0, C# 4.0, ASP.NET 4.0 etc, así que lo mejor es irse preparando, por ese motivo la gente de Microsoft lanza los “Kits de Entrenamiento”.

 Aquí podéis encontrar el ultimo, de Octubre, en el encontraremos, presentaciones, demos y ejemplos de:

C# 4.0, Visual Basic 10, F#, Parallel Extensions, Windows Communication Foundation, Windows Workflow,Windows Presentation Foundation, ASP.NET 4, Windows 7, Entity Framework,ADO.NET Data Services, Managed Extensibility Framework y Visual Studio Team System.

Así que no falta de nada

Axum es un pre proyecto de Microsoft orientado a la programación paralela.

En el sitio web del proyecto puedes descargarlo (necesita Visual Studio 2008), además de la documentación encontraras un video de como empezar y algo de feedback de otros usuarios. El equipo de programación tiene un blog en el que encontraras algo de información extra.

Esta bien pegarle un vistazo, pero no creo que convenga liarse mucho ya que no es seguro que llegue a ver la luz como producto.

Ya esta disponible el código fuente del framework desde Visual Studio 2008.

Las librerías disponibles de momento son:

• .NET Base Class Libraries (System, System.CodeDom, System.Collections, System.ComponentModel, System.Diagnostics, System.Drawing, System.Globalization, System.IO, System.Net, System.Reflection, System.Runtime, System.Security, System.Text, System.Threading, etc).

• ASP.NET (System.Web, System.Web.Extensions)

• Windows Forms (System.Windows.Forms)

• Windows Presentation Foundation (System.Windows)

• ADO.NET y XML (System.Data y System.Xml)

Los pasos necesarios para poder ver y depurar el código del framework son:

1. Instalar esta actualización (atención a los usuarios de sistemas de 64 bits, es necesario un paso extra).

2. Dentro de Visual Studio 2008 ir a Herramientas, Opciones, Debugging, General y desactivar la opción Enable Just My Code y activar Enable Source Server

3. Ir a Symbols y añadir esta URL: http://referencesource.microsoft.com/symbols y poner un directorio cualquiera en Cache symbols from symbol servers to this directory

Y listo.