Cita de: Ikillnukes;1042929488este DLL tiene siempre que estar al lado del ejecutable (.exe) para que la aplicación rule, si no lo está no se abre como sabréis.
Eso es incorrecto, una dll es un archivo localizable como cualquier otro archivo, puedes meter el ensamblado en una carpeta cualquiera, y luego cargarlo desde esa '...\carpeta\ensamblado.dll' en tu proyecto (ya sea WF o WPF).
Cita de: Ikillnukes;1042929488Para mi esto de que un maldito DLL tenga que estar al lado del Exe para que se pueda ejecutar me toca mucho la moral, y bueno, pues estuve viendo por ahí metodos de como poder llamar a este dichoso DLL desde los recursos.
Es lo más normal del mundo, una dll no es más que un conjunto de Classes y otros miembros (como un proyecto, en este caso solo métodos con sus objetos y otros miembros y los diálogos ...UserControls) compiladas en un ensamblado .NET ...de extensión dll y con sus puntos de acceso (EntryPoints) legibles y accesibles por el lenguaje, es un archivo complétamente independiente al que accedes.
Cita de: Ikillnukes;1042929488si cargo desde los recursos este dichoso DLL como se supone que Intellise va a detectar que en los recursos hay tal DLL para importarlo (Imports DLL.Dichoso)
hmmm, creo que entiendo lo que quieres decir... aunque también creo que estás confundiendo cosas, la característica IntelliSense nada tiene que ver con la importación de un ensamblado (la instrucción Imports), son dos cosas muy distintas, aparte, la declaración Imports referencia los miembros de un ensamblado para que puedas especificarlos de forma abreviada y también para evitar ambiguedades (conflictos) entre miembros que tengan el mismo nombre ...pero tú la librería la puedes usar sin importarla, solo tienes que escribir el namespace completo (una vez hayas referenciado el ensamblado).
IntelliSense es una característica que muestra la información relevante (los comentarios XML que se hayan documentado en el ensamblado), sobre los miembros (cualquier miembro documentable, como una propiedad, o un método, y sus parámetros y/o su valor de retorno),
si te fijas en alguno de mis Snippets verás muchos comentarios, pues no lo hago por gusto, lo hago para documentar el código y que IntelliSense lo muestre.
Para usar la instrucción Imports en un ensamblado (la dll), este debe existir como un archivo físico en el disco para importar (al menos que yo sepa), ten en cuenta que los recursos se cargan en la memoria y no en el disco, pero como todo espacio de memoria, este se puede manipular y extraer, así que si añades una dll como recurso a tu proyecto, una vez compilado (quiero decir, en tiempo de ejecución) podrías extraer primeramente del Stream de memoria todos los bytes que forman el archivo dll para guardarlo en el disco físico ...en un 'archivo.dll', y luego cargarlo usando Reflection, o mejor todavía, puedes cargar el Stream del ensamblado (el recurso en el namespace My.Resources) diréctamente usando Reflection,
pero el tema Reflection es MUY extenso y complejo como para explicarlo en 10 segundos, y además deberías usar reflection también para modificar todos los nombres referenciados de la libreria, por ejemplo:
Código [Seleccionar]
Dim dialog As New Ookii.Dialogs.VistaFolderBrowserDialog
Esa sería la manera normal como instanciarias el objeto, pero al no tenerlo referenciado obviamente no vas a poder especificar los nombres completos porque el Debugger te va a mandar a la mierd..., primero tienes que cargar el ensamblado, luego debes localizar el miembro instanciable (la Class que contiene el Constructor), y luego instanciarla, ejemplo:Código (vbnet) [Seleccionar]
Imports System.Reflection
Public Class Form1
Private Shadows Sub Shown() Handles MyBase.Shown
' Cargo la dll como recurso, es decir, cargo el Stream de memoria que contiene los bytes de la dll.
Dim asm As Assembly = Assembly.Load(My.Resources.Ookii_Dialogs)
' Obtengo el miembro 'VistaFolderBrowserDialog' del ensamblado.
Dim t As Type = (From member As Type In asm.GetTypes
Where member.Name = "VistaFolderBrowserDialog").First
' Instancio la Class.
' Esto sería el equivalente a:
' Dim Dialog As New Ookii.Dialogs.VistaFolderBrowserDialog
Dim Dialog = Activator.CreateInstance(t)
' Asigno una propiedad del Objeto.
Dialog.Tag = "Hello"
MsgBox(Dialog.tag)
End Sub
End Class
...Y eso es en versión reducida y rápida, si un método es privado o si hay coincidencias ambiguas (un método overload, con el mismo nombre que otro) deberás iterar los miembros (métodos) para hallar el correcto e invocarlo, y especificar sus Types, el Binder, y etc, y lo mismo para asignar valores a las propiedades en caso de que se den las mismas circunstancias, usar Reflection no es moco de pavo, es algo avanzado, aunque cuando vas aprendiendo te das cuenta de que hay cosas que son muy sencillas al fin y al cabo.Y en fín, por esa razón te sugerí otras alternativas (seguir leyendo abajo).
Cita de: Ikillnukes;1042929488ILMerge por aquí, .Net Shrink por allá, pero ningún maldito tutorial en condiciones que te explique paso por paso lo que se supone que hay que hacer.
No se si es sarcasmo, porque lo de ILMerge y .NET Shrink te lo sugerí yo... y a mi parecer si no te entiendes con una aplicación tan sencilla diseñada para newbies como es .NET Shrink entonces diréctamente te sugiero dejar de programar.
Te explico, abres la aplicación, arrastras los ensamblados .NET (el exe + las librerías dll), y le das al botoncito que pone 'Compress File', y listo, ya tienes todos los ensamblados empaquetado en un único archivo executable, muy dificil no es ...¿VERDAD?, ¿sigue siendo necesario un tutorial?.
De hecho te recomendé el uso de esa aplicación porque es lo más sencillo y rápido para ti, tú lo que debes hacer es agregar tus librerías dll a tu proyecto, no te preocupes por si la dll está "al lado" del exe, tu hazlo e importas la librería en tu proyecto como harias normalmente, acabas tu proyecto y todo el código, y luego (el paso final) abres el .NET Shrink (o ILMerge u otros Mergers) y lo empaquetas como te expliqué, se generará un único archivo EXE que contendrá todas las dll que hayas metido, la structura de archivos seguirá siendo la misma intérnamente, es decir, la dll estará ubicada al lado del exe ...pero todo estará empaquetado y podrás usar esa dll teniendo solo un exe (con la dll adentro).
Saludos!
Aparte de eso, por si te interesa más Reflection, hice este ejemplo y lo posteé hace tiempo en el hilo de Snippets, un ejemplo para localizar e invocar métodos:
Código (vbnet) [Seleccionar]
Imports System.Reflection
Imports System.Globalization
Public Class Form1
Private Shadows Sub Load() Handles MyBase.Load
Dim MethodName As String = "Test"
Dim Method As MethodInfo =
Me.GetType().GetMethod(MethodName, BindingFlags.IgnoreCase Or BindingFlags.Instance Or
BindingFlags.Public Or BindingFlags.NonPublic)
If Method IsNot Nothing Then
Method.Invoke(Me, BindingFlags.IgnoreCase Or BindingFlags.Instance Or
BindingFlags.Public Or BindingFlags.NonPublic,
Nothing,
New Object() {"Hello World!", Type.Missing}, CultureInfo.InvariantCulture)
Else
MsgBox("Method not found.")
End If
End Sub
Private Sub Test(ByVal StringValue As String, Optional ByVal IntValue As Integer = 1)
MessageBox.Show(StringValue & IntValue)
End Sub
End Class
Nota: Hay que tener muy presente la visibilidad del miembro.