Reduce visual noise with primary constructors

[Head0nF1re]

Primary constructors were introduced in C# 12, we should consider replacing the normal flow of adding a ctor in order to initialize fields. This would reduce some visual noise, just need to be aware of double capturing.

With primary constructors, AKA parameters for classes, we would be able to do:

this

private sealed class ExcludeCollectionIterator<T>(
	ICollection<T> source,
	int startIndex,
	int count) : CollectionIterator<T>
{
	public override int Count =>
		source.Count < startIndex ? source.Count :
		source.Count < startIndex + count ? startIndex :
		source.Count - count;

	protected override IEnumerable<T> GetEnumerable() =>
		ExcludeCore(source, startIndex, count);
}

instead of

private sealed class ExcludeCollectionIterator<T> : CollectionIterator<T>
{
	private readonly ICollection<T> _source;
	private readonly int _startIndex;
	private readonly int _count;

	public ExcludeCollectionIterator(ICollection<T> source, int startIndex, int count)
	{
		_source = source;
		_startIndex = startIndex;
		_count = count;
	}

	public override int Count =>
		_source.Count < _startIndex ? _source.Count :
		_source.Count < _startIndex + _count ? _startIndex :
		_source.Count - _count;

	protected override IEnumerable<T> GetEnumerable() =>
		ExcludeCore(_source, _startIndex, _count);
}

The only issue is that primary constructors params can't be readonly, the solution would be to choose one option:

1. Initialize a private readonly field, still reducing code by removing the ctor.
2. Ignore it.

My purist side says "initialize the readonly fields", while my practical side says to just ignore it. What do you think?

[viceroypenguin]

For SuperLinq, I think we can get away with 2. ignoring it. And as far as double-capturing goes, we can just turn some of the compiler warnings for primary constructors into errors. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/constructor-errors#primary-constructor-declaration