Gewusst wie: Zugreifen auf Konfigurationseigenschaften bestimmter Projekttypen
Aktualisiert: November 2007
Das allgemeine Automatisierungsmodell von Visual Studio enthält die Properties-Auflistung, mit der der Zugriff auf die Properties-Auflistungen eines beliebigen Visual Studio-Projekttyps möglich ist. Projekteigenschaften ermöglichen Ihnen u. a. das Steuern von Sicherheitseinstellungen, der Buildkonfiguration und der Debugkonfiguration.
Um Projekteigenschaften manuell festzulegen und zu untersuchen, öffnen Sie in der integrierten Entwicklungsumgebung (Integrated Development Environment, IDE) von Visual Studio ein Projekt. Klicken Sie im Menü Projekt auf Eigenschaften. Das Dialogfeld Eigenschaften enthält mehrere Registerkarten, und in den einzelnen Bereichen werden die Eigenschaften aufgeführt, mit denen das Verhalten von Projekten definiert und gesteuert wird. Das Automatisierungsmodell ermöglicht Ihnen die Steuerung dieser Einstellungen über das Programm. Insbesondere können Sie mithilfe der in CSharpProjectConfigurationProperties4, VBProjectConfigurationProperties4, JSharpProjectConfigurationProperties3 und ProjectConfigurationProperties3 aufgeführten Eigenschaften die Projekteigenschaften steuern, die sich auf der Eigenschaftenseite der aktiven Konfiguration in den Fensterbereichen Erstellen (Kompilieren bei Visual Basic-Projekten) und Debuggen befinden.
Sie können auch eine andere, nicht aktive Konfiguration auswählen, indem Sie auf das ConfigurationManager-Objekt zuzugreifen. Weitere Informationen finden Sie unter Gewusst wie: Erstellen der Buildkonfigurationen von Projektmappen und Projekten.
Konfigurationseigenschaften für Visual C#- und Visual J#-Projekte werden in CSharpProjectConfigurationProperties4 bzw. JSharpProjectConfigurationProperties3 definiert. Die Eigenschaften CodePage, DisableLangXtns, JCPA und SecureScoping sind nur für Visual J#-Projekte spezifisch. Die ErrorReport-Eigenschaft und die LanguageVersion-Eigenschaft sind nur für Visual C#-Projekte spezifisch. Bei den verbleibenden Eigenschaften in CSharpProjectConfigurationProperties3 und JSharpProjectConfigurationProperties3 handelt es sich um die gleichen Eigenschaften wie in ProjectConfigurationProperties3.
Auf diese Konfigurationseigenschaften kann nicht direkt durch das Umwandeln eines Property-Objekts in ein CSharpProjectConfigurationProperties3-Objekt, ein JSharpProjectConfigurationProperties3-Objekt oder ein ProjectConfigurationProperties3-Objekt zugegriffen werden. Stattdessen erfolgt der Zugriff auf diese Eigenschaften durch Übergeben des Namens des Konfigurationselements als Zeichenfolge, wie nachfolgend dargestellt:
EnvDTE.Project proj;
EnvDTE.Configuration config;
EnvDTE.Properties configProps;
EnvDTE.Property prop;
proj = DTE.Solution.Projects.Item(1);
config = proj.ConfigurationManager.ActiveConfiguration;
configProps = config.Properties;
prop = configProps.Item("EnableSQLServerDebugging")
Abhängig davon, ob die proj-Variable ein Visual C#-, Visual J#- oder Visual Basic-Projekt definiert, greift dieser Code entweder auf die Eigenschaft CSharpProjectConfigurationProperties3.EnableSQLServerDebugging, JSharpProjectConfigurationProperties3.EnableSQLServerDebugging oder ProjectConfigurationProperties3.EnableSQLServerDebugging zu.
Faktisch sind die in CSharpProjectConfigurationProperties3, JSharpProjectConfigurationProperties3 oder ProjectConfigurationProperties3 definierten Konfigurationseigenschaften eine Verweisliste verfügbarer Konfigurationseigenschaften bestimmter Projekte, auf die über die Properties-Auflistung als Eigenschaftenelemente für die Projektkonfiguration zugegriffen werden kann.
In den nachfolgenden Schritten wird ausführlich der programmgesteuerte Zugriff auf die Konfigurationseigenschaften der aktuellen Konfiguration in einem Visual Studio-Add-In erläutert.
.gif "Hinweis") 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. |
So greifen Sie auf die Konfigurationseigenschaften für einen bestimmten Projekttyp zu
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 System.Windows.Forms, VSLangProj, VSLangProj2 und VSLangProj80 aus, und klicken Sie auf OK.
Fügen Sie am Anfang der Datei Connect.cs die folgenden using-Anweisungen ein.
using VSLangProj; using VSLangProj2; using VSLangProj80; using VSLangProj90; using System.Windows.Forms;Fügen Sie der OnConnection-Funktion den folgenden Funktionsaufruf hinzu.
_applicationObject = (DTE2)application; _addInInstance = (AddIn)addInInst; VSProjectConfigProperties(_applicationObject);Fügen Sie die VSProjectConfigProperties-Methode direkt unterhalb der OnConnection-Methode hinzu.
public void VSProjectConfigProperties(DTE2 dte) { try { // Open a Visual C#, Visual J#, or Visual Basic project // before running this add-in. Project project; Configuration config; Properties configProps; Property prop; project = _applicationObject.Solution.Projects.Item(1); config = project.ConfigurationManager.ActiveConfiguration; configProps = config.Properties; prop = configProps.Item("PlatformTarget"); MessageBox.Show("The platform target for this project is: " + prop.Value.ToString()); prop = configProps.Item("WarningLevel"); MessageBox.Show ("The warning level for this project is set to: " + prop.Value.ToString()); MessageBox.Show("Changing the warning level to 3..."); prop.Value = "3"; MessageBox.Show ("The warning level for this project is now set to: " + prop.Value.ToString()); if (project.Kind == PrjKind.prjKindCSharpProject) { MessageBox.Show("The project is a Visual C# Project"); prop = configProps.Item("LanguageVersion"); MessageBox.Show("The language version value is : " + prop.Value.ToString()); MessageBox.Show("Setting the language version to ISO-1"); prop.Value = "ISO-1"; MessageBox.Show("The language version value is now: " + prop.Value.ToString()); } if (project.Kind == PrjKind2.prjKindVJSharpProject) { MessageBox.Show("The project is a Visual J# Project"); prop = configProps.Item("CodePage"); MessageBox.Show("The code page value is : " + prop.Value.ToString()); MessageBox.Show ("Setting the code page value to my code page"); prop.Value = "my code page"; MessageBox.Show("The code page value is now: " + prop.Value.ToString()); } } catch(Exception ex) { MessageBox.Show(ex.Message); } }Die VSProjectConfigProperties-Methode ruft den PlatformTarget-Eigenschaftenwert ab und zeigt diesen an. Sie legt die WarningLevel-Eigenschaft fest und ruft sie ab. Wenn es sich bei dem Projekt um ein Visual C#-Projekt handelt, legt die VSProjectConfigProperties-Methode die LanguageVersion-Eigenschaft fest und ruft diese ab. Wenn es sich um ein Visual J#-Projekt handelt, legt die Methode die CodePage-Eigenschaft fest und ruft diese ab.
Erstellen Sie das Add-In, indem Sie im Menü Erstellen auf Projektmappe erstellen klicken.
Öffnen Sie in der IDE von Visual Studio ein Visual C#-, Visual J#- oder Visual Basic-Projekt.
Klicken Sie im Menü Extras auf Add-In-Manager, und wählen Sie im Dialogfeld Add-In-Manager das Add-In aus. Klicken Sie auf OK, um das Add-In auszuführen.
Überprüfen Sie, ob die Warnstufe geändert wurde, indem Sie im Menü Projekt auf Eigenschaften klicken und dann im Eigenschaftenfenster die Registerkarte Erstellen auswählen.
Die programmgesteuerte Änderung hat sich auf den Wert im Feld Warnstufe ausgewirkt.
Um die Einstellung für die Sprachversion eines Visual C#-Projekts zu überprüfen, klicken Sie im Eigenschaftenfenster im Bereich Erstellen auf Erweitert.
Die durch das Add-In ausgeführte Änderung hat sich auf den Wert im Feld Sprachversion des Dialogfelds Erweiterte Buildeinstellungen ausgewirkt.
Um die an der Einstellung für die Codepage vorgenommene Änderung eines Visual J#-Projekts zu überprüfen, klicken Sie im Eigenschaftenfenster im Bereich Erstellen auf Erweitert.
Die Änderung dieser Eigenschaft hat sich auf den Wert im Feld Codepage des Dialogfelds Erweiterte Buildeinstellungen ausgewirkt.
Beispiel
Das folgende Beispiel zeigt ein einfaches Visual Studio-Add-In, das den Zugriff auf Eigenschaften eines bestimmten Projekttyps mithilfe der Visual Studio-Automatisierung veranschaulicht.
using System;
using Extensibility;
using EnvDTE;
using EnvDTE80;
using System.Windows.Forms;
using VSLangProj;
using VSLangProj2;
using VSLangProj80;
public void OnConnection(object application,
ext_ConnectMode connectMode, object addInInst, ref Array custom)
{
_applicationObject = (DTE2)application;
_addInInstance = (AddIn)addInInst;
VSProjectConfigProperties(_applicationObject);
}
public void VSProjectConfigProperties(DTE2 dte)
{
try
{
// Open a Visual C#, Visual J#, or Visual Basic project
// before running this add-in.
Project project;
Configuration config;
Properties configProps;
Property prop;
project = _applicationObject.Solution.Projects.Item(1);
config = project.ConfigurationManager.ActiveConfiguration;
configProps = config.Properties;
prop = configProps.Item("PlatformTarget");
MessageBox.Show("The platform target for this project is:
" + prop.Value.ToString());
prop = configProps.Item("WarningLevel");
MessageBox.Show
("The warning level for this project is set to: "
+ prop.Value.ToString());
MessageBox.Show("Changing the warning level to 3...");
prop.Value = "3";
MessageBox.Show
("The warning level for this project is now set to: "
+ prop.Value.ToString());
if (project.Kind == PrjKind.prjKindCSharpProject)
{
MessageBox.Show("The project is a Visual C# Project");
prop = configProps.Item("LanguageVersion");
MessageBox.Show("The language version value is : "
+ prop.Value.ToString());
MessageBox.Show("Setting the language version to ISO-1");
prop.Value = "ISO-1";
MessageBox.Show("The language version value is now: "
+ prop.Value.ToString());
}
if (project.Kind == PrjKind2.prjKindVJSharpProject)
{
MessageBox.Show("The project is a Visual J# Project");
prop = configProps.Item("CodePage");
MessageBox.Show("The code page value is : "
+ prop.Value.ToString());
MessageBox.Show
("Setting the code page value to my code page");
prop.Value = "my code page";
MessageBox.Show("The code page value is now: "
+ prop.Value.ToString());
}
}
catch(Exception ex)
{
MessageBox.Show(ex.Message);
}
}
Imports System
Imports Microsoft.VisualStudio.CommandBars
Imports Extensibility
Imports EnvDTE
Imports EnvDTE80
Imports VSLangProj
Imports VSLangProj2
Imports VSLangProj80
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)
VSProjectConfigProperties(_applicationObject)
End Sub
Sub VSProjectConfigProperties(ByVal dte As DTE2)
' Open a Visual C#, Visual J#, or Visual Basic project
' before running this add-in.
Try
Dim project As Project
Dim config As Configuration
Dim configProps As Properties
Dim prop As [Property]
project = _applicationObject.Solution.Projects.Item(1)
config = project.ConfigurationManager.ActiveConfiguration
configProps = config.Properties
prop = configProps.Item("PlatformTarget")
MsgBox("The platform target for this project is: " _
& prop.Value.ToString())
prop = configProps.Item("WarningLevel")
MsgBox("The warning level for this project is set to: " _
& prop.Value.ToString())
MsgBox("Changing the warning level to 3...")
prop.Value = "3"
MsgBox("The warning level for this project is now set to: " _
& prop.Value.ToString())
If project.Kind = PrjKind.prjKindCSharpProject Then
MsgBox("The project is a Visual C# Project")
prop = configProps.Item("LanguageVersion")
MsgBox("The language version value is : " _
& prop.Value.ToString())
MsgBox("Setting the language version to ISO-1")
prop.Value = "ISO-1"
MsgBox("The language version value is now: " _
& prop.Value.ToString())
End If
If project.Kind = PrjKind2.prjKindVJSharpProject Then
MsgBox("The project is a Visual J# Project")
prop = configProps.Item("CodePage")
MsgBox("The code page value is : " _
& prop.Value.ToString())
MsgBox("Setting the code page value to my code page")
prop.Value = "my code page"
MsgBox("The code page value is now: " _
& prop.Value.ToString())
End If
Catch ex As System.Exception
MsgBox(ex.ToString)
End Try
End Sub
Kompilieren des Codes
Um den Code zu kompilieren, erstellen Sie ein neues Visual Studio-Add-In-Projekt und ersetzen den Code der OnConnection-Methode durch den Code im Beispiel. Informationen zum Ausführen eines Add-Ins finden Sie unter Gewusst wie: Steuern von Add-Ins mit dem Add-In-Manager.