What is an alternative to Dictionaries in C# that allows for duplicate keys?

What you need is a relationship between a Project and one or more Technicians:

public class Project
{
    public ICollection<Technician> Technicians { get; set; }
}

var project = new Project();
project.Technicians = new List<Technician>()
{
    new Technician(),
    new Technician()
};

Your objects should mirror the relationships in real life.

As a side note, you might be interested in reading about Domain-driven design.

public void LoadTechnicians(Project project)
{
    List<Technician> techs = new List<Technician>();

    // query the database and map Technician objects

    // Set the "Technicians" property
    project.Technicians = techs;
}

There is an experimental NuGet package from MS that contains MultiValueDictionary.

Basically, it's like Dictionary<Project, List<Technicians>>, except that you don't have to repeat all the logic to manage the Lists every time you access it.

I don't think there is anything wrong with your solution. After all by, you can access easily all the team members by project. But alternatively you can try List<KeyValuePair<Project, Technician>>. You maintain the key-value relationship, but without restriction of not repeated keys. Is it much simpler to what you have now? Depends on use cases.

Alternatively, you can hide this structure behind your custom collection implementation.

I've copy pasted my own answer from this post.

It's easy enough to "roll your own" version of a dictionary that allows "duplicate key" entries. Here is a rough simple implementation. You might want to consider adding support for basically most (if not all) on IDictionary<T>.

public class MultiMap<TKey,TValue>
{
    private readonly Dictionary<TKey,IList<TValue>> storage;

    public MultiMap()
    {
        storage = new Dictionary<TKey,IList<TValue>>();
    }

    public void Add(TKey key, TValue value)
    {
        if (!storage.ContainsKey(key)) storage.Add(key, new List<TValue>());
        storage[key].Add(value);
    }

    public IEnumerable<TKey> Keys
    {
        get { return storage.Keys; }
    }

    public bool ContainsKey(TKey key)
    {
        return storage.ContainsKey(key);
    }

    public IList<TValue> this[TKey key]
    {
        get
        {
            if (!storage.ContainsKey(key))
                throw new KeyNotFoundException(
                    string.Format(
                        "The given key {0} was not found in the collection.", key));
            return storage[key];
        }
    }
}

A quick example on how to use it:

const string key = "supported_encodings";
var map = new MultiMap<string,Encoding>();
map.Add(key, Encoding.ASCII);
map.Add(key, Encoding.UTF8);
map.Add(key, Encoding.Unicode);

foreach (var existingKey in map.Keys)
{
    var values = map[existingKey];
    Console.WriteLine(string.Join(",", values));
}