小编Mic*_*eyn的帖子

当我在SSMS中提交批处理(例如,执行查询)时,我看到在状态栏中执行所花费的时间.是否可以配置SSMS以毫秒级分辨率显示查询时间？

这是我正在谈论的用红色圈出的感兴趣部分的酒吧:

在查看XML文件Visual Studio 2010时,是否有一种简单的方法可以重新格式化XML文件.例如,如果打开生成的app.config文件,它可能如下所示:

<?xml version="1.0"?>
<configuration>
<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>

这很难理解,是否有一种方法可以指示Visual Studio 2010对其进行格式化,使其看起来更像:

<?xml version="1.0"?>
<configuration>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
  </startup>
</configuration>

谢谢你的帮助.

更新:感谢Julien Hoarau的答案之一.答案是:

Edit -> Advanced -> Format Document (Ctrl+K, Ctrl+D)
Edit -> Advanced -> Format Selection (Ctrl+K, Ctrl+F)

我们希望将服务器上的操作系统从Ubuntu 10.04 LTS升级到Ubuntu 12.04 LTS.不幸的是,似乎运行已经变为可运行的线程的延迟从2.6内核到3.2内核显着增加.事实上,我们得到的延迟数字很难相信.

让我对测试更加具体.我们有一个运行两个线程的程序.第一个线程获取当前时间(使用RDTSC以滴答为单位),然后每秒发送一次条件变量.第二个线程等待条件变量并在发出信号时唤醒.然后它获取当前时间(使用RDTSC以滴答为单位).计算第二个线程中的时间与第一个线程中的时间之间的差异,并在控制台上显示.在此之后,第二个线程再次等待条件变量.大约第二次通过后,第一个线程将再次发出信号.

因此,简而言之,我们得到一个线程,通过条件可变延迟测量一次一次地进行线程通信.

在内核2.6.32中,这种延迟大约为2.8-3.5 us,这是合理的.在内核3.2.0中,这种延迟已经增加到大约40-100 us.我已经排除了两台主机之间硬件的任何差异.它们运行在相同的硬件上(双插槽X5687 {Westmere-EP}处理器,运行频率为3.6 GHz,具有超线程,speedtep和所有C状态关闭).测试应用程序更改线程的亲和力以在同一套接字的独立物理核心上运行它们(即,第一个线程在Core 0上运行,第二个线程在Core 1上运行),因此没有线程的弹跳套接字之间的核心或弹跳/通信.

两台主机之间的唯一区别是,一台运行Ubuntu 10.04 LTS,内核为2.6.32-28(快速上下文切换盒),另一台运行最新的Ubuntu 12.04 LTS,内核为3.2.0-23(缓慢的上下文)开关盒).所有BIOS设置和硬件都相同.

内核是否有任何变化可以解释线程被安排运行多长时间的这种荒谬的减速？

更新: 如果您想在主机和Linux版本上运行测试,我已将代码发布到pastebin供您阅读.编译:

g++ -O3 -o test_latency test_latency.cpp -lpthread

运行(假设您至少有一个双核盒子):

./test_latency 0 1 # Thread 1 on Core 0 and Thread 2 on Core 1

更新2:经过大量内核参数搜索,内核更改和个人研究的帖子后,我已经找出了问题所在并已发布解决方案作为这个问题的答案.

让我先说明我的意图.在旧的(C++)时代,我们会有如下代码:

class C
{
public:
  enum {SOME_VALUE=27};
};

然后我们可以SOME_VALUE在整个代码中使用编译时常量,无论编译器在哪里看C::SOME_VALUE,它都只是插入文字27.

现在,将代码更改为以下内容似乎更为可接受:

class C
{
public:
  static constexpr int SOME_VALUE=27;
};

这看起来更清晰,提供SOME_VALUE了一个定义良好的类型,并且似乎是C++ 11中的首选方法.(至少对我来说不可靠)问题是,这也导致SOME_VALUE需要在外部进行的情况.也就是说,在某个地方的某个cpp文件中,我们需要添加:

constexpr int C::SOME_VALUE; // Now C::SOME_VALUE has external linkage

导致这种情况的情况似乎是在使用const引用时SOME_VALUE,这在C++标准库代码中经常发生(请参阅本问题底部的示例).顺便说一句,我使用gcc 4.7.2作为我的编译器.

由于这种困境,我被迫恢复定义SOME_VALUE为枚举(即旧学校),以避免必须为某些(但不是所有)静态constexpr成员变量的cpp文件添加定义.是不是有某种方法告诉编译器这constexpr int SOME_VALUE=27意味着SOME_VALUE应该只将其视为编译时常量而不是具有外部链接的对象？如果您看到与它一起使用的const引用,请创建一个临时引用.如果你看到它的地址,如果需要的话就会产生编译时错误,因为它是编译时常量而已.

