Le contrôle Comarch.POS.Presentation.Core.Controls.DataGrid est basé sur celui connu du .NET et permet d’afficher une collection de données divisée en colonnes et lignes. Le contrôle DataGrid dans POS permet en outre de télécharger les données de manière asynchrone, il prend en charge la pagination de liste (chargement des données lors du défilement de liste), modifie la façon d’effectuer le tri des données, ainsi que le mécanisme de groupement en l’enrichissant d’agrégation des données.

Télécharger les données de manière asynchrone

Pour que les données soient téléchargées de manière asynchrone, il faut binder leur source avec la propriété AsyncItemsSource dans le DataGrid. La source de données doit être un objet de la classe AsyncDataGridCollection<T> où T est le type de données qui sera affiché dans une seule ligne. La logique responsable d’acquisition de données doit être définie dans le premier paramètre du constructeur de la classe AsyncDataGridCollection. Les données téléchargées doivent à leur tour être attribuées à la collection Data.

Exemple :

Documents = new AsyncDataGridCollection<TradeDocumentListRow>(
    (token, o) =>
    {                   
                   //téléchargement de données
        var documents = GetDocumentsAsync(token, o);
 
                  //À un moment donné, seul un fil peut modifier une collection
        lock (Documents.DataLock)
        {
                           //pris en charge d'annulation de téléchargement
            if (token.IsCancellationRequested)
            return null;

                            //chaque rafraîchissement de la liste exige qu'elle soit effacée
            Documents.Data.Clear();
 				
                            //ajout des données à la collection qui sera lue par DataGrid		 
            Documents.Data.AddRange(data);			
        }
 
    return documents;
    }, OnReceiptsOperationCompleted, loggingService);

L’exemple au dessus présente la définition de la propriété Documents implémentée dans le constructeur de viewmodel qui est bindé avec la propriété AsyncItemsSource du contrôle DataGrid. Le premier argument du constructeur est une logique simple de téléchargement de données (sans prendre en compte la pagination). La méthode sera automatiquement appelée de manière asynchrone directement par le contrôle de DataGrid, dès que celui-ci est initialisé. Pour décider manuellement à quel moment les données seront téléchargées, il faut modifier la valeur de la propriété LoadDataOnDataGridInitialization=false dans l’objet Documents. Au moment où l’on voudra télécharger les données, il faudra appeler la méthode Documents.Refresh(false). Le deuxième argument du constructeur est la méthode qui sera appelée dans le fil principal (UI) juste après l’achèvement de la logique de téléchargement. Le troisième paramètre est une instance du service d’enregistrement d’erreurs ILoggingService, grâce à laquelle les exceptions potentielles retrouvées dans le fil de téléchargement seront enregistrées dans les journaux système de l’application.

Tri de données

La pagination peut être défini par défaut et modifier par l’utilisateur à tout moment en cliquant la colonne sélectionnée. Les paramètres par défaut peuvent être en revanche modifiés dans le panneau de gestion des vues. Le contrôle n’exécute pas la tâche lui-même, mais la délègue à la source de données, en lançant une méthode de récupération qui envoie uniquement des informations sur la méthode de tri souhaitée. Les informations comment trier les données téléchargées peuvent être lues dans la propriété Sorting dans l’objet Documents.

Sorting : List<GridSortDescription> – liste contentant l’information selon quelle colonne les données ont été triées et de quelle façon.

Composants de la classe GridSortDescription :

PropertyName : string – nom de colonne défini dans la propriété SortMemberPath de colonne. Si le nom n’est pas défini, le nom par défaut utilisé est le nom de la propriété utilisée dans le binding.

Direction : ListSortDirection – sens de tri, peut être croissant ou décroissant.

Column : DataGridColumn – référence à la colonne

Pagination de liste

La pagination, ou en fait la lecture dynamique des données pendant le défilement de la liste, est basée sur le fait que le contrôle DataGrid, lorsque l’utilisateur approche de la fin de la liste, initie une méthode asynchrone qui va chercher les données, en informant la source qu’une autre portion sera nécessaire si elle existe. Ce mécanisme permet une prise en charge effective de grands ensembles de données, où le téléchargement de l’ensemble entier ne serait ni effectif ni efficace.

La logique de la pagination doit être implémentée dans la source. Pour savoir quelle portion de données est requis par le contrôle, il faut utiliser les propriétés ItemsToTake et ItemsToSkip qui sont emplacées dans l’objet de la classe AsyncDataGridCollection<T>.

temsToTake : int – nombre de lignes des données requis par le contrôle.

ItemsToSkip : int – nombre de lignes des données qui doivent être omis en comptant à partir du début d’ensemble (ce nombre représente le nombre de lignes qui ont déjà été téléchargées).

Groupement et agrégation

Le contrôle DataGrid prend en charge le mécanisme de groupement et d’agrégation des valeurs des entités de la collection présentée par le contrôle. Activer la fonction du groupement désactive le mécanisme de la pagination de données. Afin d’activer le groupement, il faut définir sur le contrôle la propriété IsGroupingEnabled=”True”. Le groupement est entièrement gérable dans la vue de gestion UI et il permet de grouper et agréger selon les critères définis auparavant. Pour qu’une propriété puisse être groupée, elle doit être marquée avec l’attribut [AllowGroupBy] (de l’espace nom : Comarch.POS.Core). Facultativement, l’attribut permet de définir le chemin du fichier ressource et le postfixe de clé avec traduction. L’attribut par défaut est Properties.Resources et chaque clé est le nom de la propriété plus le postfixe Header. Par exemple, la clé pour la propriété Name sera NameHeader.

L’agrégation est possible uniquement selon toutes les propriétés portant la marque de l’attribut AllowGroupBy. Les moyens d’agrégation suivants sont disponibles dans la version standard de l’application : Somme, Moyen, Maximum et Minimum. Ces moyens fonctionnent uniquement sur les propriétés du type numérique ou string qui est converti en type numérique.

Extensions d’agrégation

Afin d’ajouter un moyen d’agrégation personnalisé, il faut créer une nouvelle classe d’implémentation IAggregationType (espace nom : Comarch.WPF.Controls.Aggregation). Il faut implémenter dans cette classe le mécanisme d’agrégation dans la propriété Function.

Supposons que la nouvelle agrégation personnalisée soit réalisée uniquement sur les chiffres, au lieu d’implémenter l’interface il est possible d’hériter de la classe AggregationNumberType. Ensuite, la méthode Aggregate peut être surchargée sans se soucier de la vérification des types des données agrégées.

À la fin, la classe créée doit être enregistrée dans le système comme le nouveau moyen d’agrégation. Dans la classe module il faut appeler la méthode RegisterDataGridGroupAggregation, transmettre le nom de la classe et définir la clé et le ressource à partir duquel seront téléchargées les traductions pour le nouveau moyen d’agrégation.

Pour plus d’informations, voir le chapitre Exemple d’utilisation du moyen d’agrégation de données personnalisé dans DataGrid dans l’article Exemples.

Groupement des attributs

Le groupement et l’agrégation selon les attributs fonctionnent automatiquement et n’exigent pas d’implémentation supplémentaire. Il est important que l’entité d’élément contenant les attributs possède les propriétés :

• Attributes du type répértoire Dictionary<string,AttributeEntity>
• AttributeRows du type AttributesDictionary.