Question: Essentially, I am working with this:

```
var data = input.AsParallel();
List<String> output = new List<String>();

Parallel.ForEach<String>(data, line => {
    String outputLine = ""; 
    // ** Do something with "line" and store result in "outputLine" **

    // Additionally, there are some this.Invoke statements for updating UI

    output.Add(outputLine);
});

```

Input is a `List<String>` object. The `ForEach()` statement does some processing on each value, updates the UI, and adds the result to the `output` `List`. Is there anything inherently wrong with this? 

**Notes:**

* Output order is **unimportant**

**Update:**

Based on feedback I've gotten, I've added a manual `lock` to the `output.Add` statement, as well as to the UI updating code.

Answer: 
Yes; `List<T>` is not thread safe, so adding to it ad-hoc from arbitrary threads (quite possibly at the same time) is doomed. You should use a thread-safe list instead, or add locking manually. Or maybe there is a `Parallel.ToList`.

Also, if it matters: insertion order will not be guaranteed.

This version *is* safe, though:

```
var output = new string[data.Count];

Parallel.ForEach<String>(data, (line,state,index) =>
{
    String outputLine = index.ToString();
    // ** Do something with "line" and store result in "outputLine" **

    // Additionally, there are some this.Invoke statements for updating UI
    output[index] = outputLine;
});

```

here we are using `index` to update a different array index per parallel call.
[The documentation](http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx) says the following about the thread safety of `List<T>`:

> 
> Public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.
> 
> 
> A List(Of T) can support multiple readers concurrently, as long as the collection is not modified. Enumerating through a collection is intrinsically not a thread-safe procedure. In the rare case where an enumeration contends with one or more write accesses, the only way to ensure thread safety is to lock the collection during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.
> 
> 
> 

Thus, `output.Add(outputLine)` is *not* thread-safe and you need to ensure thread safety yourself, for example, by wrapping the add operation in a `lock` statement.