Dicembre 2016

Volume 31 Numero 13

Il presente articolo è stato tradotto automaticamente.

Piattaforma UWP (Universal Windows Platform) - Monitoraggio del file system nelle app UWP (Universal Windows Platform)

Da Adam Wilson | Dicembre 2016

Il file system di un dispositivo Windows cambiano rapidamente. Raccolte condivise, ad esempio la fotocamera, uno dei pochi posti in cui tutti i processi sul dispositivo contemporaneamente possono interagire con gli stessi dati. Creazione di un'applicazione universale Windows piattaforma UWP () che fornisce una straordinaria esperienza con le foto dell'utente significa che si intende disporre approfondirò deep questo chaos.

In Windows 10 anniversario Update, Microsoft ha aggiunto nuove funzionalità per gestire il caos più semplice. Il sistema è in grado di fornire un elenco di tutte le modifiche che si verificano in una libreria, da una foto fino a intere cartelle da eliminare. Si tratta di enorme aiuto se chi desidera compilare un provider di cloud di backup, tenere traccia dei file spostati spegnere il dispositivo o anche solo visualizzare le foto più recente.

Visualizzare le foto più recenti eseguite da un dispositivo non è solo per gli sviluppatori che desiderano creare Instagram successivo. Recentemente ho avuto il piacere di lavorare con partner aziendali, così come sono compilati ispezione App per le organizzazioni. Le applicazioni seguono un modello simile: Un controllo visita un sito con un Tablet PC Windows o phone, compila in un report con alcune informazioni sul sito accetta le immagini del sito utilizzando il dispositivo e, infine, consente di caricare il report in un server protetto. Per tutte le società, è fondamentale che i report vengono caricate le foto corrette, non modificate.

Tramite le pagine successive verrà illustrata in dettaglio la creazione di un'applicazione di controllo dell'organizzazione. Lungo il percorso verrà sottolineare alcuni problemi particolarmente difficili da raggiungere che è verificato durante il processo di sviluppo e si noti come è possibile evitare in app. Queste lezioni inoltre è possono applicare a qualsiasi altra app che esegue la ricerca per rilevare le modifiche nel file system, ad esempio un servizio di backup del cloud, ma poiché le applicazioni di ispezione sono piuttosto comuni, inizierà esiste ed è possibile modificare il codice per qualsiasi tipo di applicazione che si sta creando.

Controlli: Tutti gli utenti viene loro

Tra le aziende di tutti i settori e dimensioni, è comune una cosa: Sono disponibili controlli supervisione i processi aziendali critici. Da società di produzione massive verifica lo stato della propria apparecchiatura ai rivenditori assicurando che visualizza viene assemblati in modo corretto, le aziende dipendono effettua che tutto vengono eseguite in modo sicuro e in modo coerente in tutti i siti.

Se si desidera supportare in questo caso il processo di base è piuttosto semplice:

1. Un controllo Crea una nuova istanza di report per il sito del suo Tablet PC.
2. Il controllo accetta le immagini del sito per un report.
3. Le immagini vengono caricate in un server protetto insieme al report.

Nel passaggio 2, tuttavia, una serie di operazioni può andare storto:

• Il controllo può scegliere le immagini errate collegamento al report.
• Un'immagine può essere modificata per mostrare informazioni non corrette.
• Un'immagine potrebbe essere accidentalmente eliminati prima che il report viene caricato, ma dopo che il controllo esce da un percorso.

In uno di questi casi, il report si potrebbe non essere valido e richiedono il controllo ripetere l'ispezione, un costo aggiuntivo per l'azienda. Per fortuna, con le nuove API di rilevamento delle modifiche in Windows 10 ricorrenza annuale dell'aggiornamento, esiste un modo semplice per evitare tali errori e consentire agli utenti di completare le attività in modo rapido e accurato.

Nozioni di base: Ottenere l'accesso alle immagini dalla fotocamera

Il primo passaggio consiste nella verifica che l'applicazione ha accesso alle immagini provenienti dalla fotocamera. In Windows, la fotocamera del sistema verrà scritto nella cartella rullino, che è una sottocartella della libreria di immagini. È possibile (and ha infatti) scrivere un intero articolo su come accedere alla libreria di immagini (bit.ly/2dCdj4O), ma Ecco le nozioni di base:

