小编KCh*_*oux的帖子

我正在做一大堆代码的重构,这些代码过去常常使用一堆不断调整大小的多维数组.我创建了一个数据对象来替换2D数组,现在我正在传递一个这样的列表.

我发现了一些令我担忧的东西.假设我有一些看起来像这样的代码:

List<NCPoint> basePoints = new List<NCPoint>();

// ... snip populating basePoints with starting data

List<NCPoint> newPoints = TransformPoints(basePoints, 1, 2, 3);

public List<NCPoint> TransformPoints(List<NCPoint> points, int foo, int bar, int baz){
    foreach(NCPoint p in points){
        points.X += foo
        points.Y += bar
        points.Z += baz
    }

    return points;
}

我们的想法是保留原始点(basePoints)的列表和更新点的列表(newPoints).但是C#通过引用传递列表,就像任何对象一样.这将更新basePoints到位,所以现在都basePoints和newPoints将具有相同的数据.

目前,我正在努力制作一份传入的完整副本,List然后才能查看数据.这是确保对函数内对象的更改在函数外部没有副作用的唯一合理方法吗？是否有类似于传递对象的东西const？

我正在调整从Scala到C#的简单素数生成单行(在其博客作者的评论中提到).我想出了以下内容:

int NextPrime(int from)
{
  while(true)
  {
    n++;
    if (!Enumerable.Range(2, (int)Math.Sqrt(n) - 1).Any((i) => n % i == 0))
      return n;
  }
} 

它可以工作,返回我从运行博客中引用的代码得到的相同结果.事实上,它运作得相当快.在LinqPad中,它在大约1秒内产生了第100,000个素数.出于好奇,我重写它不Enumerable.Range()和Any():

int NextPrimeB(int from)
{
  while(true)
  {
    n++;
    bool hasFactor = false;
    for (int i = 2; i <= (int)Math.Sqrt(n); i++)
    {
        if (n % i == 0) hasFactor = true;
    }
    if (!hasFactor) return n;
  }
}

直观地说,我希望它们能够以相同的速度运行,或者甚至让后者以更快的速度运行.实际上,使用第二种方法计算相同的值(第100,000个素数)需要12秒 - 这是一个惊人的差异.

那么这里发生了什么？从根本上说,在第二种方法中会出现额外的事情,这会占用CPU周期,或者在Linq示例的背景下进行一些优化.谁知道为什么？

我试图弄清楚如何编写一个适用于任何函数的函数交换函数Traversable[_],给定一个集合和交换索引.我想出了以下内容:

def swap[A, CC <% Traversable[A]](xs: CC, i: Int, j: Int): Traversable[A] = {
  xs.slice(0, i) ++ 
    xs.slice(j, j+1) ++ 
    xs.slice(i+1, j) ++ 
    xs.slice(i, i+1) ++ 
    xs.slice(j+1, xs.size)
}

swap(List(1,2,3,4,5), 0, 4) // => List(5,2,3,4,1)

我想知道如何将它变成Traversable的隐式扩展,让我可以调用它List(1,2,3,4,5).swap(0, 4).我能得到的最接近的是:

