Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

ToolboxItemFilterAttribute-Klasse

 

Veröffentlicht: Juli 2016

Gibt die Filterzeichenfolge und den Filtertyp an, für ein Toolboxelement zu verwenden.

Namespace:   System.ComponentModel
Assembly:  System (in System.dll)

System.Object
  System.Attribute
    System.ComponentModel.ToolboxItemFilterAttribute

[SerializableAttribute]
[AttributeUsageAttribute(AttributeTargets.Class, AllowMultiple = true, 
	Inherited = true)]
public sealed class ToolboxItemFilterAttribute : Attribute

NameBeschreibung
System_CAPS_pubmethodToolboxItemFilterAttribute(String)

Initialisiert eine neue Instanz der ToolboxItemFilterAttribute -Klasse unter Verwendung der angegebenen Filterzeichenfolge.

System_CAPS_pubmethodToolboxItemFilterAttribute(String, ToolboxItemFilterType)

Initialisiert eine neue Instanz der ToolboxItemFilterAttribute -Klasse unter Verwendung der angegebenen Filterzeichenfolge und Typ.

NameBeschreibung
System_CAPS_pubpropertyFilterString

Ruft die Filterzeichenfolge für das Toolboxelement ab.

System_CAPS_pubpropertyFilterType

Ruft den Typ des Filters.

System_CAPS_pubpropertyTypeId

Ruft die Typ-ID für das Attribut ab.(Setzt "Attribute.TypeId" außer Kraft.)

NameBeschreibung
System_CAPS_pubmethodEquals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.(Setzt "Attribute.Equals(Object)" außer Kraft.)

System_CAPS_pubmethodGetHashCode()

Gibt den Hashcode für diese Instanz zurück.(Setzt "Attribute.GetHashCode()" außer Kraft.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von Object.)

System_CAPS_pubmethodIsDefaultAttribute()

Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob der Wert der Instanz der Standardwert für die abgeleitete Klasse ist.(Geerbt von Attribute.)

System_CAPS_pubmethodMatch(Object)

Gibt an, ob das angegebene Objekt über eine entsprechende Filterzeichenfolge verfügt.(Setzt "Attribute.Match(Object)" außer Kraft.)

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Setzt "Object.ToString()" außer Kraft.)

