Discussion :

[ghazghkull]

Comment utiliser une DLL ecrite en C# a partir de delphi5 ?

J'ai une dll que l'on va appeler FaitLeCafe.dll qui m'a été fournie avec un exemple d'appel en C# :
...
using FaitLeCafe;
...
FaitLeCafe.FaitLeCafe mydll = new FaitLeCafe.FaitLeCafe();
mydll.FaitLeCafeEtApporte("A machin");
string resulta = mydll.ReadData.ToString();

Si je decode correctement :
Y a un namspace FaitLeCafe qui contiens un objet FaitLeCafe
ils declarent donc mydll comme etant un objet de type FaitLeCafe
puis invoquent son constructeur.

Par la suite est apellé la fonction FaitLeCafeEtApporte
L'objet mydll a une propriété contenant le résultat de FaitLeCafeEtApporte

J'aimerais pouvoir l'appeler a partir de mon petit delphi5 (il est vieux je sais ^^)
pourriez vous m'aider ;-p

[Fabrice ROUXEL 1]

Appelez du code DotNet à partir de code Win32? C'est possible cela.
L'intéropérabilité des langages existe sur la plateforme DotNet, mais pour cela tu dois utiliser un Delphi qui supporte DotNet.

L'inverse par contre est vrai, via le mécanisme de Reflection, P/Invoke ou VLI.
Personellement je n'ai jamais réussi à faire fonctionner le P/Invoke sous BDS2005 .

Sinon à partir de Delphi5 comme cela, c'est impossible.

[octal]

Si il est possible d'appeler des dll .NET par des programmer Win32.
Voilà une petit exemple ... la DLL (lib) est écrite en D2006 (.NET) et compilé dans un assembly (.DLL)
Mais je pense qu'il faut que la DLL soit prévue pour... (voir le code suivant avec la directive {$UNSAFECODE ON} et l'inclusion de l'unité System.Runtime.InteropServices (à vérifier ... je pense que le livre de Olivier DAHAN traite de cela ... cela fait un bout de temps que je ne fait plus de Delphi... désolé)

Le prog qui l'apelle est un prog D7 tout ce qu'il y a de normal.

L'Assembly DLL de D2006.NET

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
 
library Library1;
 
{$UNSAFECODE ON}
uses
  SysUtils,
  Classes,
  System.Reflection,
  System.Runtime.InteropServices;
 
[assembly: AssemblyTitle('DLL D2006')]
[assembly: AssemblyDescription('DLL Demo D2006')]
[assembly: AssemblyConfiguration('')]
[assembly: AssemblyCompany('OctalWorks')]
[assembly: AssemblyProduct('OW - DLL2006')]
[assembly: AssemblyCopyright('OctalWorks(C) 2006-2007')]
[assembly: AssemblyTrademark('OctalWorks (C) 2006-2007')]
[assembly: AssemblyCulture('')]
 
//
// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Revision and Build Numbers 
// by using the '*' as shown below:
 
[assembly: AssemblyVersion('1.0.*')]
 
//
// In order to sign your assembly you must specify a key to use. Refer to the 
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing. 
//
// Notes: 
//   (*) If no key is specified, the assembly is not signed.
//   (*) KeyName refers to a key that has been installed in the Crypto Service
//       Provider (CSP) on your machine. KeyFile refers to a file which contains
//       a key.
//   (*) If the KeyFile and the KeyName values are both specified, the 
//       following processing occurs:
//       (1) If the KeyName can be found in the CSP, that key is used.
//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
//           in the KeyFile is installed into the CSP and used.
//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
//       When specifying the KeyFile, the location of the KeyFile should be
//       relative to the project output directory. For example, if your KeyFile is
//       located in the project directory, you would specify the AssemblyKeyFile 
//       attribute as [assembly: AssemblyKeyFile('mykey.snk')], provided your output
//       directory is the project directory (the default).
//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
//       documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile('')]
[assembly: AssemblyKeyName('')]
 
//
// Use the attributes below to control the COM visibility of your assembly. By
// default the entire assembly is visible to COM. Setting ComVisible to false
// is the recommended default for your assembly. To then expose a class and interface
// to COM set ComVisible to true on each one. It is also recommended to add a
// Guid attribute.
//
 
[assembly: ComVisible(False)]
//[assembly: Guid('')]
//[assembly: TypeLibVersion(1, 0)]
 
function Multiplier(a, b : integer): integer;
begin
  result := a*b;
end;
  exports Multiplier;
 
begin
 
end.

Le programme D7 Win32

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
 
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
 
type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
function Multiplier(a: Integer; b: Integer): Integer; stdcall;external 'Library1.dll';
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.Button1Click(Sender: TObject);
var i : integer;
begin
  i := Multiplier(13,2);
  ShowMessage(IntToStr(i));
end;
 
end.

Cordialement

[Laurent Dardenne]

Consultez à ce sujet les articles de Brian Long
http://www.blong.com/Conferences/Bor...NetInterop.htm

[Fabrice ROUXEL 1]

Donc la solution serait de l'inverse P/Invoke.

Sinon Octal ton exemple de DLL dotnet contenant une seule fonction, c'est typique de l'api win32 avec des proc rangées dans les dll. Il aurait fallu prendre un cas d'une DLL contenant des classes, des composantes de langage propre à .net.

[ghazghkull]

Je dois avouer que je suis trop inculte pour tout comprendre dans vos réponses...

La méthode décrite par Octal ca je connaissais et d'ailleurs j'esperais obtenir une DLL de cette forme ^^

Apres avoir lu les articles proposés j'ai compris que je ne comprenais rien...

De plus dans cette DLL rien n'est fait pour que l'on puisse l'appeler avec du code Win32 dans le sens ou il ne semble y avoir que un namespace et un objet...

[octal]

Donc la solution serait de l'inverse P/Invoke.

Sinon Octal ton exemple de DLL dotnet contenant une seule fonction, c'est typique de l'api win32 avec des proc rangées dans les dll. Il aurait fallu prendre un cas d'une DLL contenant des classes, des composantes de langage propre à .net.

Pour récupérer des classes .NET je ne pense pas que l'on puisse le faire car les mécanisme d'instantiations ne sont plus les meme. Cela dit il est tjr possible d'utiliser une assembly qui expose des fonctions simples telle que celle de la DLL que j'ai posté pour cacher les appels à des objets .NET, c'est d'ailleur tout l'interet. Pour le reste, sachez tout de meem que les Unit Delphi en .NET ne sont rien de plus que de Super-Classes .NET où les fonctions globales sont de simple méthodes de classes.