Property Spread Initializer

[ArabidopsisDev]

Property Spread Initializer

Summary

This proposal introduces a property spread initializer syntax that allows automatic property assignment from another object when property names match. This reduces boilerplate code in object initialization scenarios where multiple properties need to be copied from a source object to a target object, similar to object spread operators in JavaScript and other modern languages.

Motivation

Current Verbose Pattern

In many C# scenarios, we frequently need to initialize an object by copying properties from another object with matching property names. Currently, this requires manually assigning each property individually:

public ModBusRTU(PhysicalPort physicalPort)
{
    _serialPort = new SerialPort
    {
        PortName = physicalPort.PortName,
        BaudRate = physicalPort.BaudRate,
        DataBits = physicalPort.DataBits,
        Parity = physicalPort.Parity,
        StopBits = physicalPort.StopBits
    };
}

Problems with Current Approach

• Verbose and Repetitive: Code becomes unnecessarily long when dealing with objects with many properties

• Error-Prone: Manual copying increases the risk of missing properties or typos

• Maintenance Burden: When new properties are added, developers must remember to update all initialization sites

• Reduced Readability: Important business logic gets buried in repetitive assignment code

Real-World Use Cases

• DTO to Entity Mapping: Converting API DTOs to domain entities

• Configuration Objects: Initializing complex configuration objects

• Factory Patterns: Creating instances with pre-configured properties

• Builder Patterns: Simplifying builder implementations

Detailed Design

Basic Syntax

// Proposed syntax
var target = new TargetType
{
    ..sourceObject,
    PropertyA = explicitValue  // Can mix with explicit assignments
};

// Example from motivation
public ModBusRTU(PhysicalPort physicalPort)
{
    _serialPort = new SerialPort
    {
        ..physicalPort  // Automatically assigns all matching properties
    };
}

Advanced Scenarios

Multiple Spread Operations

var config = new AppConfig
{
    ..defaultConfig,
    ..environmentConfig,
    ..userConfig,
    ConnectionString = "custom"  // Explicit assignment overrides spreads
};

With Anonymous Types

var partialData = new { Name = "John", Age = 30 };
var person = new Person
{
    ..partialData,
    Email = "john@example.com"
};

Type Safety and Compilation

Compile-Time Type Checking

class Source { public int Value { get; set; } }
class Target { public string Value { get; set; } } // Incompatible types

var target = new Target
{
    ..source  // Compile error: Cannot convert int to string
};

Null Safety

PhysicalPort? physicalPort = null;
var serialPort = new SerialPort
{
    ..physicalPort  // Safe: no properties assigned if source is null
};

Safety Considerations

Property Visibility Rules

• Only public readable properties from source are considered

• Only public writable properties on target are assigned

• Private, protected, and internal properties are ignored

Assignment Precedence

var result = new Target
{
    PropertyA = "first",
    ..source,           // source.PropertyA overwrites "first"
    PropertyA = "final" // Explicit assignment always wins
};


// Result: PropertyA = "final"

Circular Reference Prevention

• The spread operation is shallow and compile-time only, preventing:

• Infinite recursion

• Circular object graphs

• Stack overflow scenarios

Performance Characteristics

• Zero runtime overhead compared to manual assignments

• Compile-time transformation to individual property assignments

• No reflection or dynamic dispatch involved

Compiler Transformation

The spread operator would be compiled to explicit property assignments:

// Source code
var target = new Target { ..source };

// Compiler output (conceptual)
var target = new Target();
target.Property1 = source.Property1;
target.Property2 = source.Property2;
// ... for all matching properties

Benefits

Code Quality

• Reduced Boilerplate: Eliminates repetitive assignment code

• Improved Maintainability: Automatic inclusion of new matching properties

• Better Readability: Clear intent when copying object state

Developer Experience

• Intuitive Syntax: Familiar to developers from other languages

• Tooling Support: Full IntelliSense and refactoring support

• Easy Adoption: Non-breaking change that can be adopted incrementally

Alternatives Considered

1. Implicit Conversion Operators

// Requires modifying type definitions
public static implicit SerialPort(PhysicalPort port) { ... }
Drawback: Inflexible, requires type modification

2. Mapping Libraries (AutoMapper)

_mapper.Map(physicalPort, serialPort);
Drawback: Runtime dependency, configuration complexity

3. Source Generators

[GenerateMapping]
partial class SerialPort { }
Drawback: Complex implementation, less discoverable

4. With Expressions (Limited)

// Only works for same-type copies
var copy = original with { };

Drawback: Restricted to records and same types

Language Design Principles Alignment

This proposal aligns with several C# design principles:

1. Productivity: Reduces repetitive code and cognitive load

2. Type Safety: Maintains C#'s strong typing guarantees

3. Performance: Zero-cost abstraction with compile-time resolution

4. Consistency: Follows pattern established by collection initializers and with-expressions

Implementation Considerations

• Compiler Changes: Parser and semantic analysis updates

• IDE Support: IntelliSense, completion, and quick actions-

• Documentation: Clear guidelines and best practices

• Backward Compatibility: Fully non-breaking change

[colejohnson66]

A big problem with these proposals is they fail to address a few things.

• What do you do if the names of properties don't match exactly?
• What do you do if the types of each properties don't match exactly?
• What do you do if properties on A don't exist on B (or vice versa)?

Not to mention, with EntityFramework Core, the need for "mappers" is greatly reduced.