Currently coding in C#, I wonder if there is a way to factor the code as presented below

```
Entity1 = GetByName("EntityName1");
Entity2 = GetByName("EntityName2");
Entity3 = GetByName("EntityName3");

```

The idea would be to get a single call in the code, factoring the code by placing the `entities` and the `strings` in a container and iterating on this container to get a single "`GetByName()`" line. Is there a way to do this?
['https://Stackoverflow.com/questions/29765504', 'https://Stackoverflow.com', 'https://Stackoverflow.com/users/4311207/']
Do you mean something like the below (where `entities` is the collection of `Entity1`, `Entity1` & `Entity3`):

```
var results = entities.Select(e => GetByName(e.Name));

```
Ok, here is an idea.

You can declare this function.

```
IReadOnlyDictionary<string, T> InstantiateByName<T>(
        Func<string, T> instantiator
        params string[] names)
{
    return names.Distinct().ToDictionary(
        name => name,
        name => instantiator(name))
}

```

which you could call like this,

```
var entities = InstantiateByName(
         GetByName,
         "EntityName1",
         "EntityName2",
         "EntityName3");

```

---

To push the over-engineering to the next level,

you can install the Immutable Collections package,

```
PM> Install-Package Microsoft.Bcl.Immutable

```

and modify the function slightly,

```
using Microsoft.Immutable.Collections;

IReadOnlyDictionary<string, T> InstantiateByName<T>(
        Func<string, T> instantiator
        params string[] names,
        IEqualityComparer<string> keyComparer = null,
        IEqualityComparer<T> valueComparer = null)
{
    if (keyComparer == null)
    {
        keyComparer = EqualityComparer<string>.Default;
    }

    if (valueComparer == null)
    {
        valueComparer = EqualityComparer<T>.Default;
    }

    return names.ToImmutableDictionary(
        name => name,
        name => instantiator(name),
        keyComparer,
        valueComparer);
}

```

The function would be used in the exactly the same way. However, the caller is responsible for passing unique keys to the function but, an alternative equality comparer can be passed.