是否存在用于创建具有受保护成员访问权限的工人类的标准模式？

Question

I just did something kind of wacky using a partial class and I'm wondering if there's an already established pattern that might have accomplished the same thing using a less confusing approach.

The problem:

• I had a base class with protected members and virtual methods designed for the derived class to do work when they are called.

• I wanted to delegate this work out to a list of workers.

• However I needed the workers to have access to the protected members.

My probably overly complicated solution:

Note: I realize this depends on the class being partial - I'm OK with that but it would be cool if there was a solution that didn't need it...

void Main()
{
    ABase aBase = new ADerived();
    aBase.DoWork();
}

public partial class ABase
{
    protected int state1 = 1;
    protected int state2 = 2;
    List<ABase> workers;

    public ABase()
    {
        workers = new List<ABase>();
        CreateWorkers(workers);
    }

    protected virtual void CreateWorkers(List<ABase> workers)
    {
    }

    public ABase(ABase aBase)
    {
        this.Target = aBase;
    }

    public virtual void DoWork()
    {
        foreach (var worker in this.workers)
        {
            worker.DoWork();
        }
    }

    protected ABase Target { get; private set; }
}

public partial class ABase
{
    public class Worker1 : ABase
    {
        public Worker1(ABase aBase) : base(aBase) { }

        public override void DoWork()
        {
            Console.WriteLine (Target.state1);
        }
    }

    public class Worker2 : ABase
    {
        public Worker2(ABase aBase) : base(aBase) { }

        public override void DoWork()
        {
            Console.WriteLine (Target.state2);
        }
    }
}

public class ADerived : ABase
{
    protected override void CreateWorkers(List<ABase> workers) 
    {
        workers.Add(new Worker1(this));
        workers.Add(new Worker2(this));
    }
}

Output:

1
2

Answer 1

I would change the design so that the workers weren't accessing instance fields at all. I would have DoWork take a parameter with the information that they need and have the base class pass the state into the DoWork method.

public class MyState //TODO give better name
{
    public int State1 { get; set; }
    public int State2 { get; set; }
}

public class ABase
{
    public MyState state = new MyState()
    {
        State1 = 1,
        State2 = 2
    };

    List<Action<MyState>> workers = new List<Action<MyState>>();

    public ABase()
    {
        CreateWorkers();
    }

    public void DoWork()
    {
        foreach (var action in workers)
        {
            action(state);
        }
    }

    private void CreateWorkers()
    {
        workers.Add(new Worker1().DoWork);
        workers.Add(Worker2.Process);
    }
}

public class Worker1
{
    public void DoWork(MyState state)
    {
        Console.WriteLine(state.State1);
    }
}

public class Worker2
{
    public static void Process(MyState state)
    {
        Console.WriteLine(state.State2);
    }
}