What's the best way to get rid of this code duplication in C#?

[JESUSrosetolife]

I have an extension method:

public static string StringJoin(this IEnumerable<string> strings, string separator)
{
    string[] array = strings.ToArray();
    return string.Join(separator, array);
}

I have an IEnumerable<char> chars; local variable in my code.

I cannot call StringJoin on it.

I could do this:

public static string StringJoin(this IEnumerable<char> chars, string separator)
{
    return chars.Select(c => c.ToString()).StringJoin(separator);
}

However now, for every IEnumerable<string> method I have, I will need to make a IEnumerable<char> method that calls the IEnumerable<string> method. This is code duplication.

I tried to make an implicit conversion:

public static implicit operator IEnumerable<string>(IEnumerable<char> chars) 
    => d.Select(c => c.ToString());

However that generated a compile error - apparently interfaces cannot have implicit conversions.

For now I've made this extension method:

public static IEnumerable<string> AsStrings<T>(
    this IEnumerable<T> items)
{
    return items
        .Select(d => d.ToString());
}

And then I do this:

chars.AsStrings().StringJoin("");

However there's still code duplication because I may have to type AsStrings() over and over.

Besides writing code that generates C# code, I cannot think of a way to get rid of the code duplication.

What's the best way to get rid of this code duplication in C#?

[CyrusNajmabadi]

public static string StringJoin(this IEnumerable<string> strings, string separator)
{
    string[] array = strings.ToArray();
    return string.Join(separator, array);
}

This is not necessary, string.Join can alread take an IEnumerable;

[CyrusNajmabadi]

public static string StringJoin(this IEnumerable<char> chars, string separator)
{
    return chars.Select(c => c.ToString()).StringJoin(separator);
}

Instead of that, do:

public static string StringJoin<T>(this IEnumerable<T> chars, string separator)
{
    return chars.Select(c => c.ToString()).StringJoin(separator);
}

That said, as with teh first comment, string already has an overload for this.

[HaloFour]

Could also do this, which takes advantage of the existing string.Join method but allows it to be used fluently:

using System.Collections.Generic;

public static class StringExtensions {
    public static string StringJoin<T>(this IEnumerable<T> values, string separator) {
        return string.Join(separator, values);
    }
}