SystemUpdateManager Classe

Definizione

Spazio dei nomi:

Windows.System.Update

SystemUpdateManager consente il controllo interattivo degli aggiornamenti di sistema.

public ref class SystemUpdateManager abstract sealed

/// [Windows.Foundation.Metadata.ContractVersion(Windows.System.SystemManagementContract, 393216)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class SystemUpdateManager final

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.System.SystemManagementContract), 393216)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public static class SystemUpdateManager

Public Class SystemUpdateManager

Ereditarietà

Object Platform::Object IInspectable SystemUpdateManager

Attributi

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisiti Windows

Famiglia di dispositivi	Windows 10, version 1809 (è stato introdotto in 10.0.17763.0)
API contract	Windows.System.SystemManagementContract (è stato introdotto in v6.0)

Esempio

Codice di esempio SystemUpdateManager

Commenti

Il processo di aggiornamento del sistema ha gli stati seguenti:

1. Rileva. Determinare se sono disponibili pacchetti di aggiornamento.
2. Eseguire il download. Scaricare i pacchetti di aggiornamento dal server.
3. Fase. Decomprimere i pacchetti di aggiornamento e eseguirne il commit in un secondo momento.
4. Attendere il riavvio nel sistema operativo di aggiornamento. Il sistema operativo di aggiornamento mostra gli ingranaggi su Windows 10 IoT Core mentre vengono eseguite le modifiche del sistema operativo.
5. Commit. Eseguire l'avvio nel sistema operativo di aggiornamento che mostra gli ingranaggi durante il commit delle modifiche all'aggiornamento del sistema.
6. Riavviare il sistema operativo principale aggiornato. A questo punto il processo di aggiornamento è stato completato.

L'installazione di un pacchetto di aggiornamento include la gestione temporanea del pacchetto di aggiornamento estraendo i file e le impostazioni in un'area di gestione temporanea e quindi eseguendo il commit delle modifiche in fase. Non è possibile eseguire il rollback dei pacchetti di aggiornamento in Windows 10 IoT Core dopo l'avvio della fase di commit. I pacchetti di aggiornamento non inviati che sono stati sottoposti a fasi possono essere eliminati se necessario annullando l'aggiornamento. Dopo l'avvio del processo di commit non può essere interrotto.

Il processo di aggiornamento automatico è controllato dai criteri. Un OEM può controllare i criteri tramite un gestore criteri come MDM o DUC(Device Update Center).

Le sessioni di processo di aggiornamento interattivo sono controllate dall'utente del dispositivo. I criteri che rinvierebbero il processo di aggiornamento automatico potrebbero essere sottoposti a override durante una sessione di processo di aggiornamento interattivo. Ad esempio, l'utente può eseguire l'analisi dei pacchetti di aggiornamento e scaricarli con una sessione di processo interattiva quando una sessione di processo di aggiornamento automatico potrebbe essere bloccata dall'esecuzione di queste azioni dai criteri correnti. Il processo di aggiornamento interattivo può anche eseguire la fase dei pacchetti di aggiornamento. I pacchetti di aggiornamento di gestione temporanea decomprime i pacchetti e preparano i file e le impostazioni nel pacchetto da eseguire il commit.

Dopo il download e la fase dei pacchetti di aggiornamento, il processo di aggiornamento interattivo può essere continuato dallo sviluppatore riavviando il sistema operativo di aggiornamento e eseguendo il commit dei pacchetti di aggiornamento. Il sistema operativo update è un sistema operativo molto piccolo che ha lo scopo unico di eseguire il commit dei pacchetti di aggiornamento. In Windows 10 IoT Core il sistema operativo di aggiornamento mostra una schermata con ingranaggi in movimento. Il riavvio del sistema operativo di aggiornamento può essere eseguito in risposta all'input utente o come parte della logica di business di un singolo dispositivo. RebootToCompleteInstall deve essere chiamato per procedere al sistema operativo di aggiornamento. L'attivazione e la disattivazione o l'uso di un'API alternativa per riavviare il dispositivo non avrà alcun effetto. In alternativa, lo sviluppatore può scegliere di attendere fino alla successiva finestra di riavvio del processo di aggiornamento automatico pianificato come configurata dai criteri correnti (ad esempio all'esterno delle ore attive).

Prima di installare

Prima di provare a usare l'API SystemUpdateManager , l'applicazione deve verificare che SystemManagementContract 6.0 sia presente.

if (!ApiInformation.IsApiContractPresent("Windows.System.SystemManagementContract", 6, 0))
{
    // SystemUpdateManager was first implemented in SystemManagementContract 6.0
    VisualStateManager.GoToState(this, "NotSupported", false);
    UpdateStateTextBlock.Text = "Windows.System.SystemManagementContract 6.0 not found";
}

Successivamente, l'applicazione deve assicurarsi che SystemUpdateManager sia supportato nella versione e nell'edizione corrente di Windows.

else if (!SystemUpdateManager.IsSupported())
{
    // The API must be supported by the current edition of Windows
    // This can also return false if the application doesn't have the systemManagement capability
    VisualStateManager.GoToState(this, "NotSupported", false);
    UpdateStateTextBlock.Text = "System Update not supported (or systemManagement capability missing)";
}

Visualizzazione dello stato di aggiornamento del sistema

Se il contratto è presente e l'API è supportata, registrare per le notifiche di modifica dello stato:

// Register for state change notifications
SystemUpdateManager.StateChanged += SystemUpdateManager_StateChanged;

private void SystemUpdateManager_StateChanged(object sender, object args)
{
    var action = _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
        UpdateVisualState();
    });
}

