Method Parameters Value Types vs. Reference Types in c#
User-defined program method parameters in C# programming can be divided into two main categories: the first being value types and the second being reference method parameters. The main difference between value types and reference method parameters lies in how the data value information is passed to the user-defined method during the program data exchange operation.
So, let’s take a closer look at value types and reference method parameters in C# programming.
Value Types method in C#.
User-defined value type methods in C# programs store or process the actual original program data values. When a C# programmer passes a value type to a user-defined function method, a copy of that data value is passed to the function. Any modifications made to the user-declared formal variable parameters within the user-defined program function method have no direct impact on the original data.
Common C# value types are method objects.
- Primitive data types – In a C# program, system-defined data types like int, float, double, char, bool, etc. are the primary data type methods.
- Structural data types – In a C# program, user-defined custom data types declared are value objects like custom structures, such as DateTime, Point, etc.
Example of a value type parameter in C#.
using System;
class ValueType
{
static void Main()
{
int p = 9;
AlterInfo(p);
Console.WriteLine(p); // Result – 9
}
static void AlterInfo(int q )
{
q = 13; // Here, it only modifies the local copy of the variable, but not the actual original variable data value
}
}
Explaining the value type parameter.
- In this program, the declared int data type variable parameter q is passed by value. Modifying the value of the q variable inside the user-defined method does not modify the original value of the p variable in the main program method and has no impact on its actual original value.
Reference type method in C#.
In a C# program, reference type variables hold a reference (or pointer) to an actual original data value stored in memory. Actual variables store or hold a storage address location on disk. When a declared user-defined method in a C# program is passed by reference type value, its reference address pointer location (not a copy of the data) is passed to the process. This means that any changes made to the variable parameter inside the declared program method have no direct impact on the original data value of the current program.
Common reference type methods in C#.
- Class data type – A class is a user-defined data type. It can hold or process values such as string data values, custom user-defined types, etc.
- Array data type – Arrays in C# are reference data types that represent array element data in a continuous sequence using memory address index location references.
- Delegates data type – These are similar to user-defined reference type methods.
Example of a reference type parameter in C#.
using System;
class Employee
{
public string Emp_Name;
public string Emp_Age;
}
class Emp_data
{
static void Main()
{
Employee employee = new Employee();
employee.Emp_Name = “Bhavishi Deora”;
employee.Emp_Age = “21”;
ModifyReference(employee);
Console.WriteLine(employee.Emp_Name); // Result is – Siddhi Deora
Console.WriteLine(employee.Emp_Age); // Result is – 19
}
static void ModifyReference(Employee e)
{
e.Emp_Name = “Siddhi Deora”; // Modifies the original object, because it’s passed by reference
e.Emp_Age = “19”;
}
}
Reference type parameter in C# Explanation.
- Here in this program, the Employee class object is a reference data type structure, hence the ModifyReference method modifies the original Employee class object. The values passed to employee.Emp_Name, employee.Emp_Age, and employee.Emp_Age affect the values passed to the Main method.
Passing data by reference data types in a C# program and how it differs in a program.
As reference data types in C# programs are by default passed by reference to the variable parameter storage pointer index location in the program method, here C# programmers can control and manage these variable references by using the ref or out keywords as to how they will be passed as references in a program.
Using the ref keyword with reference types in C# programs.
The ref keyword in C# programs helps C# programmers to pass reference data types by reference, so that user-defined program methods in the current program can directly modify any original variable parameter object value.
Ref keyword with reference types Example in C#.
Using System;
class employee
{
public string Emp_Name { get; set; }
public string Emp_Age { get; set; }
}
class Employee_info
{
static void Main()
{
Employee employee = new Employee();
employee.Emp_Name = “Harry Deora”;
employee.Emp_Age = “24”;
UpdateReference(ref employee);
Console.WriteLine(employee.Emp_Name); // Result is – Bhavishi Deora
Console.WriteLine(employee.Emp_Age); // Result is – 21
}
static void UpdateReference(ref Employee e)
{
e = new Employee(); // here it Changes the reference itself during process
e.Emp_Name = “Bhavishi Deora”;
e.Emp_Age = “21”;
}
}
Ref keyword with reference types Explanation.
- In this program, the ref keyword allows you to modify not only the value properties of the original object in the existing Employee class, but also to modify the existing actual original value from the formal reference object to a completely new object.
out keyword method in C#.
The out keyword in a C# program performs a class method-based reference operation similar to the ref keyword, but the main difference is that it eliminates the need to manually initialize the data type variable parameter value before passing it to a user-defined function method in the existing program. You simply assign it as a value inside a method.
out keyword method Example in C#.
using System;
class Employee
{
public string Emp_Name { get; set; }
public string Emp_Age { get; set; }
}
class Emp_info
{
static void Main()
{
Employee employee;
StartEmployee(out employee);
Console.WriteLine(employee.Emp_Name); // Result is – Bhavishi Deora
Console.WriteLine(employee.Emp_Age); // Result is – 23
}
static void StartEmployee(out Employee e)
{
e = new Employee(); // here we must assign it before use in program
e.Emp_Name = “Bhavishi Deora”;
e.Emp_Age = “23”;
}
}
out keyword method explanation.
In this program, the out keyword is used to pass an object reference when a user-defined program method is actually responsible for assigning a value to the variable parameter. In this program, it is created within the Employee class object method and is manually initialized.
Main Difference between Value Types and Reference Types in c#.
| Data type Feature | Value Types in c# | Reference Types in c# |
| What they passed | Value data type method is actually used to passed A copy of the value in program. | Reference type method used to A reference (memory storage address location) to the pass formal object value. |
| Memory Allocation | Value type data method used as Stored on the stack order. | Reference type method Stored data on the heap order. |
| Modifications impact | Value data type method any kind of Changes do not affect the original data type variable value. | Reference type method used to Changes modify the original object parameter value. |
| Where it works | Value data type method works with int, float, bool, struct, data type. | Reference type method work with class, string, array, delegate data type |
Summary of Method Parameters Value Types vs. Reference Types.
- Value type – In a C# program, a data type is passed by actual value declared, creating a copy of the actual object. Any modifications made within the user-defined program method have no direct impact on the original data value.
- Reference type – In a C# program, the ref or out keyword is used to pass a value from a pointer storage index location as a reference. Here, the variable parameter is passed as the original reference to the data. In this process, any modifications made inside the user-defined program method impact the original object in the program.
