我有一个方法(fyi,我正在使用c#),接受一个类型为"Func"的参数,让我们说它是这样定义的:
MethodAcceptingFuncParam(Func<bool> thefunction);
我已经定义了要传递的函数:
public bool DoStuff()
{
return true;
}
我可以很容易地称之为:
MethodAcceptingFuncParam(() => { return DoStuff(); });
这应该是应有的,到目前为止一切顺利.
现在,我想通过反射创建这个方法,而不是传入DoStuff()方法,并将其传递给:
Type containingType = Type.GetType("Namespace.ClassContainingDoStuff");
MethodInfo mi = containingType.GetMethod("DoStuff");
=>这个工作,我可以正确获取methodinfo.
但这就是我被困的地方:我现在想做点什么
MethodAcceptingFuncParam(() => { return mi.??? });
换句话说,我想通过反射传递方法作为MethodAcceptingFuncParam方法的Func参数的值.关于如何实现这一点的任何线索？
我最近一直在玩代理Func<T, TResult>并创建返回Func<T, TResult>包含lambda的不同实例的方法,但我一直在努力想出的是为什么人们想要返回(甚至创建这样的实例)的任何好的现实世界观点.
在MSDN上有一个例子,它们执行以下操作......
Func<string, string> convertMethod = UppercaseString;
private static string UppercaseString(string inputString)
{
return inputString.ToUpper();
}
虽然它看起来很漂亮并且是一个有趣的概念,但我没有看到这些代码提供的优势.
那么有人可以提供他们必须使用的任何现实世界的例子,Func<T, TResult>并且一般为什么人们可能想要使用这个代表？
C# 允许您定义对委托类型的隐式转换：
class myclass
{
public static implicit operator Func<String, int>(myclass x)
{
return s => 5;
}
public static implicit operator myclass(Func<String, int> f)
{
return new myclass();
}
}
但不幸的是，我们不能使用它来使对象看起来像函数：
var xx = new myclass();
int j = xx("foo"); // error
Action<Func<String, int>> foo = arg => { };
foo(xx); // ok
有没有一种好方法可以使自己的类的对象直接在其基本实例上接受函数样式参数（参数）？有点像索引器，但用括号而不是方括号？
我已经搜索了一下类型推断,但我似乎无法将任何解决方案应用于我的特定问题.
我在构建和传递函数方面做了很多工作.在我看来,它应该能够推断出int类型.我唯一能想到的是lambda返回类型不是由类型推断算法检查的.我已经删除了不必要的逻辑以更清楚地显示问题.
Func<T> Test<T>(Func<Func<T>> func)
{
return func();
}
这编译:
Func<int> x = Test<int>(() =>
{
int i = 0;
return () => i;
});
但这会给出错误"无法根据用法推断出方法的类型参数.请尝试明确指定类型参数":
Func<int> x = Test(() =>
{
int i = 0;
return () => i;
});
我想我只想知道为什么它以这种方式工作和任何变通方法.
我如何从功能中获取身体
Func<bool> methodCall = () => output.SendToFile();
if (methodCall())
Console.WriteLine("Success!");
我需要将此"output.SendToFile()"作为字符串
另一个例子
string log = "";
public void Foo<T>(Func<T> func)
{
try
{
var t = func();
}
catch (Exception)
{
//here I need to add the body of the lambda
// log += func.body;
}
}
public void Test()
{
var a = 5;
var b = 6;
Foo(() => a > b);
}
我有许多不同的函数,它们都有类似于这个的简单printf语句__func__:
printf("%s - hello world!", __func__);
现在我遇到的问题是在某些函数中它返回<unknown>而不是函数名.
这是为什么？难道我做错了什么？AFAIK __func__是其中的一部分,c99所以我不明白它为什么不像宣传的那样工作.
我在Debian中使用GCC 4.7.2.
我有这样的静态方法:
public static string MyMethod(Func<Student, object> func)
{
return ??? ;
}
我用它如下:
var s1 = MyMethod(student => student.ID); // Return "ID" ???
var s2 = MyMethod(student => student.Age); // Return "Age" ???
var s3 = MyMethod(student => student.Name); // Return "Name" ???
怎么写方法返回以下结果？
*在=>之后返回每个属性的名称作为字符串
有没有办法将现有的Func委托转换为这样的字符串:
Func<int, int> func = (i) => i*2;
string str = someMethod(func); // returns "Func<int, int> func = (i) => i*2"
或者至少接近它
所以我试图能够传递具有可变数量参数的 Func 。
就像是：
public object GetValue<T>(string name, Func<object> func) {
var result = func.DynamicInvoke();
}
当 func 的参数数量已知时，上述函数/签名效果很好。但是，当您希望参数数量在运行时之前未知时，它很快就会崩溃。
我想更改方法签名以允许以下场景，而不使用方法重载：
// No arguments
var result = GetValue("Bob", () => { return "Bob Smith"; });
// 1 argument
var result = GetValue("Joe", (i) => { return "Joe " + i.ToString(); });
// 2 arguments
var result = GetValue("Henry", (i,e) => {
return $"i: {i.ToString()}, e: {e.ToString()}";
});
现在不需要超过 2 个参数。但将来可能会需要。调用语法对我来说是最重要的。我不想让调用者投射任何内容。
我已经查看了这个问题和答案，但它们似乎都需要一些我不想使用的调用语法。
有什么想法可以实现这一点吗？
我正在寻找一种基于方法参数动态构建表达式的方法。
这是我的服务方法的代码片段，我想在其中构建谓词表达式。
public async Task<Account> GetCustomerAccountsAsync(Parameters params)
{
var items = await _unitOfWork.Accounts.GetWhereAsync(a => a.CustomerId == params.CustomerId && ... );
...
}
GetWhereAsync是通用存储库中的一种方法，如下所示：
public async Task<IEnumerable<TEntity>> GetWhereAsync(Expression<Func<TEntity, bool>> predicate)
{
return await Context.Set<TEntity>().Where(predicate).ToListAsync();
}
和参数类：
public class Parameters
{
public string CustomerId { get; set; }
public string AccountId { get; set; }
public string ProductId { get; set; }
public string CurrencyId { get; set; }
}
我想要实现的是，每个非null 的Parameter对象属性都作为条件添加到表达式谓词中。
例如，如果CustomerId和AccountId …