小编Den*_*sel的帖子

目前,我正在探索Visual Studio 2015 RC,并意识到Xamarin Studio已集成到Visual Studio及其安装程序中.我的问题是:Xamarin从现在开始是免费的吗？

与IntelliJ IDEA相比,Android Studio长期以来提供了更好的ide集成.

据我所知,IntelliJ IDE的第13版确实包含了以前版本缺少的所有功能.

我的问题是:Android Studio是否还有任何独有的功能,除了IntelliJ IDEA之外还有单独的安装是否有意义？

间谍实用程序Snoop使用一些强大的技术(可能是某种反射)来检查正在运行的WPF应用程序.最有趣的是,Snnop能够读出整个对象结构.

几天前,我下载了Snoop源代码,并花了一些时间研究内部行为.不幸的是,我还没知道Snoop是如何做这些事情的,所以我希望任何人都可以帮助我.

在工作中我正在编写一个Coded UI Testing-Framework,如果我可以访问应用程序的对象结构,那将是非常棒的,因为这样我不仅可以断言UI状态.

更新:

这是所需的代码:

string filePath = "WpfApp.exe";
AppDomain appDomain = AppDomain.CurrentDomain;
byte[] bytes = System.IO.File.ReadAllBytes(filePath);
Assembly ass = appDomain.Load(bytes);
ass.EntryPoint.Invoke(null, new object[] { });
IntPtr handle = Process.GetCurrentProcess().MainWindowHandle;
Window w = System.Windows.Interop.HwndSource.FromHwnd(handle).RootVisual as Window;

这对我来说已经是一个很大的帮助,但是了解Snoop如何将自己注入另一个进程也很有趣.

我实际上正在阅读有关任务并行库和使用async和await的异步编程的一些主题."Nutshell中的C#5.0"一书指出,在使用await关键字等待表达式时,编译器会将代码转换为如下所示:

var awaiter = expression.GetAwaiter();
awaiter.OnCompleted (() =>
{
var result = awaiter.GetResult();

让我们假设,我们有这个异步函数(也来自参考书):

async Task DisplayPrimeCounts()
{
for (int i = 0; i < 10; i++)
Console.WriteLine (await GetPrimesCountAsync (i*1000000 + 2, 1000000) +
" primes between " + (i*1000000) + " and " + ((i+1)*1000000-1));
Console.WriteLine ("Done!");
}

"GetPrimesCountAsync"方法的调用将在池化线程上排队并执行.通常,在for循环中调用多个线程有可能引入竞争条件.

那么CLR如何确保请求按照它们的顺序进行处理？我怀疑编译器只是将代码转换为上述方式,因为这会将'GetPrimesCountAsync'方法与for循环分离.

我正在研究如何正确创建弱引用事件处理程序.由于WPF已经有一个避免事件内存泄漏的解决方案,我反编译了"WeakEventManager"类并花了一些时间来分析它.

正如我所发现的,"WeakEventManager"类依赖于创建和存储对目标对象以及事件处理程序委托的弱引用.以下是一些代码段:

this._list.Add(new WeakEventManager.Listener(target, handler));


  public Listener(object target, Delegate handler)
  {
       this._target = new WeakReference(target);
       this._handler = new WeakReference((object) handler);
  }

我问自己,这个简单的解决方案是否已经有效,或者我忽略了一个重要方面,因为我在互联网上找到的大多数其他解决方案都很复杂且难以理解.到目前为止,我能找到的最佳解决方案是使用未绑定的委托.这是某种包装器委托,它将事件处理程序和事件订阅者实例作为参数(是的,它要求在委托调用期间传递事件订阅者对象).

你可以在这里找到这篇精彩的文章:

http://diditwith.net/CommentView,guid,aacdb8ae-7baa-4423-a953-c18c1c7940ab.aspx#commentstart

"WeakEventManager"类不依赖于知道订阅者类或任何其他信息.除此之外,它还可以与匿名代表合作.为什么开发人员花了这么多时间编写一个不仅工作而且使用方便的解决方案,如果解决方案只要求他们存储对委托的弱引用？有什么收获？

更新:因为有人贬低了这个问题(可能有点不明确),我想提出一个更精确的问题:

这个源代码首先是创建一个有效的弱事件处理程序吗？如果没有,缺少什么？

我正在尝试一个简单的基于ViewModel的WPF应用程序和一些原始导航逻辑.该应用程序包含两个视图(屏幕).一个屏幕包含一个按钮"前进",另一个屏幕包含一个"前进"按钮.通过按下其中一个按钮,可以调用委托命令,从而使shell视图模型切换活动屏幕.屏幕1切换到屏幕2,而屏幕2切换到屏幕1.

这种方法的问题在于它引入了竞争条件.当单击足够快时,有可能执行相应的操作(前进/后退)两次,从而导致应用程序失败.有趣的是,屏幕已经更改,但UI不会立即反映状态变化.到目前为止,我从来没有经历过这种差距,我做了这个实验只是为了证明单线程(调度)WPF应用程序是自动线程安全的.

有人对这种奇怪的行为有解释吗？WPF绑定机制是否太慢,以便可以再次按下按钮,直到UI更新自身以表示新的屏幕状态？

根据开发mvvm应用程序的建议,我不知道如何解决这个问题.没有办法同步代码,因为只有一个线程.我希望你能帮助我,因为现在依靠WPF数据绑定和模板系统我感到非常不安全.

包含项目文件的Zip存档

MainWindow.xaml:

<Window x:Class="MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApplication1"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Window.Resources>
        <DataTemplate DataType="{x:Type local:Screen1}">
            <local:View1/>
        </DataTemplate>
        <DataTemplate DataType="{x:Type local:Screen2}">
            <local:View2/>
        </DataTemplate>
    </Window.Resources>
    <Window.DataContext>
        <local:ShellViewModel/>
    </Window.DataContext>
    <Grid>
        <ContentControl Content="{Binding CurrentScreen}"/>
    </Grid>
</Window>

该ShellViewModel含有"前进"和"后退去"的方法:

Public Class ShellViewModel
    Inherits PropertyChangedBase

    Private _currentScreen As Object
    Public Property Screens As Stack(Of Object) = New Stack(Of Object)()

    Public Sub New()
        Me.Screens.Push(New Screen1(Me))
        Me.GoForward()
    End Sub

    Property CurrentScreen As Object
        Get
            Return _currentScreen
        End Get
        Set(value)
            _currentScreen = …

我在使用 async 和 await 时遇到了奇怪的行为。如果我尝试等待手动创建的任务 T1，它本身应该等待另一个任务 T2，即使任务 T2 仍在等待，任务 T1 已经运行完成。

为了说明这个问题，我写了一些代码。当我从此示例中运行“task1”时，输出为：

task1 运行完成更新...

当我运行“task2”时，输出总是：

正在更新... task2 运行完成

有没有人解释为什么第一个等待表达式不依赖于内部等待？

private void OnLoaded(object sender, RoutedEventArgs e)
{
    var task1 = new Task(async () => await UpdateAfterDelay());
    task1.Start();
    await task1;
    Console.WriteLine("task1 ran to completion");

    var task2 = Task.Run(async () => await UpdateAfterDelay());
    await task2;
    Console.WriteLine("task2 ran to completion");
}

private async Task UpdateAfterDelay()
{
    await Task.Delay(2000);
    Console.WriteLine("updating...");
}