小编jav*_*red的帖子

该计划正在实施此实施:

class Instrument
{
    public string ClassCode { get; set; }
    public string Ticker { get; set; }
    public override string ToString()
    {
        return " ClassCode: " + ClassCode + " Ticker: " + Ticker + '.';
    }
}

但是因为我需要在Dictionary中使用Instrument,所以我决定实现equals/hashcode:

class Instrument
{
    public string ClassCode { get; set; }
    public string Ticker { get; set; }
    public override string ToString()
    {
        return " ClassCode: " + ClassCode + " Ticker: " + Ticker + '.';
    }

    public override bool …

为什么我收到这样的消息？

属性"依赖关系"在此声明类型上无效.它仅对'assembly'声明有效.

public partial class MainWindow : Window
{
    private OverviewViewModel _vm;

    [Dependency]
    public OverviewViewModel VM
    {
        set
        {
            _vm = value;
            this.DataContext = _vm;
        }
    }

请参阅我之前的问题以获取代码示例套接字:有时(很少)数据包在接收期间丢失

我需要始终从UDP多播套接字接收数据.这是单向通信我只需要监听新数据并尽快处理它.

我应该用while(true)吗？我不喜欢,while(true)因为在我看来,这为处理器带来了很多额外的工作.可能c#提供其他回叫技术或其他什么？

在下面的代码中,我必须声明方法,MdrResponseInterpreter static否则我有编译错误.

class.... {

    private StandardBuilder _mdrResponseBuilder = 
      new StandardBuilder(MdrResponseInterpreter);

    public static bool MdrResponseInterpreter(DNMessageDeliverer builder, 
                                              DNFieldSet message)
    {
        // .... work
    }

为什么？由于_mdrResponseBuilder不是静态的,我希望MdrResponseInterpreter应该能够访问this

我是否正确声明一个方法abstract自动使其成为虚拟？

也就是说,在子类中,我可以多次覆盖它,并且在运行时,将调用与对象的运行时类型相对应的方法？

是否可以声明一个抽象的非虚方法？也就是说,必须在非抽象子类中实现并且不能被覆盖的方法？

我的一个线程将数据写入循环缓冲区,另一个线程需要尽快处理此数据.我想写这么简单spin.伪代码!

    while (true) {
        while (!a[i]) {
            /* do nothing - just keep checking over and over */
        }
        // process b[i]
        i++;
        if (i >= MAX_LENGTH) {
            i = 0;
        }
    }

上面我a用来表示存储的数据b可供处理.Probaly我也应该为这种"热"过程设置线程.当然这种旋转在CPU方面非常昂贵,但对我来说这是好的,因为我的主要要求是延迟.

问题是 - 我应该写出类似的东西,boost或者stl允许以下内容:

1. 更容易使用.
2. 在占用较少CPU资源的同时,延迟大致相同(甚至更好)？

我认为我的模式非常普遍,某些地方应该有一些好的实现.

upd似乎我的问题仍然太复杂了.让我们考虑一下这种情况,当我需要以任意顺序将一些项目写入数组时,另一个线程应该在项目可用时以正确的顺序读取它们,如何做到这一点？

UPD2

我正在添加测试程序来演示我想要实现的内容和方式.至少在我的机器上它恰好起作用.我rand用来告诉你我不能使用一般queue,我需要使用array-based结构:

#include "stdafx.h"
#include <string>
#include <boost/thread.hpp>
#include "windows.h" // for Sleep


const int BUFFER_LENGTH = 10; …

我正在尝试实现在不需要时不产生开销的日志记录(即根本不应该执行任何方法调用).我想要没有开销,因为它是低延迟代码.我刚刚添加#define ENABLE_LOGS到我的标题类中,现在它看起来像那样(你可以忽略细节)

#pragma once

#include <string>
#include <fstream>

#define ENABLE_LOGS

namespace fastNative {

    class Logger
    {
    public:
        Logger(std::string name_, std::string fileName, bool append = false);
        ~Logger(void);
        void Error(std::string message, ...);
        void Debug(std::string message, ...);
        void DebugConsole(std::string message, ...);
        void Flush();
        static Logger errorsLogger;
        static Logger infoLogger;
    private:
        FILE* logFile;
        bool debugEnabled;
    };

}

每当我需要使用某种方法时,我应该像这样围绕它:

#ifdef ENABLE_LOGS
    logger.Debug("seq=%6d len=%4d", seq, length_);
#endif

这是错误的错误(我可以忘记环绕)并使代码变脏.我能以某种方式修改我的代码而不是#ifdef每次都使用吗？

在C#中我喜欢Conditional我想我需要类似c ++的东西.

我有几个指标需要"始终保持最新".即如果有任何改变,我需要重新计算"依赖".我有几个级别,只有在计算前一级别时才应计算每个下一级别.让我用这幅闪亮的画面解释一下:

在某些时候假设法郎改变了.然后我们应该:

1. calc法郎/第纳尔
2. calc Franc/Dinar/Peso

或者,如果Peso,Franc和Dinar一下子改变了,那么我们应该:

1. calc法郎/第纳尔
2. calc Franc/Dinar/Peso
3. calc Peso + Euro /(欧元+美元)

因此,无论什么时候,Level 0我们应该重新计算所有其他级别.但

• 我们应该只计算所需的项目.如果欧元改变,我们不需要重新计算法郎/第纳尔
• 我们不应该多计算任何东西.如果欧元和美元立即改变,我们应该只计算一次欧元+美元(不是两次).

最直接的解决方案是:

• 将每个级别存储在数组中
• 对于来自下一级别的数组音轨"听众"中的每个项目(可能很难,因为例如Peso有来自不同级别的听众 - 来自Level2的Franc/Dinar/Peso和来自Level 3的Peso + Euro /(Euro + Usd),所以两个 - dimmension数组是必需的..)
• 如果重新计算项目,则标记所有侦听器也要重新计算
• 从0级到最后一级并重新计算标记为重新计算的项目(最初更新的项目是要重新计算的市场,例如Peso).

我想我的问题很有名,可能你可以建议我一般众所周知的解决方案.我不想重新发明轮子:)谢谢!

我的程序中有这样的代码:

catch (boost::exception& ex) {
    // error handling
}

我该如何打印细节？错误信息,堆栈跟踪等？

我正在使用boost spsc_queue将我的东西从一个线程移动到另一个线程.它是我软件中的关键位置之一,所以我希望尽快完成.我写了这个测试程序:

#include <boost/lockfree/spsc_queue.hpp>
#include <stdint.h>

#include <condition_variable>
#include <thread>

const int N_TESTS = 1000;

int results[N_TESTS];

boost::lockfree::spsc_queue<int64_t, boost::lockfree::capacity<1024>> testQueue;

using std::chrono::nanoseconds;
using std::chrono::duration_cast;

int totalQueueNano(0);
int totalQueueCount(0);

void Consumer() {
    int i = 0;
    int64_t scheduledAt;
    while (i < N_TESTS - 1) {
        while (testQueue.pop(scheduledAt)) {
            int64_t dequeuedAt = (duration_cast<nanoseconds>(
                    std::chrono::high_resolution_clock::now().time_since_epoch())).count();
            auto diff = dequeuedAt - scheduledAt;
            totalQueueNano += diff;
            ++totalQueueCount;
            results[i] = diff;
            ++i;
        }
    }
    for (int i = 0; i < N_TESTS; i++) {
        printf("%d …