LocalizationExtenderProvider Classe

Définition

Espace de noms:

System.ComponentModel.Design

Assembly:

System.Design.dll

Attention

This class has been deprecated. Use CodeDomLocalizationProvider instead. http://go.microsoft.com/fwlink/?linkid=14202

Fournit une prise en charge des fonctionnalités de localisation au moment du design pour un concepteur racine.

C#

[System.Obsolete("This class has been deprecated. Use CodeDomLocalizationProvider instead.  http://go.microsoft.com/fwlink/?linkid=14202")]
public class LocalizationExtenderProvider : IDisposable, System.ComponentModel.IExtenderProvider

Héritage

Object

LocalizationExtenderProvider

Attributs

ObsoleteAttribute

Implémente

IExtenderProvider IDisposable

Exemples

L’exemple de code suivant ajoute un LocalizationExtenderProvider à un composant.

C#

// Adds a LocalizationExtenderProvider that provides localization support properties to the specified component.
extender = new LocalizationExtenderProvider(this.component.Site, this.component);

L’exemple de code suivant inclut un exemple de composant et de concepteur. Le concepteur utilise un pour ajouter des LocalizationExtenderProvider propriétés de prise en charge de la localisation pour le composant.

C#

using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.Design;

// This example demonstrates adding localization support to a component hierarchy from a 
// custom IRootDesigner using the LocalizationExtenderProvider class.
namespace LocalizationExtenderProviderExample
{	
    // RootViewDesignerComponent is a component associated with the SampleRootDesigner
    // IRootDesigner that provides LocalizationExtenderProvider localization support.
    // This derived class is included at the top of this example to enable 
    // easy launching of designer view without having to put the class in its own file.
    public class RootViewDesignerComponent : RootDesignedComponent
    {  
        public RootViewDesignerComponent()
        {            
        }
    }

    // The following attribute associates the RootDesignedComponent with the RootDesignedComponent component.
    [Designer(typeof(SampleRootDesigner), typeof(IRootDesigner))]
    public class RootDesignedComponent : Component
    {
        public RootDesignedComponent()
        {
        }    
    }

    // Example IRootDesigner implementation demonstrates LocalizationExtenderProvider support.
    internal class SampleRootDesigner : IRootDesigner
    {
        // RootDesignerView Control provides a full region designer view for this root designer's associated component.
        private RootDesignerView m_view;			
        // Stores reference to the LocalizationExtenderProvider this designer adds, in order to remove it on Dispose.
        private LocalizationExtenderProvider extender;        
        // Internally stores the IDesigner's component reference
        private IComponent component;                
        
        // Adds a LocalizationExtenderProvider for the component this designer is initialized to support.
        public void Initialize(System.ComponentModel.IComponent component)
        {
           this.component = component;
            
            // If no extender from this designer is active...
            if( extender == null )
            {
                // Adds a LocalizationExtenderProvider that provides localization support properties to the specified component.
                extender = new LocalizationExtenderProvider(this.component.Site, this.component);
            }
        }

        // Provides a RootDesignerView object that supports ViewTechnology.WindowsForms.
        object IRootDesigner.GetView(ViewTechnology technology) 
        {
            if (technology != ViewTechnology.WindowsForms)
            {
                throw new ArgumentException("Not a supported view technology", "technology");
            }
            if (m_view == null )
            {
                // Create the view control. In this example, a Control of type RootDesignerView is used.
                // A WindowsForms ViewTechnology view provider requires a class that inherits from Control.
                m_view = new RootDesignerView(this, this.Component);
            }
            return m_view;
        }

        // This designer supports the WindowsForms view technology.
        ViewTechnology[] IRootDesigner.SupportedTechnologies 
        {
            get
            {
                return new ViewTechnology[] {ViewTechnology.WindowsForms};
            }
        }
        
        // If a LocalizationExtenderProvider has been added, removes the extender provider.
        protected void Dispose(bool disposing)
        {            
            // If an extender has been added, remove it
            if( extender != null  )  
            {
                // Disposes of the extender provider.  The extender 
                // provider removes itself from the extender provider
                // service when it is disposed.
                extender.Dispose();
                extender = null;                
            }            
        }

        // Empty IDesigner interface property and method implementations
        public System.ComponentModel.Design.DesignerVerbCollection Verbs
        {
            get
            {
                return null;
            }
        }

        public System.ComponentModel.IComponent Component
        {
            get
            {
                return this.component;
            }
        }

        public void DoDefaultAction()
        {            
        }

        public void Dispose()
        {        
        }
        
        // RootDesignerView is a simple control that will be displayed in the designer window.
        private class RootDesignerView : Control
        {
            private SampleRootDesigner m_designer;   
            private IComponent comp;
            
