小编Ala*_*ain的帖子

当用户从组合框中选择值时,如果他们选择了一个值,则会触发"SelectionChanged"事件,并设置新值并且一切正常.但是,如果他们决定不更改值并单击UI上的其他位置(如他们想要编辑的文本框),则必须单击两次 - 第一次单击只需关闭组合框弹出窗口,下一次单击将关注他们想要在第一次点击时激活的元素.

如何防止组合框弹出窗口在第一次点击时劫持焦点目标？

我已经尝试过监视ComboBox_LostFocus事件,但这会在错误的时间触发.当用户单击下拉列表并显示弹出列表时,ComboBox_LostFocus事件将触发 - 它将失去焦点到它自己的下拉列表.我不想做任何改变.当用户点击然后弹出窗口关闭时,ComboBox永远不会重新获得焦点(焦点只是'丢失'到所有东西),因此这个事件是无用的.

我不太确定如何处理这个问题。我使用了一堆带有下拉值列表的组合框，我们也允许用户设置属性。（即货币=“美元、加元、欧元”）。

有时，当我们加载数据时，我们会发现该货币不在我们的列表中，例如“AUD”。在这种情况下，我们仍然希望组合框显示加载的值，并且当前选择的货币应保持“AUD”，除非用户选择更改它，在这种情况下，他们唯一的选项仍然是“USD、CAD、EUR”。

我的问题是，一旦控件变得可见，ComboBox 就会调用我的 SelectedCurrency 属性上的 setter 并将其设置为null，大概是因为当前值“AUD”不在其列表中。如何禁用此行为而不让用户可以在“货币”字段中输入他们想要的任何内容？

如果我们的独立应用程序只是一个下载的.exe文件(即使用Windows安装程序部署),那么使用正在运行的实例启动第二个实例将非常简单System.Diagnostics.Process.Start.不幸的是,我们的WPF应用程序是通过VIA ClickOnce部署的,因此据我所知,它没有本地文件系统路径.

如何启动正在运行的ClickOnce应用程序的第二个实例？(如果可能的话,传递命令行参数.)

我正在寻找一种扩展方法或任何其他建议,可以帮助我尽可能简洁地使用此代码.

foreach( Layer lyr in this.ProgramLayers )
  foreach( UWBCEvent evt in this.BcEvents.IncludedEvents )
    EventGroupLayerLosses[new EventGroupIDLayerTuple(evt.EventGroupID, lyr)] += 
       GetEL(evt.AsIfs, lyr.LimitInMillions, lyr.AttachmentInMillions);

上面的代码有一个相当明确的目的,我用一个复合键将值分成组.但是,此代码将失败,因为字典最初为空,而+ =运算符将不知道在0处启动存储桶.

我能想到的最好的是:

public V AddOrSet<K, V>(this Dictionary<K, V> dict, K key, V value)
{
    if( dict.ContainsKey(key) )
        dict[key] += value;
    else
        dict[key] = value;
}

但是,当然,即使这样也无法编译,因为没有办法限制V的类型,使得运算符+=存在.

规则

• 只有一次迭代通过double for循环.在使用0值初始化字典之前不允许循环一次.
• 可以使用辅助方法或扩展方法,但我希望内循环是一个衬里.
• 尽可能通用且可重用,这样我就不需要为不同类型(小数,整数等)的类似存储创建一堆相同的函数.

作为参考 - 在类的其他地方,键被定义为一个实际的元组(只有命名参数),这就是为什么它可以用作字典键:

