Object 在不创建新实例的情况下执行对象方法

如何从

TestObject

中执行

Print

class Program
{
    private int Value;
    static void Main()
    {
        TestObject test = new TestObject();
        Program p1 = new Program();
        Program p2 = new Program();
        p1.Value = 1;
        p2.Value = 2;
        p1.Print();
        p2.Print();
    } 

    private void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    // How to execute p1.Print here?
}

---

有多种方法可以做到这一点：

将程序直接传递给TestObject 优点：

• 简单的改变

缺点：

• 您必须将

  打印

  公开
• 您将在程序中公开其他内容
• 您将

  TestObject

  直接耦合到

  程序

下面是示例代码：

class Program
{
    static void Main()
    {
        TestObject test = new TestObject(this);
    } 

    public void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(Program p)
    {
        p.Print();
    }
}

class Program
{
    static void Main()
    {
        TestObject test = new TestObject(() => Print());
    } 

    private void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(Action print)
    {
        print();
    }
}

interface IPrintable
{
    void Print();
}

class Program : IPrintable
{
    static void Main()
    {
        TestObject test = new TestObject(this);
    } 

    public void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(IPrintable p)
    {
        p.Print();
    }
}

将委托传递给TestObject 优点：

• 简单的改变
• 不必将

  打印

  公开
• 仅向

  TestObject

缺点：

• 耦合是

  TestObject

  想要做某事，而不是

  TestObject

  想要访问做某事的东西

下面是示例代码：

class Program
{
    static void Main()
    {
        TestObject test = new TestObject(this);
    } 

    public void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(Program p)
    {
        p.Print();
    }
}

class Program
{
    static void Main()
    {
        TestObject test = new TestObject(() => Print());
    } 

    private void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(Action print)
    {
        print();
    }
}

interface IPrintable
{
    void Print();
}

class Program : IPrintable
{
    static void Main()
    {
        TestObject test = new TestObject(this);
    } 

    public void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(IPrintable p)
    {
        p.Print();
    }
}

在程序中实现接口并将其传递给TestObject 优点：

• 仅公开接口公开的内容
• 更容易在其他地方实现（最好说“需要这个接口”而不是“需要一个代表”，更清晰的合同规范）
• 不耦合到特定类型，耦合到满足特定条件的任何对象-实现接口

缺点：

• 不相关（在我看来）

下面是示例代码：

class Program
{
    static void Main()
    {
        TestObject test = new TestObject(this);
    } 

    public void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(Program p)
    {
        p.Print();
    }
}

class Program
{
    static void Main()
    {
        TestObject test = new TestObject(() => Print());
    } 

    private void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(Action print)
    {
        print();
    }
}

interface IPrintable
{
    void Print();
}

class Program : IPrintable
{
    static void Main()
    {
        TestObject test = new TestObject(this);
    } 

    public void Print()
    {
        Console.Write(Value.ToString());
        Console.ReadKey();
    }
}

class TestObject
{
    public TestObject(IPrintable p)
    {
        p.Print();
    }
}

---

---

结论：我的建议是选择接口方式。更清晰的设计，更易于扩展，无需传递多个委托。

使

打印
静态或创建实例，这是您的选择。编辑问题，使其与调用方法的对象相关。没有办法做到这一点吗？没有实例就不能调用实例方法。不管它是哪一个对象、类型或方法，您都不能这样做。但是，您可以将
Program
的实例传递给
TestObject
，这样它将有一个实例来调用该方法。向
TestObject
添加一个构造函数，该构造函数接受
Program
的实例，然后使
Print
公开。或者您可以传入一个委托，向
TestObject
添加一个构造函数，该构造函数接受
Action
委托的实例，并使用
newtestobject（（）=>Print（））构造它
然后从
TestObject
中调用代理。您能提供一个示例吗？您可以根据需要随意更改
TestObject