As the blog post discusses, it is very common for C# programmers to waste resources by allocating lists unnecessarily. The canonical example is using ToList().ForEeach(...) solely because the List<T> type happens to have a ForEach method on it.
ToListinator is a Roslyn code analyzer designed to track down and help eliminate these kinds of unnecessary ToList calls with extreme prejudice, among other things.
Category: Performance | Severity: Warning
Detects the pattern collection.ToList().ForEach(action) which unnecessarily allocates a List just to call the ForEach method. This pattern should be replaced with a regular foreach loop.
Example:
// ❌ Bad - unnecessary List allocation
items.Where(x => x.IsValid).ToList().ForEach(ProcessItem);
// ✅ Good - use foreach loop instead
foreach (var item in items.Where(x => x.IsValid))
{
ProcessItem(item);
}Category: Performance | Severity: Warning
Detects useless Select(x => x) identity operations that perform no transformation and should be removed.
Example:
// ❌ Bad - pointless identity transformation
var result = items.Where(x => x.IsValid).Select(x => x).ToList();
// ✅ Good - remove unnecessary Select
var result = items.Where(x => x.IsValid).ToList();Category: Performance | Severity: Warning
Detects ToList().Count comparisons used for existence checks and suggests using Any() instead to avoid unnecessary allocation.
Example:
// ❌ Bad - unnecessary List allocation for existence check
if (items.Where(x => x.IsValid).ToList().Count > 0)
// ✅ Good - use Any() for existence checks
if (items.Where(x => x.IsValid).Any())Category: Performance | Severity: Warning
Detects the pattern foreach (var item in collection ?? new Collection()) which creates unnecessary allocations. Suggests using null checks instead.
Example:
// ❌ Bad - creates empty collection on every iteration when null
foreach (var item in items ?? new List<string>())
// ✅ Good - check for null to avoid allocation
if (items != null)
{
foreach (var item in items)
{
// process item
}
}Category: Performance | Severity: Warning
Detects static properties with expression bodies that may allocate new instances on every access. Suggests using getter-only properties with initializers instead.
Example:
// ❌ Bad - allocates new array on every access
public static string[] Parts => "a,b,c".Split(',');
// ✅ Good - allocated once and cached
public static string[] Parts { get; } = "a,b,c".Split(',');Category: Performance | Severity: Warning
Detects Where(predicate).Count() patterns and suggests using Count(predicate) for better performance.
Example:
// ❌ Bad - two-pass operation
var count = items.Where(x => x.IsValid).Count();
// ✅ Good - single-pass operation
var count = items.Count(x => x.IsValid);Category: Performance | Severity: Warning
Detects unnecessary ToList() or ToArray() calls in the middle of method chains that create intermediate collections only to be immediately enumerated again.
Example:
// ❌ Bad - unnecessary intermediate collection
var result = items.Where(x => x.IsValid).ToList().Select(x => x.Name).ToArray();
// ✅ Good - direct enumeration without intermediate collection
var result = items.Where(x => x.IsValid).Select(x => x.Name).ToArray();Category: Performance | Severity: Warning
Detects ToList() calls on collections that are already materialized (like List<T>, arrays, etc.) which creates unnecessary copies.
Example:
List<string> names = GetNames();
// ❌ Bad - creates unnecessary copy of already materialized collection
var filtered = names.ToList().Where(x => x.Length > 3).ToList();
// ✅ Good - use the materialized collection directly
var filtered = names.Where(x => x.Length > 3).ToList();