Procedura: creare una classe C# utilizzando l'oggetto CodeModel

Articolo
09/12/2008

Aggiornamento: novembre 2007

La gerarchia di oggetti CodeModel2 dispone di una serie completa di metodi per generare codice in maniera automatica. Anche se solitamente il codice viene digitato manualmente, ci sono casi in cui è preferibile automatizzare una parte del processo. L'automazione consente di eseguire le operazioni riportate di seguito.

Attivare le convenzioni di denominazione.
Attivare gli standard della documentazione.
Creare progetti standardizzati.

In questa routine si presuppone che si conosca la procedura di creazione di un progetto aggiuntivo. Per ulteriori informazioni, vedere Creazione di componenti aggiuntivi e di procedure guidate.

La classe nella procedura riportata di seguito sarà contenuta in un nuovo file di origine. In seguito verrà aggiunto un metodo alla classe.

Nota:
È possibile che le finestre di dialogo e i comandi di menu visualizzati siano diversi rispetto a quelli descritti nella Guida in linea a seconda delle impostazioni attive o dell'edizione del programma. Queste routine sono state sviluppate con le Impostazioni generali per lo sviluppo attive. Per modificare le impostazioni, scegliere Importa/Esporta impostazioni dal menu Strumenti. Per ulteriori informazioni, vedere Impostazioni di Visual Studio.

È possibile che le finestre di dialogo e i comandi di menu visualizzati siano diversi rispetto a quelli descritti nella Guida in linea a seconda delle impostazioni attive o dell'edizione del programma. Queste routine sono state sviluppate con le Impostazioni generali per lo sviluppo attive. Per modificare le impostazioni, scegliere Importa/Esporta impostazioni dal menu Strumenti. Per ulteriori informazioni, vedere Impostazioni di Visual Studio.

Per aggiungere un nuovo file di origine al progetto

Creare un progetto di componente aggiuntivo Visual Studio utilizzando Visual C#.
Scegliere Aggiungi riferimento dal menu Progetto, selezionare la scheda .NET e quindi VSLangProj, VSLangProj2 SLangProj80 e infine scegliere OK.

Aggiungere la chiamata riportata di seguito al metodo 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);
}

Aggiungere il metodo AddAClass direttamente sotto il metodo OnConnection.
```
public void AddAClass(DTE2 dte)
{
}
```
Aggiungere il codice riportato di seguito al metodo AddAClass per aggiungere un nuovo file di codice vuoto al progetto.

Il modello CodeFile viene installato con Visual Studio e può essere individuato mediante il metodo GetProjectItemTemplate. Il metodo utilizza due parametri, i modelli del linguaggio oggetto della ricerca e il nome di file dell'elemento di progetto risultante. L'elemento di progetto viene creato tramite il metodo AddFromTemplate.

Per poter eseguire questo esempio, il codice proj = soln.Projects.Item(1); richiede l’apertura di una soluzione Visual C# nell'ambiente di sviluppo integrato (IDE, Integrated Development Environment) Visual Studio.
```
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");
```

Per aggiungere uno spazio dei nomi al file di origine

Utilizzare il codice di seguito riportato per aggiungere uno spazio dei nomi al file di origine.

Nella proprietà FileCodeModel è contenuto un riferimento all'oggetto FileCodeModel2 che rappresenta tutti gli elementi di codice presenti nel file. L'oggetto FileCodeModel2 dispone di diversi metodi per l'aggiunta di elementi di codice al file di origine. Il metodo AddNamespace restituisce un oggetto CodeNamespace. Sarà possibile utilizzare questo riferimento a CodeNamespace per aggiungere una definizione di classe al codice sorgente.
```
FileCodeModel2 fcm = (FileCodeModel2)pi.FileCodeModel;
CodeNamespace games;
```

Per aggiungere la classe allo spazio dei nomi

Utilizzare il metodo AddClass per aggiungere una classe Chess allo spazio dei nomi Games . Il metodo AddClass restituisce un riferimento a un'istanza CodeClass che consente di aggiungere proprietà e metodi alla classe.
```
games = fcm.AddNamespace("Games", -1);
CodeClass2 chess;
```

Per definire un metodo

Utilizzare il metodo AddFunction per aggiungere un metodo Move alla classe Chess. Nel primo argomento relativo al metodo è specificato il nome della funzione creata. Nel secondo argomento viene determinato il tipo di funzione creata, poiché anche gli operatori e i costruttori vengono aggiunti mediante il metodo AddFunction. Nel terzo argomento viene specificato il tipo restituito dalla funzione. Questo argomento viene sostituito esattamente nella firma del metodo.

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

Di seguito è riportato il file di origine generato da queste procedure.

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

Di seguito è illustrato il codice aggiuntivo.

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

Sostituire il codice nella classe OnConnection con quello dell'esempio precedente. Per ulteriori informazioni sulla modalità di esecuzione di questo esempio, vedere Procedura: controllare i componenti aggiuntivi con Gestione componenti aggiuntivi.