AccessibleObject Sınıf

Tanım

Ad Alanı:

System.Windows.Forms

Bütünleştirilmiş Kod:

System.Windows.Forms.dll

Erişilebilirlik uygulamalarının, engelli kullanıcılar için uygulamanın kullanıcı arabirimini (UI) ayarlamak için kullandığı bilgileri sağlar.

C#

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

Devralma

Object

MarshalByRefObject

StandardOleMarshalObject

AccessibleObject

Türetilmiş

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

Uygulamalar

IAccessible IReflect

Örnekler

Aşağıdaki kod örneği, erişilebilir bilgileri kullanıma açmak için AccessibleObject ve Control.ControlAccessibleObject sınıflarını kullanarak erişilebilirliği algılayan bir grafik denetiminin oluşturulmasını gösterir. Denetim, bir göstergeyle birlikte iki eğri çizer. ControlAccessibleObject'den türetilen ChartControlAccessibleObject sınıfı, grafik denetimi için özel erişilebilir bilgiler sağlamak üzere CreateAccessibilityInstance yönteminde kullanılır. Grafik göstergesi gerçek bir Control -based denetimi olmadığından, bunun yerine grafik denetimi tarafından çizildiğinden, yerleşik erişilebilir bilgileri yoktur. Bu nedenle, ChartControlAccessibleObject sınıfı göstergenin her bölümü için erişilebilir bilgileri temsil eden CurveLegendAccessibleObject döndürmek için GetChild yöntemini geçersiz kılar. Erişilebilir durumdaki bir uygulama bu denetimi kullandığında, denetim gerekli erişilebilir bilgileri sağlayabilir.

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

Açıklamalar

Erişilebilirlik uygulamaları, engelli kullanıcıların kullanılabilirliğini artırmak için uygulamanın özelliklerini ayarlayabilir.

Görme engelli kullanıcılar için yazılım ve işletim sistemi özelliklerini ihtiyaçlarına uyacak şekilde ayarlayabilirsiniz. Örneğin, metinleri ve resimleri büyütebilir ve bunları karşıtlık ile işleyebilirsiniz. Buna ek olarak, renklerin uygun kullanımıyla renk körlüğüne uyum sağlayabilirsiniz. Ciddi derecede görme engelli kullanıcılar için bilgisayarlara, ekrandaki metni konuşmaya veya dinamik, yenilenebilir, Braille ekranına çeviren ekran inceleme yardımcılarıyla erişilebilir.

İşitme güçlüğü çeken kullanıcılar için, yanıp sönen araç çubuğu gibi görsel ipuçları kullanan programlar tasarlayabilirsiniz; veya konuşulan iletileri metin olarak görüntüleyebilirsiniz. Örneğin, açıldığında, Denetim Masası'ndaki bir erişilebilirlik seçeneği olan SoundSentry özelliği, sistem her alarm sesi yaptığında görsel bir uyarı sağlar.

Hareket engelli kullanıcılar için klavye ve fare kullanımını geliştiren veya ortadan kaldıran denetimler tasarlayarak bilgisayar erişilebilirliğini geliştirebilirsiniz. Denetim Masası yardım sunar. Örneğin, bir alternatif, gezinti için fare yerine sayısal tuş takımını kullanmaktır. StickyKeysolarak adlandırılan başka bir seçenek, aynı anda iki veya daha fazla tuşa (CTRL+P gibi) basılı tutamayan kullanıcıların aynı anda bir tuş yazarak aynı sonucu elde etmelerini sağlar.

Bilişsel ve dil engelli kullanıcılar için, yazılım programlarını gereksinimlerini daha iyi karşılayacak şekilde tasarlayabilirsiniz. Örneğin, ilkokul standartlarına yönelik dikkat çekici veya sevimli sıralama, karmaşık olmayan ekranlar, daha az sözcük ve okuma düzeyi kullanmak bu kullanıcılara yararlı olabilir.

Nöbet bozuklukları olan kullanıcılar için, nöbet kışkırtma düzenlerini ortadan kaldırmak için yazılım programları tasarlayabilirsiniz.

Erişilebilirlik uygulamaları hakkında bilgiler de dahil olmak üzere erişilebilirlik hakkında daha fazla bilgi için bkz.Windows Erişilebilirlik özellikleri .

Not

AccessibleObjectkullanmak için .NET Framework ile yüklenen Accessibility derlemesine bir başvuru eklemeniz gerekir. Windows Forms yalnızca Etkin Erişilebilirlik 2.0'i destekler.

Devralanlara Notlar

Bu sınıftan devraldığınızda, tüm üyeleri geçersiz kılabilirsiniz.

Oluşturucular

AccessibleObject()

AccessibleObject sınıfının yeni bir örneğini başlatır.

Özellikler

Bounds	Erişilebilir nesnenin konumunu ve boyutunu alır.
DefaultAction	Nesnenin varsayılan eylemini açıklayan bir dize alır. Tüm nesnelerin varsayılan eylemi yoktur.
Description	Belirtilen nesnenin görsel görünümünü açıklayan bir dize alır. Tüm nesnelerin açıklaması yoktur.
Help	Nesnenin ne yaptığının veya nesnenin nasıl kullanıldığının açıklamasını alır.
KeyboardShortcut	Erişilebilir nesne için kısayol tuşunu veya erişim tuşunu alır.
Name	Nesne adını alır veya ayarlar.
Parent	Erişilebilir bir nesnenin üst öğesini alır.
Role	Bu erişilebilir nesnenin rolünü alır.
State	Bu erişilebilir nesnenin durumunu alır.
Value	Erişilebilir bir nesnenin değerini alır veya ayarlar.

Yöntemler

CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
DoDefaultAction()	Bu erişilebilir nesneyle ilişkili varsayılan eylemi gerçekleştirir.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetChild(Int32)	Belirtilen dizine karşılık gelen erişilebilir alt öğeyi alır.
GetChildCount()	Erişilebilir bir nesneye ait alt öğe sayısını alır.
GetFocused()	Klavye odağı olan nesneyi alır.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetHelpTopic(String)	Bir Yardım konusu tanımlayıcısı için bir tanımlayıcı ve bu erişilebilir nesneyle ilişkilendirilmiş Yardım dosyasının yolunu alır.
GetLifetimeService()	Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetSelected()	Seçili durumdaki alt öğeyi alır.
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
HitTest(Int32, Int32)	Belirtilen ekran koordinatlarında alt nesneyi alır.
InitializeLifetimeService()	Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnesinin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
Navigate(AccessibleNavigation)	Başka bir erişilebilir nesneye gider.
RaiseAutomationNotification(AutomationNotificationKind, AutomationNotificationProcessing, String)	UI otomasyonu bildirim olayını tetikler.
RaiseLiveRegionChanged()	LiveRegionChanged UI otomasyon olayını tetikler.
Select(AccessibleSelection)	Seçimi değiştirir veya erişilebilir nesnenin klavye odağını taşır.
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
UseStdAccessibleObjects(IntPtr, Int32)	Bir nesneyi tanıtıcıya ve nesnenin nesne kimliğine göre bir AccessibleObject örneğiyle ilişkilendirir.
UseStdAccessibleObjects(IntPtr)	Bir nesneyi, nesnenin tutamacını temel alan bir AccessibleObject örneğiyle ilişkilendirir.

Belirtik Arabirim Kullanımları

