C# DLL Tutorial?

[Chefx]

Hey DBs, :hi:

kennt hier ein Tutorial für C# wo es um DLL-Dateien geht?

danke im vorraus :wink:

[Phoenix]

Äh? :glaskugel:

Was willst Du denn machen?
DLL Dateien aus einem .NET Assembly heraus aufrufen geht über sogenanntes P/Invoke. Unter dem Stichwort findest Du alles was Du brauchst.

Wenn Du eine C#-Dll (also ein Assembly) aus Delphi heraus aufrufen willst, dann hast Du ein Problem. So einfach geht das nämlich nicht, eine .NET Anwendung aus nativem Code anzusprechen. Das Stichwort wäre reverse P/Invoke, und ich bin ganz ehrlich: Ich arbeite ungeheuer viel mit .Net, und das habe ich noch nie tauglich hinbekommen, obwohl ich mich mehrere Wochen damit beschäftigt habe.

Aber warum postet Du die Frage eigentlich in eine Delphi-Sparte, wenn es doch um .NET geht?

[DP-Maintenance]

Dieses Thema wurde von "Phoenix" von "Sonstige Fragen zu Delphi" nach "Windows API / MS.NET Framework API" verschoben.
Falsche Sparte.

[Chefx]

Ich hab eingentlich ein anderes Problem weil ich eine C# DLL Datei programmiert hab und
in ein Delphi "öffnen" möcht!
Ich wollt erst mal schau ob ich in der DLL Datei was falsch programmiert hab!
In Delphi hab ich schon eine DLL programmiert aber in C# nicht!
Hab mal hier ein Bsp.:

Code:

using System;

namespace Projekt8
{
   public class Class1
   {
      public Class1()
      {
      }

      public static int tex(int t)
      {
         t += 1;
         return t;
      }

   }
}

und hier Delphi:

Delphi-Quellcode:

unit Unit3;

interface

...

function tex(t:integer):integer; stdcall; external 'Projekt8.dll';
implementation

...

procedure TForm3.Button1Click(Sender: TObject);
begin
edit1.Text:=Inttostr(tex(strtoint(edit1.Text)));
end;

end.

(ist bloß ein test)
Ich weiss auch nicht ob das so richtig ist mit dem Aurufen von der DLL Datei von C# und ob es in C# eine exports-Klausel gibt?

[Phoenix]

Zitat:

Zitat von Phoenix

Wenn Du eine C#-Dll (also ein Assembly) aus Delphi heraus aufrufen willst, dann hast Du ein Problem. So einfach geht das nämlich nicht, eine .NET Anwendung aus nativem Code anzusprechen. Das Stichwort wäre reverse P/Invoke, und ich bin ganz ehrlich: Ich arbeite ungeheuer viel mit .Net, und das habe ich noch nie tauglich hinbekommen, obwohl ich mich mehrere Wochen damit beschäftigt habe.

C#-Kompilate sind Assemblies. Das ist kein x86-Code, den Delphi importieren könnte. In der DLL liegt sogenannter IL-Code (Intermediate Language-Code, vergleichbar mit Java Bytecode), und dieser IL-Code muss erst in Assemblercode übersetzt werden damit er laufen kann.

Delphi kann den IL-Code nicht übersetzen, kann daher also keine .NET Assembly .dll aufrufen.

Dazu braucht es eine .NET Runtime (ähnlich der Java-VM), und zwar entweder das Microsoft .NET Framework oder aber Mono. Also müsste Delphi eigentlich erst die Runtime aufrufen, der Runtime sagen: Führ diese Methoden in diesem Assembly aus, konvertiere den Rückgabewert in irgendeinen Typen den ich verstehe und gebe mir das Ergebnis zurück.

Das geht nicht so einfach. Ich würde es ehrlich gesagt sein lassen, wenn Du nicht mehrere Wochen an Research da reinstecken willst.

[Chefx]

Danke für deine antwort! :pale:
Ich dachte es wäre einfacher ich werd mal ein par stunden investieren und wenn ich nicht mal ansatzweise weiterkomme
dann gehe ich dein tipp nach und lass es lieber sein!

hast du vielleicht einbisschen material darüber?

danke :thumb: :thumb: :thumb:

[jfheins]

Siehe auch das hier: http://www.delphipraxis.net/internal...t.php?t=161013

Da gings um ein ähnliches Thema - über die Qualität der Lösung kann ich aber nichts sagen.

