Conflitti e precedenza

Quando includi, escludi e reindirizzi file e impostazioni, è importante sapere come vengono gestiti conflitti e precedenza in Utilità di migrazione stato utente (USMT) 5.0. Le seguenti linee guida relative a conflitti e precedenza sono le più importanti da ricordare quando usi USMT.

• Se ci sono regole in conflitto in un componente, viene applicata la regola più specifica. La regola <unconditionalExclude> rappresenta tuttavia un'eccezione perché ha la precedenza su tutte le altre. I nomi di directory hanno la precedenza sulle estensioni di file. Vedi, ad esempio, Che cosa succede quando ci sono regole <include> ed <exclude> in conflitto? e il primo esempio nella sezione Esempi di precedenza per regole <include> ed <exclude> più avanti in questo argomento.

• Solo le regole all'interno dello stesso componente possono avere effetti reciproci, a seconda della specificità. Le regole che si trovano in componenti diversi non hanno effetti reciproci, ad eccezione della regola <unconditionalExclude>.

• Se il livello di specificità delle regole è lo stesso, <exclude> ha la precedenza su <include>. Se ad esempio usi la regola <exclude> per escludere un file e la regola <include> per includere lo stesso file, il file viene escluso.

• L'ordine dei componenti non è rilevante. Non è importante sapere quali componenti sono elencati nei vari file XML, perché ogni componente viene elaborato indipendentemente dagli altri in tutti i file XML.

• L'ordine delle regole <include> ed <exclude> all'interno di un componente non è rilevante.

• Puoi usare l'elemento <unconditionalExclude> per escludere dati a livello globale. Questo elemento esclude gli oggetti indipendentemente dalle altre regole <include> presenti nei file XML. Puoi ad esempio usare l'elemento <unconditionalExclude> per escludere tutti i file MP3 nel computer o per escludere tutti i file in C:\UserData.

In questo argomento

Informazioni generali

• Qual è la relazione tra le regole che si trovano in componenti diversi?

• Come funziona la precedenza con il file Config.xml?

• In che modo USMT elabora ogni componente in un file XML con più componenti?

• Come vengono elaborate le regole?

• In che modo USMT combina tutti i file XML che si specificano nella riga di comando?

Regole <include> ed <exclude>

• Che cosa succede quando ci sono regole <include> ed <exclude> in conflitto?

• Esempi di precedenza per regole <include> ed <exclude>

Collisioni di file

• Qual è il comportamento predefinito quando si verificano collisioni di file?

• Come funziona la regola <merge> quando si verificano collisioni di file?

Informazioni generali

Qual è la relazione tra le regole che si trovano in componenti diversi?

Solo le regole all'interno dello stesso componente possono avere effetti reciproci, a seconda della specificità, ad eccezione della regola <unconditionalExclude>. Le regole che si trovano in componenti diversi non hanno effetti reciproci. Se un componente contiene una regola <include> e un altro componente contiene una regola <exclude> identica, la migrazione dei dati viene eseguita perché le due regole sono indipendenti.

Se un componente contiene una regola <include> e un altro componente contiene una regola <locationModify> per lo stesso file, la migrazione del file viene eseguita in entrambe le posizioni. In altre parole, il file viene incluso in base alla regola <include> e ne viene eseguita la migrazione in base alla regola <locationModify>.

Il file XML seguente esegue la migrazione di tutti i file presenti in C:\Userdocs, inclusi i file MP3, perché la regola <exclude> è specificata in un componente diverso.

<migration urlid="https://www.microsoft.com/migration/1.0/migxmlext/UserDocs">
<component type="Documents" context="System">
<displayName>User Documents</displayName>
        <role role="Data">
            <rules>
                <exclude>
                    <objectSet>
                        <pattern type="File">C:\Userdocs\* [*.mp3]</pattern>
                    </objectSet>
                </exclude>
          </rules>
        </role>
</component>

<component type="Documents" context="System">
<displayName> User documents to include </displayName>
        <role role="Data">
            <rules>
                <include>
                    <objectSet>
                        <pattern type="File"> C:\Userdocs\ [*]</pattern>
                    </objectSet>
                </include>
          </rules>
        </role>
</component>
</migration>

Come funziona la precedenza con il file Config.xml?