IAccessible.accChildCount	Bu nesneye ait alt arabirimlerin sayısını alır. Bu üyenin açıklaması için bkz. accChildCount.
IAccessible.accDoDefaultAction(Object)	Belirtilen nesnenin varsayılan eylemini gerçekleştirir. Tüm nesnelerin varsayılan eylemi yoktur. Bu üyenin açıklaması için bkz. accDoDefaultAction(Object).
IAccessible.accFocus	Klavye odağı olan nesneyi alır. Bu üyenin açıklaması için bkz. accFocus.
IAccessible.accHitTest(Int32, Int32)	Belirtilen ekran koordinatlarında alt nesneyi alır. Bu üyenin açıklaması için bkz. accHitTest(Int32, Int32).
IAccessible.accLocation(Int32, Int32, Int32, Int32, Object)	Nesnenin geçerli ekran konumunu alır. Bu üyenin açıklaması için bkz. accLocation(Int32, Int32, Int32, Int32, Object).
IAccessible.accNavigate(Int32, Object)	Geçerli nesneye göre erişilebilir bir nesneye gider. Bu üyenin açıklaması için bkz. accNavigate(Int32, Object).
IAccessible.accParent	Bu nesnenin üst erişilebilir nesnesini alır. Bu üyenin açıklaması için bkz. accParent.
IAccessible.accSelect(Int32, Object)	Seçimi değiştirir veya erişilebilir nesnenin klavye odağını taşır. Bu üyenin açıklaması için bkz. accSelect(Int32, Object).
IAccessible.accSelection	Erişilebilir bir nesnenin seçili alt nesnelerini alır. Bu üyenin açıklaması için bkz. accSelection.
IReflect.GetField(String, BindingFlags)	Belirtilen alana ve bağlama bayrağına karşılık gelen FieldInfo nesnesini alır. Bu üyenin açıklaması için bkz. GetField(String, BindingFlags).
IReflect.GetFields(BindingFlags)	Geçerli sınıfın tüm alanlarına karşılık gelen bir FieldInfo nesnesi dizisi alır. Bu üyenin açıklaması için bkz. GetFields(BindingFlags).
IReflect.GetMember(String, BindingFlags)	Tüm ortak üyelere veya belirtilen adla eşleşen tüm üyelere karşılık gelen MemberInfo nesneleri dizisi alır. Bu üyenin açıklaması için bkz. GetMember(String, BindingFlags).
IReflect.GetMembers(BindingFlags)	Tüm genel üyelere veya geçerli sınıfın tüm üyelerine karşılık gelen MemberInfo nesne dizisi alır. Bu üyenin açıklaması için bkz. GetMembers(BindingFlags).
IReflect.GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])	Aşırı yüklenmiş yöntemler arasından seçim yapmak için tür dizisi kullanarak belirtilen yönteme karşılık gelen bir MethodInfo nesnesi alır. Bu üyenin açıklaması için bkz. GetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[]).
IReflect.GetMethod(String, BindingFlags)	Belirtilen arama kısıtlamaları altında belirtilen bir yönteme karşılık gelen bir MethodInfo nesnesi alır. Bu üyenin açıklaması için bkz. GetMethod(String, BindingFlags).
IReflect.GetMethods(BindingFlags)	Tüm genel yöntemler veya geçerli sınıfın tüm yöntemleriyle MethodInfo nesneleri dizisi alır. Bu üyenin açıklaması için bkz. GetMethods(BindingFlags).
IReflect.GetProperties(BindingFlags)	Tüm genel özelliklere veya geçerli sınıfın tüm özelliklerine karşılık gelen PropertyInfo nesneleri dizisi alır. Bu üyenin açıklaması için bkz. GetProperties(BindingFlags).
IReflect.GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])	Belirtilen arama kısıtlamalarına sahip belirtilen özelliğe karşılık gelen bir PropertyInfo nesnesi alır. Bu üyenin açıklaması için bkz. GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[]).
IReflect.GetProperty(String, BindingFlags)	Belirtilen arama kısıtlamaları altında belirtilen özelliğe karşılık gelen bir PropertyInfo nesnesi alır. Bu üyenin açıklaması için bkz. GetProperty(String, BindingFlags).
IReflect.InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Belirtilen üyeyi çağırır. Bu üyenin açıklaması için bkz. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).
IReflect.UnderlyingSystemType	IReflect nesnesini temsil eden temel türü alır. Bu üyenin açıklaması için bkz. UnderlyingSystemType.

Şunlara uygulanır