import language.implicitConversions
class RichTraversable[A, B <% Traversable[A]](xs: B) {
  def swap(i: Int, j: Int): Traversable[A] = {
    xs.slice(0, i) ++ 
      xs.slice(j, j+1) ++ 
      xs.slice(i+1, j) ++ 
      xs.slice(i, i+1) ++ 
      xs.slice(j+1, xs.size)
  }
} 
implicit def richTraversable[A, B <% Traversable[A]](ys: …

我的代码中有一个部分需要反转矩阵.这只能合理地在方形矩阵上完成,在这种情况下是3×3方阵.我用来反转矩阵的工具一直说我的阵列不是一个正确的方块.

所以我做了一点测试:

double[,] x = new double[3, 3];

MessageBox.Show(x.GetLength(0).ToString());
MessageBox.Show(x.GetLength(1).ToString());
MessageBox.Show(x.GetLength(2).ToString());

第一个出现为"3".第二个出现为"3".第三个出现了IndexOutOfRangeException.我只是忽略了一些非常明显的东西或......这有点奇怪吗？

(注意:这是使用.Net 2.0的C#代码)

我今天第一次使用SandCastle和HelpBuilder GUI来帮助创建一些我们公开的函数和属性的API.我已经包含/// <summary> ... </summary了许多属性,我觉得他们会从额外的文档或使用示例中受益.

当我将输出文件构建到chm时,我根本没有看到摘要描述.列出了所有属性成员,但其描述为空白.我重建了这个项目,并在SandCastle中尝试了一些不同的设置,但它们仍然没有显示出来.

我有什么明显的东西可以忽略吗？SandCastle没有阅读财产摘要吗？或者摘要需要不同的关键字？

我已经开始绕过它了,而是喜欢将它用于简单的情况,在这种情况下我可以将值从一个输出管道输出到一个输入.我熟悉的一个简单的无点组合示例是:

let joinLines = foldr (++) "" . intersperse "\n"

在今天玩GHCI的时候,我想知道我是否可以撰写not和(==)复制(/=),但我真的无法推理出来.(==)取两个输入,然后not取一个.我认为这可能有效:

let ne = not . (==)

假设单个Bool输出(==)将转到not,但它不会编译,引用以下错误:

<interactive>:1:16:
    Couldn't match expected type `Bool' with actual type `a0 -> Bool'
    Expected type: a0 -> Bool
      Actual type: a0 -> a0 -> Bool
    In the second argument of `(.)', namely `(==)'
    In the expression: not . (==)

我希望我能说这对我来说意义重大,但我所得到的只是第二个被传递的论点可能(==)是为了解决问题not？任何人都可以帮我理解这种构图背后的逻辑吗？

我今天刚刚学到了一些关于Composition over Inheritance的知识.我想知道我是否应该将这个概念应用到我最近写的东西上.

我们之前有两个几乎相同的类,除了一些小的差异.它们包含一些基本的数据库访问功能,但是在不同(但相关)的对象类型上运行.所以我们之前的课程结构如下:

class BallMillDBHandler{

    public BallMillDBHandler(){ ... }

    public void InsertTool(BallMill tool) { ... }
    public BallMill QueryTool(string toolID) { ... }
    public void UpdateTool(BallMill tool) { ... }
    public void DeleteTool(string toolID) { ... }
}

class DiamondToolDBHandler{

    public DiamondToolDBHandler(){ ... }

    public void InsertTool(DiamondTool tool) { ... }
    public DiamondTool QueryTool(string toolID) { ... }
    public void UpdateTool(DiamondTool tool) { ... }
    public void DeleteTool(string toolID) { ... }
} …

我目前知道有两种方法可以在C#中使实例不可变:

方法1 - 编译时间不变性

void Foo() 
{
    // Will be serialized as metadata and inserted
    // as a literal. Only valid for compile-time constants
    const int bar = 100;
}

方法2 - 只读字段

class Baz
{
    private readonly string frob;

    public Baz()
    {    
         // Can be set once in the constructor
         // Only valid on members, not local variables
         frob = "frob";
    }
}

如果有一个实例,一旦实例化,将不会被更改,这将是一件好事.const而readonly这样做的一个小的程度,但在他们的范围是有限的.我只能const用于编译时常readonly量和成员变量.

有没有办法在初始实例化后赋予局部变量不变性(方式readonly有效,但在更一般的层面上)？

_{Scala使用var关键字执行此操作,该关键字声明了一个新的不可变值,在获取其初始值后无法重新分配:}

var …

斯卡拉的<-箭似乎有点奇怪.大多数运算符作为函数在源中的某处实现,直接或隐式地在数据类型上定义.<-另一方面,在for理解之外似乎只能使用它,它作为一个句法元素,用于表示一个新变量在monadic上下文中的绑定(via map).

这是我能想到的唯一一个实例,Scala具有一个只能在特定上下文中使用的符合运算符的语法元素,而且不是一个实际的函数.

我错了怎么<-工作？它是仅由编译器使用的特殊情况符号,还是开发人员在编写自己的代码时可以使用此行为？

例如,是否可以编写宏来进行转换

forRange (i <- 0 to 10) { print(i) } 

成

{ var i = 0; while (i <= 10) { print(i) } }

而不是它的标准map等价？据我所知,任何上下文i <- ...之外的使用for都会因引用未知值而导致异常.

作为Rust的新手,我偶然发现了两种明显有效的运行match参考类型的方法.

我已经定义了一个枚举:

enum Color {
    Red,
    Yellow,
    Green,
    Teal,
    Blue,
    Purple,
}

我想实现一个函数,该函数适用&self于此枚举实例的引用.

我可以看到两种方法来编写这样的函数:

impl Color {
    // Approach #1: Match the reference, using references in each pattern
    fn contains_red(&self) -> bool {
        match self {
            &Color::Red => true,
            &Color::Yellow => true,
            &Color::Purple => true,
            _ => false,
        }
    }

    // Approach #2: Dereference &self and match the patterns directly
    fn contains_blue(&self) -> bool {
        match *self {
            Color::Blue => true,
            Color::Teal => true,
            Color::Purple => …