ViewTechnology Enumerazione

Definizione

Spazio dei nomi:

System.ComponentModel.Design

Assembly:

System.ComponentModel.TypeConverter.dll

Definisce gli identificatori per un insieme di tecnologie supportate dagli host di progettazione.

C#

public enum ViewTechnology

Ereditarietà

Object

ValueType

Enum

ViewTechnology

Campi

Nome	Valore	Descrizione
Default	2	Specifica il supporto di tecnologia di visualizzazione predefinito. La finestra di progettazione radice può restituire qualsiasi tipo di oggetto, ma l'oggetto deve essere compatibile con un adapter per la tecnologia dell'host. Gli ambienti di hosting, ad esempio Visual Studio, consentono di inserire nuovi adapter di tecnologia di visualizzazione. L'oggetto di visualizzazione predefinito per la finestra di progettazione Windows Form è un'istanza Control.
Passthrough	0	Rappresenta una modalità in cui l'oggetto visualizzazione viene passato direttamente all'ambiente di sviluppo. L'oggetto visualizzazione deve implementare le interfacce richieste dall'ambiente di sviluppo. L'ambiente di sviluppo di Visual Studio supporta gli oggetti di visualizzazione che sono un controllo ActiveX, un documento attivo o un oggetto che implementa l'interfaccia IVsWindowPane disponibile attraverso il programma Integrazione con Visual Studio. L'ambiente di sviluppo di Visual Studio offre il supporto per questa tecnologia di visualizzazione, che non è necessariamente disponibile in tutti gli ambienti di sviluppo.
WindowsForms	1	Rappresenta una modalità in cui un oggetto controllo Windows Form fornisce la visualizzazione per la finestra di progettazione di primo livello. L'host di progettazione completa la finestra del documento dell'ambiente di sviluppo con il controllo Windows Form.

Esempio

Nell'esempio seguente viene illustrato come usare ViewTechnology.Default in una finestra di progettazione. Questo esempio fa parte di un esempio più grande fornito per l'interfaccia 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);
            }
        }		
    }
}

Nell'esempio seguente viene illustrato come usare l'enumerazione 'ViewTechnology> in una finestra di progettazione. Questo esempio fa parte di un esempio più grande fornito per 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 } );             
                }
            }
        }
    }
}

Commenti

Il modello di adattatore di visualizzazione sostituisce e aggiunge funzionalità alla ViewTechnology funzionalità. Tuttavia, la ViewTechnology funzionalità viene mantenuta sia per la compatibilità con le versioni precedenti che per l'uso futuro, se si sceglie.

ViewTechnology definisce gli identificatori che possono indicare la modalità da usare per controllare la visualizzazione di un documento ospitato dalla finestra di progettazione.

È consigliabile usare solo il valore nell'ambiente Default di hosting della finestra di progettazione. Nelle versioni precedenti di .NET Framework l'enumerazione ha specificato il ViewTechnology tipo di modello dell'interfaccia utente supportato da una finestra di progettazione radice. Poiché questo modello non è estendibile, è consigliabile usare invece un modello di scheda di visualizzazione . Un adattatore di visualizzazione è un tipo che adatta un oggetto di un tipo a un altro.

Ad esempio, una finestra di progettazione HTML potrebbe restituire un DemoDOM albero come visualizzazione. La finestra di progettazione HTML restituisce una tecnologia di visualizzazione di Default. Un ambiente di hosting Windows Forms avrebbe una o più classi di adattatori di visualizzazione disponibili. Se una classe di questo tipo potrebbe convertire l'oggetto DemoDOM in un controllo Windows Forms, l'applicazione di hosting può supportare questo tipo di finestra di progettazione. Se nessun adattatore può gestire il tipo di dati restituito dal metodo della GetView finestra di progettazione, il carico della finestra di progettazione avrà esito negativo e l'utente verrà visualizzato un errore.

Visual Studio ha uno schema estendibile per fornire schede di visualizzazione, in modo che possa adattarsi a qualsiasi tecnologia dell'interfaccia utente. I provider di tecnologie di terze parti possono anche offrire un adattatore di visualizzazione appropriato e i relativi modelli a oggetti sono immediatamente consumabili.

Si applica a