Procédure pas à pas : localisation d’un composant WebPart

Article
09/24/2014

Dernière modification : mardi 7 décembre 2010

S’applique à : SharePoint Foundation 2010

Dans cet article
Création d’un projet SharePoint vide
Création du composant WebPart
Ajout de ressources linguistiques
Localisation de la Fonctionnalité et du fichier de description du contrôle composant WebPart
Écriture du code pour récupérer les chaînes localisées
Localisation des propriétés des composants WebPart
Localisation d’attributs
Test du composant WebPart

Cette procédure pas à pas vous explique comment localiser un composant WebPart pour le déployer sur Microsoft SharePoint Foundation 2010. Les techniques employées dans la procédure pas à pas sont propres à SharePoint Foundation 2010. Elles ne conviennent pas pour un composant WebPart déployé sur Microsoft ASP.NET.

Dans le cadre de la procédure pas à pas, vous allez créer un composant WebPart simple capable d’afficher le texte « Hello, world » dans plusieurs langues. De plus, la procédure pas à pas vous explique comment préparer l’intégralité du texte d’affichage associé au composant WebPart en vue de sa localisation, notamment le texte d’affichage pour :

La Fonctionnalité qui met en service le composant WebPar
L’entrée du composant WebPart dans la galerie de composants WebPart
Le titre dans le chrome du composant WebPart
Une action personnalisée sur le menu Composant WebPart
Une propriété personnalisée dans l’éditeur du composant WebPart
Un contrôle enfant que le composant WebPart héberge

Conditions requises

Les procédures reprises dans la procédure pas à pas sont rédigées à l’attention des développeurs qui utilisent Microsoft Visual Studio 2010. Pour connaître les éléments requis préalables, voir Configuration requise pour développer des solutions SharePoint.

Pour exécuter cette procédure pas à pas, vous devez installer les composants suivants :

Au moins un module linguistique SharePoint Foundation 2010 installé sur votre serveur de développement.

Pour plus d’informations sur le téléchargement et l’installation des modules linguistiques, voir Modules linguistiques pour SharePoint Foundation 2010.
Au moins un site Web SharePoint Foundation disposant de la prise en charge des langues de substitution activée.

Pour plus d’informations sur l’activation de la prise en charge des langues de substitution, voir Proposer plusieurs langues pour l’interface utilisateur de votre site (éventuellement en anglais).

Pour obtenir une présentation des concepts clés relatifs à la localisation de solutions dans SharePoint Foundation 2010, voir Interface utilisateur multilingue.

Création d’un projet SharePoint vide

Créez tout d’abord un projet SharePoint vierge dans Visual Studio 2010. Intitulez le projet Wingtip.WebParts. Configurez-le en vue de son déploiement en tant que solution de batterie.

Notes

Le composant WebPart que vous créez dans le cadre de cette procédure pas à pas peut être déployé sous forme de solution en bac à sable. L’intégralité du code pour le composant WebPart peut s’exécuter sous un environnement de confiance partielle. Cependant, outre le composant WebPart, la procédure pas à pas déploie également des fichiers de ressources linguistiques dans un dossier racine au sein de l’installation de SharePoint ; cette partie du projet requiert un environnement de confiance totale. Dans un environnement de production, il peut s’avérer judicieux d’exploiter deux solutions distinctes : une solution en bac à sable pour déployer le composant WebPart et une solution de batterie pour déployer les fichiers de ressources. Par souci de simplicité, la procédure pas à pas n’utilise qu’une seule solution de batterie.

Pour créer un projet SharePoint vide

Démarrez Visual Studio 2010 en tant qu’administrateur.
Ouvrez la boîte de dialogue Nouveau projet en pointant sur Nouveau dans le menu Fichier, puis en cliquant sur Nouveau projet.
Développez le nœud SharePoint dans la section Visual C# ou Visual Basic, puis cliquez sur 2010.
Dans le volet Modèles, cliquez sur Projet SharePoint vide, changez le nom du projet en Wingtip.WebParts, puis cliquez sur OK.