Se specifichi migrate="no" nel file Config.xml, ottieni lo stesso risultato dell'eliminazione del componente corrispondente dal file di migrazione XML. Se tuttavia imposti migrate="no" per la cartella Documenti, ma in un file di migrazione XML è presente una regola simile a quella illustrata di seguito (che include tutti i file con estensione doc presenti nella cartella Documenti), viene eseguita la migrazione solo dei file con estensione doc, mentre tutti gli altri file vengono esclusi.

<include>
   <objectSet>
      <pattern type="File">%CSIDL_PERSONAL%\* [*.doc] </pattern>
   </objectSet>
</include> 

In che modo USMT elabora ogni componente in un file XML con più componenti?

L'ordine dei componenti non è rilevante. Ogni componente viene elaborato in modo indipendente dagli altri. Se ad esempio un componente contiene una regola <include> e un altro componente contiene una regola <locationModify> per lo stesso file, la migrazione del file viene eseguita in entrambe le posizioni. In altre parole, il file viene incluso in base alla regola <include> e ne viene eseguita la migrazione in base alla regola <locationModify>.

Come vengono elaborate le regole?

Ci sono due categorie generali di regole.

• Regole che influiscono sul comportamento di entrambi gli strumenti ScanState e LoadState. Le regole <include>, <exclude> e <unconditionalExclude> vengono ad esempio elaborate per ogni componente nei file XML. Per ogni componente, USMT crea un elenco di inclusione e un elenco di esclusione. Alcune regole del componente potrebbero venire scartate per il livello di specificità, ma tutte le regole rimanenti vengono elaborate. Per ogni regola <include>, USMT scorre gli elementi per stabilire se è necessario escludere alcune posizioni. USMT enumera tutti gli oggetti e crea un elenco di oggetti che verranno raccolti per ogni utente. Dopo che l'elenco è stato completato, ogni oggetto viene archiviato o sottoposto a migrazione nel computer di destinazione.

• Regole che influiscono solo sul comportamento dello strumento LoadState. Le regole <locationModify>, <contentModify> e <destinationCleanup>, ad esempio, non influiscono su ScanState e vengono elaborate solo con LoadState. Lo strumento LoadState determina prima di tutto il contenuto e la posizione di ogni componente in base alle regole <locationModify> e <contentModify>. LoadState elabora quindi tutte le regole <destinationCleanup> ed elimina i dati dal computer di destinazione. Infine, LoadState applica i componenti al computer.

In che modo USMT combina tutti i file XML che si specificano nella riga di comando?

USMT non distingue i file XML in base al nome o al contenuto, ma elabora ogni componente all'interno dei file separatamente. USMT supporta più file XML solo per semplificare la gestione e l'organizzazione dei componenti in essi contenuti. Poiché USMT usa un attributo UrlId per distinguere ogni componente dagli altri, devi verificare che ogni file XML che specifichi nella riga di comando abbia un attributo UrlId di migrazione univoco.

Regole <include> ed <exclude>

Che cosa succede quando ci sono regole <include> ed <exclude> in conflitto?

Se ci sono regole in conflitto in un componente, viene applicata la regola più specifica, ad eccezione della regola <unconditionalExclude>, che ha la precedenza su tutte le altre. Se il livello di specificità delle regole è lo stesso, non viene eseguita la migrazione dei dati. Se ad esempio escludi un file e includi lo stesso file, la migrazione del file non viene eseguita. Se in componenti diversi sono presenti regole in conflitto, le regole non hanno effetti reciproci perché ogni componente viene elaborato in modo indipendente dagli altri.

Nell'esempio seguente i file MP3 non vengono esclusi dalla migrazione, perché i nomi di directory hanno la precedenza sulle estensioni di file.

<include>
     <objectSet>
          <pattern type="File">C:\Data\* [*]</pattern>
     </objectSet>
</include>
<exclude>
     <objectSet>
          <pattern type="File"> C:\* [*.mp3]</pattern>
     </objectSet>
</exclude>  

Esempi di precedenza per regole <include> ed <exclude>

In questi esempi viene illustrato come USMT gestisce le regole <include> ed <exclude>. Quando le regole si trovano in componenti diversi, il comportamento risultante è lo stesso indipendentemente dal fatto che i componenti si trovino nello stesso file di migrazione XML o in file diversi.

• Includere ed escludere file

• Includere ed escludere oggetti del Registro di sistema

Includere ed escludere file

