Décembre 2016

Volume 31, numéro 13

Cet article a fait l'objet d'une traduction automatique.

Plateforme Windows universelle - Surveillance du système de fichiers dans les applications de la plateforme Windows universelle

Par Adam Wilson | Décembre 2016

Le système de fichiers d’un périphérique Windows évolue rapidement. Bibliothèques partagées, telles que la pellicule, parmi les endroits où tous les processus sur l’appareil peuvent interagir simultanément avec les mêmes données. Création d’une application universelle Windows Platform (UWP) qui fournit une expérience exceptionnelle avec les photos d’un utilisateur signifie que vous allez devoir passer en détail ce chaos.

Dans la fenêtre 10 anniversaire mise à jour Microsoft ajouté de nouvelles fonctionnalités pour gérer ce chaos plus facile. Le système est maintenant en mesure de fournir une liste de toutes les modifications qui se produisent dans une bibliothèque, à partir d’une image tenue jusqu’au dossiers entiers en cours de suppression. Il s’agit d’une aide non négligeable si vous avez besoin pour créer un fournisseur de sauvegarde du cloud, le suivi des fichiers déplacés hors tension de l’appareil ou simplement afficher les dernières photos.

Affichant les dernières photos prises par un périphérique n’est pas pour les développeurs une tentative de création de la prochaine Instagram. Récemment, j’ai eu le plaisir de travailler avec des partenaires de l’entreprise tels qu’ils générés inspection des applications pour leurs organisations. Les applications suivent un modèle similaire : Un inspecteur visite un site avec un Tablet PC Windows ou de téléphone, renseigne un rapport avec des informations sur le site, prend des images du site à l’aide de l’appareil et, enfin, télécharge le rapport sur un serveur sécurisé. Pour toutes les entreprises, il est essentiel que les photos corrects, non modifiés, sont téléchargées dans les rapports.

Sur les pages suivantes, je vais Guide de création d’une application d’entreprise inspection. Au cours du processus je remarquer quelques problèmes particulièrement difficiles que j’ai rencontrés pendant le processus de développement et notez comment les éviter dans votre application. Ces leçons peuvent s’appliquent également à toute autre application qui cherche à suivre les modifications dans le système de fichiers, telles qu’un service de sauvegarde du cloud, mais étant donné que les applications de contrôle sont relativement courantes, je commencerai il et vous pouvez modifier le code pour le type d’application que vous créez.

Contrôles : Tout le monde est les

Toutes les entreprises de toutes tailles et de secteurs, un point est commun : Il existe des inspecteurs de surveillance des processus métiers critiques. À partir de la société de fabrication massive le suivi de l’état de leurs équipements aux détaillants de s’assurer que les écrans sont assemblés correctement, les entreprises dépendent de la fabrication que tout sont effectués régulièrement et en toute sécurité sur l’ensemble de leurs sites.

Je vais ici la prennent en charge le processus de base est assez simple :

1. Un inspecteur crée une nouvelle instance de rapport pour le site sur son Tablet PC.
2. L’inspecteur prend les images du site pour un rapport.
3. Les images sont téléchargés vers un serveur sécurisé avec le rapport.

À l’étape 2, toutefois, un certain nombre de choses peut mal se passer :

• L’inspecteur peut choisir les images incorrects à joindre au rapport.
• Vous pouvez modifier une image pour afficher des informations incorrectes.
• Une image peut être accidentellement supprimé avant que le rapport est téléchargé, mais une fois que l’inspecteur laisse un emplacement.

Dans tous ces cas, le rapport est non valide et nécessitent l’inspecteur de répéter l’inspection, une dépense supplémentaire pour l’entreprise. Heureusement, avec les nouvelles API de suivi des modifications de mise à jour de Windows 10 anniversaire, il existe un moyen simple pour éviter ces erreurs et pour aider les utilisateurs à accomplir leurs tâches rapidement et correctement.

Notions de base : L’accès aux images de l’appareil photo

