小编Xen*_*ate的帖子

我想通过使用await/async测试归于程序的开销.

为了测试这个,我编写了以下测试类:

public class Entity : INotifyCompletion {
    private Action continuation;
    private int i;

    public void OnCompleted(Action continuation) {
        this.continuation = continuation;
    }

    public Entity GetAwaiter() {
        return this;
    }

    public Entity GetResult() {
        return this;
    }

    public bool IsCompleted { get { return true; } }

    public void Execute() {
        if (i > 0) Console.WriteLine("What");
    }
}

然后我写了一个测试工具.测试工具在TestA和TestB中迭代1600次,仅测量后者1500次(以允许JIT"预热").set是Entity对象的集合(但实现是无关紧要的).该集合中有50,000个实体.测试工具使用Stopwatch该类进行测试.

private static void DoTestA() {
    Entity[] objects = set.GetElements();
    Parallel.For(0, objects.Length, async i => {
        Entity e …

我想用.NET 4.5编写一个XNA游戏,这样我就可以使用.NET 4.0中没有的一个新功能.

有没有办法做到这一点？VS2012没有在新项目列表中的任何位置列出XNA.

我也看到过这个问题: 如何在Visual Studio 2012上安装XNA游戏工作室？

但我只是一个业余爱好者,我无法让xcopy工作(加上我不认为我有游戏工作室,只有框架).无论如何,我想知道是否有可能在VS2010中使用.NET 4.5.

提前致谢.

我正在编写一个C++/CLI应用程序,但我希望我的C++ DLL中的大多数代码都是本机运行的(即不管理).

我在模块中只有一个CLI类,其他文件都是本机C++.

那么,确保这些本地类运行的最佳方法是什么......嗯,本机？

我是不是该:

• A)将#pragma unmanaged添加到每个本机类的顶部
• B)只需在我的单个CLI类中的包含之前添加#pragma unmanaged
• C)还有别的吗？

谢谢

我一直在浏览Roslyn的演练和文档,并且有很多关于IDE警告/错误和重构的例子,但似乎没有提到Roslyn是否可以用作编译钩子(如字节编织)图书馆倾向于做,但在我们生成IL之前.

例如,我想转换:

public void DoSomething(Entity e) {
    e.DoSomethingElse();
}

至:

public void DoSomething(Entity e) {
    using (e.Acquire()) {
        e.DoSomethingElse();
    }
}

......但每次编译'之前'代码时,都不是一次性重构.

我的例子的意义并不重要,我只是想知道是否可以使用Roslyn这样的事情,如果有这样的例子存在？

我有一个委托与泛型类型作为参数之一:

public delegate void UpdatedPropertyDelegate<T>(
    RemoteClient callingClient, 
    ReplicableProperty<T> updatedProp, 
    ReplicableObject relevantObject
);

现在,我想要一个可以订阅的公共事件供其他类使用.因此,我做了:

public event UpdatedPropertyDelegate<T> UpdatedProperty;

但是,编译器不喜欢这样.我不明白为什么必须在这里指定T. 当然,它是在我发射事件时指定的,即:

if (UpdatedProperty != null) 
{
    UpdatedProperty(this, readProperty, 
        ReplicableObjectBin.GetObjectByID(readProperty.OwnerID));
}

那么,我做了一些简单的错误吗？或者这是一次大规模的理解失败？

谢谢.

有什么方法可以"破解"或"胁迫"协变覆盖C#？

例如:

public class Alpha {
    public virtual Alpha DoSomething() {
        return AlphaFactory.GetAlphaFromSomewhere();
    }
}
public class Beta : Alpha {
    public override Beta DoSomething() {
        return BetaFactory.GetBetaFromSomewhere();
    }
}

不幸的是,C#不支持这个(这看起来有点荒谬,但这既不在这里也不在那里).

我以为我可能会有方法隐藏的答案:

new public Beta DoSomething() {
    return BetaFactory.GetBetaFromSomewhere();
}

