Gewusst wie: Erstellen einer C#-Klasse mithilfe des CodeModel-Objekts

Artikel
09/02/2008

Aktualisiert: November 2007

Die CodeModel2-Objekthierarchie umfasst einen kompletten Satz von Methoden für die automatische Codegenerierung. Auch wenn Sie Code normalerweise manuell eingeben, kann es Situationen geben, in denen Sie diesen Prozess teilweise automatisieren möchten. Mithilfe der Automatisierung können Sie

Namenskonventionen durchsetzen
Dokumentationsstandards durchsetzen
Standardisierte Projekte erstellen

In dieser Prozedur wird vorausgesetzt, dass Sie über Kenntnisse des Erstellens eines Add-In-Projekts verfügen. Weitere Informationen finden Sie unter Erstellen von Add-Ins und Assistenten.

Die Klasse in der folgenden Prozedur ist in einer neuen Quelldatei enthalten. In einem späteren Schritt wird der Klasse eine Methode hinzugefügt.

Hinweis:
Je nach den aktiven Einstellungen oder der verwendeten Version können sich die angezeigten Dialogfelder und Menübefehle von den in der Hilfe beschriebenen unterscheiden. Bei der Entwicklung dieser Prozeduren war die Option Allgemeine Entwicklungseinstellungen aktiviert. Wählen Sie im Menü Extras die Option Einstellungen importieren und exportieren aus, um die Einstellungen zu ändern. Weitere Informationen finden Sie unter Visual Studio-Einstellungen.

Je nach den aktiven Einstellungen oder der verwendeten Version können sich die angezeigten Dialogfelder und Menübefehle von den in der Hilfe beschriebenen unterscheiden. Bei der Entwicklung dieser Prozeduren war die Option Allgemeine Entwicklungseinstellungen aktiviert. Wählen Sie im Menü Extras die Option Einstellungen importieren und exportieren aus, um die Einstellungen zu ändern. Weitere Informationen finden Sie unter Visual Studio-Einstellungen.

So fügen Sie dem Projekt eine neue Quelldatei hinzu

Erstellen Sie in Visual C# ein Visual Studio-Add-In-Projekt.
Klicken Sie im Menü Projekt auf Verweis hinzufügen, klicken Sie auf die Registerkarte .NET, wählen Sie VSLangProj, VSLangProj2 und VSLangProj80 aus, und klicken Sie dann auf OK.

Fügen Sie der OnConnection-Methode den folgenden Methodenaufruf hinzu.

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);
}

Fügen Sie die AddAClass-Methode direkt unter der OnConnection-Methode hinzu.
```
public void AddAClass(DTE2 dte)
{
}
```
Nehmen Sie folgenden Code in die AddAClass-Methode auf, um dem Projekt eine neue, leere Codedatei hinzuzufügen.

Die CodeFile-Vorlage wird mit Visual Studio installiert und kann mithilfe der GetProjectItemTemplate-Methode gesucht werden. Die Methode verwendet zwei Parameter, die Sprachvorlagen, nach denen Sie suchen, und den Dateinamen für das sich ergebende Projektelement. Das Projektelement wird mithilfe der AddFromTemplate-Methode erstellt.

Für den Code proj = soln.Projects.Item(1); muss in der integrierten Entwicklungsumgebung (Integrated Development Environment, IDE) von Visual Studio eine Visual C#-Projektmappe geöffnet werden, bevor das Beispiel ausgeführt werden kann.
```
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");
```

So fügen Sie der Quelldatei einen Namespace hinzu

Nehmen Sie folgenden Code auf, um der Quelldatei einen Namespace hinzuzufügen.

Die FileCodeModel-Eigenschaft enthält einen Verweis auf das FileCodeModel2-Objekt, das alle Codeelemente in der Datei darstellt. Das FileCodeModel2-Objekt bietet mehrere Methoden, um der Quelldatei Codeelemente hinzuzufügen. Die AddNamespace-Methode gibt ein CodeNamespace-Objekt zurück. Um dem Quellcode eine Klassendefinition hinzuzufügen, verwenden Sie diesen CodeNamespace-Verweis.
```
FileCodeModel2 fcm = (FileCodeModel2)pi.FileCodeModel;
CodeNamespace games;
```

So fügen Sie dem Namespace die Klasse hinzu

Verwenden Sie die AddClass-Methode, um dem Games -Namespace eine Chess -Klasse hinzuzufügen. Die AddClass-Methode gibt einen Verweis auf eine CodeClass-Instanz zurück, über die Sie der Klasse Eigenschaften und Methoden hinzufügen können.
```
games = fcm.AddNamespace("Games", -1);
CodeClass2 chess;
```

So definieren Sie eine Methode

Fügen Sie der Chess-Klasse mithilfe der AddFunction-Methode eine Move-Methode hinzu. Durch das erste Argument für die Methode wird der Name der erstellten Funktion festgelegt. Durch das zweite Argument wird der Typ der erstellten Funktion bestimmt, da auch Operatoren und Konstruktoren mithilfe der AddFunction-Methode hinzugefügt werden. Durch das dritte Argument wird der Rückgabetyp der Funktion festgelegt; es passt genau in die Methodensignatur.

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);
}

Die durch diese Prozeduren erstellte Quelldatei wird im Folgenden aufgeführt:

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

Der Add-In-Code wird nachfolgend dargestellt.

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

Ersetzen Sie den Code in der OnConnection-Klasse durch den oben stehenden Beispielcode. Weitere Informationen zum Ausführen des Beispiels finden Sie unter Gewusst wie: Steuern von Add-Ins mit dem Add-In-Manager.