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

Windows Phone

Créer une application de hub d'entreprise Windows Phone 8

Tony Champion

Télécharger l'exemple de code

Avant la sortie de Windows Phone 8, les compagnies avaient seulement deux options pour le déploiement d'applications d'entreprise aux périphériques de leurs employés.Ils pourraient libérer les apps dans le magasin de Windows Phone et exiger l'authentification de l'utilisateur, ce qui permet les applications à déployer avec succès tout en assurant leur utilisation.Bien sûr, l'application serait alors disponible dans le magasin et disponibles au grand public pour le téléchargement.L'autre approche est d'utiliser une solution de gestion (MDM) du périphérique mobile pour gérer directement les appareils.Microsoft propose actuellement deux MDM : Windows Intune et System Center 2012 Configuration Manager.MDM sont toujours l'approche privilégiée pour de nombreuses entreprises à grande échelle, ils ne pourraient pas aligner avec les objectifs de déploiement de l'entreprise.

Windows Phone 8 apporte une option nouvelle, non managée pour le déploiement d'applications d'entreprise qui permet aux périphériques à installer des applications directement à partir d'une pièce jointe ou en téléchargeant l'application à partir d'une URL.Cette approche directe au déploiement d'applications d'entreprise ouvre entreprise app développement et le déploiement de plus d'entreprises.

Un inconvénient de cette approche non managé est que l'installation et la gestion des app pour l'utilisateur n'est pas tout à fait intuitive.Quand il s'agit de périphériques mobiles, les utilisateurs attendent pouvoir installer des applications avec la simple pression d'un bouton.Vu à installer manuellement des applications de courrier électronique ou par un Web site va à l'encontre de l'application normale d'expérience et peut causer l'incertitude dans les utilisateurs et les questions de formation pour le personnel informatique.Heureusement, il existe une solution — une compagnie moyeu app.

Windows Phone 8 comprend quelques ajouts au SDK qui prennent en charge ce nouveau concept.Une société moyeu app donne à l'entreprise un mécanisme de présentation et de livrer des applications à l'utilisateur pour l'installation.Et il donne aux utilisateurs une expérience familière à découvrir et à installer des applications de l'entreprise.

Exigences pour la société Hub Apps

Avant de pouvoir publier une app hub de société à vos employés, il y a quelques démarches administratives qui doivent être prises.La première étape consiste à s'inscrire pour un compte d'entreprise sur le Windows Phone Dev Center.Le processus d'inscription est similaire à un compte de développement régulier, mais un compte d'entreprise passe par une vérification des comptes supplémentaires.

Après avoir créé un compte, vous devez acheter un certificat de signature de Code Mobile entreprise de Symantec Corp.Le processus d'achat de certificat nécessite un ID valide de Symantec depuis le centre de Dev, donc cela peut s'achèvera après que le compte de la société a été établi et vérifié.Une fois que le certificat est acheté et installé sur un ordinateur, vous devez exporter le certificat dans un format PFX contenant la clé privée.Ce certificat servira pour générer un jeton d'inscription application (AET) et pour la signature de tous les apps développées par la société.Lorsque vous installez le certificat sur votre ordinateur de développement, il est important de suivre les étapes décrites au bit.ly/1287H8j.Dans le cas contraire, vous vous retrouverez avec un fichier PFX incomplète ne sera pas valider correctement pendant le déploiement.Sauter ces étapes est un mal de tête commun pour beaucoup de développeurs.

Un AET doit être installé sur un périphérique avant que ce dispositif peut installer tous les apps développés par une société.En installant l'AET, l'appareil est inscrit dans le compte de l'entreprise déjà établie.Le Windows Phone SDK 8.0 inclut un outil, AETGenerator, qui peut être utilisé pour créer l'équipe du certificat exporté.Le générateur crée trois formes différentes de l'AET : une version brute contenant l'AET au format XML (.xml), une version codée en Base64, utilisée avec une MDM comme Windows Intune ou System Center 2012 Configuration Manager (.aet) et un format XML qui peut être installé directement sur l'appareil par l'email ou Internet Explorer (.aetx).

