CLR-Klasse in nicht CLR Klasse hinzufügen

Hey Leutz,

kann mir bitte einer ein Beispiel schreiben wie ich eine CLR-Klasse in eine nicht CLR-Klasse hinzufüge.
Das Projekt soll hierbei ein CLR Projekt sein.

Also mein Ansatz war:

class oberklasse
{
public:
    __gc public class
    {
        public:
            string^ g;
    }
}

Klappt aber nicht. Da ich für __gc den Schalter /clr:oldSyntax benötige.
Wenn ich den Schalter hinzufüge klappt dann der rest mit string^ nicht usw.

Hab VS 2005 Express u. XP SP2.

Jochen Kalmbach

Das geht nur über Pointer!
Und verschachtelt gleich gar nicht...
Also:

class Unmanaged;
{
};

__gc public class Managed
{
  Unmanaged *pUnmanaged;
};

Ich versuch das mal.

Ich hab das jetzt Probiert funkt. aber nicht.

__gc public class Managed
{
public:
    Managed()
    {
         z = 5;
    }    
    int z;
};

class Unmanaged
{
public:
    Unmanaged()
    {
        pManaged = new Managed();
    }
    Managed* pManaged;
};

int main()
{

    return 0;
}

Fehlermeldung:
Ein verwalteter 'pManaged' kann nicht in einem nicht verwalteten 'Unmanaged' deklariert werden Zeile 19

Dein beispiel war ja anders herum, was ich eigentlich wollte ist Unmanaged in Managed.

Meine eigentliches Ziel ist es, eine Managed Klasse in ein CLR-Projekt global zu erstellen, egal wie. Ob wir mit mehreren Projekten arbeiten oder nicht, ist uns überlassen. Ich bin schon am verzweifeln. Ich brauch dringend bitte eure Unterstützung.

Helium

In C++/CLI-Syntax:

#include <vcclr.h>

ref class Foo {

};

class Bar {
   gcroot<Foo^> foo;
};

hmm, sieht gut aus, aber so gut bin ich nicht das ich das alles verstehe
bis du so nett, mir das Zeile für Zeile zu erklären
Bitte

Helium

#include <vcclr.h>      // bindet den Header vcclr.h ein
                        // ist eine Leerzeile ohne Effekt
ref class Foo {         // entspricht dem Alten "__gc class Foo"
                        // eine weitere Leerzeile, die andeuten soll, dass hier im Regelfall noch irgendetwas definiert wird
};                      // .. keinen Bock mehr auf jede Zeile einzugehen

class Bar {
   gcroot<Foo^> foo;    // Entspricht dem alten "gcroot<Foo __gc *> foo;"
};

gcroot Brauchst du hier um managed Typen in unmanaged Typen unterzubringen. Dabei handelt es sich um ein Template, dass in <vcclr.h> definiert ist. Wie es intern funktioniert muss dich gar nicht interessieren, sondern nur, wie du es verwendest.

Du kannst mit der ganz normalen "->" Syntax arbeiten.

#include <vcclr.h>

ref class Foo {
public:
   void methode ()
   {
      Console::WriteLine(L"Blabla");
   }
};

class Bar {
public:
   void baz ()
   {
      foo->methode();   // <- so sieht die Verwendung aus
   }

private:
   gcroot<Foo^> foo;
};

Jetzt noch ein kleinwenig selber rumexperimentieren oder ein wenig googlen und du solltest es verstanden haben.

Vielen vielen dank aber auch.
Das ist genau das was ich gesucht habe. Dieses "ref" ist der Ersatz für "__gc", hab ich echt nicht gewusst. Also nochmals Danke.
Eine Frage noch.
Bei deiner Verwendung:

void baz ()
   {
      foo->methode();   // <- so sieht die Verwendung aus
   }

Muss man nicht erstmal ein Objekt von foo haben, also mit "new" erstellen oder reicht das aus wenn man nicht dynamisches Obejtk macht?

Helium

Oh, ja klar, musst du erst erzeugen:

class Bar {
public:
   Bar ()
   {
      foo = gcnew Foo();  // <- Erzeugung
   }

   void baz ()
   {
      foo->methode();
   }

private:
   gcroot<Foo^> foo;
};

Ich glaube bei mir funktioniert das jetzt. Da war echt ne tolle Hilfe. Ich hab zu Danken. Vielen vielen Dank.