AccessibleObject Classe

Definizione

Spazio dei nomi:

System.Windows.Forms

Assembly:

System.Windows.Forms.dll

Fornisce informazioni che le applicazioni di accessibilità usano per modificare l'interfaccia utente di un'applicazione per gli utenti con problemi.

C#

public class AccessibleObject : System.Runtime.InteropServices.StandardOleMarshalObject, Accessibility.IAccessible, System.Reflection.IReflect

Ereditarietà

Object

MarshalByRefObject

StandardOleMarshalObject

AccessibleObject

Derivato

System.Windows.Forms.ComboBox.ChildAccessibleObject

System.Windows.Forms.Control.ControlAccessibleObject

System.Windows.Forms.DataGridColumnStyle.DataGridColumnHeaderAccessibleObject

System.Windows.Forms.DataGridView.DataGridViewTopRowAccessibleObject

System.Windows.Forms.DataGridViewCell.DataGridViewCellAccessibleObject

System.Windows.Forms.DataGridViewRow.DataGridViewRowAccessibleObject

System.Windows.Forms.Design.ControlDesigner.ControlDesignerAccessibleObject

System.Windows.Forms.DomainUpDown.DomainItemAccessibleObject

System.Windows.Forms.ToolStripItem.ToolStripItemAccessibleObject

System.Workflow.ComponentModel.Design.ActivityDesignerAccessibleObject

System.Workflow.ComponentModel.Design.ConnectorAccessibleObject

Implementazioni

IAccessible IReflect

Esempio

Nell'esempio di codice seguente viene illustrata la creazione di un controllo grafico compatibile con l'accessibilità, usando le classi AccessibleObject e Control.ControlAccessibleObject per esporre informazioni accessibili. Il controllo traccia due curve insieme a una legenda. La classe ChartControlAccessibleObject, che deriva da ControlAccessibleObject, viene utilizzata nel metodo CreateAccessibilityInstance per fornire informazioni personalizzate accessibili per il controllo grafico. Poiché la legenda del grafico non è un controllo Control -based effettivo, ma viene invece disegnato dal controllo grafico, non dispone di informazioni accessibili predefinite. Per questo motivo, la classe ChartControlAccessibleObject esegue l'override del metodo GetChild per restituire il CurveLegendAccessibleObject che rappresenta informazioni accessibili per ogni parte della legenda. Quando un'applicazione con riconoscimento dell'accesso usa questo controllo, il controllo può fornire le informazioni accessibili necessarie.

C#

using System;
using System.Drawing;
using System.Windows.Forms;

namespace ChartControl
{
    public class Form1 : System.Windows.Forms.Form
    {
        // Test out the Chart Control.
        private ChartControl chart1;

        [STAThread]
        static void Main() 
        {
            Application.Run(new Form1());
        }

        public Form1() {
            // Create a chart control and add it to the form.
            this.chart1 = new ChartControl();
            this.ClientSize = new System.Drawing.Size(920, 566);

            this.chart1.Location = new System.Drawing.Point(47, 16);
            this.chart1.Size = new System.Drawing.Size(600, 400);

            this.Controls.Add(this.chart1);
        }
    }

    // Declare a chart control that demonstrates accessibility in Windows Forms.
    public class ChartControl : System.Windows.Forms.UserControl
    {
        private CurveLegend legend1;
        private CurveLegend legend2; 

        public ChartControl()
        {
            // The ChartControl draws the chart in the OnPaint override.
            SetStyle(ControlStyles.ResizeRedraw, true);
            SetStyle(ControlStyles.DoubleBuffer, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);

            this.BackColor = System.Drawing.Color.White;
            this.Name = "ChartControl";

            this.Click += new System.EventHandler(this.ChartControl_Click);
            this.QueryAccessibilityHelp += 
                new System.Windows.Forms.QueryAccessibilityHelpEventHandler(
                                        this.ChartControl_QueryAccessibilityHelp);

            // The CurveLengend is not Control-based, it just
            // represents the parts of the legend.
            legend1 = new CurveLegend(this, "A");
            legend1.Location = new Point(20, 30);
            legend2 = new CurveLegend(this, "B");        
            legend2.Location = new Point(20, 50);
        }

        // Overridden to return the custom AccessibleObject 
        // for the entire chart.
        protected override AccessibleObject CreateAccessibilityInstance() 
        {            
            return new ChartControlAccessibleObject(this);
        }

