WPF, ListView d’images, MVVM et Drag and Drop… – Partie 3

WPF

Introduction

Vu précédemment

Nous avons vu dans la première partie comment implémenter une liste de fichiers en WPF avec le pattern MVVM.

Dans la deuxième partie, nous avons vus comment optimiser l’interface utilisateur avec le VirtualizingStackPanel, le multi Thread, les animations d’attente WPF. Nous avons eu également un aperçu de la manipulation des images pour utiliser lorsqu’elles existent les informations EXIF ou encore une transformation classique de ces images.

Je vous propose de voir dans cette troisième partie :

La mise en cache des images (améliorons l’interface utilisateur encore un petit peu)
Le Drag and Drop avec une sélection multiple d’éléments

Optimisation avec mise en cache

Implémentation d’un système de cache

Le but est de garder les x dernières images déjà chargée afin d’éviter un rechargement permanent de ces images.

Pour cela nous mettons en place une liste partagée en appel static, ainsi que son verrou (nous sommes dans un environnement multi-thread) afin de garantir l’écriture correcte des données.

const int maxThumbnailInCache = 300;
private static readonly List<ImageFileViewModel> _cacheThumbnail 
= new List<ImageFileViewModel>();
private static readonly object _lockCacheThumbnail = new object();

Puis nous implémentons la méthode static AddThumbnailInCache

 private static void AddThumbnailInCache(ImageFileViewModel p)
{
  if (p == null) return;
  if (_cacheThumbnail.Contains(p))
  {
      lock (_lockCacheThumbnail)
      {
          _cacheThumbnail.Remove(p);
      }
  }

  lock (_lockCacheThumbnail)
  {
      _cacheThumbnail.Add(p);
      if (_cacheThumbnail.Count > maxThumbnailInCache)
          lock (_lockCacheThumbnail)
          {
              _cacheThumbnail.Remove(_cacheThumbnail[0]);
          }
  }
}

La méthode teste si l’élément est présent. Si il est présent, l’élément est replacé à la fin de la liste.

Si le nombre d’éléments dépasse le maximum d’élément fixés dans le cache (maxThumbnailInCache), l’élément en haut (le plus ancien) est supprimé. Poursuivre la lecture →

Méthodes dynamiques (classe DynamicMethod) en .NET

Utiliser la réflexion pour invoquer des méthodes non connues à la compilation peut être problématique en terme de performances dans des applications critiques. L’exécution de ces méthodes est environ 2,5 à 3 fois plus lente qu’un appel directe.
Voici un exemple :

    class Program
    {
        [DllImport("kernel32.dll")]
        static extern void QueryPerformanceCounter(ref long ticks);

        static PropertyInfo _intProp = typeof(Foo).GetProperty("IntProp", BindingFlags.Public | BindingFlags.Instance);

        static void Main(string[] args)
        {
            Foo foo = new Foo { IntProp = 10 };
            const int COUNT = 1;
            Console.WriteLine(Measure(() => ReadPropertyWithReflection(foo), COUNT));
            Console.WriteLine(Measure(() => ReadPropertyDirectly(foo), COUNT));
        }

        static void ReadPropertyWithReflection(Foo foo)
        {
            int intProp = (int)_intProp.GetValue(foo, null);
        }

        static void ReadPropertyDirectly(Foo foo)
        {
            int intProp = foo.IntProp;
        }

        static long Measure(Action action, int count)
        {
            long startTicks = 0;
            QueryPerformanceCounter(ref startTicks);
            for (int i = 0; i < count; i++)
            {
                action();
            }
            long endTicks = 0;
            QueryPerformanceCounter(ref endTicks);
            return endTicks - startTicks;
        }

        class Foo
        {
            public int IntProp { get; set; }
        }
    }

Et voici les résultats :

Type d’accès	unités CPU
Invocation par accès directe	796
Invocation par Réflexion	1986

Ainsi, l’utilisation de la réflexion pour lire une propriété est 2,5 fois plus lente que l’accès directe à cette propriété.

Les méthodes dynamiques peuvent être utilisées pour générer et exécuter une méthode à l’exécution sans devoir déclarer une assemblie dynamique et un type dynamique qui contiendront la méthode. Elles représentent un moyen plus efficace pour générer et exécuter ce type de code.

Poursuivre la lecture →

Transactional NTFS (partie 1/2)

Transactional NTFS et DotNet

Microsoft introduit un concept intéressant à partir des versions de Windows Vista et Server 2008.
Cette nouveauté est appelée Transactional NTFS (TxF).
Elle permet aux développeurs d’écrire des fonctions d’Entrée/Sortie garantissant le succès complet ou le rejet complet en cas d’erreur d’un ensemble d’opérations.

Malheureusement il n’existe pas de classe DotNet(au moins jusqu’à la version 3.5 SP1) permettant de manipuler simplement ce type d’opérations.

Pour manipuler ces opérations, nous avons besoin de passer par le P/Invoke pour utiliser ces fonctions :

CreateTransaction, CommitTransaction, RollbackTransaction et DeleteFileTransacted

Poursuivre la lecture →

Manipulations de matrices avec du code non sécurisé

La classe Matrix

Dans cet article nous allons comparer 2 méthodes qui traitent de multiplication de matrices en .Net | C#.

Nous commençons par la définition de la classe matrice : Matrix

    class Matrix
    {
        private readonly double[,] _matrix;
        public Matrix(int dim1, int dim2)
        {
            _matrix = new double[dim1, dim2];
        }

        public int Height { get { return _matrix.GetLength(0); } }
        public int Width { get { return _matrix.GetLength(1); } }

        public double this[int x, int y]
        {
            get { return _matrix[x, y]; }
            set { _matrix[x, y] = value; }
        }
    }

Multiplications de matrices

Voici le premier algorithme de multiplication de matrice qui réalise l’opération de manière standard.

    public static Matrix NaiveMultiplication(Matrix m1, Matrix m2)
    {
        Matrix resultMatrix = new Matrix(m1.Height, m2.Width);
        for (int i = 0; i < resultMatrix.Height; i++)
        {
            for (int j = 0; j < resultMatrix.Width; j++)
            {
                resultMatrix[i, j] = 0;
                for (int k = 0; k < m1.Width; k++)
                {
                    resultMatrix[i, j] += m1[i, k] * m2[k, j];
                }
            }
        }
        return resultMatrix;
    }

Voici le second algorithme qui réalise la même chose, mais cette fois en utilisant du code non sécurisé (unsafe)

Poursuivre la lecture →