C#

bobmitch wrote:

This will always use the parent intersect function and not the appropriate child function

public virtual Intersection()
{
   // This is the base implementation.
}

...

public override Intersection()
{
    // This is the derived implementation.
}

loke6258038 wrote:

What will o eventually point to?

loke6258038 wrote:

if eventually o point to A, then what happen to int and String object?

GuyThiebaut wrote:

I suppose C++ would be the direction to go for this sort of speed?

// make a queue:
SynchronisedQueue<string> queue = new SynchronisedQueue<string>;

// send this reference along to the background thread:
IQueueWriter<string> writer = queue;

// from the background thread you put items in the queue:
writer.Enqueue("something");

// in the timer in the UI thread you read the queue and display it somehow:
string info;
while (queue.TryDequeue(out info)) {
   labelInfo.Text = info;
}

public interface IQueueReader<T> {
	bool TryDequeue(out T value);
}

public interface IQueueWriter<T> {
	void Enqueue(T value);
}

public class SynchronisedQueue<T> : IQueueReader<T>, IQueueWriter<T> {

	#region Private variables

	private Queue<T> _queue;
	private object _sync;

	#endregion

	#region Constructor

	public SynchronisedQueue() {
		_queue = new Queue<T>();
		_sync = new object();
	}

	#endregion

	#region Properties

	public int Count { get { lock (_sync) return _queue.Count; } }

	#endregion

	#region Methods

	public void Clear() {
		lock (_sync) {
			_queue.Clear();
		}
	}

	public void Enqueue(T value) {
		lock (_sync) {
			_queue.Enqueue(value);
		}
	}

	public bool TryDequeue(out T value) {
		lock (_sync) {
			if (_queue.Count > 0) {
				value = _queue.Dequeue();
				return true;
			} else {
				value = default(T);
				return false;
			}
		}
	}

	#endregion

}