Exemplarische Vorgehensweise: Lokalisieren eines Webparts

Letzte Änderung: Dienstag, 7. Dezember 2010

Gilt für: SharePoint Foundation 2010

Inhalt dieses Artikels
Erstellen eines leeren SharePoint-Projekts
Erstellen des Webparts
Hinzufügen von Sprachressourcen
Lokalisieren des Features und der Beschreibungsdatei für Webparts-Steuerelemente
Schreiben von Code zum Abrufen lokalisierter Zeichenfolgen
Lokalisieren von Webparteigenschaften
Lokalisieren von Attributen
Testen des Webparts

In dieser exemplarischen Vorgehensweise wird das Lokalisieren eines Webparts für die Bereitstellung in Microsoft SharePoint Foundation 2010 gezeigt. Die dabei verwendeten Techniken gelten speziell für SharePoint Foundation 2010. Für ein Webpart, das in Microsoft ASP.NET bereitgestellt wird, können sie nicht verwendet werden.

In dieser exemplarischen Vorgehensweise erstellen Sie ein einfaches Webpart, mit dem der Text "Hello, world" in mehreren Sprachen angezeigt wird. Darüber hinaus erfahren Sie, wie Sie den gesamten anzuzeigenden Text des Webparts für die Lokalisierung vorbereiten, einschließlich des anzuzeigenden Texts für folgende Elemente:

• Das Feature, mit dem das Webpart bereitgestellt wird

• Den Eintrag für das Webpart im Webpartkatalog

• Den Titel im Webpartchrom

• Eine benutzerdefinierte Aktion im Webpartmenü

• Eine benutzerdefinierte Eigenschaft im Webpart-Editor

• Ein vom Webpart gehostetes untergeordnetes Steuerelement

Voraussetzungen

Die Verfahren in dieser exemplarischen Vorgehensweise wurden für Entwickler geschrieben, die Microsoft Visual Studio 2010 verwenden. Informationen zu den Anforderungen finden Sie unter Anforderungen für die Entwicklung von SharePoint-Lösungen.

Folgendes ist zum Ausführen der exemplarische Vorgehensweise erforderlich:

• Mindestens ein SharePoint Foundation 2010 Language Pack, das auf dem Entwicklungsserver installiert ist.

  Weitere Informationen zum Herunterladen und Installieren von Language Packs finden Sie unter Sprachpakete für SharePoint Foundation 2010.

• Mindestens eine SharePoint Foundation-Website, für die die Unterstützung alternativer Sprachen aktiviert ist.

  Weitere Informationen zum Aktivieren der Unterstützung alternativer Sprachen finden Sie unter Bereitstellen mehrerer Sprachen für die Benutzeroberfläche Ihrer Website.

Eine Einführung in wichtige Konzepte zum Lokalisieren von Lösungen in SharePoint Foundation 2010 finden Sie unter Grundlegendes zur MUI (Multilingual User Interface).

Erstellen eines leeren SharePoint-Projekts

Beginnen Sie mit dem Erstellen eines leeren SharePoint-Projekts in Visual Studio 2010. Benennen Sie das Projekt Wingtip.WebParts, und konfigurieren Sie es für die Bereitstellung als Farmlösung.

Hinweis

Das Webpart, das Sie in dieser exemplarischen Vorgehensweise erstellen, könnte als Sandkastenlösung bereitgestellt werden. Der gesamte Code für das Webpart kann als teilweise vertrauenswürdig ausgeführt werden. Neben dem Webpart werden in dieser exemplarischen Vorgehensweise auch Sprachressourcendateien in einem Stammordner der SharePoint-Installation bereitgestellt, und dieser Teil des Projekts muss voll vertrauenswürdig sein. In einer Produktionsumgebung können Sie zwei separate Lösungen verwenden: eine Sandkastenlösung zum Bereitstellen des Webparts, und eine Farmlösung zum Bereitstellen der Ressourcendateien. Der Einfachheit halber wird in dieser exemplarischen Vorgehensweise nur eine Lösung verwendet, nämlich eine Farmlösung.

So erstellen Sie ein leeres SharePoint-Projekt

1. Starten Sie Visual Studio 2010 als Administrator.

2. Öffnen Sie das Dialogfeld Neues Projekt, indem Sie im Menü Datei auf Neu zeigen und dann auf Neues Projekt klicken.

3. Erweitern Sie den Knoten SharePoint unter Visual C# oder Visual Basic, und klicken Sie dann auf 2010.

4. Klicken Sie im Bereich Vorlagen auf Leeres SharePoint-Projekt, ändern Sie den Namen des Projekts in Wingtip.WebParts, und klicken Sie dann auf OK.

   Der Assistent zum Anpassen von SharePoint wird geöffnet.

