Xpath : utilisez des requêtes paramétrées

Soyez le premier à donner votre avis sur cette source.

Vue 11 317 fois - Téléchargée 432 fois

Description

Il s'agit des sources utilisées pour le post "XPath : utilisez des requêtes paramétrées" que vous trouverez ici : http://blogs.codes-sources.com/coq/archive/2007/03/18/xpath-utilisez-des-requ-tes-param-tr-es.aspx

Ces sources contiennent notamment le contexte personnalisé : la classe CustomContext.

Source / Exemple :


using System;
using System.Xml;
using System.Xml.Xsl;
using System.Xml.XPath;
using System.Collections.Generic;

namespace PersonsXPath
{
    class CustomContext : XsltContext
    {
        #region Constructeurs

        public CustomContext()
            : base()
        {
        }

        public CustomContext(NameTable table)
            : base(table)
        {
        }

        #endregion Constructeurs

        #region Champs

        /// <summary>
        /// Contient les variables.
        /// </summary>
        private Dictionary<String, IXsltContextVariable> _variables
            = new Dictionary<String, IXsltContextVariable>();

        #endregion Champs

        #region Implémentation de XsltContext

        public override int CompareDocument(String baseUri, String nextbaseUri)
        {
            // Nous utilisons simplement une comparaison de chaîne.
            return String.CompareOrdinal(baseUri, nextbaseUri);
        }

        public override bool PreserveWhitespace(System.Xml.XPath.XPathNavigator node)
        {
            return true;
        }

        public override bool Whitespace
        {
            get
            {
                return true;
            }
        }

        public override IXsltContextFunction ResolveFunction(
            String prefix,
            String name,
            XPathResultType[] ArgTypes)
        {
            // Inutile dans notre cas, nous ne nous intéressons qu'aux variables.
            return null;
        }

        public override IXsltContextVariable ResolveVariable(String prefix, String name)
        {
            IXsltContextVariable var = null;
            this._variables.TryGetValue(name, out var);
            return var;
        }

        #endregion Implémentation de XsltContext

        #region Gestion des paramètres

        public void AddVariable(String name, Object value)
        {
            #region Vérification des paramètres

            if (name == null)
                throw new ArgumentNullException("name");
            else if (name.Length < 0)
                throw new ArgumentException("name");

            if (value == null)
                throw new ArgumentNullException("value");

            #endregion Vérification des paramètres

            this._variables[name] = new Variable(name, value);
        }

        public Boolean RemoveVariable(String name)
        {
            #region Vérification des paramètres

            if (name == null)
                throw new ArgumentNullException("name");
            else if (name.Length < 0)
                throw new ArgumentException("name");

            #endregion Vérification des paramètres

            return this._variables.Remove(name);
        }

        public void ClearVariables()
        {
            this._variables.Clear();
        }

        #endregion Gestion des paramètres

        private class Variable : IXsltContextVariable
        {
            #region Constructeur

            /// <summary>
            /// Initialise une nouvelle instance de <see cref="Variable"/>.
            /// </summary>
            /// <param name="name"></param>
            /// <param name="value"></param>
            /// <exception cref="ArgumentNullException">
            /// <c>name</c> est une référence nulle. 
            /// ou 
            /// <c>value</c> est une référence nulle. 
            /// </exception>
            /// <exception cref="ArgumentException">
            /// <c>name</c> est une chaîne vide.
            /// </exception>
            public Variable(String name, Object value)
            {
                #region Vérification des paramètres

                if (name == null)
                    throw new ArgumentNullException("name");
                else if (name.Length < 0)
                    throw new ArgumentException("name");

                if (value == null)
                    throw new ArgumentNullException("value");

                #endregion Vérification des paramètres

                this._name = name;
                this._value = value;

                this.DetermineType();
            }

            #endregion Constructeur

            #region Champs

            /// <summary>
            /// Nom de la variable.
            /// </summary>
            private String _name;

            /// <summary>
            /// Valeur de la variable.
            /// </summary>
            private Object _value;

            /// <summary>
            /// Type de la variable.
            /// </summary>
            private XPathResultType _type;

            #endregion Champs

            #region Propriétés

            /// <summary>
            /// Obtient ou définit le nom de la variable.
            /// </summary>
            public String Name
            {
                get
                {
                    return this._name;
                }

                set
                {
                    this._name = value;
                }
            }

            /// <summary>
            /// Obtient ou définit la valeur de la variable.
            /// </summary>
            public Object Value
            {
                get
                {
                    return this._value;
                }

                set
                {
                    this._value = value;
                }
            }

            #endregion Propriétés

            #region Implémentation de IXsltContextVariable

            public object Evaluate(XsltContext xsltContext)
            {
                return this._value;
            }

            public Boolean IsLocal
            {
                get
                {
                    return false;
                }
            }

            public Boolean IsParam
            {
                get
                {
                    return false;
                }
            }

            public XPathResultType VariableType
            {
                get
                {
                    return this._type;
                }
            }

            #endregion Implémentation de IXsltContextVariable

            #region Méthodes utilitaires

            /// <summary>
            /// Permet de déterminer le type de la valeur.
            /// </summary>
            private void DetermineType()
            {
                // Détermination des types : 
                // String                : XPathResultType.String
                // Boolean               : XPathResultType.Boolean
                // XPathNavigator        : XPathResultType.Navigator
                // XPathNodeIterator     : XPathResultType.NodeSet
                // Double                : XPathResultType.Number
                // Convertible en Double : XPathResultType.Number
                // Autres                : XPathResultType.Any

                if (this._value is String)
                    this._type = XPathResultType.String;
                else if (this._value is Boolean)
                    this._type = XPathResultType.Boolean;
                else if (this._value is XPathNavigator)
                    this._type = XPathResultType.Navigator;
                else if (this._value is XPathNodeIterator)
                    this._type = XPathResultType.NodeSet;
                else if (this._value is Double)
                    this._type = XPathResultType.Number;
                else if (this._value is IConvertible)
                {
                    // Si le type n'est pas double mais implémente IConvertible, 
                    // nous tentons la conversion.
                    try
                    {
                        this._value = Convert.ToDouble(this._value);
                        this._type = XPathResultType.Number;
                    }
                    catch
                    {
                        this._type = XPathResultType.Any;
                    }
                }
                else
                    this._type = XPathResultType.Any;
            }

            #endregion Méthodes utilitaires
        }
    }
}

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

cs_coq
Messages postés
6352
Date d'inscription
samedi 1 juin 2002
Statut
Modérateur
Dernière intervention
2 août 2014
75 -
Lol, fait toi plaisir.
cs_Bidou
Messages postés
5487
Date d'inscription
dimanche 4 août 2002
Statut
Modérateur
Dernière intervention
20 juin 2013
43 -
J'espère que ce coup de pub n'est pas trop mal placé ;-p
http://www.csharpfr.com/tutorial.aspx?ID=536
romagny13
Messages postés
687
Date d'inscription
lundi 10 janvier 2005
Statut
Membre
Dernière intervention
27 août 2014
2 -
Ouuuf alors la je dis "trop" merci
moi qui ai pas une seconde a moi
ca va peut etre m'avancer pas mal a ce niveau car j'ai toujours pas regarder sur msdn comment les utiliser
merci

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.