小编JSB*_*ոգչ的帖子

偶尔(通常在源代码管理中更新我的.sln文件后)我得到一个奇怪的Visual Studio错误,其中我无法打开我的一些文件.有问题的文件显示在相应的项目中,但尝试打开它们会导致出现错误对话框,说"该文件的文件已经打开".

这几乎与为什么说"已在解决方案中打开了具有该名称的项目"相同？,除了文件,而不是项目.给出的解决方案并没有解决这个问题.

我的函数的参数f()必须实现两个不同的接口,这些接口通过继承彼此无关,IFoo并且IBar.我知道有两种不同的做法.第一种是声明一个从两者继承的空接口:

public interface IFooBar : IFoo, IBar
{
    // nothing to see here
}

public int f(IFooBar arg)
{
    // etc.
}

这,当然,要求班宣布自己执行IFooBar,而不是IFoo和IBar独立.

第二种方法是f()使用约束制作泛型:

public int f<T>(T arg) where T : IFoo, IBar
{
    // etc.
}

您更喜欢哪一个,为什么？每个都有任何非明显的优点或缺点吗？

我写了一个简单的程序,使用信号量解决了Readers-Writers问题.它在Linux操作系统上完美运行,但是当我在我的Mac OSX上运行时,我得到了意想不到的结果,我无法弄清楚原因.

我的计划:

#include <semaphore.h>
#include <sys/types.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void* function1(void* val);
void* function2(void* val);

// shared values
volatile int X;
volatile int Y;

// declare semaphores
sem_t s1;
sem_t s2;

main()
{
void* status;

pthread_t thread1;
pthread_t thread2;
srand(time(NULL));

// initialize semaphores to zero
sem_init(&s1, 0, 0);
sem_init(&s2, 0, 0);

pthread_create(&thread1, NULL, function1, NULL);
pthread_create(&thread2, NULL, function2, NULL);

pthread_join(thread1, &status);
pthread_join(thread2, &status);

sem_destroy(&s1);
sem_destroy(&s2);

}

void* function1(void* val)
{
   while(1)
   {
   X = rand()%1000; // …

当使用极短寿命的对象时,我只需要调用一个方法,我倾向于将方法调用直接链接到new.一个非常常见的例子如下:

string noNewlines = new Regex("\\n+").Replace(" ", oldString);

这里的要点是,Regex在我完成一次替换后,我不需要对象,我希望能够将其表达为单行.这个成语有什么不明显的问题吗？我的一些同事对此表示不满,但没有任何看起来像是一个很好的理由.

(我把它标记为C#和Java,因为上面的习语很常用,并且可以在两种语言中使用.)

通过学习Haskell for Great Good,在关于高阶函数的章节中,作者将介绍几个不同库函数的实现.当filter'谈到(标准库函数的重新实现)的定义时filter,我认为显而易见的是:

filter' f xs = [x | x <- xs, f x]

但是作者给出了以下更长的递归定义:

filter' _ [] = []  
filter' p (x:xs)   
    | p x       = x : filter' p xs  
    | otherwise = filter' p xs

两个定义都做同样的事情.这有什么理由吗？递归定义在某种程度上更高效吗？对于Haskell来说,它更具惯用性吗？别的什么？

(这不是我所遇到的问题,但它是同构的,我认为这种解释对其他人来说是最容易理解的.)

假设我在n维空间中有一组点.使用3个维度,例如:

A : [1,2,3]
B : [4,5,6]
C : [7,8,9]

我还有一组向量来描述这个空间中可能的运动:

V1 : [+1,0,-1]
V2 : [+2,0,0]

现在,给定一个点dest,我需要找到一个起点p和一组向量移动,它将以最有效的方式将我带到dest.效率定义为"最少的动作",不一定是"至少直线距离":它允许选择一个p进一步的从DEST比其他候选人,如果此举集是这样,你可以在更少的移动那里.移动中的向量必须是可用向量的严格子集; 除非在输入集中出现多次,否则不能多次使用同一个向量.

我的输入包含~100个起点和~10个矢量,我的维数是~20.起点和可用矢量将在应用程序的生命周期内得到修复,但我会找到许多不同目标点的路径.我想优化速度,而不是内存.算法失败(找不到dest的可能路径)是可以接受的.

更新w/Accepted Solution

我采用的解决方案非常类似于下面标记为"已接受"的解决方案.我遍历所有点和向量,并构建一个包含所有可到达点的列表以及到达它们的路径.我将此列表转换为< dest,p + vectors > 的哈希值,为每个目标点选择最短的向量集.(对于散列大小也有一点优化,这在这里不相关.)后续的dest查找在恒定时间内发生.

我有一个方法应该返回当前状态的快照,另一个方法是恢复该状态.

public class MachineModel
{
    public Snapshot CurrentSnapshot { get; }
    public void RestoreSnapshot (Snapshot saved) { /* etc */ };
}

状态Snapshot类对调用者应该是完全不透明的 - 没有可见的方法或属性 - 但是它的属性必须在MachineModel类中可见.我显然可以通过向下转换来做到这一点,即CurrentSnapshot返回一个object,并RestoreSnapshot接受一个object它回归到一个参数Snapshot.

但这样的强迫铸造让我觉得很脏.什么是最好的替代设计,允许我既是类型安全的又是不透明的？

更新解决方案:

我结束了接受的答案和关于接口的建议.该Snapshot班是由一个公共抽象类,里面的私人执行MachineModel:

public class MachineModel
{
    public abstract class Snapshot
    {
        protected internal Snapshot() {}
        abstract internal void Restore(MachineModel model);
    }

    private class SnapshotImpl : Snapshot
    {
        /* etc */
    }

    public void …

允许以下内容的目的是什么？

class A<T> where T : IFoo {
    private T t;
    A(T t) { this.t = t; }
    /* etc */
}

这与仅仅声明A需要一个IFoo需要它的地方有什么不同？

class A {
    private IFoo foo;
    A(IFoo foo) { this.foo = foo; }
    /* etc */
}

我能看到的唯一区别是,在第一种情况下,我保证都认为A<T>将始终与一个实例化T实现IFoo 和所有对象的A将是相同的基本类型.但对于我的生活,我无法弄清楚为什么我需要这样的约束.

我在今天工作的代码库中遇到了一个模式,最初看起来非常聪明,后来让我疯了,现在我想知道是否有办法拯救聪明的部分,同时尽量减少疯狂.

我们有一堆实现的对象IContractObject,以及一个如下所示的类InvariantChecker:

internal class InvariantChecker : IDisposable
{
    private IContractObject obj;

    public InvariantChecker(IContractObject obj)
    {
        this.obj = obj;
    }

    public void Dispose()
    {
        if (!obj.CheckInvariants())
        {
            throw new ContractViolatedException();
        }
    }
}

internal class Foo : IContractObject
{
    private int DoWork()
    {
        using (new InvariantChecker(this))
        {
            // do some stuff
        }
        // when the Dispose() method is called here, we'll throw if the work we
        // did invalidated our state somehow
    }
}

这用于提供状态一致性的相对无痛的运行时验证.我没有写这个,但它最初似乎是一个非常酷的主意.

但是,如果Foo.DoWork …

我目前正在查看日期和日期时间对象的msdn页面.我也打开了反射器,看起来日期和日期时间对象只是引用了日期结构.为什么我们有两个引用相同结构的对象？它们之间有什么区别？