C#在另一个对象内实例化任何类型的类并调用方法？

我目前正在尝试编写一个类，该类对传递给它的任何类执行执行环绕模式

使用大致的伪代码，如下所示：

class MyWrapperClass(){
    private object containedObject;

    public void importObject<MyObject>();
    {
        where MyObject: new ()
        {
            containedObject = new MyObject();
        }
    }

    public void callMethod(Func<int> MyMethod)
    {
        //Wrapped Code here
        containedObject.MyMethod;
        //Wrapped Code here
    }
}

class MyWrapperClass（）{
私有对象包含对象；
公共无效导入对象（）；
{
其中MyObject:new（）
{
containedObject=新的MyObject（）；
}
}
public void callMethod（Func MyMethod）
{
//包装代码在这里
containedObject.MyMethod；
//包装代码在这里
}
}

目标是任何对象类型都可以传递给my

MyWrapper

，对该对象的调用只能通过

callMethod

完成，目标是在

MyMethod

之前和之后包装代码

我已经看到，我可以通过反射来实现这一点，但这将依赖于我将方法名作为字符串传递给MyWrapperClass，这似乎不是最好的方法

目标是编写不可知类，处理将所有方法转换为新线程的问题，然后对象将使用包装的代码阻止任何进一步的调用，直到当前方法完成

其目的是快速将任何对象转换为线程安全操作。我已经针对特定函数的每对象偏差做了这项工作，但是如果能够有一些能够进行合理的管理并且不重复代码的东西，那将是一件好事

编辑：基于评论 如何使Func（MyMethod）接受具有任意数量参数的任何方法

我不知道如何在新实例化的containedObject上调用MyMethod 对象–myMethod可以这样使用吗

给定当前示例，MyObject可以是任何对象，MyMethod可以是任何返回void的方法

我应该研究什么样的主题才能做到这一点。

---

带有代码的示例将非常有用。

这将满足您的要求，尽管我不能说一旦您拥有它，您是否仍然需要它

在现实生活中，您会在代码中添加很多空检查之类的内容

public class MyWrapperClass
{
    private Object _instance;

    public void ImportObject<T>() where T : new()
    {
        _instance = new T();
    }

    public object CallMethod(String name, object[] parameters)
    {
        var parameterTypes = parameters.Select(p => p.GetType()).ToArray();

        var methodInfo = _instance.GetType().GetMethod(name, parameterTypes);

        return methodInfo.Invoke(_instance, parameters);
    }
}

公共类MyWrapperClass
{
私有对象_实例；
public void ImportObject（），其中T:new（）
{
_实例=新的T（）；
}
公共对象调用方法（字符串名称，对象[]参数）
{
var parameterTypes=parameters.Select（p=>p.GetType（））.ToArray（）；
var methodInfo=\u instance.GetType（）.GetMethod（名称、参数类型）；
返回methodInfo.Invoke（_实例，参数）；
}
}

你似乎不想要一个泛型类，但我可能误解了你的意图，所以这里也是

public class MyGenericWrapperClass<T> where T : new()
{
    private T _instance;

    public void ImportObject()
    {
        _instance = new T();
    }

    public object CallMethod(String name, object[] parameters)
    {
        var parameterTypes = parameters.Select(p => p.GetType()).ToArray();

        var methodInfo = typeof(T).GetMethod(name, parameterTypes);

        return methodInfo.Invoke(_instance, parameters);
    }
}

公共类MyGenericWrapperClass，其中T:new（）
{
私人T_实例；
公共无效导入对象（）
{
_实例=新的T（）；
}
公共对象调用方法（字符串名称，对象[]参数）
{
var parameterTypes=parameters.Select（p=>p.GetType（））.ToArray（）；
var methodInfo=typeof（T）.GetMethod（名称、参数类型）；
返回methodInfo.Invoke（_实例，参数）；
}
}

这会满足你的要求，尽管我不能说一旦你拥有它，你是否还会想要它

在现实生活中，您会在代码中添加很多空检查之类的内容

public class MyWrapperClass
{
    private Object _instance;

    public void ImportObject<T>() where T : new()
    {
        _instance = new T();
    }

    public object CallMethod(String name, object[] parameters)
    {
        var parameterTypes = parameters.Select(p => p.GetType()).ToArray();

        var methodInfo = _instance.GetType().GetMethod(name, parameterTypes);

        return methodInfo.Invoke(_instance, parameters);
    }
}

公共类MyWrapperClass
{
私有对象_实例；
public void ImportObject（），其中T:new（）
{
_实例=新的T（）；
}
公共对象调用方法（字符串名称，对象[]参数）
{
var parameterTypes=parameters.Select（p=>p.GetType（））.ToArray（）；
var methodInfo=\u instance.GetType（）.GetMethod（名称、参数类型）；
返回methodInfo.Invoke（_实例，参数）；
}
}

你似乎不想要一个泛型类，但我可能误解了你的意图，所以这里也是

public class MyGenericWrapperClass<T> where T : new()
{
    private T _instance;

    public void ImportObject()
    {
        _instance = new T();
    }

    public object CallMethod(String name, object[] parameters)
    {
        var parameterTypes = parameters.Select(p => p.GetType()).ToArray();

