.NET中STAThread的使用詳解_.Net教程

推薦：.NET中RDLC循環(huán)處理數(shù)據(jù)的應(yīng)用分析
本篇文章介紹了，.NET中RDLC循環(huán)處理數(shù)據(jù)的應(yīng)用分析。需要的朋友參考下

在WindowForm應(yīng)用程序中主要的線程，是采用一種稱為「Single-Threaded Apartment(STA)」的線程模型。這個(gè)STA線程模型，在線程內(nèi)加入了訊息幫浦等等機(jī)制，減少開發(fā)人員撰寫窗口程序的工作量。

而在開發(fā)類別庫的時(shí)候，如果要使用類似的STA線程模型，可以使用下列的程序代碼提供的類別來完成。

復(fù)制代碼代碼如下:hl5o.cn

namespace CLK.Threading
{
public class STAThread
{
// Enum
private enum ThreadState
{
Started,
Stopping,
Stopped,
}

// Fields
private readonly object _syncRoot = new object();

private readonly BlockingQueue<Action> _actionQueue = null;

private Thread _thread = null;

private ManualResetEvent _threadEvent = null;

private ThreadState _threadState = ThreadState.Stopped;

// Constructor
public STAThread()
{
// ActionQueue
_actionQueue = new BlockingQueue<Action>();

// ThreadEvent
_threadEvent = new ManualResetEvent(true);

// ThreadState
_threadState = ThreadState.Stopped;
}

// Methods
public void Start()
{
// Sync
lock (_syncRoot)
{
// ThreadState
if (_threadState != ThreadState.Stopped) throw new InvalidOperationException();
_threadState = ThreadState.Started;
}

// Thread
_thread = new Thread(this.Operate);
_thread.Name = string.Format("Class:{0}, Id:{1}", "STAThread", _thread.ManagedThreadId);
_thread.IsBackground = false;
_thread.Start();
}

public void Stop()
{
// Sync
lock (_syncRoot)
{
// ThreadState
if (_threadState != ThreadState.Started) throw new InvalidOperationException();
_threadState = ThreadState.Stopping;

// ActionQueue
_actionQueue.Release();
}

// Wait
_threadEvent.WaitOne();
}

public void Post(SendOrPostCallback callback, object state)
{
#region Contracts

if (callback == null) throw new ArgumentNullException();

#endregion

// Action
Action action = delegate()
{
try
{
callback(state);
}
catch (Exception ex)
{
Debug.Fail(string.Format("Delegate:{0}, State:{1}, Message:{2}", callback.GetType(), "Exception", ex.Message));
}
};

// Sync
lock (_syncRoot)
{
// ThreadState
if (_threadState != ThreadState.Started) throw new InvalidOperationException();

// ActionQueue
_actionQueue.Enqueue(action);
}
}

public void Send(SendOrPostCallback callback, object state)
{
#region Contracts

if (callback == null) throw new ArgumentNullException();

#endregion

// Action
ManualResetEvent actionEvent = new ManualResetEvent(false);
Action action = delegate()
{
try
{
callback(state);
}
catch (Exception ex)
{
Debug.Fail(string.Format("Delegate:{0}, State:{1}, Message:{2}", callback.GetType(), "Exception", ex.Message));
}
finally
{
actionEvent.Set();
}
};

// Sync
lock (_syncRoot)
{
// ThreadState
if (_threadState != ThreadState.Started) throw new InvalidOperationException();

// ActionQueue
if (Thread.CurrentThread != _thread)
{
_actionQueue.Enqueue(action);
}
}

// Execute
if (Thread.CurrentThread == _thread)
{
action();
}

// Wait
actionEvent.WaitOne();
}

private void Operate()
{
try
{
// Begin
_threadEvent.Reset();

// Operate
while (true)
{
// Action
Action action = _actionQueue.Dequeue();

// Execute
if (action != null)
{
action();
}

// ThreadState
if (action == null)
{
lock (_syncRoot)
{
if (_threadState == ThreadState.Stopping)
{
return;
}
}
}
}
}
finally
{
// End
lock (_syncRoot)
{
_threadState = ThreadState.Stopped;
}
_threadEvent.Set();
}
}
}
}

復(fù)制代碼代碼如下:hl5o.cn

namespace CLK.Threading
{
    public class BlockingQueue<T>
    {
        // Fields       
        private readonly object _syncRoot = new object();

        private readonly WaitHandle[] _waitHandles = null;

        private readonly Queue<T> _itemQueue = null;

        private readonly Semaphore _itemQueueSemaphore = null;

        private readonly ManualResetEvent _itemQueueReleaseEvent = null;

 
        // Constructors
        public BlockingQueue()
        {
            // Default
            _itemQueue = new Queue<T>();
            _itemQueueSemaphore = new Semaphore(0, int.MaxValue);
            _itemQueueReleaseEvent = new ManualResetEvent(false);
            _waitHandles = new WaitHandle[] { _itemQueueSemaphore, _itemQueueReleaseEvent };
        }

 
        // Methods
        public void Enqueue(T item)
        {
            lock (_syncRoot)
            {
                _itemQueue.Enqueue(item);
                _itemQueueSemaphore.Release();
            }
        }

        public T Dequeue()
        {
            WaitHandle.WaitAny(_waitHandles);
            lock (_syncRoot)
            {
                if (_itemQueue.Count > 0)
                {
                    return _itemQueue.Dequeue();
                }
            }
            return default(T);
        }

        public void Release()
        {
            lock (_syncRoot)
            {
                _itemQueueReleaseEvent.Set();
            }
        }

        public void Reset()
        {
            lock (_syncRoot)
            {
                _itemQueue.Clear();
                _itemQueueSemaphore.Close();
                _itemQueueReleaseEvent.Reset();
            }
        }
    }
}