Condividi tramite

Procedura: Impostazioni di importazione tramite il pacchetto gestito Framework

  • Articolo

L'ambiente di sviluppo integrato di (IDE) Visual Studio utilizza le classi che implementano l'interfaccia di IProfileManager e vengono registrati per supportare un'implementazione di un VSPackage. Questa implementazione è utilizzato per recuperare lo stato di un VSPackage.

Poiché l'ide crea un'istanza di una classe che implementa l'interfaccia di IProfileManager per supportare le impostazioni di Visual Studio , l'interfaccia di IProfileManager deve essere implementata in una classe indipendente.

Nota

Non distribuire IProfileManager sulla classe che implementa Package.

Per implementare l'esportazione delle impostazioni

  1. Dichiarare una classe che implementa le impostazioni di Visual Studio .

    Dichiarare una classe come implementare IProfileManager e fornirla a GUID.

    Nota

    Le classi che implementano l'interfaccia di IProfileManager deve implementare anche l'interfaccia di IComponent , che può essere eseguita derivando una classe dalla classe di Component .

    Di seguito è riportato un esempio:

    [Guid("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")]
internal class MyPackageProfileManager : Component, IProfileManager 

  2. Verificare che la classe che implementa le impostazioni recupera i dati relativi allo stato dal disco.

    Questa operazione viene eseguita mediante l'implementazione del metodo di LoadSettingsFromXml .

    Le informazioni esatte che devono essere mantenute e come tali informazioni vengono ottenute e effettuato il marshalling dal package VS differiscono per ogni package VS.

    Indipendentemente dalle informazioni che devono essere mantenute dal package VS, la classe che implementa IProfileManager necessario utilizzare l'interfaccia fornita di IVsSettingsReader per recuperare i dati dal file di impostazioni.

    Typically, as in the example below, LoadSettingsFromXml also validates the retrieved data and updates the VSPackage's state.

    Dim mySvc As MyPackageService = TryCast(GetService(GetType(IVSMDMyPackage)), MyPackageService) 
If mySvc IsNot Nothing Then 
    Dim value As String 
    Dim myState As StateObject = mySvc.MyPackage.packageState 
    reader.ReadSettingString("PbrsShowDesc", value) 
    If value Is Nothing OrElse value = "" Then 
        reader.ReportError("Unable to Help Visibility Setting") 
    Else 
        myState.HelpVisible = Not value.Equals("0") 
    End If 
    reader.ReadSettingString("PbrsAlpha", value) 
    If value Is Nothing OrElse value = "" Then 
        reader.ReportError("Unable to Retrieve Sort Value") 
    Else 
        If Not value.Equals("0") Then 
            myState.SortState = SortState.Alphabetical 
        Else 
            myState.SortState = SortState.Categorized 
        End If 
    End If 
End If

    MyPackageService mySvc = GetService(typeof(IVSMDMyPackage)) as MyPackageService;
if (mySvc != null){
  string value;
  StateObject myState = mySvc.MyPackage.packageState;
  reader.ReadSettingString("PbrsShowDesc", out value);
  if (value == null || value == ""){
      reader.ReportError("Unable to Help Visibility Setting");
  }else{
      myState.HelpVisible = !value.Equals("0");
  }
  reader.ReadSettingString("PbrsAlpha", out value);
  if (value == null || value == ""){
      reader.ReportError("Unable to Retrieve Sort Value");
  }else{
    if (!value.Equals("0")){
      myState.SortState = SortState.Alphabetical;
    }else{
      myState.SortState = SortState.Categorized;
    }
  }
}

    dettagli di implementazione:

    • Visualizzare un rapporto degli errori all'utente in modo interattivo con l'ide tramite il metodo di ReportError dell'interfaccia di IVsSettingsReader :

      reader.ReadSettingString("PbrsAlpha", value) 
If value Is Nothing OrElse value = "" Then 
    reader.ReportError("Unable to Retrieve Sort Value") 
End If

        reader.ReadSettingString("PbrsAlpha", out value);
  if (value == null || value == ""){
      reader.ReportError("Unable to Retrieve Sort Value");
  }

    • Prima effettivamente di recuperare le impostazioni archiviate, un'implementazione del metodo di LoadSettingsFromXml deve utilizzare il metodo di ReadFileVersion per verificare che la versione di Visual Studio che esporta le impostazioni archiviate è supportata.

      Nel caso dell'esempio riportato di seguito, i controlli di implementazione per verificare se le impostazioni sono state generate da una versione di Visual Studio con un numero di versione principale di m_supportVere in caso contrario, segnala un errore.

      If pnMajor <> m_supportVer Then 
    reader.ReportError("Unsupported Version") 
