klaus_b@.NET

<configuration>
    <siteMap defaultProvider="SqlSiteMapProvider" enabled="true">
        <providers>
            <clear/>
            <add name="SqlSiteMapProvider" type="TestSpace.Web.SqlSiteMapProvider"securityTrimmingEnabled="true" secureQueryStringEnabled="true"directConnection="false" cacheKey="sitemapDataSet"/>
        </providers>
    </siteMap>
</configuration>

// prüfen ob directConnection in der web.config angegeben ist
if (string.IsNullOrEmpty(config["directConnection"]))
{
    config.Remove("directConnection");
    config.Add("directConnection", "true");
}

bool.TryParse(config["directConnection"], out isDirectConnection);
config.Remove("directConnection");

#region Properties

/// <summary>
/// Der Name des Schlüssels unter dem das DataSet im Cache abgelegt werden soll.
/// Es muss der gleiche Name verwendet werden wie in der Konfiguration
/// des <see cref="T:TestSpace.Web.SqlSiteMapProvider"/>.
/// </summary>
/// <value>Setzt den Wert des privaten Feldes cacheKey oder gibt ihn zurück.</value>
/// <remarks>n/a</remarks>
public string CacheKey
{
    get { return this.cacheKey; }
    set { this.cacheKey = value; }
}

/// <summary>
/// Der Referenzschlüssel der überwacht werden soll. Initialisierungswert ist <c>false</c>.
/// Das bedeutet, Daten sind nicht geändert.
/// </summary>
/// <value>Setzt den Wert des privaten Feldes referenceKey oder gibt ihn zurück.</value>
/// <remarks>
/// Ein zusätzlicher Schlüssel, der für das verwendete <see cref="T:System.Web.Caching.CacheDependency"/>
/// -Objekt benötigt wird. Der Wert dieses Schlüssels, <c>true</c> oder <c>false</c>, sollte bei
/// Änderungen an der Datenbanktabelle ebenfalls auf <c>true</c>, als Daten geändert, gesetzt werden.
/// </remarks>
public string ReferenceKey
{
    get { return this.referenceKey; }
    set { this.referenceKey = value; }
}

/// <summary>
/// Die WebServiceProxy-Klasse, die das DataSet liefert.
/// </summary>
/// <value>Setzt den Wert des privaten Feldes proxy oder gibt ihn zurück.</value>
/// <remarks>
/// Falls der übergebene WebServiceProxy <see cref="T:System.Web.Services.Protocols.SoapHeader"/>
/// oder andere Methoden zur Authentifitierung verwendet, muss dieser an die Eigenschaft
/// <see cref="P:TestSpace.Web.SqlSiteMapCacheHandler.ProxyAuhHeader"/> übergeben werden.
/// </remarks>
public object Proxy
{
    get { return this.proxy; }
    set { this.proxy = value; }
}

/// <summary>
/// Die <see cref="T:System.Web.Services.Protocols.SoapHeader"/>-Klasse,
/// die zur Authentifizierung verwendet wird.
/// </summary>
/// <value>Setzt den Wert des privaten Felds proxyAuthHeader oder gibt ihn zurück.</value>
/// <remarks>n/a</remarks>
public object ProxyAuhHeader
{
    get { return this.proxyAuthHeader; }
    set { this.proxyAuthHeader = value; }
}

/// <summary>
/// Die Gültigkeit der AuthHeader Klasse in Sekunden.
/// </summary>
/// <value>Setzt den Wert des privaten Feldes proxyAuthHeaderExpires oder gibt ihn zurück.</value>
/// <remarks>Der Standardwert ist auf 10 Sekunden festgelegt.</remarks>
public int ProxyAuthHeaderExpires
{
    get { return this.proxyAuthHeaderExpires; }
    set { this.proxyAuthHeaderExpires = value; }
}

/// <summary>
/// Der Name der Methode im <see cref="P:TestSpace.Web.SqlSiteMapCacheHandler.Proxy"/>,
/// die das DataSet für den <see cref="T:TestSpace.Web.SqlSiteMapProvider"/> liefert.
/// </summary>
/// <value>Setzt den Wert des privaten Feldes getDataMethod oder gibt ihn zurück.</value>
/// <remarks>Die aufzurufende Methode darf keine Parameter benötigen.</remarks>
public string GetDataMethod
{
    get { return this.getDataMethod; }
    set { getDataMethod = value; }
}

#endregion

public class Global : HttpApplication
{
    // Neue Instanz des WebService-Proxy
    private GetSiteMapProxy siteMapProxy = new GetSiteMapProxy();

    // Neue Instanz vom SoapAuthHeader des WebService-Proxy
    private SoapAuthHeader authHeader = new SoapAuthHeader();
    