Au moment de décider quelle méthode utiliser pour distribuer le AET et vos applications d'entreprise, il y a un point important à considérer.Lorsqu'un dispositif installe un AET, c'est valide jusqu'à sa date d'expiration, qui par défaut est d'un an.Une fois que l'équipe arrive à expiration, l'appareil ne sera pas en mesure d'exécuter tous les apps signée et distribuée par la société — y compris les applications de moyeu — jusqu'à ce qu'un nouveau, valide AET est installé.Cela crée deux éléments, que vous devez ajouter à votre planification de stratégie de déploiement.

La première est de savoir comment gérer l'expiration de l'AET.Si vous utilisez une MDM pour gérer vos périphériques, une mise à jour AET publiables sur les appareils directement à partir de la MDM.Cela aidera à minimiser l'impact de l'expiration de l'AET original sur les périphériques.Si l'AET est installé via un processus non managé — courrier électronique ou Internet Explorer — le nouvelles AET devront être installés manuellement par l'utilisateur.Parce que l'utilisateur ne sera pas en mesure d'exécuter tous les apps de l'entreprise, y compris l'app hub, une fois que l'équipe arrive à expiration, c'est une bonne pratique pour créer et distribuer une nouvelle AET avant l'expiration de l'original.Cela empêchera l'utilisateur perdent l'accès aux applications d'entreprise.

Le deuxième élément à considérer est la suppression de l'équipe ainsi que tous les apps de compagnie installés sur l'appareil.Dans le monde actuel d'apporter votre propre dispositif (BYOD), cela peut être une considération primordiale.À l'aide d'une MDM donne à l'entreprise un contrôle complet sur ses applications installé sur un périphérique.Apps et l'AET peuvent être retiré à distance directement à partir de la MDM.Toutefois, dans un déploiement non managé, ce n'est pas possible.Une fois un AET est ajouté à l'appareil, il est valide et ne peut être retirée avant son expiration.De même, le SDK ne fournit pas un moyen de supprimer une application depuis un périphérique via le code.La meilleure pratique pour aborder cette question demande aux utilisateurs de s'authentifier auprès de toutes les applications d'entreprise.Cela vous permet d'empêcher un compte d'utilisateur de lancer une application.Alors que ce n'est pas le même comme étant en mesure de supprimer l'application, il vous donne un moyen de gérer la sécurité de votre application lorsqu'elle est déployée sur un périphérique.

Après avoir complété les étapes initiales, vous êtes prêt à commencer à créer des applications qui peuvent être déployées aux employés de votre entreprise sans avoir besoin de passer par le magasin.Vous trouverez un regard plus complet à la création d'un compte de société, obtenir un certificat de signature de Code Mobile entreprise et générant un AET à bit.ly/SBN6Tf.

Préparation pour le développement

Un app hub de société nécessite une configuration un peu plus que la plupart des applications Windows Phone.D'une part, il est assez pratique d'avoir au moins quelques applications disponibles à installer et à utiliser en cas de test au sein de l'app.Alors que les applications elles-mêmes peuvent être vides Windows Phone apps, ils ont tous ont une chose en commun : un ID de l'éditeur.

Si vous avez déjà créé une application Windows Phone, vous êtes probablement familier avec le fichier manifeste app Windows Phone, qui est le fichier WMAppManifest.xml situé dans le dossier Propriétés de la solution par défaut.Ce fichier contient des informations de Windows Phone et le magasin need to know about votre $ $ etAPP.Ouvrir le fichier WMAppManifest.xml à partir de Visual Studio lance un concepteur pour le rendre plus facile à gérer le fichier.Le concepteur contient quatre onglets, dont est l'onglet de l'emballage.

L'onglet Packaging fournit des informations sur le développeur de l'app, les info de gestion des versions et les langues prises en charge.Aux fins du présent article, la Version, la Product ID et l'ID de l'éditeur sont les points les plus importants sur cet onglet.Par défaut, les modèles de projet Windows Phone génèrent un nouveau GUID pour l'ID de produit et l'ID de l'éditeur lorsque le projet est créé.Lorsque vous travaillez avec une application comme un hub de la compagnie, le soft aura de visibilité que dans les autres applications qui ont le même ID de l'éditeur il ne.Cet ID de l'éditeur est généralement définie pour le GUID de l'éditeur qui est assigné à votre compte de développeur dans le Dev Center.Le GUID du serveur de publication se trouvent sur votre page de Résumé du compte dans le Dev Center.

Le fichier téléchargeable de cet article contient sept solutions.Les six premiers sont nommés CDSAPP [1-6].Chacune de ces applications a été créé à partir du modèle de projet application Windows Phone et n'a que le titre de l'app sur la page d'accueil et modification de l'ID de l'éditeur.Si vous allez utiliser ces applications pour vos tests, il est important d'utiliser le même ID de l'éditeur pour votre application de concentrateur d'entreprise ou de changer l'app IDs à la vôtre.

La Version et l'ID de produit sont deux éléments importants d'information à connaître lorsque vous créez une solution de concentrateur d'entreprise.La Version permet de déterminer quand les apps doivent être mis à niveau sur un périphérique, et l'ID de produit est utilisé pour identifier l'application.

La prochaine chose à considérer est votre méthode de test.En règle générale, vous pouvez faire la plupart de vos tests sur l'émulateur de Windows Phone.Il fait un excellent travail et vous permet de tester la plupart des choses que vous devez tester pendant le processus de développement.La difficulté de tester une app hub de compagnie, c'est que votre application doit avoir des apps supplémentaires installés sur l'émulateur pour tester avec.Cependant, chaque fois que vous lancez une nouvelle instance de l'émulateur, il commence à partir d'une version propre du système d'exploitation.Cela signifie que tout ce que vous avez précédemment installé pour l'essai n'est plus là.

Il y a deux façons d'aborder ce problème.La première consiste à quitter l'émulateur en cours d'exécution, installer quelques applications de test et puis faire du développement de votre entreprise app hub tandis que l'émulateur est encore en cours d'exécution.Bien sûr, si l'émulateur obtient redémarré pour une raison quelconque, vous devez réinstaller ces applications pour commencer à tester à nouveau.

L'approche privilégiée consiste à faire votre développement essais fondés sur un périphérique réel.Ceci fournit une plateforme plus stable pour vos tests.Si vous allez faire vos tests sur un périphérique live, vous aurez besoin pour s'assurer que l'ID de l'éditeur de ce dispositif correspond à l'ID de l'éditeur de votre compte.

Le Hub de la compagnie SDK

Le Windows Phone SDK 8.0 inclut deux classes qui sont principalement responsables de la gestion et l'interaction avec les applications d'entreprise qui sont installées sur la machine.Bien qu'il existe certains objets de support que vous serez introduit au long du chemin, comprendre ces deux classes est critique pour votre app hub.

La classe Package chaque application installée sur le périphérique est représentée par la classe Package, qui se trouve dans l'espace de noms Windows.ApplicationModel.La classe Package contient deux membres importants que j'aborderai ici.Le premier est la propriété Id, qui retourne une classe PackageId.La classe contient la plupart des informations de manifeste qui a été entrées dans l'onglet de l'emballage dans le concepteur de manifestes, y compris l'Id de produit qui a été attribué à l'application, le nom de l'app, informations sur l'éditeur et la version actuelle.

L'autre membre important de la classe Package est la méthode de lancement, qui permet de lancer l'application représentée par le Package de l'application actuelle.Non seulement c'est un excellent outil pour construire une société moyeu app, il peut aussi être utile pour d'autres applications de métier (LOB).

InstallationManager classe InstallationManager, dans l'espace de noms Windows.Phone.Management.Deployment est la classe chargée d'installer des paquets sur le périphérique.Ceci est accompli par le biais de la méthode AddPackageAsync.Une liste de toutes les applications de la même PublisherId comme l'application actuelle, y compris le paquet correspondant à l'application actuelle, est retournée par la méthode FindPackagesFromCurrentPublisher.En outre, la classe peut également servir pour obtenir la progression de l'installation de tous les apps avec le même PublisherId.

Création d'une application de concentrateur d'entreprise

Je vais vous présenter les principes essentiels de développer une app hub de compagnie, à l'aide de la démo montrée Figure 1.La démo contient une application de trois pages panorama qui répertorie les applications entreprise disponible en trois catégories : Apps qui ne sont actuellement pas les applications installées, avec une mise à jour disponible et applications qui ont la dernière version installée.En outre, l'application aura un détail de la page qui présente les informations sur l'application et fournit les commandes pour installer la dernière version et lancer l'application à partir du moyeu.La solution de travail peut être trouvée comme une ressource téléchargeable de archive.msdn.microsoft.com/mag201307Hub.

Figure 1 l'App Hub de compagnie

Ce qui est manquant par souci d'exhaustivité, il est important de souligner quelques éléments qui ne sont pas inclus dans l'application de démo, mais devront être créé pour toute solution réelle.Le premier est la source de la compagnie disponibles les applications.Si vous examinez la classe CompanyPackage, vous verrez qu'il contient une méthode GenerateData.Cette méthode est utilisée pour simuler les applications d'entreprise disponible en générant une liste des applications entreprise installée sur le périphérique, en modifiant certaines données et en créant des données fictives, ainsi.

La deuxième pièce manquante est un site Web pour héberger les fichiers .xap pour être téléchargé et installé sur le périphérique.Pour le hub de la compagnie soit fonctionnel, il doit être en mesure de télécharger les apps de certain endroit.Cette solution Web devra être créé ainsi.

La classe CompanyPackage afin de représenter la liste des applications disponibles à installer sur l'appareil, la première chose à définir est une classe CompanyPackage qui s'inspire de la classe Package.La classe CompanyPackage contient les informations d'affichage et l'emplacement du package d'installation :

public class CompanyPackage
{
  public string Id { get; set; }
  public string Name { get; set; }
  public string Description { get; set; }
  public string Thumbnail { get; set; }
  public string Version { get; set; }
  public Uri SourceUri { get; set; }
  public CompanyPackageStatus Status { get; set; }
}

La propriété Status est utilisée pour déterminer si l'application est actuellement installée sur l'appareil et s'il y a une version plus récente. CompanyPackageStatus est une énumération qui je vais explorer plus loin dans l'article :

public enum CompanyPackageStatus
{
  Unknown,
  New,
  Update,
  Installed
};

Création d'un modèle de vue ce $ $ etAPP de la plaque tournante de compagnie, vous devez créer un modèle de vue unique, CompanyPackageViewModel, montré dans Figure 2. Le modèle d'affichage doit avoir trois propriétés qui retournent une collection IEnumerable d'objets CompanyPackage : NewPackage, UpdatePackages et InstalledPackages. La propriété NewPackage contient tous les apps disponibles qui ne sont pas actuellement installés sur l'ordinateur. UpdatePackages représente tous les apps qui sont actuellement installés sur la machine, mais qui ont une version plus récente disponible. Enfin, InstalledPackages contient toutes les applications qui sont actuellement installées sur l'appareil.

Figure 2 le modèle d'affichage CompanyPackage

public class CompanyPackageViewModel : INotifyPropertyChanged
{
  private IEnumerable<CompanyPackage> _packages;
  public CompanyPackageViewModel()
  {
    LoadData();       
  }
  private void LoadData()
  {
    // Get list of packages and populate properties
    _packages = CompanyPackage.GenerateData();
    UpdatePackageStatus();
  }
  private IEnumerable<CompanyPackage> _newPackages;
  public IEnumerable<CompanyPackage> NewPackages
  {
    get
    {
      return _newPackages;
    }
  }
  private IEnumerable<CompanyPackage> _updatePackages;
  public IEnumerable<CompanyPackage> UpdatePackages
  {
    get
    {
      return _updatePackages;
    }
  }
  private IEnumerable<CompanyPackage> _installedPackages;
  public IEnumerable<CompanyPackage> InstalledPackages
  {
    get
    {
      return _installedPackages;
    }
  }
  public event PropertyChangedEventHandler PropertyChanged;
  private void NotifyPropertyChanged(String propertyName)
  {
    PropertyChangedEventHandler handler = PropertyChanged;
    if (null != handler)
    {
      handler(this, new PropertyChangedEventArgs(propertyName));
    }
  }
}