        protected override void OnPaint(PaintEventArgs e) 
        {
            // The ChartControl draws the chart in the OnPaint override.
            base.OnPaint(e);

            Rectangle bounds = this.ClientRectangle;
            int border = 5;

            // Draws the legends first.
            StringFormat format = new StringFormat();
            format.Alignment = StringAlignment.Center;
            format.LineAlignment = StringAlignment.Center;
            
            if (legend1 != null) {
                if (legend1.Selected) {
                    e.Graphics.FillRectangle(new SolidBrush(Color.Blue), legend1.Bounds);
                } else {
                    e.Graphics.DrawRectangle(Pens.Blue, legend1.Bounds);
                }

                e.Graphics.DrawString(legend1.Name, this.Font, Brushes.Black, legend1.Bounds, format);                
            }
            if (legend2 != null) {
                if (legend2.Selected) {
                    e.Graphics.FillRectangle(new SolidBrush(Color.Red), legend2.Bounds);
                } else {
                    e.Graphics.DrawRectangle(Pens.Red, legend2.Bounds);
                }
                e.Graphics.DrawString(legend2.Name, this.Font, Brushes.Black, legend2.Bounds, format);
            }            

            // Charts out the actual curves that represent data in the Chart.
            bounds.Inflate(-border, -border);
            Point[] curve1 = new Point[] {new Point(bounds.Left, bounds.Bottom),
                            new Point(bounds.Left + bounds.Width / 3, bounds.Top + bounds.Height / 5),
                            new Point(bounds.Right - bounds.Width / 3, (bounds.Top + bounds.Bottom) / 2),
                            new Point(bounds.Right, bounds.Top)};

            Point[] curve2 = new Point[] {new Point(bounds.Left, bounds.Bottom - bounds.Height / 3),
                            new Point(bounds.Left + bounds.Width / 3, bounds.Top + bounds.Height / 5),
                            new Point(bounds.Right - bounds.Width / 3, (bounds.Top + bounds.Bottom) / 2),
                            new Point(bounds.Right, bounds.Top + bounds.Height / 2)};

            // Draws the actual curve only if it is selected.
            if (legend1.Selected) e.Graphics.DrawCurve(Pens.Blue, curve1);
            if (legend2.Selected) e.Graphics.DrawCurve(Pens.Red, curve2);

            e.Graphics.DrawRectangle(Pens.Blue, bounds);            
        }

        // Handles the QueryAccessibilityHelp event.
        private void ChartControl_QueryAccessibilityHelp(object sender, 
                                    System.Windows.Forms.QueryAccessibilityHelpEventArgs e)
        {            
            e.HelpString = "Displays chart data";
        }          

        // Handles the Click event for the chart. 
        // Toggles the selection of whatever legend was clicked on
        private void ChartControl_Click(object sender, System.EventArgs e)
        {
            Point pt = this.PointToClient(Control.MousePosition);
            if (legend1.Bounds.Contains(pt)) {
                legend1.Selected = !legend1.Selected;
            } else if (legend2.Bounds.Contains(pt)) {
                legend2.Selected = !legend2.Selected;
            }
        }

        // Gets an array of CurveLengends used in the Chart.
        public CurveLegend[] Legends
        {   
            get {                
                return new CurveLegend[] { legend1, legend2 };
            }            
        }                

        // Inner class ChartControlAccessibleObject represents accessible information associated with the ChartControl.
        // The ChartControlAccessibleObject is returned in the ChartControl.CreateAccessibilityInstance override.
        public class ChartControlAccessibleObject : ControlAccessibleObject
        {
            ChartControl chartControl;

            public ChartControlAccessibleObject(ChartControl ctrl) : base(ctrl) 
            {
                chartControl = ctrl;
            }

            // Gets the role for the Chart. This is used by accessibility programs.
            public override AccessibleRole Role
            {  
                get {
                    return AccessibleRole.Chart;
                }
            }

            // Gets the state for the Chart. This is used by accessibility programs.
            public override AccessibleStates State
            {  
                get {                    
                    return AccessibleStates.ReadOnly;
                }
            }

            // The CurveLegend objects are "child" controls in terms of accessibility so 
            // return the number of ChartLengend objects.
            public override int GetChildCount()
            {  
                return chartControl.Legends.Length;
            }

            // Gets the Accessibility object of the child CurveLegend idetified by index.
            public override AccessibleObject GetChild(int index)
            {  
                if (index >= 0 && index < chartControl.Legends.Length) {
                    return chartControl.Legends[index].AccessibilityObject;
                }                
                return null;
            }