    // neue Instanz vom SqlSiteMapCacheHandler
    private SqlSiteMapCacheHandler handler = new SqlSiteMapCacheHandler();
    
    /// <summary>
    /// Standard-Konstruktor
    /// </summary>
    public Global()
    {
        //Auskommentierung der folgenden Zeile bei Verwendung von Designkomponenten aufheben 
        //InitializeComponent();
    }

    /// <summary>
    /// Wird beim Start der Anwendung ausgeführt.
    /// </summary>
    void Application_Start(object sender, EventArgs e)
    {   
        // SqlSiteMapCacheHandler initialisieren
        handler.CacheKey = "sitemapDataSet";
        handler.ReferenceKey = "sitemapKey";
        handler.Proxy = siteMapProxy;
        handler.GetDataMethod = "getData";
        handler.ProxyAuhHeader = authHeader;
        handler.ProxyAuthHeaderExpires = 30;
        handler.Initialize();
    }

    // hier weitere Methoden
}

public void Initialize()
{
    // prüfen ob die Felder proxy und getDataMethod mit Werten belegt sind.
    if (this.proxy == null || this.getDataMethod == null)
    {
        throw new EmptyPropertyException(Resources.EmptyProxyAndGetData);
    }
    // prüfen ob die beiden CacheSchlüssel schon im Cache vorhanden sind.
    if (HttpRuntime.Cache[this.referenceKey] == null
        && HttpRuntime.Cache[this.cacheKey] == null)
    {
        HttpRuntime.Cache.Insert(this.referenceKey, false);
        this.CacheSiteMap();
    }
    // Schlüssel sind vorhanden, aber Daten wurden geändert.
    else
    {
        if ((bool)HttpRuntime.Cache[this.referenceKey])
        {
            HttpRuntime.Cache[this.referenceKey] = false;
            this.CacheSiteMap();
        }
    }
}

private void CacheSiteMap()
{
    // den ReferenceSchlüssel in das cacheKeys-Array schreiben.
    // wird zur Überwachung der Gültigkeit des Cache-Objekt benötigt.
    this.cacheKeys[0] = this.referenceKey;

    // Eine Cacheabhängikeit zum referenceKey erzeugen.
    CacheDependency dependency = new CacheDependency(null, this.cacheKeys);

    // Das DataSet in das Cache schreiben.
    HttpRuntime.Cache.Insert(
        this.cacheKey,
        this.GetDataSet(),
        dependency,
        Cache.NoAbsoluteExpiration,
        Cache.NoSlidingExpiration,
        CacheItemPriority.High,this.SitemapRemovedCallback);
}

byte[] hash = Fingerprint.CreateHash(
    new object[] { DateTime.Now, this.proxyAuthHeaderExpires, false });

// mittels Reflection die Properties der SoapAuthHeader Klasse holen.
PropertyInfo proxyAuthHeaderValue = this.proxy.GetType().GetProperty("SoapAuthHeaderValue");
PropertyInfo authHeaderCreated = this.proxyAuthHeader.GetType().GetProperty("Created");
PropertyInfo authHeaderExpires = this.proxyAuthHeader.GetType().GetProperty("Expires");
PropertyInfo authHeaderIsEditMode = this.proxyAuthHeader.GetType().GetProperty("IsEditMode");
PropertyInfo authHeaderHashValue = this.proxyAuthHeader.GetType().GetProperty("HashValue");       
// Die Werte in den Properties der SoapAuthHeader Klasse setzen
if (authHeaderCreated != null)
{
    authHeaderCreated.SetValue(this.proxyAuthHeader, DateTime.Now, null);
}

if (authHeaderExpires != null)
{
    authHeaderExpires.SetValue(this.proxyAuthHeader, this.proxyAuthHeaderExpires, null);
}

if (authHeaderIsEditMode != null)
{
    authHeaderIsEditMode.SetValue(this.proxyAuthHeader, false, null);
}

if (authHeaderHashValue != null)
{
    authHeaderHashValue.SetValue(this.proxyAuthHeader, hash, null);
}       
// Die SoapAuthHeader-Klasse an das Property SoapAuthHeaderValue der
// WebService-Proxy Klasse übergeben
if (proxyAuthHeaderValue != null)
{
    proxyAuthHeaderValue.SetValue(this.proxy, this.proxyAuthHeader, null);
}

// mittels Reflection die Methode holen welche das DataSet liefert.
MethodInfo proxyGetData = this.proxy.GetType().GetMethod(this.getDataMethod);

// Falls die Methode gefunden wurde und der RückgabeTyp ein DataSet ist
// wird die Methode mit Invoke aufgerufen.
if (proxyGetData != null && proxyGetData.ReturnType == typeof(DataSet))
{
    return (DataSet)proxyGetData.Invoke(this.proxy, new object[] { });
}