Enum und Const in C#-Dll???

Tag zusammen,

wollte mir aus meinen selbst geschriebenen Funktionen, Methoden, etc. mal eine Dll erstellen. Das mit den Methoden bekomme ich auch hin (Definition über public static blabla und Aufruf über DllImport im Hauptprogramm) aber es scheitert an den Konstanten und Enumerations....
Wie definiere ich diese in der Dll und wie rufe ich sie im Hauptprogramm auf?

Vielen Dank schonmal
Lg Oli

Konstanten und Enums müssen über die Projektgrenzen hinaus deklariert werden, d.h. in C++ macht man z.B. einen Header und trägt diese dort ein.
Der Header wird dann zum neuen Projekt hinzugefügt (was die DLL verwendet) und inkludiert. So sind die selbst definierten Datentypen dann im neuen Projekt verwendbar.
Ähnlich sollte das auch in C# ablaufen.
Oder die müssen dann eben im neuen Projekt erneut definiert werden...

Mach Dir doch sowas wie eine defines.cs, wo deine Definitionen drin stehen und nimm dieses dann in die anderen Projekte mit auf.

Also kann man in einer Dll nur Funktionen und Methoden unterbringen?!

So in etwa. In einer DLL befindet sich alles, was ein Compiler in Code oder Daten umwandeln kann. Definitionen eigener Datentypen sind lediglich Vereinbarungen, welche auch nur Projektbezogen existieren!
Diese werden nicht in der DLL abgelegt. Werden allerdings Daten aus diesen Datentypen definiert bzw. erzeugt, sind diese ggf. enthalten, werden aber nicht zwangsläufig auch exportiert.
Damit jemand mit diesen speziellen Datentypen in der DLL was anfangen kann, muss
bei dem nächsten Projekt die alte Vereinbarung "wiederholt" werden, denn der Compiler ist auch kein Hellseher und kann diese Datentypen somit nicht kennen.

Also gilt: Selbstdefinierte Datentypen eines Projekts sind nicht zwangläufig in einem anderen Projekt erneut bekannt. Ist doch auch logisch oder?

Aha, ok, vielen Dank für die Beschreibung

Lg Oli

Nur noch kurz zum Verständnis:

- eigene Datentypen werden in den Projektdateien im Quellcode vereinbart und sind streng genommen nur wärend der Compilezeit "bekannt", der Compiler "vergisst" dann alles wieder
- während das Projekt übersetzt wird, "kennt" der Compiler also auch nur alle Vereinbarungen aller Dateien, die zu diesem Projekt gehören oder auf irgend eine Weise zusätzlich inkludiert bzw. einbezogen werden
- in einem neuen Projekt werden andere Quelldateien kompiliert, sofern da nicht die selben Vereinbarungen greifbar sind, wie sie bei der DLL getroffen wurde, muss der Compiler zu Recht "unknown" ausgeben!

Von daher ist es nützlich, die selbst definierten Datentypen über die Projektgrenzen verfügbar zu machen, sofern die anderswo benötigt werden.
In C++ macht man das über die Header (printf kennt jeder der C mal gesehen hat, der Compiler kennt printf erst, nach dem #include <stdio.h> den Prototypen der Funktion vereinbart), in C# könntest Du eine DLL_Defines.cs erzeugen und dort nur deine Definitionen vornehmen. Diese lädst Du dann in allen Projekten dazu, wo die speziellen Datentypen der DLL bekannt gemacht werden müssen.

Grüßle CF

Danke für den Tipp, das hilft mir sehr weiter
Aber jetzt wird erstmal der schöne Frühlingstag genossen, bevors dann heute Abend weitergeht

Lg Oli

Solange die dll aus managed code (z.B. C#) besteht, ist dllimport nicht nötig. Die dll den References hinzufügen und per using auf die Klassen, Enums, etc. zugreifen.
Alles geht direkt über die jeweiligen namespaces. Falls etwas nur in der dll 'public' sein soll, kann dies als 'internal' deklariert werden. Und die public enums und consts am Besten in einer Klasse (z.B. public class EnumsAndConstants) definieren.

So, ich habe mich dazu entschlossen jetzt alles einfach in eine cs-Datei auszulagern, das erscheint mir persönlich die beste Lösung, da ich dort direkt Zugriff auf meine Dokumentationen zu den Inhalten habe.
Ich habe also eine cs-Datei erstellt mit dem Namen WinMob.cs, sie sieht von der Struktur her folgendermaßen aus:

Code:

using System.blabla;
...

namespace WinMob
{
public class Enumerations
{
public enum aufz1 {Eins = 1, Zwei = 2}
}

public class Konstanten
{
public const int konst1 = 1;
public const int konst2 = 2;
}

public class API_Methoden
{
[DllImport("dll.dll")]
public static extern void ....
}

public class Methoden
{
public void.....
}

}

So, jetzt ist mir etwas aufgefallen, in den Methoden greife ich auch auf eine Methode der Klasse API_Methoden zu, das ging aber erst, als ich static zur Definition hinzugefügt habe, woran liegt das?
Dann habe ich die cs-Datei zu einem neuen Projekt hinzugefügt und using WinMob; eingefügt.
Gebe ich dann im Editor in der Main()-Funktion ein Enumerations. so werden alle Enumerationen aufgelistet, so wie ich es haben möchte. Gebe ich aber z.B. Konstanten. ein, so erscheint diese Liste nicht, genauso läuft es bei Eingabe der anderen Klassennamen....wie bekomme ich es hin, dass bei Eingabe von z.B. API_Methoden. die Liste zur Auswahl der unter der Klasse API_Methoden definierten Methoden erscheint???

Lg Oli

Entweder wird die Klasse als static deklariert -> Konstanten.konst1
Oder so wie jetzt -> Konstanten konstanten = new Konstanten(); konstanten.konst1
Also, falls static kann man direkt aufrufen, sonst muss zuerst eine Instanz der Klasse erstellt werden (new...)
-> die Konstanten nicht in einer Klasse definieren, also direkt nach der Enumeration Klasse definieren.

P.S.:
Grundsätzlich: pro Klasse eine Datei

Habs jetzt hinbekommen
War ein kleiner Denkfehler von mir, vielen Dank