即时将字符串转换为字符串数组

Question

I have a method that returns an array of strings. In that method I am processing only one string, and I want to return it as an array of strings (an array of strings with only one element, which is my string → array[0] == myString ).

I want that because I want to avoid some ugly code for creating an array of strings with one element, like that:

private static string[] FooterContent()
{
      string[] array = new string[1];
      array[0] = GetMyData();
      return array;        
}

I want something like that:

private static string[] FooterContent()
{
      string myData = GetMyData();
      return myData.ToArray();        
}

And that myData.ToArray() should create an array with only one element ( array[0] = myString ) and then to return it.

Or, something like that (if possible):

private static string[] FooterContent()
{
     return GetMyData().ToArray();        
}

The point is that I can't simply modify the return type from string[] to string because I am using the value returned from FooterContent (array of strings) and from other similar methods, like BodyContent or HeadContent , into another general method, WriteContent() that accepts an array of strings.

Is there an elegant way of doing this?

Thank you respectfully.

Answer 1

As w0lf suggested in comments, the simplest way of creating an array would just be:

return new[] { GetMyData() };

While you could create an extension method, I personally wouldn't - and if you do, you absolutely should not call it ToArray , as that already has a meaning for string due to Enumerable.ToArray and the fact that string implements IEnumerable<char> .

If you really, really want to create this extension method, I'd do it as:

public static T[] ToSingleElementArray(this T value)
{
    return new[] { value };
}

Then you can use:

return GetMyData().ToSingleElementArray();

But as I said, I wouldn't even create the extension method...

Answer 2

You can:

private static string[] FooterContent()
{
    return new[] { GetMyData() };        
}

or write extension method which isn't the best approach here (but possible):

public static class StringExtensions
{
    public static string[] ToSingleElementArray(this string inputString)
    {
        return new[] { inputString };
    }
}

private static string[] FooterContent()
{
    return GetMyData().ToSingleElementArray();        
}

Answer 3

Try this,

private static string[] FooterContent()
{
     return new[] { GetMyData() };
}

Answer 4

Alternatively, you can wrap your GetData return value in a struct and use implicit operators to perform conversions:

public struct DataResult
{
    private string _raw;
    private string[] _rawArray;

    public DataResult(string raw)
    {
        _raw = raw;
        _rawArray = new [] { raw };
    }

    private string Raw { get { return _raw; } }
    private string[] RawArray { get { return _rawArray; } }

    public static implicit operator string(DataResult result)
    {
        return result.Raw;  
    }

    public static implicit operator DataResult(string rawResult)
    {
        return new DataResult(rawResult);
    }

     public static implicit operator string[](DataResult result)
     {
         return result.RawArray;
     }

    public static implicit operator DataResult(string[] rawResultArray)
    {
        if(rawResultArray == null || rawResultArray.Length != 1)
            throw new ArgumentException("Raw result must be a single item array", "rawResultArray");

        return new DataResult(rawResultArray[0]);
    }
}

Implicit operators let you do implicit conversions from apples to pears (and viceversa):

DataResult result = new DataResult("hello world");
string[] resultArray = result;
string rawResult = result;

DataResult result2 = new string[] { "hello world" };
DataResult result3 = "hello world";

What does it mean? If your GetData method returns DataResult any other code can set its value to a string , string[] or DataResult , and perform the opposite conversions implicitly.

I believe that in your case, this should be one of best approaches.