标签: func

为什么这样:

Private [Function] As Func(Of Double, String) = Function(ByRef z As Double) z.ToString

给出以下错误:

嵌套函数没有与委托String)兼容的签名.

这个:

Private [Function] As Func(Of Double, String) = Function(ByVal z As Double) z.ToString

才不是？(区别是ByRef/ByVal)

而且,我怎么能实现这样的事情呢？

我正在阅读mercurial的源代码,并在commands.py中找到了这样的函数def:

def import_(ui, repo, patch1=None, *patches, **opts):
    ...

在python中,postional args必须放在关键字args之前.但这里patch1是一个关键字参数,后跟一个位置参数*patches.为什么这样好？

当S和T不同时,这有效:

public static void Fun<S, T>(Func<S, T> func)
{

}

Fun((string s) => true); //compiles, T is inferred from return type.

但,

public static void Fun<T>(Func<T, T> func)
{

}

Fun(t => true); //can't infer type.

在第一个例子中,既然T是从lambda表达式的返回类型推断出来的,那么T在第二个例子中也不能推断出来？我想它这样做,但为什么第一次T不知道,如果将第二T的Func<T, T>是已知的,毕竟T == T对不对？或者在Funcs的情况下是否有推断类型的订单？

好吧,让我设置场景:我们在代码中使用了一个函数,它接受一个函数并对其进行一些日志记录然后返回结果.看起来有点像这样.

TResponse LoggedApiCall<TResponse>(Func<BaseRequest, BaseResponse> apiCall, ...)
    where TResponse : BaseResponse;

在使用中我有以下四个对象

namespace Name.Space.Base {
    public class BaseRequest {
        ...
    }
}

namespace Name.Space.Base {
    public class BaseResponse {
        ...
    }
}

namespace Some.Other.Name.Space {
    public class Request : BaseRequest {
        ...
    }
}

namespace Name.Space {
    public class Response<TPayload> : BaseResponse {
        ...
    }
}

所以,有了这些,我正在尝试模拟LoggedApiCall(使用Moq)以支持一些单元测试.我正在编写一个泛型方法,它允许我们传入一个满足基类型约束的函数和一个也匹配匹配的响应,以创建一个在Mock上执行.Setup()的公共方法.

它看起来像这样:

protected IReturnsResult<IService> SetupLoggedApiCall<TRequest, TResponse>(
    Func<TRequest, TResponse> function,
    TResponse response
    ) 
    where TRequest : BaseRequest 
    where TResponse : BaseResponse
{
    var baseFunction = function …

我最近一直在研究功能编程,并希望将一些概念带到我的C#世界.我正在尝试编写函数来创建服务(或任何你称之为的服务),而不是创建具有可注入依赖项的类.

我想方设法通过创建一个像这样的静态方法,用两个参数和一个返回参数来部分应用一个函数(与注入依赖项具有相同的效果):

// this makes a func with a single arg from a func with two
static Func<T2, TResult> PartiallyApply<T1, T2, TResult>(
        Func<T1,T2, TResult> f, 
        T1 t1)
    {
        // use given t1 argument to create a new function
        Func<T2, TResult> map = t2 => f(t1, t2);
        return map;
    }

这工作,但我想传递一个静态方法,如下所示:

static string MakeName(string a, string b) => a + " " + b;

当我尝试连接它时,我得到错误The type arguments for method 'Program.PartiallyApply<T1, T2, TResult>(Func<T1, T2, TResult>, T1)' cannot be inferred …

我试图将我写的一些代码移动到更通用的方法.虽然方法较长,但我遇到问题的部分如下:

public static void Test()

{    
           MyObjectType[] list1 = ListMyObjectTypeMethod1();
            MyObjectType[] list2 = ListMyObjectTypeMethod2();

            List<MyObjectType> linqAblelist1 = new List<MyObjectType>(list1);
            List<MyObjectType> linqAblelist2 = new List<MyObjectType>(list2);

            IEnumerable<MyObjectType> toBeAdded = linqAblelist1.Where(x => linqAblelist2.All(y => y.Property1 != x.Property1));
            IEnumerable<MyObjectType> toBeDeleted = linqAblelist2.Where(a => linqAblelist1.All(b => b.Property1 != a.Property1));

}

我试图为MyObjectType传递一个泛型类型,但我在哪里[如何在这里设置属性？]如何在方法的参数中指定？

public static void Test<T>(T[] x, T[] y)
        {
            List<T> list1 = new List<T>(x);
            List<T> list2 = new List<T>(y);
            IEnumerable<T> toBeAdded = list1.Where(x => list2.All(y => y.[How To Set Property Here?] != x.[How To Set …

我的代码在这里有什么问题吗？我一直收到这个错误:

System.InvalidOperationException:请求消息已发送.无法多次发送相同的请求消息.

我的HttpRequestMessage在Func中,所以我想我每次传入func()时都会得到一个全新的请求.

public async Task<HttpResponseMessage> GetAsync(HttpRequestMessage request)
{
     return await RequestAsync(() => request);
}

public async Task<HttpResponseMessage> RequestAsync(Func<HttpRequestMessage> func)
{
   var response = await ProcessRequestAsync(func);

    if (response.StatusCode == HttpStatusCode.Unauthorized)   
    {
        WaitForSomeTime();
        response = await ProcessRequestAsync(func);        
    }

    return response;
}

private async Task<HttpResponseMessage> ProcessRequestAsync(Func<HttpRequestMessage> func)
{
    var client = new HttpClient();
    var response = await client.SendAsync(func()).ConfigureAwait(false);
    return response;
}

我有一个类型的变量,Func<dynamic>我试图给它一个值.如果我将它分配给返回值类型的方法(例如int),我会得到错误

'int MethodName()'的返回类型错误

但是,如果我将方法包装在lambda调用中,它可以正常工作.返回引用类型的方法似乎也可以正常工作.

private string Test()
{
    return "";
}

private int Test2()
{
    return 0;
}

Func<dynamic> f = Test;           // Works
Func<dynamic> g = Test2;          // Does not
Func<dynamic> h = () => Test2();  // Works

直接转让案有什么问题？

我读了很多类似的帖子和博客

ASP.NET MVC中基于代理的强类型URL生成

但他们中没有一个人真的做我想做的事.目前我有一个混合方法,如:

// shortened for Brevity
public static Exts
{  
  public string Action(this UrlHelper url, 
    Expression<Func<T, ActionResult>> expression)
    where T : ControllerBase
  {
    return Exts.Action(url, expression, null);
  }

  public string Action(this UrlHelper url, 
    Expression<Func<T, ActionResult>> expression,
    object routeValues)
    where T : ControllerBase
  {
    string controller;
    string action;

    // extension method 
    expression.GetControllerAndAction(out controller, out action);

    var result = url.Action(action, controller, routeValues);

    return result;
  }
}

如果你的控制器方法没有任何参数,那么效果很好:

public class MyController : Controller 
{
  public ActionResult MyMethod()
  {
    return null;
  } …

我正在研究动态实例化类的自动化.

我决定写一个表达式树,它会生成一个Func,可以为我实例化我的类.但是,我注意到我的性能降低了3倍Func,而不是简单地使用new.

根据我对表达树和调用函数的了解,性能差异应该几乎不存在(可能是20-30%,但远不及慢3倍)

首先,这是我正在构建的表达式

public Expression<Func<A1, T>> BuildLambda<T, A1>(string param1Name)
    {
        var createdType = typeof(T);

        var param = Expression.Parameter(typeof(A1), param1Name);
        var ctor = Expression.New(createdType);
        var prop = createdType.GetProperty(param1Name);

        var displayValueAssignment = Expression.Bind(prop, param);
        var memberInit = Expression.MemberInit(ctor, displayValueAssignment);

        return
            Expression.Lambda<Func<A1, T>>(memberInit, param);
    }

然后我继续编译它(我只做一次)

var c1 = mapper.BuildLambda<Class1, int>("Id").Compile();

然后我像这样调用我的Func

var result = c1.Invoke(5);

当我把这最后一部分放在一个循环中并将它与类似的东西进行比较时

var result = new Class1() { Id = 5 };

我做了几个测试,比较两者的性能,这就是我最终得到的结果:

100,000    Iterations - new: 0ms.   | Func 2ms. …