无法识别通用方法参数类型？

Question

This is probably due to my terrible understanding of generic methods, so I apologize in advance.

I am trying to write a csvWriter class that inherits from StreamWriter. One method I want it to have is to take a collection like an array or list and use String.Join to change it into a comma separated string, and then to write it as usual. I thought it would be simple, and if I use method overloading it is, but I am used to python and the idea of generics feels better to me, so I was giving it a shot.

However, my attempt is not working. The method doesn't seem to know what type is being passed to it, or something?

Class:

public class csvWriter : System.IO.StreamWriter
    {
        public csvWriter(string filename) : base(filename)
        {
        }

        public void WriteLineFromCollection<T>(T line)
        {
            string newLine = String.Join(",", line);
            base.WriteLine(newLine);
        }
    }

Lines to call it:

using (var reader = new csvReader(filename_in))
using (var writer = new csvWriter(filename_out))
            {
                while (!reader.EndOfStream)
                {
                    string[] line = reader.ReadLine();
                    writer.WriteLineFromCollection<string[]>(line);
                }
                Console.Out.Write("PAUSE");
            }

The file, instead of having the string full of comma-separated values, ends up with "System.String[]." I think that I am actually giving it the type of the argument but not the argument itself, but don't know why this is the case. The debugger from inside WriteLineFromCollection is giving me what feels like conflicting information: It says line is of type string[], but when I try line[0] it says "Cannot apply indexing with [] to an expression of type T."

Answer 1

This happens because compiler chooses String.Join overload with 2nd parameter params object[] value , so you passes string array as one param. To resolve this you can add constraint to WriteLineFromCollection method:

public void WriteLineFromCollection<T>(T line) where T : IEnumerable<string>
{
    string newLine = String.Join(",", line);
    base.WriteLine(newLine);
}

This will force compiler to choose overload with 2nd parameter of type IEnumerable<string>

Answer 2

In you function you are using string[] as your generic type argument, but your function knows nothing about what you are passing in other than it's an object (you have no type restriction). So you code has to be able to work with whatever you might pass. Now you are, presumably hoping it will use this overload of string.Join :

public static string Join(
    string separator,
    IEnumerable<string> values
)

since string[] implements IEnumerable<string> , but the compiler can't do that. It doesn't know if anything about T at all. All it knows is that it's an object. So the only overload of it can use is this one :

public static string Join(
    string separator,
    params Object[] values
)

Now because of the params keyword here, you don't have to pass an Object[] explictly, you can just pass a bunch of arguments and it'll treat it like an object array. For example, you could do something like this (not to say it's a good idea, because it probably isn't):

string.Join(",","somestring",1,true,new object());

So what happens when you pass in your string[] is basically equivalent to if you'd done this:

string.Join("," new object[] { line });

Now what that overload does is it will iterate through each item in the object array and call ToString on it and then join the results together. Calling ToString on a string[] will return System.String[] as you saw. That's the base implementation of object.ToString() , it just returns the type name.

Obviously, this isn't what you want. Something like this should work:

public void WriteLineFromCollection<T>(IEnumerable<T> line)
{
    string newLine = String.Join(",", line);
    base.WriteLine(newLine);
}

You are using this overload of Join which takes an IEnumerable<T> and will call ToString() on each item in your collection.

public static string Join<T>(
    string separator,
    IEnumerable<T> values
)

So now, when you pass in a collection of T (that implements IEnumerable<T> , which string[] does), it will be treated as a collection and not implicitly wrapped in an object array like before. Now it's iterates through you collection of T and calls ToString , which in the case of an actual string just returns the string itself. Note if you passed something other than string as your type parameter, then you will get whatever their ToString does, which might be just the type name. So you'll probably want to override ToString in your own classes to do something sensible if you intend it to be used here.

Of course, you really aren't gaining much out of this versus just inlining a call to String.Join , but it might be a little more readable and would at least give you a single place to have to change when somebody decides you should use a different separator.

Note, using IEnumerable is preferable to IList here if you don't need to index into your collection. That way you could, for example, pass something from linq without having to ToList it first.

You can call it simply with:

writer.WriteLineFromCollection(line);

You don't need to specify T explicitly if the compiler can figure it out.

Answer 3

I think you should try changing from public void WriteLineFromCollection<T>(T line) to public void WriteLineFromCollection<IList<T>>(IList<T> line)

if you want to support indexing, or as Sergey mentioned, add a constraint.

Answer 4

代码的处理几乎没有问题，因为将要传递的唯一类型是String，这使它成为对泛型的滥用。...可能您想编写一个Extension方法以字符串类型输出，输出将是CSV格式化的字符串？