为字符串数组添加新值的更好方法？

Question

I have the following code:

private void AddMissingValue(ref string[] someArray) {
  string mightbemissing="Another Value";
  if (!someArray.Contains(mightbemissing)) {
    var lst=someArray.ToList();
    lst.Add(mightbemissing);
    someArray=lst.ToArray();
  }
}

While this works (Add an item to an array if missing), I wonder if this can be done in a smarter way? I don't like converting the array twice and writing so many lines for such a simple task.

Is there a better way? Maybe using LinQ?

Answer 1

General idea is right - array is a fixed-sized collection and you cannot add an item to it without recreating an array.

Your method can be written in a slightly more elegant way using LINQ .Concat method without creating a List :

private void AddMissingValue(ref string[] someArray)
{
    string mightbemissing = "Another Value";
    if (!someArray.Contains(mightbemissing))
    { 
        someArray = someArray.Concat(new[] { mightbemissing }).ToArray();
    }
}

This implementation takes N * 2 operations which is better than your N * 3 , but it is still enumerating it multiple times and is quadratic for adding N items to your array.
If you are going to perform this operation too often, then changing your code to use dynamic-size collections (fi, List ) would be a more effective way.

Even if you decide to continue using arrays, it probably (imo) will look better if you return modified array instead of using ref :

private string[] AddMissingValue(string[] someArray)
{
    string mightbemissing = "Another Value";
    return someArray.Contains(mightbemissing)
        ? someArray
        : someArray.Concat(new[] { mightbemissing }).ToArray();
}

// Example usage:

string[] yourInputArray = ...;
yourInputArray = AddMissingValue(yourInputArray);

LINQ-style and the most performant

Another implementation which comes to my mind and is the best ( O(N) ) in terms of performance (not against dynamic-size collections, but against previous solutions) and is LINQ-styled:

public static class CollectionExtensions
{
    public static IEnumerable<T> AddIfNotExists<T>(this IEnumerable<T> enumerable, T value) 
    {
        bool itemExists = false;
        foreach (var item in enumerable)
        {
            if (!itemExists && value.Equals(item))
                itemExists = true;

            yield return item;
        }

        if (!itemExists)
            yield return value;
    }
}

// Example usage:
string[] arr = ...;
arr = arr.AddIfNotExists("Another Value").ToArray();

This implementation with yield is used to prevent multiple enumeration.

If you need to add multiple items, then it can even be rewritten this way, and it seems to still be linear:

public static IEnumerable<T> AddIfNotExists<T>(this IEnumerable<T> enumerable, params T[] value) 
{
    HashSet<T> notExistentItems = new HashSet<T>(value);
    foreach (var item in enumerable)
    {
        if (notExistentItems.Contains(item))
            notExistentItems.Remove(item);

        yield return item;
    }

    foreach (var notExistentItem in notExistentItems)
        yield return notExistentItem;
}

// Usage example:
int[] arr = new[] { 1, 2, 3 };
arr = arr.AddIfNotExists(2, 3, 4, 5).ToArray(); // 1, 2, 3, 4, 5

Answer 2

You have to resize the array, see

https://msdn.microsoft.com/en-us/library/bb348051(v=vs.110).aspx

for details. Implementation:

// static: it seems that you don't want "this" in the method
private static void AddMissingValue(ref string[] someArray) {
  string mightbemissing = "Another Value";

  if (!someArray.Contains(mightbemissing)) {
    Array.Resize(ref someArray, someArray.Length + 1);

    someArray[someArray.Length - 1] = mightbemissing;
  }
}

In you current implementation, you copy all the items twice which can be unwanted if the array is large

...
var lst=someArray.ToList(); // first: all data copied from array to list
lst.Add(mightbemissing);
someArray=lst.ToArray();    // second: all data copied from list to array 

A better design, however, is to switch from fixed size array string[] to, say, List<string> :

  List<string> someList = ...

  if (!someList.Contains(mightbemissing))
    someList.Add(mightbemissing); // <- just Add

if all the values should be not null and unique you can do further improvement:

  HashSet<string> someHash = ...

  someHash.Add(mightbemissing);