Ma demande n'est pas gérée. Où dois-je commencer à introduire du code géré?

Question

Toute mon application (qui est assez grande, avec un exécutable de 20 Mo) est écrite en C ++ non gérée. Parce que je peux clairement voir les avantages de l'utilisation du code géré, je veux commencer à introduire du code géré dans mon application, mais par où commencer?

Puis-je facilement commencer à utiliser C ++ / CLI et le relier au reste de mon application? (bien que la syntaxe C ++ / CLI semble plutôt «exotique»).

Ou est-il préférable de passer à C #, mais quelle est la meilleure façon de le «lier» avec mon code C ++ non géré?

Est-il logique de compiler tout mon code C ++ avec l'option / CLR? Est-ce que ça va marcher?

Dois-je m'inquiéter du maréchalage? Est-ce que cela donne une surcharge ou puis-je basculer entre géré et non géré sans pénalité de performance (comme je l'ai fait il y a 20 ans lors du mélange de Fortran et C). Les performances sont vraiment importantes dans mon application car il s'agit d'une application scientifique qui traite parfois plusieurs gigaoctets de mémoire.

Ou est-il logique de repenser l'interface utilisateur et d'écrire cela en C #, et de garder le reste de mon application (logique de calcul, logique métier, interface de base de données, ...) en C ++ non géré?

Étant donné que mon application doit parfois gérer plusieurs gigaoctets de mémoire, j'ai une variante 64 bits. Est-il facile d'avoir du code géré 64 bits? Woudl le collecteur des ordures est toujours efficace si beaucoup de mémoire est utilisée?

Indiquez simplement: par où commencer?

Patrick

Answer 1

Pour le moment, considérez cette question fermée.

J'ai réalisé que la réponse ne mélange pas C ++ et C #, mais obtenant l'architecture juste en premier lieu.

Si l'architecture est correcte et séparée où elle doit être séparée, la modification des parties de l'application par d'autres modules (externe, autre langue, ...) devrait être plus facile.

En ce qui concerne les problèmes de performance pendant le maréchalage, nous devrons attendre que .NET se soit encore mûri.

Answer 2

Profitez l'application, décidez de quels points d'intégration vous pouvez éliminer la ligne de logique C # et pénétrer en C ++ et vice versa. Disposez-les dans un plan pour que un motif de conception de façade se déplace dans le système en remplaçant progressivement C ++ par C #. Le CPU et le coût de la mémoire sont d'une préoccupation clé lors de la décision de changer de langue à chaque façade / interface candidate.

Vous voudrez pouvoir incorporer les modifications afin que vous soyez peut-être mieux avec un ensemble de codes source et un référentiel de code source pour le code C ++ d'origine et un autre ensemble et un référentiel pour la façade plus le C #.

Ensuite, à mesure que les travaux d'améliorations / de maintenance se présentent dans le trame dans le trajet, vous l'appliquez aux deux bases de code, et vous essayez de vous assurer que la façade se déplace dans le système en commençant par le code moins susceptible de changer les améliorations ou la maintenance pour minimiser le doublement des changements .

Idéalement, structurez également votre travail afin que vous puissiez faire reculer la façade pour revenir à 100% C ++ à la goutte d'un chapeau si vous frappez un accroc.

Pour tester si quelques modules C ++ particulièrement impénétrables peuvent être séparés en une pièce C ++ et une pièce C #, exécutez-les dans deux processus Win32 C ++ différents communiquant à l'aide d'un tuyau ou d'une prise. De cette façon, vous aurez une meilleure idée de savoir s'il y a des problèmes de gestion de la mémoire ou de performances qui doivent être réparés avant de pouvoir diviser la chaîne d'appels à ce stade.

Answer 3

Nous faisons exactement ce que vous avez décrit dans une application critique de mission qui est utilisée par des milliers d'utilisateurs. Fondamentalement, nous avons gardé l'application existante tel quel, donc l'exécutable est toujours un exécutable 100% non géré (pas C ++ / CLI). Nous mettons ensuite tout notre nouveau code C # dans .NET DLLS qui se compose d'objets commerciaux, de contrôles des utilisateurs et de code d'interface graphique, etc.

Fondamentalement, tout nouveau code est écrit en C #. Nous avons 1 DLL qui est C ++ / CLI qui n'est que de la colle. Cela nous permet de nous interopérer facilement entre le code géré et non géré, sans avoir à faire le code C ++ existant CLR. Cela limite la quantité de code C ++ / CLI que nous devons écrire. Le code natif parle au code de mode mixte, qui peut parler au code géré. La DLL en mode mixte peut accrocher les événements sur les classes C # afin que le code C # puisse simplement tirer l'événement pour communiquer au C ++ / CLI (qui peut parler au code natif).

Nous pouvons également héberger .NET UserControls dans une application C ++ existante (WinForms est juste un wrapper autour du WinAPI de toute façon, donc cela fonctionne assez bien).

Cela fonctionne très bien et vous permet de conserver votre code existant sans avoir à réécrire toute l'interface graphique en C #.