Skip to main content

How to Resolve Error "CS0631: ref and out are not valid in this context" in C#

The Compiler Error CS0631 is a restriction error regarding the ref and out parameter modifiers. The message reads: "ref and out are not valid in this context".

In C#, ref and out are used to pass arguments by reference. While valid in standard methods and delegates, they are forbidden in specific contexts where the underlying mechanism of reference passing (pointers to memory locations) cannot be supported or is syntactically invalid. The most common occurrence is inside Indexers.

This guide explains why these modifiers are blocked in indexers and how to structure your code to achieve similar results.

Understanding the Indexer Limitation​

An Indexer (this[int i]) allows an object to be indexed like an array. Under the hood, the compiler translates indexers into a pair of methods: get_Item and set_Item.

However, the syntax myObj[x] = y or var val = myObj[x] implies a specific access pattern. C# language specifications restrict indexers to standard value passing for the indices. Passing an index by reference (myObj[ref i]) creates ambiguity and complexity in how get and set operations would handle the pointer, especially during assignment. Therefore, the compiler simply forbids ref and out parameters in the indexer signature.

Scenario 1: Using ref or out in Indexers​

This error occurs when you define an indexer and try to make one of the indices a reference parameter.

Example of error:

public class DataCollection
{
    private string[] _data = new string[10];

    // ⛔️ Error CS0631: ref and out are not valid in this context.
    // Indexers cannot modify the index variable passed to them.
    public string this[ref int index]
    {
        get { return _data[index]; }
        set { _data[index] = value; }
    }
}

Solution 1: Use a Method instead of an Indexer​

If your logic requires modifying the index variable (e.g., advancing a cursor or returning a status), you should use a standard method instead of an indexer property. Methods support ref and out fully.

Solution: replace this[...] with a named method like GetAt.

public class DataCollection
{
    private string[] _data = new string[10];

    // ✅ Correct: Methods fully support 'ref'.
    public string GetAt(ref int index)
    {
        // Example logic: Advance the index automatically
        string result = _data[index];
        index++; 
        return result;
    }
}

public class Program
{
    static void Main()
    {
        var col = new DataCollection();
        int i = 0;
        
        // Calling the method
        string val = col.GetAt(ref i);
        Console.WriteLine($"Value: {val}, Next Index: {i}");
    }
}

Solution 2: Return a Tuple or Custom Object​

If you were using out to return extra information alongside the value lookup (e.g., success status), consider returning a Tuple or a Result object instead. This keeps the logic cleaner without needing reference parameters.

Solution (Tuples):

public class DataCollection
{
    private string[] _data = new string[10];

    // ✅ Correct: Standard index (by value) returning multiple values.
    // Returns (The Value, IsSuccess)
    public (string Value, bool IsValid) GetItem(int index)
    {
        if (index >= 0 && index < _data.Length)
        {
            return (_data[index], true);
        }
        return (null, false);
    }
}
note

If you specifically want the indexer syntax [], you must accept that inputs are by-value only.

Conclusion​

CS0631 prevents syntax features that don't make sense for property-like accessors.

  1. Check Declarations: Look at your this[...] definition.
  2. Remove Modifiers: Delete ref or out from the parameters inside the brackets.
  3. Refactor: If reference behavior is critical, convert the indexer into a named method (e.g., GetNext(ref int i)).

Table of Contents