            public RootDesignerView(SampleRootDesigner designer, IComponent component)
            {
                m_designer = designer;                        
                this.comp = component;      
                BackColor = Color.Blue;
                Font = new Font(FontFamily.GenericMonospace, 12);
            }

            // Displays the name of the component and the name of the assembly of the component 
            // that this root designer is providing support for.
            protected override void OnPaint(PaintEventArgs pe)
            {
                base.OnPaint(pe);

                if( m_designer != null && comp != null )
                {
                    // Draws the name of the component in large letters.
                    pe.Graphics.DrawString("Root Designer View", Font, Brushes.Yellow, 8, 4);                    
                    pe.Graphics.DrawString("Design Name  : "+comp.Site.Name, new Font("Arial", 10), Brushes.Yellow, 8, 28);                    
                    pe.Graphics.DrawString("Assembly    : "+comp.GetType().AssemblyQualifiedName, new Font("Arial", 10), Brushes.Yellow, new Rectangle(new Point(8, 44), new Size(ClientRectangle.Width-8, ClientRectangle.Height-44)));                   

                    // Uses the site of the component to acquire an ISelectionService and sets the property grid focus to the component.
                    ISelectionService selectionService = (ISelectionService)comp.Site.GetService(typeof(ISelectionService));
                    if( selectionService != null )                
                        selectionService.SetSelectedComponents( new IComponent[] { m_designer.component } );             
                }
            }
        }
    }
}

Remarques

LocalizationExtenderProvider peut étendre un IRootDesigner avec un ensemble de propriétés et de méthodes qui prennent en charge l’architecture de localisation .NET Framework. Pour plus d’informations sur l’utilisation des ressources, consultez Localisation.

L’architecture de prise en charge de la localisation permet aux concepteurs d’initialiser les propriétés des composants à l’aide de fichiers de ressources qui peuvent être échangés au moment de l’exécution pour prendre en charge divers langages, styles spécifiques à la culture et fonctionnalités configurables dynamiquement. Vous pouvez utiliser les méthodes de cette classe pour permettre aux concepteurs et aux sérialiseurs générateurs de code de charger à partir de ressources et de générer du code d’initialisation qui utilise des fonctionnalités de localisation.

Les sérialiseurs par défaut fournis avec Visual Studio sont déjà capables de localiser les composants et les contrôles, mais ils ne le font que s’ils prennent en charge l’architecture de localisation .NET Framework. Pour détecter la présence de la prise en charge de la localisation, le système de sérialisation doit localiser une propriété publique Boolean nommée « Localizable » sur le composant de concepteur racine. Si un sérialiseur trouve cette propriété, il recherche une propriété de type CultureInfo « Language » pour déterminer la configuration de ressource actuelle. Les sérialiseurs par défaut utilisent ces propriétés pour déterminer s’il doit localiser les ressources localisables du composant et, le cas échéant, dans quel CultureInfo format les informations de ressource doivent être enregistrées.

Constructeurs

LocalizationExtenderProvider(ISite, IComponent)

Obsolète. Initialise une nouvelle instance de la classe LocalizationExtenderProvider à l'aide du fournisseur de services et du composant de base spécifiés.

Méthodes

CanExtend(Object)	Obsolète. Indique si cet objet peut fournir ses propriétés extendeur à l'objet spécifié.
Dispose()	Obsolète. Libère les ressources (autres que la mémoire) utilisées par LocalizationExtenderProvider.
Dispose(Boolean)	Obsolète. Libère les ressources non managées utilisées par LocalizationExtenderProvider et libère éventuellement les ressources managées.
Equals(Object)	Obsolète. Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Obsolète. Fait office de fonction de hachage par défaut. (Hérité de Object)
GetLanguage(Object)	Obsolète. Obtient la culture de ressource en cours pour l'objet spécifié.
GetLoadLanguage(Object)	Obsolète. Obtient la culture de ressource par défaut à utiliser lors de l'initialisation des valeurs d'un objet localisé au moment du design.
GetLocalizable(Object)	Obsolète. Obtient une valeur indiquant si l'objet spécifié prend en charge la localisation des ressources.
GetType()	Obsolète. Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Obsolète. Crée une copie superficielle du Object actuel. (Hérité de Object)
ResetLanguage(Object)	Obsolète. Rétablit la culture de ressource pour l'objet spécifié.
SetLanguage(Object, CultureInfo)	Obsolète. Affecte à la culture de ressource en cours de l'objet spécifié la culture de ressource déterminée.
SetLocalizable(Object, Boolean)	Obsolète. Définit une valeur indiquant si l'objet spécifié prend en charge les ressources localisées.
ShouldSerializeLanguage(Object)	Obsolète. Obtient une valeur indiquant si les valeurs localisables de l'objet spécifié doivent être persistantes dans une ressource.
ToString()	Obsolète. Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

S’applique à