Comme le dit le père catuhe dans son billet concernant le Jour 4, nous pouvons considérer que c’est le dernier jour de notre série.

 

Vous retrouverez le code liée à cette article ici  :http://aka.ms/isz0ot

 

Ainsi que les jours précédent :

Jour 0    (la Consumer Preview)

Jour 1 :  (Consumer preview)

Jour 2 :  (Release Preview)

Jour 2 Optimisé :(Release preview)

Jour 3

 

 

Ajouter un fichier pour gérer l’état de la collection de l’utilisateur.

 

Dans la page d’extension, nous allons pouvoir ajouter une barre d’application contextuelle afin de permettre à l’utilisateur

d’indiquer quelles cartes sont présentes dans sa collection :

 

image1

 

Les nouveaux boutons de la barre d’outils sont alors les suivants :

 

 

Code Snippet
  1. <Page.BottomAppBar>
  2.         <AppBar x:Name="PageAppBar" Padding="10,0,10,0" IsSticky="{Binding DisplayElement,Converter={StaticResource BooleanToIsOpenConverter}}">
  3.             <Grid>
  4.                 <Grid.ColumnDefinitions>
  5.                     <ColumnDefinition Width="50*"/>
  6.                     <ColumnDefinition Width="50*"/>
  7.                 </Grid.ColumnDefinitions>
  8.                 <StackPanel x:Name="LeftCommands" Orientation="Horizontal" Grid.Column="0" HorizontalAlignment="Left">
  9.                     <Button x:Name="AddButton" x:Uid="AddButton" Visibility="{Binding DisplayElement, Converter={StaticResource IntToVisibilityConverter}}" HorizontalAlignment="Left" Style="{StaticResource CheckAppBarButtonStyle}" Click="AddButton_Click"/>
  10.                     <Button x:Name="DelButton" x:Uid="DelButton" Visibility="{Binding DisplayElement, Converter={StaticResource IntToVisibilityConverter}}" HorizontalAlignment="Left" Style="{StaticResource UnCheckAppBarButtonStyle}" Click="DelButton_Click" />
  11.                 </StackPanel>
  12.                 <StackPanel x:Name="RightCommands" Orientation="Horizontal" Grid.Column="1" HorizontalAlignment="Right">
  13.                     <Button x:Name="AddAllButton" x:Uid="AddAllButton" HorizontalAlignment="Left" Style="{StaticResource CheckAppBarButtonStyle}" Click="AddAllButton_Click" />
  14.                     <Button x:Name="DelAllButton" x:Uid="DelAllButton" HorizontalAlignment="Left" Style="{StaticResource UnCheckAppBarButtonStyle}" Click="DelAllButton_Click" />
  15.                       <Button x:Name="AlbumButton" x:Uid="AlbumButton" HorizontalAlignment="Left" Style="{StaticResource AlbumAppBarButtonStyle}" />
  16.                        <Button x:Name="PinButton"   x:Uid="PinButton" Visibility="{Binding PinUnpinSecondaryTile, Converter={StaticResource BooleanToCollapseConverter}}" HorizontalAlignment="Right" Style="{StaticResource PinAppBarButtonStyle}" Click="Pin_Click" />
  17.                     <Button x:Name="UnPinButton" x:Uid="UnPinButton" Visibility="{Binding PinUnpinSecondaryTile,Converter={StaticResource BooleanToVisibilityConverter}}" HorizontalAlignment="Right" Style="{StaticResource UnpinAppBarButtonStyle}" Click="UnPin_Click" />
  18.                 </StackPanel>
  19.             </Grid>
  20.         </AppBar>
  21.     </Page.BottomAppBar>

Les commandes contextuelles AddButton et DelButton se trouvant à gauche les autres à droite.

1ere remarque : Tout d’abord, le style des boutons est défini sur un style particulier par exemple CheckAppBarButtonStyle pour le bouton AddButton.

Ce style est présent dans le fichier StandardStyles.xaml,

Code Snippet
  1. <Style x:Key="CheckAppBarButtonStyle" TargetType="Button" BasedOn="{StaticResource AppBarButtonStyle}">
  2.         <Setter Property="AutomationProperties.AutomationId" Value="CheckAppBarButton"/>
  3.         <Setter Property="AutomationProperties.Name" Value="Check"/>
  4.         <Setter Property="Content" Value="&#x2714;"/>
  5.     </Style>

 

Ce qui donne comme résultat image

