c# - 了解 C# 中的代理模式

Question

假设我尝试通过像这样的其他类访问类的方法

class SuperClass
    {
        public interface ISubject
        {
            void Print();
        }
        private class Subject : ISubject
        {
            public void Print()
            {
                Console.WriteLine("this is a print");
            }
        }
       public class Proxy {
            ISubject subject;
            public void CallOtherMethod() {
                subject = new Subject();
                subject.Print();
            }
        }
    }
    class Client: SuperClass
    {
        static void Main() {
            Proxy proxy = new Proxy();
            proxy.CallOtherMethod();
        }
    } 

这被称为代理类吗？或者是否需要有一个接口(interface)作为引用然后我们必须调用该方法？例如像这样

class SuperClass
    {
        public interface ISubject
        {
            void Print();
        }
        private class Subject : ISubject
        {
            public void Print()
            {
                Console.WriteLine("this is a print");
            }
        }
        public class Proxy : ISubject
        {
            ISubject subject;
            public void Print()
            {
                subject = new Subject();
                subject.Print();
            }
        }
    }
    class Client : SuperClass
    {
        static void Main()
        {
            ISubject proxy = new Proxy();
            proxy.Print();
        }
    }

Answer 1

通常，代理模式的目的是拦截。也就是说，捕获对某种类型的某些(或全部)方法的调用，并在实际调用之前/之后执行某些操作。为了实现这一点，代理必须继承目标类型。

例如:

public class Subject
{
    public virtual void Print()
    {
        Console.WriteLine("this is a print");
    }
}

public class SubjectProxy : Subject
{
    public override void Print()
    {
        Console.Write("Before calling base.Print()");
        base.Print();
        Console.Write("After calling base.Print()");
    }
}

现在，当您在代码中的某个时刻您期望 Subject 时， ，你实际上可能会得到 SubjectProxy并仍然将其视为 Subject :

public Subject GetSubject()
{
    return new SubjectProxy();
}

Subject subject = GetSubject();
subject.Print(); // would use the proxied method

(这并不是说实现拦截的唯一方法是通过继承。我认为有一些代理风格使用组合/装饰的变体来实现这一点)