La première étape consiste à s’assurer que l’application a accès aux images en provenance de l’appareil photo. Dans Windows, la caméra du système écrit dans le dossier pellicule, qui est un sous-dossier de la bibliothèque d’images. Impossible (and a en fait) écrire un article complet sur la façon d’accéder à la bibliothèque d’images (bit.ly/2dCdj4O), mais voici les principes de base :

• Déclarez votre intention d’accéder à la bibliothèque d’images dans votre manifeste (bit.ly/2dqoRJX) en ajoutant le nom de fonctionnalité = « Bibliothèquemusicale » / > dans l’éditeur de manifeste ou cochez la case de la bibliothèque d’images sous l’onglet fonctionnalités dans l’Assistant.
• Obtenir un StorageFolder représentant l’emplacement où les images de la caméra sont écrits à l’aide de KnownFolders.CameraRoll (bit.ly/2dEiVMS).
• Obtenir un objet représentant la bibliothèque images à l’aide de StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures) (bit.ly/2dmZ85X).

Ne vous inquiétez pas si le périphérique possède une carte SD et un paramètre utilisateur pour l’écriture de nouvelles images au stockage interne ou une carte SD. La classe KnownFolder clarifient tout cela pour vous et vous donner un dossier virtuel englobant tous les emplacements dans lesquels la caméra peut écrire un fichier.

Recevoir une notification lorsque quelque chose change

Une fois que vous avez accès aux fichiers, il est temps de commencer à suivre les modifications. Je recommande cela dès que possible. Dans un monde parfait, les inspecteurs seraient toujours créer un rapport avant leur démarrage prise de photos, mais en réalité ils généralement avoir pris les quelques images avant qu’ils n’oubliez pas de créer un rapport.

Configurer les notifications et le suivi des modifications implique trois étapes :

1. Initialisation du traceur de modifications, qui indique au système les bibliothèques vous intéresse suivi. Le suivi continue même si votre application n’est pas en cours d’exécution et l’application peut lire la liste des modifications à tout moment.
2. Inscription aux notifications de modification en arrière-plan, ce qui activera tâche d’arrière-plan de votre application chaque fois qu’il y a une modification dans une bibliothèque, il est en cours d’exécution ou non.
3. Inscription aux notifications de changement de premier plan. Si votre application est au premier plan, vous pouvez inscrire d’autres événements chaque fois qu’un fichier est modifié dans une certaine étendue.

Notez que les étapes 2 et 3 pourraient potentiellement se chevauchent pas. Je vais aborder la configuration de ces deux types de notifications dans cet article, mais le graphique de Figure 1 peuvent vous aider à choisir dont vous souhaitez utiliser dans votre application. La recommandation générale consiste à toujours utiliser des notifications de modification en arrière-plan avec StorageLibraryContentChangeTrigger et d’utiliser des événements de premier plan si vous avez un besoin spécifique de l’interface Utilisateur, telles que l’affichage d’une vue du système de fichiers à vos utilisateurs.

Figure 1 les Types de Notifications de modification

Le StorageLibraryChangeTracker est une nouvelle classe ajoutée dans la mise à jour d’anniversaire (bit.ly/2dMFlfu). Il permet aux applications pour vous abonner à une liste de modifications qui se produisent dans une bibliothèque. Le système surveille tous les fichiers dans la bibliothèque et génère une liste des modifications apportées à leur. Votre application peut demander la liste des modifications et les traite à son gré.

StorageLibraryChangeTracker est très similaire pour le journal des modifications NTFS, si vous avez déjà travaillé avec qui, mais il fonctionne sur des lecteurs FAT, également. Pour plus d’informations, vous pouvez lire via la discussion approfondie sur mon blog (bit.ly/2dQ6MEK).

Initialisation du StorageLibraryChangeTracker est assez simple, vous venez d’obtenir l’instance spécifique à la bibliothèque du dispositif de suivi des modifications et appeler les activer :

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

À ce stade, le traceur conserve une liste de toutes les modifications à la bibliothèque. Maintenant assurons-nous que votre application est avertie à chaque modification.

Écouter les Notifications de premier plan

