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

时间:2017-04-27 18:42:29

标签: c# multithreading reflection

我目前正在尝试编写一个为传递给它的任何类执行EXECUTE-AROUND模式的类。

使用像这样的粗略伪代码:

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
    }
}

目标是任何对象类型都可以传递给我MyWrapper对此对象的调用只能通过via callMethod完成,目标是在{{1}之前和之后包装代码}。

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

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

目的 - 快速将任何对象转换为线程安全操作。我已经根据特定功能的每个对象偏差完成了这个,但是能够有一些能够进行合理数量的内务管理并且不会复制该代码的东西会很好。

编辑:基于评论 我怎样才能使Func MyMethod采用任何数量的参数方法。

我不确定如何在新实例化的containsObject上调用MyMethod 对象 - myMethod可以像这样使用吗?

鉴于当前示例,MyObject可以是任何返回void的方法的任何对象和MyMethod。

我应该研究什么样的主题才能做到这一点。 代码示例非常有用。

3 个答案:

答案 0 :(得分:3)

像这样。

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));

答案 1 :(得分:0)

这将按照你想要的做,但我不能说你是否还想要它。

在现实生活中,您需要在此代码中添加大量空值检查。

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);
    }
}

你似乎不想要一个通用课程,但我可能误读了你的意图,所以也是这样。

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);
    }
}

答案 2 :(得分:0)

按照你的例子,如果我理解正确,这应该足够了:

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);
    }
}

要使用它,请执行以下操作:

var instance = new Example();
ThreadSafeWrapper.ExecuteSafe(instance, instance.Execute, 5);