5. Geben Sie auf der Seite Site und Sicherheitsebene für Debugging angeben die URL für die SharePoint-Website ein, der Sie das neue Webpart hinzufügen möchten, oder verwenden Sie den Standardspeicherort (http://< Systemname>/).

6. Wählen Sie im Abschnitt Wie lautet die Vertrauensebene für diese SharePoint-Lösung? die Option Als Farmlösung bereitstellen aus.

7. Klicken Sie auf Fertig stellen.

   Das Projekt wird im Projektmappen-Explorer angezeigt.

Erstellen des Webparts

Im nächsten Schritt fügen Sie dem Projekt ein Webpart hinzu. Dazu erstellen Sie eine neue Klasse, die von der WebPart-Klasse im System.Web.UI.WebControls.WebParts-Namespace abgeleitet ist. Mit dem Beispielwebpart wird die CreateChildControls-Methode überschrieben, um ein untergeordnetes Steuerelement hinzuzufügen, nämlich eine Instanz der Label-Klasse. Später erfahren Sie in dieser exemplarischen Vorgehensweise, wie Sie den Text lokalisieren, der von diesem Steuerelement angezeigt wird. Um Ihnen die Möglichkeit zu bieten, die unterschiedlichen Benutzeroberflächentypen zu lokalisieren, die für ein Webpart in Frage kommen, wird mit dem Beispielcode eine benutzerdefinierte Eigenschaft erstellt, die mit den Attributen WebBrowsable und Personalizable versehen ist. Diese Attribute bewirken, dass die Eigenschaft im Toolbereich angezeigt wird, wenn ein Benutzer das Webpart bearbeitet. Schließlich wird in diesem Beispiel dem Menü mit den Webpartoptionen ein Element hinzugefügt, indem ein benutzerdefiniertes WebPartVerb-Element erstellt wird.

So fügen Sie dem Projekt ein Webpart hinzu

1. Wählen Sie im Projektmappen-Explorer den Knoten Wingtip.WebParts aus. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

2. Wählen Sie im Dialogfeld Neues Element hinzufügen die Option Webpart aus, und geben Sie LocalizedWebPart im Feld Name ein. Klicken Sie dann auf Hinzufügen.

   Die LocalizedWebPart-Klasse wird im Code-Editor geöffnet.

3. Drücken Sie im Code-Editor STRG+A, um alles auszuwählen. Anschließend kopieren Sie den folgenden Code und fügen ihn ein:

   using System;
   using System.ComponentModel;
   using System.Globalization;
   using System.Web.UI.WebControls;
   using System.Web.UI.WebControls.WebParts;
   using Microsoft.SharePoint.WebControls;
   
   namespace Wingtip.WebParts.LocalizedWebPart
   {
       [ToolboxItemAttribute(false)]
       public class LocalizedWebPart : WebPart
       {
   
           // Constants for display strings.
           const string CATEGORY_TEXT = "Text";
           const string LABEL_TEXT = "Hello, world!";
           const string TOOLPANE_BOLD = "Bold";
           const string TOOLPANE_BOLD_DESC = "Make the text bold";
           const string VERB_UNDERLINE = "Underline";
           const string VERB_UNDERLINE_DESC = "Draw a line under the text";
           const string WEB_PART_TITLE = "Localized Web Part";
           const string WEB_PART_DESC = "An example localized Web Part";
   
           // Member variable for the child control.
           private Label m_textLabel;
   
           // Instantiates the Web Part.
           public LocalizedWebPart()
           {
   
               // Add a handler for the PreRender event.
               PreRender += LocalizedWebPart_PreRender;
           }
   
           // Creates the control tree.
           protected override void CreateChildControls()
           {
   
               // Add a Label control to display content.
               m_textLabel = new Label();
               m_textLabel.Text = Text;
               Controls.Add(m_textLabel);
           }
   
           // The PreRender event is raised after the Web Part is edited,
           // so this is a good time to update the child control.
           void LocalizedWebPart_PreRender(object sender, EventArgs e)
           {
   
               // Make sure that CreateChildControls has been called.
               EnsureChildControls();
   
               // Apply current Web Part settings to the child control.
               m_textLabel.Font.Bold = Bold;
           }
   
   
           // Indicates whether the text is bold.
           // This property is exposed in the Web Part Editor.
           [WebBrowsable]
           [Personalizable(PersonalizationScope.Shared)]
           [Category(CATEGORY_TEXT)]
           [WebDisplayName(TOOLPANE_BOLD)]
           [WebDescription(TOOLPANE_BOLD_DESC)]
           public bool Bold { get; set; }
   
           // Overrides the Description property.
           [WebBrowsable(false), Personalizable(false)]
           public override string Description
           {
               get { return WEB_PART_DESC; }
               set { ; }
           }
   
           // Gets the text to display.
           private string Text
           {
               get { return LABEL_TEXT; }
           }
   
           // Overrides the Title property.
           [WebBrowsable(false), Personalizable(false)]
           public override string Title
           {
               get { return WEB_PART_TITLE; }
               set { ; }
           }
   
           // Gets a collection of custom verbs that provide items
           // on the options menu for the Web Part.
           public override WebPartVerbCollection Verbs
           {
               get
               {
   
                   // Add a custom verb to toggle underlining for the text.
                   WebPartVerb verb = new WebPartVerb(this.ID + "_UnderlineVerb",
                    (sender, args) =>
                    {
                        EnsureChildControls();
                        m_textLabel.Font.Underline = !m_textLabel.Font.Underline;
                    });
   
                   verb.Checked = m_textLabel.Font.Underline;
                   verb.Text = VERB_UNDERLINE;
                   verb.Description = VERB_UNDERLINE_DESC;
   
                   WebPartVerb[] newVerbs = new WebPartVerb[] { verb };
                   return new WebPartVerbCollection(base.Verbs, newVerbs);
               }
           }
       }
   }
   

   Imports System
   Imports System.ComponentModel
   Imports System.Globalization
   Imports System.Web.UI.WebControls
   Imports System.Web.UI.WebControls.WebParts
   Imports Microsoft.SharePoint.WebControls
   
   <ToolboxItemAttribute(false)> _
   Public Class LocalizedWebPart
       Inherits WebPart
   
       ' Constants for display strings.
       Const CATEGORY_TEXT As String = "Text"
       Const LABEL_TEXT As String = "Hello, world!"
       Const TOOLPANE_BOLD As String = "Bold"
       Const TOOLPANE_BOLD_DESC As String = "Make the text bold"
       Const VERB_UNDERLINE As String = "Underline"
       Const VERB_UNDERLINE_DESC As String = "Draw a line under the text"
       Const WEB_PART_TITLE As String = "Localized Web Part"
       Const WEB_PART_DESC As String = "An example localized Web Part"
   
       ' Member variable for the child control.
       Private m_textLabel As Label
   
       ' Instantiates the Web Part.
       Public Sub New()
           ' Add a handler for the PreRender event.
           AddHandler PreRender, AddressOf LocalizedWebPart_PreRender
       End Sub
   
       ' Creates the control tree.
       Protected Overrides Sub CreateChildControls()
           ' Add a Label control to display content.
           m_textLabel = New Label()
           m_textLabel.Text = Text
           Controls.Add(m_textLabel)
       End Sub
   
       ' The PreRender event is raised after the Web Part is edited,
       ' so this is a good time to update the child control.
       Private Sub LocalizedWebPart_PreRender(ByVal sender As Object, ByVal e As EventArgs)
   
           ' Make sure that CreateChildControls has been called.
           EnsureChildControls()
   
           ' Apply current Web Part settings to the child control.
           m_textLabel.Font.Bold = Bold
       End Sub
   
       Private m_bold As Boolean
   
       ' Indicates whether the text is bold.
       ' This property is exposed in the Web Part Editor.
       <WebBrowsable()> _
       <Personalizable(PersonalizationScope.[Shared])> _
       <Category(CATEGORY_TEXT)> _
       <WebDisplayName(TOOLPANE_BOLD)> _
       <WebDescription(TOOLPANE_BOLD_DESC)> _
       Public Property Bold() As Boolean
           Get
               Return m_bold
           End Get
           Set(ByVal value As Boolean)
               m_bold = value
           End Set
       End Property
   
       ' Overrides the Description property.
       <WebBrowsable(False)> _
       <Personalizable(False)> _
       Public Overrides Property Description As String
           Get
               Return WEB_PART_DESC
           End Get
           Set(ByVal value As String)
           End Set
       End Property
   
       ' Gets the text to display.
       ReadOnly Property Text As String
           Get
               Return LABEL_TEXT
           End Get
       End Property
   
       ' Overrides the Title property.
       <WebBrowsable(False)> _
       <Personalizable(False)> _
       Public Overrides Property Title As String
           Get
               Return WEB_PART_TITLE
           End Get
           Set(ByVal value As String)
           End Set
       End Property
   
       ' Gets a collection of custom verbs that provide items
       ' on the options menu for the Web Part.
       Public Overrides ReadOnly Property Verbs() As WebPartVerbCollection
           Get
   
               ' Add a custom verb to toggle underlining for the text.
               Dim verb As New WebPartVerb(Me.ID + "_UnderlineVerb", AddressOf UnderlineVerbHandler)
   
               verb.Checked = m_textLabel.Font.Underline
               verb.Text = VERB_UNDERLINE
               verb.Description = VERB_UNDERLINE_DESC
   
               Dim newVerbs As WebPartVerb() = New WebPartVerb() {verb}
               Return New WebPartVerbCollection(MyBase.Verbs, newVerbs)
           End Get
       End Property
   
       ' Toggles underlining.
       Private Sub UnderlineVerbHandler(ByVal sender As Object, ByVal args As EventArgs)
           EnsureChildControls()
           m_textLabel.Font.Underline = Not m_textLabel.Font.Underline
       End Sub
   
   End Class
   

4. Drücken Sie STRG+UMSCHALT+S, um alles zu speichern.

Damit verfügen Sie über ein funktionierendes Webpart, das Sie testen sollten. Drücken Sie F5, um die Lösung zu erstellen und bereitzustellen. Erstellen Sie beim Öffnen der Website eine neue Webpartseite, und fügen Sie ihr das Webpart hinzu. Während für die Seite der Bearbeitungsmodus aktiviert ist, überprüfen Sie das Optionsmenü in der rechten oberen Ecke des Webpartchroms. Klicken Sie mehrmals auf Underline, um sicherzustellen, dass das benutzerdefinierte Verb ordnungsgemäß ausgeführt wird. Klicken Sie anschließend auf Webpart bearbeiten. Wenn der Toolbereich angezeigt wird, suchen Sie unten in diesem Bereich nach der benutzerdefinierten Eigenschaft. Wählen Sie Bold aus, und klicken Sie dann auf Übernehmen, um sicherzustellen, dass die Eigenschaft ordnungsgemäß festgelegt wird.

Hinzufügen von Sprachressourcen

Der erste Schritt beim Lokalisieren des Webparts ist das Hinzufügen von Sprachressourcendateien zum Projekt. Für diese exemplarische Vorgehensweise benötigen Sie nur zwei Ressourcendateien: eine Datei für die Standardsprache der Website, und eine andere Datei für eine der alternativen Sprachen, die von der Website unterstützt werden. Sie können die von Ihnen bevorzugten Sprachen verwenden. In diesen Beispielen werden Englisch und Spanisch verwendet.

Tipp

Wenn Sie feststellen möchten, welche Sprachen von Ihrer Entwicklungswebsite unterstützt werden, öffnen Sie die zugehörige Homepage im Browser. Klicken Sie auf Websiteaktionen und dann auf Websiteeinstellungen. Klicken Sie unter Websiteadministration auf Spracheinstellungen. Die Standardsprache wird oben auf der Seite aufgelistet. Alternative Sprachen werden unterhalb der Standardsprache aufgelistet.

Sie müssen die von Ihnen erstellten Ressourcendateien in einem Speicherort im Dateisystem Ihres Webservers bereitstellen, auf den alle Komponenten des Webparts, mit denen anzuzeigender Text generiert werden, Zugriff haben. Hierzu zählen die folgenden Komponenten:

• Das Feature, mit dem das Webpart aktiviert wird.

• Die Beschreibungsdateien für Webparts-Steuerelemente, die Information für den Webpartkatalog enthält.

• Der Code, der in der kompilierten Assembly ausgeführt wird.

Es gibt mehrere Alternativen, um Sprachressourcen auf den Zielwebservern bereitzustellen. Die einfachste und zugleich flexibelste Vorgehensweise zum Einrichten der Unterstützung anderer Sprachen ist das Bereitstellen von Sprachressourcendateien im Ressourcenordner, der sich direkt unterhalb des SharePoint Foundation-Installationsstammverzeichnisses befindet. Das von Visual Studio für diesen Ordner verwendete Token ist {SharePointRoot}\Resources. Der vollständige Pfad lautet %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\Resources. In diesem Ordner werden von SharePoint Foundation Sprachressourcen installiert, die von integrierten Webparts verwendet werden.

So fügen Sie dem Ordner "{SharePointRoot}\Resources" Ressourcen hinzu

1. Wählen Sie im Projektmappen-Explorer den Projektknoten Wingtip.Webparts aus. Klicken Sie im Menü Projekt auf Zugeordneten SharePoint-Ordner hinzufügen.

2. Wählen Sie im Dialogfeld Zugeordneten SharePoint-Ordner hinzufügen die Option Ressourcen aus, und klicken Sie auf OK.

   Dem Projekt wird ein Ressourcenordner hinzugefügt. Überprüfen Sie die Eigenschaften dieses Ordners. Beachten Sie, dass die DeploymentLocation-Eigenschaft auf {SharePointRoot}\Resources festgelegt ist.

3. Wählen Sie im Projektmappen-Explorer den Ordner Ressourcen aus. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

4. Erweitern Sie im Dialogfeld Neues Element hinzufügen den Knoten Visual C#, falls Sie C# als Entwicklungssprache verwenden, oder den Knoten Gemeinsame Elemente, falls Sie in Visual Basic arbeiten. Wählen Sie Allgemein aus. Wählen Sie im Vorlagenbereich die Option Ressourcendatei aus. Benennen Sie die Datei Wingtip.WebParts.resx, und klicken Sie dann auf Hinzufügen.

   Die Ressourcendatei wird dem Projekt hinzugefügt und im Editor für verwaltete Ressourcen geöffnet.

   Tipp

   Beim Bereitstellen von Dateien im globalen Ressourcenordner empfiehlt es sich, eindeutige Dateinamen auszuwählen, um Namenskonflikte mit Ressourcen zu vermeiden, die von anderen Anwendungen bereitgestellt werden. Eine Konvention besteht darin, dem Dateinamen Ihren Firmennamen als Präfix voranzustellen. Wenn beispielsweise Ihr Unternehmen "Wingtip Toys" heißt, können die Namen der von Ihnen bereitgestellten Ressourcendateien alle mit "Wingtip" beginnen.

5. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die soeben erstellte Ressourcendatei, und klicken Sie dann auf Öffnen mit. Wählen Sie im Dialogfeld Öffnen mit die Option XML (Text)-Editor aus, und klicken Sie dann auf OK.

   Die Ressourcendatei wird im Editor geöffnet.

6. Verschieben Sie den Fensterinhalt an das Ende der Datei, und fügen Sie direkt über dem </root>-Tag eine leere Zeile ein. Kopieren Sie das folgende Markup, und fügen Sie es an der Einfügemarke in die Datei ein.

     <data name="Bold" xml:space="preserve">
       <value>Bold (invariant)</value>
     </data>
     <data name="BoldDesc" xml:space="preserve">
       <value>Make the text bold (invariant)</value>
     </data>
     <data name="FeatureDesc" xml:space="preserve">
       <value>An example localized Web Part (invariant)</value>
     </data>
     <data name="FeatureTitle" xml:space="preserve">
       <value>Localized Web Part (invariant)</value>
     </data>
     <data name="LabelText" xml:space="preserve">
       <value>Hello, world! (invariant)</value>
     </data>
     <data name="TextCategory" xml:space="preserve">
       <value>Text (invariant)</value>
     </data>
     <data name="Underline" xml:space="preserve">
       <value>Underline (invariant)</value>
     </data>
     <data name="UnderlineDesc" xml:space="preserve">
       <value>Draw a line under the text (invariant)</value>
     </data>
     <data name="WebPartDesc" xml:space="preserve">
       <value>An example localized Web Part (invariant)</value>
     </data>
     <data name="WebPartTitle" xml:space="preserve">
       <value>Localized Web Part (invariant)</value>
     </data>
   

7. Drücken Sie STRG+S, um die Datei zu speichern. Klicken Sie dann im Menü Datei auf Schließen, um die Datei zu schließen.

8. Wählen Sie im Projektmappen-Explorer die Datei Wingtip.WebParts.resx aus. Klicken Sie im Menü Bearbeiten auf Kopieren, und klicken Sie dann auf Einfügen.

   Eine Datei mit dem Namen Kopie von Wingtip.WebParts.resx wird dem Ordner Ressourcen hinzugefügt.

9. Klicken Sie mit der rechten Maustaste auf die Datei Kopie von Wingtip.WebParts.resx, und klicken Sie dann auf Umbenennen. Benennen Sie die Datei in Wingtip.WebParts.Sprache-LAND/REGION.resx um. Dabei ist Sprache ein aus zwei Buchstaben bestehender Code für die Standardsprache Ihrer Website, und LAND/REGION ist ein aus zwei Buchstaben bestehender Code für die Subkultur.

   Wenn beispielsweise die Standardsprache Englisch (USA) ist, heißt die Ressourcendatei Wingtip.WebParts.en-US.resx.

   Weitere Informationen zu Sprachen-IDs finden Sie im Thema zur System.Globalization.CultureInfo-Klasse.

   Wichtig

   Später wird in dieser exemplarischen Vorgehensweise gezeigt, dass mithilfe des Basisdateinamens, wie z. B. Wingtip.WebParts, auf eine Ressourcendatei verwiesen wird. Wenn von SharePoint Foundation ein Ressourcenwert abgerufen wird, wird nach einer Ressourcendatei gesucht, die diesen Basisdateinamen gefolgt von einer Sprachen-ID, die dem Wert der CurrentUICulture-Eigenschaft des aktuell ausgeführt Threads entspricht, aufweist. SharePoint Foundation sucht nach einer genauen Übereinstimmung. Wenn beispielsweise die Sprachen-ID im aktuellen Thread "pt-BR" lautet, sucht SharePoint Foundation nach einer Ressourcendatei mit dem Namen Basisdateiname.pt-BR.resx. Dateien mit derselben Sprachen-ID, aber einer unterschiedlichen Subkultur, wie z. B. Basisdateiname.pt.resx und Basisdateiname.pt-PT.resx, werden ignoriert. Falls SharePoint Foundation keine Ressourcendatei findet, die mit der Sprachen-ID im aktuell ausgeführten Thread übereinstimmt, wird nach einer Fallback-Ressourcendatei gesucht. Die erste Wahl als Fallback ist eine Ressourcendatei für die invariante Kultur, d. h., eine Ressourcendatei ohne Sprachen-ID am Ende des Dateinamens. Beispielsweise ist Wingtip.WebParts.resx im aktuellen Projekt die Ressourcendatei für die invariante Kultur. Falls SharePoint Foundation keine Ressourcendatei für die invariante Kultur findet, wird versucht auf die Standardsprache auszuweichen. Für den Fall, dass keine Ressourcendatei für die Standardsprache gefunden wird, wird der Ressourcenname angezeigt.

10. Wiederholen Sie die Schritte 8 und 9, aber fügen Sie dieses Mal die Sprachen-ID für eine alternative Sprache an, die in Ihrer Website aktiviert ist.

11. Öffnen Sie die beiden soeben erstellten kulturspezifischen Sprachressourcendateien, und ersetzen Sie das Wort "invariant" durch die Sprachen-ID für die Datei. In der Datei Wingtip.WebParts.en-US.resx wird beispielsweise Bold (invariant) zu Bold (en-US).

    Für diese exemplarische Vorgehensweise müssen keine Zeichenfolgenwerte übersetzt werden. Vielmehr sollte es ausreichen, eine Sprachen-ID an eine unübersetzte Zeichenfolge anzufügen. Beim Testen des Webparts gibt die Sprachen-ID die angezeigte Sprache an.

12. Drücken Sie STRG+UMSCHALT+S, um alles zu speichern.

Lokalisieren des Features und der Beschreibungsdatei für Webparts-Steuerelemente

Der nächste wichtige Schritt ist das Lokalisieren der Anzeigenzeichenfolgen, die in zwei wichtigen XML-Dateien vorkommen: der Featureelementdatei und der Beschreibungsdatei für Webparts-Steuerelemente. Beide Dateien enthalten Titel- und Beschreibungszeichenfolgen, die Sie durch ASP.NET-Ausdrücke ersetzen können, die dem folgenden Muster entsprechen:

$Resources:BaseFileName,ResourceName

Das Dollarzeichen ($) weist darauf hin, dass ein Ausdruck folgt. Mit dem Präfix "Resources" wird der Ausdruckstyp angegeben. Das Suffix nach dem Doppelpunkt (:) ist der Ausdruckswert, der aufgelöst wird. Der erste Teil dieses Wertes ist der Basisdateiname für eine Ressourcendatei. Der Teil nach dem Komma ist der Name der lokalisierten Zeichenfolge, die aus der Datei abgerufen wird. In diesem Ausdruck sind an keiner Stelle Leerzeichen zulässig.

Hinweis
Eventuell sind Ressourcenausdrücke vorhanden, die auf ein Semikolon (;) enden. Dieses Trennzeichen ist zulässig, aber für SharePoint Foundation 2010 nicht erforderlich.

So lokalisieren Sie das Feature

1. Erweitern Sie im Projektmappen-Explorer den Ordner Features, und doppelklicken Sie dann auf Feature1.

   Feature1.feature wird im Feature-Designer geöffnet.

2. Löschen Sie im Feature-Designer den Text im Feld Titel, und ersetzen Sie ihn durch den folgenden Ressourcenausdruck:

   $Resources:Wingtip.WebParts,FeatureTitle
   

3. Fügen Sie den folgenden Ausdruck in das Feld Beschreibung ein:

   $Resources:Wingtip.WebParts,FeatureDesc
   

4. Drücken Sie STRG+UMSCHALT+S, um alles zu speichern.

So lokalisieren Sie die Beschreibungsdatei für Webparts-Steuerelemente

1. Erweitern Sie im Projektmappen-Explorer den Ordner LocalizedWebPart, und doppelklicken Sie dann auf LocalizedWebPart.webpart.

   LocalizedWebPart.webpart wird im XML-Editor geöffnet.

2. Löschen Sie den Wert für die Title-Eigenschaft ("LocalizedWebPart"), und ersetzen Sie ihn durch den folgenden Ressourcenausdruck:

   $Resources:Wingtip.WebParts,WebPartTitle
   

3. Löschen Sie den Wert für die Description-Eigenschaft ("My WebPart"), und ersetzen Sie ihn durch den folgenden Ressourcenausdruck:

   $Resources:Wingtip.WebParts,WebPartDesc
   

4. Drücken Sie STRG+UMSCHALT+S, um alles zu speichern.

Schreiben von Code zum Abrufen lokalisierter Zeichenfolgen

Sie lokalisieren Code in einer regulären ASP.NET-Anwendung, indem Sie Sprachressourcen in eine Satellitenassembly einbetten, die mit der Hauptassembly im globalen Assemblycache bereitgestellt wird. Wenn mit dem Code ein Ressourcenwert abgerufen werden muss, rufen Sie die HttpContext.GetGlobalResourceObject-Methode auf.

Diese Methode kann natürlich über Code abgerufen werden, der in SharePoint Foundation ausgeführt wird. Es gibt jedoch für SharePoint Foundation-Entwickler eine alternative Methode, für die Sie die Sprachressourcen nicht in Satellitenassemblys bereitstellen müssen. Die SPUtility-Klasse enthält die statische GetLocalizedString-Methode, mit der ein Zeichenfolgenwert aus einer Ressourcendatei im Ordner {SharePointRoot}\Resources auf dem Webserver abgerufen werden kann. In dieser exemplarischen Vorgehensweise werden Sie die GetLocalizedString-Methode verwenden.

Die GetLocalizedString-Methode erwartet einen Ressourcenausdruck im ersten Argument sowie den Basisdateinamen einer Ressourcendatei im zweiten Argument. Zur Vereinfachung von Methodenaufrufen im Webpartcode binden Sie GetLocalizedString in eine benutzerdefinierte Methode ein.

So erstellen Sie eine Methode zum Abrufen von Ressourcenzeichenfolgen

1. Wählen Sie im Projektmappen-Explorer den Projektknoten Wingtip.Webparts aus. Klicken Sie im Menü Projekt auf Klasse hinzufügen.

   Das Dialogfeld Neues Element hinzufügen wird angezeigt.

2. Geben Sie im Feld Name in Abhängigkeit von der verwendeten Sprache die Zeichenfolge Utility.cs oder Utility.vb ein. Klicken Sie anschließend auf Hinzufügen.

3. Drücken Sie STRG+A, um alles auszuwählen. Anschließend kopieren Sie den folgenden Code und fügen ihn ein, wobei Sie den gesamten Inhalt der Datei ersetzen.

   using Microsoft.SharePoint.Utilities;
   
   namespace Wingtip.WebParts.LocalizedWebPart
   {
       public static class Utility
       {
   
           // Wraps the SPUtility method of the same name.
           public static string GetLocalizedString(string resourceName, int LCID)
           {
               if (string.IsNullOrEmpty(resourceName))
                   return string.Empty;
   
               // SPUtility.GetLocalized string needs a resource expression as the first argument.
               string resourceExpression = string.Format("$Resources:{0}", resourceName);
   
               string resourceFile = "Wingtip.WebParts";
   
               // Note: If the named resource does not have a value for the specified language, 
               // SPUtility.GetLocalizedString returns the value for the invariant language.
               // If the named resource does not exist, it returns the original expression.
              return SPUtility.GetLocalizedString(resourceExpression, resourceFile, (uint)LCID);
           }
       }
   }
   

   Imports Microsoft.SharePoint.Utilities
   
   Public NotInheritable Class Utility
   
       ' Wraps the SPUtility method of the same name.
       Public Shared Function GetLocalizedString(ByVal resourceName As String, ByVal LCID As Integer) As String
   
           If String.IsNullOrEmpty(resourceName) Then
               Return String.Empty
           End If
   
           Dim resourceFile As String = "Wingtip.WebParts"
   
           ' SPUtility.GetLocalized string needs a resource expression as the first argument.
           Dim resourceExpression As String = String.Format("$Resources:{0}", resourceName)
   
           ' Note: If the named resource does not have a value for the specified language, 
           ' SPUtility.GetLocalizedString returns the value for the invariant language.
           ' If the named resource does not exist, it returns the original expression.
           Return SPUtility.GetLocalizedString(resourceExpression, resourceFile, CUInt(LCID))
   
       End Function
   
   End Class
   

4. Drücken Sie STRG+UMSCHALT+S, um alles zu speichern.

Lokalisieren von Webparteigenschaften

Im nächsten Schritt lokalisieren Sie den Code für die Webparteigenschaften, mit denen der anzuzeigende Text zurückgegeben wird. Sie können in jedem Fall eine hartcodierte Zeichenfolge durch einen Aufruf der Hilfsmethode GetLocalizedString ersetzen und dabei einen Ressourcennamen und die Gebietsschema-ID (LCID) für die Sprache des aktuellen Threads übergeben. Die LCID für die aktuelle Sprache erhalten Sie durch den Zugriff auf die statische CultureInfo.CurrentUICulture-Eigenschaft.

So lokalisieren Sie Eigenschaften des Webparts

1. Doppelklicken Sie im Projektmappen-Explorer auf LocalizedWebPart.cs oder LocalizedWebPart.vb, um die Quelldatei zu öffnen.

2. Am Anfang der Datei, direkt unter der Deklaration für die LocalizedWebPart-Klasse, sind Deklarationen für mehrere Zeichenfolgenkonstanten vorhanden. Löschen Sie diese Deklarationen, und ersetzen Sie sie durch den folgenden Code:

   // Translate resource keys to string constants.
   const string CATEGORY_TEXT = "TextCategory";
   const string LABEL_TEXT = "LabelText";
   const string TOOLPANE_BOLD = "Bold";
   const string TOOLPANE_BOLD_DESC = "BoldDesc";
   const string VERB_UNDERLINE = "Underline";
   const string VERB_UNDERLINE_DESC = "UnderlineDesc";
   const string WEB_PART_TITLE = "WebPartTitle";
   const string WEB_PART_DESC = "WebPartDesc";
   

   ' Translate resource keys to string constants.
   Const CATEGORY_TEXT As String = "TextCategory"
   Const LABEL_TEXT As String = "LabelText"
   Const TOOLPANE_BOLD As String = "Bold"
   Const TOOLPANE_BOLD_DESC As String = "BoldDesc"
   Const VERB_UNDERLINE As String = "Underline"
   Const VERB_UNDERLINE_DESC As String = "UnderlineDesc"
   Const WEB_PART_TITLE As String = "WebPartTitle"
   Const WEB_PART_DESC As String = "WebPartDesc"
   

3. Navigieren Sie zur Description-Eigenschaft. Ersetzen Sie den Code für den get-Accessor durch den folgenden Code:

   get { return Utility.GetLocalizedString(WEB_PART_DESC, CultureInfo.CurrentUICulture.LCID); }
   

   Get
       Return Utility.GetLocalizedString(WEB_PART_DESC, CultureInfo.CurrentUICulture.LCID)
   End Get
   

4. Navigieren Sie zur Text-Eigenschaft. Ersetzen Sie den Code für den get-Accessor durch den folgenden Code:

   get { return Utility.GetLocalizedString(LABEL_TEXT, CultureInfo.CurrentUICulture.LCID); }
   

   Get
       Return Utility.GetLocalizedString(LABEL_TEXT, CultureInfo.CurrentUICulture.LCID)
   End Get
   

5. Navigieren Sie zur Title-Eigenschaft. Ersetzen Sie den Code für den get-Accessor durch den folgenden Code:

   get { return Utility.GetLocalizedString(WEB_PART_TITLE, CultureInfo.CurrentUICulture.LCID); }
   

   Get
       Return Utility.GetLocalizedString(WEB_PART_TITLE, CultureInfo.CurrentUICulture.LCID)
   End Get
   

6. Navigieren Sie zur Verbs-Eigenschaft. Ersetzen Sie die beiden Codezeilen, mit denen die Eigenschaften verb.Text und verb.Description festgelegt werden, durch die folgenden Codezeilen:

   verb.Text = Utility.GetLocalizedString(VERB_UNDERLINE, CultureInfo.CurrentUICulture.LCID);
   verb.Description = Utility.GetLocalizedString(VERB_UNDERLINE_DESC, CultureInfo.CurrentUICulture.LCID);
   

   verb.Text = Utility.GetLocalizedString(VERB_UNDERLINE, CultureInfo.CurrentUICulture.LCID)
   verb.Description = Utility.GetLocalizedString(VERB_UNDERLINE_DESC, CultureInfo.CurrentUICulture.LCID)
   

7. Drücken Sie STRG+UMSCHALT+S, um alles zu speichern.

Lokalisieren von Attributen

Wie im folgenden Codeausschnitt veranschaulicht, wird mit dem Code für das Webpart eine benutzerdefinierte Bold-Eigenschaft definiert, die mit mehreren Attributen versehen ist:

[WebBrowsable]
[Personalizable(PersonalizationScope.Shared)]
[Category(CATEGORY_TEXT)]
[WebDisplayName(TOOLPANE_BOLD)]
[WebDescription(TOOLPANE_BOLD_DESC)]
public bool Bold { get; set; }

<WebBrowsable()> _
<Personalizable(PersonalizationScope.[Shared])> _
<Category(CATEGORY_TEXT)> _
<WebDisplayName(TOOLPANE_BOLD)> _
<WebDescription(TOOLPANE_BOLD_DESC)> _
Public Property Bold() As Boolean
    Get
        Return m_bold
    End Get
    Set(ByVal value As Boolean)
        m_bold = value
    End Set
End Property

Mit den Attributen WebBrowsable und Personalizable wird die Eigenschaft in der Bearbeitungsbenutzeroberfläche angezeigt, wenn ein Benutzer das Webpart bearbeitet. Mit drei zusätzlichen Attributen wird anzuzeigender Text für die Bearbeitungsbenutzeroberfläche bereitgestellt:

• Category

  Stellt den Anzeigenamen einer benutzerdefinierten Kategorie für die Eigenschaft bereit.

• WebDisplayName

  Stellt den Anzeigenamen der Eigenschaft bereit.

• WebDescription

  Stellt den QuickInfo-Text für die Eigenschaft bereit.

Zum Lokalisieren des Texts für diese Attribute müssen Sie benutzerdefinierte Attributklassen erstellen, die von den Klassen CategoryAttribute, WebDisplayNameAttribute und WebDescriptionAttribute abgeleitet sind.

So lokalisieren Sie die Attribute "Category", "WebDisplayName" und "WebDescription"

1. Doppelklicken Sie im Projektmappen-Explorer auf LocalizedWebPart.cs oder LocalizedWebPart.vb, um die Quelldatei zu öffnen.

2. Fügen Sie am Ende der LocalizedWebPart-Klasse, aber noch innerhalb der Klasse, Code für die folgenden Unterklassen ein:

   public sealed class LocalizedCategoryAttribute : CategoryAttribute
   {
       public LocalizedCategoryAttribute(string category)
           : base(category)
       { }
   
       // Override this method to return values from the webpart's resource file.
       protected override string GetLocalizedString(string value)
       {
           return Utility.GetLocalizedString(value, CultureInfo.CurrentUICulture.LCID);
       }
   }
   
   public sealed class LocalizedWebDisplayNameAttribute : WebDisplayNameAttribute
   {
       bool m_isLocalized;
   
       public LocalizedWebDisplayNameAttribute(string displayName)
           : base(displayName)
       { }
   
       // Override this property to return values from the webpart's resource file.
       public override string DisplayName
       {
           get
           {
               if (!m_isLocalized)
               {
                   this.DisplayNameValue = Utility.GetLocalizedString(base.DisplayName, CultureInfo.CurrentUICulture.LCID);
                   m_isLocalized = true;
               }
               return base.DisplayName;
           }
       }
   }
   
   public sealed class LocalizedWebDescriptionAttribute : WebDescriptionAttribute
   {
       bool m_isLocalized;
   
       public LocalizedWebDescriptionAttribute(string description)
           : base(description)
       { }
   
       // Override this property to return values from the webpart's resource file.
       public override string Description
       {
           get
           {
               if (!m_isLocalized)
               {
                   this.DescriptionValue = Utility.GetLocalizedString(base.Description, CultureInfo.CurrentUICulture.LCID);
                   m_isLocalized = true;
               }
               return base.Description;
           }
       }
   }
   

   Public NotInheritable Class LocalizedCategoryAttribute
       Inherits CategoryAttribute
       Public Sub New(ByVal category As String)
           MyBase.New(category)
       End Sub
   
       ' Override this method to return values from the webpart's resource file.
       Protected Overrides Function GetLocalizedString(ByVal value As String) As String
           Return Utility.GetLocalizedString(value, CultureInfo.CurrentUICulture.LCID)
       End Function
   End Class
   
   Public NotInheritable Class LocalizedWebDisplayNameAttribute
       Inherits WebDisplayNameAttribute
       Private m_isLocalized As Boolean
   
       Public Sub New(ByVal displayName As String)
           MyBase.New(displayName)
       End Sub
   
       ' Override this property to return values from the webpart's resource file.
       Public Overrides ReadOnly Property DisplayName() As String
           Get
               If Not m_isLocalized Then
                   Me.DisplayNameValue = Utility.GetLocalizedString(MyBase.DisplayName, CultureInfo.CurrentUICulture.LCID)
                   m_isLocalized = True
               End If
               Return MyBase.DisplayName
           End Get
       End Property
   End Class
   
   Public NotInheritable Class LocalizedWebDescriptionAttribute
       Inherits WebDescriptionAttribute
       Private m_isLocalized As Boolean
   
       Public Sub New(ByVal description As String)
           MyBase.New(description)
       End Sub
   
       ' Override this property to return values from the webpart's resource file.
       Public Overrides ReadOnly Property Description() As String
           Get
               If Not m_isLocalized Then
                   Me.DescriptionValue = Utility.GetLocalizedString(MyBase.Description, CultureInfo.CurrentUICulture.LCID)
                   m_isLocalized = True
               End If
               Return MyBase.Description
           End Get
       End Property
   End Class
   

3. Navigieren Sie zur Bold-Eigenschaft. Ändern Sie anschließend die Namen der Attribute Category, WebDisplayName und WebDescription in LocalizedCategory, LocalizedWebDisplayName bzw. LocalizedWebDescription.

   Ändern Sie die Attributparameter nicht. Der überarbeitete Code sieht wie folgt aus:

   [LocalizedCategory(CATEGORY_TEXT)]
   [LocalizedWebDisplayName(TOOLPANE_BOLD)]
   [LocalizedWebDescription(TOOLPANE_BOLD_DESC)]
   

   <LocalizedCategory(CATEGORY_TEXT)> _
   <LocalizedWebDisplayName(TOOLPANE_BOLD)> _
   <LocalizedWebDescription(TOOLPANE_BOLD_DESC)> _
   

4. Drücken Sie STRG+UMSCHALT+S, um alles zu speichern.

Testen des Webparts

Testen Sie das Webpart, um sicherzustellen, dass es ordnungsgemäß ausgeführt wird.

So testen Sie das Webpart

1. Drücken Sie in Visual Studio F5, um das Debugging zu starten.

   Im Ausgabebereich wird der Erstellungs- und Bereitstellungsprozess gemeldet. Schließlich wird die Website im Standardbrowser angezeigt.

2. Klicken Sie auf Websiteaktionen und dann auf Websiteeinstellungen. Klicken Sie unter Websitesammlungsverwaltung auf Websitesammlungs-Features. Überprüfen Sie, ob für das lokalisierte Webpartfeature der Titel und die Beschreibung in der Standardsprache angezeigt werden.

3. Klicken Sie in der rechten oberen Ecke der Seite auf Ihren Namen. Zeigen Sie auf Anzeigesprache auswählen, und klicken Sie dann auf die alternative Sprache, die Sie zum Lokalisieren des Webparts verwendet haben. Überprüfen Sie, ob der Titel und die Beschreibung des lokalisierten Webpartfeatures in der alternativen Sprache angezeigt werden.

4. (Optional) Wiederholen Sie Schritt 3, aber wählen Sie eine Sprache aus, für die Sie keine Sprachressourcendatei bereitgestellt haben. Überprüfen Sie, ob der Titel und die Beschreibung des lokalisierten Webpartfeatures in der invarianten Sprache angezeigt werden.

5. Wiederholen Sie Schritt 3, aber setzen Sie die Sprache auf den Standardwert der Website zurück.

6. Klicken Sie auf Websiteaktionen und dann auf Websiteeinstellungen. Klicken Sie unter Galerien auf Webparts, und klicken Sie anschließend auf LocalizedWebPart.webpart. Überprüfen Sie, ob der Titel, die Beschreibung und das Beispiel in der Standardsprache angezeigt werden.

7. Wiederholen Sie den Schritte  3 und optional Schritt 4. Überprüfen Sie, ob die Sprache erwartungsgemäß geändert wird. Setzen Sie die Anzeige anschließend wieder auf die Standardsprache zurück.

8. Klicken Sie auf Websiteaktionen und dann auf Weitere Optionen. Klicken Sie auf Seite, wählen Sie Webpartseite aus, und klicken Sie dann auf Erstellen. Geben Sie einen Namen für die Seite ein, und klicken Sie dann auf Erstellen.

   Die neue Webpartseite wird angezeigt.

9. Klicken Sie in Mittlere Spalte auf Webpart hinzufügen. Klicken Sie unter Kategorien auf Benutzerdefiniert. Wählen Sie LocalizedWebPart aus, und klicken Sie dann auf Hinzufügen.

   Hinweis
   In diesem Bereich der Benutzeroberfläche werden der Webparttitel und das Beispiel stets in der Standardsprache der Website angezeigt. Die Umstellung auf eine alternative Sprache hat keine Auswirkung auf den Text, der von dem Webpart angezeigt wird.

   Das Webpart wird der Seite hinzugefügt.

10. Klicken Sie auf Bearbeitung beenden. Stellen Sie auf die alternative Sprache um, und überprüfen Sie, ob der Webparttitel und der Beschriftungstext erwartungsgemäß geändert werden. Setzen Sie anschließend wieder auf die Standardsprache zurück.

11. Bewegen Sie den Cursor ganz nach rechts auf der Seite. Wenn der Pfeil nach unten angezeigt wird, klicken Sie auf diesen. Überprüfen Sie, ob die Underline-Aktion im Menü in der Standardsprache angezeigt wird.

12. Stellen Sie auf die alternative Sprache um, und wiederholen Sie Schritt 11. Überprüfen Sie, ob die Underline-Aktion in der Standardsprache angezeigt wird.

13. Bewegen Sie den Cursor ganz nach rechts auf der Seite. Wenn der Pfeil nach unten angezeigt wird, klicken Sie auf diesen. Klicken Sie anschließend auf Webpart bearbeiten. Suchen Sie unten im Toolbereich nach der Kategorie Text. Überprüfen Sie, ob der Name in der Standardsprache angezeigt wird. Erweitern Sie die Kategorie. Überprüfen Sie ob das Kontrollkästchen Bold und die zugehörige QuickInfo in der Standardsprache angezeigt werden.

14. Stellen Sie auf die alternative Sprache um, und wiederholen Sie Schritt 13. Überprüfen Sie, ob der Text nun in der alternativen Sprache angezeigt wird.

Siehe auch

Aufgaben

Exemplarische Vorgehensweise: Lokalisieren von Spalten, Inhaltstypen und Listen

Referenz

CultureInfo

GetLocalizedString

WebBrowsableAttribute

PersonalizableAttribute

CategoryAttribute

WebDisplayNameAttribute

WebDescriptionAttribute

Konzepte

Grundlegendes zur MUI (Multilingual User Interface)

Weitere Ressourcen

Bereitstellen mehrerer Sprachen für die Benutzeroberfläche Ihrer Website

Gewusst wie: Hinzufügen und Entfernen zugeordneter Ordner