• Dichiarare l'intenzione di accedere alla libreria di immagini nel manifesto (bit.ly/2dqoRJX) aggiungendo il nome funzionalità = "musicLibrary" / > nell'editor del manifesto o selezionando la casella di raccolta immagini scheda delle funzionalità nella procedura guidata.
• Ottenere un StorageFolder che rappresenta la posizione in cui le immagini dalla fotocamera vengono scritte utilizzando KnownFolders.CameraRoll (bit.ly/2dEiVMS).
• Ottenere un oggetto che rappresenta l'intera libreria di immagini mediante StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures) (bit.ly/2dmZ85X).

Non preoccuparsi se il dispositivo dispone di una scheda SD e un'impostazione utente per la scrittura di nuove immagini per l'archiviazione interna o la scheda SD. La classe Cartellanota che sottraggono automaticamente e offrono una cartella virtuale che include tutte le posizioni in cui la fotocamera può scrivere un file.

Ricevere notifiche quando vengono apportate modifiche

Dopo aver ottenuto l'accesso ai file, è necessario avviare il rilevamento delle modifiche. Consigliabile effettuare questa scelta non appena possibile. In un mondo perfetto, ispettori sempre creerebbe un nuovo report prima che vengano avviati scattare foto, ma in realtà cui ha preso in genere alcune immagini prima apprese creare un nuovo report.

Configurazione di notifiche e il rilevamento delle modifiche prevede tre passaggi:

1. Inizializzazione in corso il rilevamento delle modifiche, che consente al sistema le librerie si è interessati a rilevamento. Il monitoraggio continuerà anche quando l'applicazione non è in esecuzione e l'applicazione può leggere l'elenco di modifiche in qualsiasi momento.
2. Registrazione per le notifiche di modifica in background, che attiverà attività in background dell'applicazione ogni volta che viene apportata una modifica in una libreria, è in esecuzione o meno.
3. Registrazione per le notifiche di modifica in primo piano. Se l'applicazione è in primo piano, è possibile registrare per altri eventi ogni volta che un file viene modificato in un determinato ambito.

Si noti che i passaggi 2 e 3 potrebbero potenzialmente si sovrappongono. Parleremo di come configurare entrambi i tipi di notifiche in questo articolo, ma il grafico in figura 1 consentono di scegliere quali si desidera utilizzare nell'applicazione. La raccomandazione generale consiste nell'utilizzare sempre le notifiche di modifica dello sfondo con StorageLibraryContentChangeTrigger e utilizzare gli eventi di primo piano se si dispone di una specifica esigenza dell'interfaccia Utente, ad esempio la visualizzazione di una visualizzazione del file system per gli utenti.

Figura 1 tipi di notifiche di modifica

Il StorageLibraryChangeTracker è una nuova classe aggiunta nell'aggiornamento anniversario (bit.ly/2dMFlfu). Consente alle applicazioni di sottoscrivere un elenco di modifiche che avvengono in una libreria. Il sistema controlla tutti i file nella libreria e crea un elenco delle modifiche che si verificano a essi. App può richiedere l'elenco di modifiche ed elaborarli nel tempo libero.

StorageLibraryChangeTracker è molto simile per il journal delle modifiche NTFS, se è mai lavorato con quello, ma funziona su unità FAT, nonché. Per ulteriori informazioni è possibile leggere la discussione approfondita sul mio blog (bit.ly/2dQ6MEK).

Inizializzazione di StorageLibraryChangeTracker è piuttosto semplice, ovvero appena l'istanza di specifiche della raccolta del rilevamento delle modifiche e chiamare attiva:

StorageLibrary picsLib =
  await StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures);
picsLib.ChangeTracker.Enable();

A questo punto, il rilevamento delle modifiche manterrà un elenco di tutte le modifiche alla libreria. A questo punto è importante verificare l'applicazione riceve la notifica a ogni modifica.

Ascoltare le notifiche di primo piano

