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/']
You can use LINQ:

```
var names=new[]{"EntityName1","EntityName2","EntityName3",.....};
var entities=names.Select(name=>GetByName(name)).ToArray();

```

Without `ToArray`, `Select` will return an IEnumerable that will be reevalueated each time you enumerate it - that is, `GetByName` will be called each time you enumerate the enumerable.

`ToArray()` or `ToList` will create an array (or list) you can use multiple times. 

You can also call `ToDictionary` if you want to be able to access the entities by name:

```
var entities=names.ToDictionary(name=>name,name=>GetByName(name));

```

All this assumes that the entities don't already exist or that `GetByName` has to do some significant work to retrieve them. If the entities exist you can simply put them in a `Dictionary<String,Entity>`. If the entities have a `Name` property you can use `ToDictionary` to create the dictionary in one statement:

```
var entities=new []{entity1,entity2,entity3,...};
var entitiesDict=entities.ToDictionary(entity=>entity.Name,entity=>entity);

```
It depends on what you're looking for. If you need to set the variables in a single line, that won't work. You could play with reflection if you're dealing with fields or properties, but honestly that seems messier than what you've got already.

If the data-structure doesn't matter, and you just need the data and are able to play with it as you see so fit, I'd probably enumerate it into a dictionary. Of course, that's pretty tightly coupled to what you've got now, which looks like it's a fake implementation anyway.

If you want to do that, it's pretty straight-forward. It's your choice how you create the `IEnumerable<string>` that's represented below as `entityNames`. You could use an array initializer as I do, you could use a `List<string>` that you build over time, you could even `yield return` it in its own method.

```
var entityNames = new[] { "EntityName1", "EntityName2", "EntityName3" };

var dict = entityNames.ToDictionary(c => c, c => GetByName(c));

```

Then it's just a matter of checking those.

```
var entity1 = dict["EntityName1"];

```

Or enumerating over the dictionary.

```
foreach(var kvp in dict)
{
    Console.WriteLine("{0} - {1}", kvp.Key, kvp.Value);
}

```

But realistically, it's hard to know whether that's preferable to what you've already got.