List<int> a = new() { .. }

C>Тяп-ляп, заплатка на заплатку, никакой продуманности, никакой целостности дизайна.

DoSomething(new(something, new(somethingElse)), new(wtfIsThat))

C>DoSomething(new(something, new(somethingElse)), new(wtfIsThat))
C>

DoSomething(new Something(something, new SomethingElse(somethingElse)), new WtfIsThat(wtfIsThat))

MoveTo(new(10,20));
//или
SetBirthDay(new(2024, 10, 29));
//или
AddItem(new("foo", 123, false));

var wtfIsThat = GetSomething()

C>Вот, например, partial methods. Фича крайне сомнительной полезности, и в языке ей просто не место.

public partial class WeatherViewModel : INotifyPropertyChanged
{
    private string? _location;
    public  string?  Location
    {
        get { return _location; }
        set
        {
            if (_location != value)
            {
                BeforeLocationChanged(value);
                _location = value;
                AfterLocationChanged();

                OnLocationChanged();
            }
        }
    }

    partial void BeforeLocationChanged(string? newValue);
    partial void AfterLocationChanged ();
}

partial class WeatherViewModel
{
    partial void AfterLocationChanged()
    {
        _lastUpdate = DateTime.MinValue;
        Update();
    }
}

void AddItem(SimpleItem item) {doStuff();}

AddItem(new("foo", 123, false));

void AddItem(SimpleItem item) {doStuff();}

void AddItem(SpecialItem item) {doSpecialStuff();}

        public AccountManagementBO()
        {
            AccountTypeConfigurationBo = (AccountTypeConfigurationBO)BusinessObjectFactory.GetBusinessObject(typeof(AccountTypeConfigurationBO));
            AccountManagementDao = (AccountManagementDAO)DataAccessObjectFactory.GetDataAccessObject(typeof(AccountManagementDAO));
            accesManagerDao = (AccessManagerDao)DataAccessObjectFactory.GetDataAccessObject(typeof(AccessManagerDao));

var r = new 
{
    Name = "",
    Amount = 148.8,
    IsVerified = false
}

Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)> dic = new Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)>();

Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)> dic = new();

IT>Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)> dic = new Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)>();
IT>

IT>Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)> dic = new();
IT>

var dic = new Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)>();

·> Так надо телегу за лошадью ставить, тогда всё просто:

·>var dic = new Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)>();
·>

class AAA
{
    private Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)> _dic = new();
}

IT>class AAA
IT>{
IT>    private Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)> _dic = new();
IT>}
IT>

private Dictionary<(int code,string value, List<MyCodeValueContainerBlaBlaBla>)> _dic = new Dictionary<>();

private Map<...very many type params> _dic = new ConcurrentHashMap<>();

ReadOnlySpan<byte> span = stackalloc byte[10]
{
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10
};

var x = new MyList { a, b, c };

var tmp = new MyList();
tmp.Add(a);
tmp.Add(b);
tmp.Add(c);
var x = tmp;

property[MyStyle1] string? Location
{
    //...before
    _location = value;
    //...after
}

private string? _location;
public  string?  Location
{
    get { return _location; }
    set
    {
        if (_location != value)
        {
            //...before
            _location = value;
            //...after
        }
    }
}

S_S>property[MyStyle1] string? Location
S_S>{
S_S>    //...before
S_S>    _location = value;
S_S>    //...after
S_S>}
S_S>

using PropertyChanged.SourceGenerator;
public partial class MyViewModel
{
    [Notify] private string _lastName;
    public string FullName => $"Dr. {LastName}";
}

partial class MyViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    public string LastName
    {
        get => _lastName;
        set
        {
            if (!EqualityComparer<string>.Default.Equals(_lastName, value))
            {
                _lastName = value;
                OnPropertyChanged(EventArgsCache.LastName);
                OnPropertyChanged(EventArgsCache.FullName);
            }
        }
    }

    protected virtual void OnPropertyChanged(PropertyChangedEventArgs args)
    {
        PropertyChanged?.Invoke(args);
    }
}

new Collection { 1, 2, 3 }

Collection t = new();
t.AddRange(new[] { 1, 2, 3 });

ImmutableArray<int>.Create(new int[] { 1, 2, 3 });

[InlineArray(3)] struct __InlineArray3<T> { private T _element0; }

Span<int> __tmp = new __InlineArray3<int>();
__tmp[0] = 1;
__tmp[1] = 2;
__tmp[2] = 3;
ImmutableArray<int> ia =
    ImmutableArray.Create((ReadOnlySpan<int>)__tmp);

[MyPropertyGenerator] string? Location
{
    _location = value; //Или лучше "field = value;" - в C# уже обсуждают ключевое слово "field"
}

//Тело вызовется после автоматического изменения field
[after_change] Type Name
{
   //код
}

//вызовется после автоматической проверки: if(field==value) return;
[change] Type Name
{
   //код
   field = value;  //присваиваем вручную, зато можно вызвать код до изменения.
   //код
}

//Для более гибких setter.
//Здесь ничего автоматически не делается. Все вручную: "if(AreSame(field,value)) return; ..."
[setter] Type Name
{
   //код
}

 //Можно для читабельности назвать [property_setter] Вместо [setter]

https://github.com/dotnet/csharplang/discussions/8561
To elaborate, this is what you will be able to do using langversion=preview when C# 13 releases, and eventually langversion=14:

public Type PropertyName
{
    get;
    set
    {
        if (field == value) return;
        field = value;
        f(PropertyName);
    }
}

If you use a helper method, you could write it as:

public Type PropertyName { get; set => Set(ref field, value, onChanged: () => f(PropertyName)); }

public implicit Type PropertyName 
{
    //OnChanged
}

[Prop<int>] void Name1_(){/*OnChanged*/} 
[Prop] void Name2_(int value){ _name2 = value;}

ctrl.Color = c;
ctrl.Invalidate();

public Type PropertyName
{
    get;
    set
    {
        //field = value;
    }
}

public Type PropertyName
{   
    //field = value;
}

[JsonProperty("is_enabled")]
public boolean IsEnabled { get; set; }

@JsonProperty("is_enabled")
boolean enabled;

public boolean isEnabled() {
  return this.enabled;
}

public void setEnabled(boolean value) {
  this.enabled = value;
}

[JsonProperty("is_enabled")]
public boolean IsEnabled;

public AccountManagementBO()
        {
            AccountTypeConfigurationBo = BusinessObjectFactory.GetBusinessObject<AccountTypeConfigurationBO>();
            AccountManagementDao = DataAccessObjectFactory.GetDataAccessObject<AccountManagementDAO>();
            accesManagerDao = DataAccessObjectFactory.GetDataAccessObject<AccessManagerDao>());