ModuleBuilder.DefinePInvokeMethod scheint eine gute Sache zu sein. Einfache Funktionen aus einer DLL kann ich aufrufen. Aber bei Funktionen mit komplexen Parametern krachts noch:

C++

struct StructA
{
  int iLength;
  const char* pszBuffer;
};

struct StructB
{
  int iCount;
  StructA* pStructA;
};

__declspec(dllexport) const int __stdcall Foo(const StructB& xParams);

    [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct StructA
    {
        public int iLength;
        [MarshalAs(UnmanagedType.LPStr)]
        public String sBuffer;
    };

    [StructLayoutAttribute(LayoutKind.Sequential)]
    public struct StructB
    {
        public int iCount;
        public IntPtr pStructA;
    };

Beim Aufruf der Methode Invoke für die Funktion Foo kommt es zu der Exception:
System.Reflection.TargetInvocationException {"Exception has been thrown by the target of an invocation."}

Ich initalisiere ModuleBuilder.DefinePInvokeMethod wie hier beschrieben:
http://msdn.microsoft.com/en-us/library/628csc41.aspx

Hat einer eine Idee?

@Cat

public class bar
{
    const string dll = "Test.dll";

    [DllImport(dll)]
    public static extern void foo();
}  

const ... und schon gehts 😃 ... aber danke für die Func definition!

mit C++ Templates hat man sehr wohl Typsicherheit. Man kann unter anderem dadurch sogar zur kompilelaufzeit berechnungen durchführen (Expression Template), Template spezialisierungen (partielle template spezialisierung) implementieren bzw. typen vom compiler erzeugen lassen. Bei Generics muss man ein Interface mit where nur angeben um überhaubt auf methoden von dem generic type zugreifen zu können bzw. man hat damit zur Programierzeit schon sicherheit das z.B. keine nicht vorhandene Methode aufgerufen wird. Bei C++ meckert der Compiler so was halt zur Kompilelaufzeit an.

Das sieht schon mal nicht schlecht aus. Allerdings ist Func erst ab .NET 3.5 vorhanden 😦 Die Generics sind ein bisschen schwach finde ich... bin da von C++ verwöhnt 😉

Hi

in C++ kann man mit Templates so was machen:

class A
{
  public:
    static const std::string dll_name;
};

const std::string A::dll_name("Test.dll");

template<typename Type>
class B
{
  public:
    static const std::string name;

    B()
    {
      // mach was
    }

    const std::string GetName() const {return name;}
};

template<typename Type> const std::string B<Type>::name = Type::dll_name;

main()
{
  B<A> xB;

  std::string s = xB.GetName();
  
}

kann man das iwie in C# Generics auch machen? Z.B.:

public class A
{
  public const String DLLName = "Test.dll";
}

public class B<Type>
{
   [DllImport(Type.DLLName)]
   public static extern void foo();
   
   ...
}

mfg
Tobias