Pour écouter les notifications de premier plan, votre application doit créer, exécuter et maintenir ouverte une requête sur l’emplacement dont les modifications vous concernent. Création et exécution de la requête indique au système les emplacements sont intéressantes pour votre application. Contenant une référence aux résultats de cette requête par la suite, vous indique que votre application souhaite être averti lorsque quelque chose change :

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;

Comme vous pouvez le voir, j’utilise quelques optimisations intéressantes peuvent s’avérer utiles dans votre application :

• CommonFileQuery.DefaultQuery effectue l’opération entière beaucoup plus rapide dans les cas où l’indexeur n’est pas disponible. Si un autre ordre de tri est utilisé et que l’indexeur n’est pas disponible, le système doit parcourir l’espace de l’intégralité de la requête avant de retourner le premier résultat.
• La requête est une requête partielle. Cela fonctionne parce que l’appareil photo s’écrivent toujours à la racine de la pellicule, et en évitant une requête approfondie réduit le nombre de fichiers que le système doit effectuer le suivi des modifications.
• À l’aide de l’indexeur n’est pas obligatoire, mais elle accélère les notifications figurant dans l’application. Sans l’indexeur, notifications peuvent prendre jusqu'à 30 secondes pour atteindre votre application.
• Une interrogation pour un seul fichier est le moyen le plus rapide pour démarrer le suivi des modifications dans un emplacement indexé, bien que vous souhaiterez interroger d’autres fichiers au cas où l’interface Utilisateur en a besoin.

Maintenant chaque fois qu’un élément dans la requête change, le Gestionnaire d’événements est déclenché, donner votre application une chance de traiter la modification.

L’enregistrement du déclencheur de modification en arrière-plan

Toutes les modifications vont se produire pendant que votre application est au premier plan, et même si votre application est au premier plan doit peut-être pas la granularité des notifications de premier plan. StorageLibraryContentsChangedTrigger est un excellent moyen pour être informé lorsque quelque chose change dans une bibliothèque. Étant donné que vous enregistrez une tâche en arrière-plan à l’aide du processus standard (bit.ly/2dqKt9i), je vais passer rapidement (voir Figure 2).

Figure 2 l’inscription d’une tâche en arrière-plan

// 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();

Il existe quelques points importants à noter dans l’exemple de Figure 2.

Vous pouvez toujours utiliser l’ancien modèle de processus de deux pour inscrire votre tâche en arrière-plan, mais prenez un bon moyen d’examiner le modèle de processus unique qui a été ajouté dans la mise à jour de l’anniversaire. Il rapidement convaincu me avec combien il est simple à utiliser et combien il est facile de recevoir les déclencheurs en arrière-plan pendant que votre application au premier plan.

StorageLibraryContentChangedTrigger se déclenche pour toutes les modifications dans la bibliothèque d’images, qui peut inclure des fichiers qui ne sont pas intéressantes à votre application. Je vais aborder comment éliminer ceux dans une section ultérieure, mais il est toujours important de savoir que parfois, il y aura rien à faire lorsque votre application est activée.

Il est important de vérifier votre tâche d’arrière-plan que vous exécutiez en arrière-plan ou premier plan, car les allocations de ressources sont différentes. Vous trouverez plus de détails sur le modèle d’allocation de ressources à bit.ly/2cNvcSr. 

Lire les modifications

Votre application va maintenant la possibilité d’exécuter du code chaque fois que quelque chose change dans la pellicule, soit dans le premier plan ou d’arrière-plan. Pour déterminer ce qui a changé, vous devez lire l’ensemble de modifications à partir de StorageLibraryChangeTracker. La première étape consiste à obtenir un objet de lecteur, ce qui vous permet d’énumérer les modifications qui ont eu lieu depuis la dernière fois que votre application est activée. Lorsque vous y êtes, vous pouvez également sélectionner le premier lot de modifications à traiter :

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

Une fois que vous obtenez un ensemble de modifications, il est temps de les traiter. Dans cette application, je vais me concentrer uniquement sur les images en cours de modification et ignorer toutes les modifications de fichier et dossier. Si vous êtes intéressé dans d’autres types de modifications sur le système, ma présentation approfondie sur le traceur de modifications a les plus d’informations sur les différents types de modifications (bit.ly/2dQ6MEK).