Se è presente il codice seguente nello stesso componente	Comportamento risultante	Spiegazione
Regola di inclusione: <pattern type="File">C:\Dir1\* [*]</pattern> Regola di esclusione: <pattern type="File">C:\* [*.txt]</pattern>	Esegue la migrazione di tutti i file e le sottocartelle di Dir1, inclusi tutti i file con estensione txt in C.	La regola <exclude> non ha effetti sulla migrazione, perché la regola <include> è più specifica.
Regola di inclusione: <pattern type="File">C:\Dir1\* [*]</pattern> Regola di esclusione: <pattern type="File">C:\Dir1\Dir2\* [*.txt]</pattern>	Esegue la migrazione di tutti i file e le sottocartelle di C:\Dir1, ad eccezione dei file con estensione txt in C:\Dir1\Dir2 e nelle relative sottocartelle.	Entrambe le regole vengono elaborate come previsto.
Regola di inclusione: <pattern type="File">C:\Dir1\* [*]</pattern> Regola di esclusione: <pattern type="File">C:\Dir1\ * [*.txt]</pattern>	Esegue la migrazione di tutti i file e le sottocartelle di C:\Dir1, ad eccezione dei file con estensione txt in C:\Dir1 e nelle relative sottocartelle.	Entrambe le regole vengono elaborate come previsto.
Regola di inclusione: <pattern type="File">C:\Dir1\Dir2\* [*.txt]</pattern> Regola di esclusione: <pattern type="File">C:\Dir1\Dir2\* [*.txt]</pattern>	Non viene eseguita la migrazione di alcun elemento.	Le regole hanno la stessa specificità, quindi la regola <exclude> ha la precedenza sulla regola <include>.
Regola di inclusione: C:\Dir1\* [*.txt] Regola di esclusione: C:\Dir1\Dir2\* [*]	Esegue la migrazione dei file con estensione txt in Dir1 e dei file con estensione txt nelle sottocartelle diverse da Dir2. Non viene eseguita la migrazione di alcun file presente in Dir2 o nelle relative sottocartelle.	Entrambe le regole vengono elaborate come previsto.
Regola di inclusione: C:\Dir1\Dir2\* [*] Regola di esclusione: C:\Dir1\* [*.txt]	Esegue la migrazione di tutti i file e le sottocartelle di Dir2, ad eccezione dei file con estensione txt in Dir1 e nelle relative sottocartelle, inclusa Dir2.	Entrambe le regole vengono elaborate come previsto.

Se è presente il codice seguente in diversi componenti	Comportamento risultante	Spiegazione
Componente 1: Regola di inclusione: <pattern type="File">C:\Dir1\* [*]</pattern> Regola di esclusione: <pattern type="File">C:\Dir1\Dir2\* [*.txt]</pattern> Componente 2: Regola di inclusione: <pattern type="File">C:\Dir1\Dir2\* [*.txt]</pattern> Regola di esclusione: <pattern type="File">C:\Dir1\* [*]</pattern>	Esegue la migrazione di tutti i file e le sottocartelle di C:\Dir1\, inclusa C:\Dir1\Dir2\.	Le regole in diversi componenti non hanno effetti reciproci, ad eccezione della regola <unconditionalExclude>. In questo esempio, quindi, anche se alcuni file con estensione txt sono stati esclusi durante l'elaborazione di Componente 1, gli stessi file sono stati inclusi durante l'elaborazione di Componente 2.
Componente 1: Regola di inclusione: C:\Dir1\Dir2\* [*] Componente 2: Regola di esclusione: C:\Dir1\* [*.txt]	Esegue la migrazione di tutti i file e le sottocartelle di Dir2, ad eccezione dei file con estensione txt in C:\Dir1 e nelle relative sottocartelle.	Entrambe le regole vengono elaborate come previsto.
Componente 1: Regola di esclusione: C:\Dir1\Dir2\* [*] Componente 2: Regola di inclusione: C:\Dir1\* [*.txt]	Esegue la migrazione di tutti i file con estensione txt in Dir1 e nelle relative sottocartelle.	Componente 1 non contiene una regola <include>, quindi la regola <exclude> non viene elaborata.

Includere ed escludere oggetti del Registro di sistema