Ce que l’on peut constater c’est que la propriété Content est remplie par le code de caractère 2714, ce qui dans la fonte Segoe UI Symbol donne ✔ et que le texte “Ajouter” est un texte qui provient de la propriété AutomationProperties.Name. Pour que ce texte soit traduit automatiquement en fonction du langage choisi dans les préférences de Windows, il faut encore une fois utiliser la propriété x:Uid du bouton, comme je l’ai indiqué dans le jour 2 de cette série.

Néanmoins, la syntaxe est légérement différente et ne s’invente pas malheureusement. Si vous retournez dans le fichier Resources.resw, il faudra ajouter la syntaxe suivante :

Name = AddButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name   

Value = Ajouter   

 

Les boutons contextuels sont réglés pour apparaitre en fonction de la selection à l’aide du modèle DisplayElement, qui sera renseigné à l’ouverture de l’AppBar, par le nombre d’éléments sélectionnés.

Code Snippet
  1. void PageAppBar_Opened(object sender, object e)
  2.         {
  3.             String expansionId = _vueData.CurrentExpansion.id.ToString();
  4.             Boolean isTileExist = URZATileManager.IsSecondaryTileExists(expansionId);
  5.             this.DefaultViewModel["PinUnpinSecondaryTile"] = isTileExist;
  6.             this.DefaultViewModel["DisplayElement"] = CardsItemsGridView.SelectedItems.Count;
  7.             
  8.         }

 

et du Converter IntToVisibilityConverter attaché à sa propriété Visibility.

Code Snippet
  1. class IntToVisibilityConverter : IValueConverter
  2.     {
  3.         public object Convert(object value, Type targetType, object parameter, string language)
  4.         {
  5.             var count = (int)value;
  6.             return count>0 ? Visibility.Visible : Visibility.Collapsed;
  7.         }
  8.  
  9.         public object ConvertBack(object value, Type targetType, object parameter, string language)
  10.         {
  11.             return value is Visibility && (Visibility)value == Visibility.Visible;
  12.         }
  13.     }

 

 

Par défaut, la selection multiple du contrôle GridView n’étant pas activée, il ne faut pas oublier de le faire.

 

 

Code Snippet
  1.      <GridView
  2.     SelectionChanged="CardsItemsGridView_SelectionChanged"
  3.     x:Name="CardsItemsGridView"
  4.             SelectionMode="Multiple"

 

Ensuite sur l’évenement click des boutons AddButton/DelButton par exemple , nous allons  tout d’abord déclencher la méthode SetUserData, qui aura juste pour rôle d’affecter à la propriété IsChecked d’un objet UrzaCard, si oui ou non elle fait partie de la collection de l’utilisateur.

Code Snippet
  1. private async void AddButton_Click(object sender, RoutedEventArgs e)
  2.     {
  3.         try
  4.         {
  5.             SetUserData(true);
  6.             await _vueData.SerializeUserDataAsync();
  7.          }
  8.         catch (Exception ex)
  9.         {
  10.             Helper.ShowOnError(ex, UrzaResources.AppErrorMessage);
  11.         }
  12.     }
  13.     private void SetUserData(bool adddata)
  14.     {
  15.         var SelectedCardsItem = CardsItemsGridView.SelectedItems;
  16.         foreach (var objCard in SelectedCardsItem)
  17.         {
  18.  
  19.             var card = (URZACard)objCard;
  20.             card.IsChecked = adddata;
  21.  
  22.  
  23.         }
  24.         if (adddata == false)
  25.         {
  26.             foreach (var objCard in SelectedCardsItem)
  27.             {
  28.  
  29.                 CardsItemsGridView.SelectedItems.Remove((URZACard)objCard);
  30.  
  31.             }
  32.         }
  33.         if (SelectedCardsItem.Count > 0 || adddata == false)
  34.             _vueData.AppliedFiltersAsync();
  35.     }