Je vais vous guider les modifications et extraire les dans lequel je m’intéresse. Pour cette application, il faudra de toute modification apportée au contenu d’un fichier .jpg, comme indiqué dans Figure 3.

Figure 3 la vérification des modifications apportées aux fichiers

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();

Voici quelques éléments sur l’extrait de code intéressants Figure 3.

La première chose à que faire est de contrôler StorageLibraryChangeType.ChangeTrackingLost. Ce problème survient uniquement après une opération de système de fichiers volumineux (où le système n’a pas suffisamment de stockage pour l’ensemble de modifications) ou dans le cas d’une erreur interne critique. Dans les deux cas, quoi que ce soit en cours de lecture à partir du traceur ne peut plus être approuvé. L’application doit réinitialiser le traceur de modifications pour les futurs résultats dignes de confiance.

UnknownItemRemoved (modification. Chemin d’accès) est atteints chaque fois qu’un fichier ou dossier est supprimé d’une partition FAT, tel qu’une carte SD. Une fois qu’un élément est supprimé d’une partition FAT, que le système ne peut pas savoir s’il s’agit d’un répertoire ou un fichier qui a été supprimé. Je vais vous guider dans du code en un bit qui indique comment vous pouvez déterminer ce qui est arrivé dans votre application.

Lorsque toutes les modifications ont été traitées, vous appelez changeReader.AcceptChangesAsync. Cela indique au traceur de modifications que votre application a traité toutes les modifications n’a pas besoin de les afficher à nouveau. Lorsque vous créez un StorageLibraryChangeReader contient uniquement les modifications qui ont eu lieu depuis ce point. Appel non AcceptChangesAsync provoque la mémoire tampon interne à remplir et de dépassement de capacité, ce qui entraîne StorageLibraryChangeType.ChangeTrackingLost.

Une modification de la gestion des

Maintenant que vous savez comment parcourir les modifications, l’étape suivante consiste à étoffer la méthode ProcessFileChange. Un concept clé à retenir est que l’ouverture de fichiers (en créant des objets StorageFile) est très coûteuse. Pour obtenir un objet StorageFile dans votre processus, le système doit effectuer un appel d’interprocessus pour vérifier les autorisations, créer un handle vers le fichier, lecture des métadonnées sur le fichier à partir du disque et puis marshaler le handle et les métadonnées au processus de votre application. Par conséquent, vous souhaitez réduire le nombre de StorageFiles vous créez, surtout si vous ne prévoyez pas d’ouvrir les flux de fichiers.

Le traceur de modifications fournit votre application avec les chemins d’accès et le type de modification pour vous aider à déterminer si un fichier est du type de votre application s’intéresse avant de créer l’objet StorageFile. Nous allons commencer par effectuer autant de filtrage que possible avec ces informations avant de créer l’objet StorageFile, comme indiqué dans Figure 4.

Figure 4 traiter les modifications

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;                   
  }
}

Analysons que se passe-t-il en consultant chacune des instructions case.

Nouveau fichier dans la bibliothèque : Dans la première instruction, que je cherche les nouveaux fichiers qui ont été ajoutés à la bibliothèque. Dans le cas de la caméra du système, le fichier va être créé dans la bibliothèque et je verrai une modification de type StorageLibraryChangeType.Created. Certaines applications tierces réellement créer l’image dans leur conteneur de données d’application, puis déplacement vers la bibliothèque, donc je vais traiter StorageLibraryChangeType.MovedIntoLibrary comme la création d’un, trop.

Je vais processus StorageLibraryChangeType.MovedOrRenamed en tant que nouveau fichier. Il s’agit de contourner une curiosité de la caméra intégrée sur Windows phone. Lorsque l’appareil photo prend une photo, il écrit un fichier temporaire avec la fin .jpg. ~ tmp. Plus tard, il va finaliser l’image, supprimant la. ~ extension tmp. Si votre application est suffisamment rapide intercepter le fichier avant de l’appareil photo s’effectue à la finalisation de l’image, il peut observer un événement de changement de nom au lieu de l’événement de création.