Per restare in attesa delle notifiche di primo piano che l'applicazione deve creare, eseguire e mantenere aperta una query sulla posizione problema cui le modifiche. Creazione e l'esecuzione della query indica al sistema i percorsi sono interessanti per l'applicazione. Che contiene un riferimento ai risultati della query in un secondo momento indica che l'applicazione desidera ricevere una notifica quando vengono apportate modifiche:

StorageFolder photos = KnownFolders.CameraRoll;
// Create a query containing all the files your app will be tracking
QueryOptions option = new QueryOptions(CommonFileQuery.DefaultQuery,
  supportedExtentions);
option.FolderDepth = FolderDepth.Shallow;
// This is important because you are going to use indexer for notifications
option.IndexerOption = IndexerOption.UseIndexerWhenAvailable;
StorageFileQueryResult resultSet =
  photos.CreateFileQueryWithOptions(option);
// Indicate to the system the app is ready to change track
await resultSet.GetFilesAsync(0, 1);
// Attach an event handler for when something changes on the system
resultSet.ContentsChanged += resultSet_ContentsChanged;

Come si può vedere, utilizzo un paio di interessanti ottimizzazioni che potrebbero essere utili per l'applicazione:

• CommonFileQuery.DefaultQuery rende l'intera operazione molto più veloce in casi in cui l'indicizzatore non è disponibile. Se viene utilizzato un altro criterio di ordinamento e l'indicizzatore non è disponibile, il sistema deve esaminare lo spazio dell'intera query prima di restituire il primo risultato.
• La query è un duplicato superficiale. Questo procedimento funziona perché la fotocamera verrà sempre scritto nella radice del rullino della fotocamera ed evitare una query completa riduce al minimo il numero di file, che il sistema deve tenere traccia delle modifiche.
• Utilizzare l'indicizzatore non è obbligatorio, ma rende più notifiche nell'app. Senza l'indicizzatore, le notifiche possono richiedere fino a 30 secondi per raggiungere l'app.
• L'esecuzione di query per un file è il modo più rapido per iniziare a tenere traccia delle modifiche in una posizione indicizzata, se è possibile eseguire una query per più file nel caso in cui l'interfaccia Utente necessari.

Ora ogni volta che viene modificato un elemento nella query, il gestore dell'evento verrà attivato, offrendo la possibilità di elaborare la modifica dell'app.

La registrazione per il Trigger di modifica dello sfondo

Non tutte le modifiche verranno verificarsi durante l'applicazione è in primo piano e anche se l'applicazione è in primo piano potrebbe non essere la granularità delle notifiche di primo piano. StorageLibraryContentsChangedTrigger è un ottimo modo per ricevere una notifica quando si modifica in una libreria. Poiché si registra un'attività in background utilizzando il processo standard (bit.ly/2dqKt9i), mi porto attraverso di esso rapidamente (vedere figura 2).

Figura 2, la registrazione di un'attività in Background

// Check if your app has access to the background
var requestStatus = await BackgroundExecutionManager.RequestAccessAsync();
if (!(requestStatus ==
  BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity ||
  requestStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy ||
  requestStatus ==
    BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity ||
  requestStatus == BackgroundAccessStatus.AlwaysAllowed))
{
  log("Failed to get access to the background");
  return;
}
// Build up the trigger to fire when something changes in the pictures library
var builder = new BackgroundTaskBuilder();
builder.Name = "Photo Change Trigger";
StorageLibrary picturesLib =
  await StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures);
var picturesTrigger = StorageLibraryContentChangedTrigger.Create(picturesLib);
// We are registering to be activated in OnBackgroundActivated instead of
// BackgroundTask.Run; either works, but I prefer the single-process model
builder.SetTrigger(picturesTrigger);
BackgroundTaskRegistration task = builder.Register();

Esistono un paio di aspetti importanti da notare nell'esempio in figura 2.

È possibile utilizzare ancora il vecchio modello di processo a due per registrare l'attività in background, ma il modello di processo singolo che è stato aggiunto nell'aggiornamento anniversario attentamente. In quanto rapidamente ha me quanto sia semplice da utilizzare e come è facile per ricevere i trigger in background mentre l'app è in primo piano.

