小编dan*_*dan的帖子

Visual Studio会记住以前调试会话中的断点,这很棒.

但是,当我正在调试时,我通过点击它来清除其中一个"旧"断点,它只是暂时删除.我的意思是下次调试时,我认为我删除的断点又回来了.

这是非常烦人的 - 有没有设置让它不这样做？

我对如何使用条件Continuations的任务感到困惑.

如果我有一个任务,然后我想继续处理成功和错误的任务,然后等待那些完成.

void FunctionThrows() {throw new Exception("faulted");}

static void MyTest()
{

    var taskThrows = Task.Factory.StartNew(() => FunctionThrows());

    var onSuccess = taskThrows.ContinueWith(
                          prev => Console.WriteLine("success"), 
                          TaskContinuationOptions.OnlyOnRanToCompleted);

    var onError = taskThrows.ContinueWith(
                          prev => Console.WriteLine(prev.Exception),
                          TaskContinuationOptions.OnlyOnFaulted);

    //so far, so good



    //this throws because onSuccess was cancelled before it was started
    Task.WaitAll(onSuccess, onError);
}

这是执行任务成功/失败分支的首选方式吗？另外,我应该如何加入所有这些任务,假设我已经创建了一长串的延续,每个延续都有自己的错误处理.

  //for example
  var task1 = Task.Factory.StartNew(() => ...)
  var task1Error = task1.ContinueWith(  //on faulted
  var task2  = task1.ContinueWith(      //on success
  var task2Error = task2.ContinueWith(  //on faulted
  var task3 = …

我有一些用c#编写的执行并发代码的东西,大量使用任务并行库(Task and Future continuation chains).

我现在将其移植到F#,并试图找出使用F#Async工作流与TPL中的构造的优缺点.我倾向于TPL,但我认为无论哪种方式都可以.

有没有人有关于在F#中编写并发程序的提示和智慧？

有没有办法在解决方案中自动查找所有未使用的公共函数？我有resharper,现在我必须在每个符号上做一个"查找用法",这很乏味 - 似乎应该有一个更好的方法

我最近在我的.NET应用程序(asp.net网站)中有一个堆栈溢出异常,我知道因为它出现在我的EventLog中.我知道无法捕获或处理StackOverflow异常,但有没有办法在它杀死你的应用程序之前记录它？我有100k行代码.如果我知道堆栈跟踪,或者只是堆栈跟踪的一部分,我可以追踪无限循环/递归的来源.但是没有任何有用的诊断信息,看起来它需要进行大量的猜测和测试.

我想在我的应用程序域(在Global.asax中)建立一个未处理的异常处理,但似乎并没有执行,这是有道理的,如果一个堆栈溢出应该终止,不能运行任何catch/finally块.

有没有办法记录这些,或者是否有一些我可以启用的秘密设置,当应用程序崩溃时将堆栈帧保存到磁盘？

我认为命名参数很好,但我认为缺点是它们会给函数调用增加一些视觉噪音.我希望Visual Studio将它们涂成浅灰色(ReSharper渲染死代码的方式),以便强调实际的参数值.

现在看起来有点像这样(一切都是黑色的):

LaunchThings(飞机:真,船:假,火箭:真,核武器:假);

我希望它看起来像这样:

LaunchThings(飞机:真,船:假,火箭:真,核武器:假);

你可以使用部分应用的运算符传递"除以2"或"减1"等操作,其中"加1"如下所示:

List.map ((+) 1) [1..5];;  //equals [2..6]
// instead of having to write: List.map (fun x-> x+1) [1..5]

正在发生的事情是1被应用于(+)作为它的第一个参数,并且列表项被应用为第二个参数.对于加法和乘法,这个参数排序无关紧要.

假设我想从每个元素中减去1(这可能是常见的初学者错误):

List.map ((-) 1) [1..5];;  //equals [0 .. -4], the opposite of what we wanted

1被应用于( - )作为它的第一个参数,所以不是(list_item - 1),我得到(1 - list_item).我可以将其重写为添加负数而不是减去正数:

List.map ((+) -1) [1..5];;
List.map (fun x -> x-1) [1..5];; // this works too

我正在寻找一种更具表现力的方式来编写它,例如((-) _ 1),where _表示占位符,就像在Arc语言中一样.这将导致1成为第二个参数-,因此在List.map中,它将评估为list_item - 1.所以如果你想映射divide by 2到列表,你可以写:

List.map ((/) …

我正在努力使BinaryFormatter我的装配的不同版本的工作.我希望反序列化的实际类在每个程序集版本中完全相同,但在反序列化时,因为序列化对象包括它们来自的程序集名称,所以BinaryFormatter抱怨它无法找到正确的程序集.所以我创建了一个自定义SerializationBinder,告诉它BinaryFormatter始终反序列化到当前的程序集版本.

我的方案工作正常,可以反序列化对象,但如果我的对象是一个T列表,它不起作用,其中T是从我的程序集的旧版本序列化的类型.

是否有一些方法可以使用Lists和其他泛型类型,其中type参数是我的程序集中的类？

//the object i want to deserialize
class MyObject
{
     public string Name{get;set;}
}

//my binder class
class MyBinder : SerializationBinder
{
    static string assemblyToUse = typeof (MyObject).Assembly.FullName;
    public override Type BindToType(string assemblyName, string typeName)
    {
        var isMyAssembly = assemblyName.StartsWith("oldAssemblyName");
        var assemblyNameToUse = isMyAssembly ? assemblyToUse : assemblyName;
        var tn = typeName + ", " + assemblyNameToUse;
        return Type.GetType(tn);            
    }
}


//my deserialize method
static object BinaryDeserialize(string input)
{
    var …

添加是否会with (Nolock)在从临时表中进行选择时减少争用,或者SQL Server是否足够智能,以便首先不在临时表上创建争用？

PS:是的我知道READUNCOMMITTED的危险.

select * from #myTempTable

VS

select * from #myTempTable with (nolock) --is this faster?

我得到了这个异常
读取锁定被释放而没有被释放.
在System.Threading.ReaderWriterLockSlim.ExitReadLock()at .. GetBreed(String)

下面是访问锁的代码中唯一的位置.如您所见,没有递归.我无法理解如何发生此异常.

static readonly Dictionary<string, BreedOfDog> Breeds 
     = new Dictionary<string,BreedOfDog>();

static BreedOfDog GetBreed(string name)
{
        try
        {
            rwLock.EnterReadLock();
            BreedOfDog bd;
            if (Breeds.TryGetValue(name, out bd))
            {
                return bd;
            }
        }
        finally
        {
            rwLock.ExitReadLock();
        }

        try
        {
            rwLock.EnterWriteLock();
            BreedOfDog bd;
            //make sure it hasn't been added in the interim
            if (Breeds.TryGetValue(t, out bd)
            {
                return bd;
            }
            bd = new BreedOfDog(name); //expensive to fetch all the data needed to run  the constructor, hence the caching

            Breeds[name] = bd; …