Entwickeln einer Regelvorlage für das URL-Neuschreibmodul

von Ruslan Yakushev

Diese Schritt-für-Schritt-Anleitung führt Sie durch die Erstellung einer Regelvorlage für das Modul "URL Rewrite". Sie erstellen eine Regelvorlage, die zum Generieren einer Neuschreibregel verwendet werden kann, die die Verwendung einer bestimmten Domäne für eine Website erzwingt.

Vorlagenübersicht

Kanonische Regelvorlage für Domänennamen kann verwendet werden, um die Erstellung einer Neuschreibregel zu vereinfachen, die zum Erzwingen kanonischer Domänennamen für eine Website verwendet wird. Benutzer haben die Möglichkeit, diese Vorlage im Dialog "Regel(n) hinzufügen" auszuwählen.

Dann können Benutzer einen Domänennamen angeben, den sie verwenden möchten:

Danach generiert die Vorlage eine Neuschreibregel wie folgt:

Voraussetzungen

Bevor Sie mit dieser exemplarischen Vorgehensweise fortfahren, empfiehlt es sich, sich mit den grundlegenden Konzepten der IIS-Manager-Erweiterbarkeit vertraut zu machen, indem Sie die Aufgaben im Artikel "Erstellen eines einfachen IIS-Manager-Moduls" ausführen.

VS2008-Projekt für die Regelvorlage

Das vollständige Visual Studio 2008-Projekt für diese Regelvorlage steht hier zum Download zur Verfügung.

Implementieren einer Regelvorlage

Zur Unterstützung der Remoteverwaltung werden alle IIS-Manager-UI-Komponenten mithilfe eines bestimmten Entwurfsmusters implementiert. Die Implementierung eines Moduls besteht aus folgenden Teilen:

• Clientseitige Benutzeroberfläche und Dienstproxy
• Serverseitiger Dienst zum Verwalten der IIS-Konfiguration

Alle benutzeroberflächenspezifischen Implementierungen befinden sich auf einer Clientseite, die möglicherweise ein Remoteclientcomputer ist. Alle Funktionen, die tatsächlich Änderungen an der IIS-Konfiguration vornehmen, werden als Dienst auf serverseitiger Seite implementiert, wodurch sichergestellt wird, dass sie Zugriff auf alle Serverkonfigurations-APIs hat. Clientseitige Steuerelemente interagieren mit dem Dienst über den Dienstproxy.

Es empfiehlt sich, Regelvorlagen mithilfe desselben Musters zu implementieren, damit die Vorlagen funktionieren, wenn Benutzer Regeln über IIS Remote Manager erstellen. In den folgenden Abschnitten wird beschrieben, wie Regelvorlagendienst und -client implementiert werden.

Implementieren einer clientseitigen Benutzeroberfläche

Erstellen eines Moduls

Zunächst müssen Sie ein Modul erstellen, ist der Haupteinstiegspunkt im Client für alle Erweiterbarkeitsobjekte. Gehen Sie dafür folgendermaßen vor:

1. Erstellen und konfigurieren Sie ein Visual Studio-Projekt, indem Sie die in den Aufgaben 1 und 2 beschriebenen Schritte aus dem Artikel "Erstellen eines einfachen IIS-Manager-Moduls" ausführen. Benennen Sie das Projekt als "CanonicalDomainTemplateClient".
2. Wählen Sie im Menü "Projekt" "Verweise hinzufügen" aus, und fügen Sie Verweise auf Microsoft.Web.Management.dll in \Windows\System32\inetsrv hinzu:
3. Wählen Sie erneut "Verweis hinzufügen" aus, und fügen Sie einen Verweis auf Microsoft.Web.Management.Rewrite.Client.dll in "\Programme\Referenzassemblys\Microsoft\IIS" hinzu.
4. Wählen Sie erneut "Verweis hinzufügen" aus, und fügen Sie System.Windows.Forms.dll einen Verweis hinzu.
5. Wählen Sie die Option " Neues Element hinzufügen " aus dem Menü "Projekt" aus. Wählen Sie im Dialogfeld " Neues Element hinzufügen " die Klassenvorlage aus, und geben Sie CanonicalDomainModule.cs als Namen für die Datei ein.
6. Ändern Sie den Code so, dass er wie folgt aussieht:

using System;
using Microsoft.Web.Management.Server;
using Microsoft.Web.Management.Client;
using Microsoft.Web.Management.Iis.Rewrite;

namespace CanonicalDomainTemplate
{
    internal class CanonicalDomainModule: Module
    {
        protected override void Initialize(IServiceProvider serviceProvider, ModuleInfo moduleInfo)
        {
            base.Initialize(serviceProvider, moduleInfo);

            IExtensibilityManager extensibilityManager = (IExtensibilityManager)GetService(typeof(IExtensibilityManager));

            extensibilityManager.RegisterExtension(typeof(RewriteTemplateFeature), new CanonicalDomainFeature(this)); 
        }
    }
}

Dieser Code initialisiert eine neue Instanz einer Klasse canonicalDomainFeature, die die Regelvorlagenfunktionalität implementiert. Die Instanz dieser Klasse wird verwendet, um eine Erweiterung des Typs "RewriteTemplateFeature" zu registrieren. Dabei handelt es sich um einen Typ, von dem alle Regelvorlagen abgeleitet werden.

Erstellen eines Feature zum Neuschreiben von Vorlagen

Beim Definieren einer Klasse, die die Regelvorlage implementiert, müssen Sie diese Klasse von der RewriteTemplateFeature-Klasse ableiten. Es handelt sich um eine übergeordnete Klasse, die von allen URL Rewrite-Regelvorlagen verwendet wird.

1. Wählen Sie die Option "Neues Element hinzufügen" im Projektmenü aus. Wählen Sie die Klassenvorlage aus, und geben Sie CanonicalDomainFeature.cs als Dateinamen ein.
2. Ändern Sie den Code so, dass er wie folgt aussieht:

using System;
using Microsoft.Web.Management.Client;
using Microsoft.Web.Management.Iis.Rewrite;
using System.Windows.Forms;
using System.Collections;

namespace CanonicalDomainTemplate
{
    class CanonicalDomainFeature: RewriteTemplateFeature
    {
        private const string FeatureTitle = "Canonical Domain Name";
        private const string FeatureDescription = "Creates a rewrite rule for enforcing canonical domain name for your web site";

        public CanonicalDomainFeature(Module module)
            : base(module, FeatureTitle, FeatureDescription, Resource.domain_icon16, Resource.domain_icon32)
        {
        }

        public override void Run()
        {
            CanonicalDomainModuleServiceProxy serviceProxy = 
                 (CanonicalDomainModuleServiceProxy)Connection.CreateProxy(this.Module, 
                                                                           typeof(CanonicalDomainModuleServiceProxy));
            CanonicalDomainForm form = new CanonicalDomainForm(serviceProxy);
            form.StartPosition = FormStartPosition.CenterParent;
            if (form.ShowDialog() == DialogResult.OK)
            {
                Navigate(GetPageType("Rewrite"));
            }
        }

        /// <summary>
        /// Returns the main page for the specified module
        /// </summary>
        private Type GetPageType(string moduleName)
        {
            IControlPanel controlPanel = (IControlPanel)GetService(typeof(IControlPanel));
            Module module = (Module)Connection.Modules[moduleName];

            if (module != null)
            {
                ICollection pageInfos = controlPanel.GetPages(module);

                foreach (ModulePageInfo pageInfo in pageInfos)
                {
                    if (pageInfo.IsEnabled && !pageInfo.PageType.IsAssignableFrom(typeof(IModuleChildPage)))
                    {
                        return pageInfo.PageType;
                    }
                }
            }

            return null;
        }
    }
}

Dieser Code macht Folgendes:

1. Definiert den Namen und den Titel für die Regelvorlage.
2. Übergibt den Namen, den Titel und die Symbole an den Basisklassenkonstruktor, sodass diese verwendet werden, wenn im Dialogfeld "Regel(en)" alle registrierten Regelvorlagen angezeigt werden.
3. Definiert die Run()-Methode, die zum Rendern der Vorlagen-Benutzeroberfläche verwendet wird. Dabei handelt es sich um ein modales WinForm-Dialogfeld (CanonicalDomainForm). Wenn im Dialogfeld auf die Schaltfläche "OK" geklickt wird, wird die Hauptbenutzeroberfläche des URL-Moduls "Rewrite" durch Aufrufen der Navigate()-Methode aktualisiert.
4. Schließlich definiert sie eine Hilfsfunktion GetPageType , die zum Abrufen der Hauptseite für das angegebene Modul verwendet wird.

Definieren eines Dienstproxys

Damit ein Remoteclient einen Dienst aufruft, muss ein Dienstproxy bereitgestellt werden. Fügen Sie dazu ihrem Projekt eine weitere Datei namens CanonicalDomainModuleServiceProxy.cs hinzu, und ändern Sie den Darin enthaltenen Code so, dass er wie folgt aussieht:

using System;
using Microsoft.Web.Management.Client;
using Microsoft.Web.Management.Server;

namespace CanonicalDomainTemplate
{
    class CanonicalDomainModuleServiceProxy : ModuleServiceProxy
    {

        public void GenerateRule(string domainName)
        {
            Invoke("GenerateRule", domainName);
        }
    }
}

Die tatsächliche Dienstimplementierung für die GenerateRule-Methode wird später hinzugefügt.

Implementieren des Dialogfelds "Regelvorlage"

Da nun der gesamte clientseitige Code des IIS-Managers abgeschlossen ist, besteht der verbleibende Teil darin, die eigentliche Benutzeroberfläche für die Regelvorlage zu entwerfen und zu implementieren. Führen Sie dazu die folgenden Schritte aus:

1. Wählen Sie die Option "Neues Element hinzufügen" im Projektmenü aus. Wählen Sie im Dialogfeld "Neues Element hinzufügen" "Windows Form" aus, und geben Sie den Namen CanonicalDomainForm.cs ein:
   

2. Verwenden Sie den Windows Forms-Designer von Visual Studio, um Steuerelemente im Formular anzuordnen:
   

3. Wechseln Sie zur Codeansicht, und fügen Sie das private Mitglied der Klasse hinzu, das einen Verweis auf einen Dienstproxy enthält:

   private CanonicalDomainModuleServiceProxy _serviceProxy;
   

4. Ändern Sie in derselben Klasse den Konstruktorcode wie folgt:

   public CanonicalDomainForm(CanonicalDomainModuleServiceProxy serviceProxy)
   {
      _serviceProxy = serviceProxy;
      InitializeComponent();
   }
   

5. Fügen Sie in derselben Klasse die Hilfsfunktion hinzu, die den Dienstproxy aufruft, um die Neuschreibregel mit den von einem Benutzer angegebenen Parametern zu generieren:

   private void GenerateRule(string domainName)
   {
       try
       {
           _serviceProxy.GenerateRule(domainName);
       }
       catch (Exception ex)
       {
           MessageBox.Show(ex.Message);
       }
   }
   

6. Fügen Sie einen Ereignishandler hinzu, wenn auf die Schaltfläche "OK" geklickt wird. Rufen Sie im Ereignishandlercode die Hilfsfunktion GenerateRule auf, und übergeben Sie den Inhalt des TextBox-Steuerelements als Parameter.

   private void OnOkButtonClick(object sender, EventArgs e)
   {
       GenerateRule(_DomainTextBox.Text);
   }
   

Implementieren eines Diensts für Regelvorlage

Um einen Dienst zu implementieren, müssen Sie einen Modulanbieter erstellen, bei dem es sich um einen Einstiegspunkt für die Registrierung von Modulen im IIS-Manager handelt. Gehen Sie dafür folgendermaßen vor:

1. Erstellen und konfigurieren Sie ein weiteres Visual Studio-Projekt, indem Sie die in den Aufgaben 1 und 2 beschriebenen Schritte aus dem Artikel "Erstellen eines einfachen IIS-Manager-Moduls" ausführen. Benennen Sie das Projekt als "CanonicalDomainTemplate".

2. Wählen Sie " Verweise hinzufügen" aus dem Menü "Projekt " aus, und fügen Sie Verweise auf die folgenden Assemblys hinzu, die sich in \Windows\System32\inetsrv befinden:

   1. Microsoft.Web.Administration.dll
   2. Microsoft.Web.Management.dll

3. Wählen Sie die Option " Neues Element hinzufügen " aus dem Menü "Projekt" aus. Wählen Sie im Dialogfeld " Neues Element hinzufügen " die Klassenvorlage aus, und geben Sie CanonicalDomainModuleProvider.cs als Namen für die Datei ein.

4. Ändern Sie den Code so, dass er wie unten aussieht (vergessen Sie nicht, das PublicKeyToken durch das öffentliche Schlüsseltoken der CanonicalDomainTemplate.Client.dll Assembly zu ersetzen)

namespace CanonicalDomainTemplate
{
    internal sealed class CanonicalDomainModuleProvider : ModuleProvider
    {
        public override string FriendlyName
        {
            get
            {
                return Resource.ModuleFriendlyName;
            }
        }

        public override Type ServiceType
        {
            get {
                 return typeof(CanonicalDomainModuleService);
            }
        }

        public override ModuleDefinition GetModuleDefinition(IManagementContext context)
        {
            if (context != null && string.Compare(context.ClientUserInterfaceTechnology, 
            "System.Windows.Forms.Control", StringComparison.OrdinalIgnoreCase) != 0)
            {
                return null;
            }

            return new ModuleDefinition(Name, "CanonicalDomainTemplate.CanonicalDomainModule,
                                               CanonicalDomainTemplate.Client,Version=1.0.0.0,Culture=neutral,
                                               PublicKeyToken={your key}");
        }

        public override bool SupportsScope(ManagementScope scope)
        {
            return true;
        }
    }
}

Dieser Code erstellt einen ModuleProvider, der alle Arten von Verbindungen (Server, Standort und Anwendung) unterstützt und ein clientseitiges Modul namens CanonicalDomainModule registriert. Außerdem wird der Typ des Moduldiensts CanonicalDomainModuleService registriert, der auf einer serverseitigen Anwendung zum Generieren von Neuschreibregeln verwendet wird.

Führen Sie die folgenden Schritte aus, um einen Dienst für die Regelvorlage zu erstellen:

1. Wählen Sie die Option "Neues Element hinzufügen" im Projektmenü aus. Wählen Sie die Klassenvorlage aus, und geben Sie CanonicalDomainModuleService.cs als Dateinamen ein.
2. Ändern Sie den Code so, dass er wie folgt aussieht:

using System;
using System.Collections.Generic;
using Microsoft.Web.Management.Server;
using Microsoft.Web.Administration;

namespace CanonicalDomainTemplate
{
    class CanonicalDomainModuleService : ModuleService
    {

        [ModuleServiceMethod]
        public void GenerateRule(string domainName)
        {
            string sectionPath = "system.webServer/rewrite/rules";
            
            if (ManagementUnit.ConfigurationPath.PathType == ConfigurationPathType.Server)
            {
                sectionPath = "system.webServer/rewrite/globalRules";
            }

            ConfigurationSection rulesSection = ManagementUnit.Configuration.GetSection(sectionPath);
            ConfigurationElementCollection rulesCollection = rulesSection.GetCollection();

            ConfigurationElement ruleElement = rulesCollection.CreateElement("rule");
            ruleElement["name"] = @"Canonical domain for " + domainName;
            ruleElement["patternSyntax"] = @"Wildcard";
            ruleElement["stopProcessing"] = true;

            ConfigurationElement matchElement = ruleElement.GetChildElement("match");
            matchElement["url"] = @"*";

            ConfigurationElement conditionsElement = ruleElement.GetChildElement("conditions");

            ConfigurationElementCollection conditionsCollection = conditionsElement.GetCollection();

            ConfigurationElement addElement = conditionsCollection.CreateElement("add");
            addElement["input"] = @"{HTTP_HOST}";
            addElement["negate"] = true;
            addElement["pattern"] = domainName;
            conditionsCollection.Add(addElement);

            ConfigurationElement actionElement = ruleElement.GetChildElement("action");
            actionElement["type"] = @"Redirect";
            actionElement["url"] = @"http://" + domainName + @"/{R:1}";
            actionElement["appendQueryString"] = true;
            rulesCollection.Add(ruleElement);

            ManagementUnit.Update();
        }
    }
}

Dieser Code erstellt eine Regel für die Umleitung zu kanonischer Domäne.

Registrieren der Regelvorlage beim IIS-Manager

Nachdem das Regelvorlagenprojekt erfolgreich kompiliert und in den globalen Assemblycache eingefügt wurde, müssen Sie es beim IIS-Manager registrieren, indem Sie dessen Informationen zu administration.config Datei hinzufügen.

Öffnen Sie die Datei administration.config unter \Windows\System32\inetsrv\config, und fügen Sie dem Abschnitt <moduleProviders> die folgende Zeile hinzu. Stellen Sie sicher, dass Sie das PublicKeyToken ersetzen:

<add name="CanonicalDomainName" type="CanonicalDomainTemplate.CanonicalDomainModuleProvider, CanonicalDomainTemplate, Version=1.0.0.0, Culture=neutral, PublicKeyToken=e4e6d0bc8fe7a06a" />

<location path=".">
   <module> 
     <add name="CanonicalDomainName" />
   </module>
</location>

Nachdem diese Schritte ausgeführt wurden, sollten Sie in der Lage sein, die Regelvorlage "Kanonischer Domänenname" im Dialogfeld "Regel hinzufügen" des URL-Moduls "Neu schreiben" anzuzeigen.