相关疑难解决方法(0)

换句话说,这个Singleton实现线程是否安全:

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

    static Singleton()
    {
        instance = new Singleton();
    }

    public static Singleton Instance
    {
        get { return instance; }
    }
}

我正在尝试在C#中创建线程安全属性,我想确保我在正确的路径上 - 这就是我所做的 -

private readonly object AvgBuyPriceLocker = new object();
private double _AvgBuyPrice;
private double AvgBuyPrice 
{
    get
    {
        lock (AvgBuyPriceLocker)
        {
            return _AvgBuyPrice;
        }
    }
    set
    {
        lock (AvgBuyPriceLocker)
        {
            _AvgBuyPrice = value;
        }
    }
}

阅读这篇文章,似乎这不是正确的做法 -

C#线程安全与get/set

但是,这篇文章似乎暗示,

http://www.codeproject.com/KB/cs/Synchronized.aspx

有没有人有更明确的答案？

编辑:

我想为此属性执行Getter/Setter的原因是b/c我实际上希望它在设置时触发事件 - 所以代码实际上就像这样 -

public class PLTracker
{

    public PLEvents Events;

    private readonly object AvgBuyPriceLocker = new object();
    private double _AvgBuyPrice;
    private double AvgBuyPrice 
    {
        get
        {
            lock (AvgBuyPriceLocker)
            {
                return _AvgBuyPrice;
            }
        }
        set …

我在类中有属性定义,我只有计数器,这必须是线程安全的,这不是因为get并且set不在同一个锁中,如何做到这一点？

    private int _DoneCounter;
    public int DoneCounter
    {
        get
        {
            return _DoneCounter;
        }
        set
        {
            lock (sync)
            {
                _DoneCounter = value;
            }
        }
    }

问题是如何INotifyPropertyChanged在静态属性上实现,因为您实现的事件不是静态的,并且不能由静态属性调用.此外,您无法绑定到Silverlight中的静态属性.

我已经看到这个问题在一些论坛中出现了各种各样的解决方案,其中没有一个非常令人满意.

嗯,我想我已经找到了一个优雅的解决方案,但它很简单,我觉得我必须遗漏一些东西.

答案是,编写一个访问静态变量的非静态属性,如下所示:

    private static double length;
    public double Length
    {
        get
        {
            return length;
        }
        set
        {
            length = value;
            NotifyPropertyChanged("Length");
        }
    }

我已经测试了它,似乎工作得很好.我错过了什么吗？

以下对象线程是否安全？我将创建一个实例并使用两个或多个线程来使用它,这是一个很好的方法来解决这个问题吗？

public class ASyncBuffer<T>
{
    readonly object _locker = new object();
    private T _value;
    private bool _dirty;

    public T GetValue()
    {
        lock (_locker)
        {
            _dirty = false;
            return _value;
        }
    }

    public void SetValue(T value)
    {
        lock (_locker)
        {
            _dirty = true;
            _value = value;
        }
    }

    public bool Dirty
    {
        get
        {
            lock (_locker)
            {
                return _dirty;
            }
        }
    }
}

我一直在阅读周围的内容，并得到了关于我是否应该在属性上使用同步锁的相互矛盾的答案。

我有一个多线程应用程序，需要跨线程获取/设置实例对象的属性。目前它是在不使用同步锁的情况下实现的，到目前为止我还没有注意到任何问题。我在常见的静态方法上使用同步锁，但我想以线程安全的方式正确实现我的实例类。

任何反馈将不胜感激。