StorageLibraryContentChangedTrigger verrà generato per tutte le modifiche nella raccolta immagini, che possono includere i file che non sono interessanti per l'applicazione. Mi occuperò come filtrare quelli in una sezione successiva, ma è sempre importante da tenere presente che a volte ci sarà nessuna operazione da eseguire quando viene attivata l'applicazione.

È importante controllare l'attività in background, se si esegue in background o in primo piano poiché le allocazioni di risorse sono diverse. Sono disponibili ulteriori dettagli sul modello di allocazione di risorse in bit.ly/2cNvcSr. 

Lettura delle modifiche

Ora l'applicazione sta per essere abbia la possibilità di eseguire codice ogni volta che si apportano modifiche nel rullino, uno in primo piano o in background. Per scoprire cosa è cambiato, è necessario leggere il set di modifiche da StorageLibraryChangeTracker. Il primo passaggio consiste nell'eseguire un oggetto lettore, che consente di enumerare le modifiche che si sono verificati dall'ultima volta che l'applicazione selezionata. Mentre ci siete, è anche possibile acquisire il primo batch di modifiche da elaborare:

StorageLibrary picturesLib =
  await StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures);           
StorageLibraryChangeTracker picturesTracker= picturesLib.ChangeTracker;
picturesTracker.Enable();
StorageLibraryChangeReader changeReader = picturesTracker.GetChangeReader();
IReadOnlyList<StorageLibraryChange> changes = await changeReader.ReadBatchAsync();

Dopo aver ottenuto un insieme di modifiche, è necessario elaborarli. In questa applicazione, I questo articolo ci concentreremo solo su immagini da modificare e ignorare tutte le altre modifiche di file e cartelle. Se si è interessati in altri tipi di modifiche nel sistema, l'approfondimento sul rilevamento delle modifiche con i dettagli su tutti i tipi diversi di modifiche (bit.ly/2dQ6MEK).

Se si desidera esaminare le modifiche ed estrarre quelli in cui sono interessato. Per questa applicazione, sta per essere qualsiasi modifica apportata al contenuto di un file con estensione jpg, come illustrato nella figura 3.

Figura 3 verifica le modifiche ai file

foreach (StorageLibraryChange change in changes)
{
  if (change.ChangeType == StorageLibraryChangeType.ChangeTrackingLost)
  {
    // Change tracker is in an invalid state and must be reset
    // This should be a very rare case, but must be handled
    picturesLib.ChangeTracker.Reset();
    return;
  }
  if (change.IsOfType(StorageItemTypes.File))
  {
    await ProcessFileChange(change);
  }
  else if (change.IsOfType(StorageItemTypes.Folder))
  {
    // No-op; not interested in folders
  }
  else
  {
    if (change.ChangeType == StorageLibraryChangeType.Deleted)
    {
      UnknownItemRemoved(change.Path);
    }
  }
}
// Mark that all the changes have been seen and for the change tracker
// to never return these changes again
await changeReader.AcceptChangesAsync();

Ecco alcuni interessanti aspetti il frammento di codice in figura 3.

La prima cosa da che fare è controllare StorageLibraryChangeType.ChangeTrackingLost. Questo errore dovrebbe verificarsi solo dopo un'operazione di sistema di file di grandi dimensioni (in cui il sistema non dispone di spazio di archiviazione sufficiente per l'intero set di modifiche) o nel caso di un errore interno critico. In entrambi i casi, un valore letto dal rilevamento delle modifiche non può più essere attendibile. L'applicazione è necessario reimpostare il rilevamento delle modifiche per i futuri risultati attendibili.

UnknownItemRemoved (modifica. Percorso) verrà raggiunti ogni volta che un file o cartella viene eliminata da una partizione FAT, ad esempio una scheda SD. Una volta eliminato un elemento da una partizione FAT, che il sistema non consente di stabilire se si tratta di una directory o un file che è stato eliminato. Se si desidera esaminare codice in un po' che mostra come è possibile scoprire cosa sia accaduto nell'app.

Quando sono state elaborate tutte le modifiche, chiamare changeReader.AcceptChangesAsync. In questo modo il rilevamento delle modifiche che l'applicazione ha gestito tutte le modifiche e non è necessario leggere le descrizioni. Alla successiva che creazione di un StorageLibraryChangeReader conterrà solo le modifiche che si sono verificati dopo questo punto. Non chiamare AcceptChangesAsync causerà il buffer modifiche interna da riempire e di overflow, risultante in StorageLibraryChangeType.ChangeTrackingLost.

Gestione delle modifiche

Dopo aver appreso come esaminare le modifiche, il passaggio successivo consiste in evidenza il metodo ProcessFileChange. Un concetto chiave da ricordare è che l'apertura di file (mediante la creazione di oggetti StorageFile) è molto costosa. Per ottenere un oggetto StorageFile del processo, il sistema deve eseguire una chiamata tra processi per controllare le autorizzazioni, creare un handle al file, leggere alcuni metadati relativi al file dal disco e quindi effettuare il marshalling dell'handle e i metadati al processo dell'applicazione. Pertanto, si desidera ridurre al minimo il numero di StorageFiles si crea, soprattutto se non si desidera aprire i flussi di file.

Il rilevamento delle modifiche fornisce app con i percorsi e il tipo di modifica per determinare se un file è di tipo app è interessato a prima di creare il StorageFile. Iniziamo eseguendo più filtri con queste informazioni prima di creare StorageFile, come illustrato nella figura 4.

Figura 4 l'elaborazione modifiche

private async Task ProcessFileChange(StorageLibraryChange change)
{
  // Temp variable used for instantiating StorageFiles for sorting if needed later
  StorageFile newFile = null;
  switch (change.ChangeType)
  {
    // New File in the Library
    case StorageLibraryChangeType.Created:
    case StorageLibraryChangeType.MovedIntoLibrary:
    case StorageLibraryChangeType.MovedOrRenamed:
      if (change.Path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase))
      {
        StorageFile image = (StorageFile)(await change.GetStorageItemAsync());
        AddImageToReport(image);                                               
      }                   
      break;
    // File Removed From Library
    case StorageLibraryChangeType.Deleted:
    case StorageLibraryChangeType.MovedOutOfLibrary:
      if (change.Path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase))
      {
        var args = new FileDeletedWarningEventArgs();
        args.Path = change.Path;
        FileDeletedWarningEvent(this, args);
      }
      break;
    // Modified Contents
    case StorageLibraryChangeType.ContentsChanged:
      if (change.Path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase))
      {
        newFile = (StorageFile)(await change.GetStorageItemAsync());
        var imageProps = await newFile.Properties.GetImagePropertiesAsync();
        DateTimeOffset dateTaken = imageProps.DateTaken;
        DateTimeOffset dateModified = newFile.DateCreated;
        if (DateTimeOffset.Compare(dateTaken.AddSeconds(70), dateModified) > 0)
        {
          // File was modified by the user
          log("File path: " + newFile.Path + " was modified after being taken");
        }
      }                  
      break;
    // Ignored Cases
    case StorageLibraryChangeType.EncryptionChanged:
    case StorageLibraryChangeType.ContentsReplaced:
    case StorageLibraryChangeType.IndexingStatusChanged:
    default:
      // These are safe to ignore in this application
      break;                   
  }
}

Si è specificato in questo esempio esaminando ognuna delle istruzioni case.

Nuovo File nella libreria: Nella prima istruzione che si sta cercando nuovi file che sono state aggiunte alla libreria. Nel caso la fotocamera del sistema, il file dovrà essere creati nella raccolta e noterà una modifica del tipo StorageLibraryChangeType.Created. Alcune applicazioni di terze parti creare effettivamente l'immagine nel relativo contenitore di dati dell'applicazione e spostarlo nella libreria, in modo che intendo trattare StorageLibraryChangeType.MovedIntoLibrary come la creazione di un tipo, troppo.

Devo processo StorageLibraryChangeType.MovedOrRenamed come nuovo file. Si tratta di risolvere una stranezza della videocamera incorporata in Windows phone. Quando la fotocamera acquisisce un'immagine, scrive un file temporaneo con estensione jpg finale. ~ tmp. In un secondo momento completerà l'immagine, rimuovendo il. ~ estensione tmp. Se l'applicazione è sufficientemente rapido individuare il file prima che venga eseguita la fotocamera finalizzazione dell'immagine, è possibile che venga visualizzato un evento di ridenominazione anziché l'evento di creazione.

Poiché questa applicazione sta per essere interessati solo le immagini create dall'utente, filtreranno verso il basso solo i file con estensione. jpg. È possibile farlo creando un StorageFile e controllando la proprietà ContentType, ma si vuole evitare di creare StorageFiles non necessari. Una volta determinato che un file viene che mi interessano, mi occuperò per il file a un altro metodo per eseguire alcune operazioni di elaborazione dati.

Utilizzo di un cast qui anziché come parola chiave perché ho già chiesto StorageLibraryChange il tipo di oggetto StorageItem utilizzerà: StorageLibraryChange.IsOfType(StorageItemTypes.File).

File rimosso dalla raccolta: Nel secondo caso, l'applicazione esegue la ricerca in situazioni in cui un file è stato rimosso dalla libreria. Si noterà che sono raggruppati due tipi di modifica diversi nuovamente. StorageLibraryChangeType.Deleted viene generato ogni volta che un file viene eliminato definitivamente dal disco, ovvero il tipico caso di eliminazione tramite l'API del file system. Tuttavia, se invece l'utente elimina manualmente il file da Esplora File, il file verrà inviato al Cestino. Viene illustrato come StorageLibraryChangeType.MovedOutOfLibrary perché il file è ancora residente su disco.

In questo caso, verrà generato un avviso per il controllo che il file venga rimossa, nel caso in cui era un'eliminazione accidentale. In altre applicazioni attento alla sicurezza, potrebbe essere utile memorizzare file eliminazioni o modifiche per il controllo in un secondo momento in caso di un'indagine.

Modifica contenuto: il contenuto di un file è stato modificato è un caso interessano per questa applicazione. Poiché questa applicazione può essere utilizzata per i controlli di sicurezza, non si desidera consentire agli utenti di modificare le immagini prima di essere state caricate al report, sebbene possano esistere motivi validi per il contenuto di un'immagine per essere modificato dopo che viene eseguita un'immagine.

È possibile visualizzare una notifica di tipo StorageLibraryChangeType.ContentsChanged generati circa tre per 60 secondi dopo un'immagine viene eseguita con la fotocamera. Infatti, talvolta può richiedere fino a un minuto per ottenere le coordinate dal sistema GPS. In questa app non sono interessato informazioni GPS pertanto è l'elaborazione del file sin da subito. In alcune applicazioni potrebbe essere utile per verificare se sono stati scritti i dati del percorso del file e in caso contrario, attendere che il percorso viene determinato.

In questo caso, mi occuperò di intermedie molto sicuro. Se un file viene modificato più di 70 secondi dopo che è stato eseguito, presupporrà che è stato modificato dall'utente e la disconnessione un problema di conformità per analisi successive. Se è stato modificato all'interno della finestra di 70 secondo, presuppone che questa operazione è stata eseguita dal sistema quando si aggiungono i dati GPS e può essere tranquillamente ignorato.

Crittografia modificata: Se è necessario l'attenzione sul caso riguarda una domanda: L'organizzazione utilizza Windows informazioni protezione (WIP) con la crittografia per proteggere le informazioni riservate? In caso affermativo, questo tipo di modifica è un problema enorme. Significa che un utente ha modificato la protezione del file e il file potrebbe essere seduti sul disco non protetto. Attraverso le informazioni su come verificare se il file è protetto (e solo da spostare a un altro livello di protezione) WIP esula dall'ambito di questo articolo. Se si distribuisce WIP nell'organizzazione, è importante che consente di monitorare questo tipo di modifica.

Per coloro che non utilizzano WIP o la crittografia per proteggere le risorse aziendali sensibili, consiglio vivamente esaminare, ma per ora è possibile ignorare questa modifica.

