Procedura: Assembly di interoperabilità viene utilizzato per importare le impostazioni
Un VSPackage possibile importare impostazioni dall'ambiente di sviluppo integrato di (IDE) Visual Studio . L'ide utilizza l'implementazione di un package VS dell'interfaccia di IVsUserSettings per determinare quali la configurazione del package VS deve essere recuperata.
Nota
Il pacchetto gestito Framework (MPF) fornisce un insieme di classi gestite per semplificare la creazione di estensioni di Visual Studio.Per eseguire questa attività utilizzando il MPF, vedere Procedura: Impostazioni di importazione tramite il pacchetto gestito Framework.
Per implementare l'importazione delle impostazioni in un VSPackage
Supporto di base di utilizzo al meccanismo delle impostazioni di Visual Studio .
Registrare il package VS come supporto del meccanismo di impostazioni tramite la definizione di uno o più punti di impostazioni personalizzati.
Per ulteriori informazioni, vedere Rendere persistenti le impostazioni.
Dichiarare che il package VS implementa l'interfaccia di IVsUserSettings , ad esempio:
public class MyPackage : IVsPackage, IVsUserSettings, IVsUserSettingsQueryAssicurarsi che l'implementazione del package VS del metodo di QueryInterface fornisce un'interfaccia di IVsUserSettings una volta chiamata con IID_IVsUserSettings. Di seguito è riportato un esempio:
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; }
Recuperare le informazioni delle impostazioni.
Per supportare recuperare informazioni sulle impostazioni, un VSPackage deve implementare il metodo di ImportSettings .
Per leggere i dati, l'implementazione di un package VS dell'interfaccia di IVsUserSettings necessario utilizzare i primi due argomenti passati dall'IDE: il GUID della categoria personalizzata di impostazioni e un'interfaccia di IVsSettingsReader .
L'implementazione di un package VS del metodo di ImportSettings necessario controllare la categoria GUID passata in e scegliere il meccanismo corretto per lo stato di recupero.
Nell'esempio riportato di seguito, le chiamate al metodo di ImportSettings un'implementazione diversa per recuperare lo stato della barra dei comandi anziché recuperare lo stato dell'associazione di chiavi.
Un VSPackage necessario utilizzare l'interfaccia fornita di IVsSettingsReader per recuperare i dati nel file di impostazioni.
Nota
Se le modifiche di informazioni delle impostazioni in funzione di Visual Studio versione, l'implementazione di un package VS del metodo di ImportSettings necessario utilizzare il metodo di ReadFileVersion prima dei dati di lettura per controllare la versione dell'IDE.
L'interfaccia fornisce metodi per la lettura dei tipi di dati diversi dal file di impostazioni.
interface IVsSettingsReader : IUnknown
{
HRESULT ReadSettingString(WCHAR *pszSettingName, BSTR *pbstrSettingValue);
HRESULT ReadSettingLong(WCHAR *pszSettingName, long *plSettingValue);
HRESULT ReadSettingBoolean(WCHAR *pszSettingName, BOOL *pfSettingValue);
HRESULT ReadSettingAttribute(LPCOLESTR pszSettingName,LPCOLESTR pszAttributeName, BSTR *pbstrSettingValue); //Internal use only
HRESULT ReadSettingBytes(WCHAR *pszSettingName, BYTE *pSettingValue, long *plDataLength, long lDataMax);
HRESULT ReadVersion(int *pnMajor, int *pnMinor, int *pnBuild);
HRESULT ReportError(WCHAR *pszError);
};
Il file di impostazioni supporta l'accesso ai dati casuali, pertanto l'ordine di lettura di e scrive le impostazioni che le operazioni non è importante.
Tale situazione è illustrata nello stato di esportazione e importazione della barra dei comandi (ExportSettings_CommandBar e ImportSettings_CommandBar) dell'implementazione nell'esempio riportato di seguito.
validate ha recuperato i dati.
Informazioni sulle impostazioni sono contenute in file XML, che possono essere modificati manualmente.
.gif "Nota sulla sicurezza") Nota sulla sicurezza |
|---|
Informazioni sulle impostazioni possono diventare danneggiate su disco, possono contenere impostazioni specifiche e possono essere utilizzate come veicolo per l'attacco dannoso.La validità di ogni elemento di dati restituito dal metodo di IVsSettingsReader deve essere convalidato. |
Per verificare il supporto della versione di Visual Studio stato utilizzato per produrre le impostazioni recuperate, chiamare il metodo di ReadFileVersion per recuperare la versione.
Per visualizzare l'ide per informare l'utente che un elemento importato non convalida, chiamate di un package VS il metodo di ReportError .
Applicare le informazioni delle impostazioni.
L'implementazione del metodo di ImportSettings deve rispettare il valore del terzo argomento che l'ide ha superato. I valori supportati sono membri dell'enumerazione di __UserSettingsFlags . Per ulteriori informazioni, vedere __UserSettingsFlags.
Nell'esempio riportato di seguito, l'implementazione per importare le impostazioni della barra dei comandi (ImportSettings_Commandbar) utilizza il valore di questo argomento per determinare se applicare le impostazioni per sovrascrivere i valori esistenti o rappresentata aggiornarli.
È necessario implementare una metodologia della cache di write-through quando si applica le impostazioni importate.
Le informazioni sullo stato nel Registro di sistema o nel file system devono essere aggiornate nel momento stesso in cui vengono applicate le impostazioni dell'IDE. Ciò garantisce la coerenza di configurazione e gli scenari di più istanze dell'IDE di supportare.
L'ide attenzione come gestire l'importazione delle impostazioni.
Utilizzare l'argomento restituito di pfRestartRequired del metodo di ImportSettings per consigliare l'ide se un riavvio è necessario applicare impostazioni importate.
Se il valore VSQueryEditResult è QER_EditNotOK e il valore VSQueryEditResultFlags ha il bit QER_ReadOnlyUnderScc inpostato, il file di progetto deve essere verificato chiamando QueryEditFiles (QEF_ForceEdit_NoPrompting, QEF_DisallowInMemoryEdits,...).
Esempio
In questo esempio viene illustrato come importare ed esportare i dati delle impostazioni.
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";
// --------------------------------------------------------------------------
// IVsUserSettings methods used for configuration export and import
// 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 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-thru cache methodology is essential 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 to import 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-thru cache methodology is essential to work in multi-instance IDE scenarios.
hr = UpdateState_KeyBindings(bstrBreakPointWindow);
Error:
return hr;
}
Vedere anche
Attività
Procedura: Esporta impostazioni tramite assembly di interoperabilità
Concetti
Rendere persistenti le impostazioni