小编Bri*_*eon的帖子

所以我正在完成我的第一个WPF项目,我喜欢到目前为止看到的内容.学习曲线比我预期的要多,但WPF非常酷.但是,我正在努力解决数据绑定概念.我遇到的一个具体问题是如何使我的数据绑定声明重构安全？考虑这个例子.

public class MyDataObject
{
  public string FooProperty { get; set; }
}

void Bind() 
{
  var gridView = myListView.View as GridView;
  gridView.Columns.Clear();
  gridView.Columns.Add(
    new GridViewColumn() 
      { 
        Header = "FooHeader", 
        DisplayMember = new Binding("FooProperty")
      }
    );
  List<MyDataObject> source = GetData();
  myListView.ItemsSource = source;
}

那么如果我将数据对象上的FooProperty重命名为其他内容呢？数据绑定将无效,我不会收到编译错误,因为绑定是通过文本声明的.有没有办法让绑定更安全一点？

请考虑以下简短代码段.

namespace B
{
    public class Foo
    {
        public string Text
        {
            get { return GetType().FullName; }
        }
    }
}

namespace A.B
{
    public class Foo
    {
        public string Text
        {
            get { return GetType().FullName; }
        }
    }
}

首先熟悉示例#1.

using B;

namespace A.C
{
    public static class Program
    {
        public static void Main()
        {
            Console.WriteLine(new Foo().Text);
        }
    }
}

现在考虑示例#2.

namespace A.C
{
    using B; // Notice the placement here.

    public static class Program
    { …

using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Taking data from Main Thread\n->");
        string message = Console.ReadLine();

        ThreadStart newThread = new ThreadStart(delegate { Write(message); });

        Thread myThread = new Thread(newThread);

    }

    public static void Write(string msg)
    {
        Console.WriteLine(msg);
        Console.Read();
    }
}
}

任何人都可以在平行编程.net 4.0中与我分享"虚假共享"的知识吗？如果你能用一个例子来解释,那就太棒了.提前致谢 .我想要我的代码的最大性能.

这是一个例子:

if (control.InvokeRequired)
{
    control.BeginInvoke(action, control);
}
else
{
    action(control);
}

例如,如果在条件和BeginInvoke调用之间调用控件,该怎么办？

另一个与事件有关的例子:

var handler = MyEvent;

if (handler != null)
{
    handler.BeginInvoke(null, EventArgs.Empty, null, null);
}

如果MyEvent在第一行和if语句之间取消订阅,则仍将执行if语句.但是,这是正确的设计吗？如果使用取消订阅也会破坏正确调用事件所需的状态？这个解决方案不仅具有更多代码行(样板文件),而且它不直观,并且可能导致客户端出现意外结果.

怎么说你呢？

可以将两个值从WebService返回到jQuery.

我尝试过

[WebMethod(EnableSession = true)]
public string testing(string testId)
{
    string data = string.Empty;
    string data1 = string.Empty;
    List<test1> datalist1 = new List<test1>();
    List<test> datalist = new List<test>();

    //coding
    data = jsonSerialize.Serialize(datalist1);
    data1 = jsonSerialize.Serialize(datalist);
    return [data,data1];
}

但它显示错误....我们如何从webservice返回两个值.....

我有以下代码创建10个线程,然后将消息写入控制台:

for (int i = 0; i < 10; i++)
{
    {
        Thread thread = new Thread((threadNumber) =>
            {
                for (int j = 0; j < 10; j++)
                {
                    Thread.Sleep(200);
                    Console.WriteLine(string.Format("Thread: {0}, Line: {1}", threadNumber, j));
                }                           
            });
        thread.Start(i);
    }
}

我的理解是ParameterizedThreadStart将一个引用副本的对象发送到该线程.如果是这种情况,因为我没有i在每个循环中创建一个本地副本,所有新线程将指向相同的内存位置,这意味着某些线程号可能被"遗漏".虽然运行了这个(甚至对更多的线程/休眠时间),每个值i都有自己的线程.有谁能解释为什么？

