What is the difference between byval and byref

A Brief Insight into Reference Types: Data for Reference types is stored on the heap and a pointer which points to the data on the heap is created on the stack, whenever an instance of reference type is created the pointer is returned back and is used to manipulate the data on the stack.

Now when this pointer is passed by val, all we are doing is duplicating the pointer but it still points to the same memory on the heap and hence any manipulation done to the object in the called method will manipulate the same data to which original hashtable pointer was pointing. In case of passing by ref, the original pointer itself is passed to the called function. Lets take a look at the slightly modified version of above code:. Hope this article explained the subtle difference between passing reference type by val or by ref.

View All. Windows 11 is Here. Read what is new in Windows Connect and share knowledge within a single location that is structured and easy to search. What is the difference? I always use ByVal, but, I don't really have a good idea of when should I and when not If you are in the same memory space, this means passing just the 'word' not the object.

The method you are passing it to can make changes in the original object, and does not need to pass them back at all, as they are in the original object. Useful for making large data passes faster. Why not to use ByRef: Since the method has access to the original, any changes made will be immediate and permanent. If the method fails, the object could be corrupted. Using ByVal will make a copy, pass the whole copy into the method, and then the method will process the info and either return a copy back, report information or do nothing.

If you pass in a reference, when you modify the value in the method, the variable in the call site will also be modified.

If you pass value, it's the same as if another variable is created at the method, so even if you modify it, the original variable at the call site won't have its value changed.

So, indeed, you should usually pass variables as value. Only pass as reference if you have an explicit need to do so. ByRef is like a second return value. It passes a reference to the object into the function rather than the object itself.

If you change the value of a ByRef parameter in the function, you will see those changes after the function ends. If that wasn't clear enough, read this and this. Poor explanation, I know, see code below for a better understanding:.

Both common sense and might catch you out one day, so something to bear in mind. Think there may have been a typo in the last sample: The last sub should be "byval" and not "byref". The output parameter can be changed inside the function which creates a rarely used side-effect. Stack Overflow for Teams — Collaborate and share knowledge with a private group.

Create a free Team What is Teams? Collectives on Stack Overflow. Learn more. Difference between ByVal and ByRef? Ask Question. Asked 10 years, 8 months ago. A string is an immutable reference type the contents where is pointed to with the reference will never change, the same is with Arrays. Because that byref there is created an extra reference, that new address would be set in the place of the old one, while byval the reference address would stay the same.

The effect is that when you pass byval a string to a method, changing that string inside the method is only affected inside that method, while byref it is also outside that method. That code won't demonstrate the difference. The example below shows how passing by ref means that changes to the argument passed to the function do modfy the original variable, while changes to the argument passed by value do not modify the original variable.

This is what you would expect for a value variable, but strings are a reference type, and would not be expected to behave like this. Changes made to a reference variable should be reflected in the original variable whether it is passed by ref or by val.

The reason that the string acts like a value variable in this case is that the assignment statement for a string is implemented as a process that creates a new string. So the string is actually behaving like a reference variable after all, but it is a reference variable that has been assigned to a new instance of the string object as a result of the way that the assignment operation works, and when it has been passed by val that new assignment is lost when the function terminates, and the original variable is unchanged.

Object, ByVal e As System. EventArgs Handles MyBase. This is not the case by mutable reference types like Lists and DataSets. Would you care to explain with an example of a mutable reference type like a LIST please? If you assign a new object to the local variable, the original variable will refer to that new object if it was passed to the function by ref, but it will not be changed if it was passed by val.

This is consistent - the reference used in the by val function is a copy of the variable that was passed, so if you change that reference then the original is unaffected. Only if you change the object that the reference points to is the original changed. With a string, you can't do that, but with a List and many other objects you can.

The code below demonstrates that, for a reference variable, changes made to the object are always reflected in the original. Option Strict On Imports System.