# Method Parameters

In C#, arguments can be passed to parameters either by value or by reference. 

* *Pass by value* means **passing a copy of the variable** to the method.
* *Pass by reference* means **passing access to the variable** to the method.
* A variable of a *reference type* contains a reference to its data.
* A variable of a *value type* contains its data directly.

## Reference parameters <a href="#reference-parameters" id="reference-parameters"></a>

### `ref` parameter modifier

* The `ref` keyword causes arguments to be passed by reference, not by value.
* The argument for a `ref` parameter must be definitely assigned. The called method may reassign that parameter.

```csharp
void Method(ref int refArgument)
{
    refArgument = refArgument + 44;
}

int number = 1;
Method(ref number);
Console.WriteLine(number);
// Output: 45
```

### `out` parameter modifier

* The `out` keyword causes arguments to be passed by reference.
* The argument for an `out` parameter needn't be definitely assigned. The called method must assign the parameter.

```csharp
int initializeInMethod;
OutArgExample(out initializeInMethod);
Console.WriteLine(initializeInMethod);     // value is now 44

void OutArgExample(out int number)
{
    number = 44;
}
```

### `in` parameter modifier

* The `in` keyword causes arguments to be passed by reference.
* The argument for an `in` parameter must be definitely assigned. The called method can't reassign that parameter.

```csharp
int readonlyArgument = 44;
InArgExample(readonlyArgument);
Console.WriteLine(readonlyArgument);     // value is still 44

void InArgExample(in int number)
{
    number = 19;    
    // error: Cannot assign to variable 'in int' because it is a readonly variable
}
```

###

###

{% hint style="info" %}
Parameters declared for a method without `in`, `ref` or `out`, are passed to the called method by value.
{% endhint %}