End If

      if (pnMajor != m_supportVer){
  reader.ReportError("Unsupported Version");
}

    • Il file di impostazioni di Visual Studio supporta l'accesso ai dati casuali, pertanto l'ordine delle operazioni del writer e letti delle impostazioni non è importante. Nell'esempio riportato di seguito, l'ordine delle operazioni del writer nell'implementazione del metodo di SaveSettingsToXml rappresenta l'opposto di operazioni di lettura nel metodo di LoadSettingsFromXml .

    • Il valore dell'argomento di pszSettingName assegnato a un metodo di interfaccia di IVsSettingsWriter necessario identificare in modo univoco ognuno degli elementi salvato all'interno di una categoria di impostazioni.

      Nota

      I nomi devono essere univoci solo nella classe di implementazione perché l'ide utilizza il GUID della classe che implementa le impostazioni e il valore di pszSettingName per identificare ogni impostazione salvata.Se più di un metodo di IVsSettingsWriter viene chiamato con lo stesso valore di pszSettingName, il valore originale viene sovrascritto nel file di impostazioni.

  3. Assicurare la coerenza tra lo stato di un VSPackage e le impostazioni in locale archiviate o memorizzato nella cache.

    Questa operazione in genere viene eseguita durante l'implementazione del metodo di SaveSettingsToStorage (come illustrato nell'esempio riportato di seguito). I dettagli di questo passaggio sono specifici di un VSPackage e possono includere ottenere lo stato del package VS da automazione, eseguire una query sul package VS e impostare le chiavi del Registro di sistema.

    Nota

    Il metodo di LoadSettingsFromStorage necessario recuperare le informazioni salvate con il metodo di SaveSettingsToStorage quando il metodo di LoadSettingsFromStorage viene chiamato dall'IDE per tutta la sua inizializzazione del package VS che supporta.

    Nell'esempio riportato di seguito, la classe che fornisce il supporto delle impostazioni implementa il metodo di SaveSettingsToStorage :

    • Ottenere l'accesso alle informazioni sullo stato aggiornato del package VS.

      Dim mySvc As MyPackageService = TryCast(GetService(GetType(IVSMDMyPackage)), MyPackageService) 
Dim package As Package = TryCast(GetService(GetType(Package)), Package) 
Dim rootKey As RegistryKey = package.UserRegistryRoot

      MyPackageService mySvc = GetService(typeof(IVSMDMyPackage)) as MyPackageService;
Package package = GetService(typeof(Package)) as Package;
RegistryKey rootKey = package.UserRegistryRoot;

    • Utilizzare queste informazioni per aggiornare le impostazioni del Registro di sistema del package VS.

      If mySvc.MyPackage.packageState IsNot Nothing Then 
    Using rootKey 
        Using pbrsKey As RegistryKey = rootKey.CreateSubKey(Me.[GetType]().Name) 
            Using pbrsKey 
                DirectCast(mySvc.MyPackage.packageState, IComPropertyBrowser).SaveState(pbrsKey) 
            End Using 
        End Using 
    End Using 
End If

      if (mySvc.MyPackage.packageState != null) {
  using (rootKey) {
    using(RegistryKey pbrsKey = rootKey.CreateSubKey(this.GetType().Name)) {
      using (pbrsKey) {
        ((IComPropertyBrowser)mySvc.MyPackage.packageState).SaveState(pbrsKey);
      }
    }
  }
}

    • Nota

      La suddivisione del lavoro tra l'entity_M:Microsoft.VisualStudio.Shell.IProfileManager.LoadSettingsFromXml(Microsoft.VisualStudio.Shell.Interop.IVsSettingsReader) e i metodi di SaveSettingsToStorage dipende dall'implementazione e è Ad esempio, l'implementazione potrebbe essere riscritta con un'implementazione vuota del metodo di LoadSettingsFromStorage e del Registro di sistema e query dello stato eseguito nel metodo di SaveSettingsToXml .

  4. Registrare la classe implementa le impostazioni come fornire supporto in un VSPackage.

    Applicare un'istanza di ProvideProfileAttribute ha costruito utilizzando Type della classe che implementa IProfileManager implementazione di Package del package VS.

    <ProvideProfile(GetType(MyPackageProfileManager), "CoreUI", "MyPackage", 1004, 1004, False)> _ 
<Guid("YYYYYYYY-YYYY-YYYY-YYYY-YYYYYYYYYYYY")> _ 
Class MyPackage 
    Inherits Package 
