小编lys*_*cid的帖子

我有一个奇怪的问题:

在我的C#app中,我正在创建另一个线程,如下所示:

Thread printThread = new Thread(printWorker);

printThread.Name = "Logger MainThread";
printThread.IsBackground = true;
printThread.Start();

当我的主线程完成时,这个新线程继续工作,虽然它被标记为背景.

可能是什么原因造成的？这个对象持有Mutex对象,不确定这可能是原因......

任何人的想法？

这是printWorker方法的代码:

while (loggerIsActive)
{
    LogMessage log = LoggerQueue.Dequeue();

    if (log.message != null)
    {
        syncLogObj.WaitOne();
        lock (writerobj)
        {
            StreamWriter sw;

            if (!File.Exists(fName))
            {
                sw = File.CreateText(fName);
            }
            else
            {
                sw = new StreamWriter(fName, true);
            }

            using (sw)
            {
                if (log.message != "")
                {
                    if (log.message.EndsWith("\r\n"))
                    {
                        log.message =
                            log.message.Substring(0, log.message.Length - 2);
                    }

                    sw.WriteLine(string.Format("[{0}][{3}][{1}] | {2}",
                                               log.msgTime,
                                               log.level.ToString(),
                                               log.message,
                                               log.sender.ToString()));
                }

                sw.Flush();
                sw.Close(); …

我们正在为自动化代码进行开发.

我们的代码使公司的产品自动化,并与特定的产品版本同步.

目前,我们有一个包含多个分支的大型Git存储库 - v1.0,v1.1,v2.0(版本1.0的自动化进入v1.0分支,依此类推).

在具有分支的单个存储库中将这些存储在一个单独的存储库中的优点和缺点是什么？

两种解决方案都可以工作,我正在寻找的答案是两种方法的优缺点列表.

我知道许多团队正在使用分支来隔离开发中的临时阶段,例如执行错误修复或新功能,最终将工作合并到主要开发分支中.

我知道的其他工作模式有不同的分支用于开发,发布等,以将代码的"清洁"修订与经常处理的脏代码分开.

这些听起来都不像我们目前所做的那样.

*请注意,我们制作的特定版本中的某些修改与所有产品版本相关,而有些版本则不然.

我很想知道C#中的所有演员阵容是否会导致拳击,如果不是,所有演员阵容都是昂贵的操作？

从拳击和拆箱中获取的示例(C#编程指南)

    int i = 123;
    // The following line boxes i.
    object o = i;  

这一行显然导致装箱(将int类型包装为一个对象).这是一项被认为是昂贵的操作,因为它会产生将要收集的垃圾.

那些来自2种不同类型的参考类型的演员表怎么样？那是多少钱？可以正确测量吗？(与前一个例子相比)

例如:

public class A
{
}

public class B : A
{
}

var obj = new B();
var obj2 = (A)obj; // is this an "expensive" operation? this is not boxing

我正在使用Reflection.Emit开发一个在运行时动态创建Assembly的工具.

该工具针对.NET 4.5框架.

我想知道是否可以指定动态生成的程序集所针对的.NET运行时(例如:指定将创建.NET 3.5程序集).

我想创建一些以通用方式使用的方法,它是否会阻塞(除非某个超时到期),直到满足给定条件.

代码中的用法类似于:

WaitUntil( condition );

我尝试使用While(..)循环实现它,但这似乎是浪费.

在当前的实现中,我正在初始化一个在TIMEOUT到期的"一次性"计时器.我正在运行一个while循环,并检查计时器是否已超时,如果有,则抛出异常.

有没有简单而有效的技术来实现这种方法？

我有一个.NET应用程序,它使用一个定义一些方法的程序集(.dll):

    public void DoSomething()
    {
        // Do work
    }

假设此方法签名更改为包含字符串返回类型:

    public string DoSomething()
    {
        // Do work
        return "something";
    }

为什么使用此方法的代码在System.MissingMethodException上失败？

在我看来,在这个方法的所有调用站点,没有使用返回值(因为它之前不存在).

为什么这个改变会破坏代码呢？

在TeamCity中,我需要说明包含要执行的NUnit测试的程序集的确切位置.

是否可以选择声明.SLN文件,以便动态查找这些测试项目？

我正在使用NUnit进行单元测试(使用TD.NET运行).

使用Assert.DoesNotThrow时,我得到了异常,但没有任何堆栈跟踪,这使得识别根问题变得更加困难.

我该如何解决这个问题？

我们正在为我们公司内部使用的测试自动化构建一个.NET软件平台.

该应用程序由GUI(WinForms)组件和动态加载到其中以执行的各种"动作"组成.

已经有大约约100个行动项目,这个数字正在增加.其中一些项目与其他项目相互依赖,依此类推.

加载的所有操作必须引用我们的"SDK"dll用于各种活动(结果到主应用程序,记录等).

通过这种相对简单的设计,我们面临着一些我们希望以最佳方式解决的管理决策:

1. 动作("插件")应该引用我们的SDK项目输出,还是某些已知的稳定版本？例如,在开发大型应用程序(仅用于示例的MS Office)时,并非所有团队都自然地使用所有组件的源代码.

对于这样的事情,最好的解决方案是什么？为什么？

1. 如何正确验证所有需要的依赖项(例如第三方库)确实是从正确的位置获取的？

管理众多项目之间的场景中的常见做法是什么？这样做有什么提示吗？

我在我们的构建上运行一些分析工具,如StyleCop/FXCop.

我想要实现的是自动纠正这些警告产生的一些警告.

你认为这可以使用Roslyn CTP完成吗？有没有其他工具允许:

1. 扫描我的代码文本以查找未遵循的规则.
2. 用正确的代码替换它.

一些操作可以使用VS编辑器的简单文本替换来完成,但更复杂的事情需要使用其他一些工具.

所以我的问题是 - 为此,Roslyn CTP是使用的工具吗？或者.NET有什么其他工具可以做到这一点？