但是这并没有将条目添加到'vtable'中,它只是基本上声明了一个具有相同名称的全新方法,因此意味着Beta通过指向一个Alpha将调用的指针来访问s Alpha.DoSomething().

那么,有什么好的伎俩吗？

我想我可能在VS2013附带的MSVC++编译器中发现了编译器错误,但这是一个我无法确定的简单情况.再加上我还在学习C++的事实,我想在提交任何内容之前先问这里; 因为老实说,我很确定这只是我做错了导致一个不寻常的错误信息.

无论如何,我把问题减少到一个小的测试文件:

#include <string>
#include <iostream>

std::wstring cstr_to_wstring(const char* cString) {
    std::string temp = cString;
    return { temp.begin(), temp.end() };
}

int main() {
    std::cout << cstr_to_wstring("Hi").c_str();
}

当我尝试编译时,我收到以下错误:

1>d:\documents\projects\compilerbugtest\compilerbugtest\compilerbugtest.cpp(6): fatal error C1001: An internal error has occurred in the compiler.
1>  (compiler file 'f:\dd\vctools\compiler\utc\src\p2\main.c', line 227)
1>   To work around this problem, try simplifying or changing the program near the locations listed above.

要解决这个问题,我可以在第六行指定类型,这样:

return { temp.begin(), temp.end() };

变

return std::wstring { temp.begin(), temp.end() };.

这真的是一个编译器错误吗？谢谢.

考虑以下示例:

private int sharedState = 0;

private void FirstThread() {
    Volatile.Write(ref sharedState, 1);
}

private void SecondThread() {
    int sharedStateSnapshot = Volatile.Read(ref sharedState);
    Console.WriteLine(sharedStateSnapshot);
}

直到最近,我的印象是,只要FirstThread()真的执行过SecondThread(),这个程序除了1之外不能输出任何东西.

但是,我现在的理解是:

• Volatile.Write()发出一个发布栏.这意味着在分配1到之后,可能不会发生先前的加载或存储(按程序顺序).sharedState
• Volatile.Read()发出一个获取围栏.这意味着,没有后续的加载或存储(按程序顺序)可以的复制之前发生sharedState到sharedStateSnapshot.

或者,换句话说:

• 当sharedState实际发布到所有处理器核心时,该写入之前的所有内容也将被释放,并且,
• sharedStateSnapshot获取地址中的值时; sharedState一定是已经被收购了.

如果我的理解是正确的,那么sharedState如果写入FirstThread()还没有被释放,那么没有什么可以防止获得"陈旧" .

如果这是真的,我们如何才能真正确保(假设最弱的处理器内存模型,如ARM或Alpha),程序将始终打印1？(或者我在某个地方的心理模型中犯了错误？)

当通过P/Invoke通过显式64位.NET应用程序与64位本机库交互时,属性中的CallingConvention属性是否DllImport被有效忽略？

我问这个是因为在"传统"x86上你必须指定调用者或被调用者清理堆栈变量的方式(以及函数本身如何使用某些CPU寄存器等); 但据我了解,x64只有一个约定__fastcall(__vectorcall尽管最近添加了).

那么__fastcall,无论你为CallingConvention属性设置什么,CLR都会继续使用x64约定来编组函数调用？

考虑以下代码，编写在启用可空引用的上下文中：

static string GetStr() => "test";

public static void Main() {
    var s = GetStr();
}

s被隐式输入为 astring?而不是 a string。

这是设计使然，正如MSDN 的 var 官方文档中提到的那样：

当 var 与启用的可为空引用类型一起使用时，它始终暗示一个可为空引用类型，即使表达式类型不可为空。

但这是为什么呢？是不是因为变量以后可能会被重新赋值？

此外，即使它被输入为string?我可以在没有警告的情况下取消引用它：

if (s.Length > 10) return; // Emits no compiler warning

但是，如果我创建另一个确实返回 astring?的方法，如果我尝试取消引用，编译器现在会发出警告，即使两个变量都输入为string?：

static string? GetStrMaybe() => "test";

public static void Main() {
    var s = GetStrMaybe();
    if (s.Length > 10) return; // Compiler emits a warning …