End Class

     [ProvideProfile(typeof(MyPackageProfileManager), "CoreUI", "MyPackage", 1004, 1004, false)]
[Guid("YYYYYYYY-YYYY-YYYY-YYYY-YYYYYYYYYYYY")]
class MyPackage: Package 

    In questo caso, l'attributo all'IDE che la classe di MyPackageProfileManager fornisce un'implementazione delle impostazioni alla classe di MyPackage . Il passaggio di impostazioni personalizzato nel Registro di sistema viene creato in \Software\Microsoft\VisualStudio HKLM \ <versione> \UserSettings\ CoreUI_MyPackage, dove <versione> è la versione di Visual Studio, ad esempio 8,0.

    Per ulteriori informazioni, vedere Rendere persistenti le impostazioni e ProvideProfileAttribute

Esempio

Nell'esempio seguente viene implementato IProfileManager su una classe.

Imports System 
Imports System.Runtime.InteropServices 
Imports Microsoft.VisualStudio.Shell 
Imports Microsoft.VisualStudio.Shell.Interop 
Imports Microsoft.Win32 
Imports myPackageNameSpace 
Namespace myProfileManagerNameSpace 
    
    
    <Guid("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")> _ 
    Friend Class MyPackageProfileManager 
        Inherits System.ComponentModel.Component 
        Implements IProfileManager 
        Friend Const m_supportVer As Integer = 8 
        Public Sub SaveSettingsToXml(ByVal writer As IVsSettingsWriter) 
            Dim mySvc As MyPackageService = TryCast(GetService(GetType(MyPackage)), MyPackageService) 
            If mySvc IsNot Nothing Then 
                ' Information is stored in a StateObject. 
                Dim myState As StateObject = mySvc.MyPackage.packageState 
                writer.WriteSettingString("PbrsAlpha", (If(myState.SortState = SortState.Alphabetical, "1", "0"))) 
                writer.WriteSettingString("PbrsShowDesc", (If(myState.HelpVisible, "1", "0"))) 
            End If 
        End Sub 
        
        Public Sub LoadSettingsFromXml(ByVal reader As IVsSettingsReader) 
            
            Dim pnMajor As Integer, pnMinor As Integer, pnBuild As Integer 
            ' First check if we are getting data from the correct major version. 
            reader.ReadVersion(pnMajor, pnMinor, pnBuild) 
            If pnMajor <> m_supportVer Then 
                reader.ReportError("Unsupported Version") 
            Else 
                Dim mySvc As MyPackageService = TryCast(GetService(GetType(IVSMDMyPackage)), MyPackageService) 
                If mySvc IsNot Nothing Then 
                    Dim value As String 
                    Dim myState As StateObject = mySvc.MyPackage.packageState 
                    reader.ReadSettingString("PbrsShowDesc", value) 
                    ' Not all values must be present. 
                    If value Is Nothing OrElse value = "" Then 
                        reader.ReportError("Unable to Help Visibility Setting") 
                    Else 
                        myState.HelpVisible = Not value.Equals("0") 
                    End If 
                    reader.ReadSettingString("PbrsAlpha", value) 
                    ' Not all values must be present. 
                    If value Is Nothing OrElse value = "" Then 
                        reader.ReportError("Unable to Retrieve Sort Value") 
                    Else 
                        If Not value.Equals("0") Then 
                            myState.SortState = SortState.Alphabetical 
                        Else 
                            myState.SortState = SortState.Categorized 
                        End If 
                    End If 
                End If 
            End If 
        End Sub 
        
        Public Sub SaveSettingsToStorage() 
            Dim mySvc As MyPackageService = TryCast(GetService(GetType(IVSMDMyPackage)), MyPackageService) 
            Dim package As Package = TryCast(GetService(GetType(Package)), Package) 
            Dim rootKey As RegistryKey = package.UserRegistryRoot 
            
            If mySvc.MyPackage.packageState IsNot Nothing Then 
                Using rootKey 
                    Using pbrsKey As RegistryKey = rootKey.CreateSubKey(Me.[GetType]().Name) 
                        Using pbrsKey 
                            DirectCast(mySvc.MyPackage.packageState, IComPropertyBrowser).SaveState(pbrsKey) 
                        End Using 
                    End Using 
                End Using 
            End If 
        End Sub 
        
        Public Sub LoadSettingsFromStorage() 
            Dim mySvc As MyPackageService = TryCast(GetService(GetType(IVSMDMyPackage)), MyPackageService) 
            Dim package As Package = TryCast(GetService(GetType(Package)), Package) 
            Dim rootKey As RegistryKey = package.UserRegistryRoot 
            Using rootKey 
                Dim pbrsKey As RegistryKey = rootKey.OpenSubKey(Me.[GetType]().Name) 
                If pbrsKey IsNot Nothing Then 
                    Using pbrsKey 
                        If mySvc.MyPackage.MakeCurrentSettingTheDefault() Then 
                            DirectCast(mySvc.MyPackage.packageState, IComPropertyBrowser).SaveState(pbrsKey) 
                        Else 
                            DirectCast(mySvc.MyPackage.packageState, IComPropertyBrowser).LoadState(pbrsKey) 
                        End If 
                    End Using 
                End If 
            End Using 
        End Sub 
    End Class 