今晚我与约束执行区一起玩耍，以更好地完善我对更好细节的理解。我以前曾经使用过它们，但是在那种情况下，我主要严格遵守既定模式。无论如何，我注意到了一些我无法完全解释的奇特之处。

考虑下面的代码。注意，我的目标是.NET 4.5，并在没有附加调试器的情况下使用Release版本对其进行了测试。

public class Program
{
    public static void Main(string[] args)
    {
        bool toggle = false;
        bool didfinally = false;
        var thread = new Thread(
            () =>
            {
                Console.WriteLine("running");
                RuntimeHelpers.PrepareConstrainedRegions();
                try
                {
                    while (true) 
                    {
                      toggle = !toggle;
                    }
                }
                finally
                {
                    didfinally = true;
                }
            });
        thread.Start();
        Console.WriteLine("sleeping");
        Thread.Sleep(1000);
        Console.WriteLine("aborting");
        thread.Abort();
        Console.WriteLine("aborted");
        thread.Join();
        Console.WriteLine("joined");
        Console.WriteLine("didfinally=" + didfinally);
        Console.Read();
    }
}

您认为该程序的输出是什么？

1. didfinally =真
2. didfinally =假

在猜测之前，请阅读文档。我在下面包括相关部分。

约束执行区（CER）是创作可靠的托管代码的机制的一部分。CER定义了一个区域，在该区域中，公共语言运行库（CLR）受到约束，无法抛出带外异常，这将阻止该区域中的代码整体执行。在该区域内，用户代码无法执行代码，从而导致抛出带外异常。PrepareConstrainedRegions方法必须立即在try块之前，并将catch块，fault块和Fault块标记为受约束的执行区域。一旦标记为受约束区域，代码就只能调用具有强可靠性合同的其他代码，并且除非代码准备好处理失败，否则代码不应分配或对未准备好的方法或不可靠的方法进行虚拟调用。对于在CER中执行的代码，CLR延迟线程中止。

和

可靠性try / catch / finally是一种异常处理机制，具有与非托管版本相同的可预测性保证。 …

只是在我的业余时间玩弄并发,并希望尝试防止撕裂读取而不使用读取器端的锁定,因此并发读取器不会相互干扰.

想法是通过锁序列化写入,但在读取端只使用内存屏障.这是一个可重用的抽象,它封装了我提出的方法:

public struct Sync<T>
    where T : struct
{
    object write;
    T value;
    int version; // incremented with each write

    public static Sync<T> Create()
    {
        return new Sync<T> { write = new object() };
    }

    public T Read()
    {
        // if version after read == version before read, no concurrent write
        T x;
        int old;
        do
        {
            // loop until version number is even = no write in progress
            do
            {
                old = version;
                if (0 == (old & …

我有一个多线程应用程序,我需要在一定时间后取消每个任务,即使在取消时,他们使用非托管资源.现在我使用以下代码(例如,控制台应用程序).在实际应用中,延迟可能发生在非托管资源中.

static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            Task.Factory.StartNew(Do, TaskCreationOptions.LongRunning);
        }

        Console.ReadLine();
    }

    private static void Do()
    {
        new Timer(Thread.CurrentThread.Abort, null, 1000, -1);

        try
        {
            Console.WriteLine("Start " + Task.CurrentId);
            Thread.Sleep(2000);
            Console.WriteLine("End " + Task.CurrentId);
        }
        catch (Exception)
        {
            Console.WriteLine("Thread Aborted " + Task.CurrentId);
        }
    }

得到结果:

但从安全角度来看,我不确定它是否适合真正的应用.我也在不同的变种中使用了CancellationToken,但是它没有给我正确的结果,因为我在使用CancellAfter()或.Delay()时使用了时间跨度并且在获得时间后取消任务我获得了以下结果:

static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            var clt = new CancellationTokenSource();

            Task task = new Task(() =>
            { …