Como criar uma classe do C# usando o objeto CodeModel

Artigo
06/10/2015

A hierarquia de objetos de CodeModel2 tem métodos para gerar código automaticamente. Enquanto você, normalmente, digitaria o código manualmente, há situações onde você pode querer automatizar parte do processo. A automação permite que você:

Impõe convenções de nomenclatura.
Imponha os padrões de documentação.
Crie projetos padronizados.

Este procedimento presume que você saiba como criar um projeto do suplemento. Para obter mais informações, consulte Criando suplementos e assistentes.

A classe no procedimento a seguir será contida em um novo arquivo de origem. Posteriormente, um método é adicionado à classe.

Dica

Seu computador pode mostrar diferentes nomes ou localizações para alguns dos elementos de interface do usuário Visual Studio nas instruções a seguir.A edição do Visual Studio que você possui e as configurações que você usa determinam esses elementos.Para obter mais informações, consulte Personalizando configurações de desenvolvimento no Visual Studio.

Para adicionar um novo arquivo de origem ao projeto

Crie um projeto de suplemento do Visual Studio usando o Visual C#.
No menu Projeto, clique em Adicionar Referência, clique na guia .NET, selecione VSLangProj, VSLangProj2 e VSLangProj80 e clique em OK.

Adicione a seguinte chamada de método ao método 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);
}

Adicione o método de AddAClass diretamente abaixo do método de OnConnection.
```
public void AddAClass(DTE2 dte)
{
}
```
Adicione o seguinte código ao método de AddAClass para adicionar um arquivo de código novo e vazio ao projeto.

O modelo CodeFile é instalado com Visual Studio e pode ser localizado usando o método GetProjectItemTemplate. O método usa dois parâmetros, os modelos de linguagem que você está procurando e o nome do arquivo do item de projeto resultante. O item de projeto é criado usando o método AddFromTemplate.

O código, proj = soln.Projects.Item(1);, necessita que uma solução Visual C# seja aberta no ambiente de desenvolvimento integrado (IDE) Visual Studio antes da execução desse exemplo.
```
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");
```

Para adicionar um namespace ao arquivo de origem

Adicione o seguinte código para adicionar um namespace no arquivo de origem.

A propriedade FileCodeModel contém uma referência ao objeto de FileCodeModel2 que representa todos os elementos de código no arquivo. O objeto de FileCodeModel2 fornece vários métodos para adicionar elementos de código ao arquivo de origem. O método AddNamespace retorna um objeto CodeNamespace. Você usará essa referência de CodeNamespace para adicionar uma definição de classe para o código-fonte.
```
FileCodeModel2 fcm = (FileCodeModel2)pi.FileCodeModel;
CodeNamespace games;
```

Para adicionar a classe ao namespace

Use o método AddClass para adicionar uma classe Chess ao namespace Games . O método AddClass retorna uma referência a uma instância da CodeClass, que você pode usar para adicionar propriedades e métodos à classe.
```
games = fcm.AddNamespace("Games", -1);
CodeClass2 chess;
```

Para definir um método

Use o método AddFunction para adicionar um método Move à classe Chess. O primeiro argumento para o método especifica o nome da função criada. O segundo argumento determina o tipo de função criada, porque os operadores e construtores também são adicionados usando o método AddFunction. O terceiro argumento especifica o tipo de retorno da função e é substituído exatamente na assinatura do método.

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

O arquivo de origem gerado por esses procedimentos é mostrado abaixo.

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

O código do suplemento é mostrado abaixo.

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

Substitua o código na classe OnConnection pelo código de exemplo acima. Para obter informações adicionais sobre como executar este exemplo, consulte Como controlar suplementos usando o Gerenciador de Suplementos.