Comment : créer une classe C# à l'aide de l'objet CodeModel

Article
06/10/2015

La hiérarchie des objets CodeModel2 possède des méthodes pour la génération automatique de code. Même si vous avez l'habitude de taper le code manuellement, il peut être utile dans certaines situations d'automatiser une partie du processus. L'automatisation vous permet :

d'appliquer les conventions d'affectation de noms ;
d'appliquer les normes de documentation ;
de créer des projets normalisés.

Cette procédure suppose que vous savez comment créer un projet Complément. Pour plus d'informations, consultez Création de compléments et d'Assistants.

La classe de la procédure suivante se trouvera dans un nouveau fichier source. Ultérieurement, une méthode est ajoutée à la classe.

Notes

Il est possible que pour certains des éléments de l'interface utilisateur de Visual Studio, votre ordinateur affiche des noms ou des emplacements différents de ceux indiqués dans les instructions suivantes.Ces éléments dépendent de l'édition de Visual Studio dont vous disposez et des paramètres que vous utilisez.Pour plus d'informations, consultez Paramètres Visual Studio.

Pour ajouter un fichier source au projet

Créez un projet de complément Visual Studio en utilisant Visual C#.
Dans le menu Projet, cliquez sur Ajouter une référence, cliquez sur l'onglet .NET, puis sélectionnez VSLangProj, VSLangProj2 et VSLangProj80. Cliquez ensuite sur OK.

Ajoutez l'appel de méthode suivant à la méthode OnConnection.

public void OnConnection(object application, 
ext_ConnectMode connectMode, object addInInst, ref Array custom)
{
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;
    // Call the AddClass method.
    AddAClass(_applicationObject);
}

Ajoutez la méthode AddAClass directement sous la méthode OnConnection.
```
public void AddAClass(DTE2 dte)
{
}
```
Ajoutez le code suivant à la méthode AddAClass pour ajouter un fichier code vide au projet.

Le modèle CodeFile est installé avec Visual Studio et peut être localisé en utilisant la méthode GetProjectItemTemplate. La méthode accepte deux paramètres ; les modèles de langage que vous recherchez et le nom de fichier pour l'élément de projet résultant. L'élément de projet est créé en utilisant la méthode AddFromTemplate.

Le code, proj = soln.Projects.Item(1);, nécessite qu'une solution Visual C# soit ouverte dans l'environnement de développement intégré (IDE) de Visual Studio avant l'exécution de cet exemple.
```
Project proj;
String csItemTemplatePath;
Solution2 soln;
soln = (Solution2)_applicationObject.Solution;
// Open a C# solution in the Visual Studio IDE
// before running this add-in.
proj = soln.Projects.Item(1);
ProjectItem pi;
csItemTemplatePath = soln.GetProjectItemTemplate("CodeFile",
 "CSharp");
proj.ProjectItems.AddFromTemplate(csItemTemplatePath, "MyFile.cs");
pi = proj.ProjectItems.Item("MyFile.cs");
```

Pour ajouter un espace de noms au fichier source

Ajoutez le code suivant pour ajouter un espace de noms au fichier source.

La propriété FileCodeModel contient une référence à l'objet FileCodeModel2 qui représente tous les éléments de code présents dans le fichier. L'objet FileCodeModel2 fournit plusieurs méthodes permettant d'ajouter des éléments de code au fichier source. La méthode AddNamespace retourne un objet CodeNamespace. Vous utiliserez cette référence CodeNamespace pour ajouter une définition de classe au code source.
```
FileCodeModel2 fcm = (FileCodeModel2)pi.FileCodeModel;
CodeNamespace games;
```

Pour ajouter une classe à l'espace de noms

Utilisez la méthode AddClass pour ajouter une classe Chess à l'espace de noms Games . La méthode AddClass retourne une référence à une instance CodeClass, que vous pouvez utiliser pour ajouter des propriétés et des méthodes à la classe.
```
games = fcm.AddNamespace("Games", -1);
CodeClass2 chess;
```

Pour définir une méthode

Utilisez la méthode AddFunction pour ajouter une méthode Move à la classe Chess. Le premier argument de la méthode spécifie le nom de la fonction créée. Le deuxième argument détermine le type de la fonction créée, car les opérateurs et les constructeurs sont également ajoutés à l'aide de la méthode AddFunction. Le troisième argument spécifie le type de retour de la fonction et est exactement remplacé dans la signature de la méthode.