Étant donné que cette application va être intéressé uniquement par les images prises par l’utilisateur, je vais filtrer jusqu'à uniquement les fichiers portant l’extension .jpg. Vous pouvez procéder en créant un objet StorageFile et en vérifiant sa propriété ContentType, mais j’essaie d’éviter de créer des StorageFiles inutiles. Lorsque je connais qu'un fichier est un que m’intéresse, je vais remettre le fichier à une autre méthode pour effectuer un traitement de données.

J’utilise ici un cast plutôt que comme mot clé, car j’ai déjà demandé StorageLibraryChange le type de l’objet StorageItem utiliseront : StorageLibraryChange.IsOfType(StorageItemTypes.File).

Fichier supprimé de la bibliothèque : Dans le deuxième cas, l’application consulte les situations où un fichier a été supprimé de la bibliothèque. Vous remarquerez que j’ai regroupés deux types de modifications différents à nouveau. StorageLibraryChangeType.Deleted est déclenché chaque fois qu’un fichier est supprimé définitivement à partir du disque, qui est le cas classique de suppression à l’aide de l’API de système de fichiers. Toutefois, si l’utilisateur supprime manuellement le fichier à partir de l’Explorateur de fichiers au lieu de cela, le fichier sera envoyé à la Corbeille. Cette option s’appelle StorageLibraryChangeType.MovedOutOfLibrary, car le fichier réside toujours sur le disque.

Dans ce cas, je vais déclenche un avertissement à l’inspecteur que le fichier a disparu, dans le cas où il s’agissait d’une suppression accidentelle. Dans les applications plus soucieux de la sécurité, il peut être utile pour stocker les suppressions de fichiers ou des modifications d’audit plus tard dans le cas d’une enquête.

Modification du contenu : le contenu d’un fichier en cours de modification est un cas à part pour cette application. Étant donné que cette application peut être utilisée pour les vérifications de sécurité, vous ne souhaitez permettre aux utilisateurs de modifier les images avant leur téléchargement à l’état, s’il existe des raisons valables pour le contenu d’une image à modifier après une image.

Vous pouvez voir une notification de type StorageLibraryChangeType.ContentsChanged déclenchés sur trois à 60 secondes après une image avec l’appareil photo. Il s’agit, car elle peut parfois prendre une minute pour obtenir les coordonnées du système GPS. Dans cette application je ne suis pas inquiet informations GPS afin que je suis traitement immédiatement le fichier. Dans certaines applications, il peut être judicieux de vérifier si les données d’emplacement a été écrit dans le fichier et, le cas contraire, pour attendre que l’emplacement est déterminé.

Dans ce cas, je vais aller pour un juste milieu très fiable. Si un fichier est modifié plus de 70 secondes après que celle-ci a été effectuée, je vais supposer qu’il a été modifié par l’utilisateur et se déconnecter d’un problème de conformité pour un examen ultérieur. S’il a été modifié dans la fenêtre de la seconde 70, je suppose que cela a été effectuée par le système lors de l’ajout de données GPS et peut être ignoré en toute sécurité.

Le chiffrement est modifié : Si vous intéresser ce cas revient à une question : Votre entreprise utilise-t-il Windows Information Protection (TEC) avec le chiffrement pour protéger ses informations sensibles ? Dans ce cas, ce type de modification est un problème énorme. Cela signifie que quelqu'un a modifié la protection sur le fichier et le fichier peut être placé sur le disque non protégé. En parcourant toutes les informations sur la façon de vérifier si le fichier est sécurisé (et non simplement déplacé vers un autre niveau de protection) en COURS est abordée dans cet article. Si vous déployez des travaux en COURS dans votre entreprise, ce type de modification est important pour vous permettent de surveiller.

Pour ceux qui n'utilisent pas les travaux en COURS ou le chiffrement pour protéger les ressources d’entreprise sensibles, je recommande fortement de vous rechercher dedans, mais pour l’instant, cette modification est sûr à ignorer.