Définir les trois statuts avant que vous pouvez remplir les trois propriétés différentes du modèle de la vue, vous devez générer la liste des applications disponibles, représenté comme une collection de CompanyPackages. Dans le modèle d'affichage montré Figure 2, les données sont chargées et renseignées dans la méthode LoadData. La méthode LoadData tire une liste des données d'essai et le stocke dans la variable privée _packages. Il appelle ensuite la méthode UpdatePackageStatus dans Figure 3.

Figure 3 méthode de détermination du statut de chaque CompanyPackage

public void UpdatePackageStatus()
{
  var devicePkgs = 
    InstallationManager.FindPackagesForCurrentPublisher();
  foreach (var pkg in _packages)
  {
    var qry = devicePkgs.Where(p => p.Id.ProductId == pkg.Id);
    if (qry.Count() > 0)
    {
      var devicePkg = qry.First();
      var devicePkgVersion =
        PackageVersionHelper.VersionToString(devicePkg.Id.Version);
      pkg.Status = PackageVersionHelper.IsNewer(
        pkg.Version, devicePkgVersion) ?
CompanyPackageStatus.Update : CompanyPackageStatus.Installed;
    }
    else
    {
      pkg.Status = CompanyPackageStatus.New;
    }
  }
  _newPackages = _packages.Where(
     p => p.Status == CompanyPackageStatus.New).ToList();
  _updatePackages = _packages.Where(
     p => p.Status == CompanyPackageStatus.Update).ToList();
  _installedPackages = _packages.Where(
     p => p.Status == CompanyPackageStatus.Installed).ToList();
  // Fire notifications for all properties
  NotifyPropertyChanged("NewPackages");
  NotifyPropertyChanged("UpdatePackages");
  NotifyPropertyChanged("InstalledPackages");
}

La méthode UpdatePackageStatus a deux responsabilités : déterminer l'état actuel de chaque classe de CompanyPackage disponible et ensuite remplir les propriétés de trois collection du modèle vue basé sur ce statut.

La propriété Status est déterminée en comparant chaque CompanyPackage contre les apps qui sont actuellement installés sur l'appareil. Une liste des applications installées est obtenue à partir de la méthode statique InstallationManager.FindPackagesForCurrentPublisher. Si un objet de Package avec le même Id que le CompanyPackage n'existe pas, il est marqué avec un statut « Nouveau ».

Si un Package portant le même Id existe, la propriété de Version du paquet est ensuite comparée à la Version de la CompanyPackage. La propriété PackageId Version retourne un struct PackageVersion. Contrairement à la classe System.Version, ce struct manque quelques fonctionnalités. La première caractéristique est la possibilité de convertir le struct dans une représentation de chaîne. Si vous appelez la méthode ToString, elle retourne le nom de type et pas le numéro de version réel. La deuxième fonctionnalité manquante est la possibilité de comparer deux instances de PackageVersion pour déterminer lequel est le plus récent.

Figure 4 montre une classe d'assistance qui implémente tous les deux de ces fonctionnalités manquantes. La méthode VersionToString retourne une représentation de chaîne appropriée d'une PackageVersion. La méthode IsNewer prend deux représentations de chaîne d'un nombre de version et détermine si l'argument newVersion est plus récent que l'argument oldVersion. Elle accomplit ceci en convertissant les chaînes à System.Version objets et à l'aide de la méthode CompareTo.

Figure 4 classe d'assistance pour PackageVersion

public static class PackageVersionHelper
{
  public static string VersionToString(PackageVersion version)
  {
    return String.Format("{0}.{1}.{2}.{3}",
                         version.Major,
                         version.Minor,
                         version.Build,
                         version.Revision);
  }
  public static bool IsNewer(string newVersion, 
    string oldVersion)
  {
    var newVer = Version.Parse(newVersion);
    var oldVer = Version.Parse(oldVersion);
    return newVer.CompareTo(oldVer) > 0;
  }
}

Une fois que la méthode de UpdatePackageStatus a calculé la propriété Status pour chaque compagnie­paquet d'objet, il remplit les propriétés de la collection de trois à l'aide de requêtes LINQ. Enfin, le modèle d'affichage déclenche l'événement PropertyChanged pour chacune des propriétés.

