Expose une énumération à partir d'un composant COM encapsulé

Question

J'écris une bibliothèque de classes dans .NET qui encapsule une DLL COM et expose des fonctionnalités spécifiques à être consommées par un autre code .NET. La bibliothèque COM a plusieurs énumérations définies et je l'ai utilisé certains types de ENUM en tant que paramètres comme ceci:

//C# 
public void TransactionTypeSetByEnum(COMComponent.TransactionType transType) 
{ 
    this.TransactionType = transType 
} 

'VB.NET' 
Public Sub TransactionTypeSetByEnum(_ 
    ByVal transType As COMComponent.TransactionType) 
    Me.TransactionType = transactionType 
End Sub 

Cependant, quand je vais à consommer ce wrapper .NET à partir d'un autre projet, le compilateur ne peut pas voir les types COM (et je ne veux pas les exposer à la classe consommatrice). Par exemple ...

netWrappedObject.TransactionTypeSetByEnum(//...No intellisense for the enum 

est-il un moyen d'exposer l'énumération non gérée sous-jacente dans ma bibliothèque wrapper .NET sans ajouter une référence DLL non géré le projet qui est responsbile pour consommer cette bibliothèque?

---

informations générales supplémentaires:

Le code a déjà entreprise travaille VB6 qui a été compilé dans un composant COM. L'entreprise ne souhaite pas réécrire ces composants dans le code managé .NET, mais souhaite pouvoir utiliser ce code existant dans une application .NET. Plutôt que de demander à chaque application .NET d'insérer directement le composant COM, mon but est d'écrire un "wrapper" .NET autour du composant COM existant et d'exposer les fonctionnalités nécessaires avec des classes et des interfaces à d'autres applications .NET. Une partie de ma réflexion derrière l'utilisation de la conception de l'interface pour envelopper la DLL COM est la suivante: si l'entreprise décide plus tard qu'il serait préférable de réécrire le DLL COM existant pour être 100% géré. NET code, tout ce que je voudrais faire est d'implémenter l'interface avec le nouveau code et changer les applications existantes pour référencer le nouvel assemblage et éventuellement changer une ligne de code. Cela évite d'avoir à réécrire l'implémentation de la DLL COM pour chaque application .NET.

Dans ma question ci-dessus, mon problème est que le dll COM a plusieurs enum s que je veux être exposé par le composant .NET que « wraps » que DLL. Disons que le COM dll a une classe appelée ComFoo qui a un appel d'énumération ComFooEnum. Je veux la classe NetFoo pour exposer en quelque sorte ComFooEnum lorsque d'autres projets consomment NetFoo. Je ne veux pas que les autres projets soient obligés de faire référence à ComFoo juste pour pouvoir voir le enum exposé par NetFoo. Si je dois imiter ComFooEnum et faire un nouveau NetFooEnum, je suppose que c'est ce que je vais faire, mais je me demande s'il y a une meilleure façon.

est ici un diagramme qui tente d'expliquer l'encapsulation, je suis en train de réaliser:

______________________________ 
|       | 
| Compiled VB6 COM Assembly | 
| Exposes class called  | 
|  ComFoo     | 
|____________________________| 
         || 
_____________________ || 
|     | || 
| Existing VB6  | || 
| Business   | < | 
| Application  | || 
| references ComFoo | 
|___________________| 

//The business is building new applications in .NET 
//that need to consume ComFoo, which cannot be rewritten. 
//NetFoo exposes the functionality of ComFoo. 

____________________________________ 
|         | 
|  .NET Wrapper Assembly  | 
| Exposes class called NetFoo | 
| ______________________________ | 
| |       | | 
| | Compiled VB6 COM Assembly | | 
| | Exposes class called  | | 
| |  ComFoo     | | 
| |____________________________| | 
|__________________________________| 
         || 
_____________________ || 
|     | || 
| New .NET Business | < | 
| Order Entry App | || 
| references NetFoo | || 
|___________________| || 
         || 
_____________________ || 
|     | || 
| New .NET Business | || 
| Internet App  | < | 
| references NetFoo | || 
|___________________| 

Answer 1

Il n'y a pas de magie ici. Tout comme vous enveloppez les types d'interface du composant COM avec des types .NET équivalents, vous devez donc envelopper d'autres déclarations de la bibliothèque de types. Si vous ne voulez pas exposer les types COM enum, vous devez les envelopper. Avec une déclaration de type .NET enum. Le code est simple en utilisant int, mais c'est un élément de maintenance. Tout comme les wrappers de classe .NET. Assurez-vous qu'il existe une valeur ajoutée réelle provenant de l'encapsulation des types COM, un mappage un-à-un est rarement utile.

À moins que ce soit des roues d'entraînement pour un remplacement éventuel du serveur COM. Ce qui est ok, ça vous donne une bonne idée de ce dont vous avez besoin. Dans ce cas, vous voulez vraiment déclarer l'enum.