ViewTechnology Enumeration

Definition

Namespace:

System.ComponentModel.Design

Assembly:

System.ComponentModel.TypeConverter.dll

Definiert Bezeichner für eine Gruppe von Technologien, die von Designerhosts unterstützt werden.

C#

public enum ViewTechnology

Vererbung

Object

ValueType

Enum

ViewTechnology

Felder

Name	Wert	Beschreibung
Default	2	Gibt die Standardunterstützung für die Ansichtstechnologie an. Der Stammdesigner kann Objekte jedes Typs zurückgeben, aber das Objekt muss mit einem Adapter für die Technologie des Hosts kompatibel sein. Hostumgebungen wie Visual Studio ermöglichen das Einbinden neuer Ansichtstechnologieadapter. Das Standardansichtsobjekt für den Windows Forms-Designer ist eine Control-Instanz.
Passthrough	0	Stellt einen Modus dar, in dem das Ansichtsobjekt direkt an die Entwicklungsumgebung übergeben wird. Das Ansichtsobjekt muss alle Schnittstellen implementieren, die die Entwicklungsumgebung erfordert. Die Visual Studio-Entwicklungsumgebung unterstützt Ansichtsobjekte, bei denen es sich entweder um ein ActiveX-Steuerelement, ein aktives Dokument oder ein Objekt handelt, das die IVsWindowPane-Schnittstelle implementiert, die über das Visual Studio-VSI-Programm (Visual Studio Integration) verfügbar ist. Die Entwicklungsumgebung von Visual Studio bietet Unterstützung für diese Ansichtstechnologie. Diese Ansichtstechnologie wird nicht unbedingt in allen Entwicklungsumgebungen unterstützt.
WindowsForms	1	Stellt einen Modus dar, in dem ein Windows Forms-Steuerelementobjekt die Anzeige für den Stammdesigner bereitstellt. Der Designerhost füllt das Dokumentfenster der Entwicklungsumgebung mit dem Windows Forms-Steuerelement.

Beispiele

Im folgenden Beispiel wird die Verwendung ViewTechnology.Default in einem Designer veranschaulicht. Dieses Beispiel ist Teil eines größeren Beispiels, das für die GetView -Schnittstelle bereitgestellt wird.

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);
            }
        }		
    }
}

Im folgenden Beispiel wird veranschaulicht, wie die ViewTechnology-Enumeration> in einem Designer verwendet wird. Dieses Beispiel ist Teil eines größeren Beispiels, das für die LocalizationExtenderProvider -Klasse bereitgestellt wird.

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 } );             
                }
            }
        }
    }
}

Hinweise

Das Ansichtsadaptermodell ersetzt das Feature und fügt funktionen ViewTechnology hinzu. Das Feature wird jedoch sowohl aus Gründen der ViewTechnology Abwärtskompatibilität als auch der zukünftigen Verwendung beibehalten, wenn Sie dies möchten.

ViewTechnology definiert Bezeichner, die den Modus angeben können, der zum Steuern der Anzeige eines vom Designer gehosteten Dokuments verwendet werden soll.

Sie sollten nur den Default Wert in Ihrer Designerhostumgebung verwenden. In früheren Versionen des .NET Framework hat die Enumeration den ViewTechnology Typ des BENUTZEROBERFLÄCHENmodells angegeben, das von einem Stamm-Designer unterstützt wird. Da dieses Modell nicht erweiterbar ist, sollten Sie stattdessen ein Ansichtsadaptermodell verwenden. Ein Ansichtsadapter ist ein Typ, der ein Objekt eines Typs an einen anderen anpasst.

Beispielsweise kann ein HTML-Designer eine DemoDOM Struktur als Ansicht zurückgeben. Der HTML-Designer gibt eine Ansichtstechnologie von zurück Default. Für eine Windows Forms-Hostingumgebung stehen mindestens eine Ansichtsadapterklasse zur Verfügung. Wenn eine solche Klasse die DemoDOM in ein Windows Forms-Steuerelement konvertieren könnte, kann die Hostinganwendung diesen Designertyp unterstützen. Wenn kein Adapter den datentyp verarbeiten kann, der von der -Methode des GetView Designers zurückgegeben wird, schlägt das Laden des Designers fehl, und dem Benutzer wird ein Fehler angezeigt.

Visual Studio verfügt über ein erweiterbares Schema zum Bereitstellen von Ansichtsadaptern, sodass es sich an jede Ui-Technologie anpassen kann. Drittanbieter von Technologie können auch einen geeigneten Ansichtsadapter anbieten, und ihre Objektmodelle sind sofort nutzbar.

Gilt für: