C# peut-il utiliser la réflexion pour attribuer des valeurs aux propriétés en lecture seule ?

Conclusion : Vous pouvez

vérifier la démo comme suit :

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace IconTest
{
    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
            ReflectTest rt = new ReflectTest();
            rt.GetType().GetProperty("ID").SetValue(rt, "Guid", null);
            MessageBox.Show(rt.ID);
        }

    }
    public class ReflectTest
    {
        private string id;
        [ReadOnly(true)]
        public string ID
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
    }
}

Sortie du programme winform en cours d'exécution :

Petite note :

TypeDescriptor.GetProperties est utilisé pour définir une valeur qui n'a aucun effet :

TypeDescriptor.GetProperties(rt)["ID"].SetValue(rt, "Guid");

Alors pourquoi ? TypeDescriptor.GetProperties n'a-t-il aucun effet lorsqu'il est utilisé pour définir une valeur ?

Divisez le code ci-dessus en deux phrases suivantes :

PropertyDescriptor prop = TypeDescriptor.GetProperties(rt)["ID"];
prop.SetValue(rt, "Guid");

Single Cliquez pour suivre et vous pourrez trouver :

Après avoir obtenu l'instance de la classe abstraite PropertyDescriptor , lors de l'appel de la méthode SetValue, elle est appelée depuis sa sous-classe ReflectPropertyDescriptor.

Et plus précisément L'implémentation se trouve dans la sous-classe : ReflectPropertyDescriptor. Recherchez ReflectPropertyDescriptor et SetValue à partir du code source Microsoft

 public override void SetValue(object component, object value) {
#if DEBUG
            if (PropDescUsageSwitch.TraceVerbose) {
                string compName = "(null)";
                string valName  = "(null)";

                if (component != null)
                    compName = component.ToString();
                if (value != null)
                    valName = value.ToString();

                Debug.WriteLine("[" + Name + "]: SetValue(" + compName + ", " + valName + ")");
            }
#endif
            if (component != null) {
                ISite site = GetSite(component);
                IComponentChangeService changeService = null;
                object oldValue = null;

                object invokee = GetInvocationTarget(componentClass, component);

                Debug.Assert(!IsReadOnly, "SetValue attempted on read-only property [" + Name + "]");
                if (!IsReadOnly) {

                    // Announce that we are about to change this component
                    //
                    if (site != null) {
                        changeService = (IComponentChangeService)site.GetService(typeof(IComponentChangeService));
                        Debug.Assert(!CompModSwitches.CommonDesignerServices.Enabled || changeService != null, "IComponentChangeService not found");
                    }


                    // Make sure that it is ok to send the onchange events
                    //
                    if (changeService != null) {
                        oldValue = SecurityUtils.MethodInfoInvoke(GetMethodValue, invokee, (object[])null); 
                        try {
                            changeService.OnComponentChanging(component, this);
                        }
                        catch (CheckoutException coEx) {
                            if (coEx == CheckoutException.Canceled) {
                                return;
                            }
                            throw coEx;
                        }
                    }

                    try {
                        try {
                            SecurityUtils.MethodInfoInvoke(SetMethodValue, invokee, new object[] { value });
                            OnValueChanged(invokee, EventArgs.Empty);
                        }
                        catch (Exception t) {
                            // Give ourselves a chance to unwind properly before rethrowing the exception.
                            //
                            value = oldValue;
                            
                            // If there was a problem setting the controls property then we get:
                            // ArgumentException (from properties set method)
                            // ==> Becomes inner exception of TargetInvocationException
                            // ==> caught here

                            if (t is TargetInvocationException && t.InnerException != null) {
                                // Propagate the original exception up
                                throw t.InnerException;
                            }
                            else {
                                throw t;
                            }
                        }
                    }
                    finally {
                        // Now notify the change service that the change was successful.
                        //
                        if (changeService != null) {
                            changeService.OnComponentChanged(component, this, oldValue, value);
                        }
                    }
                }
            }
        }

comme vous pouvez le voir sur le code out, l'attribut en lecture seule est ignoré directement. . . . . .

Alors, y a-t-il des restrictions sur PropertyInfo ?

La SetValue appelée par PropertyInfo est la suivante :

L'implémentation spécifique peut être trouvée dans le code open source de Microsoft comme suit :

 [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden]
#if !FEATURE_CORECLR
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
#endif
        public override void SetValue(Object obj, Object value, Object[] index)
        {
            SetValue(obj,
                    value,
                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, 
                    null, 
                    index, 
                    null);
        }

        [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden]
        public override void SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, Object[] index, CultureInfo culture)
        {
             
            MethodInfo m = GetSetMethod(true);

            if (m == null)
                throw new ArgumentException(System.Environment.GetResourceString("Arg_SetMethNotFnd"));

            Object[] args = null;

            if (index != null) 
            {
                args = new Object[index.Length + 1];

                for(int i=0;i<index.Length;i++)
                    args[i] = index[i];

                args[index.Length] = value;
            }
            else 
            {
                args = new Object[1];
                args[0] = value;
            }

            m.Invoke(obj, invokeAttr, binder, args, culture);
        }

Je n'ai pas vu l'appel PropertyInfo pourtant Quelles sont les limites de SetValue

PropertyInfo Méthode .GetSetMethod (booléenne)

Ce qui précède est en C#. Pouvez-vous utiliser la réflexion pour attribuer des valeurs. aux propriétés en lecture seule ? Pour plus de contenu connexe, veuillez prêter attention au site Web PHP chinois (www.php.cn) !