Cette documentation est archivée et n’est pas conservée.

StaticSiteMapProvider, classe

Sert d'implémentation partielle de la classe abstraite SiteMapProvider et de classe de base à la classe XmlSiteMapProvider qui constitue le fournisseur de plan de site ASP.NET par défaut.

Espace de noms: System.Web
Assembly : System.Web (dans system.web.dll)

public abstract class StaticSiteMapProvider : SiteMapProvider
public abstract class StaticSiteMapProvider extends SiteMapProvider
public abstract class StaticSiteMapProvider extends SiteMapProvider
Non applicable.

La classe StaticSiteMapProvider est une implémentation partielle de la classe abstraite SiteMapProvider. Elle fournit deux méthodes supplémentaires : AddNode et RemoveNode, ainsi que la méthode abstraite BuildSiteMap et la méthode protégée Clear.

La classe StaticSiteMapProvider prend en charge la rédaction d'un fournisseur de plan de site (par exemple, un XmlSiteMapProvider) qui traduit un plan de site enregistré dans un stockage persistant en un plan de site stocké dans mémoire. La classe StaticSiteMapProvider fournit des implémentations de base pour stocker et récupérer des objets SiteMapNode.

Les classes SiteMapProvider et StaticSiteMapProvider prennent en charge le concept d'une hiérarchie du fournisseur du plan de site, dans le cadre duquel un fournisseur de plan de site peut établir une relation hiérarchique avec d'autres fournisseurs de plan de site. Ce schéma est implémenté avec les propriétés RootProvider et ParentProvider.

La classe StaticSiteMapProvider stocke ses objets SiteMapNode dans les tables de hachage et utilise en interne la propriété SiteMapNode.Url des pages, représentée par des nœuds de plan de site, sous forme de clés. (Si un nœud de plan de site ne spécifie aucune URL, il est suivi à l'aide d'une clé unique générée automatiquement.) En conséquence, plusieurs nœuds d'un plan de site ne peuvent pas utiliser une même URL plusieurs fois. Par exemple, la tentative de chargement du nœud de plan de site illustré dans l'exemple de code suivant avec la classe XmlSiteMapProvider, qui constitue le fournisseur de plan de site ASP.NET par défaut, ou tout autre fournisseur de plan de site dérivé de la classe StaticSiteMapProvider échouera, car la page AboutUs.aspx est utilisée plusieurs fois.

<sitemap>
  <sitemapnode title="Home" description="Home" url="default.aspx" >
    <sitemapnode title="Catalog" description="Our catalog" url="catalog.aspx"/>
    <sitemapnode title="About Us" description="All about our company" url="aboutus.aspx"/>
    <sitemapnode title="Driving Directions" description="Directions to our store" url="aboutus.aspx"/>
  </sitemapnode>
</sitemap>

Si vous étendez la classe StaticSiteMapProvider, les trois méthodes les plus importantes sont GetRootNodeCore, Initialize et BuildSiteMap. Les méthodes Clear et FindSiteMapNode ont des implémentations par défaut suffisantes pour la plupart des implémentations de fournisseur de plan de site personnalisées.

La méthode Initialize est appelée pour initialiser des fournisseurs de plan de site dérivés, y compris toute ressource nécessaire au chargement de données de plan de site, mais elle essaie tout de même de construire le nœud de plan de site en mémoire. Si votre classe dérivée utilise des fichiers pour stocker des données de plan de site, toute initialisation de fichier peut s'y effectuer. Si le nœud de plan de site utilise un autre type de magasin de données, tel qu'une base de données relationnelle, l'initialisation d'une connexion peut s'y effectuer. Des attributs supplémentaires, tels que des noms de fichiers ou des chaînes de connexion, placés sur l'élément de fournisseur de plan de site dans la configuration, sont traités par le système de configuration ASP.NET, puis passés à la méthode Initialize avec le paramètre attributes.

La méthode BuildSiteMap doit être substituée par toutes les classes dérivées de la classe StaticSiteMapProvider. Elle est appelée pour charger le nœud de plan de site à partir de stockage persistant, puis le convertir en une représentation interne. La méthode BuildSiteMap est appelée en interne dans nombre d'implémentations de membres par défaut des classes StaticSiteMapProvider et XmlSiteMapProvider. Si vous implémentez votre propre fournisseur de plan de site, assurez-vous que le traitement des données de plan de site s'effectue une fois, et que les appels ultérieurs à la méthode BuildSiteMap sont instantanément retournés, si les informations de plan de site ont déjà été chargées. Lorsque vous implémentez la méthode BuildSiteMap, assurez-vous qu'elle est de type thread-safe, car plusieurs demandes de page simultanées peuvent engendrer plusieurs appels pour le chargement d'informations de plan de site. L'infrastructure de plan de site prend en charge l'affichage des informations de plan de site selon le rôle de l'utilisateur. Selon la propriété Roles prise en charge par les objets SiteMapNode individuels, une structure de navigation distincte peut exister pour différents utilisateurs. Les implémentations par défaut des membres de récupération de nœuds de plan de site de la classe StaticSiteMapProvider exécutent automatiquement l'ajustement de la sécurité en appelant la méthode IsAccessibleToUser.

Les méthodes AddNode, Clear et RemoveNode manipulent les collections internes utilisées pour suivre des nœuds de plan de site selon une méthode thread-safe.

Remarques à l'attention des héritiers : Lorsque vous héritez de la classe StaticSiteMapProvider, vous devez substituer le membre suivant : BuildSiteMap.

L'exemple de code suivant montre comment étendre la classe StaticSiteMapProvider pour utiliser Microsoft Access en tant que fournisseur de plan de site. La classe AccessSiteMapProvider constitue un fournisseur de plan de site qui ne prend en charge qu'une hiérarchie simple, d'un niveau de profondeur. La table dans laquelle les données de plan de site sont stockées présente la structure suivante :

NODEID URL            NAME       PARENTNODEID
 ---------------------------------------------
 1      default.aspx   Default    <NULL>
 2      catalog.aspx   Catalog    1
 3      aboutus.aspx   Contact Us 1
...

La classe AccessSiteMapProvider est dérivée de la classe StaticSiteMapProvider et récupère ses informations dans une base de données Microsoft Access à l'aide de requêtes SQL de base et des objets OleDbCommand et OleDbDataReader.

namespace Samples.AspNet.CS.Controls {

    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Data;
    using System.Data.OleDb;
    using System.Security.Permissions;
    using System.Web;

