StaticSiteMapProvider Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
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.
public ref class StaticSiteMapProvider abstract : System::Web::SiteMapProviderpublic abstract class StaticSiteMapProvider : System.Web.SiteMapProvidertype StaticSiteMapProvider = class
inherit SiteMapProviderPublic MustInherit Class StaticSiteMapProvider
Inherits SiteMapProvider- Héritage
- Dérivé
Exemples
L’exemple de code suivant montre comment étendre la StaticSiteMapProvider classe pour utiliser Microsoft Access comme fournisseur de plan de site. La AccessSiteMapProvider classe est un fournisseur de plan de site qui ne prend en charge qu’une hiérarchie simple, à un niveau profond. La table dans laquelle les données de plan de site sont stockées a la structure suivante :
NODEID URL NAME PARENTNODEID
---------------------------------------------
1 default.aspx Default <NULL>
2 catalog.aspx Catalog 1
3 aboutus.aspx Contact Us 1
...
La AccessSiteMapProvider classe est dérivée de la StaticSiteMapProvider classe et récupère ses informations à partir d’une base de données Microsoft Access à l’aide de requêtes SQL de base et des OleDbCommand objets et OleDbDataReader .
#using <System.Data.dll>
#using <System.Transactions.dll>
#using <System.EnterpriseServices.dll>
#using <System.dll>
#using <System.Web.dll>
#using <System.Configuration.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Configuration;
using namespace System::Data;
using namespace System::Data::OleDb;
using namespace System::Security::Permissions;
using namespace System::Web;
/// An extremely simple AccessSiteMapProvider that only supports a
/// site map node hierarchy 1 level deep.
[AspNetHostingPermission(SecurityAction::Demand,Level=AspNetHostingPermissionLevel::Minimal)]
public ref class AccessSiteMapProvider: public StaticSiteMapProvider
{
private:
SiteMapNode ^ rootNode;
OleDbConnection^ accessConnection;
// This string is case sensitive.
String^ AccessConnectionStringName;
public:
// Implement a default constructor.
AccessSiteMapProvider()
{
initialized = false;
AccessConnectionStringName = "accessSiteMapConnectionString";
}
private:
// Some basic state to help track the initialization state of the provider.
bool initialized;
public:
property bool IsInitialized
{
virtual bool get()
{
return initialized;
}
}
property SiteMapNode ^ RootNode
{
// Return the root node of the current site map.
virtual SiteMapNode ^ get() override
{
SiteMapNode ^ temp = nullptr;
temp = BuildSiteMap();
return temp;
}
}
protected:
virtual SiteMapNode ^ GetRootNodeCore() override
{
return RootNode;
}
public:
// 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.
virtual void Initialize( String^ name, NameValueCollection^ attributes ) override
{
if ( IsInitialized )
return;
StaticSiteMapProvider::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 ( nullptr == connectionString || connectionString->Length == 0 )
throw gcnew Exception( "The connection string was not found." );
else
accessConnection = gcnew OleDbConnection( connectionString );
initialized = true;
}
protected:
///
/// SiteMapProvider and StaticSiteMapProvider methods that this derived class must override.
///
// Clean up any collections or other state that an instance of this may hold.
virtual void Clear() override
{
System::Threading::Monitor::Enter( this );
try
{
rootNode = nullptr;
StaticSiteMapProvider::Clear();
}
finally
{
System::Threading::Monitor::Exit( this );
}
}
public:
// Build an in-memory representation from persistent
// storage, and return the root node of the site map.
virtual SiteMapNode ^ BuildSiteMap() override
{
// Since the SiteMap class is static, make sure that it is
// not modified while the site map is built.
System::Threading::Monitor::Enter( this );
try
{
// If there is no initialization, this method is being
// called out of order.
if ( !IsInitialized )
{
throw gcnew Exception( "BuildSiteMap called incorrectly." );
}
// If there is no root node, then there is no site map.
if ( nullptr == 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 = gcnew 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 = gcnew SiteMapNode(this, rootNodeId.ToString(),
rootNodeReader->GetString( 1 ),rootNodeReader->GetString( 2 ));
}
else
return nullptr;
rootNodeReader->Close();
// Select the child nodes of the root node.
OleDbCommand^ childNodesCommand = gcnew OleDbCommand
("SELECT nodeid, url, name FROM SiteMap WHERE parentnodeid = ?", accessConnection);
OleDbParameter^ rootParam = gcnew OleDbParameter( "parentid", OleDbType::Integer);
rootParam->Value = rootNodeId;
childNodesCommand->Parameters->Add( rootParam );
OleDbDataReader^ childNodesReader = childNodesCommand->ExecuteReader();
if ( childNodesReader->HasRows )
{
SiteMapNode ^ childNode = nullptr;
while ( childNodesReader->Read() )
{
childNode = gcnew SiteMapNode( this,
System::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;
}
finally
{
System::Threading::Monitor::Exit( this );
}
}
};
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;
}
}
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Data
Imports System.Data.OleDb
Imports System.Security.Permissions
Imports System.Web
Namespace Samples.AspNet.VB.Controls
' An extremely simple AccessSiteMapProvider that only supports a
' site map node hierarchy one level deep.
<AspNetHostingPermission(SecurityAction.Demand, Level:=AspNetHostingPermissionLevel.Minimal)> _
Public Class AccessSiteMapProvider
Inherits StaticSiteMapProvider
Private aRootNode As SiteMapNode = Nothing
Private accessConnection As OleDbConnection = Nothing
' This string is case sensitive.
Private AccessConnectionStringName As String = "accessSiteMapConnectionString"
' Implement a default constructor.
Public Sub New()
End Sub
' Some basic state to help track the initialization state of the provider.
Private initialized As Boolean = False
Public Overridable ReadOnly Property IsInitialized() As Boolean
Get
Return initialized
End Get
End Property
' Return the root node of the current site map.
Public Overrides ReadOnly Property RootNode() As SiteMapNode
Get
Return BuildSiteMap()
End Get
End Property
Protected Overrides Function GetRootNodeCore() As SiteMapNode
Return RootNode
End Function
' 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 Overrides Sub Initialize(ByVal name As String, ByVal attributes As NameValueCollection)
If IsInitialized Then
Return
End If
MyBase.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.
Dim connectionString As String = attributes(AccessConnectionStringName)
If Nothing = connectionString OrElse connectionString.Length = 0 Then
Throw New Exception("The connection string was not found.")
Else
accessConnection = New OleDbConnection(connectionString)
End If
initialized = True
End Sub
' 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 Overrides Sub Clear()
SyncLock Me
aRootNode = Nothing
MyBase.Clear()
End SyncLock
End Sub
' Build an in-memory representation from persistent
' storage, and return the root node of the site map.
Public Overrides Function BuildSiteMap() As SiteMapNode
' Since the SiteMap class is static, make sure that it is
' not modified while the site map is built.
SyncLock Me
' If there is no initialization, this method is being
' called out of order.
If Not IsInitialized Then
Throw New Exception("BuildSiteMap called incorrectly.")
End If
' If there is no root node, then there is no site map.
If aRootNode Is Nothing Then
' Start with a clean slate
Clear()
' Select the root node of the site map from Microsoft Access.
Dim rootNodeId As Integer = -1
If accessConnection.State = ConnectionState.Closed Then
accessConnection.Open()
End If
Dim rootNodeCommand As New OleDbCommand("SELECT nodeid, url, name FROM SiteMap WHERE parentnodeid IS NULL", accessConnection)
Dim rootNodeReader As OleDbDataReader = rootNodeCommand.ExecuteReader()
If rootNodeReader.HasRows Then
rootNodeReader.Read()
rootNodeId = rootNodeReader.GetInt32(0)
' Create a SiteMapNode that references the current StaticSiteMapProvider.
aRootNode = New SiteMapNode(Me, rootNodeId.ToString(), rootNodeReader.GetString(1), rootNodeReader.GetString(2))
Else
Return Nothing
End If
rootNodeReader.Close()
' Select the child nodes of the root node.
Dim childNodesCommand As New OleDbCommand("SELECT nodeid, url, name FROM SiteMap WHERE parentnodeid = ?", accessConnection)
Dim rootParam As New OleDbParameter("parentid", OleDbType.Integer)
rootParam.Value = rootNodeId
childNodesCommand.Parameters.Add(rootParam)
Dim childNodesReader As OleDbDataReader = childNodesCommand.ExecuteReader()
If childNodesReader.HasRows Then
Dim childNode As SiteMapNode = Nothing
While childNodesReader.Read()
childNode = New SiteMapNode(Me, _
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, aRootNode)
End While
End If
childNodesReader.Close()
accessConnection.Close()
End If
Return aRootNode
End SyncLock
End Function 'BuildSiteMap
End Class
End Namespace
Enfin, est AccessSiteMapProvider configuré comme 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>
Remarques
La StaticSiteMapProvider classe est une implémentation partielle de la classe abstraite SiteMapProvider et fournit deux méthodes supplémentaires : AddNode et RemoveNode, ainsi que les méthodes abstraites BuildSiteMap et protégées Clear .
La StaticSiteMapProvider classe prend en charge l’écriture d’un fournisseur de plan de site (par exemple, un XmlSiteMapProvider) qui traduit un plan de site stocké dans un stockage persistant en un qui est stocké en mémoire. La StaticSiteMapProvider classe fournit des implémentations de base pour stocker et récupérer des SiteMapNode objets.
Les SiteMapProvider classes et prennent StaticSiteMapProvider en charge le concept de hiérarchie de fournisseur de plan de site, où un fournisseur de plan de site peut avoir une relation hiérarchique avec d’autres fournisseurs de plan de site. Ce modèle est implémenté avec les RootProvider propriétés et ParentProvider .
La StaticSiteMapProvider classe stocke ses SiteMapNode objets dans des tables de hachage et utilise en interne la SiteMapNode.Url propriété des pages, représentée par des nœuds de plan de site, en tant que clés. (Si un nœud de plan de site ne spécifie pas d’URL, il est suivi à l’aide d’une clé unique générée automatiquement.) Par conséquent, vous ne pouvez pas avoir de nœuds de plan de site dans lesquels un nœud de plan de site avec la même URL est utilisé plusieurs fois. Par exemple, la tentative de chargement du nœud de plan de site illustré dans l’exemple de code suivant avec la XmlSiteMapProvider classe , qui est la ASP.NET fournisseur de plan de site par défaut, ou tout fournisseur de plan de site dérivé de la StaticSiteMapProvider classe ne fonctionnera pas, 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 StaticSiteMapProvider classe, les trois méthodes les plus importantes sont les GetRootNodeCoreméthodes , Initializeet BuildSiteMap . Les Clear méthodes et FindSiteMapNode ont des implémentations par défaut qui sont suffisantes pour la plupart des implémentations de fournisseurs de plan de site personnalisées.
La Initialize méthode est appelée pour initialiser les fournisseurs de plan de site dérivés, y compris toutes les ressources requises pour charger les données de plan de site, mais elle tente de créer 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 être effectuée ici. 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 être effectuée ici. Les attributs supplémentaires, tels que les noms de fichiers ou les chaînes de connexion placés sur l’élément fournisseur de plan de site dans la configuration, sont traités par le système de configuration ASP.NET et transmis à la Initialize méthode avec le attributes paramètre .
La BuildSiteMap méthode doit être remplacée par toutes les classes dérivées de la StaticSiteMapProvider classe et appelée pour charger le nœud de plan de site à partir d’un stockage persistant et le convertir en représentation interne. La BuildSiteMap méthode est appelée en interne dans la plupart des implémentations membres par défaut des StaticSiteMapProvider classes 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 se produit une fois et que les appels suivants à la BuildSiteMap méthode retournent immédiatement, si les informations de plan de site ont déjà été chargées. Lorsque vous implémentez la BuildSiteMap méthode, vérifiez qu’elle est thread-safe, car plusieurs demandes de page simultanées peuvent entraîner indirectement plusieurs appels pour charger des informations de plan de site. L’infrastructure de plan de site prend en charge l’affichage des informations de plan de site en fonction du rôle de l’utilisateur. Selon la Roles propriété prise en charge par les objets individuels SiteMapNode , une structure de navigation différente peut exister pour différents utilisateurs. Les implémentations par défaut des membres de récupération de nœud de carte de site de la classe effectuent automatiquement un StaticSiteMapProvider filtrage de sécurité en appelant la IsAccessibleToUser méthode .
Les AddNodeméthodes et RemoveNodeClear manipulent les collections internes utilisées pour suivre les nœuds de plan de site de manière thread-safe.
Notes pour les responsables de l’implémentation
Lorsque vous héritez de la StaticSiteMapProvider classe , vous devez remplacer le membre suivant : BuildSiteMap().
Constructeurs
| StaticSiteMapProvider() |
Initialise une nouvelle instance de la classe StaticSiteMapProvider. |
Propriétés
| CurrentNode |
Obtient l'objet SiteMapNode qui représente la page actuellement demandée. (Hérité de SiteMapProvider) |
| Description |
Obtient une description brève et conviviale qui peut s'afficher dans les outils d'administration ou d'autres interfaces utilisateur. (Hérité de ProviderBase) |
| EnableLocalization |
Obtient ou définit une valeur Boolean qui indique si des valeurs localisées des attributs SiteMapNode sont retournées. (Hérité de SiteMapProvider) |
| Name |
Obtient le nom convivial qui référence le fournisseur au cours de la configuration. (Hérité de ProviderBase) |
| ParentProvider |
Obtient ou définit l'objet SiteMapProvider parent du fournisseur actuel. (Hérité de SiteMapProvider) |
| ResourceKey |
Obtient ou définit la clé de ressource utilisée pour localiser des attributs SiteMapNode. (Hérité de SiteMapProvider) |
| RootNode |
Obtient l'objet racine SiteMapNode des données de plan de site que le fournisseur actuel représente. (Hérité de SiteMapProvider) |
| RootProvider |
Obtient l'objet SiteMapProvider racine dans la hiérarchie de fournisseur actuelle. (Hérité de SiteMapProvider) |
| SecurityTrimmingEnabled |
Obtient une valeur Boolean qui indique si un fournisseur de plan de site filtre ou non des nœuds en fonction du rôle d'un utilisateur. (Hérité de SiteMapProvider) |
Méthodes
| AddNode(SiteMapNode) |
Ajoute un objet SiteMapNode à la collection de nœuds gérée par le fournisseur de plan de site. (Hérité de SiteMapProvider) |
| AddNode(SiteMapNode, SiteMapNode) |
Ajoute un SiteMapNode aux collections conservées par le fournisseur de plan de site et établit une relation parent/enfant entre les objets SiteMapNode. |
| BuildSiteMap() |
En cas de substitution dans une classe dérivée, charge les informations de plan de site à partir d'un stockage persistant et le génère en mémoire. |
| Clear() |
Supprime tous les éléments dans les collections de nœuds de plan de site enfants et parents que StaticSiteMapProvider suit dans le cadre de son état. |
| Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
| FindSiteMapNode(HttpContext) |
Récupère un objet SiteMapNode qui représente la page actuellement demandée à l'aide de l'objet HttpContext spécifié. (Hérité de SiteMapProvider) |
| FindSiteMapNode(String) |
Récupère un objet SiteMapNode qui représente la page à l'URL spécifiée. |
| FindSiteMapNodeFromKey(String) |
Récupère un objet SiteMapNode selon une clé spécifiée. |
| GetChildNodes(SiteMapNode) |
Récupère les nœuds de plan de site enfants d'un objet SiteMapNode spécifique. |
| GetCurrentNodeAndHintAncestorNodes(Int32) |
Fournit une méthode de recherche optimisée pour les fournisseurs de plan de site lors de la récupération du nœud pour la page actuellement demandée et lors de l'extraction des nœuds de plan de site parents et ancêtres de la page actuelle. (Hérité de SiteMapProvider) |
| GetCurrentNodeAndHintNeighborhoodNodes(Int32, Int32) |
Fournit une méthode de recherche optimisée aux fournisseurs de plan de site lors de la récupération du nœud pour la page actuellement demandée et lors de l'extraction de nœuds de plan de site situés à proximité du nœud actuel. (Hérité de SiteMapProvider) |
| GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
| GetParentNode(SiteMapNode) |
Récupère le nœud de plan de site parent d'un objet SiteMapNode spécifique. |
| GetParentNodeRelativeToCurrentNodeAndHintDownFromParent(Int32, Int32) |
Fournit une méthode de recherche optimisée pour les fournisseurs de plan de site lors de la récupération d'un nœud ancêtre pour la page actuellement demandée et lors de l'extraction des nœuds descendants pour l'ancêtre. (Hérité de SiteMapProvider) |
| GetParentNodeRelativeToNodeAndHintDownFromParent(SiteMapNode, Int32, Int32) |
Fournit une méthode de recherche optimisée pour les fournisseurs de plan de site lors de la récupération d'un nœud ancêtre pour l'objet SiteMapNode spécifié et lors de l'extraction de ses nœuds enfants. (Hérité de SiteMapProvider) |
| GetRootNodeCore() |
Lorsqu'il est substitué dans une classe dérivée, il récupère le nœud racine de tous les nœuds gérés par le fournisseur actuel. (Hérité de SiteMapProvider) |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| HintAncestorNodes(SiteMapNode, Int32) |
Fournit une méthode que les fournisseurs de plan de site peuvent substituer pour exécuter une récupération optimisée d'un ou plusieurs niveaux de nœuds parents et ancêtres relatifs à l'objet SiteMapNode spécifié. (Hérité de SiteMapProvider) |
| HintNeighborhoodNodes(SiteMapNode, Int32, Int32) |
Fournit une méthode que les fournisseurs de plan de site peuvent substituer pour exécuter une récupération optimisée des nœuds trouvés à proximité du nœud spécifié. (Hérité de SiteMapProvider) |
| Initialize(String, NameValueCollection) |
Initialise l'implémentation de SiteMapProvider, y compris toutes les ressources nécessaires pour charger des données de plan de site à partir d'un stockage persistant. (Hérité de SiteMapProvider) |
| IsAccessibleToUser(HttpContext, SiteMapNode) |
Récupère une valeur Boolean qui indique si l'objet SiteMapNode spécifié peut être affiché par l'utilisateur dans le contexte spécifié. (Hérité de SiteMapProvider) |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| RemoveNode(SiteMapNode) |
Supprime l'objet SiteMapNode spécifié de toutes les collections de nœuds de plan de site suivies par le fournisseur de plan de site. |
| ResolveSiteMapNode(HttpContext) |
Déclenche l’événement SiteMapResolve. (Hérité de SiteMapProvider) |
| ToString() |
Retourne une chaîne qui représente l'objet actuel. (Hérité de Object) |
Événements
| SiteMapResolve |
Se produit lorsque la propriété CurrentNode est appelée. (Hérité de SiteMapProvider) |
S’applique à
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour