标签: func

这只是一个好奇的问题,我想知道是否有人有一个很好的答案:

在.NET Framework类库中,我们有两个方法:

public static IQueryable<TSource> Where<TSource>(
    this IQueryable<TSource> source,
    Expression<Func<TSource, bool>> predicate
)

public static IEnumerable<TSource> Where<TSource>(
    this IEnumerable<TSource> source,
    Func<TSource, bool> predicate
)

他们为什么用Func<TSource, bool>而不是Predicate<TSource>？好像Predicate<TSource>只由List<T>和Array<T>,而Func<TSource, bool>所使用的几乎所有Queryable和Enumerable方法和扩展方法...什么与怎么了？

我可以将带有out参数的方法作为Func传递吗？

public IList<Foo> FindForBar(string bar, out int count) { }

// somewhere else
public IList<T> Find(Func<string, int, List<T>> listFunction) { }

Func需要一个类型,因此不会在那里编译,并且调用listFunction需要一个int并且不允许输入.

有没有办法做到这一点？

我正在尝试编写一个基本的go程序,它调用不同文件上的函数,但是同一个软件包的一部分.但是,它返回:

undefined: NewEmployee

这是源代码:

main.go:

package main

func main() {
emp := NewEmployee()    
}

employee.go:

package main

type Employee struct {
    name string
    age int
}   

func NewEmployee() *Employee {
    p := &Employee{}
    return p
}

func PrintEmployee (p *Employee)  {
    return "Hello world!"
}

提前致谢

使用方法调用很容易从lambda转到Expression

public void GimmeExpression(Expression<Func<T>> expression)
{
    ((MemberExpression)expression.Body).Member.Name; // "DoStuff"
}

public void SomewhereElse()
{
    GimmeExpression(() => thing.DoStuff());
}

但我想将Func转换为表达式,仅在极少数情况下......

public void ContainTheDanger(Func<T> dangerousCall)
{
    try 
    {
        dangerousCall();
    }
    catch (Exception e)
    {
        // This next line does not work...
        Expression<Func<T>> DangerousExpression = dangerousCall;
        var nameOfDanger = 
            ((MemberExpression)dangerousCall.Body).Member.Name;
        throw new DangerContainer(
            "Danger manifested while " + nameOfDanger, e);
    }
}

public void SomewhereElse()
{
    ContainTheDanger(() => thing.CrossTheStreams());
}

不起作用的行给了我编译时错误Cannot implicitly convert type 'System.Func<T>' to 'System.Linq.Expressions.Expression<System.Func<T>>'.显式强制转换无法解决问题.我有一个设施可以做到这一点吗？

我想知道是否有人可以Func<int, string>通过一些明确的例子解释它是什么以及如何使用它.

我很好奇直接调用Func和使用Invoke()之间的区别.有区别吗？是第一个,语法糖,并在下面调用Invoke()？

public T DoWork<T>(Func<T> method)
{
    return (T)method.Invoke();
}

VS

public T DoWork<T>(Func<T> method)
{
    return (T)method();
}

或者我完全走错了轨道:)谢谢.

我可以找到关于Func <>和Action <>的所有示例都很简单,如下所示,您可以看到它们在技术上如何工作,但我希望看到它们用于解决以前无法解决的问题的示例中只有在一个更复杂的方式,即我知道他们是如何工作的,我可以看到他们是可以解决简洁,功能强大,所以我想了解他们在更大的意义上他们解决什么样的问题,我怎么可能会在使用它们应用程序设计.

您以什么方式(模式)使用Func <>和Action <>来解决实际问题？

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestFunc8282
{
    class Program
    {
        static void Main(string[] args)
        {
            //func with delegate
            Func<string, string> convert = delegate(string s)
            {
                return s.ToUpper();
            };

            //func with lambda
            Func<string, string> convert2 = s => s.Substring(3, 10);

            //action
            Action<int,string> recordIt = (i,title) =>
                {
                    Console.WriteLine("--- {0}:",title);
                    Console.WriteLine("Adding five to {0}:", i);
                    Console.WriteLine(i + 5);
                };

            Console.WriteLine(convert("This is the first test.")); …

今天我在考虑宣布这个:

private delegate double ChangeListAction(string param1, int number);

但为什么不用这个:

private Func<string, int, double> ChangeListAction;

或者如果ChangeListAction没有返回值,我可以使用:

private Action<string,int> ChangeListAction;

那么使用delegate关键字声明委托的优势在哪里？

是因为.NET 1.1,随着.NET 2.0的出现Action<T>和.NET 3.5的出现Func<T>？

我意识到,一般来说,使用反射会产生性能影响.(事实上​​,我自己并不是反思的粉丝;这是一个纯粹的学术问题.)

假设存在一些看起来像这样的类:

public class MyClass {
    public string GetName() {
        return "My Name";
    }
}

跟我来这儿.我知道如果我有一个MyClass被叫的实例x,我可以打电话x.GetName().此外,我可以设置一个Func<string>变量x.GetName.

现在这是我的问题.假设我不知道上面的类叫做MyClass; 我有一些对象,x但我不知道它是什么.我可以GetName通过这样做来检查该对象是否有方法:

MethodInfo getName = x.GetType().GetMethod("GetName");

假设getName不为空.然后,我不能进一步检查getName.ReturnType == typeof(string)和getName.GetParameters().Length == 0,在这一点上,我岂不是很肯定的是,在我所代表的方法,getName对象可以肯定被转换为一个Func<string>,不知何故？

我意识到有一个MethodInfo.Invoke,我也意识到我总能创造一个Func<string>像:

Func<string> getNameFunc = () => getName.Invoke(x, null);

我想我要问的是,是否有任何方法可以从一个MethodInfo对象转到它所代表的实际方法,从而在该过程中产生反射的性能成本,但 …

如何使用Swift制作随机颜色功能？

import UIKit

class ViewController: UIViewController {

    var randomNumber = arc4random_uniform(20)
    var randomColor = arc4random()

    //Color Background randomly
    func colorBackground() {

        // TODO: set a random color
        view.backgroundColor = UIColor.yellow

    }
}