NameBeschreibung
System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.(Geerbt von Attribute.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, mit deren Hilfe die Typinformationen für eine Schnittstelle abgerufen werden können.(Geerbt von Attribute.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).(Geerbt von Attribute.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.(Geerbt von Attribute.)

ToolboxItemFilterAttribute Stellt einen Mechanismus, mit dem, den Toolboxelemente für die ausschließliche Verwendung mit Designern kann, die über ein entsprechendes Attribut oder Code, der bestimmt markiert werden, ob das Element aktiviert oder in der Toolbox deaktiviert werden soll.

Ein ToolboxItemFilterAttribute kann angewendet werden, um eine ToolboxItem an, dass ein Filter und einen Filtertyp, die festlegen, wann zu aktivieren oder deaktivieren das Element. ToolboxItemFilterAttribute kann auch in einen Designer an, dass die Anforderung für die Aktivierung von Elementen in der Toolbox angewendet werden. Dieser Typ des Attributs kann verwendet werden, um anzugeben, dass ein Toolboxelement nur aktiviert werden kann, wenn ein Designer mit einer übereinstimmenden Filterzeichenfolge verwendet wird. Der Typ des Filters wird angegeben, der FilterType Eigenschaft, indem Sie einen ToolboxItemFilterType der angibt, ob und wie eine Entsprechung der Filterzeichenfolge verwendet wird oder ob benutzerdefinierten Code verwenden, um zu bestimmen, ob ein Element zu aktivieren.

Im folgenden Codebeispiel wird veranschaulicht, wie Anwenden der ToolboxItemFilterAttribute.

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

// This example contains an IRootDesigner that implements the IToolboxUser interface.
// This example demonstrates how to enable the GetToolSupported method of an IToolboxUser
// designer in order to disable specific toolbox items, and how to respond to the 
// invocation of a ToolboxItem in the ToolPicked method of an IToolboxUser implementation.
namespace IToolboxUserExample
{
    // This example component class demonstrates the associated IRootDesigner which 
    // implements the IToolboxUser interface. When designer view is invoked, Visual 
    // Studio .NET attempts to display a design mode view for the class at the top 
    // of a code file. This can sometimes fail when the class is one of multiple types 
    // in a code file, and has a DesignerAttribute associating it with an IRootDesigner. 
    // Placing a derived class at the top of the code file solves this problem. A 
    // derived class is not typically needed for this reason, except that placing the 
    // RootDesignedComponent class in another file is not a simple solution for a code 
    // example that is packaged in one segment of code.
    public class RootViewSampleComponent : RootDesignedComponent
	{
	}

	// The following attribute associates the SampleRootDesigner with this example component.
	[DesignerAttribute(typeof(SampleRootDesigner), typeof(IRootDesigner))]
	public class RootDesignedComponent : System.Windows.Forms.Control
	{
	}

    // This example IRootDesigner implements the IToolboxUser interface and provides a 
    // Windows Forms view technology view for its associated component using an internal 
    // Control type.     
    // The following ToolboxItemFilterAttribute enables the GetToolSupported method of this
    // IToolboxUser designer to be queried to check for whether to enable or disable all 
    // ToolboxItems which create any components whose type name begins with "System.Windows.Forms".
    [ToolboxItemFilterAttribute("System.Windows.Forms", ToolboxItemFilterType.Custom)]
    [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")] 
    public class SampleRootDesigner : ParentControlDesigner, IRootDesigner, IToolboxUser
    {
        // This field is a custom Control type named RootDesignerView. This field references
        // a control that is shown in the design mode document window.
        private RootDesignerView view;

        // This string array contains type names of components that should not be added to 
        // the component managed by this designer from the Toolbox.  Any ToolboxItems whose 
        // type name matches a type name in this array will be marked disabled according to  
        // the signal returned by the IToolboxUser.GetToolSupported method of this designer.
        private string[] blockedTypeNames =
        {
            "System.Windows.Forms.ListBox",
            "System.Windows.Forms.GroupBox"
        };

        // IRootDesigner.SupportedTechnologies is a required override for an IRootDesigner.
        // This designer provides a display using the Windows Forms view technology.
        ViewTechnology[] IRootDesigner.SupportedTechnologies 
        {
            get { return new ViewTechnology[] {ViewTechnology.Default}; }
        }

        // This method returns an object that provides the view for this root designer. 
        object IRootDesigner.GetView(ViewTechnology technology) 
        {
            // If the design environment requests a view technology other than Windows 
            // Forms, this method throws an Argument Exception.
            if (technology != ViewTechnology.Default)            
                throw new ArgumentException("An unsupported view technology was requested", 
                "Unsupported view technology.");            

            // Creates the view object if it has not yet been initialized.
            if (view == null)                            
                view = new RootDesignerView(this);          

            return view;
        }

        // This method can signal whether to enable or disable the specified
        // ToolboxItem when the component associated with this designer is selected.
        bool IToolboxUser.GetToolSupported(ToolboxItem tool)
        {       
            // Search the blocked type names array for the type name of the tool
            // for which support for is being tested. Return false to indicate the
            // tool should be disabled when the associated component is selected.
            for( int i=0; i<blockedTypeNames.Length; i++ )
                if( tool.TypeName == blockedTypeNames[i] )
                    return false;

            // Return true to indicate support for the tool, if the type name of the
            // tool is not located in the blockedTypeNames string array.
            return true;
        }

        // This method can perform behavior when the specified tool has been invoked.
        // Invocation of a ToolboxItem typically creates a component or components, 
        // and adds any created components to the associated component.
        void IToolboxUser.ToolPicked(ToolboxItem tool)
        {
        }

        // This control provides a Windows Forms view technology view object that 
        // provides a display for the SampleRootDesigner.
        [DesignerAttribute(typeof(ParentControlDesigner), typeof(IDesigner))]
        internal class RootDesignerView : Control
        {
            // This field stores a reference to a designer.
            private IDesigner m_designer;

            public RootDesignerView(IDesigner designer)
            {
                // Perform basic control initialization.
                m_designer = designer;
                BackColor = Color.Blue;
                Font = new Font(Font.FontFamily.Name, 24.0f);                
            }

            // This method is called to draw the view for the SampleRootDesigner.
            protected override void OnPaint(PaintEventArgs pe)
            {
                base.OnPaint(pe);
                // Draw the name of the component in large letters.
                pe.Graphics.DrawString(m_designer.Component.Site.Name, Font, Brushes.Yellow, ClientRectangle);
            }
        }
    }
}

.NET Framework
Verfügbar seit 1.1

Öffentliche statische (in Visual Basic freigegebene) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Zurück zum Anfang
Anzeigen: