AccessibleObject Clase

Definición

Espacio de nombres:

System.Windows.Forms

Ensamblado:

System.Windows.Forms.dll

Proporciona información que las aplicaciones de accesibilidad usan para adaptar la interfaz de usuario (UI) de una aplicación para usuarios discapacitados.

C#

[System.Runtime.InteropServices.ComVisible(true)]
public class AccessibleObject : MarshalByRefObject, Accessibility.IAccessible, System.Reflection.IReflect

C#

[System.Runtime.InteropServices.ComVisible(true)]
public class AccessibleObject : System.Runtime.InteropServices.StandardOleMarshalObject, Accessibility.IAccessible, System.Reflection.IReflect

C#

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

Herencia

Object

MarshalByRefObject

AccessibleObject

Herencia

Object

MarshalByRefObject

StandardOleMarshalObject

AccessibleObject

Derivado

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

Atributos

ComVisibleAttribute

Implementaciones

IAccessible IReflect

Ejemplos

En el ejemplo de código siguiente se muestra la creación de un control de gráfico compatible con accesibilidad, mediante las AccessibleObject clases y Control.ControlAccessibleObject para exponer información accesible. El control traza dos curvas junto con una leyenda. La ChartControlAccessibleObject clase , que deriva de ControlAccessibleObject, se usa en el CreateAccessibilityInstance método para proporcionar información accesible personalizada para el control de gráfico. Dado que la leyenda del gráfico no es un control basado en real Control , sino que se dibuja mediante el control de gráfico, no tiene ninguna información accesible integrada. Por este motivo, la ChartControlAccessibleObject clase invalida el GetChild método para devolver que CurveLegendAccessibleObject representa información accesible para cada parte de la leyenda. Cuando una aplicación con reconocimiento accesible usa este control, el control puede proporcionar la información accesible necesaria.

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

Comentarios

Las aplicaciones de accesibilidad pueden ajustar las características de la aplicación para mejorar la facilidad de uso de los usuarios con discapacidades.

En el caso de los usuarios con discapacidad visual, puede ajustar las características del sistema operativo y el software para satisfacer sus necesidades. Por ejemplo, puede ampliar el texto y las imágenes y representarlas con un contraste. Además, puede dar cabida a la daltonismo con el uso adecuado de colores. En el caso de los usuarios con discapacidades visuales graves, se puede acceder a los equipos con ayudas de revisión de pantalla que traducen texto en pantalla a voz o a una pantalla dinámica, actualizable y braille.

Para los usuarios con dificultades auditivas, puede diseñar programas que usen indicaciones visuales, como una barra de herramientas parpadeante; o puede mostrar mensajes hablados como texto. Por ejemplo, cuando se activa, la SoundSentry característica, una opción de accesibilidad en Panel de control, proporciona una advertencia visual cada vez que el sistema hace un sonido de alarma.

Para los usuarios con discapacidades de movimiento, puede diseñar controles que refinan o eliminan el uso del teclado y el mouse, lo que mejora la accesibilidad del equipo. Panel de control ofrece asistencia. Por ejemplo, una alternativa es usar el teclado numérico en lugar del mouse para la navegación. Otra opción, denominada StickyKeys, permite a los usuarios que no pueden mantener presionadas dos o más teclas a la vez (como CTRL+P) para obtener el mismo resultado escribiendo una tecla a la vez.

Para los usuarios con discapacidades cognitivas y de lenguaje, puede diseñar programas de software para adaptarse mejor a sus necesidades. Por ejemplo, el uso de secuencias conspicuas o cued, pantallas sin complicaciones, menos palabras y un nivel de lectura destinado a los estándares de la escuela primaria puede beneficiar a estos usuarios.

Para los usuarios con trastornos de convulsiones, puede diseñar programas de software para eliminar patrones de ataque de convulsiones.

Para obtener más información sobre la accesibilidad, incluida la información sobre las aplicaciones de accesibilidad, consulte Características de accesibilidad de Windows.

Nota

Para usar AccessibleObject, debe agregar una referencia al Accessibility ensamblado instalado con .NET Framework. Windows Forms solo admite Active Accessibility 2.0.

Notas a los desarrolladores de herederos

Cuando hereda de esta clase, puede invalidar todos los miembros.

Constructores

AccessibleObject()

Inicializa una nueva instancia de la clase AccessibleObject.

Propiedades

Bounds	Obtiene la ubicación y el tamaño del objeto accesible.
DefaultAction	Obtiene una cadena que describe la acción predeterminada del objeto. No todos los objetos tienen una acción predeterminada.
Description	Obtiene una cadena que describe la apariencia visual del objeto especificado. No todos los objetos tienen una descripción.
Help	Obtiene una descripción de lo que el objeto hace o de cómo se utiliza.
KeyboardShortcut	Obtiene la tecla de método abreviado o la tecla de acceso para el objeto accesible.
Name	Obtiene o establece el nombre del objeto.
Parent	Obtiene el primario de un objeto accesible.
Role	Obtiene la función de este objeto accesible.
State	Obtiene el estado de este objeto accesible.
Value	Obtiene o establece el valor de un objeto accesible.

Métodos

CreateObjRef(Type)	Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
DoDefaultAction()	Realiza la acción predeterminada asociada a este objeto accesible.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetChild(Int32)	Recupera el elemento secundario accesible correspondiente al índice especificado.
GetChildCount()	Recupera el número de elementos secundarios que pertenecen a un objeto accesible.
GetFocused()	Recupera el objeto que tiene el foco de teclado.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetHelpTopic(String)	Obtiene un identificador de un tema de ayuda y la ruta de acceso al archivo de ayuda asociado a este objeto accesible.
GetLifetimeService()	Obsoleto. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetSelected()	Recupera el secundario seleccionado actualmente.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
HitTest(Int32, Int32)	Recupera el objeto secundario que se encuentra en las coordenadas de pantalla especificadas.
InitializeLifetimeService()	Obsoleto. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
Navigate(AccessibleNavigation)	Navega hasta otro objeto accesible.
RaiseAutomationNotification(AutomationNotificationKind, AutomationNotificationProcessing, String)	Genera el evento de notificación de automatización de interfaz de usuario.
RaiseLiveRegionChanged()	Genera el evento de automatización de la interfaz de usuario LiveRegionChanged.
Select(AccessibleSelection)	Modifica la selección o desplaza el foco de teclado del objeto accesible.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
UseStdAccessibleObjects(IntPtr)	Asocia un objeto a una instancia de un objeto AccessibleObject basándose en el controlador del objeto.
UseStdAccessibleObjects(IntPtr, Int32)	Asocia un objeto a una instancia de un objeto AccessibleObject basándose en el controlador y el identificador del objeto.

Implementaciones de interfaz explícitas

IAccessible.accChildCount	Obtiene el número de interfaces secundarias que pertenecen a este objeto. Para obtener una descripción de este miembro, vea accChildCount.
IAccessible.accDoDefaultAction(Object)	Realiza la acción predeterminada del objeto especificado. No todos los objetos tienen una acción predeterminada. Para obtener una descripción de este miembro, vea accDoDefaultAction(Object).
IAccessible.accFocus	Obtiene el objeto que tiene el foco de teclado. Para obtener una descripción de este miembro, vea accFocus.
IAccessible.accHitTest(Int32, Int32)	Obtiene el objeto secundario que se encuentra en las coordenadas de pantalla especificadas. Para obtener una descripción de este miembro, vea accHitTest(Int32, Int32).
IAccessible.accLocation(Int32, Int32, Int32, Int32, Object)	Obtiene la ubicación de pantalla actual del objeto. Para obtener una descripción de este miembro, vea accLocation(Int32, Int32, Int32, Int32, Object).
IAccessible.accNavigate(Int32, Object)	Navega a un objeto accesible relativo al objeto actual. Para obtener una descripción de este miembro, vea accNavigate(Int32, Object).
IAccessible.accParent	Obtiene el objeto accesible primario de este objeto. Para obtener una descripción de este miembro, vea accParent.
IAccessible.accSelect(Int32, Object)	Modifica la selección o desplaza el foco de teclado del objeto accesible. Para obtener una descripción de este miembro, vea accSelect(Int32, Object).
IAccessible.accSelection	Obtiene los objetos secundarios seleccionados de un objeto accesible. Para obtener una descripción de este miembro, vea accSelection.
IReflect.GetField(String, BindingFlags)	Obtiene el objeto FieldInfo correspondiente al campo y al marcador de enlace especificados. Para obtener una descripción de este miembro, vea GetField(String, BindingFlags).
IReflect.GetFields(BindingFlags)	Obtiene una matriz de objetos FieldInfo correspondientes a todos los campos de la clase actual. Para obtener una descripción de este miembro, vea GetFields(BindingFlags).
IReflect.GetMember(String, BindingFlags)	Obtiene una matriz de objetos MemberInfo correspondientes a todos los miembros públicos o a todos los miembros que coincidan con un nombre especificado. Para obtener una descripción de este miembro, vea GetMember(String, BindingFlags).
IReflect.GetMembers(BindingFlags)	Obtiene una matriz de objetos MemberInfo correspondientes a todos los miembros públicos o a todos los miembros de la clase actual. Para obtener una descripción de este miembro, vea GetMembers(BindingFlags).
IReflect.GetMethod(String, BindingFlags)	Obtiene un objeto MethodInfo correspondiente a un método especificado con unas restricciones de búsqueda especificadas. Para obtener una descripción de este miembro, vea GetMethod(String, BindingFlags).
IReflect.GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Obtiene un objeto MethodInfo correspondiente a un método especificado, utilizando una matriz Type para elegir entre varios métodos sobrecargados. Para obtener una descripción de este miembro, vea GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[]).
IReflect.GetMethods(BindingFlags)	Obtiene una matriz de objetos MethodInfo con todos los métodos públicos o todos los métodos de la clase actual. Para obtener una descripción de este miembro, vea GetMethods(BindingFlags).
IReflect.GetProperties(BindingFlags)	Obtiene una matriz de objetos PropertyInfo correspondientes a todas las propiedades públicas o a todas las propiedades de la clase actual. Para obtener una descripción de este miembro, vea GetProperties(BindingFlags).
IReflect.GetProperty(String, BindingFlags)	Obtiene un objeto PropertyInfo correspondiente a una propiedad especificada con unas restricciones de búsqueda especificadas. Para obtener una descripción de este miembro, vea GetProperty(String, BindingFlags).
IReflect.GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Obtiene un objeto PropertyInfo correspondiente a una propiedad especificada con unas determinadas restricciones de búsqueda. Para obtener una descripción de este miembro, vea GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]).
IReflect.InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Invoca el miembro especificado. Para obtener una descripción de este miembro, vea InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).
IReflect.UnderlyingSystemType	Obtiene el tipo subyacente que representa el objeto IReflect. Para obtener una descripción de este miembro, vea UnderlyingSystemType.

Se aplica a