Gewusst wie: und exportieren mithilfe von Interop-Assemblys
Exportieren von Einstellungen möglicherweise ein VSPackage Visual Studio der integrierten Entwicklungsumgebung (IDE). Die IDE verwendet eine VSPackages Implementierung der IVsUserSettings-Schnittstelle. Wenn das Paket auch die IVsUserSettingsQuery-Schnittstelle bereitstellt, dann wird die IVsUserSettingsQuery-Schnittstelle verwendet, um zu bestimmen, wie die VSPackages Konfiguration gespeichert werden soll.
Hinweis
Das verwaltete Paketframework (MPF) stellt einen Satz verwalteter Klassen aufgerufen, um die Erstellung von Visual Studio-Erweiterungen zu erleichtern.Um diese Aufgabe mithilfe des MPF finden Sie unter Gewusst wie: und exportieren mithilfe von verwaltetem Paketframeworks.
So export Einstellungen in einem VSPackage implementieren
Implementieren Sie grundlegende Unterstützung für den Visual Studio Mechanismus zur Einstellungen.
Registrieren von VSPackages Mechanismus für die Einstellungen des unterstützt, indem Sie eine oder mehrere benutzerdefinierte Einstellungs-Punkte definieren.
Weitere Informationen finden Sie unter Beibehalten von Einstellungen.
Deklarieren Sie, dass ein VSPackage IVsUserSettingsimplementiert. Wenn es erforderlich ist, kann auch ein VSPackage IVsUserSettingsQuery-Schnittstelle implementieren. Beispiele:
public class MyPackage : IVsPackage, IVsUserSettings, IVsUserSettingsQueryStellen Sie sicher, dass die VSPackages Implementierung des QueryInterface-Methode stellt eine IVsUserSettings-Schnittstelle, wenn Sie mit IID_IVsUserSettingsaufgerufen werden.
Optional kann QueryInterface eine IVsUserSettingsQuery-Schnittstelle bereitstellen, wenn sie mit der IID_IVsUserSettingsQuery-Schnittstelle aufgerufen wird.
STDMETHODIMP MyPackage::QueryInterface(THIS_ REFIID riid, LPVOID FAR* ppvObj) { if (ppvObj == NULL) return E_POINTER; *ppvObj = NULL; if (riid == IID_IUnknown) *ppvObj = (LPVOID)(IUnknown *)(IClassFactory*)this; else if (riid == IID_IClassFactory) *ppvObj = (LPVOID)(IClassFactory *)this; else if (riid == IID_IVsPackage) *ppvObj = (LPVOID)(IVsPackage *)this; else if (riid == IID_IVsPersistSolutionOpts) *ppvObj = (LPVOID)(IVsPersistSolutionOpts *)this; else if (riid == IID_IVsPersistSolutionProps) *ppvObj = (LPVOID)(IVsPersistSolutionProps *)this; else if (riid == IID_IVsComponentSelectorProvider) *ppvObj = (LPVOID)(IVsComponentSelectorProvider *)this; else if (riid == IID_IVsUserSettings) *ppvObj = (LPVOID)(IVsUserSettings *)this; else if (riid == IID_IVsUserSettingsQuery) *ppvObj = (LPVOID)(IVsUserSettingsQuery *)this; if (*ppvObj) { AddRef(); return NOERROR; } return E_NOINTERFACE; }
Optional benachrichtigen Sie die IDE der Anforderung, eine bestimmte Einstellung zu exportieren.
VSPackage kann eine Einstellung bedingt zu speichern, die der benutzerdefinierte Einstellungs-Punkt Zustand definiert. Speichern Sie beispielsweise nur, wenn der Benutzer keine explizit festlegt Einstellung gespeichert werden soll.
In diesem Fall muss die IVsUserSettingsQuery-Schnittstelle implementiert werden.
Wenn ein VSPackage IVsUserSettingsQuerynicht implementiert, werden sämtliche Zustandsinformationen während eines exports Einstellungen gespeichert.
VSPackage kann mehr als einen Gewohnheits-Einstellungs-Punkt (Einstellungskategorie) unterstützen. Implementierungen der NeedExport-Methode müssen das GUID-Wert oder Einstellungskategorie - Argument des angegebenen benutzerdefinierten Einstellungs-Punkts überprüfen, um zu ermitteln, ob eine bestimmte Gruppe von Einstellungen gespeichert werden muss.
Im nachstehenden Beispiel fordert die Anforderungen, die immer VSPackages der Befehlsleiste - Zustand gespeichert wird, jedoch lediglich an, dass der Tastenzuordnungs Zustand gespeichert wird, wenn ein Flag festgelegt wurde.
Schreiben Sie Einstellungsdaten für die Einstellungsdatei.
Zum Exportieren von Einstellungen zu unterstützen, muss die ExportSettings-Methode immer ein VSPackage implementieren.
Die Implementierung muss die Argumente verarbeiten, die von der IDE, die GUIDs der benutzerdefinierten Kategorie des Einstellungs-Punkts und eine IVsSettingsWriter-Schnittstelle übergeben werden.
VSPackage kann mehr als einen Gewohnheits-Einstellungs-Punkt (Einstellungskategorie) unterstützen. Im nachfolgenden Beispiel wird die ExportSettings-Methode ruft eine andere Implementierung für das Beibehalten der Zustand der Befehlsleiste im Gegensatz zum Beibehalten von Tastenzuordnungs Zustand.
VSPackage muss die angegebene IVsSettingsWriter-Schnittstelle verwenden, um Daten in die Datei mit Einstellungen zu speichern.
interface IVsSettingsWriter : IUnknown
{
HRESULT WriteSettingString( LPCOLESTR pszSettingName, LPCOLESTR pszSettingValue);
HRESULT WriteSettingLong( LPCOLESTR pszSettingName, long lSettingValue);
HRESULT WriteSettingBoolean( LPCOLESTR pszSettingName, BOOL fSettingValue);
HRESULT WriteSettingBytes( LPCOLESTR pszSettingName, BYTE *pSettingValue, long lDataLength);
HRESULT WriteSettingAttribute( LPCOLESTR pszSettingName, LPCOLESTR pszAttributeName, LPCOLESTR pszSettingValue);
HRESULT WriteSettingXml( IUnknown *pIXMLDOMNode);
HRESULT WriteSettingXmlFromString( LPCOLESTR szXML);
HRESULT ReportError( LPCOLESTR pszError, VSSETTINGSERRORTYPES dwErrorType);
};
Der Wert des Arguments pszSettingName , das einer IVsSettingsWriter-Schnittstelle angegeben wird, muss jedes Datenelement eindeutig bezeichnen, das in eine Einstellungskategorie gespeichert wird.
Hinweis
Namen müssen innerhalb eines benutzerdefinierten Einstellungs-Punkts eindeutig sein, da die IDE der GUID und den Wert pszSettingName verwendet, um jede gespeicherte Einstellung zu identifizieren.Wenn mehr als eine IVsSettingsWriter-Methode mit demselben Wert pszSettingNameaufgerufen wird, wird der ursprüngliche Wert in der Einstellungsdatei überschrieben.
Die Einstellungsdatei zufälligen unterstützt den Datenzugriff. Folglich das Lesen und Schreiben die Reihenfolge von Einstellungen, die Operationen nicht wichtig ist.
Dies wird in den Implementierungen des Importierens und Exportierens von Befehlsleiste - Zustand (ExportSettings_CommandBar) und ImportSettings_CommandBarim folgenden Beispiel veranschaulicht.
Wenn die Implementierung in Karteninformationen einem der vier unterstützten Formaten kann, gibt es keine Beschränkung auf, wie viel oder dem Typ der Daten geschrieben werden kann.
Hinweis
Zusätzlich zu den Daten, die explizit geschrieben werden und die Implementierung ExportSettings transparent, speichert die Einstellungen auch APIs Visual Studio-Versionsinformationen.Gespeicherte Einstellungen können für die Version der IDE verglichen werden, während sie das Festlegen des importes generiert hat.
Beispiel
Das folgende Beispiel zeigt, wie Sie Einstellungsdaten importiert und exportiert.
// --------------------------------------------------------------------------
// IVsUserSettings methods used for configuration export.
// Delegate to the right shell object based on the category GUID.
// --------------------------------------------------------------------------
static const WCHAR c_szFirstSettingName[] = L"FirstSettingName";
static const WCHAR c_szRandomTrashBytes[] = L"RandomTrashBytes";
static const WCHAR c_szRandomTrashLength[] = L"RandomTrashLength";
static const WCHAR c_szBreakPointWindow[] = L"Breakpoints Window";
// Export Settings.
STDMETHOD(NeedExport)(WCHAR* pszCategoryGUID, BOOL *pfNeedExport)
{
if (!pfNeedExport)
return E_INVALIDARG;
CLSID clsidCategory;
HRESULT hr= S_OK;
hr = CLSIDFromString(pszCategoryGUID, &clsidCategory);
IfFailGo(hr);
if (GUID_Profiles_CommandBars == clsidCategory) {
*pfNeedExport = TRUE; //Always export Command Bar Configuration
}else if (GUID_Profiles_KeyBindings == clsidCategory) {
*pfNeedExport = FALSE; //By Default don't export key bindings
if (m_fMake_Permanent)
*pfNeedExport = TRUE; //Export if user wants current configuration saved.
}else{
hr = E_UNEXPECTED;
}
Error:
return hr;
}
STDMETHOD(ExportSettings)(WCHAR *pszCategoryGUID, IVsSettingsWriter *pSettings)
{
CLSID clsidCategory;
HRESULT hr;
hr = CLSIDFromString(pszCategoryGUID, &clsidCategory);
IfFailGo(hr);
// Delegate to the right internal implementation based on
// the requested category.
if (GUID_Profiles_CommandBars == clsidCategory) {
hr = ExportSettings_CommandBars(pSettings);
}else if (GUID_Profiles_KeyBindings == clsidCategory) {
hr = ExportSettings_KeyBindings(pSettings);
}else{
hr = E_UNEXPECTED;
}
Error:
return hr;
};
HRESULT ExportSettings_CommandBars(IVsSettingsWriter *pSettings)
{
if (!pSettings)
return E_INVALIDARG;
hr = pSettings->WriteSettingString(c_szFirstSettingName, L"Value1");
IfFailGo(hr);
int cRandomTrash = 12345;
BYTE *pRandomTrash = (BYTE *)VSAlloc(cRandomTrash);
if (pRandomTrash){
hr = pSettings->WriteSettingBytes(c_szRandomTrashBytes, pRandomTrash, cRandomTrash);
IfFailGo(hr);
hr = pSettings->WriteSettingLong(c_szRandomTrashLength, cRandomTrash);
IfFailGo(hr);
}
Error:
return hr;
};
HRESULT ExportSettings_KeyBindings(IVsSettingsWriter *pSettings)
{
if (!pSettings)
return E_INVALIDARG;
hr = pSettings->WriteSettingString(c_szBreakPointWindow, L"Ctrl + Alt + B");
IfFailGo(hr);
Error:
return hr;
};
STDMETHOD(ImportSettings)(WCHAR *pszCategoryGUID, IVsSettingsReader *pSettings, UserSettingsFlags flags, BOOL *pfRestartRequired)
{
CLSID clsidCategory;
HRESULT hr;
hr = CLSIDFromString(pszCategoryGUID, &clsidCategory);
IfFailGo(hr);
// Delegate to the right internal implementation based on
// the requested category.
if (GUID_Profiles_CommandBars == clsidCategory)
{
hr = ImportSettings_CommandBars(, pSettings, flags, pfRestartRequired);
}
else if (GUID_Profiles_KeyBindings == clsidCategory)
{
hr = ImportSettings_KeyBindings( pSettings, flags, pfRestartRequired);
}
else
{
hr = E_UNEXPECTED;
}
Error:
return hr;
};
// Import Settings.
HRESULT ImportSettings_CommandBars(IVsSettingsReader *pSettings, UserSettingsFlags flags, BOOL *pfRestartRequired)
{
if (!pSettings)
return E_INVALIDARG;
if (pfRestartRequired)
{
*pfRestartRequired = FALSE; //Nobody should require a restart!!
}
CComBSTR bstrFirstSettingName;
long lTrashLength = 0;
BYTE *pTrashBytes = NULL;
// Determines whether to treat import as an additive operation, or a reset all settings operation.
BOOL fResetCompletely = FALSE;
if (flags & USF_ResetOnImport)
fResetCompletely = TRUE;
hr = pSettings->ReadSettingString(c_szFirstSettingName, &bstrFirstSettingName);
IfFailGo(hr);
hr = pSettings->ReadSettingLong(c_szRandomTrashLength, &lTrashLength);
IfFailGo(hr);
if (lTrashLength > 0)
{
pTrashBytes = (BYTE*)VSAlloc(lTrashLength);
IfNullMemGo(pTrashBytes);
long lDataRead = 0;
hr = pSettings->ReadSettingBytes(c_szRandomTrashLength, pTrashBytes, &lDataRead, lTrashLength);
IfFailGo(hr);
if (lDataRead != lTrashLength)
{
hr = E_UNEXPECTED;
goto Error;
}
}
// Note: before returning, these settings should immediately
// be applied to your personal settings store,
// whether in the registry or the file system.
// This write-through cache methodology is essential to to work
// in multi-instance IDE scenarios.
hr = UpdateState_CommandBar(bstrFirstSettingName,lTrashLength,pTrashBytes,lDataRead);
Error:
return hr;
};
HRESULT ImportSettings_KeyBindings(IVsSettingsReader *pSettings, UserSettingsFlags flags, BOOL *pfRestartRequired)
{
if (!pSettings)
return E_INVALIDARG;
if (pfRestartRequired)
{
*pfRestartRequired = FALSE; //Nobody should require a restart!!
}
CComBSTR bstrBreakPointWindow;
// Determines whether import can be treated as an additive
// operation, or a reset all settings operation.
BOOL fResetCompletely = FALSE;
if (flags & USF_ResetOnImport)
fResetCompletely = TRUE;
hr = pSettings->ReadSettingString(c_szBreakPointWindow, &bstrBreakPointWindow);
IfFailGo(hr);
// Note: Before returning, these settings should immediately
// be applied to your personal settings
// store, whether in the registry or the file system.
// This write-through cache methodology is essential to allow us
// to work in multi-instance IDE scenarios.
hr = UpdateState_KeyBindings(bstrBreakPointWindow);
Error:
return hr;
}
Siehe auch
Aufgaben
Gewusst wie: Verwendungs-Interopassemblys, um Einstellungen zu importieren