private Dictionary<EventGroupIDLayerTuple, Decimal> _EventGroupLayerLosses;
public class EventGroupIDLayerTuple : Tuple<Int32, Layer>
{
    public EventGroupIDLayerTuple(Int32 EventGroupID, Layer Layer) : base(EventGroupID, Layer) { }
    public Int32 …

我刚开始使用node.js,从目前为止我所知道的,客户端与服务器通信的方式是:

//Client Code 1
var iosocket = io.connect();
iosocket.on('connect', function () {
   iosocket.send("Here's some info");
});

收到"消息"事件后服务器会发现这种情况:

//Server Code 1
var socketio = require('socket.io');
var io = socketio.listen(server);
io.sockets.on('connection', function (client) {    
    client.on('message', function(msg) {
        //msg== "Here's some info"
    }
});

现在我希望客户端能够提供几个不同的事件,例如:

//Server Code 2
client.on('buttonClicked', function() { ...
client.on('nameChanged', function(newName) { ...

但我无法弄清楚如何.我可以使用我所拥有的部分找到的唯一解决方案是发回消息,但让它们包含键值对信息:

//Server Code 3
client.on('message', function(msg) {
   kvp = message.split(',');
   if( kvp[0] == 'buttonClicked' )
      ...
   else if( kvp[0] == 'nameChanged' )
      ...
}

但我确信有一种正确的方法,我还没有在任何例子中看到过.我希望有类似于服务器如何生成它想要使用的任何事件:

//Server Code …

我有一个非常大的枚举，并且正在准备对其进行昂贵的延迟操作（例如对其进行排序）。然后，我将其传递给一个函数，该函数可能会也可能不会消耗 IEnumerable，具体取决于其自身的某些逻辑。

这是一个例子：

IEnumerable<Order> expensiveEnumerable = fullCatalog.OrderBy(c => Prioritize(c));
MaybeFullFillSomeOrders(expensiveEnumerable);

// Elsewhere... (example use-case for multiple enumerations, not real code)
void MaybeFullFillSomeOrders(IEnumerable<Order> nextUpOrders){
    if(notAGoodTime())
       return;
    foreach(var order in nextUpOrders)
       collectSomeInfo(order);
    processInfo();
    foreach(var order in nextUpOrders) {
       maybeFulfill(order);
       if(atCapacity())
          break;
    }
}

我想准备对其他函数的输入，以便：

1. 如果它们不消耗可枚举值，则不会付出排序的性能代价。
   • 这已经阻止了调用例如ToList()或ToArray()它
2. 如果他们选择多次枚举（也许没有意识到在这种情况下会有多昂贵），我希望采取一些防御措施来防止多次枚举。
3. 理想情况下，结果仍然是IEnumerable<T>

我想出的最好的解决方案是使用Lazy<>

var expensive = new Lazy<List<Order>>>(
    () => fullCatalog.OrderBy(c => Prioritize(c)).ToList());

这似乎满足标准 1 和 2，但有一些缺点：

• 我必须更改所有下游用途的接口才能期望Lazy.
• 完整列表（在本例中是由多个较小的分区构建的SelectMany()）需要在内存中分配为新的单个连续列表。如果我想“缓存”排序结果，我不确定是否有一种简单的方法可以解决这个问题，但如果你知道有一种方法，我会洗耳恭听。

我必须解决第一个问题的一个想法是包装Lazy<>一些自定义类，该类可以实现或可以隐式转换为IEnumerable<T>，但我希望有人知道一种更优雅的方法。

我想创建一个自定义 observable 集合（可以在 XAML 中绑定），但我想跟踪需要覆盖 observable 集合方法的其他信息。ObservableCollection 方法不是虚拟的，这意味着“覆盖”它们的唯一方法实际上只是使用“new”关键字隐藏它们。这是我的意思的一个简单示例：

//Tracks how many objects of each type are in this collection
class CustomCollectionInherited:ObservableCollection<Object>
{
    private Dictionary<Type, UInt32> _count = new Dictionary<Type,uint>();

    public UInt32 getTypeCount(Type T)
    {
        return _count[T];
    }

    #region Base Method 'Overrides'

    new public void Add(Object item)
    {
        base.Add(item);
        if (!_count.ContainsKey(item.GetType())) {
            _count[item.GetType()] = 1;
        } else {
            _count[item.GetType()] += 1;
        }
    }

    new public bool Remove(Object item)
    {
        if (base.Remove(item))
        {
            _count[item.GetType()] -= 1;
            return true;
        }
        return …

我正在尝试在我的xaml中定义一个本地资源,它应该是我的单元格的宽度,所以不要去:

<Setter Property="ColumnStretchMinWidth" Value="75"/>
<Textbox Width="75" />
<ColumnDefinition Width="*" MinWidth="75" />
...etc

我可以去

<Setter Property="ColumnStretchMinWidth" Value="{StaticResource MinCellWidth}"/>
<Textbox Width="{StaticResource MinCellWidth}" />
<ColumnDefinition Width="*" MinWidth="{StaticResource MinCellWidth}" />

但是当我定义这个常量时,我​​会遇到绑定错误,说它无法转换.我走的时候

<System:String x:Key="MinCellWidth">"75"</s:String>

我收到一个错误,说某些控件无法从String转换为Double.我走的时候

<System:Double x:Key="MinCellWidth">"75"</s:Double>

我得到一个错误,说它不能从Double转换为字符串用于其他控件(比如ColumnDefinition,其中允许使用"*"宽度).

什么是硬编码的神奇类型="75",可以将其转换为每个控件的适当类型.如何定义可在所有这些不同位置使用的资源？

清空Scripting.DictionaryExcel表格的最快方法是什么？这就是我现在正在做的事情,但是对于一个包含大约3000个元素的字典,它显然很慢.我做了我能想到的每一个优化.

这是我所拥有的一个简单的版本:

'wordCount and emailCount are late bound "Scripting.Dictionary" objects
Private Sub DictionaryToExcel(ByRef wordCount As Object, emailCount As Object)
    oExcel.EnableEvents = False
    oExcel.ScreenUpdating = False
    Set oWorkbook = oExcel.Workbooks.Add
    oExcel.Calculation = -4135
    With oWorkbook.Sheets(1)
        iRow = 1
        For Each strKey In wordCount.Keys()
            iWordCount = wordCount.Item(strKey)
            iEmailCount = emailCount.Item(strKey)
            If iWordCount > 2 And iEmailCount > 1 Then
                .Cells(iRow, 1) = strKey
                .Cells(iRow, 2) = iEmailCount
                .Cells(iRow, 3) = iWordCount
                iRow = iRow + 1
            End If
        Next strKey …

我在这里理解这个故事:

• PC寄存器保存指向下一条指令的指针
• LDR指令将第二个操作数的值加载到第一个操作数中(例如)

  LDR r0, [pc, 0x5678]

  相当于这个"C代码"

  r0 = *(pc + 0x5678)
  

  它是使用基本偏移量解引用的指针.

我的问题是:

我找到了这段代码

LDR PC, [PC,-4]

它被评论为猴子修补等.

我如何理解这段代码

pc = *(pc - 4)

在这种情况下,"pc"寄存器将取消引用前一条指令的地址,并将包含指令的"机器代码"(不是指令的地址),程序将跳转到该无效地址继续执行,可能我们将"分段故障".那么我缺少或不理解？

让我思考的是LDR指令中第二个操作数的括号.据我所知,x86架构上的括号已经取消引用指针,但我无法理解ARM架构中的含义.

mov r1, 0x5678
add r1, pc
mov r0, [r1]

这段代码相当于？

LDR r0, [pc, 0x5678]