Puis ensuite nous déclenchons la sauvegarde, ou plutot la sérialisation XML de la collection de l’utilisateur. SerializeUserDataAsync()
Pour la serialisation de la collection de l’utilisateur, j’ai, pour simplifier le processus, crée de nouvelles classes sérialisables qui ne contiendront que le strict minimum
et ceci afin d’éviter de sérialiser la totalité des données contenues dans une carte.
Code Snippet
  1. public class URZAUserData
  2.     {
  3.         public int Version { get; set; }
  4.         public List<URZAUserDataExpansion> Expansions;
  5.         public URZAUserData()
  6.         {
  7.             Expansions = new List<URZAUserDataExpansion>();
  8.         }
  9.     }
  10.     public class URZAUserDataCard
  11.     {
  12.         public int Id;        
  13.     }
  14.     public class URZAUserDataExpansion
  15.     {
  16.         public int ExpansionId;        
  17.         public List<URZAUserDataCard> UserCards;
  18.         public URZAUserDataExpansion()
  19.         {
  20.             UserCards = new List<URZAUserDataCard>();
  21.         }
  22.     }
 
Code Snippet
  1. private async Task internalSerializeUserDataAsync(URZAUserData userData)
  2.         {
  3.             try
  4.             {
  5.                 await _semaphoreForUserData.WaitAsync(SEMAPHORE_MAX_WAIT);
  6.                
  7.                     var folder = ApplicationData.Current.LocalFolder;
  8.                     IStorageFile storageFile = await folder.CreateFileAsync(USERDATA_FILE, CreationCollisionOption.ReplaceExisting);
  9.                     XmlSerializer x = new XmlSerializer(typeof(URZAUserData));
  10.                     using (var stream = await storageFile.OpenStreamForWriteAsync())
  11.                     {
  12.                         x.Serialize(stream, userData);
  13.                     }                                                                   
  14.             }
  15.             finally
  16.             {
  17.                 _semaphoreForUserData.Release();
  18.             }
  19.         }
 
 

En faite, dans le code livré avec ce billet, c’est un peu plus complexe que cela et je vous laisse le découvrir. Mais le principe est de tester si le fichier existe déjà, si oui de déserialiser les données qu’il contient, afin de les fusionner avec les données qui viennent d’être selectionnées. Cela se complique encore, lorsque le fichier est présent sur SkyDrive (Connexion que nous verrons plus tard), car il faudra tester la version de la collection de l’utilisateur.

 

Pour identifier qu’une carte est selectionnée, on va utiliser la propriété IsChecked de chaque carte afin de lui affecter un style particulier comme dans l’image suivante :

image7

Pour se faire : on va passer dans mon exemple par un DataTemplateSelector

Code Snippet
  1. class CardsDataTemplateSelector:DataTemplateSelector
  2.     {
  3.         static DataTemplate UrzaCheckedCardsItemsGridViewItemTemplate = Application.Current.Resources["UrzaCheckedCardsItemsGridViewItemTemplate"] as DataTemplate;
  4.         static DataTemplate UrzaCardsItemsGridViewItemTemplate = Application.Current.Resources["UrzaCardsItemsGridViewItemTemplate"] as DataTemplate;
  5.             
  6.         protected override DataTemplate SelectTemplateCore(object item, DependencyObject container)
  7.         {
  8.             var card = item as URZACard;
  9.             return (card.IsChecked == true) ? UrzaCheckedCardsItemsGridViewItemTemplate : UrzaCardsItemsGridViewItemTemplate;
  10.         }
  11.     }

 

 

 

Dans le fichier Expansion.Xaml, il suffira alors d’y faire reference dans les ressources, puis d’indiquer l’ItemTemplateSelector adéquate pour le GridView.

Code Snippet
  1. <Page.Resources>
  2.         <common:CardsDataTemplateSelector x:Key="cardsDataTemplateSelector"/>
  3.                      <GridView
  4.             SelectionChanged="CardsItemsGridView_SelectionChanged"
  5.             x:Name="CardsItemsGridView"
  6.                         SelectionMode="Multiple"
  7.             Grid.Row="2"
  8.             Margin="0,-3,0,0"
  9.             Padding="116,0,40,46"
  10.             IsItemClickEnabled="True"
  11.             ItemsSource="{Binding Source={StaticResource groupedCardsItemsViewSource}}"
  12.                                     ItemClick="cardsItemsGridView_ItemClick"
  13.             ItemTemplateSelector="{StaticResource cardsDataTemplateSelector}">

 

Se connecter à SkyDrive

La collection de l’utilisateur sera à la fois sauvegardée localement, mais également sur son compte SkyDrive.

Tout d’abord, vous devez télécharger et installer le SDK Live. et le référencer dans votre projet :
image3

 

Le SDK s’installant dans le répertoire : C:\Program Files (x86)\Microsoft SDKs\Live\v5.0