Inizializzare l'interfaccia utente:

// Display update information
UpdateStateTextBlock.Text = GetResourceString(SystemUpdateManager.State.ToString());
LastChecked.Text = SystemUpdateManager.LastUpdateCheckTime.ToString("G");
LastInstalled.Text = SystemUpdateManager.LastUpdateInstallTime.ToString("G");

// Attach ViewModel to ListView
UpdateItemsListView.ItemsSource = _items;

// Initialize the visual state
UpdateVisualState();
UpdateFlightRing();

BlockAutoReboot.IsOn = IsAutomaticRebootBlockOn();

La funzione di codice di esempio UpdateVisualState esegue le operazioni seguenti:

1. Aggiornamenti il campo stato.
2. Aggiornamenti l'ultima ora di controllo dell'aggiornamento.
3. Aggiornamenti lo stato di VisualStateManager.
4. Aggiornamenti barre di stato per gli stati con stato di avanzamento.
5. Aggiornamenti lo stato dell'elemento di aggiornamento.

Ecco il codice:

private void UpdateVisualState()
{
    // Update the state text
    UpdateStateTextBlock.Text = GetResourceString(SystemUpdateManager.State.ToString());

    // Update the last update check time
    LastChecked.Text = SystemUpdateManager.LastUpdateCheckTime.ToString("G");

    // Change the VisualStateManager state based on the current SystemUpdateManagerState
    var state = SystemUpdateManager.State;
    Debug.WriteLine($"State={state}");
    switch (state)
    {
        case SystemUpdateManagerState.Idle:
        case SystemUpdateManagerState.Detecting:
        case SystemUpdateManagerState.Downloading:
        case SystemUpdateManagerState.Installing:
        case SystemUpdateManagerState.RebootRequired:
            VisualStateManager.GoToState(this, SystemUpdateManager.State.ToString(), false);
            break;

        case SystemUpdateManagerState.AttentionRequired:
            AttentionRequiredTextBlock.Text = GetResourceString(SystemUpdateManager.AttentionRequiredReason.ToString());
            VisualStateManager.GoToState(this, "AttentionRequired", false);
            break;

        default:
            VisualStateManager.GoToState(this, "UnknownState", false);
            break;
    }

    // Update progress for states with progress
    switch (SystemUpdateManager.State)
    {
        case SystemUpdateManagerState.Downloading:
            Debug.WriteLine($"Downloading={SystemUpdateManager.DownloadProgress}");
            SessionDownloadProgressBar.Value = SystemUpdateManager.DownloadProgress;
            break;
        case SystemUpdateManagerState.Installing:
            Debug.WriteLine($"Installing={SystemUpdateManager.InstallProgress}");
            SessionDownloadProgressBar.Value = SystemUpdateManager.DownloadProgress;
            SessionInstallProgressBar.Value = SystemUpdateManager.InstallProgress;
            break;
    }

    // Update progress items
    switch (SystemUpdateManager.State)
    {
        case SystemUpdateManagerState.Downloading:
        case SystemUpdateManagerState.Installing:
            foreach (var updateItem in SystemUpdateManager.GetUpdateItems())
            {
                var viewModelItem = _items.Where(x => x.Id == updateItem.Id).FirstOrDefault();
                if (viewModelItem != null)
                {
                    viewModelItem.Update(updateItem);
                }
                else
                {
                    _items.Add(new UpdateItemViewModel(updateItem));
                }
            }
            break;
    }
}

Installare gli aggiornamenti di sistema

