Using 'AsParallel()' / 'Parallel.ForEach()' guidelines?

I would prefer to use another data structure like a Set for each alias and then use Set union to merge them.

Something like this

public string[] ExpandAliases(string[] countries){
    // Alias definitions
    var apac = new HashSet<string> { "US", "FR", ...};
    ... 

    var aliases = new HashMap<string, Set<string>> { {"APAC": apac}, ... };

    var expanded = new HashSet<string>
    foreach(var country in countries){
        if(aliases.Contains(country)
            expanded.Union(aliases[country]);
        else{
            expanded.Add(country);
    }

    return expanded.ToArray();
}

Note: code should be viewed as pseudo-code.

This seems like an inherently serial operation to me. All you're doing is looping through a list of strings and inserting them into another list. The parallelization libraries are going to do that, plus a bunch of threading and synchronization - it'd probably end up slower.

Also, you should be using a HashSet<string> if you don't want duplicates.

Several points.

writing just countriesAndAliases.AsParallel() is useless. AsParallel() makes part of Linq query that comes after it execute in parallel. Part is empty, so no use at all.

generally you should repace foreach with Parallel.ForEach(). But beware of not thread safe code! You have it. You can't just wrap it into foreach because List<T>.Add is not thread safe itself.

so you should do like this (sorry, i didn't test, but it compiles):

        return countriesAndAliases
            .AsParallel()
            .SelectMany(s => 
                IsCountryNotAlias(s)
                    ? Enumerable.Repeat(s,1)
                    : AliasCountryLists[s]
                ).Distinct();

Edit:

You must be sure about two more things:

1. IsCountryNotAlias must be thread safe. It would be even better if it is pure function.
2. No one will modify AliasCountryLists in a meanwhile, because dictionaries are not thread safe. Or use ConcurrentDictionary to be sure.

Useful links that will help you:

Patterns for Parallel Programming: Understanding and Applying Parallel Patterns with the .NET Framework 4

Parallel Programming in .NET 4 Coding Guidelines

When Should I Use Parallel.ForEach? When Should I Use PLINQ?

PS: As you see new parallel features are not as obvious as they look (and feel).

When using AsParallel(), you need to make sure that your body is thread safe. Unfortunately, the above code will not work. List<T> is not thread safe, so your addition of AsParallel() will cause a race condition.

If, however, you switch your collections to using a collection in System.Collections.Concurrent, such as ConcurrentBag<T>, the above code will most likely work.