Value types vs reference type and pass-by-value vs pass-by-reference sound like similar distinctions, and are related concepts, so it's easy to conflate them, but they are not the same thing.

In C# (like Java) there are both value types and reference types.

In C# (like C++) you can pass by value or pass by reference.

And you can intermix these, so you can even pass values by reference or pass references by value:

Pass value by value:

void PassValueByValue(int x) => x = 99;

int a = 1;
PassValueByValue(a);
// a is still 1

Pass reference by value:

// The reference is copied, but both point to the same object.
// Mutating the object is visible; reassigning the parameter is not.
void PassReferenceByValue(List<int> list)
{
    list.Add(99);              // visible to caller
    list = new List<int>();    // NOT visible to caller
}

var b = new List<int> { 1 };
PassReferenceByValue(b);
// b is now { 1, 99 }

Passing by value is the default. To enable passing by reference for a parameter, you use the ref keyword.

Pass value by reference:

void PassValueByReference(ref int x) => x = 99;

int c = 1;
PassValueByReference(ref c);
// c is now 99

Pass reference by reference:

// Now reassigning the parameter IS visible to the caller.
void PassReferenceByReference(ref List<int> list)
{
    list = new List<int> { 99 };
}

var d = new List<int> { 1 };
PassReferenceByReference(ref d);
// d is now { 99 }

The distinction between value types and reference types is whether a variable of that type contains the value itself or just a reference (effectively a pointer) to it.

The distinction between pass by value and pass by reference is whether a variable passed as an argument to a function can be modified in the function.

Many people get confused by passing references by value and think that it is pass by reference, because a function can mutate the value that the variable references, but pass by reference means the variable itself can be changed, not just a value that it references.

Most modern languages only support pass by value, while many modern languages have either both reference types and value types (Java, Swift, etc.) and some (like Python and Ruby) only have reference types.