End Namespace

namespace myProfileManagerNameSpace  {
  
  using System;
  using System.Runtime.InteropServices;
  using Microsoft.VisualStudio.Shell;
  using Microsoft.VisualStudio.Shell.Interop;
  using Microsoft.Win32;
  using myPackageNameSpace;
  
  
  [Guid("XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")]
  internal class MyPackageProfileManager : System.ComponentModel.Component , IProfileManager {
    internal const int m_supportVer = 8;
    public void SaveSettingsToXml(IVsSettingsWriter writer) {
      MyPackageService mySvc = GetService(typeof(MyPackage)) as MyPackageService;
      if (mySvc != null) {
        // Information is stored in a StateObject.
        StateObject myState = mySvc.MyPackage.packageState;
        writer.WriteSettingString( 
                                  "PbrsAlpha", 
                                  (myState.SortState == SortState.Alphabetical ? "1" : "0"));
        writer.WriteSettingString( 
                                  "PbrsShowDesc", 
                                  (myState.HelpVisible ? "1" : "0"));
      }
    }
    
    public void LoadSettingsFromXml(IVsSettingsReader reader)
    {
      
      int pnMajor, pnMinor, pnBuild;
      // First check if we are getting data from the correct major version. 
      reader.ReadVersion(pnMajor, pnMinor, pnBuild);
      if (pnMajor != m_supportVer){
        reader.ReportError("Unsupported Version");
      }else{
        MyPackageService mySvc = GetService(typeof(IVSMDMyPackage)) as MyPackageService;
        if (mySvc != null){
          string value;
          StateObject myState = mySvc.MyPackage.packageState;
          reader.ReadSettingString("PbrsShowDesc", out value);
          // Not all values must be present.
          if (value == null || value == ""){
              reader.ReportError("Unable to Help Visibility Setting");
          }else{
            myState.HelpVisible = !value.Equals("0");
          }
          reader.ReadSettingString("PbrsAlpha", out value);
          // Not all values must be present.
          if (value == null || value == ""){
              reader.ReportError("Unable to Retrieve Sort Value");
          }else{
            if (!value.Equals("0")){
              myState.SortState = SortState.Alphabetical;
            }else{
              myState.SortState = SortState.Categorized;
            }
          }
        }
      }
    }

    public void SaveSettingsToStorage() {
      MyPackageService mySvc = GetService(typeof(IVSMDMyPackage)) as MyPackageService;
      Package package = GetService(typeof(Package)) as Package;
      RegistryKey rootKey = package.UserRegistryRoot;
      
      if (mySvc.MyPackage.packageState != null) {
        using (rootKey) {
          using(RegistryKey pbrsKey = rootKey.CreateSubKey(this.GetType().Name)) {
            using (pbrsKey) {
              ((IComPropertyBrowser)mySvc.MyPackage.packageState).SaveState(pbrsKey);
            }
          }
        }
      }
    }
    
    public void LoadSettingsFromStorage() {
      MyPackageService mySvc = GetService(typeof(IVSMDMyPackage)) as MyPackageService;
      Package package = GetService(typeof(Package)) as Package;
      RegistryKey rootKey = package.UserRegistryRoot;
      using (rootKey) {
        RegistryKey pbrsKey = rootKey.OpenSubKey(this.GetType().Name);
        if (pbrsKey != null) {
          using (pbrsKey) {
            if (mySvc.MyPackage.MakeCurrentSettingTheDefault()){
              ((IComPropertyBrowser)mySvc.MyPackage.packageState).SaveState(pbrsKey);
            }else{
              ((IComPropertyBrowser)mySvc.MyPackage.packageState).LoadState(pbrsKey);
            }
          }
        }
      }
    }
  }
}

Vedere anche

Attività

Procedura: Esporta impostazioni utilizzando il pacchetto gestito Framework

Riferimenti

IProfileManager

IVsSettingsWriter

Concetti

Rendere persistenti le impostazioni