if (games != null)
{
    // Add a class to the namespace.
    chess = (CodeClass2)games.AddClass("Chess", -1, null, null,
 vsCMAccess.vsCMAccessDefault);
    // Add a method with a parameter to the class.
    CodeFunction2 move;
    move = (CodeFunction2)chess.AddFunction("Move",
 vsCMFunction.vsCMFunctionFunction,
 "int", -1, vsCMAccess.vsCMAccessDefault, null);
    move.AddParameter("IsOK", "bool", -1);
}

Voici le fichier source obtenu à l'aide de ces procédures.

namespace Games
{
    class Chess
    {
        int Move(bool IsOK)
        {
            return default(int);
        }
    }
}

Le code du complément est présenté ci-dessous.

public void OnConnection(object application, ext_ConnectMode connectMode, 
object addInInst, ref Array custom)
{
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;
    // Call the AddClass method.
    AddAClass(_applicationObject);
}
public void AddAClass(DTE2 dte)
{
    Project proj;
    String csItemTemplatePath;
    Solution2 soln;
    soln = (Solution2)_applicationObject.Solution;
    // Open a C# solution in the Visual Studio IDE
    // before running this add-in.
    proj = soln.Projects.Item(1);
    ProjectItem pi;
    csItemTemplatePath = soln.GetProjectItemTemplate("CodeFile", "CSharp");
    proj.ProjectItems.AddFromTemplate(csItemTemplatePath, "MyFile.cs");
    pi = proj.ProjectItems.Item("MyFile.cs");
    FileCodeModel2 fcm = (FileCodeModel2)pi.FileCodeModel;
    CodeNamespace games;
    try
    {
        // Add a namespace.
        games = fcm.AddNamespace("Games", -1);
        CodeClass2 chess;
        if (games != null)
        {
            // Add a class to the namespace.
            chess = (CodeClass2)games.AddClass("Chess", -1, null, null, 
vsCMAccess.vsCMAccessDefault);
            // Add a method with a parameter to the class.
            CodeFunction2 move;
            move = (CodeFunction2)chess.AddFunction("Move", 
vsCMFunction.vsCMFunctionFunction, "int", -1,
 vsCMAccess.vsCMAccessDefault, null);
            move.AddParameter("IsOK", "bool", -1);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show("Failed to add a code model element, because " 
+ ex.Message);
    }
}

Public Sub OnConnection(ByVal application As Object, _
 ByVal connectMode As ext_ConnectMode, ByVal addInInst As Object, _
 ByRef custom As Array) Implements IDTExtensibility2.OnConnection
    _applicationObject = CType(application, DTE2)
    _addInInstance = CType(addInInst, AddIn)
    AddAClass(_applicationObject)
End Sub

Public Sub AddAClass(ByVal dte As DTE2)
    Dim proj As Project
    Dim csItemTemplatePath As String
    Dim soln As Solution2
    soln = CType(_applicationObject.Solution, Solution2)
    ' Open a C# solution in the Visual Studio IDE before
    ' running this add-in.
    proj = soln.Projects.Item(1)

    Dim pi As ProjectItem
    csItemTemplatePath = soln.GetProjectItemTemplate("CodeFile", "CSharp")
    proj.ProjectItems.AddFromTemplate(csItemTemplatePath, "MyFile34.cs")
    pi = proj.ProjectItems.Item("MyFile34.cs")
    Dim fcm As FileCodeModel2 = CType(pi.FileCodeModel, FileCodeModel2)
    Dim games As CodeNamespace
    Try
        ' Add a namespace.
        games = fcm.AddNamespace("Games")
        Dim chess As CodeClass2
        If Not games Is Nothing Then
            ' Add a class to the namespace.
            chess = CType(games.AddClass("Chess"), CodeClass2)
            ' Add a method with a parameter to the class.
            Dim move As CodeFunction2
            move = CType(chess.AddFunction("Move", vsCMFunction.vsCMFunctionFunction, _
            "int"), CodeFunction2)
            move.AddParameter("IsOK", "bool")
        End If
    Catch e As Exception
        MsgBox("Failed to add a code model element, because " & _
        e.ToString())
    End Try
End Sub

Remplacez le code de la classe OnConnection par l'exemple de code ci-dessous. Pour plus d'informations sur l'exécution de cet exemple, consultez Comment : contrôler des compléments avec le Gestionnaire de compléments.