以下是一些看似良性的示例代码,它们使我们需要SOME_VALUE在cpp文件中添加定义(再次使用gcc 4.7.2进行测试):

#include <vector>

class C
{
public:
  static constexpr int SOME_VALUE=5;
};

int main()
{
  std::vector<int> iv;

  iv.push_back(C::SOME_VALUE); // Will cause an undefined reference …

我在行选择模式中使用DataGrid(即SelectionUnit="FullRow").我只想删除当用户突出显示一行时为当前单元格放置的边框,以便进行真正的全行选择(并且不选择单元格级别).我不介意网格保持当前单元格的概念,我只想删除那个讨厌的当前单元格边界,可能是通过改变当前单元格的样式.最简单的方法是什么？

需要考虑的是以下函数,该函数可用于(相对快速地)将64位无符号整数分解为其素因子.注意,因子分解不是概率性的(即,它是精确的).在现代硬件上,该算法已经足够快,可以在几秒钟内找到一个数字是素数或几乎没有很大的因子.

问题:可以对所提出的算法进行任何改进,同时保持它是单线程的,这样它可以更快地考虑(任意)非常大的无符号64位整数,最好不使用概率方法(例如,Miller-Rabin)确定素性？

// system specific typedef for ulong should go here (or use boost::uint64_t)
typedef unsigned __int64 ulong;
typedef std::vector<ulong> ULongVector;

// Caller needs to pass in an empty factors vector
void GetFactors(ULongVector &factors, ulong num)
{
  // Num has to be at least 2 to contain "prime" factors
  if (num<2)
    return;

  ulong workingNum=num;
  ulong nextOffset=2; // Will be used to skip multiples of 3, later

  // Factor out factors of 2
  while (workingNum%2==0)
  {
    factors.push_back(2);
    workingNum/=2;
  }

  // Factor …

想象一下,你在课堂上有一个字段_items.您可以在声明点初始化它:

class C
{
  IList<string> _items=new List<string>();
}

现在我想将此字段转换为自动生成的属性,但现在初始化无效:

class C
{
  public IList<string> Items=new List<string>(); {get; set;} // Invalid
}

所以,我必须这样做:

class C
{
  public IList<string> Items {get; set;}

  public C
  {
    Items=new List<string>();
  }
}

但这并不像在声明点初始化字段那样方便.有没有更好的方法来执行此操作,而不必(不必要地)使用私有(在声明点初始化)字段来支持此属性,例如.

谢谢

以下是一些示例代码:

IList<MyType> myList1=new List<MyType>();
IList<MyType> myList2=new List<MyType>();

// Populate myList1
...
// Add contents of myList1 to myList2
myList2.Add(myList1); // Does not compile

如何将一个列表的内容添加到另一个列表中？是否有方法可以实现此目的？

我有两个迭代器到一个容器,一个const和一个非const.比较它们是否存在问题,看它们是否都引用了容器中的同一个对象？这是一个通用的C++ 11迭代器问题:

可以合法地比较const和非const迭代器,看看它们是否都引用同一个对象,与容器的类型无关(即,它们都是保证引用同一容器中的对象或容器末端的迭代器) (),但一个是const而另一个不是)？

例如,请考虑以下代码:

some_c++11_container container;

// Populate container
...

some_c++11_container::iterator iObject1=container.begin();
some_c++11_container::const_iterator ciObject2=container.cbegin();

// Some operations that move iObject1 and ciObject2 around the container
...

if (ciObject2==iObject1) // Is this comparison allowed by the C++11 standard?
  ...; //Perform some action contingent on the equality of the two iterators

问题严格关注std::function而非关键boost::function.有关详细信息,请参阅此问题底部的" 更新"部分,尤其是有关无法std::function根据C++ 11标准比较非空对象的部分.

C++ 11 std::function类模板非常适合维护一组回调.vector例如,可以将它们存储在a中,并在需要时调用它们.但是,维护这些对象并允许取消注册似乎是不可能的.

让我具体一点,想象一下这堂课:

class Invoker
{
public:
  void Register(std::function<void()> f);
  void Unregister(std::function<void()> f);

  void InvokeAll();

private:
  // Some container that holds the function objects passed to Register()
};

示例使用场景:

void foo()
{
}

int main()
{
  std::function<void()> f1{foo};
  std::function<void()> f2{[] {std::cout << "Hello\n";} };

  Invoker inv;

  // The easy part

  // Register callbacks
  inv.Register(f1);
  inv.Register(f2);

  // Invoke them
  inv.InvokeAll();

  // The seemingly impossible part. How can …