Detaillierte Erläuterung der dynamischen Implementierungsmethoden für dynamische Objekte in C# und des dynamischen Attributcodes

Der folgende Editor bietet Ihnen eine detaillierte Erläuterung der dynamischen C#-Objekte (dynamische Implementierung von Methoden und Eigenschaften). Der Herausgeber findet es ziemlich gut, deshalb werde ich es jetzt mit Ihnen teilen und es allen als Referenz geben. Folgen wir dem Editor und werfen wir einen Blick darauf.

Die Eigenschaftenimplementierung dynamischer Objekte in C# ist relativ einfach. Wenn Sie dynamische Methoden wie dynamische Sprachen implementieren möchten, ist dies schwieriger, da dynamische Objekte, Erweiterungsmethoden usw. und anonyme Methoden können keine direkten Methoden verwenden. Hier verwenden wir immer noch Objekte und Delegaten, um die Implementierung dieser dynamischen Methode zu simulieren:

1) Definieren Sie einen Delegaten, die Anzahl der Parameter ist variabel und die Parameter sind alle vom Objekttyp: Die meisten Delegaten hier haben einen dynamischen Parameter, der das dynamische Objekt selbst darstellt, das diesen Delegaten aufruft.

public delegate object MyDelegate(dynamic Sender, params object[] PMs);

2) Delegiertes Reproduktionsobjekt definieren, da dynamische Objekte anonyme Methoden nicht direkt verwenden können. Hier verwenden wir Objekte, um sie zu übertragen:

public class DelegateObj
  {
    private MyDelegate _delegate;

    public MyDelegate CallMethod
    {
      get { return _delegate; }
    }
    private DelegateObj(MyDelegate D)
    {
      _delegate = D;
    }
    /// <summary>
    /// 构造委托对象，让它看起来有点javascript定义的味道.
    /// </summary>
    /// <param name="D"></param>
    /// <returns></returns>
    public static DelegateObj Function(MyDelegate D)
    {
      return new DelegateObj(D);
    }
  }

3) Definieren Sie ein dynamisches Objekt:

public class DynObj : DynamicObject
  {
    //保存对象动态定义的属性值
    private Dictionary<string, object> _values;
    public DynObj()
    {
      _values = new Dictionary<string, object>();
    }
    /// <summary>
    /// 获取属性值
    /// </summary>
    /// <param name="propertyName"></param>
    /// <returns></returns>
    public object GetPropertyValue(string propertyName)
    {
      if (_values.ContainsKey(propertyName) == true)
      {
        return _values[propertyName];
      }
      return null;
    }
    /// <summary>
    /// 设置属性值
    /// </summary>
    /// <param name="propertyName"></param>
    /// <param name="value"></param>
    public void SetPropertyValue(string propertyName,object value)
    {
      if (_values.ContainsKey(propertyName) == true)
      {
        _values[propertyName] = value;
      }
      else
      {
        _values.Add(propertyName, value);
      }
    }
    /// <summary>
    /// 实现动态对象属性成员访问的方法，得到返回指定属性的值
    /// </summary>
    /// <param name="binder"></param>
    /// <param name="result"></param>
    /// <returns></returns>
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
      result = GetPropertyValue(binder.Name);
      return result == null ? false : true;
    }
    /// <summary>
    /// 实现动态对象属性值设置的方法。
    /// </summary>
    /// <param name="binder"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
      SetPropertyValue(binder.Name, value);
      return true;
    }
    /// <summary>
    /// 动态对象动态方法调用时执行的实际代码
    /// </summary>
    /// <param name="binder"></param>
    /// <param name="args"></param>
    /// <param name="result"></param>
    /// <returns></returns>
    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
      var theDelegateObj = GetPropertyValue(binder.Name) as DelegateObj;
      if (theDelegateObj == null || theDelegateObj.CallMethod == null)
      {
        result = null;
        return false;
      }
      result = theDelegateObj.CallMethod(this,args);
      return true;
    }
    public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
    {
      return base.TryInvoke(binder, args, out result);
    }
  }

Testcode anwenden:

dynamic theObj = new DynObj();
      theObj.aaa = "this is a test";//动态属性
      //动态方法，这里不能没法定义参数，调用的时候可以是任意多参数，具体参数类型和含义就只能自己去小心处理了.
      theObj.show = DelegateObj.Function((s, pms) =>
      {
        if (pms != null && pms.Length > 0)
        {
          MessageBox.Show(pms[0].ToString() + ":" + s.aaa);
        }
        else
        {
          MessageBox.Show(s.aaa);
        }
        return null;
      }
      );
      
theObj.show("hello");

Obwohl es ein bisschen so aussieht, als würde JS Objektmethoden definieren, ist der bereitgestellte dynamische Simulationsmechanismus immer noch begrenzt, da C# eine statische Sprache ist. Er sieht dynamisch aus, aber alle Wertespeicher und Methoden müssen von geschrieben werden selbst. Code zum Verarbeiten.

Der obige Code wurde auf vs2010, Windows 2008 Server, Framework 4.0.

getestet

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der dynamischen Implementierungsmethoden für dynamische Objekte in C# und des dynamischen Attributcodes. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!