Afficher la liste des Apps trois listes des applications disponibles sont affichées dans un contrôle Panorama avec Panorama trois­éléments, chacun contenant une longue liste­sélecteur lié à une des listes. Chacun utilise le même DataTemplate pour afficher un CompanyPackage, et le XAML Panorama complet se trouve dans Figure 5. Dans le projet téléchargeable, vous verrez que le DataContext du contrôle Panorama hérite de DataContext du parent PhoneApplicationPage, qui est définie à une instance de le CompanyPackageViewModel. Vous avez vu le résultat de ceci dans Figure 1.

Figure 5 Panorama pour afficher les applications disponibles

<phone:Panorama Title="my company hub">
  <phone:Panorama.Resources>
    <DataTemplate x:Key="listItemTemplate">
      <StackPanel Margin="0,-6,0,12" Orientation="Horizontal">
        <Image  Source="{Binding Thumbnail,
          Converter={StaticResource debugConv}}"/>
        <TextBlock Text="{Binding Name}" TextWrapping="Wrap"
          VerticalAlignment="Center"
          Style="{StaticResource PhoneTextExtraLargeStyle}"
          FontSize="{StaticResource PhoneFontSizeExtraLarge}"/>
      </StackPanel>
    </DataTemplate>
  </phone:Panorama.Resources>
  <!--Panorama New Apps-->
  <phone:PanoramaItem Header="New Apps">
    <!--Single line list with text wrapping-->
    <phone:LongListSelector Margin="0,0,-22,0"
      ItemsSource="{Binding NewPackages}"
      SelectionChanged="ItemSelected"
      ItemTemplate="{StaticResource listItemTemplate}"/>
  </phone:PanoramaItem>
  <!--Panorama Update Apps-->
  <phone:PanoramaItem Header="Update Apps">
    <!--Single line list with text wrapping-->
    <phone:LongListSelector Margin="0,0,-22,0"
      ItemsSource="{Binding UpdatePackages}"
      SelectionChanged="ItemSelected"
      temTemplate="{StaticResource listItemTemplate}"/>
  </phone:PanoramaItem>
  <!--Panorama Installed Apps-->
  <phone:PanoramaItem Header="Installed Apps">
    <!--Single line list with text wrapping-->
    <phone:LongListSelector Margin="0,0,-22,0"
      ItemsSource="{Binding InstalledPackages}"
      SelectionChanged="ItemSelected"
      ItemTemplate="{StaticResource listItemTemplate}"/>
  </phone:PanoramaItem>
</phone:Panorama>

La vue de détail CompanyPackage

Chaque LongListSelector partage le même gestionnaire d'événements pour l'événement SelectionChanged, ItemSelected. Le gestionnaire d'événements utilise le NavigationService pour naviguer vers un détail PhoneApplicationPage, PackagePage et passe l'Id de la CompanyPackage. Parce que la page active va être mis en cache dans la navigation, le SelectedItem de la LongListSelector est réinitialisé à null pour assurer le bon événement tiré chaque fois :

private void ItemSelected(object sender, 
  SelectionChangedEventArgs e)
{
  if (e.AddedItems.Count > 0 && e.AddedItems[0] != null)
  {
    var pkg = e.AddedItems[0] as CompanyPackage;
    NavigationService.Navigate(
      new Uri("/PackagePage.xaml?id=" + pkg.Id, 
      UriKind.Relative));
    (sender as LongListSelector).SelectedItem = null;
  }
}

Parce que la classe PackagePage ne reçoit que l'Id de la CompanyPackage à afficher, il faut utiliser cet Id pour Rechercher l'objet approprié. Cela se fait en ajoutant une méthode FindPackage à le CompanyPackageViewModel :

public CompanyPackage FindPackage(string id)
{
  return _packages.Where(p => p.Id == id).FirstOrDefault();
}

Le projet Windows Phone Panorama App expose un modèle de vue globale en ajoutant une propriété du ViewModel à la classe App. Ce projet utilise cette propriété pour exposer son modèle vue aux principales et les pages de détails.