Se il proprietario del dispositivo dispone di criteri di processo di aggiornamento automatici configurati in modo che controllino quando si avviano i download oppure si sceglie di consentire ai clienti di avviare il processo di aggiornamento in modo interattivo, chiamare SystemUpdateManager.StartInstall verificherà la presenza di pacchetti di aggiornamento e scaricare i pacchetti di aggiornamento se presenti. Si tratta di un metodo fire-and-forget che viene eseguito in modo asincrono, ma restituisce immediatamente.

Lo stato del processo di aggiornamento può essere monitorato tramite l'evento StateChanged e la proprietà State . Se un download è già in corso, la chiamata restituisce immediatamente senza errore. Se l'attenzione dell'utente è necessaria per continuare lo stato viene impostata su AttentionRequired e viene impostata l'opzione AttentionRequiredReason. Se si verifica un errore non recuperabile lo stato è impostato su ExtendedError e la proprietà ExtendedError è impostata.

Per iniziare un aggiornamento, chiamare SystemUpdateManager.StartInstall. Se il parametro è SystemUpdateStartInstallAction.UpToReboot , l'installazione procederà fino a quando non è necessario un riavvio. Se il parametro è SystemUpdateStartInstallAction.AllowReboot , l'installazione procederà e riavvia non appena è consentita dai criteri.

private void CheckForUpdates_Click(object sender, RoutedEventArgs e)
{
    if (SystemUpdateManager.State == SystemUpdateManagerState.Idle)
    {
        SystemUpdateManager.StartInstall(SystemUpdateStartInstallAction.UpToReboot);
    }
}

Per eseguire il commit di un'installazione dell'aggiornamento di sistema, a volte è necessario un riavvio. In questo caso SystemUpdateManager.State sarà uguale a SystemUpdateManagerState.RebootRequired. Si noti che un normale riavvio non funzionerà per finalizzare le modifiche in questo stato. È necessario chiamare SystemUpdateManager.RebootToCompleteInstall o attendere che il riavvio pianificato venga eseguito automaticamente durante le finestre di aggiornamento del sistema (all'esterno dell'orario di attività dell'utente).

private void RebootNow_Click(object sender, RoutedEventArgs e)
{
    if (SystemUpdateManager.State == SystemUpdateManagerState.RebootRequired)
    {
        SystemUpdateManager.RebootToCompleteInstall();
    }
}

Gestire le ore attive dell'utente:

private void ChangeActiveHours_Click(object sender, RoutedEventArgs e)
{
    StartTime.Time = SystemUpdateManager.UserActiveHoursStart;
    EndTime.Time = SystemUpdateManager.UserActiveHoursEnd;
    ActiveHoursErrorText.Visibility = Visibility.Collapsed;
    ActiveHoursPopup.IsOpen = true;
}

private void SaveActiveHours_Click(object sender, RoutedEventArgs e)
{
    bool succeeded = SystemUpdateManager.TrySetUserActiveHours(StartTime.Time, EndTime.Time);
    if (succeeded)
    {
        ActiveHoursPopup.IsOpen = false;
    }
    else
    {
        // Active hours not set display error message
        string format = GetResourceString("ActiveHoursErrorFormat");
        ActiveHoursErrorText.Text = String.Format(format, SystemUpdateManager.UserActiveHoursMax);
        ActiveHoursErrorText.Visibility = Visibility.Visible;
    }
}

Ottenere l'ultimo errore di aggiornamento del sistema

Se si verifica un errore durante l'installazione di un aggiornamento di sistema, systemUpdateManager.LastErrorInfo verrà impostato. Ecco un esempio di visualizzazione delle ultime informazioni sull'errore:

var info = SystemUpdateManager.LastErrorInfo;
if (SystemUpdateManager.LastErrorInfo.ExtendedError == null)
{
    NoErrorText.Visibility = Visibility.Visible;
    LastErrorInfoPanel.Visibility = Visibility.Collapsed;
}
else
{
    NoErrorText.Visibility = Visibility.Collapsed;
    LastErrorInfoPanel.Visibility = Visibility.Visible;
    ErrorStateTextBlock.Text = GetResourceString(info.State.ToString());
    HResultTextBlock.Text = (info.ExtendedError == null) ? "No Error Data" : info.ExtendedError.Message;
    IsInteractiveTextBlock.Text = GetResourceString(info.IsInteractive ? "Yes" : "No");
}

Anello di volo dell'aggiornamento del sistema

L'anello di volo può essere vuoto, Canary, Selfhost o definito dall'utente. Se il valore è vuoto, 'Nessuna' è selezionata nell'interfaccia utente. In caso contrario, se non è Canary o Selfhost, si supponga che l'anello sia definito dall'utente e salvarlo nell'elenco dell'interfaccia utente.

private void UpdateFlightRing()
{
    var ring = Windows.System.Update.SystemUpdateManager.GetFlightRing();
    for (int i = 0; i < FlightRingCombo.Items.Count(); i++)
    {
        if (ring == FlightRingCombo.Items[i] as string)
        {
            FlightRingCombo.SelectedIndex = i;
            return;
        }
    }

    // if the current ring is non-empty and is not in the list save it to the list
    if (!String.IsNullOrEmpty(ring))
    {
        int index = FlightRingCombo.Items.Count;
        FlightRingCombo.Items.Insert(index, ring);
        FlightRingCombo.SelectedIndex = index;
        return;
    }

    FlightRingCombo.SelectedIndex = 0;
}

private void FlightRingCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    var oldRing = SystemUpdateManager.GetFlightRing();
    var newRing = e.AddedItems[0].ToString();
    Debug.WriteLine($"newRing={newRing} oldRing={oldRing}");

    if (oldRing != newRing)
    {
        if (newRing == "None")
        {
            // only set if previous ring was not null or empty
            if (!String.IsNullOrEmpty(oldRing))
            {
                Windows.System.Update.SystemUpdateManager.SetFlightRing(String.Empty);
            }
        }
        else
        {
            Windows.System.Update.SystemUpdateManager.SetFlightRing(newRing);
        }
    }
}