Incidents ignorés : Enfin, dans cette application, il est judicieux d’ignorer certaines des choses qui peuvent se produire sur le système de fichiers. StorageLibraryChangeType.IndexingStatusChanged est important uniquement dans le cas des applications de bureau qui vont être les requêtes répétées de la bibliothèque et attend les mêmes résultats chaque fois. StorageLibraryChangeType.ContentsReplaced indique qu’un lien physique pour le fichier a été modifié, ce qui n’est pas intéressant pour cette application.

Suppression d’une Image sur une carte SD de détection

Comme vous le savez, le système ne peut pas déterminer si un élément supprimé est un fichier ou dossier une fois qu’il a été supprimé sur FAT lecteurs comme une carte SD. Par conséquent, du code de tri spécial est nécessaire si vous vous souciez suppressions sur des lecteurs FAT. Pour mon application, je veux uniquement savoir si les images sont supprimés de la carte SD, ce qui rend le code simple :

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

Le code vérifie si l’élément est utilisé pour une extension .jpg et si tel est le cas déclenche l’événement de l’interface Utilisateur même en Figure 4.

Réflexions finales

Une fois le code de base en place, il existe plusieurs choses intéressantes qui peuvent aider à garantir votre nouvelle application s’exécutera aussi facilement que possible.

Faites des essais avec votre configuration. Il s’agit de l’information la plus importante de conseil que je peux vous donner sur la création d’une application qui effectue le suivi des modifications de système de fichiers. Écrire une application rapide qui se connecte à ce qui se passe sur vos périphériques avant d’aller plus loin dans le code. Essayez d’un grand nombre de composants avec l’écriture de fichiers temporaires et d’évaluer rapidement les supprimer, telles que l’appareil photo intégré abordées précédemment. J’ai vu même cas ici ou là où les applications ont été écriture de fichiers incomplets, fermer le handle, puis rouvrir immédiatement la poignée pour terminer l’écriture du fichier sur le disque. Avec une application de suivi des modifications, vous êtes non seulement va commencer à voir toutes ces modifications, mais susceptible d’être au milieu de ces opérations. Il est important d’être un bon citoyen du système, ce qui signifie que la présentation et le respect qu’autres applications essaient.

N’oubliez pas qu’étant donné que les cartes SD peuvent être supprimés de l’appareil pendant qu’il est hors tension et il n’existe pas de journalisation sur les systèmes de fichiers FAT, le suivi des modifications ne sont pas garanti sur une carte SD entre les sessions de démarrage. Si votre entreprise a des spécifications très strictes permet d’assurer que les fichiers ne sont pas falsifiés, envisagez d’utiliser une stratégie de gestion des appareils mobiles pour forcer les photographies chiffré à écrire dans le stockage interne uniquement. Cela garantit que la protection des données au repos et que toutes les modifications apportées au fichier sont pris en compte.

Pour résumer

Et c’est tout. L’application de contrôle est maintenant prête à ajouter automatiquement les fichiers lorsqu’ils sont créés sur le système et avertir les utilisateurs lorsqu’un d’eux est supprimé. Bien qu’il peut sembler simple, cette expérience permet aux utilisateurs de se concentrer sur leurs contrôles au lieu de prélèvement des miniatures espoirs sélecteur du système. Si l’inspecteur est constamment prendre des photos des équipements similaires, automatiquement, y compris les images récentes dans le rapport peut considérablement réduire les erreurs dont le coût du temps d’entreprises et de l’argent. Plus important encore, elle peut aider votre application se distinguent entre le champ encombré d’applications d’entreprise pour Windows.

ADAM Wilsonest responsable de programme de l’équipe plate-forme et écosystème de développement Windows, travaille sur les Windows indexeur et des notifications push.  Vous pouvez le contacter à l’adresse Adam.D.Wilson@microsoft.com.

Je remercie les experts techniques Microsoft suivants qui cet article : Brendan Flynn, Mary Anne Noskowski et Kyle Yuan