小编Ric*_*bob的帖子

常见的情形:具有项目模型集合的模型.
例如一个有人的集合的房子.

如何正确地为MVVM构造这一点 - 特别是在使用添加和删除更新Model和ViewModel集合方面？

模型House包含模型的集合People(通常为a List<People>).
视图模型HouseVM包含它包装的House对象和视图模型的ObservableCollection PeopleVM(ObservableCollection<PeopleVM>).请注意,我们最终会在HouseVM中保存两个集合(需要同步):
1.2 HouseVM.House.List<People>
.HouseVM.ObservableCollection<PeopleVM>

当House更新为新人(添加)或人员离开(删除)时,现在必须在两个集合中处理该事件: Model House People集合和 VM HouseVM PeopleVM ObservableCollection.

这个结构是否正确MVVM？
反正是否有必要对添加和删除进行双重更新？

我有一个带有验证规则的TextBox,它位于TabControl的选项卡上.验证规则失败时,默认的ErrorTemplate正确显示(TextBox周围的红色边框).
但是,如果切换到另一个选项卡,然后使用TextBox返回选项卡,则ErrorTemplate hightlight将消失.如果TextBox中有更改,则仍会调用验证规则并返回false,但仍未显示错误突出显示.
只有当文本内容被更改为有效然后再次无效时才会重新亮相.
我希望如果文本内容无效,切换到另一个选项卡并返回保持无效突出显示.任何想要获得这种行为的想法都是最受欢
xaml:

<TextBox Height="35" >
  <TextBox.Text>
    <Binding Path="pan_id" UpdateSourceTrigger="PropertyChanged">
      <Binding.ValidationRules>
        <ps:PanIdValidation />
      </Binding.ValidationRules>
    </Binding>
  </TextBox.Text>
</TextBox>

我有一些控制台和wpf应用程序使用的库代码.在库代码中,有一些Console.Read()调用.如果应用程序是一个控制台应用程序,我只想做那些输入读取,如果它是一个GUI应用程序 - 如何在dll中告诉应用程序是否有控制台？

我有一个blackbox对象,它暴露了一个异步操作的方法,并在操作完成时触发一个事件.我已经将它包装到一个Task<OpResult> BlackBoxOperationAysnc()使用TaskCompletionSource 的方法中 - 效果很好.

但是,在那个异步包装器中,如果在给定的超时后没有收到事件,我想管理用超时错误完成异步调用.目前我使用计时器管理它:

public Task<OpResult> BlackBoxOperationAysnc() {
    var tcs = new TaskCompletionSource<TestResult>();   
    const int timeoutMs = 20000;
    Timer timer = new Timer(_ => tcs.TrySetResult(OpResult.Timeout),
                            null, timeoutMs, Timeout.Infinite);

    EventHandler<EndOpEventArgs> eventHandler = (sender, args) => {
        ...
        tcs.TrySetResult(OpResult.BlarBlar);
    }
    blackBox.EndAsyncOpEvent += eventHandler;
    blackBox.StartAsyncOp();
    return tcs.Task;
}

这是管理超时的唯一方法吗？有没有设置我自己的计时器 - 我在TaskCompletionSource中看不到任何超时？

public struct Test 
{
    public double Val;
    public Test(double val = double.NaN) { Val = val; }
    public bool IsValid { get { return !double.IsNaN(Val); } }
}

Test myTest = new Test();
bool valid = myTest.IsValid;

上面给出了valid==true因为没有调用默认arg的构造函数,并且使用标准默认值val = 0.0创建了对象.
如果结构是一个类,那么行为就是valid==false我所期望的.

我发现这种行为上的差异,特别是结构案例中的行为令人惊讶和不直观 - 发生了什么？stuct构造的默认arg服务是什么？ 如果它无用为什么要让这个编译？

更新:澄清这里的重点不在于行为是什么 - 而是为什么在没有警告的情况下进行编译并且行为不直观.即如果没有应用默认的arg,因为在新的Test()情况下没有调用构造函数,那么为什么要让它编译？

回顾一些第三方C代码我遇到了类似的事情:

switch (state) {
case 0: 
    if (c=='A') { // open brace
        // code...
    break; // brace not closed!
case 1:
    // code...
    break;
    } // close brace!
case 2:
    // code...
    break;
}

在我正在审查的代码中看起来只是一个错字,但我很惊讶它编译时没有错误.

为什么这个有效的C？
与在预期位置关闭支撑相比,对此代码执行的影响是什么？
有什么情况可以使用吗？

编辑:在示例中,我查看了存在的所有中断(如上所述) - 但如果在0或1的情况下中断,则答案还可以包括行为.

IDisposable关于处理非托管资源的"标准完整" 实现有很多信息- 但实际上这种情况非常罕见(大多数资源已经被托管类包装).这个问题集中在更常见的"仅限托管资源"案例的IDisposable的最小实现上.

1:IDisposable下面的代码中的mimimal实现是否正确,是否存在问题？

2:是否有任何理由增加一个完整的标准IDisposable执行(Dispose(),Dispose(bool),Finalizer等)在最小的执行力度呈现的？

3:在这个极小的情况下,制作Dispose虚拟(因为我们没有提供Dispose(bool))是否可行/明智？

4:如果这个最小的实现被一个包含(在这种情况下是无用的)终结器的完整标准实现替换 - 这会改变GC处理对象的方式吗？有什么缺点吗？

5:示例包括Timer与事件处理程序,因为这些情况下,尤其重要的是不能错过的无法处理它们会保持对象活蹦乱跳(this在的情况下Timer,eventSource在事件处理程序的情况下),直到GC得到轮在释放他们是时候了.还有其他这样的例子吗？

class A : IDisposable {
    private Timer timer;
    public A(MyEventSource eventSource) {
        eventSource += Handler
    }

    private void Handler(object source, EventArgs args) { ... }

    public virtual void Dispose() {
        timer.Dispose();
        if (eventSource != null)
           eventSource -= Handler;
    }
}

class B : A, IDisposable {
    private …

假设我们有2个工作函数:

void Step1(); // Maybe long.
void Step2(); // Might be short clean up of step 1.

我经常看到:

Task.Run(() => Step1()).ContinueWith(t => Step2());

这创建了2个串行运行的任务.什么时候:

Task.Run(() => { Step1(); Step2(); });

这将创建一个单独的任务运行于2个功能系列,看起来似乎是一个简单的选择.

是否有常识性指南可用于确定何时对更简单的方法进行延续是否需要延续？
上面的例子没有异常处理 - 异常处理对这些指导有何影响？

TaskStatus Enum或Task.Exception MSDN似乎都没有明确说明:

是否TasksStatus.Faulted总是意味着Task.Exception != null(并且TaskStatus != Faulted总是暗示Task.Exception == null)？

在C++/CLI中有什么方法可以执行以下操作吗？(我认为答案是否定的,因为没有行动支持？)

public ref class MyClass {
public:
    void TaskMethod();
    void Start();
}

void MyClass::Start() {
    Task^ myTask = Task::Factory->StartNew(??TaskMethod??);
}