Archives journalières: 19 mai 2010

2 articles

LINQ to XML et la lecture des très gros fichiers

C#

LINQ to XML est relativement facile à implémenter pour lire de gros fichiers et pour requêter des fichiers XML.
Par exemple, considérons ce fichier XML :

    <?xml version="1.0" encoding="utf-8" ?>
    <users>
        <user name="User1" groupid="4" />
        <user name="User2" groupid="1" />
        <user name="User3" groupid="3" />
        <user name="User4" groupid="1" />
        <user name="User5" groupid="1" />
        <user name="User6" groupid="2" />
        <user name="User7" groupid="1" />
    </users>

Supposons que vous souhaitez trouver tous les enregistrements avec groupid > 2. Vous pouvez être tenté d’implémenter la requête suivante :

    XElement doc = XElement.Load("users.xml");
    var users = from u in doc.Elements("user")
                where u.Attribute("groupid") != null &&
                int.Parse(u.Attribute("groupid").Value) > 2
                select u;
    Console.WriteLine("{0} users match query", users.Count());

Il y a un piège dans cette implémentation. La méthode XElement.Load va lire tout le fichier XML en mémoire avant de s’exécuter, et ce fichier peut être très gros.

Poursuivre la lecture →

Méthodes dynamiques (classe DynamicMethod) en .NET

C#

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 →