小编Sti*_*tig的帖子

任何人都可以解释为什么这个finally块没有被执行？我已经阅读了关于何时期望最终阻止不被执行的帖子,但这似乎是另一种情况.此代码需要TopShelf和log4net.我正在运行.net 4.5

我想它必须是Windows服务引擎启动未处理的异常,但为什么它在finally块完成之前运行？

using log4net;
using log4net.Config;
using System;
using System.Threading;
using Topshelf;

namespace ConsoleApplication1
{
    public class HostMain
    {
        static void Main(string[] args)
        {
            HostFactory.Run(x =>
            {
                x.Service<HostMain>(s =>
                {
                    s.ConstructUsing(name => new HostMain());
                    s.WhenStarted(tc => tc.Start());
                    s.WhenStopped(tc => tc.Stop());
                });

                x.RunAsLocalSystem();
                x.SetServiceName("TimerTest");
            });
        }

        public void Stop()
        {
            LogManager.GetLogger("MyLog").Info("stopping");
        }

        public void Start()
        {
            XmlConfigurator.Configure();

            LogManager.GetLogger("MyLog").Info("starting");

            new Thread(StartServiceCode).Start();
        }

        public void StartServiceCode()
        {
            try
            {
                LogManager.GetLogger("MyLog").Info("throwing");

                throw new ApplicationException();
            }
            finally
            {
                LogManager.GetLogger("MyLog").Info("finally");
            }
        }
    }
}

输出 …

我正在使用SHA-1来检测程序处理文件中的重复项.它不需要加密强大并且可以是可逆的.我找到了这个快速哈希函数列表https://code.google.com/p/xxhash/

如果我想在SHA-1附近的随机数据上获得更快的功能和冲突,我该选择什么？

也许128位哈希足以用于文件重复数据删除？(vs 160 bit sha-1)

在我的程序中,哈希是在0到512 KB的块上计算的.

如果我将文件中的字节读入byte [],我发现当数组大约1 MB而不是128 KB时,FileInputStream的性能会更差.在我测试的2个工作站上,它几乎是128 KB的两倍.这是为什么？

import java.io.*;

public class ReadFileInChuncks 
{
    public static void main(String[] args) throws IOException 
    {
        byte[] buffer1 = new byte[1024*128];
        byte[] buffer2 = new byte[1024*1024];

        String path = "some 1 gb big file";

        readFileInChuncks(path, buffer1, false);

        readFileInChuncks(path, buffer1, true);
        readFileInChuncks(path, buffer2, true);
        readFileInChuncks(path, buffer1, true);
        readFileInChuncks(path, buffer2, true);
    }

    public static void readFileInChuncks(String path, byte[] buffer, boolean report) throws IOException
    {
        long t = System.currentTimeMillis();

        InputStream is = new FileInputStream(path);
        while ((readToArray(is, buffer)) != 0) {} …

检测文件是否已更改时,使用File Last Modified(例如NTFS)是否安全？如果没有,文件备份应用程序是否总是散列整个文件以检查更改？如果是这样,什么哈希算法适合这种检查？

这是为什么？

这不是关于using关键字的问题.

谁能解释为什么这个例子是没有volatile的线程安全的？

http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

实际上,假设computeHashCode函数总是返回相同的结果并且没有副作用(即幂等),您甚至可以摆脱所有的同步.

// Lazy initialization 32-bit primitives
// Thread-safe if computeHashCode is idempotent
class Foo { 
  private int cachedHashCode = 0;
  public int hashCode() {
    int h = cachedHashCode;
    if (h == 0) {
      h = computeHashCode();
      cachedHashCode = h;
      }
    return h;
    }
  // other functions and members...
  }

更多:我明白了,我们不关心值是否计算两次(因此它不是真正的线程安全).我还想知道在计算哈希码之后创建的新线程是否可以保证看到新的哈希码？

NHibernate.Linq返回IQueryable给我后期评估.这可以用QueryOver完成吗？

更新:

我将使用它来定义许多只使用子集的查询.因此,未来不是解决方案,它将全部执行它们.

我喜欢NHibernate.Linq中的IQueryable(IEnumerable)返回类型,如果从未使用过,它将永远不会执行查询.

如何在ac#代码块中运行最多n个线程？

我喜欢像这种伪代码一样容易和简短的东西

lock (this, 5)
{
   //do some work
}

编辑:这不是共享内存,竞争条件的事情.问题是我有很多线程.但我发现,当并行使用太多时,代码的一部分中使用的资源会失败.我可以使用objecpool,但我希望我能做到更容易.

也许是一个愚蠢的问题,但使用基于函数的索引是否安全.我的意思是,当列更改时,索引立即更改？