Ahora que ya empezamos a tener (algunos ciudadanos) certificados digitales
expedidos por la FNMT cada vez es más común la necesidad de FIRMAR
documentos desde el browser.
Hasta ahora, sólo sabia hacerlos con CAPICOM, pero como es un ActiveX, sólo
para IE.
Por fin he encontrado un componente para hacerlo con mozilla 1.5
Hoy he vuelto a intentar la macro, sigue dando problemas,
el UI no es útil, y hacerlo bien me va a llevar tiempo asi que lo
necesito es algo ... "quick and dirty".
Paso de UI, y con unas ctes me apaño, de paso hago
un poco de Refactoring y para terminar lo dejo todo en un ficherito como este..
'--------------------------------------------------------------
'written by rido'03 (rido@ya.com)
'------------------------------------------------------------
Imports System
Imports EnvDTE
Imports System.Diagnostics
Imports VSLangProj
#Region "Path to NUnit"
Public Module NUnitConstants
Public Const BASE_PATH As String = "c:\Program Files\NUnit v2.1\bin\"
Public Const NUNIT_FX_ID As String = "nunit.framework.dll"
Public Const NUNIT_FX As String = BASE_PATH & "nunit.framework.dll"
Public Const NUNITGUI_RUNNER As String = BASE_PATH & "nunit-gui.exe"
End Module
#End Region
Public Module TestProjectConfigurator
Dim currentProject As VSProject
#Region "Private"
Private Sub removeReference(ByVal referenceIdentity As String)
currentProject.References.Find(referenceIdentity).Remove()
End Sub
Private Sub addReference(ByVal referencePath As String)
currentProject.References.Add(referencePath)
End Sub
Private Sub resetDebugProperties()
Dim configProps As Properties = currentProject.Project.ConfigurationManager.ActiveConfiguration.Properties
With configProps
.Item("StartAction").Value = prjStartAction.prjStartActionProject
.Item("StartProgram").Value = ""
.Item("StartArguments").Value = ""
End With
End Sub
Private Sub setDebugProperties(ByVal runnerPath As String)
Dim assemblyName As EnvDTE.Property = CType(currentProject.Project.Properties.Item("AssemblyName"), EnvDTE.Property)
Dim configProps As Properties = currentProject.Project.ConfigurationManager.ActiveConfiguration.Properties
With configProps
.Item("StartAction").Value = prjStartAction.prjStartActionProgram
.Item("StartProgram").Value = runnerPath
.Item("StartArguments").Value = assemblyName.Value + ".dll"
End With
End Sub
Private Sub resetProject()
removeReference(NUNIT_FX_ID)
resetDebugProperties()
End Sub
Private Sub configureProject()
addReference(NUNIT_FX)
setDebugProperties(NUNITGUI_RUNNER)
End Sub
#End Region
Public Sub Run()
currentProject = DTE.ActiveSolutionProjects(0).Object
configureProject()
End Sub
Public Sub ResetConfig(ByVal nada As Object)
currentProject = DTE.ActiveSolutionProjects(0).Object
resetProject()
End Sub
End Module
Hacia unos meses que no me tenia que pelear con VB6, y sobre todo con los problemas de compatibilidad binaria, referencias a proyectos/dlls etc.
Buscando una herramienta con la que limpiar
el registro he encontrado esta página que explica muy bien la mecánica del IDE de VB6 y la compatibilidad binaria
http://www.visibleprogress.com/vb_binary_compatibility.htm
He tenido problemas para ejecutar un bat y redirigir la salida a la consola, aqui está el ejemplo:
Process p = null;
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = Path.GetFullPath( MOCK_BASE_PATH + "buildMockAssemblies.bat");
psi.WorkingDirectory = Path.GetFullPath(MOCK_BASE_PATH);
psi.UseShellExecute = false;
psi.RedirectStandardOutput = true;
p = Process.Start(psi);
string output = p.StandardOutput.ReadToEnd();
p.WaitForExit();
Console.WriteLine(output);
Mi lista de Feeds RSS sigue creciendo, he añadido los feeds de SF más importantes:
Si las quieres, aqui están (en formato sharpreader)
Sigo flipando con nant.
Viendo las tareas de nant.contrib me sorprendio encontrar codestats
Y he decidio ampliar la tareas para que cuente las clases publicas que hay en un grupo de assemblies dado.
Como siempre los interesados pueden descargarse una temprana version de mi
wokspace en GotDotNet
Alguna vez has necesitado abrir VS para probar realizar una pequeña prueba de cocepto?
Gracias a Snippet Compiler
podemos hacer pruebas de concepto sin tener que arrancar VS !!
La serialización de objetos es una tecnología que nos permite persistir el estado de un objeto y rehidratarlo después.
Gracias a este mecanismo podemos desacolar subsistemas facilmente.
Pero a veces nos econtramos con objetos que no cumplen con los requisitos de serialización estándar.
Estos objetos se pueden serializar gracias al Memento Design Pattern ...
http://www.ondotnet.com/pub/a/dotnet/2002/09/09/memento.html
El mecanismo de ficheros de configuración de .NET funciona por AppDomain (miniProceso),
Eso significa que al cargar una libreria para probarla con nunit necesitarias incluir los parámetros
de configuración en Nunit-gui.exe.config, lo cual no parece muy buena idea.
Afortunadamente NUnit soluciona este problema leyendo la configuración del fichero
MyLib.dll.config. Por lo tanto, para que todo funcione correctamente necesitamos crear
este fichero manualmente.
VS crea el fichero de configuración al compilar a partir del fichero App.config, pero solo
para proyectos cuya salida sea un EXE.
Con esta macro (Post Build) podemos automatizar la creación de ficheros de configuración
para librerias:
copy $(ProjectDir)App.config $(TargetDir)$(TargetFileName).config
Afortunadamente NUnit soluciona este problema leyendo la configuración del fichero
MyLib.dll.config. Por lo tanto, para que todo funcione correctamente necesitamos crear
este fichero manualmente.
VS crea el fichero de configuración al compilar a partir del fichero App.config, pero solo
para proyectos cuya salida sea un EXE.
Con esta macro (Post Build) podemos automatizar la creación de ficheros de configuración
para librerias:
copy $(ProjectDir)\App.config $(TargetDir)$(TargetFileName).config
La versión actual de NAnt no soporta NUNit 2.1, que como no, es la versión con la que estamos escribiendo los UnitTests.
La primera opción parecia ejecutar las pruebas fuera del script de NAnt,
pero los proyectos open source permiten ser más ágil cuando te encuentras estas incompatibilidades, gracias a John Lam hay forma de arreglarlo: http://www.iunknown.com/000342.html
Esta semana me ha tocado montar el sistema de compilación del proyecto en el que estamos trabajando.
He estado evaluando varias opciones y parece que la mejor es:
La serialización de objetos siempre me ha parecido una característica muy importante en cualquier arquitectura, nos permite:
En .NET tenemos dos tipos de serializadores: XmlSerializer y SoapFormatter (tb está el BinaryFormatter, pero ese lo dejamos para otro día).
La principal diferencia radica en que el primero serializa el interfaz público de la clase y los Formatter serializan el ObjectGraph de la instancia en memoria.
Gracias a esta clase podemos serializar objetos como strings XML, lo mejor es que no es necesario crear un fichero físico y podemos serializarlo en memoria:
using System; using System.IO; using System.Xml.Serialization;namespace ListSerializerDemo
{
···public class XmlSerializerHelper
···{
······static public string Serialize(object o)
······{
·········string result = String.Empty;
·········XmlSerializer ser = new XmlSerializer(o.GetType());
·········MemoryStream s = new MemoryStream();
·········ser.Serialize(s, o);
·········s.Position = 0;
·········StreamReader sr = new StreamReader(s, System.Text.Encoding.UTF8);
·········result = sr.ReadToEnd();
·········sr.Close();
·········s.Close();
·········return result;
·········}
······}
}