Discussion :

[Pjosse]

Bonjour,

J'ai une petite question sur la manière de faire les choses.

En espérant ne pas me tromper de section mais étant donnée que je souhaite travailler en C++/C# je pense être au bonne endroit.


Voici donc l'exposé de ma question:


Je cherche à réaliser un "petit" projet qui comprend un jeu simple (C++) et un outil (C#) qui permettrait d'éditer ce jeu (niveau, son, ...) avec pour but de toucher un peu à l'inter-op entre C++ et C#.


Dans un soucis de maintenance, je cherchais la meilleur manière d'aborder le projet et je suis arriver à cette ébauche d'architecture:

C++ DLL:
Le moteur (graphique/son) et le gameplay.

C++ exe:
Le jeu en lui même avec utilisation des DLL.

C#:
L'outil avec utilisation des DLL.


Que pensez-vous de cela? Est-ce réalisable? Pratique ? Voyez-vous une meilleur manière d'aborder le projet ?

Merci pour vos réponse!

[Dr Dédé]

Je travaille sur un projet très similaire. Ce n'est pas moi qui ai écrit le moteur donc il est dans une librairie séparée. Le tout est contrôlable par un exécutable C# à l'aide de P/Invoke. Le marshalling de C# à C++ et vice-versa est délicat et coûteux en termes de performances, alors il vaut mieux tout écrire dans le même langage, mais pour des motifs pédagogiques (ce qui est mon cas aussi) c'est intéressant en effet.

Si tu as des questions il y a des chances que je puisse t'aider parce que c'est encore très frais dans ma mémoire (j'ai abstrait toute la communication inter-langage dans une classe alors je n'y touche plus, mais ce fut assez long de faire cette classe ).

[Pjosse]

Bonjour et merci,

(j'ai abstrait toute la communication inter-langage dans une classe alors je n'y touche plus, mais ce fut assez long de faire cette classe ).

Tu parles d'une classe en C# qui récupérerait les méthodes requises?
du type:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Marshal.cs
using System;
using System.Runtime.InteropServices;
 
class PlatformInvokeTest
{
    [DllImport("msvcrt.dll")]
    public static extern int puts(
        [MarshalAs(UnmanagedType.LPStr)]
        string m);
    [DllImport("msvcrt.dll")]
    internal static extern int _flushall();
 
 
    public static void Main() 
    {
        puts("Hello World!");
        _flushall();
    }
}

(Merci MSDN)

Merci en tout cas de ta proposition je garderais ca en tête en cas de futur pépin .

[Dr Dédé]

J'ai effectivement une classe avec uniquement les méthodes P/Invoke (public static extern). Mais je ne m'en sers pas directement. En gros, j'ai un buffer d'évènements C#, et je le passe périodiquement au C++, qui désérialise les objets et qui peut ainsi savoir ce que le C# lui a envoyé. Cela marche dans l'autre sens aussi, donc la communication est bi-directionelle (ce qui est impossible avec de simples appels de méthodes puisqu'on ne peut pas appeler du C# depuis C++).

Cela a aussi l'avantage de minimiser le nombre d'appels entre C# et C++ car il y a un gros overhead relié à P/Invoke. Microsoft recommande de faire moins d'appels en passant plus de données à la fois et c'est exactement ça le principe ici.

[bacelar]

donc la communication est bi-directionelle (ce qui est impossible avec de simples appels de méthodes puisqu'on ne peut pas appeler du C# depuis C++).

CCW
http://msdn.microsoft.com/en-us/library/f07c8z1c.aspx

[Dr Dédé]

À moins d'utiliser COM bien entendu. Quand j'ai vu le nombre d'étapes que ça représentait j'ai assez rapidement mis ça de côté, mais c'est peut-être une solution intéressante, qu'en penses-tu?

[Pjosse]

D'accord je pense avoir compris ta manière de faire Dr Dédé et merci bacelar je ne connaissais pas du tout la méthodes je vais jeter un œil dessus.

[el_socio]

Quelque chose qui pourrait etre utile: P/Invoke Interop Assistant
http://blogs.msdn.com/b/bclteam/arch...an-patten.aspx

C'est un outil developpe par microsoft qui (si j'ai bien compris) genere automatiquement le wrapper a partir d'un code natif en c++

[Pjosse]

Merci bien !

[Médinoc]

Si tu n'utilises pas COM, il reste quand même une solution: pour utiliser du C++ "de base" depuis C#, tu peux te faire une couche de compatibilité en C++/CLI (en gros, écrire des classes managées qui sont des wrappers des classes non-managées).

Je résume donc les deux options:

1. Avec COM:
   
   • DLL C++ COM
   • Exe C++ du jeu
   • Éditeur C#
2. Sans COM:
   
   • DLL C++ normale
   • DLL de compatibilité en C++/CLI
   • Exe C++ du jeu
   • Éditeur C#

[Pjosse]

Bien pensé de résumer la chose!

J'espère que le topic sera utile à d'autre en tout cas.