Quiero convertir una matriz o lista de entradas en una cadena delimitada por comas, como esta:

string myFunction(List<int> a) {
    return string.Join(",", a);
}

Pero string.Join solo toma List<string>como segundo parámetro. ¿Cuál es la mejor manera de hacer esto?

La mejor manera es actualizar a .NET 4.0 donde hay una sobrecarga que hace lo que desea:

• String.Join<T>(String, IEnumerable<T>)

Si no puede actualizar, puede lograr el mismo efecto usando Select y ToArray.

    return string.Join(",", a.Select(x => x.ToString()).ToArray());

Una implementación escalable y segura de una combinación de cadena enumerable genérica para .NET 3.5. El uso de iteradores es para que el valor de la cadena de unión no se atasque al final de la cadena. Funciona correctamente con 0, 1 y más elementos:

public static class StringExtensions
{
    public static string Join<T>(this string joinWith, IEnumerable<T> list)
    {
        if (list == null)
            throw new ArgumentNullException("list");
        if (joinWith == null)
            throw new ArgumentNullException("joinWith");

        var stringBuilder = new StringBuilder();
        var enumerator = list.GetEnumerator();

        if (!enumerator.MoveNext())
            return string.Empty;

        while (true)
        {
            stringBuilder.Append(enumerator.Current);
            if (!enumerator.MoveNext())
                break;

            stringBuilder.Append(joinWith);
        }

        return stringBuilder.ToString();
    }
}

Uso:

var arrayOfInts = new[] { 1, 2, 3, 4 };
Console.WriteLine(",".Join(arrayOfInts));

var listOfInts = new List<int> { 1, 2, 3, 4 };
Console.WriteLine(",".Join(listOfInts));

¡Disfrutar!

.NET 2.0:

static string IntListToDelimitedString(List<int> intList, char Delimiter)
{
    StringBuilder builder = new StringBuilder();

    for (int i = 0; i < intList.Count; i++)
    {
        builder.Append(intList[i].ToString());

        if (i != intList.Count - 1)
            builder.Append(Delimiter);
    }

    return builder.ToString();
}

Tenía un método de extensión similar que modifiqué a este

public static class MyExtensions
{
    public static string Join(this List<int> a, string splitChar)
    {
        return string.Join(splitChar, a.Select(n => n.ToString()).ToArray());
    }
}

y lo usas así

var test = new List<int>() { 1, 2, 3, 4, 5 };
string s = test.Join(",");

.NET 3.5

Esta respuesta es para usted si todavía no desea aventurarse en las profundidades de .NET 4.0.

String.Join () concatena todos los elementos de una matriz de cadenas, utilizando el separador especificado entre cada elemento.

La sintaxis es

public static string Join(
    string separator,
    params string[] value
)

En lugar de pasar su Lista de entradas al método Join, sugiero que primero cree una matriz de cadenas.

Esto es lo que propongo:

static string myFunction(List<int> a) {
    int[] intArray = a.ToArray();
    string[] stringArray = new string[intArray.Length];

    for (int i = 0; i < intArray.Length; i++)
    {
        stringArray[i] = intArray[i].ToString();
    }

    return string.Join(",", stringArray);
}

Usando .NET 4.0

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        string s = myFunction(PopulateTestList());
        this.TextBox1.Text = s;
    }

    protected List<int> PopulateTestList()
    {
        List<int> thisList = new List<int>();
        thisList.Add(22);
        thisList.Add(33);
        thisList.Add(44);

        return thisList;
    }

    protected string myFunction(List<int> a)
    {
        return string.Join(",", a);
    }
}

En .NET, la clase list tiene un .ToArray()método. Algo como esto podría funcionar:

string myFunction(List<int> a)
{
    return string.Join(",", a.ToArray());
}

Ref: Métodos List <T> (MSDN)