Bloccare i riavvii automatici

Per indicare al servizio di aggiornamento che gli aggiornamenti di sistema non sono consentiti, chiamare SystemUpdateManager.UnblockAutomaticRebootAsync(id) dove ID è una stringa univoca composta da numeri, lettere e trattini. Al termine dell'esecuzione del codice critico, il codice deve chiamare SystemUpdateManager.UnblockAutomaticRebootAsync per ogni ID passato in BlockAutomaticRebootAsync

if (BlockAutoReboot.IsOn)
{
    await SystemUpdateManager.BlockAutomaticRebootAsync(Guid.NewGuid().ToString());
}
else
{
    var ids = SystemUpdateManager.GetAutomaticRebootBlockIds();
    foreach(var id in ids)
    {
        bool unblocked = await SystemUpdateManager.UnblockAutomaticRebootAsync(id);
    }
}

L'applicazione deve dichiarare la funzionalità systemManagement. Supportato solo in Windows 10 IoT Core.

Proprietà

AttentionRequiredReason	Motivo per cui è necessaria l'attenzione dell'utente.
DownloadProgress	Scarica percentuale di avanzamento.
ExtendedError	Informazioni sull'errore estese se disponibili.
InstallProgress	Percentuale di stato di installazione.
LastErrorInfo	Informazioni sull'ultimo aggiornamento del sistema non riuscito.
LastUpdateCheckTime	Ora dell'ultima verifica per gli aggiornamenti.
LastUpdateInstallTime	Ora dell'ultima installazione dell'aggiornamento.
State	Stato corrente di SystemUpdateManager.
UserActiveHoursEnd	Ottiene il valore dell'ora di fine ore attive dell'utente.
UserActiveHoursMax	Ottiene l'intervallo massimo consentito tra UserActiveHoursStart e UserActiveHoursEnd in ore.
UserActiveHoursStart	Ottiene il valore dell'ora di inizio ore attive dell'utente.

Metodi

BlockAutomaticRebootAsync(String)	Blocca i riavvii automatici per l'aggiornamento fino a quando non viene chiamato UnblockAutomaticRebootAsync o fino a quando il riavvio non viene applicato dai criteri di sistema.
GetAutomaticRebootBlockIds()	Ottenere gli ID delle richieste di blocco di riavvio automatico.
GetFlightRing()	Ottenere l'anello di volo.
GetUpdateItems()	Ottenere l'elenco degli elementi di aggiornamento in sospeso.
IsSupported()	Indica se questa API è supportata in questo dispositivo.
RebootToCompleteInstall()	Riavvia il dispositivo per completare l'installazione, se è necessario un riavvio.
SetFlightRing(String)	Imposta l'anello di volo.
StartCancelUpdates()	Iniziare a annullare gli aggiornamenti se gli aggiornamenti sono in corso.
StartInstall(SystemUpdateStartInstallAction)	Avviare il rilevamento, il download e l'installazione degli aggiornamenti in sospeso.
TrySetUserActiveHours(TimeSpan, TimeSpan)	Provare a impostare l'orario di attività definito dall'utente durante il quale i riavvii automatici per l'aggiornamento non saranno consentiti.
UnblockAutomaticRebootAsync(String)	Sbloccare i riavvii automatici degli aggiornamenti, se bloccato.

Eventi

StateChanged

Evento di notifica delle modifiche delle proprietà di stato.