C# - 将未知类型的函数传递给另一个函数并调用它

发布于 2024-11-30 02:37:56 字数 52 浏览 3 评论 0原文

在我的程序中,我假设获取一个函数作为参数,并从另一个函数中调用它。可以吗?
谢谢你

In my program i'm suppose to get a function as a parameter, and call it from within another function. can it be done?
thank you

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(5

幸福丶如此 2024-12-07 02:37:57

当然,您可以只接受 Delegate 并利用 Delegate.DynamicInvokeDelegate.Method.Invoke。除非有更多信息,否则这将回答您的问题。

因此:

class Foo {
    public void M(Delegate d) {
        d.DynamicInvoke();
    }
}

Action action = () => Console.WriteLine("Hello, world!");
var foo = new Foo();
foo.M(action);

Sure, you could just take in a Delegate and utilize Delegate.DynamicInvoke or Delegate.Method.Invoke. Barring more information, this answers your question.

Thus:

class Foo {
    public void M(Delegate d) {
        d.DynamicInvoke();
    }
}

Action action = () => Console.WriteLine("Hello, world!");
var foo = new Foo();
foo.M(action);
无边思念无边月 2024-12-07 02:37:57

或者您可以使用 lambda 表达式。仍然委托,但编码速度更快。

private static void Main(string[] args)
{
    NoReturnValue((i) =>
        {
            // work here...
            Console.WriteLine(i);
        });
    var value = ReturnSometing((i) =>
        {
            // work here...
            return i > 0;
        });
}

private static void NoReturnValue(Action<int> foo)
{
    // work here to determind input to foo
    foo(0);
}

private static T ReturnSometing<T>(Func<int, T> foo)
{
    // work here to determind input to foo
    return foo(0);
}

or you can use lambda expressions. delegate still, but faster to code.

private static void Main(string[] args)
{
    NoReturnValue((i) =>
        {
            // work here...
            Console.WriteLine(i);
        });
    var value = ReturnSometing((i) =>
        {
            // work here...
            return i > 0;
        });
}

private static void NoReturnValue(Action<int> foo)
{
    // work here to determind input to foo
    foo(0);
}

private static T ReturnSometing<T>(Func<int, T> foo)
{
    // work here to determind input to foo
    return foo(0);
}
梦幻之岛 2024-12-07 02:37:57

一个例子:

Action logEntrance = () => Debug.WriteLine("Entered");
UpdateUserAccount(logEntrance);

public void UpdateUserAccount(
           IUserAccount account, 
           Action logEntrance)
{
   if (logEntrance != null)
   {
      logEntrance();
   }
}

An example:

Action logEntrance = () => Debug.WriteLine("Entered");
UpdateUserAccount(logEntrance);

public void UpdateUserAccount(
           IUserAccount account, 
           Action logEntrance)
{
   if (logEntrance != null)
   {
      logEntrance();
   }
}
享受孤独 2024-12-07 02:37:57
  • 使用 Func 使用任意函数,同时保持类型安全。

    这可以通过内置的 Func 泛型类来完成:

    给定一个具有以下签名的方法(在本例中,它接受一个 int 并返回一个 bool):

    void Foo(Funcfun);
    

    你可以这样称呼它:

    Foo(myMethod);    
    Foo(x => x > 5);  
    

    您可以将任意函数分配给 Func 实例:

    var f = new Func((x,y) => { return x/y; });
    

    您可以将 f 传递到以后可以使用的地方:

    Assert.AreEqual(2.0, f(6,3)); // ;-) 我想知道这是否有效
    

    请参阅此处 了解更多信息。

  • 当你确实不知道参数,但你愿意支付运行时调查它们的成本时,请使用反射。

    此处了解此内容 。您将传递 MemberInfo 的实例。您可以查询其参数来动态发现它们的数量和类型。

  • 使用动态以获得完全的自由。没有类型安全。

    在 C# 4.0 中,您现在拥有 dynamic 关键字。

    public void foo(dynamic f) {
      f.Hello();
    }
    
    公共类 Foo {
      公共无效Hello(){Console.WriteLine(“Hello World”);}
    }
    
    [测试]
    公共无效测试动态(){
      动态 d = new Foo();
      食物);
    }
    

    请在此处查看更多信息。

  • Use Func to use arbitrary functions while preserving type safety.

    This can be done with the built-in Func generic class:

    Given a method with the following signature (in this case, it takes an int and returns a bool):

    void Foo(Func<int, bool> fun);
    

    You can call it like this:

    Foo(myMethod);    
    Foo(x => x > 5);  
    

    You can assign arbitrary functions to a Func instance:

    var f = new Func<int, int, double>((x,y) => { return x/y; });
    

    And you can pass that f around where it can be used later:

    Assert.AreEqual(2.0, f(6,3));  // ;-) I wonder if that works
    

    See here for more information.

  • Use Reflection when you really don't know the parameters, but you are willing to pay the cost to investigate them at run time.

    Read about this here. You will be passing around instances of MemberInfo. You can query its parameters to dynamically discover their number and type.

  • use dynamic for complete freedom. There is no type safety.

    And in C# 4.0, you now have the dynamic keyword.

    public void foo(dynamic f) {
      f.Hello();
    }
    
    public class Foo {
      public void Hello() { Console.WriteLine("Hello World");}
    }
    
    [Test]
    public void TestDynamic() {
      dynamic d = new Foo();
      foo(d);
    }
    

    See more on this here.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文