Ignorato casi: Infine, in questa applicazione è opportuno ignorare alcune operazioni che la causa del problema nel file system. StorageLibraryChangeType.IndexingStatusChanged è rilevante solo nel caso di applicazioni desktop che sta per eseguire query ripetute della libreria e prevede gli stessi risultati ogni volta. StorageLibraryChangeType.ContentsReplaced indica che un collegamento fisso per il file è stato modificato, che non è interessante per questa applicazione.

Rileva l'eliminazione di un'immagine su una scheda SD

Come ricorderete, il sistema non può determinare se un elemento rimosso è un file o cartella dopo che è stato eliminato nel file system FAT unità, ad esempio una scheda SD. Codice di ordinamento speciale in questo modo, è necessario se ci si preoccupa eliminazioni in unità FAT. Per l'applicazione, si desidera sapere se le immagini vengano eliminate dalla scheda SD, che rende il codice di un'operazione estremamente semplice:

private void UnknownItemRemoved(StorageLibraryChange change)
{
  if (change.Path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase))
  {
    var args = new FileDeletedWarningEventArgs();
    args.Path = change.Path;
    FileDeletedWarningEvent(this, args);
  }
}

Il codice semplicemente controlla se l'elemento utilizzato per avere un'estensione. jpg e in tal caso genera lo stesso evento dell'interfaccia Utente come in figura 4.

Considerazioni finali

Una volta il codice di base sul posto, esistono un paio di aspetti da considerare che consentono di assicurarsi che la nuova app verrà eseguito in modo uniforme possibile.

Provare a utilizzare la configurazione. Questa è la parte più importante di consulenza che posso dare è sulla creazione di un'applicazione che tiene traccia delle modifiche al file system. Scrivere un'app rapida che registra ciò che accade nei dispositivi prima di entrare nel codice. Provare a numerosi componenti con la scrittura di file temporanei e il tentativo di eliminare rapidamente, ad esempio la fotocamera incorporata illustrato in precedenza. Ho anche visto casi in circostanze normali in cui App sono stati scrittura file incompleti, la chiusura dell'handle, quindi riaprire immediatamente l'handle per completare la scrittura del file su disco. Con un'app di rilevamento delle modifiche, si è non solo per iniziare a vedere tutte le modifiche, ma potenzialmente ottenere nel corso di queste operazioni. È importante eseguire del sistema, ovvero la comprensione e rispettando ciò che siano tentando di eseguire altre applicazioni.

Tenere presente che perché schede SD possono essere rimosso dal dispositivo è spento, mentre nel file System basati su file system FAT non è l'inserimento nel journal, rilevamento delle modifiche non può essere garantita su una scheda SD tra le sessioni di avvio. Se l'organizzazione ha requisiti molto precise su come verificare che i file non vengano manomessi, considerare l'utilizzo di un criterio di gestione di dispositivi mobili per forzare le immagini della fotocamera crittografati verranno scritti solo l'archiviazione interna. Questo garantisce che i dati siano protetti inattivi e che tutte le modifiche apportate al file vengono presi in considerazione.

Conclusioni

E questo è tutto. L'ispezione app è ora pronto per aggiungere automaticamente i file quando vengono creati nel sistema e per notificare agli utenti quando viene eliminato uno. Sebbene possa sembrare semplice, l'abilitazione di questa esperienza consente agli utenti di concentrarsi sulla loro controlli anziché prelievo anteprime dall'esperienza di sistema di selezione. Se il controllo è costantemente scattate apparecchiature simili, tra cui immagini recenti automaticamente nel report può notevolmente ridurre il errori con un costo aziende tempo e denaro. Più importante, può consentire l'app si distinguono tra il campo piena di applicazioni aziendali per Windows.

ADAM Wilsonè un program manager del team di piattaforma e l'ecosistema di sviluppatori di Windows utilizza le notifiche push e dell'indicizzatore di Windows.  È possibile contattarlo all'indirizzo Adam.D.Wilson@microsoft.com.

Grazie per i seguenti esperti tecnici Microsoft che ha esaminato in questo articolo: Brendan Flynn, Mary Anne Noskowski e Kyle Yuan