Ensuite il faut inscrire votre application, afin d’obtenir un Package Name, qui permettra d’identifer votre application de façon unique comme illustré sur la figure suivante . Pour cela il suffit de suivre les étapes décrites ici : https://manage.dev.live.com/build?wa=wsignin1.0

image

Si vous ne suivez pas cette étape, la connexion à SkyDrive ne fonctionnera pas.

Avec ce SDK, il est possible de créer son propre bouton de connexion comme décrit par David Catuhe dans son article, ou alors d’utiliser le contrôle prévu à cette effet, comme je l’ai fait dans la vue Home.XAML

Code Snippet
  1. <Controls:SignInButton Content="SignInButton" Grid.Column="2" HorizontalAlignment="Left"
  2.                        Margin="10,10,0,0" VerticalAlignment="Top" Width="233"
  3.                        SessionChanged="SignInButton_SessionChanged_1" Branding="Skydrive" Theme="Light" Height="41"/>

 

Lors de la 1ere utilisation,  la boite de connexion s’affiche.

image5

Une fois connecté j’affiche l’état de la connexion en affichant le nom de la personne connectée.

image6

Pour contrôler ce qui se passe, j’ai abonné le bouton à l’évenement SessionChanged, dans lequel je vais initialiser les options de SkyDrive par l’intermediaire d’une classe Helper SkyDriveHelper

Code Snippet
  1. private async void SignInButton_SessionChanged_1(object sender, Microsoft.Live.Controls.LiveConnectSessionChangedEventArgs e)
  2.         {
  3.             var status = e.Status;
  4.             if (e.Status == LiveConnectSessionStatus.Connected)
  5.             {
  6.  
  7.                 await SkyDriveHelper.InitAuthenticationAsync();
  8.                 txtNameProfile.Text = SkyDriveHelper.Profile["name"].ToString();
  9.  
  10.  
  11.             }
  12.             else
  13.             {
  14.                 SkyDriveHelper.IsUserLogged = false;
  15.                 txtNameProfile.Text = "";
  16.             }
  17.         }
 

 

La méthode InitAuthenticationAsync(), va initialiser le champ d’application de l’application. Entre autre la possibilité de mettre à jour SkyDrive, car ensuite nous allons y créer un repertoire, puis y uploader un fichier. Ensuite je crée une connection client avec l’état de session, puis je télécharge le profile de la connection, me permettant d’afficher le nom de l’utilisateur connecté.

Code Snippet
  1.        public static async TaskInitAuthenticationAsync()
  2.       {
  3.           if (!NetworkInterface.GetIsNetworkAvailable()) return;
  4.  
  5.           if (Session != null) return;
  6.           
  7.               _authenticationClient = new LiveAuthClient();                
  8.               List<String> scopes = new List<String>() { "wl.signin",   "wl.skydrive_update" };                
  9.               LiveLoginResult authenticationResult = await _authenticationClient.InitializeAsync(scopes);
  10.               if (authenticationResult.Status == LiveConnectSessionStatus.Connected)
  11.               {                    
  12.                   Session = authenticationResult.Session;
  13.                   _client = new LiveConnectClient(Session);
  14.                   IsFirstConnectionToSkyDrive = await CreateSkyDriveFolderAsync();                                                                                      
  15.                   await LoadProfileAsync(Session);
  16.                   _userLogged = true;                                        
  17.               }            
  18.       }

 

La création du repertoire “Urza” sur SkyDrive est assez simple, il suffira de poster les informations nécessaire à sa création. puis de sauvegarder son numéro d’identification dans les paramètres itinérant. Ce numéro d’identification qui est sous la forme “folder.9607f0bf305f86d2.9607F0BF305F86D2!681” nous servira comme chemin pour l’upload du fichier de la collection des cartes. A noter que je retourne true ou false, ce qui permet de determiner dans la propriété IsFirstConnectionToSkyDrive si c’est la 1ere fois que le répertoire a été crée.

Code Snippet
  1. public static async Task<Boolean> CreateSkyDriveFolderAsync()
  2.       {
  3.           if (Session == null) return false;
  4.  
  5.           try
  6.           {
  7.               IDictionary<String, Object> body = new Dictionary<String, Object>();
  8.               body["name"] = "Urza";
  9.               body["description"] = "UrzaGatherer repository folder";
  10.               LiveOperationResult result = await _client.PostAsync("me/skydrive", body);
  11.               IDictionary<String, Object> r = result.Result;
  12.               URZASettings.SaveRoamingSkyDriveFolder(r["id"].ToString());
  13.               return true;
  14.           }
  15.           catch (LiveConnectException lcex)
  16.           {
  17.               if (lcex.ErrorCode=="resource_already_exists")
  18.                   return false;
  19.               throw;
  20.           }
  21.       }
 
 