L’Assistant Personnalisation de SharePoint apparaît.
Sur la page Spécifier le site et le niveau de sécurité pour le débogage, entrez l’URL du site SharePoint auquel vous voulez ajouter le nouveau composant WebPart ou utilisez l’emplacement par défaut (http://< nom du système>/).
Dans la section Quel est le niveau de confiance de cette solution SharePoint ?, sélectionnez Déployer en tant que solution de batterie.
Cliquez sur Terminer.

Le projet apparaît dans l’Explorateur de solutions.

Création du composant WebPart

La tâche suivante consiste à ajouter un composant WebPart au projet. Pour ce faire, créez une classe qui dérive de la classe WebPart issue de l’espace de noms System.Web.UI.WebControls.WebParts. Le composant WebPart de l’exemple remplace la méthode CreateChildControls pour ajouter un contrôle enfant, à savoir une instance de la classe Label. Plus loin dans cette procédure pas à pas, nous verrons comment localiser le texte que le contrôle en question affiche. Pour vous permettre de localiser tous les différents types d’interface utilisateur dont un composant WebPart peut disposer, l’exemple de code crée une propriété personnalisée décorée des attributs WebBrowsable et Personalizable. Ces attributs entraînent l’affichage de la propriété dans le volet des outils lorsqu’un utilisateur modifie le composant WebPart. Enfin, l’exemple ajoute un élément au menu des options du composant WebPart en créant un WebPartVerb personnalisé.

Pour ajouter un composant WebPart au projet

Dans l’Explorateur de solutions, sélectionnez le nœud Wingtip.WebParts. Dans le menu Projet, cliquez sur Ajouter un nouvel élément.
Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez Composant WebPart. Dans le champ Nom, tapez LocalizedWebPart. Cliquez ensuite sur Ajouter.

La classe LocalizedWebPart s’ouvre dans l’éditeur de code.

Dans l’éditeur de code, appuyez sur Ctrl+A pour tout sélectionner. Copiez et collez ensuite le code suivant :

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

Appuyez sur Ctrl+Maj+S pour tout enregistrer.

Maintenant que nous disposons d’un composant WebPart fonctionnel, il nous reste à le tester. Appuyez sur la touche F5 pour construire et déployer la solution. Lorsque votre site Web s’ouvre, créez une page de composant WebPart et ajoutez-y votre composant WebPart. Activez le mode d’édition pour la page, puis vérifiez le menu des options situé dans le coin supérieur droit du chrome du composant WebPart. Cliquez sur Souligné plusieurs fois pour vous assurer que le verbe personnalisé fonctionne. Cliquez ensuite sur Modifier le composant WebPart. Lorsque le volet des outils apparaît, recherchez la propriété personnalisée située en bas du volet. Sélectionnez Gras, puis cliquez sur Appliquer pour vous assurer que la propriété se définit correctement.

Ajout de ressources linguistiques

La première étape à suivre dans la localisation du composant WebPart est d’ajouter les fichiers de ressources linguistiques au projet. Pour cette procédure pas à pas, vous n’avez besoin que de deux fichiers de ressources : un fichier pour la langue par défaut du site Web et un autre fichier pour l’une des langues de substitution prises en charge par le site Web. Vous pouvez indifféremment faire appel à l’une de ces langues. Les exemples s’appuient sur l’anglais et l’espagnol.

Conseil
Pour savoir quelles langues sont prises en charge par votre site Web de développement, ouvrez sa page d’accueil dans votre navigateur. Cliquez sur Actions du site, puis sur Paramètres du site. Sous Administration du site, cliquez sur Paramètres de langue. La langue par défaut est mentionnée en haut de la page. Les autres langues sont répertoriées sous la langue par défaut.

Pour savoir quelles langues sont prises en charge par votre site Web de développement, ouvrez sa page d’accueil dans votre navigateur. Cliquez sur Actions du site, puis sur Paramètres du site. Sous Administration du site, cliquez sur Paramètres de langue. La langue par défaut est mentionnée en haut de la page. Les autres langues sont répertoriées sous la langue par défaut.

Vous devez déployer les fichiers de ressources que vous créez vers un emplacement dans le système de fichiers de votre serveur Web, accessible par tous les éléments du composant WebPart qui génèrent du texte d’affichage, notamment :

La Fonctionnalité qui active le composant WebPart.
Les Fichiers de description des contrôles WebPart qui fournissent des informations à la galerie de composants WebPart.
Le code qui s’exécute dans l’assembly compilé.

Vous disposez de plusieurs possibilités pour la mise en service de ressources linguistiques sur les serveurs Web cibles. L’approche la plus simple, celle qui offre le plus de souplesse lors de l’ajout ultérieur de prise en charge d’autres langues, consiste à mettre en service des fichiers de ressources linguistiques dans le dossier Resources situé juste en dessous de la racine d’installation de SharePoint Foundation. Le jeton que Visual Studio utilise pour ce dossier est {SharePointRoot}\Resources. Le chemin d’accès complet est %ProgramFiles%\Common Files\Microsoft Shared\web server extensions\14\Resources. Ce dossier constitue le point où SharePoint Foundation installe les ressources linguistiques consommées par les composants WebPart intégrés.

Pour ajouter des ressources au dossier {SharePointRoot}\Resources

Dans l’Explorateur de solutions, sélectionnez le nœud de projet Wingtip.Webparts. Dans le menu Projet, cliquez sur Ajouter un dossier mappé SharePoint.
Dans la boîte de dialogue Ajouter un dossier mappé SharePoint, sélectionnez Ressources, puis cliquez sur OK.

Un dossier Resources est ajouté au projet. Vérifiez les propriétés de ce dossier. La propriété DeploymentLocation a la valeur {SharePointRoot}\Resources.
Dans l’Explorateur de solutions, sélectionnez Ressources. Dans le menu Projet, cliquez sur Ajouter un nouvel élément.

Dans la boîte de dialogue Ajouter un nouvel élément, développez le nœud relatif à Visual C# s’il correspond à votre langage de programmation ou Éléments communs si vous travaillez dans Visual Basic. Sélectionnez Général. Dans le volet des modèles, sélectionnez Fichier de ressources. Attribuez le nom de Wingtip.WebParts.resx au fichier, puis cliquez sur Ajouter.

Le fichier de ressources est ajouté au projet et s’ouvre dans l’Éditeur de ressources managées.

Conseil
Chaque fois que vous mettez en service des fichiers dans le dossier global Resources, il est judicieux de choisir des noms de fichiers uniques pour éviter les conflits de noms avec les ressources mises en service par d’autres applications. Une convention consiste à préfixer le nom du fichier de celui de votre entreprise. Par exemple, si votre entreprise s’appelle Jouets Wingtip, les noms des fichiers de ressources que vous déployez peuvent tous commencer par « Wingtip ».

Chaque fois que vous mettez en service des fichiers dans le dossier global Resources, il est judicieux de choisir des noms de fichiers uniques pour éviter les conflits de noms avec les ressources mises en service par d’autres applications. Une convention consiste à préfixer le nom du fichier de celui de votre entreprise. Par exemple, si votre entreprise s’appelle Jouets Wingtip, les noms des fichiers de ressources que vous déployez peuvent tous commencer par « Wingtip ».

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le fichier de ressources que vous venez de créer, puis cliquez sur Ouvrir avec. Dans la boîte de dialogue Ouvrir avec, sélectionnez Éditeur XML (Texte), puis cliquez sur OK.

Le fichier de ressources s’ouvre dans l’éditeur.

Faites défiler l’affichage jusqu’au bas du fichier. Insérez une ligne vierge juste au-dessus de la balise </root> tag. Copiez le code suivant et collez-le dans le fichier au niveau du point d’insertion.

  <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>

Appuyez sur Ctrl+S pour enregistrer le fichier. Ensuite, dans le menu Fichier, cliquez sur Fermer.
Dans l’Explorateur de solutions, sélectionnez le fichier Wingtip.WebParts.resx. Dans le menu Edition, cliquez sur Copier. Cliquez ensuite sur Coller.

Un fichier intitulé Copie de Wingtip.WebParts.resx est alors ajouté au dossier Resources.
Cliquez avec le bouton droit sur le fichier intitulé Copie de Wingtip.WebParts.resx, puis cliquez sur Renommer. Attribuez au fichier le nouveau nom de Wingtip.WebParts.langue-PAYS/RÉGION.resx où langue correspond à un code à deux lettres définissant la langue par défaut de votre site Web et PAYS/RÉGION représente un code à deux lettres indiquant la sous-culture.

Par exemple, si la langue par défaut représente le français (Canada), le nom du fichier de ressources est dans ce cas Wingtip.WebParts**.fr-CA**.resx.

Pour plus d’informations sur les identificateurs de langue, voir la classe System.Globalization.CultureInfo.

Important

Tel qu’il est démontré plus loin dans cette procédure pas à pas, vous devez référencer un fichier de ressources en réutilisant le nom de son fichier de base, tel que « Wingtip.WebParts ». Lorsque SharePoint Foundation récupère une valeur de ressource, il recherche un fichier de ressources possédant ce même nom de fichier de base suivi de l’identificateur d’une langue qui correspond à la valeur de la propriété CurrentUICulture du thread en cours d’exécution. SharePoint Foundation s’attend à retrouver une correspondance exacte. Par exemple, si l’identificateur de langue pour le thread actif est « pt-BR », SharePoint Foundation recherche un fichier de ressources portant le nom de « NomFichierDeBase.pt-BR.resx ». Il ignore les fichiers qui possèdent le même code de langue mais pas la même sous-culture, par exemple « NomFichierDeBase.pt.resx » et « NomFichierDeBase.pt-PT.resx ».

Si SharePoint Foundation ne trouve aucun fichier de ressources répondant à l’identificateur de langue sur le thread en cours d’exécution, il recherche alors un fichier de ressources de secours. Le premier choix pour l’usage de secours représente un fichier de ressources pour la culture invariante (en d’autres termes, un fichier de ressources ne possédant aucun identificateur de langue à la fin du nom de son fichier). Par exemple, dans notre projet, le fichier de ressources pour la culture invariante correspond à Wingtip.WebParts.resx. Si SharePoint Foundation n’est pas en mesure de trouver de fichier de ressources pour la culture invariante, il tente d’utiliser celui de secours pour la langue par défaut. S’il ne trouve aucun fichier de ressources pour cette langue par défaut, il affiche le nom de la ressource.
Répétez les étapes 8 et 9, cette fois-ci en ajoutant l’identificateur de langue pour une langue de substitution activée sur votre site Web.
Ouvrez les deux fichiers de ressources linguistiques spécifiques à la culture que vous venez de créer, puis remplacez le mot « invariant » par l’identificateur de langue pour le fichier. Par exemple, dans Wingtip.WebParts.en-US.resx, « Bold (invariant) » devient « Bold (en-US) ».

Dans le cadre de cette procédure pas à pas, Il n’est pas nécessaire de traduire la valeur des chaînes. En fait, ajouter l’identificateur d’une langue à une chaîne sans la traduire doit être suffisant. Lorsque vous testez le composant WebPart, l’identificateur de langue indique la langue dans laquelle l’interface s’affiche.
Appuyez sur Ctrl+Maj+S pour tout enregistrer.

Localisation de la Fonctionnalité et du fichier de description du contrôle composant WebPart

La tâche principale suivante consiste à localiser les chaînes d’affichage se trouvant dans deux fichiers XML clés : le fichier d’élément Feature et le Fichier de description des contrôles WebPart. Ces deux fichiers contiennent un titre et des chaînes de description qu’il vous est possible de remplacer par des expressions ASP.NET répondant à la convention suivante :

$Resources:BaseFileName,ResourceName

Le signe dollar ($) indique qu’une expression suit. Le préfixe « Resources » indique le type d’expression. Le suffixe situé après les deux-points (:) représente la valeur de l’expression à résoudre. La première partie de la valeur constitue le nom de fichier de base d’un fichier de ressources. La partie qui suit la virgule correspond au nom de la chaîne localisée à récupérer du fichier. Aucun espace n’est autorisé dans l’expression.

Notes

Les expressions des ressources se terminent par un point-virgule (;). Ce délimiteur est accepté mais n’est pas requis par SharePoint Foundation 2010.

Pour localiser la Fonctionnalité

Dans l’Explorateur de solutions, développez le dossier Features, puis double-cliquez sur Feature1.

Feature1.feature s’ouvre dans le concepteur de fonctionnalités.
Dans ce concepteur, supprimez le texte du champ Titre, puis remplacez-le par l’expression de ressource suivante :
```
$Resources:Wingtip.WebParts,FeatureTitle
```
Collez l’expression suivante dans le champ Description :
```
$Resources:Wingtip.WebParts,FeatureDesc
```
Appuyez sur Ctrl+Maj+S pour tout enregistrer.

Pour localiser la description du contrôle WebPart

Dans l’Explorateur de solutions, développez le dossier LocalizedWebPart, puis double-cliquez sur LocalizedWebPart.webpart.

LocalizedWebPart.webpart s’ouvre dans l’éditeur XML.
Supprimez la valeur de la propriété Title (à savoir « LocalizedWebPart »), puis remplacez-la par l’expression de ressource suivante :
```
$Resources:Wingtip.WebParts,WebPartTitle
```
Supprimez la valeur de la propriété Description (« My WebPart »), puis remplacez-la par l’expression de ressource suivante :
```
$Resources:Wingtip.WebParts,WebPartDesc
```
Appuyez sur Ctrl+Maj+S pour tout enregistrer.

Écriture du code pour récupérer les chaînes localisées

Pour localiser du code dans une application ASP.NET normale, vous devez incorporer les ressources linguistiques dans un assembly satellite déployé à l’aide de l’assembly principal dans le GAC (Global Assembly Cache). Lorsque votre code doit récupérer la valeur d’une ressource, vous devez appeler la méthode HttpContext.GetGlobalResourceObject.

Bien que vous puissiez sans aucun doute appeler cette méthode à partir du code s’exécutant sur SharePoint Foundation, une autre méthode, qui ne demande pas de déployer vos ressources linguistiques dans des assemblys satellites, est proposée aux développeurs SharePoint Foundation. La classe SPUtility comprend une méthode statique, GetLocalizedString, capable de récupérer la valeur d’une chaîne à partir d’un fichier de ressources placé dans le dossier {SharePointRoot}\Resources situé sur le serveur Web. Nous allons utiliser la méthode GetLocalizedString au cours de cette procédure pas à pas.

La méthode GetLocalizedString attend une expression de ressource en tant que premier argument et le nom du fichier de base d’un fichier de ressources en second argument. Pour simplifier les appels de méthode depuis le code de votre composant WebPart, vous devez encapsuler GetLocalizedString dans une méthode personnalisée.

Pour créer une méthode qui récupère les chaînes de ressources

Dans l’Explorateur de solutions, sélectionnez le nœud de projet Wingtip.Webparts. Dans le menu Projet, cliquez sur Ajouter une classe.

La boîte de dialogue Ajouter un nouvel élément s’affiche.
Dans le champ Nom, tapez Utility.cs ou Utility.vb selon votre langage de programmation. Cliquez ensuite sur Ajouter.

Appuyez sur Ctrl+A pour tout sélectionner. Copiez et collez ensuite le code suivant en remplaçant le contenu du fichier.

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

Appuyez sur Ctrl+Maj+S pour tout enregistrer.

Localisation des propriétés des composants WebPart

La tâche suivante consiste à localiser le code pour les propriétés du composant WebPart qui renvoient du texte à afficher. Dans chaque cas, vous pouvez remplacer une chaîne codée en dur par un appel à la méthode utilitaire GetLocalizedString en passant le nom d’une ressource et l’ID de la langue (LCID) se rapportant au thread actif. Vous pouvez obtenir le LCID de la langue active en accédant à la propriété statique CultureInfo.CurrentUICulture.

Pour localiser les propriétés du contrôle WebPart

Dans l’Explorateur de solutions, double-cliquez sur LocalizedWebPart.cs ou LocalizedWebPart.vb pour ouvrir le fichier source.

Tout en haut du fichier, juste après la déclaration de la classe LocalizedWebPart, se trouvent celles de plusieurs constantes de type chaîne. Supprimez ces déclarations et remplacez-les par le code suivant :

// 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"

Accédez à la propriété Description. Remplacez le code de l’accesseur get par le code suivant :

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

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

Accédez à la propriété Text. Remplacez le code de l’accesseur get par le code suivant :

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

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

Accédez à la propriété Title. Remplacez le code de l’accesseur get par le code suivant :

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

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

Accédez à la propriété Verbs. Remplacez les deux lignes de code qui définissent les propriétés verb.Text et verb.Description par les lignes suivantes :

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)