            // Helper function that is used by the CurveLegend's accessibility object
            // to navigate between sibiling controls. Specifically, this function is used in
            // the CurveLegend.CurveLegendAccessibleObject.Navigate function.
            internal AccessibleObject NavigateFromChild(CurveLegend.CurveLegendAccessibleObject child, 
                                                        AccessibleNavigation navdir) 
            {  
                switch(navdir) {
                    case AccessibleNavigation.Down:
                    case AccessibleNavigation.Next:
                        return GetChild(child.ID + 1);
                        
                    case AccessibleNavigation.Up:
                    case AccessibleNavigation.Previous:
                        return GetChild(child.ID - 1);                        
                }
                return null;
            }

            // Helper function that is used by the CurveLegend's accessibility object
            // to select a specific CurveLegend control. Specifically, this function is used
            // in the CurveLegend.CurveLegendAccessibleObject.Select function.
            internal void SelectChild(CurveLegend.CurveLegendAccessibleObject child, AccessibleSelection selection) 
            {   
                int childID = child.ID;

                // Determine which selection action should occur, based on the
                // AccessibleSelection value.
                if ((selection & AccessibleSelection.TakeSelection) != 0) {
                    for(int i = 0; i < chartControl.Legends.Length; i++) {
                        if (i == childID) {
                            chartControl.Legends[i].Selected = true;                        
                        } else {
                            chartControl.Legends[i].Selected = false;
                        }
                    }

                    // AccessibleSelection.AddSelection means that the CurveLegend will be selected.
                    if ((selection & AccessibleSelection.AddSelection) != 0) {
                        chartControl.Legends[childID].Selected = true;                        
                    }

                    // AccessibleSelection.AddSelection means that the CurveLegend will be unselected.
                    if ((selection & AccessibleSelection.RemoveSelection) != 0) {
                        chartControl.Legends[childID].Selected = false;                        
                    }
                }            
            }
        }

        // Inner Class that represents a legend for a curve in the chart.
        public class CurveLegend 
        {
            private string name;
            private ChartControl chart;
            private CurveLegendAccessibleObject accObj;
            private bool selected = true;
            private Point location;

            public CurveLegend(ChartControl chart, string name) 
            {
                this.chart = chart;
                this.name = name;
            }

            // Gets the accessibility object for the curve legend.
            public AccessibleObject AccessibilityObject
            {
                get
                {
                    accObj ??= new CurveLegendAccessibleObject(this);
                    return accObj;
                }
            }
            
            // Gets the bounds for the curve legend.
            public Rectangle Bounds
            {   
                get
                {
                    return new Rectangle(Location, Size);
                }
            }

            // Gets or sets the location for the curve legend.
            public Point Location
            {   
                get {
                    return location;
                }
                set {
                    location = value;
                    chart.Invalidate();

                    // Notifies the chart of the location change. This is used for
                    // the accessibility information. AccessibleEvents.LocationChange
                    // tells the chart the reason for the notification.

                    chart.AccessibilityNotifyClients(AccessibleEvents.LocationChange, 
                        ((CurveLegendAccessibleObject)AccessibilityObject).ID);
                }
            }            
        
            // Gets or sets the Name for the curve legend.
            public string Name
            {   
                get {
                    return name;
                }
                set {
                    if (name != value) 
                    {
                        name = value;
                        chart.Invalidate();

                        // Notifies the chart of the name change. This is used for
                        // the accessibility information. AccessibleEvents.NameChange
                        // tells the chart the reason for the notification.

                        chart.AccessibilityNotifyClients(AccessibleEvents.NameChange, 
                            ((CurveLegendAccessibleObject)AccessibilityObject).ID);
                    }
                }
            }

            // Gets or sets the Selected state for the curve legend.
            public bool Selected
            {   
                get {
                    return selected;
                }
                set {
                    if (selected != value) 
                    {
                        selected = value;
                        chart.Invalidate();

                        // Notifies the chart of the selection value change. This is used for
                        // the accessibility information. The AccessibleEvents value depends upon
                        // if the selection is true (AccessibleEvents.SelectionAdd) or 
                        // false (AccessibleEvents.SelectionRemove).
                        chart.AccessibilityNotifyClients(
                            selected ? AccessibleEvents.SelectionAdd : AccessibleEvents.SelectionRemove, 
                            ((CurveLegendAccessibleObject)AccessibilityObject).ID);
                    }
                }
            }

            // Gets the Size for the curve legend.
            public Size Size
            {   
                get {                    
                    int legendHeight = chart.Font.Height + 4;
                    Graphics g = chart.CreateGraphics();
                    int legendWidth = (int)g.MeasureString(Name, chart.Font).Width + 4;            

                    return new Size(legendWidth, legendHeight);
                }
            }
    
            // Inner class CurveLegendAccessibleObject represents accessible information 
            // associated with the CurveLegend object.
            public class CurveLegendAccessibleObject : AccessibleObject
            {
                private CurveLegend curveLegend;

                public CurveLegendAccessibleObject(CurveLegend curveLegend) : base() 
                {
                    this.curveLegend = curveLegend;                    
                }                

                // Private property that helps get the reference to the parent ChartControl.
                private ChartControlAccessibleObject ChartControl
                {   
                    get {
                        return Parent as ChartControlAccessibleObject;
                    }
                }

                // Internal helper function that returns the ID for this CurveLegend.
                internal int ID
                {
                    get {
                        for(int i = 0; i < ChartControl.GetChildCount(); i++) {
                            if (ChartControl.GetChild(i) == this) {
                                return i;
                            }
                        }
                        return -1;
                    }
                }

                // Gets the Bounds for the CurveLegend. This is used by accessibility programs.
                public override Rectangle Bounds
                {
                    get {                        
                        // The bounds is in screen coordinates.
                        Point loc = curveLegend.Location;
                        return new Rectangle(curveLegend.chart.PointToScreen(loc), curveLegend.Size);
                    }
                }

                // Gets or sets the Name for the CurveLegend. This is used by accessibility programs.
                public override string Name
                {
                    get {
                        return curveLegend.Name;
                    }
                    set {
                        curveLegend.Name = value;                        
                    }
                }

                // Gets the Curve Legend Parent's Accessible object.
                // This is used by accessibility programs.
                public override AccessibleObject Parent
                {
                    get {
                        return curveLegend.chart.AccessibilityObject;
                    }
                }

                // Gets the role for the CurveLegend. This is used by accessibility programs.
                public override AccessibleRole Role 
                {
                    get {
                        return AccessibleRole.StaticText;
                    }
                }

                // Gets the state based on the selection for the CurveLegend. 
                // This is used by accessibility programs.
                public override AccessibleStates State 
                {
                    get {
                        AccessibleStates state = AccessibleStates.Selectable;
                        if (curveLegend.Selected) 
                        {
                            state |= AccessibleStates.Selected;
                        }
                        return state;
                    }
                }

                // Navigates through siblings of this CurveLegend. This is used by accessibility programs.
                public override AccessibleObject Navigate(AccessibleNavigation navdir) 
                {
                    // Uses the internal NavigateFromChild helper function that exists
                    // on ChartControlAccessibleObject.
                    return ChartControl.NavigateFromChild(this, navdir);
                }

                // Selects or unselects this CurveLegend. This is used by accessibility programs.
                public override void Select(AccessibleSelection selection) 
                {
                    // Uses the internal SelectChild helper function that exists
                    // on ChartControlAccessibleObject.
                    ChartControl.SelectChild(this, selection);
                }
            }
        }
    }
}

Commenti

Le applicazioni di accessibilità possono modificare le funzionalità dell'applicazione per migliorare l'usabilità per gli utenti con disabilità.

Per gli utenti con problemi visivi, è possibile modificare le funzionalità del software e del sistema operativo in base alle proprie esigenze. Ad esempio, è possibile ingrandire testo e immagini ed eseguirne il rendering con un contrasto. Inoltre, è possibile adattare la cecità al colore con l'uso appropriato dei colori. Per gli utenti con gravi problemi di vista, i computer sono accessibili con strumenti di revisione dello schermo che traducono testo sullo schermo in voce o in uno schermo dinamico, aggiornabile, display Braille.

Per gli utenti che sono difficili da sentire, è possibile progettare programmi che usano segnali visivi, ad esempio una barra degli strumenti lampeggiante; oppure puoi visualizzare messaggi vocali come testo. Ad esempio, quando è attivata, la funzionalità SoundSentry, un'opzione di accessibilità nel Pannello di controllo, fornisce un avviso visivo ogni volta che il sistema genera un suono di allarme.

Per gli utenti con disabilità di movimento, è possibile progettare controlli che affinano o eliminano l'uso della tastiera e del mouse, migliorando così l'accessibilità del computer. Il Pannello di controllo offre assistenza. Ad esempio, un'alternativa consiste nell'usare il tastierino numerico anziché il mouse per lo spostamento. Un'altra opzione, denominata StickyKeys, consente agli utenti che non possono tenere premuti due o più tasti alla volta (ad esempio CTRL+P) per ottenere lo stesso risultato digitando un tasto alla volta.

Per gli utenti con disabilità cognitive e linguistiche, è possibile progettare programmi software per soddisfare meglio le proprie esigenze. Ad esempio, l'uso di una sequenziazione conspicuosa o cued, visualizzazioni non replicate, un minor numero di parole e un livello di lettura destinato agli standard scolastici elementari può trarre vantaggio da questi utenti.

Per gli utenti con disturbi di crisi, è possibile progettare programmi software per eliminare i modelli che provocano l'attacco.

Per altre informazioni sull'accessibilità, incluse le informazioni sulle applicazioni di accessibilità, vedere funzionalità di accessibilità di Windows.

Nota

Per usare il AccessibleObject, è necessario aggiungere un riferimento all'assembly Accessibility installato con .NET Framework. Windows Form supporta solo l'accessibilità attiva 2.0.

Note per gli eredi

Quando si eredita da questa classe, è possibile eseguire l'override di tutti i membri.

Costruttori

AccessibleObject()

Inizializza una nuova istanza della classe AccessibleObject.

Proprietà

Bounds	Ottiene la posizione e le dimensioni dell'oggetto accessibile.
DefaultAction	Ottiene una stringa che descrive l'azione predefinita dell'oggetto . Non tutti gli oggetti hanno un'azione predefinita.
Description	Ottiene una stringa che descrive l'aspetto visivo dell'oggetto specificato. Non tutti gli oggetti hanno una descrizione.
Help	Ottiene una descrizione delle operazioni dell'oggetto o del modo in cui viene utilizzato l'oggetto.
KeyboardShortcut	Ottiene il tasto di scelta rapida o il tasto di scelta rapida per l'oggetto accessibile.
Name	Ottiene o imposta il nome dell'oggetto.
Parent	Ottiene l'elemento padre di un oggetto accessibile.
Role	Ottiene il ruolo di questo oggetto accessibile.
State	Ottiene lo stato di questo oggetto accessibile.
Value	Ottiene o imposta il valore di un oggetto accessibile.

Metodi

CreateObjRef(Type)	Crea un oggetto che contiene tutte le informazioni pertinenti necessarie per generare un proxy utilizzato per comunicare con un oggetto remoto. (Ereditato da MarshalByRefObject)
DoDefaultAction()	Esegue l'azione predefinita associata a questo oggetto accessibile.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetChild(Int32)	Recupera l'elemento figlio accessibile corrispondente all'indice specificato.
GetChildCount()	Recupera il numero di elementi figlio appartenenti a un oggetto accessibile.
GetFocused()	Recupera l'oggetto con lo stato attivo della tastiera.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetHelpTopic(String)	Ottiene un identificatore per un identificatore di argomento della Guida e il percorso del file della Guida associato a questo oggetto accessibile.
GetLifetimeService()	Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
GetSelected()	Recupera l'elemento figlio attualmente selezionato.
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
HitTest(Int32, Int32)	Recupera l'oggetto figlio in corrispondenza delle coordinate dello schermo specificate.
InitializeLifetimeService()	Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia superficiale dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
Navigate(AccessibleNavigation)	Passa a un altro oggetto accessibile.
RaiseAutomationNotification(AutomationNotificationKind, AutomationNotificationProcessing, String)	Genera l'evento di notifica di automazione interfaccia utente.
RaiseLiveRegionChanged()	Genera l'evento di automazione dell'interfaccia utente LiveRegionChanged.
Select(AccessibleSelection)	Modifica la selezione o sposta lo stato attivo della tastiera dell'oggetto accessibile.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
UseStdAccessibleObjects(IntPtr, Int32)	Associa un oggetto a un'istanza di un AccessibleObject in base all'handle e all'ID oggetto dell'oggetto.
UseStdAccessibleObjects(IntPtr)	Associa un oggetto a un'istanza di un AccessibleObject in base all'handle dell'oggetto.

Implementazioni dell'interfaccia esplicita

IAccessible.accChildCount	Ottiene il numero di interfacce figlio che appartengono a questo oggetto. Per una descrizione di questo membro, vedere accChildCount.
IAccessible.accDoDefaultAction(Object)	Esegue l'azione predefinita dell'oggetto specificato. Non tutti gli oggetti hanno un'azione predefinita. Per una descrizione di questo membro, vedere accDoDefaultAction(Object).
IAccessible.accFocus	Ottiene l'oggetto con lo stato attivo della tastiera. Per una descrizione di questo membro, vedere accFocus.
IAccessible.accHitTest(Int32, Int32)	Ottiene l'oggetto figlio in corrispondenza delle coordinate dello schermo specificate. Per una descrizione di questo membro, vedere accHitTest(Int32, Int32).
IAccessible.accLocation(Int32, Int32, Int32, Int32, Object)	Ottiene la posizione corrente dello schermo dell'oggetto. Per una descrizione di questo membro, vedere accLocation(Int32, Int32, Int32, Int32, Object).
IAccessible.accNavigate(Int32, Object)	Passa a un oggetto accessibile relativo all'oggetto corrente. Per una descrizione di questo membro, vedere accNavigate(Int32, Object).
IAccessible.accParent	Ottiene l'oggetto accessibile padre di questo oggetto. Per una descrizione di questo membro, vedere accParent.
IAccessible.accSelect(Int32, Object)	Modifica la selezione o sposta lo stato attivo della tastiera dell'oggetto accessibile. Per una descrizione di questo membro, vedere accSelect(Int32, Object).
IAccessible.accSelection	Ottiene gli oggetti figlio selezionati di un oggetto accessibile. Per una descrizione di questo membro, vedere accSelection.
IReflect.GetField(String, BindingFlags)	Ottiene l'oggetto FieldInfo corrispondente al campo e al flag di associazione specificati. Per una descrizione di questo membro, vedere GetField(String, BindingFlags).
IReflect.GetFields(BindingFlags)	Ottiene una matrice di oggetti FieldInfo corrispondenti a tutti i campi della classe corrente. Per una descrizione di questo membro, vedere GetFields(BindingFlags).
IReflect.GetMember(String, BindingFlags)	Ottiene una matrice di oggetti MemberInfo corrispondenti a tutti i membri pubblici o a tutti i membri che corrispondono a un nome specificato. Per una descrizione di questo membro, vedere GetMember(String, BindingFlags).
IReflect.GetMembers(BindingFlags)	Ottiene una matrice di oggetti MemberInfo corrispondenti a tutti i membri pubblici o a tutti i membri della classe corrente. Per una descrizione di questo membro, vedere GetMembers(BindingFlags).
IReflect.GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Ottiene un oggetto MethodInfo corrispondente a un metodo specificato, utilizzando una matrice Type da scegliere tra i metodi di overload. Per una descrizione di questo membro, vedere GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[]).
IReflect.GetMethod(String, BindingFlags)	Ottiene un oggetto MethodInfo corrispondente a un metodo specificato in base ai vincoli di ricerca specificati. Per una descrizione di questo membro, vedere GetMethod(String, BindingFlags).
IReflect.GetMethods(BindingFlags)	Ottiene una matrice di oggetti MethodInfo con tutti i metodi pubblici o tutti i metodi della classe corrente. Per una descrizione di questo membro, vedere GetMethods(BindingFlags).
IReflect.GetProperties(BindingFlags)	Ottiene una matrice di oggetti PropertyInfo corrispondenti a tutte le proprietà pubbliche o a tutte le proprietà della classe corrente. Per una descrizione di questo membro, vedere GetProperties(BindingFlags).
IReflect.GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Ottiene un oggetto PropertyInfo corrispondente a una proprietà specificata con vincoli di ricerca specificati. Per una descrizione di questo membro, vedere GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]).
IReflect.GetProperty(String, BindingFlags)	Ottiene un oggetto PropertyInfo corrispondente a una proprietà specificata in base ai vincoli di ricerca specificati. Per una descrizione di questo membro, vedere GetProperty(String, BindingFlags).
IReflect.InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Richiama un membro specificato. Per una descrizione di questo membro, vedere InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).
IReflect.UnderlyingSystemType	Ottiene il tipo sottostante che rappresenta l'oggetto IReflect. Per una descrizione di questo membro, vedere UnderlyingSystemType.

Si applica a