ViewTechnology Énumération

Définition

Espace de noms:

System.ComponentModel.Design

Assembly:

System.ComponentModel.TypeConverter.dll

Définit des identificateurs pour un ensemble de technologies prises en charge par les hôtes du concepteur.

C#

public enum ViewTechnology

Héritage

Object

ValueType

Enum

ViewTechnology

Champs

Nom	Valeur	Description
Default	2	Spécifie la prise en charge de la technologie d'affichage par défaut. Le concepteur racine peut retourner tout type d’objet, à condition que l’objet soit compatible avec un adaptateur de la technologie de l’hôte. Les environnements d’hébergement tels que Visual Studio fournissent un moyen d’intégrer de nouveaux adaptateurs de technologie d’affichage. L’objet de vue par défaut pour le concepteur Windows Forms est une instance Control.
Passthrough	0	Représente un mode dans lequel l'objet de vue est passé directement à l'environnement de développement. L’objet de vue doit implémenter les interfaces requises par l’environnement de développement. L’environnement de développement Visual Studio prend en charge les objets de vue qui sont un contrôle ActiveX, un document actif, ou un objet qui implémente l’interface IVsWindowPane disponible dans le programme Visual Studio VSI (Visual Studio Integration). L’environnement de développement Visual Studio prend en charge cette technologie d’affichage. Celle-ci n’est pas nécessairement disponible dans tous les environnements de développement.
WindowsForms	1	Représente un mode dans lequel un objet contrôle Windows Forms assure l'affichage du concepteur racine. Le concepteur hôte remplit la fenêtre de document de l’environnement de développement avec le contrôle Windows Forms.

Exemples

L’exemple suivant montre comment utiliser ViewTechnology.Default dans un concepteur. Cet exemple fait partie d’un exemple plus grand fourni pour l’interface GetView .

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;

namespace SampleRootDesigner
{	
    // This sample demonstrates how to provide the root designer view, or
    // design mode background view, by overriding IRootDesigner.GetView().

    // This sample component inherits from RootDesignedComponent which 
    // uses the SampleRootDesigner.
    public class RootViewSampleComponent : RootDesignedComponent
    {
        public RootViewSampleComponent()
        {
        }
    }

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

    public class SampleRootDesigner : ComponentDesigner, IRootDesigner
    {
        // Member field of custom type RootDesignerView, a control that 
        // will be shown in the Forms designer view. This member is 
        // cached to reduce processing needed to recreate the 
        // view control on each call to GetView().
        private RootDesignerView m_view;			

        // This method returns an instance of the view for this root
        // designer. The "view" is the user interface that is presented
        // in a document window for the user to manipulate. 
        object IRootDesigner.GetView(ViewTechnology technology) 
        {
            if (technology != ViewTechnology.Default)
            {
                throw new ArgumentException("Not a supported view technology", "technology");
            }
            if (m_view == null)
            {
                   // Some type of displayable Form or control is required 
                   // for a root designer that overrides GetView(). In this 
                   // example, a Control of type RootDesignerView is used.
                   // Any class that inherits from Control will work.
                m_view = new RootDesignerView(this);
            }
            return m_view;
        }

        // IRootDesigner.SupportedTechnologies is a required override for an
        // IRootDesigner. Default is the view technology used by this designer.  
        ViewTechnology[] IRootDesigner.SupportedTechnologies 
        {
            get
            {
                return new ViewTechnology[] {ViewTechnology.Default};
            }
        }

        // RootDesignerView is a simple control that will be displayed 
        // in the designer window.
        private class RootDesignerView : Control 
        {
            private SampleRootDesigner m_designer;

            public RootDesignerView(SampleRootDesigner designer)
            {
                m_designer = designer;
                BackColor = Color.Blue;
                Font = new Font(Font.FontFamily.Name, 24.0f);
            }

            protected override void OnPaint(PaintEventArgs pe)
            {
                base.OnPaint(pe);

                // Draws the name of the component in large letters.
                pe.Graphics.DrawString(m_designer.Component.Site.Name, Font, Brushes.Yellow, ClientRectangle);
            }
        }		
    }
}

L’exemple suivant montre comment utiliser l’énumération ViewTechnology> dans un concepteur. Cet exemple fait partie d’un exemple plus grand fourni pour la LocalizationExtenderProvider classe .

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

Le modèle d’adaptateur de vue remplace et ajoute des fonctionnalités à la ViewTechnology fonctionnalité ; toutefois, la fonctionnalité est conservée à des ViewTechnology fins de compatibilité descendante et d’utilisation ultérieure, si vous le souhaitez.

ViewTechnology définit des identificateurs qui peuvent indiquer le mode à utiliser pour contrôler l’affichage d’un document hébergé par le concepteur.

Vous devez uniquement utiliser la Default valeur dans votre environnement d’hébergement de concepteur. Dans les versions précédentes du .NET Framework, l’énumération ViewTechnology spécifiait le type de modèle d’interface utilisateur pris en charge par un concepteur racine. Étant donné que ce modèle n’est pas extensible, vous devez plutôt utiliser un modèle d’adaptateur de vue . Un adaptateur de vue est un type qui adapte un objet d’un type à un autre.

Par exemple, un concepteur HTML peut retourner une DemoDOM arborescence comme affichage. Le concepteur HTML retourne une technologie d’affichage de Default. Un environnement d’hébergement Windows Forms aurait une ou plusieurs classes d’adaptateur d’affichage disponibles. Si l’une de ces classes peut convertir le DemoDOM en contrôle Windows Forms, l’application d’hébergement peut prendre en charge ce type de concepteur. Si aucun adaptateur ne peut gérer le type de données retourné par la méthode du GetView concepteur, la charge du concepteur échoue et l’utilisateur reçoit une erreur.

Visual Studio dispose d’un schéma extensible pour fournir des adaptateurs de vue, de sorte qu’il peut s’adapter à n’importe quelle technologie d’interface utilisateur. Les fournisseurs de technologies tiers peuvent également offrir un adaptateur de vue approprié, et leurs modèles objet sont immédiatement consommables.

S’applique à