小编Man*_*ndo的帖子

如何定义一个将带有空数组的可选数组作为默认值的函数？

public void DoSomething(int index, ushort[] array = new ushort[] {},
 bool thirdParam = true)

结果是:

'array'的默认参数值必须是编译时常量.

下面的ArrayList可以直接初始化而不需要aFileExt字符串数组吗？

private static string[] aFileExt = 
     {"css", "gif", "htm", "html", "txt", "xml" };
private System.Collections.ArrayList alFileTypes =
     new System.Collections.ArrayList(aFileExt);

下面的行是目标,但我的.Net编译器不喜欢它:

private static System.Collections.ArrayList alFileTypes = 
     new System.Collections.ArrayList({"css","gif","htm","html","txt","xml"});

我正在使用.net Micro Framework,因此无法访问泛型类型.

我正在构建一个使用Zeroconf的.net-microframework应用程序.现有的zeroconf解决方案似乎都依赖于dns-sd.dll或.netmf不支持的.net的其他一些互操作功能.

有没有你知道的纯粹的C#版zeroconf(或dns-sd)？

这可能看起来很愚蠢,但是在这个时代,如果数组的内容发生了变化,那么应该能够期望JS引发一个事件.

关于变量变化时通知的几个问题(定义getter或setter).似乎有办法做到这一点(至少对于大多数浏览器,包括IE6 +)

我的问题是,如果数组中的项目发生更改,我会尝试收到通知:

    var ar = ["one", "two", "three"];
    // setting the whole array will call the custom setter method
    // (assuming you defined it)

    ar = ["one", "three", "five"];

    // however, this will only call the getter method and won't call the setter
    // without defining custom setters for every item in the array.  

    ar[1] = "two";

显然,我试图避免强迫编码器使用老式的java风格.getVale()和.setValue()函数来访问/修改数据.

我正在使用嵌入式C编译器(ARM cortex-m3芯片),它似乎将错误的值初始化为结构.为什么会这样？如果是对齐问题,编译器是否应该知道将int32u与4字节边界对齐？

注意:printf只会抛出串行端口的字节.该芯片上没有stdio.h实现.

typedef struct
{
    int32u startTime; 
    int16u length;
    int32u offTime;
} Cycle;

Cycle cycle = 
{
    315618000, 
    1200,
    0
};


void init()
{
   printf("\r\nInitialized! Cycle Start: %d", cycle.startTime);

   cycle.startTime = 315618000;
   cycle.length = 1200;

   printf(" Cycle Start: %d", cycle.startTime);

}

输出:初始化!循环开始:631237200循环开始:315618000

注意::这不是printf问题.调试器也会将内存中的值验证为631237200.

WaitForSingleObject即使事件已经发出信号,有时也会等待超时.

信令线程SetEvent()每次都会收到成功.但是,发出信号的线程并不总是听到信号.如果我SetEvent()在信令线程中添加冗余,问题就会消失.

显然这里有些不对劲.可能的原因是什么？

// Signalling Thread
if (SetEvent(waitEvent))
    consoleprintf(L"\r\nEvent Set.");

应等待延迟时间或发出信号.但并不总是得到信号.

waitEvent = CreateEvent( 
    NULL,               // default security attributes
    FALSE,               // auto-reset event
    FALSE,              // initial state is nonsignaled
    TEXT("WaitEvent")  // object name
    ); 

for(;;)
{
   dwWaitResult = WaitForSingleObject(waitEvent, // event handle
        5000);    

  switch (dwWaitResult) 
  {
    // Event object was signaled
    case WAIT_OBJECT_0:
        consoleprintf(L"\r\nSuccess.");
        break; 

    case WAIT_FAILED:
    //break;
    case WAIT_ABANDONED:
        consoleprintf(L"\r\nWait failed.");
        break;
    case WAIT_TIMEOUT:
        consoleprintf(L"\r\nWait Timed out: %d", waitTime);
        break;
          default: 
        break; …

我正在使用.Net微框架,因此StringBuilder不可用.

我已经看到来自apt专业人员的一些代码使用chars的Arraylist来连接和构建字符串,而不是+运算符.它们本质上构建了一个托管代码StringBuilder.

这有性能优势吗？假设连接数大于10且字符串长度也大于10.

我正在将一个数组传递给一个函数,我很好奇是否有一种快速的方法来使用json样式数组初始化程序来传递一个匿名数组:

例如:

myfunction([1,2,3,4]);

javascript中是否有一些特殊的语法允许用非零索引初始化数组？

例如,而不是

myfunction([,,,,4321]);

//array[4] == 4321 here

但如果你有一个未定义前100个位置的数组,你必须有100个逗号.[,, ...,4321]

基本上寻找一个简短形式:

var a = new Array(); a[100] = 4321; 

您可以将其用作函数参数.

我要求一部分代码一次只能由一个线程运行(单个资源锁定).

lock(object)C#中的语句允许这样做.但是,它不会保留对锁的请求顺序.

例如,考虑下面的100个线程启动,其中编号的线程尝试按顺序锁定挂锁:

    for (int i = 0; i < 100; i++)
             {

            (new Thread(delegate(object index) 
               {
                  int name = (int) index;
                  byte[] len = new byte[2];

                  Console.WriteLine(string.Format("Thread:{0} going for lock. ",
                      name));
                  lock (padlock)
                  {

                     rnd.GetBytes(len);
                     ushort l = BitConverter.ToUInt16(len, 0);
                     Console.WriteLine(string.Format("Thread:{0} sleeping: {1}", 
                       name, l));
                     Thread.Sleep(l);
                  }
            })).Start(i);

实际授予访问权限的顺序并不完美(1-> 100)或NOT FIFO.然而,似乎确实存在"早期早期"EIEO模式(可能由堆运行？).

问题是:什么决定了锁定授予顺序,是否可以依赖于不使不幸的线程挨饿？

更新:这个答案解释了它.这是相关的引用(Joe Duffy在Windows上的并发编程):

因为监视器在内部使用内核对象,所以它们表现出与OS同步机制也表现出的相同的粗略FIFO行为(在前一章中描述).监视器是不公平的,因此如果另一个线程试图在唤醒的等待线程尝试获取锁之前获取锁,则允许偷偷摸摸的线程获取锁.