小编the*_*onk的帖子

前几天我注意到这一点,说你有两个重载方法:

public void Print<T>(IEnumerable<T> items) {
    Console.WriteLine("IEnumerable T"); 
}
public void Print<T>(T item) {
    Console.WriteLine("Single T"); 
}

这段代码:

public void TestMethod() {  
    var persons = new[] { 
        new Person { Name = "Yan", Age = 28 },
        new Person { Name = "Yinan", Age = 28 } 
    };  
    Print(persons);
    Print(persons.ToList()); 
}

打印:

Single T
Single T

在这些情况下,为什么Person[]和他们相比List<Person>更好？TIEnumerable<T>

谢谢,

更新: 此外,如果你有另一个重载

public void Print<T>(List<T> items) {
    Console.WriteLine("List T");
}

Print(persons.ToList());实际上会打印List T而不是Single …

我的DataAccessLayer上有一个FindAll方法,如下所示:

public FindResult<T> FindAll<T>() where T : Entity, new()

和一个客户端代码有一个Type []数组,它需要用来迭代调用FindAll方法,如下所示:

foreach (var type in typeArray)
{    
    var result = DataAccessLayer.FindAll<type>();
    ...

但是编译器抱怨"预期的类型或命名空间"..有没有一种简单的方法来解决这个问题？我尝试过type.GetType()或typeof(type),但都没有用.

提前谢谢了!

在C#中,我可以为类型为T的泛型数组定义一个扩展方法,如下所示:

public static T GetOrDefault<T>(this T[] arr, int n)
{
    if (arr.Length > n)
    {
        return arr[n];
    }

    return default(T);
}

但对于我的生活,我无法弄清楚如何在F#中做同样的事情!我试过了type 'a array with,type array<'a> with并且type 'a[] with编译器对它们中的任何一个都不满意.

任何人都可以告诉我在F#中做到这一点的权利是什么？

当然,我可以通过掩盖阵列模块并为此轻松添加功能来实现这一点,但我真的想知道如何将其作为扩展方法!

对于其限制设置为高(例如,200个最大并发调用)的PerCall WCF服务,WCF会调出一个新实例并在线程池线程上调用该请求吗？

如果是,那么这会对允许的并发呼叫总数产生影响吗？

我问,因为我似乎没有以往任何时候都打我的服务节流配置设置并发呼叫的最大数量,而是这个数字的一​​小部分 - 高达50 100个MaxConcurrentCalls设置和160上的200个MaxConcurrentCalls设置.

谢谢,

有没有办法测试当前线程是否在对象上持有监视器锁定？即相当于Java中的Thread.holdsLock.

谢谢,

假设我有一个像这样的不可变值类型:

[Serializable]
[DataContract]
public struct MyValueType : ISerializable
{
private readonly int _x;
private readonly int _z;

public MyValueType(int x, int z)
    : this()
{
    _x = x;
    _z = z;
}

// this constructor is used for deserialization
public MyValueType(SerializationInfo info, StreamingContext text)
    : this()
{
    _x = info.GetInt32("X");
    _z = info.GetInt32("Z");
}

[DataMember(Order = 1)]
public int X
{
    get { return _x; }
}

[DataMember(Order = 2)]
public int Z
{
    get { return _z; }
} …

你如何explicit在F#中实现相应的C#运算符？是否支持？

我正在寻找一种算法,它可以采用两组整数(正数和负数),并找到每个具有相同总和的子集.

问题类似于子集求和问题,除了我正在寻找两侧的子集.

这是一个例子:

列表A {4,5,9,10,1}

清单B {21,7,-4,180}

所以这里唯一的匹配是:{10,1,4,9} <=> {21,7,-4}

有谁知道这种问题是否存在现有的算法？

到目前为止,我所拥有的唯一解决方案是蛮力方法,它尝试每个组合,但它在指数时间内执行,我不得不对要考虑的元素数量设置硬限制,以避免花费太长时间.

我能想到的唯一其他解决方案是在两个列表上运行一个阶乘并寻找那里的等式,但这仍然不是很有效,并且随着列表变大而需要指数地增长.

您可以使用哪些不同的技术在F#中创建Async <'T>的实例？

我看到Web客户端/请求和文件流有很多扩展方法,但是如果我想编写自己的异步计算提供程序,我将如何编写AsyncDoSomething同步DoSomething函数的那些版本？

我知道,你可以使用相同签名的委托来包装原有的功能,然后用Async.FromBeginEnd对BeginInvoke和EndInvoke方法:

open System

let del : Func<int> = new Func<int>(fun () -> 42)
let delAsync = async {
    let! res = Async.FromBeginEnd(del.BeginInvoke, del.EndInvoke)
    printfn "result was %d" res
}

Async.Start delAsync

但这感觉有点强迫,它似乎不是'F#方式',因为你必须使用在C#或VB中定义的代理(其中有很多System.Action和System.Func变体可供选择)因为F#代表不要支持BeginInvoke和EndInvoke方法.

有没有人有一个列表,你可以在F#中编写同步函数的异步版本的不同方法？

提前谢谢了!

在F#中考虑以下代码:

let n = 10000000
let arr = Array.init n (fun _ -> 0)

let rec buildList n acc i = if i = n then acc else buildList n (0::acc) (i + 1)
let lst = buildList n [] 0

let doNothing _ = ()
let incr x = x + 1

#time

arr |> Array.iter doNothing         // this takes 14ms
arr |> Seq.iter doNothing           // this takes 74ms

lst |> List.iter doNothing          // this takes 19ms
lst |> …