[C# --> C++] parameters

[Verwijderd]

Tijdje geleden liep ik tegen het feit aan dat het gebruik van COM binnen .NET best wel traag kan zijn, omdat die die dingen heel de tijd moet wrappen enzo... En ik was een utility aan 't schrijven waarbij heel veel bewerkingen op die comobjecten moesten plaatsvinden. Dus ik denk, combinatie managed/unmanaged c++, dat moet ultiem zijn, dus ik een voorbeeld gevonden van een mixed-mode class die die COM objecten gebruikt en als bridge kan funderen tussen C# en C++.
De snelheidswinst is uiteraard enorm, dus nut heeft het wel

http://forums.esri.com/Attachments/9898.zip

Nu het grote probleem... (En ja, ik weet het. Ben nogal een newbie wat betreft Visual C++. Vroeger wel wat C++ gehad, maar das redelijk weggezakt en blablabla...)

Hoe geef ik parameters door van C# naar C++? Ik heb een ProxyClass gemaakt in C++ waarvan ik een instance klus in C# en methodes (void) kan callen. Hoe geef ik bijvoorbeeld een simpele string door? of een int16?

code:

C++
        void Gaan(Int32& number)
        {
        }
C#

            Int32 bla = 0;
            pc.Gaan(ref bla); /* doet het niet :?

Zou iemand mij hier iets zinnigs over kunnen vertellen a.u.b.? Mochten er extreme pro's zijn die nog wat ultieme tips kunnen geven hoe je COM objecten uit C# (bijv IFeature, een arcobjects klasse) kan doorgeven aan C++, dan zou ik dat echt super vinden... In C# zie ik namelijk bij het meegeven van een COM object als parameter "__com_........ " required. Maar misschien moet ik het eerst maar
eenvoudig houden, en het bij een string en int houden .

[.oisyn]

Je moet "[url=Managed Extensions for C++ Specification]Managed Extensions for C++ Secification[/]" in de MSDN eens doorlezen, staan ook een hoop samples in.

Wat deze vraag betreft, waarom eigenlijk een Int32 structure, en niet gewoon een int (in zowel C++ als C#)? En objecten pass je altijd als pointers in managed C++, dus de string wordt dan een System::String *.

[Verwijderd]

Bedankt voor de tips... Het is me nu gelukt om simpele dingen zoals Managed objecten (zowel references als values) door te geven naar C++ en daar iets mee te doen.

code:

public:
void Boeh(System::String ^gaan)
void WriteSome( System::IO::StreamWriter ^mywriter )
void ExcelTest( Microsoft::Office::Interop::Excel::Application ^excelapp )

Nu nog even over COM objecten. Stel, ik maak in C# een nieuwe instantie van Excel aan via COM-interop. Dus een reference klussen met Excel Object Library (even de volledige namespace geklust vanwege ambigious Application gebruik , En dan:

code:

Microsoft.Office.Interop.Excel.Application myApp = 
   new Microsoft.Office.Interop.Excel.Application();
myApp.Visible = true;
mc.ExcelTest( myApp );

Dit gaat dus fout.... Wat ik gedaan heb is in het C++ ook een ref naar het COM-excel-object-lib gemaakt. Ik vermoed dat C++ dan ook een interop klasse gebruikt daarvoor. Dus zoals ik het nu zie probeer ik een gewrapt dotnet object (met com-object daarin) door te sturen van C# naar C++.
Hier loop ik weer klem doordat ik allerlei foutmeldingen krijg als ik in C++ bijv. dit doe:

code:

void ExcelTest( Microsoft::Office::Interop::Excel::Application ^excelapp )
{
    excelapp->Visible = false;
    MessageBox::Show( excelapp->Caption );
}

Het mooiste zou natuurlijk zijn wanneer ik het doorgestuurde object van C# soort van kan unwrappen naar regular COM en dan de speedwinst daarvan te benutten. ... Do I make any sense, of is dit complete wartaal?

[MSalters]

Managed Extensions? Waarom geen C++/CLI gebruiken?

[Verwijderd]

Als ik het goed gebruik is dat alleen available in Whidbey?

http://www.codeproject.com/managedcpp/cppcliintro01.asp

Dan zou het dus makkelijker gaan om COM objecten door te geven?
Is er iemand die hier al iets mee gedaan heeft?

[Verwijderd]

MSalters schreef op woensdag 27 juli 2005 @ 20:23:
Managed Extensions? Waarom geen C++/CLI gebruiken?

Nu ben ik wellicht helemaal abuis, maar de hat operator ( ^ ) om managed references aan te geven is toch een van de kenmerken van C++/CLI?

Ik zie de TS deze gebruiken in :

code:

public:
void Boeh(System::String ^gaan)
void WriteSome( System::IO::StreamWriter ^mywriter )
void ExcelTest( Microsoft::Office::Interop::Excel::Application ^excelapp )

Of is dit weer wat anders?

[Verwijderd]

Helaas ben ik geen C++ pro. Ik gebruik VS2005 beta2, en heb de keuze tusssen ATL en CLR

Use of MFC: Use standard windows libraries
Use of ATL: Not using ATL
CLR support staat aan
Geen program optimization

Heb gelezen dat het makkelijk werd in 2005 om Managed objecten heen en weer te pleuren en dus de ^ te gebruiken, wat wil zeggen een pointer naar dat object neem ik aan. Voorheen was het veel klussen met __gc..... , en dat scheen rottig te werken. Heb er (helaas) geen ervaring mee, wil alleen weten hoe ik een COM object van C# naar C++ krijg. Simpelweg omdat ik het niet kan uitstaan dat het me dat niet lukt. Ik weet dat ik nog veel Visual Studio 8.0 C++ boeken moet doorspitten, maar dat kan helaas niet allemaal direct, dus een simpele uitleg zou veel verhelderen.

[TeeDee]

Ik heb hier een beetje hetzelfde probleem.
Voor Samurize had ik een plugin in c# geschreven. Samurize werkt alleen met C++ plugins. Balen dus.

Vervolgens het e.e.a. opgezocht in de fora daar, en iemand zei dat het het makkelijkste werkt als je je functies e.d. in je c# public static maakt.

[Verwijderd]

TeeDee schreef op vrijdag 29 juli 2005 @ 11:17:
Ik heb hier een beetje hetzelfde probleem.
Voor Samurize had ik een plugin in c# geschreven. Samurize werkt alleen met C++ plugins. Balen dus.

Vervolgens het e.e.a. opgezocht in de fora daar, en iemand zei dat het het makkelijkste werkt als je je functies e.d. in je c# public static maakt.

static methods ken ik uiteraard (in c#), dan hoef je geen instance aan te maken. Het .NET framework zelf wemelt ook van de static methods...

Maar hoe pass ik een COM object van C# naar C++ ? Dat is nog steeds de grote vraag...

[Verwijderd]

C#:

[DllImport("user32.Dll")]
public static extern IntPtr GetFocus();

For een class:

C#:

[ComVisible(true), StructLayout(LayoutKind.Sequential)]
public class RECT{...}

Volgens mij is dit gewoon de beste manier. MS doet dit namelijk zelf ook als ze bijvoorbeeld functies uit de MSHTML lib willen callen. Dit performed volgens mij best goed. Als je geen heftige rekenfuncties hebt(zoals het renderen van een 3d wereld bla bla) in je lib dan moet dit gewoon werken. Ik gebruik functies uit de user32.dll en dat gaat behoorlijk snel.

ff snel een functie gevonden die objecten door passed:

C#:

int ShowUI([In, MarshalAs(UnmanagedType.I4)] int dwID, [In,
            MarshalAs(UnmanagedType.Interface)] IOleInPlaceActiveObject activeObject,
            [In, MarshalAs(UnmanagedType.Interface)] Object /* IOleCommandTarget */
            commandTarget, [In, MarshalAs(UnmanagedType.Interface)] IOleInPlaceFrame
            frame, [In, MarshalAs(UnmanagedType.Interface)] Object doc);

En kan je misschien wat met unsafe code blocks?

[ Voor 27% gewijzigd door Verwijderd op 31-07-2005 14:38 ]