L’upload du fichier sur SkyDrive ce fait à chaque fois que l’utilisateur ajoute ou supprime une carte dans sa collection, est également assez simple, 
il suffit d’utiliser la méthode BackGroundUploadAsync du SDK Live.
Cette méthode prend comme paramère :
  • Le FolderId (Ex. folder.9607f0bf305f86d2.9607F0BF305F86D2!681),
  • Le nom du fichier (Attention, le nom de fichier doit avoir IMPERATIVEMENT l’extension .txt),
  • Le contenu fichier à sauvegarder,
  • Puis la valeur true pour indiquer que l’on veut ecraser l’ancien fichier.
Ensuite, nous sauvegardons la source du fichier dans les paramètres itinérant, qui correspond à une Uri du type :
 http://storage.live.com/s1pBoQfS-WhonrKV7bCPsqQdDOLTtuQShJ76mz4EwW9_2OsgyP5M4_aY7BncUOTpfWsdsrHKID31j4F9Huo7h31W9DhUbl9WjFIa0hpeP7WDCJs3W4CEFMfOZyXnofcbCgn/UserData.txt:Binary,Default/UserData.txt
Et ceci car nous la réutiliseront par la suite.
Code Snippet
  1. public static async Task<Boolean> UploadFileAsync(String fileName)
  2.  {
  3.      if (Session==null) return false;
  4.  
  5.          try
  6.          {                    
  7.              var file = await ApplicationData.Current.LocalFolder.GetFileAsync(fileName);
  8.              var folderId = URZASettings.GetRoamingSkydriveFolder();
  9.              if (folderId == String.Empty)
  10.              {
  11.                  //Hum this mean that we have a problem
  12.                  return false;
  13.              }
  14.  
  15.              LiveOperationResult liveOpResult =
  16.                  await _client.BackgroundUploadAsync(folderId, fileName, file, true);                    
  17.              URZASettings.SaveRoamingSkyDriveFileFolder(liveOpResult.Result["source"].ToString());
  18.              return true;
  19.          }
  20.          catch (Exception ex)
  21.          {                    
  22.              return false;
  23.          }
  24.      
  25.  }
 
Ensuite tout se passe au chargement de la vue Expansion, ou j’appelle la méthode DeserializeUserDataAsync(). 
Cette méthode à pour but de déserialiser le flux XML pour en construire une classe URZAUserData, afin de mettre la propriété IsCheck à true, en fonction de la présence 
de la carte dans le fichier.
Code Snippet
  1. private static URZAUserData DeserializeUserData(Stream stream)
  2.       {
  3.           XmlSerializer x = new XmlSerializer(typeof(URZAUserData));                
  4.           URZAUserData data = (URZAUserData)x.Deserialize(stream);
  5.           return data;
  6.       }
  7.  
  8.       public async Task DeserializeUserDataAsync()
  9.           {
  10.  
  11.           
  12.                   URZAUserData data = await internalDeserializeUserDataAsync();
  13.                   if (data == null) return; //Nothing to deserialize
  14.  
  15.                   
  16.                   var query = from expansion in data.Expansions where expansion.ExpansionId == CurrentExpansion.id select expansion;
  17.                   
  18.                   if (query.ToList<URZAUserDataExpansion>().Count == 0) return;
  19.                   var UserExpansion = query.First<URZAUserDataExpansion>();
  20.                   var UserCards = UserExpansion.UserCards;
  21.                   var cards = CurrentExpansion.cards;
  22.  
  23.                   foreach (var userCard in UserCards)
  24.                   {
  25.                       var queryLookup = from card in cards where card.id == userCard.Id select card;
  26.                       queryLookup.First<URZACard>().IsChecked = true;
  27.                   }                            
  28.           }
 
 

Néanmoins, avant on va la 1ere fois tester si la version locale du fichier est plus récente que la version sur SkyDrive et en fonction récuperer le bon flux de données
 
