Add string to array

Simple solution: don't use an array! List<T> is much better suited for this.

using System.Collections.Generic;
...
private List<string> spam = {"$$$", "Affordable", "Bargain", "Beneficiary", ... }

...

public void addSpam(string spamFlag)
{
    spam.Add(spamFlag);
}

DLeh's answer is best - this is what a List<T> is for, so that's your solution.

But the reason things are failing for you is that you're attempting to access an index that is one higher than the max index of the array. The highest index is always one less than the length, because arrays are zero-based.

int[] arr = new[] { 1, 2, 3 };
Console.WriteLine(arr.Length); // 3
Console.WriteLine(arr[0]); // 1
Console.WriteLine(arr[1]); // 2
Console.WriteLine(arr[2]); // 3
Console.WriteLine(arr[3]); // Exception

To access the last item in an array, you either need to use:

var lastItem = arr[arr.Length - 1];
// or
var lastItem = arr[arr.GetUpperBound(0)];

Array.Resize(ref spam, spam.Length + 1);
spam[spam.Length] = spamFlag;

Here you're trying to write to index 58 (spam.Length after the re-size) of a 58-element zero-indexed array; that is, it goes from 0 to 57.

You should use:

Array.Resize(ref spam, spam.Length + 1);
spam[spam.Length - 1] = spamFlag;

That said, you should really use List<string> instead. Among other things it does the resizing of the internal array it uses in batches rather than on every Add(), which makes things much more efficient, as well as being easier.

If you really need an array for some reason, then use List<string> for most of the work, and then call ToArray() at the end.

While DLeh raise legit points about how it's better to use a List that dynamically grows, and Joe's answer provides a great explanation, I want to add on to a few more things.

Firstly, to Answer your question, to fix either method, you probably wanted to do spam[spam.Length-1] = spamFlag instead of spam[spam.Length] = spamFlag in attempt one. Because indexes start at 0 and the last index within the bound is thus length -1 (As Joe pointed out)

Your second attempt will not work as an exception is thrown if either array is too short. See this dotnetPerl link on the explanation. Basically it isn't recommended to use Array.Copy as you have to ensure the types and lengths are the same as well.

To elaborate on Array.Resize(), it should be noted that it's actually a misnomer in which C# doesn't actually resize the array. Rather, it creates a new array and copies the contents over. It always does this unless an exception is thrown, so from a performance point of view this is discouraged. (You could have a variable to keep track of how full your array is, and always grow it by double the amount, this avoids you from having to always create a new array.)

This is also used in hashtables as well where if a certain bucket is full, we grow it and rehash everything back in (it's a really fast lookup table/data structure).

Read this DotNetPerl tutorial on Array Resize

However, a lot of times a List is better, but of course there may be a reason why you don't want to/can't use. I know of a few classes that explicitly tell us not to use built in data structures to learn how arrays work.