小编Mar*_*age的帖子

我正在使用Reactive Extensions for .NET(Rx)将事件公开为IObservable<T>.我想创建一个单元测试,我断言特定事件被触发.这是我要测试的类的简化版本:

public sealed class ClassUnderTest : IDisposable {

  Subject<Unit> subject = new Subject<Unit>();

  public IObservable<Unit> SomethingHappened {
    get { return this.subject.AsObservable(); }
  }

  public void DoSomething() {
    this.subject.OnNext(new Unit());
  }

  public void Dispose() {
    this.subject.OnCompleted();
  }

}

显然我的真正课程更复杂.我的目标是验证对被测试的类执行某些操作会导致在该信号上发出一系列事件IObservable.幸运的是,我想测试实现的类IDisposable以及OnCompleted在处理对象时调用主题使得测试更容易.

这是我测试的方式:

// Arrange
var classUnderTest = new ClassUnderTest();
var eventFired = false;
classUnderTest.SomethingHappened.Subscribe(_ => eventFired = true);

// Act
classUnderTest.DoSomething();

// Assert
Assert.IsTrue(eventFired);

使用变量来确定事件是否被触发也不是太糟糕,但在更复杂的场景中,我可能想要验证是否触发了特定的事件序列.如果不简单地在变量中记录事件然后对变量进行断言,这是否可能？能够使用流畅的类似LINQ的语法来对其进行断言IObservable有望使测试更具可读性.

我读到了锁和线程性能计数器,但我仍然不明白它们中的一些实际意味着什么.我特别谈论队列长度和争用率计数器,以及它们的每秒对应数.MSDN表示首先显示等待锁定的线程数,第二个显示获取锁定"未成功"的线程数.我以为如果一个线程正在等待一个锁,这意味着没有获得锁,但显然我错了？

假设我有这个示例程序:

static void Main(string[] args)
{
    var t1 = new Thread(RunThread1);
    var t2 = new Thread(RunThread2);
    t1.Start();
    t2.Start();
    t1.Join();
    t2.Join();
}

static void RunThread1()
{
    Thread.Sleep(1000);
    // this lock is acquired immediately. What will counters show at this moment?
    // probably both will be zero?
    lock (m_Lock)
    {
        Thread.Sleep(10000);
    }
}