Code Snippet
  1. public async Task<URZAUserData> internalDeserializeUserDataAsync()
  2.         {
  3.             var folder = ApplicationData.Current.LocalFolder;
  4.             var folderId = URZASettings.GetRoamingSkydriveFolder();
  5.  
  6.             //First, test if it's the first fresh install or if whe don't have the SkyDrive folderID roaming state
  7.             //does this means that the file does not exist also on skydrive
  8.             if (SkyDriveHelper.IsFirstConnectionToSkyDrive || folderId==String.Empty)
  9.             {
  10.                 if (!await folder.IsFileExistsAsync(USERDATA_FILE))
  11.                     return null;    
  12.             
  13.                 try
  14.                 {
  15.                     var stream = await folder.OpenStreamForReadAsync(USERDATA_FILE);
  16.                     return DeserializeUserData(stream);
  17.                 }
  18.                 catch (Exception)
  19.                 {
  20.                     //for any reason return null so the file will be re-created
  21.                     return null;
  22.                 }
  23.                 
  24.             }
  25.                             
  26.             //Else If isn't the first connection
  27.  
  28.             //First test if the file exist localy if not download it from skydrive
  29.             if (!await folder.IsFileExistsAsync(USERDATA_FILE))
  30.             {
  31.  
  32.                 if (!NetworkInterface.GetIsNetworkAvailable() || !SkyDriveHelper.IsUserLogged)
  33.                 {
  34.                     //the locale file have to be created localy
  35.                     return null;
  36.                 }
  37.               
  38.                 try
  39.                 {
  40.                     var storageFile = await folder.CreateFileAsync(USERDATA_FILE, CreationCollisionOption.ReplaceExisting);
  41.                     var fileId = URZASettings.GetRoamingSkydriveFile();
  42.                     await SkyDriveHelper.DownloadFileAsync(fileId, storageFile);
  43.                     var stream = await folder.OpenStreamForReadAsync(USERDATA_FILE);
  44.                     return DeserializeUserData(stream);
  45.                 }
  46.                 catch (Exception ex)
  47.                 {
  48.                     //for any reason recreate the file
  49.                     return null;
  50.  
  51.                 }
  52.             }
  53.  
  54.  
  55.             //the file exist localy
  56.             
  57.                 var localStream = await folder.OpenStreamForReadAsync(USERDATA_FILE);
  58.                 var localData = DeserializeUserData(localStream);
  59.                 if (!NetworkInterface.GetIsNetworkAvailable() || !SkyDriveHelper.IsUserLogged)
  60.                 {                                                
  61.                     return localData;
  62.                 }
  63.  
  64.                 try
  65.                 {
  66.                     //No need to check Again
  67.                     if (SkyDriveHelper.IsRemoteFileVersionAlreadyChecked) return localData;
  68.  
  69.                     var source = URZASettings.GetRoamingSkydriveFile();
  70.                     if (source == String.Empty)
  71.                     {
  72.                         return localData;
  73.                     }
  74.                     
  75.                     var roamingStream = await SkyDriveHelper.DownloadFileAsync(source);                                            
  76.                     var roamingData = DeserializeUserData(roamingStream);
  77.                     SkyDriveHelper.IsRemoteFileVersionAlreadyChecked = true;
  78.                     if (roamingData.Version > localData.Version)
  79.                     {
  80.                         internalSerializeUserDataAsync(roamingData);
  81.                         return roamingData;
  82.                     }
  83.                     else
  84.                     {
  85.                         UploadOnSkyDriveAsync();
  86.                         return localData;
  87.                     }
  88.  
  89.                 }
  90.                 catch (Exception ex)
  91.                 {
  92.                     //For any reason re-create the local file
  93.                     return null;
  94.                 }
  95.             
  96.             
  97.         }

Le téléchargement du fichier est assez simple, car il suffit d’utiliser la source (correspondant à l’uri vue plus haut) avec la méthode BackgroundDownloadAsync().

Code Snippet
  1. public static async Task<Stream> DownloadFileAsync(String source)
  2.         {
  3.             Stream stream = null;
  4.             if (Session == null) return null;
  5.             try
  6.             {
  7.                 var LiveOperationResult = await _client.BackgroundDownloadAsync(source);
  8.                 stream=LiveOperationResult.Stream.AsStreamForRead();
  9.             }
  10.             catch (System.Exception ex) //file not found
  11.             {
  12.  
  13.                 stream = null;
  14.             }
  15.             return stream;            
  16.         }
 
 
Ainsi avec une API assez réduite (à peine 5 fonctions), vous allez pouvoir vous connecter sur Skydrive et y créer vos fichiers et vos répertoires.

 

A bientôt

 

Eric Vernié