La classe PackagePage substitue la méthode OnNavigatedTo pour définir le DataContext sur le CompanyPackage correspondant à l'ID fourni. Il appelle ensuite une méthode UpdateUI qui active/désactive la visibilité et le contenu de deux boutons qui sont ajoutés à l'écran en fonction du statut de la CompanyPackage. Les résultats de chaque type de statut peuvent être vu dans Figure 6.

La figure 6, les Pages de détail différents

Les deux boutons exposent les deux actions disponibles dans les classes de concentrateur d'entreprise. La première est la possibilité de lancer l'application. Si l'application est actuellement installée sur l'appareil, le bouton de lancement est visible. Le gestionnaire d'événements du bouton identifie l'objet de Package correcte qui correspond à l'actuelle CompanyPackage et appelle la méthode de lancement :

private void btnLaunch_Click(
  object sender, RoutedEventArgs e)
{
  var pkg = DataContext as CompanyPackage;
  var devicePkgs = InstallationManager.
FindPackagesForCurrentPublisher();
  var devicePkg = devicePkgs.Where(p =>
    p.Id.ProductId == pkg.Id).FirstOrDefault();
  if (devicePkg != null)
  {
    devicePkg.Launch("");
  }        
}

Si l'état de CompanyPackage est « Nouveau » ou "Update", un bouton d'installation est visible sur la page. Le gestionnaire d'événements pour ce bouton tente d'installer la dernière version de l'app de l'Uri fourni dans la Source­propriété Uri de le CompanyPackage. Ceci est effectué par la méthode InstallationManager.AddPackageAsync. La même méthode est appelée si l'app est mis à jour ou il s'agit d'une nouvelle installation. Cette méthode peut être très capricieuse et vous devez vous assurer de prendre soin de toutes les erreurs générées. La figure 7 montre le gestionnaire d'événements et le processus d'installation. Si l'application est installée avec succès, la UpdatePackage­méthode Status de le CompanyPackageView­modèle est appelée pour mettre à jour les collections de statut affichées dans la page d'accueil et de la méthode UpdateUI de la page mise à jour de la page.

Figure 7 installation et mise à jour gestionnaire d'événements de bouton

private async void btnInstall_Click(object sender, RoutedEventArgs e)
{
  var pkg = DataContext as CompanyPackage;
  if (MessageBox.Show("Install " + pkg.Name + "?", "Install app",  
   MessageBoxButton.OKCancel) == MessageBoxResult.OK)
  {
    try
    {
      var result =
        await InstallationManager.AddPackageAsync(pkg.Name, pkg.SourceUri);
      if (result.InstallState ==
        Windows.Management.Deployment.PackageInstallState.Installed)
      {
        MessageBox.Show(pkg.Name + " was installed.");
        App.ViewModel.UpdatePackageStatus();
        UpdateUI();
      }
      else
      {
        MessageBox.Show("An error occurred during installation.");
      }
    }
    catch (Exception)
    {
      MessageBox.Show("An error occurred during installation.");
    }
  }
}

Étapes suivantes

Dans cet article, j'ai pris un coup d'oeil à développer une app hub de compagnie tout en exposant les détails nécessaires pour créer une solution plus robuste. Certains détails qui ont été omis par souci de brièveté se trouvent dans le téléchargement inclus. Toutefois, il est important de se rappeler que c'est juste le début.

Il y a beaucoup de fonctionnalités qui peuvent être ajoutés à un hub de la compagnie d'offrir de grands avantages à vos utilisateurs, par exemple en profitant des tuiles vivants pour informer l'utilisateur de nouvelles applications sont disponibles. Vous pouvez créer des solutions qui exposent uniquement certaines applications à certains utilisateurs basés sur leurs rôles au sein de la société. Une application peut fournir des fonctionnalités supplémentaires, telles que les nouvelles de la société et des notifications. Alors que les possibilités ne sont peut-être pas illimitées, il ya plus que suffisant pour vous occuper pendant un certain temps.

Tony Champion est président de Champion DS, est un MVP Microsoft et actif dans la communauté comme un haut-parleur, blogueur et auteur. Il anime un blog à tonychampion.net et puisse être joint par courriel à tony@tonychampion.net.

Merci à l'expert technique suivant d'avoir relu cet article : Cliff Strom (Microsoft)