Discussion :

[Divadz]

Bonjour tout le monde !

Voilà le contexte : je travaille sur une application qui a 12 ans, qui a été développée en VB6... La mission du moment (enfin, de l'année à venir plutôt !), c'est de migrer le code de VB vers .Net (interfaces utilisateur en VB.Net, classes métiers en C#).
Vu la longueur du projet, on va donc procéder petit à petit, et travailler pendant un bout de temps avec une application moitié managée, moitié native !


Et donc, l'ancien code travaillais avec une DLL de ressource (uniquement des bitmap, icones,... pas de code) faite avec VC++ : on prend un fichier .rc, et on le compile avec les options /DLL /NOENTRY (pas de point d'entrée), etc...
Du coup, on peut accéder à cette DLL par le code VB, en utilisant les fonctions LoadLibrary, FindResource et autres.

Maintenant, je voudrais pouvoir accéder à cette DLL par du code .Net (VB de préférence, mais je me débrouillerais aussi avec du C#...) pour accéder aux images et les afficher dans mes form.

Comment je peux faire ça ?
J'ai regardé un peu la class DllImportAttribute, mais ça m'à l'air fait pour importer les fonctions d'une DLL, pas les ressources... Ou alors j'ai loupé un truc ?

Je dois avouer que ça fait seulement deux semaines que j'ai entendu parler de COM Interop, du coup je débarque un peu...

Merci d'avance !

[Divadz]

Bon ben, au final j'ai bien réussi à me débrouiller, en faisant du P/Invoke sur les même fonctions qu'en VB...
Ça à l'air plutôt rapide, et à défaut je ferai ça, mais si vous connaissez une autre méthode, je suis preneur !

Pour ceux que ça intéresse, voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
Imports System.Runtime.InteropServices
Imports System.ComponentModel
 
Namespace Divadz.Helpers
 
    Public Class ResMgr
        Implements IDisposable
 
#Region "Import d'API"
        <DllImport("kernel32.dll", EntryPoint:="LoadLibraryW", SetLastError:=True, CharSet:=CharSet.Unicode)> _
        Public Shared Function LoadLibrary(ByVal lpFileName As String) As IntPtr
        End Function
        <DllImport("kernel32.dll", EntryPoint:="FreeLibrary", SetLastError:=True)> _
        Public Shared Function FreeLibrary(ByVal hModule As IntPtr) As Boolean
        End Function
        <DllImport("Kernel32.dll", EntryPoint:="FindResourceW", SetLastError:=True, CharSet:=CharSet.Unicode)> _
        Private Shared Function FindResource(ByVal hModule As IntPtr, ByVal pName As String, ByVal pType As String) As IntPtr
        End Function
        <DllImport("Kernel32.dll", EntryPoint:="LoadResource", SetLastError:=True)> _
        Private Shared Function LoadResource(ByVal hModule As IntPtr, ByVal hResource As IntPtr) As IntPtr
        End Function
        <DllImport("Kernel32.dll", EntryPoint:="LockResource")> _
        Private Shared Function LockResource(ByVal hGlobal As IntPtr) As IntPtr
        End Function
        <DllImport("Kernel32.dll", EntryPoint:="SizeofResource", SetLastError:=True)> _
        Private Shared Function SizeofResource(ByVal hModule As IntPtr, ByVal hResource As IntPtr) As UInt32
        End Function
#End Region
 
#Region "Attributs"
        ' Stocke une référence vers l'instance
        Private Shared _instance As ResMgr = Nothing
        ' Pour l'utilisation de SuncLock (singleton en thread-safe)
        Private Shared ReadOnly _mylock As New Object()
        ' Stocke le nom de la dll de ressource. Propriété : DLL
        Private Shared _resLib As String = "ResourcesManager.dll"
        ' Stocke le pointeur vers la dll de ressource.
        Private Shared _resHandle As IntPtr
#End Region
 
#Region "Propriétés"
        Public Shared Property DLL() As String
            Get
                Return _resLib
            End Get
            Set(ByVal value As String)
                _resLib = value
            End Set
        End Property
#End Region
 
#Region "Constructeur/Destructeur"
        ' Le constructeur est Private
        Private Sub New()
            _resHandle = LoadLibrary(_resLib)
            If _resHandle = IntPtr.Zero Then Throw New Win32Exception(Marshal.GetLastWin32Error())
        End Sub
 
        ' On implémente IDisposable.Dispose pour une meilleure gestion de la mémoire
        Public Sub Dispose() Implements IDisposable.Dispose
            If _resHandle <> IntPtr.Zero Then If Not FreeLibrary(_resHandle) Then Throw New Win32Exception(Marshal.GetLastWin32Error())
        End Sub
#End Region
 
        ' Les méthodes d'accès aux ressources gèrent également le pattern singleton
#Region "Accès aux ressources"
        ' Méthode générale, qui renvoit un MemoryStream
        Public Shared Function GetRessource(ByVal name As String, ByVal type As String) As IO.MemoryStream
 
            SyncLock (_mylock)
                ' Si pas d'instance existante on en crée une...
                If _instance Is Nothing Then
                    _instance = New ResMgr
                End If
 
                ' On localise la ressource
                Dim resH1 As IntPtr = FindResource(_resHandle, name, type)
                If IntPtr.Zero = resH1 Then Throw New Win32Exception(Marshal.GetLastWin32Error())
 
                ' On charge la ressource
                Dim resH2 As IntPtr = LoadResource(_resHandle, resH1)
                If IntPtr.Zero = resH2 Then Throw New Win32Exception(Marshal.GetLastWin32Error())
 
                ' On verrouille la ressource
                Dim resH3 As IntPtr = LockResource(resH2)
                If IntPtr.Zero = resH3 Then Throw New Exception("Lock failed")
 
                ' On récupère la ressource
                Dim resSize As UInt32 = SizeofResource(_resHandle, resH1)
                Dim y As Byte() = New Byte(CInt(resSize)) {}
                Marshal.Copy(resH3, y, 0, CInt(resSize))
 
                ' On retourne le flux
                Return New IO.MemoryStream(y)
            End SyncLock
 
        End Function
 
        ' Renvoie une image (gif, png, bmp, jpg, ...)
        Public Shared Function GetImage(ByVal resName As String, ByVal resType As String) As Image
            Return Image.FromStream(GetRessource(resName, resType))
        End Function
#End Region
    End Class
 
End Namespace

Voili voilou !