C#

George_George wrote:

You mean when we pass a reference, we actually just copied the pointer/reference's value?

George_George wrote:

My most confusion is what means "and as that is a value type".

George_George wrote:

"A reference variable is a value type, so when it's passed by value (i.e. as usual) it's value is copied" -- we could understand this in context of C++ that the reference is a pointer and the pointer value is copied?

George_George wrote:

"the value of the reference variable is a reference" -- we could understand this in context of C++ that the value of reference is pointer?

George_George wrote:

A reference variable is a value type, so when it's passed by value (i.e. as usual) it's value is copied" -- we could understand this in context of C++ that the reference is a pointer and the pointer value is copied?

static void Main(string[] args) {
   StringBuilder sb = new StringBuilder();
   PassReferenceByValue(sb);
   Console.WriteLine(sb);
   PassReferenceAsReference(ref sb);
   if (sb == null)
     Console.WriteLine("SB is NULL");
   Console.Read();
}

static void PassReferenceByValue(StringBuilder sb) {
   sb.Append("Something");     // This affects the original string builder instance
   sb = null;                  // This won't affect the original one. It makes the local "sb" value as NULL.
}

static void PassReferenceAsReference(ref StringBuilder sb) {
   sb.Append("Something"); // This affects the original string builder instance
   sb = null;  // Makes the original instance as NULL
}

void PassReferenceByValue(std::string* str){
	str = new std::string; // Pointing local copy of str to new location
	*str = "This will not come";
}

void PassReferenceAsReference(std::string** str){
	*str = new std::string; // Pointing original pointer to a new location
	(*(*str)) = "Hello";
}

int _tmain(int argc, _TCHAR* argv[])
{
	std::string str = "From Main";
	std::string* strPtr = &str;
	
	PassReferenceAsReference(&strPtr);
	std::cout << (*strPtr) << std::endl;
	
	PassReferenceByValue(strPtr);
	std::cout << (*strPtr) << std::endl;
	return 0;
}

Guffa wrote:

but the reference to the object is a value type

Dewald wrote:

what exactly is the difference between BeginInvoke and Invoke which I've been using?

private BackgroundWorker MyWorker;

MyWorker = new BackgroundWorker();
MyWorker.WorkerSupportsCancellation = true;
MyWorker.DoWork += new DoWorkEventHandler(MyWorker_DoWork);

void MyWorker_DoWork(object sender, DoWorkEventArgs e)
{
    SetImages((string)e.Argument, sender as BackgroundWorker, e);
}

if (worker.CancellationPending)
{
    e.Cancel = true;
    return;
}

while (MyWorker.IsBusy)
    MyWorker.CancelAsync();
MyWorker.RunWorkerAsync(someStringValue);

MyWorker.CancelAsync();
waitHandle.WaitOne();
MyWorker.RunWorkerAsync(someStringValue);

// inside your runworker completed
if(e.Cancelled)
   waitHandle.Set();

Dewald wrote:

the custom control's AddPicture method which is thread safe by using InvokeRequired and BeginInvoke as described in the article.

peterchen wrote:

Couldn't find any besides the (non-generic) Array.BinarySearch

int index = Array.BinarySearch<string>(list.ToArray<string>(), "SearchString");

public static class IListExtensions
{
	///<summary>Search assuming that a list is sorted and items are somehow comparable.
	///</summary>
	public static int BinarySearch<T>(this IList<T> list, T item, Comparison<T> comp)
	{
		if (list == null) throw new ArgumentNullException("list");
		if (comp == null) throw new ArgumentNullException("comp");
		if (list.Count == 0)
			return -1;
		return BinarySearch(list, item, comp, 0, list.Count - 1);
	}
	private static int BinarySearch<T>(IList<T> list, T item,
                           Comparison<T> comprasion, int start, int end)
	{
		while (true) {
			int i = (end + start) / 2;
			int cmp = comprasion(item, list[i]);
			if (cmp == 0)
				return i;
			else if (cmp > 0) {
				if (i == end)
					return -1;
				start = i + 1;
			}
			else {
				if (i == start)
					return -1;
				end = i - 1;
			}
		}
	}	
}