static void RunThread2()
{
    Thread.Sleep(2000);
    // this lock has to wait for about 9 seconds. What will counters show?
    lock (m_Lock)
    { …

我有一个有系统托盘图标的应用程序.在卸载时,如果它正在运行,我将终止该进程.因此,由于没有优雅地停止应用程序,图标仍保留在系统托盘中,只有当我们将鼠标悬停在系统托盘上时才会删除.我编写了一个代码,可以沿着托盘运行光标并将光标放回其初始位置.这就是我所做的:

        [DllImport("user32.dll")]
        static extern IntPtr FindWindow(string className, string windowName);
        [DllImport("user32.dll")]
        static extern IntPtr FindWindowEx(IntPtr parent, IntPtr child, string className, string windowName);
        [DllImport("user32.dll")]
        static extern bool GetWindowRect(HandleRef handle, out RECT rct);

        [StructLayout(LayoutKind.Sequential)]
        struct RECT
        {
            public int Left;
            public int Top;
            public int Right;
            public int Bottom;
        }

        void RefreshTray()
        {
            IntPtr taskbar_Handle = FindWindow("Shell_Traywnd", "");
            IntPtr tray_Handle = FindWindowEx(taskbar_Handle, IntPtr.Zero, "TrayNotifyWnd", "");

            RECT rct;

            if (!(GetWindowRect(new HandleRef(null, tray_Handle), out rct)))
            {
            }

            System.Drawing.Point init = Control.MousePosition;

            for (int i = …

我正在使用AutoMoq,但由于实体框架(使用EF6和代码优先),我有点困惑如何编写我的第一个单元测试dbContext

// in service class(constructor)
private readonly MyContext context;

public PriceService(MyContext context)
{
    this.context = context;
}

// following would be in nunit test method.
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var priceService = fixture.Create<PriceService>();

当我运行单元测试时,它会崩溃

    at Ploeh.AutoFixture.Kernel.TerminatingSpecimenBuilder.Create(Object request, ISpecimenContext context)
    at Ploeh.AutoFixture.Kernel.CompositeSpecimenBuilder.c__DisplayClass6.b__1(ISpecimenBuilder b)
    at System.Linq.Enumerable.WhereSelectArrayIterator`2.MoveNext()
    at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext()
    at System.Linq.Enumerable.d__a5`1.MoveNext()
    at System.Linq.Enumerable.FirstOrDefault[TSource](IEnumerable`1 source)
    at Ploeh.AutoFixture.Kernel.RecursionGuard.Create(Object request, ISpecimenContext context)
    at Ploeh.AutoFixture.Kernel.CompositeSpecimenBuilder.c__DisplayClass6.b__1(ISpecimenBuilder b)
    at System.Linq.Enumerable.WhereSelectArrayIterator`2.MoveNext()
    at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext()
    at System.Linq.Enumerable.d__a5`1.MoveNext()
    at System.Linq.Enumerable.FirstOrDefault[TSource](IEnumerable`1 source)
    at Ploeh.AutoFixture.Kernel.CompositeSpecimenBuilder.c__DisplayClass6.b__1(ISpecimenBuilder b)
    at System.Linq.Enumerable.WhereSelectArrayIterator`2.MoveNext()
    at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext() …

我想更改控制器中某些参数的必需属性。我使用 XML 注释来链接到 Swagger。

我需要一个WPF应用程序的Datepicker.什么被认为是最好的？

有没有人知道使用普通的非托管Visual C++创建自定义性能计数器的方法？

我知道可以使用托管C++轻松完成,但我需要使用非托管Windows服务.

我也知道您可以检索性能计数器数据,但我需要创建一些自定义计数器并在应用程序运行时期间递增它们.

我试图在现有形式上添加"评级"系统(即1星,2星或差,平均,良好,优秀等).有没有人知道如何通过.Net或免费的第三方控制实现这种美观的用户体验？

谢谢

我有一个十元素的整数数组.我想按组对元素求和,所以例如我想在元素0处添加值,元素1的值,然后是元素2的值,然后是3,依此类推到元素9,然后添加元素1处的值,其值为2,3,直至9,直到每组2个值已加在一起并存储在变量中.然后,我想用3个组,4个组,5个组,一直到10个组重复该过程.每个结果总数存储在一个单独的变量中.到目前为止,我能弄清楚如何做到这一点的唯一方法是: -

int i = 0;
int p = 1;
int q = 2;
int r = 3;

while (i < NumArray.Length - 3)
{
    while (p < NumArray.Length - 2)
    {
        while (q < NumArray.Length-1)
        {
            while (r < NumArray.Length)
            {
                foursRet += NumArray[i] + NumArray[p] + NumArray[q]+ NumArray[r];
                r++; 
            }
            q++;
            r = q + 1;
        }
        p++;
        q = p + 1;
        r = q + 1;
    }
    i++;
    p = i + 1;
    q = i …

我知道使用lock(this)或任何共享对象是错误的.

我想知道这种用法是否合适？

public class A
{
  private readonly object locker = new object();
  private List<int> myList;
  public A()
  {
    myList = new List<int>()
  }

  private void MethodeA()
  {
    lock(locker)
    {
      myList.Add(10);
    }
  }

  public void MethodeB()
  {
    CallToMethodInOtherClass(myList);
  }
}

public class OtherClass
{
  private readonly object locker = new object();
  public CallToMethodInOtherClass(List<int> list)
  {
   lock(locker)
   {
     int i = list.Count;
   }
  }
}

这个线程安全吗？在OtherClass我们锁定私有对象,所以如果class A锁具有其私有锁,列表仍然可以在锁定块中更改OtherClass？