将委托用作线程安全指针的“操作指南”

• 下载源代码 - 5.28 Kb
• 下载测试代码 - 3.64 Kb

引言

本文提供了一个委托使用的实际应用示例。 什么是委托？我该如何在代码中使用它？可以将委托视为一个线程安全的指针，为类上的方法调用提供线程吞吐量。 我见过很多关于如何使用委托的理论示例，但为了让更多人使用它们，我创建了一个实际的示例，该示例是我专业工作的一部分。

背景

我需要一种方法，从子对象向父对象提供一个线程安全的指针，而无需将父对象作为参数放入子对象中，这会导致循环引用。 我希望在子对象更改时更改父对象上的一个参数，而无需直接引用父对象。 我想到的解决方案是使用委托。 委托允许我在子对象中提供一个指向其父对象的指针，而无需直接引用父对象。

使用代码

请注意，父对象包含子对象

public class ParentObject
    {
        private ChangeType _changeType = ChangeType.None;
        private ChildObject _childObject;

请注意，子对象不包含父对象，而是包含两种委托类型：ParentSetChangeTypeDelegate 和 ParentGetChangeTypeDelegate

public class ChildObject 
    {
        #region Private Varaibles
        private ChangeType _changeType = ChangeType.None;
        private ParentSetChangeTypeDelegate _parentSetChangeTypeDelegate;
        private ParentGetChangeTypeDelegate _parentGetChangeTypeDelegate;
        #endregion

我们有两个构造函数，一个没有参数，另一个接受 ParentObject 类。 这提供了一种控制，用于支持单独的对象或其父对象中的对象

#region Constructor
        /// <summary>
        /// 
        /// </summary>
        public ChildObject()
        {
            
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="parent"></param>
        public ChildObject(ParentObject parent)
        {
            SetParent(parent);
        }
        #endregion

SetParent 方法提供了一种设置对父类方法的访问器的方式。 请注意我们如何将来自父类的方法调用委托给子类。 这样，我们就可以提供一个线程安全的指针返回到父类，而无需将父类作为实际参数

        /// <summary>
        /// Set the ParentSetChangeTypeDelegate to hold an instance of the method
        /// ChildObject.SetTypeOfChange for use when changing the ChangeType
        /// of an object
        /// </summary>
        /// <param name="parent"></param>
        public void SetParent(ParentObject parent)
        {
            if(parent != null)
            {
                _parentGetChangeTypeDelegate = 
                   new ParentGetChangeTypeDelegate(parent.GetTypeOfChange);
                _parentSetChangeTypeDelegate = 
                   new ParentSetChangeTypeDelegate(parent.SetTypeOfChange);    
            }
        }

DoChange 方法实际上通过委托对子对象和父对象进行更改

        /// <summary>
        /// Sets the child's change, if the parent is availiable, then 
        /// sets the parents as well
        /// </summary>
        /// <param name="changeType"></param>
        public void DoChange(ChangeType changeType)
        {
            
            //here we find out if there is a parent object
            if(_parentGetChangeTypeDelegate != null && 
                _parentSetChangeTypeDelegate != null)
            {
                switch(changeType)
                {
                    case ChangeType.Add : 
                        SetTypeOfChange(ChangeType.Add);
                        _parentSetChangeTypeDelegate(ChangeType.Modify);
                        break;
                    case ChangeType.Modify : 
                        SetTypeOfChange(ChangeType.Modify);
                        _parentSetChangeTypeDelegate(ChangeType.Modify);
                        break;
                    case ChangeType.Remove : 
                        SetTypeOfChange(ChangeType.Remove);
                        _parentSetChangeTypeDelegate(ChangeType.Modify);
                        break;
                    default :
                        break;
                }
            }

请注意，当子对象更改时，父对象上的 GetTypeOfChange 的值也会更改。

line 30:    Console.WriteLine("///New Change....///");
line 32:    child.DoChange(ChangeType.Add);

关注点

运行测试，亲眼看看它是如何工作的。 希望这能帮助那些在寻找委托使用实际示例时遇到困难的人。

历史

这是 CodeProject 上关于此主题的第一个提交，也是第一次修订。