        var methodInfo = typeof(T).GetMethod(name, parameterTypes);

        return methodInfo.Invoke(_instance, parameters);
    }
}

公共类MyGenericWrapperClass，其中T:new（）
{
私人T_实例；
公共无效导入对象（）
{
_实例=新的T（）；
}
公共对象调用方法（字符串名称，对象[]参数）
{
var parameterTypes=parameters.Select（p=>p.GetType（））.ToArray（）；
var methodInfo=typeof（T）.GetMethod（名称、参数类型）；
返回methodInfo.Invoke（_实例，参数）；
}
}

类似这样的东西

public class Wrapped<T> where T : new()
{
    private T _instance;

    public void New()
    {
        _instance = new T();
    }

    public void Import(T t)
    {
        _instance = t;
    }

    public S Call<S>(Func<T, S> method)
    {
        //do something before
        var result = method(_instance);
        //do something after

        return result;
    }

    public void Call(Action<T> method)
    {
        //do something before
        method(_instance);
        //do something after
    }
}

Wrapped<StringBuilder> wrap = new Wrapped<StringBuilder>();
wrap.New();
wrap.Call(s => s.Append("WAT"));
wrap.Call(s => s.CopyTo(1, new char[] { 'c' }, 1, 1));

public类包装，其中T:new（）
{
私人T_实例；
新公共图书馆
{
_实例=新的T（）；
}
公共无效导入（T）
{
_实例=t；
}
公共S调用（Func方法）
{
//做某事之前
var结果=方法（_实例）；
//事后做某事
返回结果；
}
公共作废调用（操作方法）
{
//做某事之前
方法（_实例）；
//事后做某事
}
}

这样叫

public class Wrapped<T> where T : new()
{
    private T _instance;

    public void New()
    {
        _instance = new T();
    }

    public void Import(T t)
    {
        _instance = t;
    }

    public S Call<S>(Func<T, S> method)
    {
        //do something before
        var result = method(_instance);
        //do something after

        return result;
    }

    public void Call(Action<T> method)
    {
        //do something before
        method(_instance);
        //do something after
    }
}

Wrapped<StringBuilder> wrap = new Wrapped<StringBuilder>();
wrap.New();
wrap.Call(s => s.Append("WAT"));
wrap.Call(s => s.CopyTo(1, new char[] { 'c' }, 1, 1));

Wrapped-wrapp=new-Wrapped（）；
wrap.New（）；
wrap.Call（s=>s.Append（“WAT”））；
调用（s=>s.CopyTo（1，newchar[]{'c'}，1，1））；

类似这样的东西

public class Wrapped<T> where T : new()
{
    private T _instance;

    public void New()
    {
        _instance = new T();
    }

    public void Import(T t)
    {
        _instance = t;
    }

    public S Call<S>(Func<T, S> method)
    {
        //do something before
        var result = method(_instance);
        //do something after

        return result;
    }

    public void Call(Action<T> method)
    {
        //do something before
        method(_instance);
        //do something after
    }
}

Wrapped<StringBuilder> wrap = new Wrapped<StringBuilder>();
wrap.New();
wrap.Call(s => s.Append("WAT"));
wrap.Call(s => s.CopyTo(1, new char[] { 'c' }, 1, 1));

public类包装，其中T:new（）
{
私人T_实例；
新公共图书馆
{
_实例=新的T（）；
}
公共无效导入（T）
{
_实例=t；
}
公共S调用（Func方法）
{
//做某事之前
var结果=方法（_实例）；
//事后做某事
返回结果；
}
公共作废调用（操作方法）
{
//做某事之前
方法（_实例）；
//事后做某事
}
}

这样叫

public class Wrapped<T> where T : new()
{
    private T _instance;

    public void New()
    {
        _instance = new T();
    }

    public void Import(T t)
    {
        _instance = t;
    }

    public S Call<S>(Func<T, S> method)
    {
        //do something before
        var result = method(_instance);
        //do something after

        return result;
    }

    public void Call(Action<T> method)
    {
        //do something before
        method(_instance);
        //do something after
    }
}

Wrapped<StringBuilder> wrap = new Wrapped<StringBuilder>();
wrap.New();
wrap.Call(s => s.Append("WAT"));
wrap.Call(s => s.CopyTo(1, new char[] { 'c' }, 1, 1));

Wrapped-wrapp=new-Wrapped（）；
wrap.New（）；
wrap.Call（s=>s.Append（“WAT”））；
调用（s=>s.CopyTo（1，newchar[]{'c'}，1，1））；

按照您的示例，如果我理解正确，这就足够了：

public class Example
{
    public int Execute(int Param){ return Param + 1; }
}

public static ThreadSafeWrapper
{
    public static int ExecuteSafe(object Instance, Func<int, int> Function, int Param)
    {
        lock(Instance)
            return Function(Param);
    }
}

---

按照你的例子，如果我理解正确，这就足够了：

public class Example
{
    public int Execute(int Param){ return Param + 1; }
}

public static ThreadSafeWrapper
{
    public static int ExecuteSafe(object Instance, Func<int, int> Function, int Param)
    {
        lock(Instance)
            return Function(Param);
    }
}

---

我希望您的函数被声明为

1是使用
的扩展类，其中T:class