Skip to main content

How to Resolve Error "CS0190: The __arglist construct is valid only within a variable argument method" in C#

The Compiler Error CS0190 is a context restriction error involving an undocumented C# feature. The message reads: "The __arglist construct is valid only within a variable argument method".

The __arglist keyword is a special, undocumented feature in C# designed for interoperability with unmanaged C/C++ functions that use variable arguments (varargs). It allows a method to accept an unspecified number of parameters of unspecified types.

This error occurs when you try to use the __arglist keyword inside the body of a method (typically to access the passed arguments) without declaring that the method accepts a variable argument list in its signature.

Understanding __arglist​

In standard C#, we use the params keyword to accept a variable number of arguments (e.g., params object[] args). However, params creates a .NET array.

__arglist is different. It corresponds to the C-style varargs mechanism (...). It does not create a managed array. It is primarily used when defining P/Invoke signatures for unmanaged libraries that require varargs (like printf in C).

If you use __arglist inside a function to retrieve values, the function itself must be declared as capable of receiving them.

Scenario: Using __arglist in a Standard Method​

This error happens if you try to access the special ArgIterator logic associated with __arglist inside a normal C# method.

Example of error:

using System;

public class Program
{
    // ⛔️ Error CS0190: The __arglist construct is valid only within a variable argument method.
    // This method signature is standard. It does not mention __arglist.
    public static void MyMethod()
    {
        // Attempting to create an iterator over the varargs
        ArgIterator iterator = new ArgIterator(__arglist);
    }
}

Solution: Correctly Defining the Method Signature​

To fix this, you must include the __arglist keyword in the method's parameter list.

Solution:

using System;

public class Program
{
    // ✅ Correct: The signature includes __arglist
    public static void MyMethod(__arglist)
    {
        // Now we can access the arguments using the special iterator
        ArgIterator iterator = new ArgIterator(__arglist);
        
        // Iterating through the arguments (unsafe/advanced usage)
        while (iterator.GetRemainingCount() > 0)
        {
            TypedReference r = iterator.GetNextArg();
            Console.WriteLine(TypedReference.ToObject(r));
        }
    }

    static void Main()
    {
        // Calling the method with variable arguments
        MyMethod(__arglist(1, "Hello", 3.5));
    }
}
warning

Use with Caution: __arglist is undocumented and not CLS-compliant. It should generally be avoided unless strictly necessary for specific Interop scenarios.

Alternatives: params vs __arglist​

For almost all C# development scenarios, you should use the standard params keyword instead.

  • params: Type-safe, works with LINQ, standard .NET arrays, CLS-compliant.
  • __arglist: Not type-safe, intended for unmanaged interop, awkward syntax.
public static void MyMethod(params object[] args)
{
    foreach (var item in args)
    {
        Console.WriteLine(item);
    }
}

// Usage:
MyMethod(1, "Hello", 3.5);

Conclusion​

CS0190 indicates a syntax mismatch in an advanced feature.

  1. Check the Signature: If you use __arglist inside the curly braces { ... }, you must also have __arglist inside the parentheses ( ... ) of the method definition.
  2. Evaluate Need: Unless you are calling a C++ function like sscanf or printf, switch to using params object[].

Table of Contents