小编myt*_*thz的帖子

如何使用自定义功能工具扩展Swift Array<T>或T[]类型？

浏览Swift的API文档显示,Array方法是其扩展T[],例如:

extension T[] : ArrayType {
    //...
    init()

    var count: Int { get }

    var capacity: Int { get }

    var isEmpty: Bool { get }

    func copy() -> T[]
}

复制和粘贴相同的源并尝试任何变化时,例如:

extension T[] : ArrayType {
    func foo(){}
}

extension T[] {
    func foo(){}
}

它无法构建错误:

标称类型T[]不能扩展

使用完整类型定义失败Use of undefined type 'T',即:

extension Array<T> {
    func foo(){}
}

而且它也失败,Array<T : Any>和Array<String>.

好奇Swift让我扩展一个无类型数组:

extension Array …

如何修改字符串插值中显示的文本输出？

该Printable协议看起来最明显,但在字符串插值和打印实例时都被忽略,例如:

struct Point : Printable
{
    var x = 0
    var y = 0

    var description : String {
        return "(\(x), \(y))"
    }

    func toString() -> String {
        return description
    }
}

同样,该toString()公约也没有任何效果:

var p = Point(x: 10, y: 20)

println(p)                   // V11lldb_expr_05Point (has 2 children)
println("\(p)")              // V11lldb_expr_05Point (has 2 children)
println(p.description)       // (10, 20)
println("\(p.description)")  // (10, 20)

PlayGround中的行为再次不同,它使用自己的String表示结构,即:

p // {x 10, y 20}

有没有办法可以改变实例的显示方式？

给定一个包含[Any]可选值和非可选值的数组,例如:

let int:Int? = 1
let str:String? = "foo"

let values:[Any] = [int,2,str,"bar"]

我们怎样才能提取的值Optional的Any类型(如果有的话),所以我们可以创建一个通用的打印功能,仅打印出的值.

例如,这个printArray函数遍历并打印每个元素:

func printArray(values:[Any]) {
    for i in 0..<values.count {
        println("value[\(i)] = \(values[i])")
    }
}

printArray(values)

哪个会输出:

value[0] = Optional(1)
value[1] = 2
value[2] = Optional("foo")
value[3] = bar

我们如何更改它以便它只打印基础值,以便在可选时将其展开值？例如:

value[0] = 1
value[1] = 2
value[2] = foo
value[3] = bar

更新进度......

更改参数时它可以工作[Any?],例如:

let values:[Any?] = [int,2,str,"bar"]

func printArray(values:[Any?]) {
    for i in 0..<values.count {
        println("value[\(i)] = \(values[i]!)") …

在ServiceStack网站上列出,它表明ServiceStack可以在Mono上运行:

• XSP
• 是mod_mono
• FASTCGI
• 安慰

这些不同的配置是什么,哪些是Mono上的Web服务的首选？

Swift允许您创建一个数组扩展,它将Integer与:

extension Array {
    func sum() -> Int {
        return self.map { $0 as Int }.reduce(0) { $0 + $1 }
    }
}

现在可以用来总结Int[]如下:

[1,2,3].sum() //6

但是我们如何制作一个支持对其他数字类型求和的通用版本Double[]呢？

[1.1,2.1,3.1].sum() //fails

这个问题不是如何对数字求和,而是如何创建一个通用的数组扩展来实现它.

越来越近

如果能帮助任何人更接近解决方案,这是我能够获得的最接近的:

您可以创建一个可以满足我们需要的协议,即:

protocol Addable {
    func +(lhs: Self, rhs: Self) -> Self
    init()
}

然后扩展我们想要支持的每种类型,以符合上述协议:

extension Int : Addable {
}

extension Double : Addable {
}

然后添加具有该约束的扩展:

extension Array {
    func sum<T : Addable>(min:T) -> T
    {
        return self.map { …

是否有投一个更快的方法Fun<TEntity, TId>来Func<TEntity, object>

public static class StaticAccessors<TEntity>
{
 public static Func<TEntity, TId> TypedGetPropertyFn<TId>(PropertyInfo pi)
 {
  var mi = pi.GetGetMethod();
  return (Func<TEntity, TId>)Delegate.CreateDelegate(typeof(Func<TEntity, TId>), mi);
 }

 public static Func<TEntity, object> ValueUnTypedGetPropertyTypeFn(PropertyInfo pi)
 {
  var mi = typeof(StaticAccessors<TEntity>).GetMethod("TypedGetPropertyFn");
  var genericMi = mi.MakeGenericMethod(pi.PropertyType);
  var typedGetPropertyFn = (Delegate)genericMi.Invoke(null, new[] { pi });

  //slow: lambda includes a reflection call
  return x => typedGetPropertyFn.Method.Invoke(x, new object[] { }); //can we replace this?
 }
}

有没有办法在返回的lambda中转换typedGetPropertyFn为Func<TEntity, object>没有反射代码,如上例所示？

编辑:添加修改后的解决方案

好的,感谢280Z28引导我沿着正确的道路前进,我已经将其包含在下面的最终解决方案中.我已将反射代码留在那里,用于不支持表达式的平台.对于这样做的平台来说,它可以获得26x …

我目前正在研究是使用非托管C/C++还是在.NET中构建一个Windows应用程序,并想了解使用托管C#/ .NET GUI应用程序的性能和响应能力？

毫不奇怪,看起来最快响应最快的应用程序(例如chrome,spotify等)是用非托管C/C++编写的.我很难找到真正优秀的.NET应用程序的例子,所以我想要一些帮助.

快速响应的.NET Windows应用程序的最佳示例是什么？

Swift操场或控制台应用程序中的以下代码:

let letters = ["A", "B", "C"]

letters.filter({
    (x : String) -> Bool in
    println("PRINT: \(x)")
    return true
})

打印出来:

PRINT: A
PRINT: B
PRINT: C
PRINT: A
PRINT: B
PRINT: C

为什么它会两次迭代集合？

我正在尝试通过将一些C#算法重写为惯用的F#来学习F#.

我正在尝试重写的第一个函数之一是batchesOf,其中:

[1..17] |> batchesOf 5

哪个会将序列分成多个批次,每个最多五个,即:

[[1; 2; 3; 4; 5]; [6; 7; 8; 9; 10]; [11; 12; 13; 14; 15]; [16; 17]]

我第一次尝试这样做有点丑陋,我在尝试在闭包内部使用可变类型时遇到错误而使用了一个可变的ref对象.使用ref特别不愉快,因为要取消引用它你必须使用!在一个条件表达式内部的操作符可以与某些开发人员相反直观,这些开发人员将其视为逻辑不符合.我遇到的另一个问题是Seq.skip和Seq.take与他们的Linq别名不同,如果大小超过序列的大小,他们将抛出错误.

let batchesOf size (sequence: _ seq) : _ list seq =
    seq {
        let s = ref sequence
        while not (!s |> Seq.isEmpty)  do
            yield !s |> Seq.truncate size |> List.ofSeq
            s := System.Linq.Enumerable.Skip(!s, size)
    }

无论如何,在F#中重写这个最优雅/惯用的方法是什么？保持原始行为但最好没有ref可变变量.

需要ResponseStatus吗？

维基说我们需要在响应DTO中有一个ResponseStatus属性来处理异常序列化:

https://github.com/ServiceStack/ServiceStack/wiki/Validation

但是,即使响应DTO中没有ResponseStatus属性,它看起来也会自动生成ResponseStatus.

我们需要ResponseStatus属性吗？