[xaromz]

Hallo,

eigentlich geht das gar nicht so schwer. Man muss nur den Umweg über COM gehen. Ich hab hier mal ein kleines Beispiel. Du baust ein Assembly und definierst Deine Klassen:

Code:

    //Interface definieren
    [Guid("454F8365-58CA-4583-9991-5EF798997B73")]
    public interface ISqlConnection
    {
        DatabaseType DatabaseType { get; set; }
        string UserName { get; set; }
        string Password { get; set; }
        string Host { get; set; }
        string Port { get; set; }
        string Database { get; set; }
        bool Encrypt { get; set; }

        void Open();
        void Close();
        void ChangeDatabase(string DatabaseName);
        SqlQuery CreateQuery();
        ConnectionState State { get; }
    }

    // Klasse definieren
    [ClassInterface(ClassInterfaceType.None)]
    [Guid("60E14408-876F-4017-AF09-0131D8C82F5A")]
    public class SqlConnection: ISqlConnection
    {
      ...
    }

Für das erstellte Assembly kannst Du Dir in Delphi über "Komponente importieren" eine Type-Library bauen lassen, und schon kannst Du mit Deinen Klassen loslegen. Vorher musst Du natürlich das Assembly mit RegAsm registrieren (ist ja COM).

Ich hab mal ein fertiges Assembly-Projekt und das zugehörige Delphi-Projekt angehängt.

Gruß
xaromz

[Elvis]

Zitat:

Zitat von Phoenix

Wenn Du eine C#-Dll (also ein Assembly) aus Delphi heraus aufrufen willst, dann hast Du ein Problem. So einfach geht das nämlich nicht, eine .NET Anwendung aus nativem Code anzusprechen. Das Stichwort wäre reverse P/Invoke, und ich bin ganz ehrlich: Ich arbeite ungeheuer viel mit .Net, und das habe ich noch nie tauglich hinbekommen, obwohl ich mich mehrere Wochen damit beschäftigt habe.

Was geht denn nicht?
Schaue mal den Beitrag hier an. Damit kann man das mit jeder .Net Sprache machen, die Attribute und MSBuild unterstützt.

Zitat:

Zitat von Phoenix

C#-Kompilate sind Assemblies. Das ist kein x86-Code, den Delphi importieren könnte. In der DLL liegt sogenannter IL-Code (Intermediate Language-Code, vergleichbar mit Java Bytecode), und dieser IL-Code muss erst in Assemblercode übersetzt werden damit er laufen kann.
Delphi kann den IL-Code nicht übersetzen, kann daher also keine .NET Assembly .dll aufrufen.

Äpfel und Birnen. Zum Laden einer .Net Assembly muss Windows nur wissen, wie es passieren soll.
IOW: Soll COM benutzt werden oder ist die Assembly Mixed-Mode mit einer korrekten Exporttabelle.
Ob der eigentliche Code nun in IL geschrieben wurde oder nicht ist für den konsumierenden Prozess absolut transparent.
Der wirkliche Unterschied ist, dass COM Interop auch mit normalen "AnyCPU" Assemblies geht, ie ja gar keine DLLs sind. Während klassische DLL-Exports nur mit Assebmlies geht, die auf eine CPU-Platform fixiert sind. Das sind dann aber auch richtige DLLs, bis auf die Tatsache, dass sie innen auch ein bissel IL enthalten.

Zitat:

Zitat von Phoenix

Das geht nicht so einfach. Ich würde es ehrlich gesagt sein lassen, wenn Du nicht mehrere Wochen an Research da reinstecken willst.

Er müsste nur das Archiv aus dem Beitrag oben in sein Projekt entpacken und wie dort beschrieben eine Zeile in seine Projektdatei hinzufügen.

Danach kann er das einfach so machen:

Code:

public class Class1 
{ 
  [DllExport("ausCSharp", CallingConvention = CallingConvention.StdCall)]
  public static int tex(int t) 
  { 
    t += 1; 
    return t; 
  } 
}

Delphi-Quellcode:

function ausCSharp(t:integer):integer; stdcall; external 'DieDotNetAssembly.dll';

Da ist auch kein Hack oder irgendein fieser Trick involviert.
Ich nutze dafür die dokumentierte Infrastruktur/API, die MSFT für C++/CLI oder andere mixed-mode Sprachen in die CLR integriert hat. (Ist ein .Net-only feature, Mono kann das nicht)