Se è presente il codice seguente nello stesso componente	Comportamento risultante	Spiegazione
Regola di inclusione: HKLM\Software\Microsoft\Command Processor\* [*] Regola di esclusione: HKLM\Software\Microsoft\Command Processor [DefaultColor]	Esegue la migrazione di tutte le chiavi in HKLM\Software\Microsoft\Command Processor, ad eccezione di DefaultColor.	Entrambe le regole vengono elaborate come previsto.
Regola di inclusione: HKLM\Software\Microsoft\Command Processor [DefaultColor] Regola di esclusione: HKLM\Software\Microsoft\Command Processor\* [*]	Esegue la migrazione solo di DefaultColor in HKLM\Software\Microsoft\Command Processor.	Viene eseguita la migrazione di DefaultColor perché la regola <include> è più specifica della regola <exclude>.
Regola di inclusione: HKLM\Software\Microsoft\Command Processor [DefaultColor] Regola di esclusione: HKLM\Software\Microsoft\Command Processor [DefaultColor]	Non viene eseguita la migrazione di DefaultColor.	Le regole hanno la stessa specificità, quindi la regola <exclude> ha la precedenza sulla regola <include>.

Se è presente il codice seguente in diversi componenti	Comportamento risultante	Spiegazione
Componente 1: Regola di inclusione: HKLM\Software\Microsoft\Command Processor [DefaultColor] Regola di esclusione: HKLM\Software\Microsoft\Command Processor\* [*] Componente 2: Regola di inclusione: HKLM\Software\Microsoft\Command Processor\* [*] Regola di esclusione: HKLM\Software\Microsoft\Command Processor [DefaultColor]	Esegue la migrazione di tutte le chiavi e i valori in HKLM\Software\Microsoft\Command Processor.	Le regole in diversi componenti non hanno effetti reciproci, ad eccezione della regola <unconditionalExclude>. In questo esempio, quindi, gli oggetti che sono stati esclusi durante l'elaborazione di Componente 1 sono stati inclusi durante l'elaborazione di Componente 2.

Collisioni di file

Qual è il comportamento predefinito quando si verificano collisioni di file?

Se non è presente una regola <merge>, il comportamento predefinito per il Registro di sistema è che l'origine sovrascrive la destinazione. Il comportamento predefinito per i file è che l'origine viene rinominata in modo incrementale: ad esempio NomeFileOriginale(1).EstensioneOriginale, NomeFileOriginale(2).EstensioneOriginale e così via.

Come funziona la regola <merge> quando si verificano collisioni di file?

Quando viene rilevata una collisione, USMT seleziona la regola <merge> più specifica e la applica per risolvere il conflitto. Se ad esempio sono presenti una regola <merge> per C:\* [*] impostata su sourcePriority() e un'altra regola <merge> per C:\sottocartella\* [*] impostata su destinationPriority(), USMT usa la regola destinationPriority() perché è più specifica.

Scenario di esempio

Il computer di origine contiene i file seguenti:

• C:\Data\SampleA.txt

• C:\Data\SampleB.txt

• C:\Data\Folder\SampleB.txt

Il computer di destinazione contiene i file seguenti:

• C:\Data\SampleB.txt

• C:\Data\Folder\SampleB.txt

È presente un file XML di destinazione contenente il codice seguente:

<include> 
   <objectSet> 
      <pattern type="File">c:\data\* [*]</pattern> 
   </objectSet> 
</include> 

Per questo esempio, la tabella seguente descrive il comportamento risultante se aggiungi il codice nella prima colonna del file XML personalizzato.

Se specifichi il codice seguente	Comportamento risultante
<merge script="MigXmlHelper.DestinationPriority()"> <objectSet> <pattern type="File">c:\data\* [*]</pattern> </objectSet> </merge>	Durante ScanState, tutti i file vengono aggiunti all'archivio. Durante LoadState, viene ripristinato solo C:\Data\SampleA.txt.
<merge script="MigXmlHelper.SourcePriority()"> <objectSet> <pattern type="File">c:\data\* [*]</pattern> </objectSet> </merge>	Durante ScanState, tutti i file vengono aggiunti all'archivio. Durante LoadState, vengono ripristinati tutti i file sovrascrivendo i file esistenti nel computer di destinazione.
<merge script="MigXmlHelper.SourcePriority()"> <objectSet> <pattern type="File">c:\data\ [*]</pattern> </objectSet> </merge>	Durante ScanState, tutti i file vengono aggiunti all'archivio. Durante LoadState, si verifica quanto segue: C:\Data\SampleA.txt viene ripristinato. C:\Data\SampleB.txt viene ripristinato sovrascrivendo il file esistente nel computer di destinazione. C:\Data\Folder\SampleB.txt non viene ripristinato.

Vedere anche

Altre risorse

Riferimento XML per USMT