小编Xen*_*ate的帖子

有没有办法按原样处理你的正则表达式字符串的一部分？

即我想匹配文字模式:"[^*.. @/w $ [{"在某些文字中(夸大的例子,但你明白我的意思)...我可以把整个内容包含在内吗？

在DirectX11中，当创建Shader Resource View到缓冲区时；我们必须填写D3D11_BUFFER_SRV结构。

结构如下：

typedef struct D3D11_BUFFER_SRV {
  union {
    UINT FirstElement;
    UINT ElementOffset;
  };
  union {
    UINT NumElements;
    UINT ElementWidth;
  };
} D3D11_BUFFER_SRV;

我似乎找不到任何关于我应该使用每个联合中的哪个字段以及何时使用的文档，甚至找不到它们的真正含义。MSDN 页面（http://msdn.microsoft.com/en-us/library/windows/desktop/ff476094%28v=vs.85%29.aspx）给出了每个字段的相当明显的描述，但没有什么太大帮助。

我遇到了C#和C++之间的互操作问题,我通过本机代码和托管代码中定义的结构在应用程序的两个"端"之间共享内存.本机端的结构定义如下:

#pragma pack(push, 1)
        struct RayTestCollisionDesc {
                btVector3 hitPosition;
                btRigidBody* hitBody;

                RayTestCollisionDesc(btRigidBody* body, btVector3& position)
                        : hitBody(body), hitPosition(position) { }
        };
#pragma pack(pop)

并且在托管(C#)端定义了类似的结构.在C#上,结构大小是20个字节(正如我在32位系统上所期望的那样).但是,尽管有这个pragma pack指令,C++大小的结构大小仍然是32.为了清楚起见,这里sizeof()是每个类型的C++:

sizeof(btVector3) : 16 
sizeof(btRigidBody*) : 4
sizeof(RayTestCollisionDesc) : 32

显然pragma pack,只是指结构成员之间的打包,而不是结构末尾的填充(即对齐).我也试过添加,__declspec(align(1))但没有效果,MSDN本身确实说"__declspec(align(#))只会增加对齐限制."

FWIW我正在使用VS2013编译器(Platform Toolset v120).

有没有办法将结构大小"强制"为20个字节？

在浏览CLR/CLI规范和内存模型等时,我注意到根据ECMA CLI规范围绕原子读/写的措辞:

符合标准的CLI应保证当对位置的所有写访问具有相同大小时,对正确对齐的内存位置的读写访问权限不大于本机字大小(native int类型的大小)是原子的.

特别是" 恰当对齐的记忆 " 这句话引起了我的注意.我想知道我是否能以某种方式long在64位系统上以某种方式获得撕裂读取.所以我写了以下测试用例:

unsafe class Program {
    const int NUM_ITERATIONS = 200000000;
    const long STARTING_VALUE = 0x100000000L + 123L;
    const int NUM_LONGS = 200;
    private static int prevLongWriteIndex = 0;

    private static long* misalignedLongPtr = (long*) GetMisalignedHeapLongs(NUM_LONGS);

    public static long SharedState {
        get {
            Thread.MemoryBarrier();
            return misalignedLongPtr[prevLongWriteIndex % NUM_LONGS];
        }
        set {
            var myIndex = Interlocked.Increment(ref prevLongWriteIndex) % NUM_LONGS;
            misalignedLongPtr[myIndex] = value;
        }
    }

    static unsafe void Main(string[] args) {
        Thread …

请考虑以下代码:

public static void M() {
    A(V);
    A(V);
    A(V);
}

public static void V() {

}

public static void A(Action x) {
    x();   
}

这可以在幕后编译为:

public static void M() {
    A(new Action(V));
    A(new Action(V));
    A(new Action(V));
}

但是,我们可以编写自己的简单性能改进,以减少不必要的垃圾:

private static readonly Action v = new Action(V);
A(v);
A(v);
A(v);

对于这个非常简单的案例,Roslyn有什么理由无法做出类似的优化吗？

如果答案是否定的,那么当方法不是静态但实例成员时呢？什么时候捕获了封闭变量？

注意:我是一个业余爱好者C#程序员.我没有NuGet的经验(我不完全确定它的用途).

我有Resharper(6或7,我认为),我想安装Respeller Free.但是,该页面没有下载链接,只是关于使用NuGet的模糊解释......

......对于这些命令行的事情似乎总是如此,在任何地方都没有关于如何做到这一点的实际解释; 只是为什么它更好的标准模糊...

无论如何,我已经尝试在NuGet命令行中运行它:

PM> Get-Package -filter spell -listavailable

但我看不出任何与推进器有关的事情.那么......我错过了什么？谷歌什么都没有.

提前致谢.

这是使用std :: atomic的正确方法吗？我Logger在命名空间级别声明了一个名为LOGGER:

class Logger {
    public:

    Logger();
    ~Logger();

    bool Init(std::wstring logFileLocation);
    bool Shutdown();

    void const LogMessage(std::wstring message);
};

std::atomic<Logger&> LOGGER;

我的期望是LOGGER将实例化一次(没有比赛;它将从代码中的单个已知点初始化),但随后从多个线程访问.

我是C++中多线程和线程安全的新手; 但是在C#或Java中,我想要使LOGGER volatile或(在C#中)放置内存围栏.这是C++中的正确​​模拟吗？

我有以下结构：

struct Logger::LoggerImpl {
    std::wofstream loggerStream;
}

当我创建 LoggerImpl 时，显然将隐式创建 std::wofstream （通过编译器的默认构造函数）。

我的问题是，有没有办法在不使用指针的情况下阻止（或推迟）wofstream 的构造？因为我稍后将使用给定的文件名创建它。

我知道在这种情况下没有什么区别，但我是在理论基础上问的。

我有一个C#类型,从逻辑比较来比较与int的相等性.叫这种类型Number.

但是,我不能使Equals对称,因为我无法改变Int32.Equals(object other).那么,我应该允许非对称相等,如下所示:

Number numberThree = new Number(3);
int intThree = 3;

bool equal;
equal = numberThree.Equals(intThree); // equal is true
equal = intThree.Equals(numberThree); // equal is false

或者,如果类型匹配以及数值,我应该只允许相等吗？

我正在尝试找出带来IAsyncEnumerable<T>诸如IEnumerable<Task<T>>.

我编写了以下类，它允许我等待一系列数字，每个数字之间有定义的延迟：

class DelayedSequence : IAsyncEnumerable<int>, IEnumerable<Task<int>> {
    readonly int _numDelays;
    readonly TimeSpan _interDelayTime;

    public DelayedSequence(int numDelays, TimeSpan interDelayTime) {
        _numDelays = numDelays;
        _interDelayTime = interDelayTime;
    }

    public IAsyncEnumerator<int> GetAsyncEnumerator(CancellationToken cancellationToken = default) {
        async IAsyncEnumerable<int> ConstructEnumerable() {
            for (var i = 0; i < _numDelays; ++i) {
                await Task.Delay(_interDelayTime, cancellationToken);
                yield return i;
            }
        }

        return ConstructEnumerable().GetAsyncEnumerator();
    }

    public IEnumerator<Task<int>> GetEnumerator() {
        IEnumerable<Task<int>> ConstructEnumerable() {
            for (var i = 0; i < _numDelays; ++i) { …