C#

George_George wrote:

Passing by value means passing a new copy of original object

George_George wrote:

Could you explicitly point out what do you think are the differences between passing by reference and passing by value of a value type please?

George_George wrote:

I think you mean only value type is eligible to the discussion of choices of passing by value or passing by reference?

Guffa wrote:

When you pass a reference type as argument, you are actually passing the reference, and as that is a value type it's value is simply copied.

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.