获取string []的out参数为IEnumerable <string>

Question

Let's say we have a method:

public void SomeMethod(out string[] someArray) { // ... }

Is there a way to do something similar to this:

IEnumerable<string> result;

SomeMethod(out result);

Edit: The point is, I dont' want to bind the out value to string[] , I'd like the code to work even if the method declaration is changed to SomeMethod(out List<string> outputValue) .

Answer 1

It's not allowed to change the type of an out parameter because type safety cannot be guaranteed. This is explained in detail in Eric Lippert's Blog .

Here is a code example how one could break type safety if it would be allowed:

IEnumerable<string> result;

public void Test()
{
   SomeMethod(out result);
}

public void SomeMethod(out string[] someArray)
{
   someArray = new string[];
   ChangeTheType();

   int n = someArray.Length;    // BANG!! - someArray is now a List<string>
}

public void ChangeTheType()
{
    result = new List<string>();
}

Obviously this is only a problem if result is not in the same scope as the call to SomeMethod but the compiler will not check for that. It is just not allowed.

Change the method signature to public void SomeMethod(out IEnumerable<string> someStrings) . You can assign a string[] to someStrings inside SomeMethod and if you later decide to use a List<string> you can assign that also without braking the call.

Personally I would avoid out parameters in the first place: public string[] SomeMethod() .

Answer 2

I'm sure it's not a best way, but you can write another method which do this job for you:

public class ClassA
    {
        private void SomeMethod(out IEnumerable<string> result)
        {
            string[] res;
            SomeMethod(out res);
            result = res;
        }

        public void SomeMethod(out string[] someArray)
        {
            someArray = new string[2];
        }

        void Test()
        {
            IEnumerable<string> result;
            SomeMethod(out result);
        }
    }

Answer 3

You can't do that and there is no way around that. One of the reasons why is that CLR doesn't support out , only ref . So out is actually represented as ref , with some special rules added by the C# compiler.

The simplest (and obvious) way around that is to create a separate variable:

string[] resultArray;

SomeMethod(out resultArray);
IEnumerable<string> result = resultArray;

You could create a helper method to do that casting for you:

public delegate void ActionWithOut<T>(out T result);

public static void ConvertOut<TBase, TDerived>(
    ActionWithOut<TDerived> method, out TBase result)
    where TDerived : TBase
{
    TDerived derived;
    method(out derived);
    result = derived;
}

Usage:

IEnumerable<string> result;
ConvertOut<IEnumerable<string>, string[]>(SomeMethod, out result);

But you would need a separate overload (and delegate type) for each number of parameters and the code doesn't actually look much better. (The type parameters are necessary, type inference doesn't seem to work for this code.)