Appuyez sur Ctrl+Maj+S pour tout enregistrer.

Localisation d’attributs

Le code pour le composant WebPart définit une propriété Bold personnalisée décorée à l’aide de plusieurs attributs, tel qu’illustré dans l’extrait de code suivant :

[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

Les attributs WebBrowsable et Personalizable font apparaître la propriété dans l’interface lorsqu’un utilisateur modifie le composant WebPart. Trois attributs complémentaires fournissent du texte d’affichage pour l’interface de modification :

Category

Nom d’affichage d’une catégorie personnalisée pour la propriété.
WebDisplayName

Fournit le nom complet de la propriété.
WebDescription

Texte de l’info-bulle indiquant la propriété.

Pour localiser le texte de ces attributs, vous devez écrire les classes d’attributs personnalisées qui dérivent des classes CategoryAttribute, WebDisplayNameAttribute et WebDescriptionAttribute.

Pour localiser les attributs Category, WebDisplayName et WebDescription

Dans l’Explorateur de solutions, double-cliquez sur LocalizedWebPart.cs ou LocalizedWebPart.vb pour ouvrir le fichier source.

En bas de la classe LocalizedWebPart, mais toujours à l’intérieur de la classe même, insérez le code pour les sous-classes suivantes :

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

Accédez à la propriété Bold. Modifiez ensuite le nom des attributs respectifs Category, WebDisplayName et WebDescription en LocalizedCategory, LocalizedWebDisplayName et LocalizedWebDescription.

Ne modifiez pas les paramètres d’attributs. Le code révisé correspond au suivant :
```
[LocalizedCategory(CATEGORY_TEXT)]
[LocalizedWebDisplayName(TOOLPANE_BOLD)]
[LocalizedWebDescription(TOOLPANE_BOLD_DESC)]
```
```
<LocalizedCategory(CATEGORY_TEXT)> _
<LocalizedWebDisplayName(TOOLPANE_BOLD)> _
<LocalizedWebDescription(TOOLPANE_BOLD_DESC)> _
```
Appuyez sur Ctrl+Maj+S pour tout enregistrer.

Test du composant WebPart

Testez le composant WebPart pour vous assurer qu’il fonctionne correctement.

Pour tester le composant WebPart

Dans Visual Studio, appuyez sur la touche F5 pour lancer le débogage.

Le volet Sortie indique le processus de génération et de déploiement. Le site Web apparaît dans le navigateur par défaut à la fin du processus.
Cliquez sur Actions du site, puis sur Paramètres du site. Sous Administration de la collection de sites, cliquez sur Fonctionnalités de la collection de sites. Assurez-vous que la Fonctionnalité du composant WebPart localisé affiche bien le titre et la description dans la langue par défaut.
Cliquez sur votre nom dans le coin supérieur droit de la page. Pointez sur Sélectionnez la langue d’affichage, puis cliquez sur la langue de substitution ayant servi pour localiser le composant WebPart. Assurez-vous que le titre et la description de la Fonctionnalité du composant WebPart localisé s’affiche bien dans la langue de substitution.
(En option) Répétez l’étape 3 mais sélectionnez une langue pour laquelle vous n’avez pas déployé de fichier de ressources linguistiques. Assurez-vous que le titre et la description de la Fonctionnalité du composant WebPart localisé s’affiche bien dans la langue invariante.
Répétez l’étape 3 en faisant revenir l’affichage sur la langue par défaut du site Web.
Cliquez sur Actions du site, puis sur Paramètres du site. Sous Galeries, cliquez sur Composants WebPart. Cliquez ensuite sur LocalizedWebPart.webpart. Vérifiez que le titre, la description et l’exemple s’affichent bien dans la langue par défaut.
Répétez les étapes 3 et éventuellement 4. Assurez-vous que les changements de langue se réalisent comme prévu. Réactivez ensuite l’affichage de la langue par défaut.
Cliquez sur Actions du site, puis sur Autres options. Cliquez sur Page, sélectionnez Page de composants WebPart, puis cliquez sur Créer. Attribuez un nom à la page. Cliquez sur Créer.

La page du nouveau composant WebPart apparaît.
Dans Colonne centrale, cliquez sur Ajouter un composant WebPart. Sous Catégories, cliquez sur Personnalisé. Sélectionnez LocalizedWebPart, puis cliquez sur Ajouter.

Notes

Dans cette partie de l’interface utilisateur, le titre et l’exemple du composant WebPart apparaissent toujours dans la langue par défaut du site Web. Passer à une autre langue n’influe en rien sur le texte affiché par le composant WebPart.

Le composant WebPart est ajouté à la page.
Cliquez sur Arrêter la modification. Passez à l’autre langue pour vous assurer que le titre et le texte de l’étiquette du composant WebPart changent comme prévu. Réactivez ensuite la langue par défaut.
Déplacez le curseur sur le bord droit de la page. Lorsque la flèche vers le bas apparaît, effectuez un clic. Assurez-vous que l’action Souligné apparaît dans le menu dans la langue par défaut.
Activez la langue de substitution. Répétez ensuite l’étape 11. Assurez-vous que l’action Souligné apparaît dans le menu dans la langue de substitution. Réactivez l’affichage à la langue par défaut.
Déplacez le curseur sur le bord droit de la page. Lorsque la flèche vers le bas apparaît, effectuez un clic. Cliquez ensuite sur Modifier le composant WebPart. En bas du volet des outils, vérifiez la catégorie Texte. Assurez-vous que son nom apparaît dans la langue par défaut. Développez la catégorie. Assurez-vous que la case à cocher Gras et son info-bulle s’affichent dans la langue par défaut..
Activez la langue de substitution. Répétez ensuite l’étape 13. Assurez-vous que les changements de texte d’affichage se font dans la langue de substitution.

Voir aussi

Partager via