    /// An extremely simple AccessSiteMapProvider that only supports a
    /// site map node hierarchy 1 level deep.
    [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Minimal)]
    public class AccessSiteMapProvider : StaticSiteMapProvider
    {
        private SiteMapNode rootNode =  null;
        private OleDbConnection accessConnection = null;

        // This string is case sensitive.
        private string AccessConnectionStringName = "accessSiteMapConnectionString";

        // Implement a default constructor.
        public AccessSiteMapProvider () { }

        // Some basic state to help track the initialization state of the provider.
        private bool initialized = false;
        public virtual bool IsInitialized {
            get {
                return initialized;
            }
        }
        // Return the root node of the current site map.
        public override SiteMapNode RootNode {
            get {
                SiteMapNode temp = null;
                temp = BuildSiteMap();
                return temp;
            }
        }
        protected override SiteMapNode GetRootNodeCore() {
            return RootNode;
        }
        // Initialize is used to initialize the properties and any state that the
        // AccessProvider holds, but is not used to build the site map.
        // The site map is built when the BuildSiteMap method is called.
        public override void Initialize(string name, NameValueCollection attributes) {
            if (IsInitialized)
                return;

            base.Initialize(name, attributes);

            // Create and test the connection to the Microsoft Access database.

            // Retrieve the Value of the Access connection string from the
            // attributes NameValueCollection.
            string connectionString = attributes[AccessConnectionStringName];

            if (null == connectionString || connectionString.Length == 0)
                throw new Exception ("The connection string was not found.");
            else
                accessConnection = new OleDbConnection(connectionString);

            initialized = true;
        }

        ///
        /// SiteMapProvider and StaticSiteMapProvider methods that this derived class must override.
        ///
        // Clean up any collections or other state that an instance of this may hold.
        protected override void Clear() {
            lock (this) {
                rootNode = null;
                base.Clear();
            }
        }

        // Build an in-memory representation from persistent
        // storage, and return the root node of the site map.
        public override SiteMapNode BuildSiteMap() {

            // Since the SiteMap class is static, make sure that it is
            // not modified while the site map is built.
            lock(this) {

                // If there is no initialization, this method is being
                // called out of order.
                if (! IsInitialized) {
                    throw new Exception("BuildSiteMap called incorrectly.");
                }

                // If there is no root node, then there is no site map.
                if (null == rootNode) {
                    // Start with a clean slate
                    Clear();

                    // Select the root node of the site map from Microsoft Access.
                    int rootNodeId = -1;

                    if (accessConnection.State == ConnectionState.Closed)
                        accessConnection.Open();
                    OleDbCommand rootNodeCommand =
                        new OleDbCommand("SELECT nodeid, url, name FROM SiteMap WHERE parentnodeid IS NULL",
                                         accessConnection);
                    OleDbDataReader rootNodeReader = rootNodeCommand.ExecuteReader();

                    if(rootNodeReader.HasRows) {
                        rootNodeReader.Read();
                        rootNodeId = rootNodeReader.GetInt32(0);
                        // Create a SiteMapNode that references the current StaticSiteMapProvider.
                        rootNode   = new SiteMapNode(this,
                                                     rootNodeId.ToString(),
                                                     rootNodeReader.GetString(1),
                                                     rootNodeReader.GetString(2));

                    }
                    else return null;

                    rootNodeReader.Close();
                    // Select the child nodes of the root node.
                    OleDbCommand childNodesCommand =
                        new OleDbCommand("SELECT nodeid, url, name FROM SiteMap WHERE parentnodeid = ?",
                                         accessConnection);
                    OleDbParameter rootParam = new OleDbParameter("parentid", OleDbType.Integer);
                    rootParam.Value = rootNodeId;
                    childNodesCommand.Parameters.Add(rootParam);

                    OleDbDataReader childNodesReader = childNodesCommand.ExecuteReader();

                    if (childNodesReader.HasRows) {

                        SiteMapNode childNode = null;
                        while(childNodesReader.Read()) {
                            childNode =  new SiteMapNode(this,
                                                         childNodesReader.GetInt32(0).ToString(),
                                                         childNodesReader.GetString(1),
                                                         childNodesReader.GetString(2));

                            // Use the SiteMapNode AddNode method to add
                            // the SiteMapNode to the ChildNodes collection.
                            AddNode(childNode, rootNode);
                        }
                    }

                    childNodesReader.Close();
                    accessConnection.Close();
                }
                return rootNode;
            }
        }
    }
}

package Samples.AspNet.JSL;
import System.*;
import System.Collections.*;
import System.Collections.Specialized.*;
import System.Data.*;
import System.Data.OleDb.*;
import System.Web.*;
import System.Configuration.*;

/// An extremely simple AccessSiteMapProvider that only supports a
/// site map node hierarchy 1 level deep.
public class AccessSiteMapProvider extends StaticSiteMapProvider
{
	private SiteMapNode rootNode = null;
	private OleDbConnection accessConnection = null;

	// This string is case sensitive.
	public String accessConnectionStringName = "accessSiteMapConnectionString";

	// Implement a default constructor.
	public AccessSiteMapProvider()
	{
	} //AccessSiteMapProvider 

	// Some basic state to help track the initialization state of the provider.
	private boolean initialized = false;

	/** @property 
	 */
	public boolean get_IsInitialized()
	{
		return initialized;
	} //get_IsInitized.

	// Return the root node of the current site map.
	/** @property 
	 */
	public SiteMapNode get_RootNode() throws Exception
	{
		SiteMapNode temp = null;
		temp = BuildSiteMap();
		return temp;
	} //get_RootNode

	// Initialize is used to initialize the properties and any state that the
	// AccessProvider holds, but is not used to build the site map.
	// The site map is built when the BuildSiteMap method is called.
	public void Initialize(String name, NameValueCollection attributes) 
        throws Exception
	{
		if (get_IsInitialized())
		{
			return;
		}

		super.Initialize(name, attributes);
		// Create and test the connection to the Microsoft Access database.
		// Retrieve the Value of the Access connection string from the
		// attributes NameValueCollection.
		String connectionString = attributes.get_Item(
			accessConnectionStringName);

		if (null == connectionString || connectionString.get_Length() == 0)
		{
			throw new Exception("The connection string was not found.");
		}
		else
		{
			accessConnection = new OleDbConnection(connectionString);
		}
		initialized = true;
	} //Initialize

	///
	/// SiteMapProvider and StaticSiteMapProvider methods that this 
	/// derived class must override.
	///
	// Clean up any collections or other state that an instance of this may hold.
	protected void Clear()
	{
		synchronized (this)
		{
			rootNode = null;
			super.Clear();
		}
	} //Clear

	// Build an in-memory representation from persistent
	// storage, and return the root node of the site map.
	public SiteMapNode BuildSiteMap() throws Exception
	{
		// Since the SiteMap class is static, make sure that it is
		// not modified while the site map is built.
		synchronized (this)
		{
			// If there is no initialization, this method is being
			// called out of order.
			if (!get_IsInitialized())
			{
				throw new Exception("BuildSiteMap called incorrectly.");
			}
			// If there is no root node, then there is no site map.
			if (null == rootNode)
			{
				// Start with a clean slate
				Clear();
				// Select the root node of the site map from Microsoft Access.
				int rootNodeId = -1;

				if (accessConnection.get_State().Equals(ConnectionState.Closed))
				{
					accessConnection.Open();
				}

				OleDbCommand rootNodeCommand = new OleDbCommand(
					"SELECT nodeid, url, name FROM SiteMap WHERE "
					+ "parentnodeid IS NULL", accessConnection);
				OleDbDataReader rootNodeReader = rootNodeCommand.ExecuteReader();

				if (rootNodeReader.get_HasRows())
				{
					rootNodeReader.Read();
					rootNodeId = rootNodeReader.GetInt32(0);
					// Create a SiteMapNode that references the current 
					// StaticSiteMapProvider.
					rootNode = new SiteMapNode(this,
						((Int32)rootNodeId).ToString(), rootNodeReader.
						GetString(1), rootNodeReader.GetString(2));
				}
				else
				{
					return null;
				}
				rootNodeReader.Close();
				// Select the child nodes of the root node.
				OleDbCommand childNodesCommand = new OleDbCommand(
					"SELECT nodeid, url, name FROM SiteMap WHERE "
					+ "parentnodeid = ?", accessConnection);
				OleDbParameter rootParam = new OleDbParameter("parentid",
					OleDbType.Integer);
				rootParam.set_Value((Int32)rootNodeId);
				childNodesCommand.get_Parameters().Add(rootParam);

				OleDbDataReader childNodesReader = childNodesCommand.
					ExecuteReader();

				if (childNodesReader.get_HasRows())
				{
					SiteMapNode childNode = null;
					while (childNodesReader.Read())
					{
						childNode = new SiteMapNode(this,
							Convert.ToString(childNodesReader.GetInt32(0)), 
							childNodesReader.GetString(1),
							childNodesReader.GetString(2));
						// Use the SiteMapNode AddNode method to add
						// the SiteMapNode to the ChildNodes collection.
						AddNode(childNode, rootNode);
					}
				}

				childNodesReader.Close();
				accessConnection.Close();
			}
			return rootNode;
		}
	} //BuildSiteMap

	protected SiteMapNode GetRootNodeCore()
	{
		return null;
	} //GetRootNodeCore
} //AccessSiteMapProvider 

Enfin, le AccessSiteMapProvider est configuré en tant que fournisseur par défaut dans le fichier Web.config suivant.

<configuration>
  <system.web>
    <siteMap defaultProvider="AccessSiteMapProvider">
     <providers>
       <add 
         name="AccessSiteMapProvider"
         type="Samples.AspNet.AccessSiteMapProvider,Samples.AspNet "
         accessSiteMapConnectionString="PROVIDER=MICROSOFT.JET.OLEDB.4.0;DATA SOURCE=sitemap.mdb "/>
     </providers> 
    </siteMap>
  </system.web>
</configuration>

  • AspNetHostingPermission  pour opérer dans un environnement hébergé. Valeur de demande : LinkDemand ; valeur d'autorisation : Minimal.
  • AspNetHostingPermission  pour opérer dans un environnement hébergé. Valeur de demande : InheritanceDemand ; valeur d'autorisation : Minimal.

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 est pris en charge sur Windows Vista, Microsoft Windows XP SP2 et Windows Server 2003 SP1.

.NET Framework

Prise en charge dans : 3.0, 2.0
Afficher: