C# recordのwith式とは？コピー更新の仕組み・使い方・classとの違いをわかりやすく解説

はじめに

C#のrecordを学んでいると、よく一緒に登場するのがwith式です。

recordは、データを表現するために便利な型です。そしてwith式は、そのデータを「元の値を残したまま、一部だけ変更した新しい値」として作り直すための構文です。

たとえば、ユーザー情報を表すrecordがあるとします。

C#
public record User(string Name, int Age);

このUserのNameはそのままで、Ageだけを変更した新しいオブジェクトを作りたい場合、with式を使うと次のように書けます。

C#
var user1 = new User("Taro", 20);
var user2 = user1 with { Age = 21 };

user1の値は変更されません。user2として、Ageだけが21になった新しいUserが作られます。

この記事では、C#のrecordにおけるwith式について、基本的な使い方、内部の仕組み、classとの違い、実務での使いどころ、注意点までわかりやすく解説します。

1. C# recordのwith式とは？コピー更新をかんたんに理解する

1-1. with式は「元の値を残したまま一部だけ変更したコピーを作る」構文

C#のwith式は、既存のオブジェクトをもとにして、一部のプロパティだけを変更した新しいオブジェクトを作るための構文です。

たとえば、次のようなrecordがあるとします。

C#
public record Product(string Name, int Price);

このProductの価格だけを変更したい場合、通常であれば新しいインスタンスを作り直します。

C#
var product1 = new Product("Keyboard", 5000);
var product2 = new Product(product1.Name, 6000);

これでも動きますが、プロパティが増えると書く量が多くなります。

C#
public record Product(
    string Name,
    int Price,
    string Category,
    bool IsActive
);

このような型でPriceだけ変更したい場合、すべての値を再指定するのは面倒です。

そこでwith式を使います。

C#
var product1 = new Product("Keyboard", 5000, "PC", true);

var product2 = product1 with
{
    Price = 6000
};

これにより、Name、Category、IsActiveはproduct1の値を引き継ぎ、Priceだけが6000になった新しいProductが作られます。

つまりwith式は、次のようなイメージです。

C#
元の値 + 変更したい部分 = 新しい値

既存のデータを直接変更するのではなく、新しいデータとして作り直す点が重要です。

1-2. recordとwith式がセットで使われる理由

recordとwith式は相性がよい機能です。

recordは、値そのものを表すデータ型として使われることが多いです。たとえば、ユーザー情報、設定値、APIレスポンス、イベントデータ、コマンド情報などです。

このようなデータは、後から直接書き換えるよりも、必要な部分だけを変更した新しいデータとして扱う方が安全です。

C#
public record UserProfile(
    int Id,
    string Name,
    string Email
);

メールアドレスだけを変更する場合は、次のように書けます。

C#
var current = new UserProfile(1, "Taro", "taro@example.com");

var updated = current with
{
    Email = "new-taro@example.com"
};

currentは元の状態のまま残ります。updatedには新しいメールアドレスが入ります。

このように、recordは「データを値として扱う」ための型であり、with式は「値を安全にコピー更新する」ための構文です。そのため、recordとwith式はセットで説明されることが多いです。

1-3. まずは最小コードで動きを確認する

最小限のコードでrecordとwith式の動きを確認してみます。

C#
public record Person(string Name, int Age);

var person1 = new Person("Alice", 30);

var person2 = person1 with
{
    Age = 31
};

Console.WriteLine(person1);
Console.WriteLine(person2);

出力例は次のようになります。

C#
Person { Name = Alice, Age = 30 }
Person { Name = Alice, Age = 31 }

person1はAge = 30のままです。person2はAge = 31になっています。

また、person1とperson2は別のインスタンスです。

C#
Console.WriteLine(ReferenceEquals(person1, person2));

出力は次のようになります。

C#
False

with式は、既存のオブジェクトを直接変更するものではありません。あくまで、コピーを作ってから指定したプロパティを変更する構文です。

2. C# recordの基本：with式を理解する前に押さえるポイント

2-1. recordとは何か

recordは、C# 9.0で導入されたデータ表現に向いた型です。

通常のclassと似ていますが、recordにはデータを扱いやすくするための機能が自動的に用意されます。

代表的な特徴は次のとおりです。

C#
public record Customer(int Id, string Name);

このように書くだけで、主に次のような機能が使えます。

値に基づく等価比較、ToString()の見やすい出力、分解、コピー更新に使う仕組みなどが自動で提供されます。

たとえば、同じ値を持つ2つのrecordを比較してみます。

C#
var customer1 = new Customer(1, "Taro");
var customer2 = new Customer(1, "Taro");

Console.WriteLine(customer1 == customer2);

出力は次のようになります。

C#
True

通常のclassでは、特別な実装をしない限り、別インスタンス同士の比較は参照が同じかどうかで判断されます。一方、recordでは値が同じであれば等しいと判断されます。

この「値として扱いやすい」という特徴が、recordの大きなポイントです。

2-2. record classとrecord structの違い

recordには、大きく分けてrecord classとrecord structがあります。

C#
public record class UserRecordClass(string Name, int Age);

public record struct UserRecordStruct(string Name, int Age);

record classは参照型です。通常のclassと同じように、変数にはオブジェクトへの参照が入ります。

C#
var user1 = new UserRecordClass("Alice", 30);
var user2 = user1;

この場合、user1とuser2は同じインスタンスを参照します。

一方、record structは値型です。通常のstructと同じように、代入時には値がコピーされます。

C#
var point1 = new Point(10, 20);
var point2 = point1;

record structは値型なので、小さな値のまとまりを表す場合に向いています。

ただし、実務ではrecord classの方が使われる場面は多いです。DTO、コマンド、イベント、設定値など、データを参照型として扱いたい場合にはrecord classが自然です。

なお、次のように単にrecordと書いた場合は、基本的にrecord classを意味します。

C#
public record User(string Name, int Age);

これは次の書き方とほぼ同じ意味です。

C#
public record class User(string Name, int Age);

2-3. イミュータブルなデータ表現に向いている理由

recordは、イミュータブルなデータ表現に向いています。

イミュータブルとは、作成後に値を変更しない、または変更しにくい性質のことです。

たとえば、次のようなrecordを考えます。

C#
public record Order(
    int Id,
    string Status,
    decimal TotalAmount
);

注文情報を直接変更するのではなく、状態が変わるたびに新しいOrderを作ると、過去の状態を壊さずに扱えます。

C#
var order1 = new Order(1, "Created", 5000m);

var order2 = order1 with
{
    Status = "Paid"
};

order1はCreatedのまま残ります。order2はPaidの新しい注文状態です。

このようにすると、どこかの処理で意図せず値が書き換わるリスクを減らせます。

特に、状態管理、非同期処理、テストコード、イベント履歴の管理などでは、元の値を壊さない設計が役立ちます。

2-4. initアクセサとsetアクセサの違い

recordを理解するうえで、initアクセサとsetアクセサの違いも重要です。

setは、オブジェクト作成後でもプロパティを書き換えられます。

C#
public class User
{
    public string Name { get; set; }
}

この場合、次のように後から変更できます。

C#
var user = new User { Name = "Alice" };
user.Name = "Bob";

一方、initは、オブジェクト初期化時にだけ値を設定できます。

C#
public record User
{
    public string Name { get; init; }
}

次のような初期化は可能です。

C#
var user = new User { Name = "Alice" };

しかし、作成後の通常代入はできません。

C#
user.Name = "Bob"; // コンパイルエラー

ただし、with式の中ではinitプロパティを指定できます。

C#
var updated = user with
{
    Name = "Bob"
};

これは、with式が新しいオブジェクトを作る初期化処理として扱われるためです。

recordのプライマリコンストラクタで定義したプロパティは、基本的にinit可能なプロパティとして扱われます。

C#
public record User(string Name, int Age);

そのため、次のようにwith式で更新できます。

C#
var user1 = new User("Alice", 30);

var user2 = user1 with
{
    Age = 31
};

3. with式の基本的な使い方

3-1. recordの一部プロパティだけ変更してコピーする

with式の基本形は次のとおりです。

C#
var newObject = oldObject with
{
    PropertyName = newValue
};

具体例を見てみましょう。

C#
public record Employee(
    int Id,
    string Name,
    string Department
);

var employee1 = new Employee(1, "Sato", "Sales");

var employee2 = employee1 with
{
    Department = "Marketing"
};

employee2は、DepartmentだけがMarketingになった新しいEmployeeです。

C#
Console.WriteLine(employee1);
Console.WriteLine(employee2);

出力例は次のようになります。

C#
Employee { Id = 1, Name = Sato, Department = Sales }
Employee { Id = 1, Name = Sato, Department = Marketing }

employee1のDepartmentはSalesのままです。with式は元のオブジェクトを壊しません。

3-2. 複数プロパティを同時に変更する

with式では、複数のプロパティを同時に変更できます。

C#
public record User(
    string Name,
    int Age,
    string Email
);

var user1 = new User("Alice", 30, "alice@example.com");

var user2 = user1 with
{
    Age = 31,
    Email = "alice.new@example.com"
};

この場合、Nameはそのままで、AgeとEmailだけが変更されます。

C#
Console.WriteLine(user2);

出力例は次のようになります。

C#
User { Name = Alice, Age = 31, Email = alice.new@example.com }

変更したいプロパティだけを書けばよいので、プロパティ数が多いrecordでも読みやすくなります。

3-3. 変更しないプロパティは元の値が引き継がれる

with式で指定しなかったプロパティは、元のオブジェクトから引き継がれます。

C#
public record Book(
    string Title,
    string Author,
    int Price
);

var book1 = new Book("C# Guide", "Tanaka", 3000);

var book2 = book1 with
{
    Price = 3500
};

book2のTitleとAuthorは、book1と同じです。

C#
Console.WriteLine(book2.Title);
Console.WriteLine(book2.Author);
Console.WriteLine(book2.Price);

出力例は次のようになります。

C#
C# Guide
Tanaka
3500

この「指定しなかった値はそのまま」という動きが、with式の大きな便利ポイントです。

3-4. with式で作られたオブジェクトは元のインスタンスとは別物

with式で作られたオブジェクトは、元のインスタンスとは別物です。

C#
public record User(string Name, int Age);

var user1 = new User("Alice", 30);
var user2 = user1 with { Age = 31 };

Console.WriteLine(ReferenceEquals(user1, user2));

出力は次のようになります。

C#
False

user1とuser2は別インスタンスです。

ただし、値の比較では注意が必要です。

C#
var user3 = user1 with { };

Console.WriteLine(ReferenceEquals(user1, user3));
Console.WriteLine(user1 == user3);

出力例は次のようになります。

C#
False
True

user3はuser1のコピーなので別インスタンスです。しかし、すべての値が同じなので、recordの値比較では等しいと判断されます。

つまり、recordでは「同じインスタンスか」と「同じ値か」を分けて考える必要があります。

4. with式の仕組み：内部では何が起きているのか

4-1. with式はコピーを作ってから指定プロパティを更新する

with式の基本的な流れは、次のように考えるとわかりやすいです。

C#
var newObject = oldObjectのコピーを作る;
newObject.Property = newValue;

実際のコードでは次のように書きます。

C#
var user2 = user1 with
{
    Age = 31
};

これはイメージとしては、次のような処理に近いです。

C#
var user2 = コピーされたuser1;
user2.Age = 31;

もちろん、実際にはコンパイラがrecordのコピー更新に必要な処理を使って展開します。

重要なのは、元のインスタンスを書き換えているわけではないという点です。

C#
var user1 = new User("Alice", 30);
var user2 = user1 with { Age = 31 };

Console.WriteLine(user1.Age); // 30
Console.WriteLine(user2.Age); // 31

with式は、変更というより「コピー更新」と考えると理解しやすくなります。

4-2. record classではClone相当の処理が使われる

record classでwith式を使うと、内部ではコピーを作るための仕組みが使われます。

C#
public record User(string Name, int Age);

このようなrecord classには、コピーを作るためのメンバーがコンパイラによって生成されます。with式はその仕組みを利用して、新しいインスタンスを作ります。

C#
var user1 = new User("Alice", 30);
var user2 = user1 with { Age = 31 };

大まかなイメージは次のとおりです。

C#
var user2 = user1のコピー;
user2.Age = 31;

record classは参照型なので、単に変数を代入するだけではコピーになりません。

C#
var user2 = user1;

これは同じインスタンスを参照するだけです。

しかし、with式を使うと、元のインスタンスとは別のインスタンスが作られます。

C#
var user2 = user1 with { };

この時点で、値が同じ別インスタンスが作られます。

4-3. record structでは値のコピーとして扱われる

record structは値型です。そのため、with式では値のコピーとして扱われます。

C#
public record struct Point(int X, int Y);

var point1 = new Point(10, 20);

var point2 = point1 with
{
    X = 30
};

point2は、Yは20のままで、Xだけが30になった新しい値です。

C#
Console.WriteLine(point1);
Console.WriteLine(point2);

出力例は次のようになります。

C#
Point { X = 10, Y = 20 }
Point { X = 30, Y = 20 }

record structは値型なので、record classとはコピーの考え方が少し異なります。ただし、with式を使う側から見ると「元の値を残したまま、一部だけ変更したコピーを作る」という感覚は同じです。

4-4. with式はディープコピーではなく浅いコピーである

with式で特に重要なのが、ディープコピーではなく浅いコピーであるという点です。

浅いコピーとは、オブジェクトが持っている参照型プロパティについて、参照先の中身まではコピーしないということです。

たとえば、次のようなrecordを考えます。

C#
public record User(string Name, Address Address);

public record Address(string City);

この場合、Userをwith式でコピーしても、Addressを変更しなければ、同じAddressインスタンスを参照します。

C#
var address = new Address("Tokyo");
var user1 = new User("Alice", address);

var user2 = user1 with
{
    Name = "Bob"
};

Console.WriteLine(ReferenceEquals(user1.Address, user2.Address));

出力は次のようになります。

C#
True

user1とuser2は別インスタンスですが、Addressプロパティは同じ参照を持っています。

これが浅いコピーです。

4-5. 参照型プロパティを持つ場合の注意点

参照型プロパティがイミュータブルであれば、浅いコピーでも問題になりにくいです。

C#
public record Address(string City);
public record User(string Name, Address Address);

Addressもrecordで、値を書き換えずに扱うなら安全です。

一方、参照型プロパティが可変オブジェクトの場合は注意が必要です。

C#
public record Team(string Name, List<string> Members);

var members = new List<string> { "Alice", "Bob" };

var team1 = new Team("A Team", members);

var team2 = team1 with
{
    Name = "B Team"
};

team2.Members.Add("Charlie");

Console.WriteLine(string.Join(", ", team1.Members));
Console.WriteLine(string.Join(", ", team2.Members));

出力例は次のようになります。

C#
Alice, Bob, Charlie
Alice, Bob, Charlie

team1とteam2は別のTeamですが、MembersのList<string>は同じインスタンスを参照しています。

そのため、team2.Membersを変更すると、team1.Membersにも影響します。

このようなケースでは、コレクションもコピーして渡す必要があります。

C#
var team2 = team1 with
{
    Name = "B Team",
    Members = team1.Members.ToList()
};

または、List<T>ではなく、読み取り専用コレクションやイミュータブルコレクションを使う設計も検討します。

5. C# record with式の具体例

5-1. ユーザー情報を一部だけ変更する例

ユーザー情報の一部を変更する例です。

C#
public record User(
    int Id,
    string Name,
    string Email,
    bool IsActive
);

var user = new User(
    Id: 1,
    Name: "Yamada",
    Email: "yamada@example.com",
    IsActive: true
);

var updatedUser = user with
{
    Email = "yamada.new@example.com"
};

updatedUserは、メールアドレスだけが変更された新しいユーザー情報です。

C#
Console.WriteLine(user.Email);
Console.WriteLine(updatedUser.Email);

出力例は次のようになります。

C#
yamada@example.com
yamada.new@example.com

元のuserは変更されません。

実務では、画面から入力された変更内容をもとにDTOを更新する場合などに使えます。

5-2. 設定オブジェクトをコピー更新する例

アプリケーション設定の一部だけを変えたい場合にも、with式は便利です。

C#
public record AppSettings(
    string Environment,
    int TimeoutSeconds,
    bool EnableLogging
);

var defaultSettings = new AppSettings(
    Environment: "Production",
    TimeoutSeconds: 30,
    EnableLogging: false
);

var debugSettings = defaultSettings with
{
    Environment = "Development",
    EnableLogging = true
};

TimeoutSecondsは元の値のまま、EnvironmentとEnableLoggingだけを変更できます。

C#
Console.WriteLine(debugSettings);

出力例は次のようになります。

C#
AppSettings { Environment = Development, TimeoutSeconds = 30, EnableLogging = True }

設定値のように、基本設定をもとに環境ごとの設定を作る場面では、with式によるコピー更新が読みやすくなります。

5-3. DTOやAPIレスポンスで使う例

DTOやAPIレスポンスを扱うときにもrecordとwith式はよく合います。

C#
public record UserResponse(
    int Id,
    string Name,
    string Email,
    string Role
);

たとえば、内部用のレスポンスから、外部公開用に一部の値を変更する場合を考えます。

C#
var internalResponse = new UserResponse(
    Id: 1,
    Name: "Sato",
    Email: "sato@example.com",
    Role: "Admin"
);

var publicResponse = internalResponse with
{
    Email = "hidden@example.com",
    Role = "User"
};

このように、元のDTOを壊さずに、用途に応じた別のDTOを作れます。

ただし、機密情報を隠す目的で使う場合は、そもそも公開用DTOを別に定義した方が安全なケースもあります。with式は便利ですが、セキュリティ設計そのものを置き換えるものではありません。

5-4. ネストしたrecordを更新する例

ネストしたrecordを更新する場合は、内側のrecordにもwith式を使います。

C#
public record Address(
    string PostalCode,
    string City
);

public record User(
    string Name,
    Address Address
);

ユーザーの住所のうち、Cityだけを変更したい場合は次のように書きます。

C#
var user1 = new User(
    Name: "Alice",
    Address: new Address("100-0001", "Tokyo")
);

var user2 = user1 with
{
    Address = user1.Address with
    {
        City = "Osaka"
    }
};

外側のUserをコピーし、さらに内側のAddressもコピー更新しています。

C#
Console.WriteLine(user1.Address.City);
Console.WriteLine(user2.Address.City);

出力例は次のようになります。

C#
Tokyo
Osaka

ネストした値を安全に更新したい場合は、このように階層ごとにwith式を使うのが基本です。

5-5. コレクションを含むrecordでの注意例

コレクションを含むrecordでは、浅いコピーに注意が必要です。

C#
public record Cart(
    int UserId,
    List<string> Items
);

var cart1 = new Cart(
    UserId: 1,
    Items: new List<string> { "Book", "Pen" }
);

var cart2 = cart1 with
{
    UserId = 2
};

cart2.Items.Add("Notebook");

Console.WriteLine(string.Join(", ", cart1.Items));

出力例は次のようになります。

C#
Book, Pen, Notebook

cart2.Itemsを変更したのに、cart1.Itemsにも影響しています。これは、ItemsのList<string>が同じ参照だからです。

安全に扱うなら、コレクションもコピーします。

C#
var cart2 = cart1 with
{
    UserId = 2,
    Items = cart1.Items.ToList()
};

さらに堅牢にしたい場合は、可変なList<T>を外部に公開せず、読み取り専用コレクションやイミュータブルコレクションの利用を検討します。

C#
public record Cart(
    int UserId,
    IReadOnlyList<string> Items
);

ただし、IReadOnlyList<T>にしても、内部の実体がList<T>である場合は完全に不変になるわけではありません。設計上、本当に変更不可にしたい場合は、より厳密な方法を選ぶ必要があります。

6. recordのwith式とclassの違い

6-1. 通常のclassではwith式をそのまま使えない

通常のclassでは、recordのようにwith式をそのまま使うことはできません。

C#
public class User
{
    public string Name { get; init; }
    public int Age { get; init; }
}

var user1 = new User
{
    Name = "Alice",
    Age = 30
};

var user2 = user1 with
{
    Age = 31
};

このようなコードは、通常のclassではコンパイルエラーになります。

with式を使いたい場合は、record classとして定義します。

C#
public record User
{
    public string Name { get; init; }
    public int Age { get; init; }
}

または、プライマリコンストラクタ形式で次のように書けます。

C#
public record User(string Name, int Age);

recordはコピー更新に必要な仕組みをコンパイラが用意してくれるため、with式と自然に組み合わせられます。

6-2. recordはコピー更新のための仕組みが自動生成される

recordでは、コピー更新に必要な仕組みが自動生成されます。

C#
public record User(string Name, int Age);

この短い定義だけで、次のようなコードが使えます。

C#
var user1 = new User("Alice", 30);
var user2 = user1 with { Age = 31 };

通常のclassで同じようなことをしようとすると、自分でコピー用のメソッドやコンストラクタを実装する必要があります。

recordは、値の比較、見やすいToString()、コピー更新など、データ中心の型に必要な機能を自動で持たせられる点が特徴です。

6-3. classで同じことをする場合の実装例

通常のclassでwith式のようなコピー更新をしたい場合は、自分でメソッドを用意します。

C#
public class User
{
    public string Name { get; }
    public int Age { get; }

    public User(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public User With(
        string? name = null,
        int? age = null
    )
    {
        return new User(
            name ?? this.Name,
            age ?? this.Age
        );
    }
}

使う側は次のようになります。

C#
var user1 = new User("Alice", 30);

var user2 = user1.With(age: 31);

このようにすれば、通常のclassでも似たことはできます。

ただし、プロパティが増えるほど実装が面倒になります。また、nullを有効な値として扱いたい場合には、この例のようなnull合体演算子では正しく表現できないこともあります。

より厳密に実装するなら、変更する値を明示的に表す仕組みを用意する必要があります。

その点、recordとwith式を使えば、コピー更新を言語機能として簡潔に書けます。

6-4. recordとclassの使い分け

recordとclassは、どちらが常に優れているというものではありません。目的によって使い分けます。

recordが向いているのは、値そのものを表したい場合です。

たとえば、次のようなものです。

C#
public record Money(decimal Amount, string Currency);
public record UserDto(int Id, string Name, string Email);
public record OrderCreatedEvent(int OrderId, DateTime CreatedAt);

これらは、データの中身が重要です。値が同じなら同じものとして扱いたい場面が多いため、recordと相性がよいです。

一方、通常のclassが向いているのは、状態や振る舞いを持つオブジェクトを表したい場合です。

C#
public class BankAccount
{
    public decimal Balance { get; private set; }

    public void Deposit(decimal amount)
    {
        Balance += amount;
    }

    public void Withdraw(decimal amount)
    {
        Balance -= amount;
    }
}

このような型では、単なる値のまとまりではなく、振る舞いやライフサイクルが重要になります。その場合は、通常のclassの方が自然です。

6-5. 値の比較と参照の比較の違い

recordとclassの大きな違いのひとつが、等価比較です。

通常のclassでは、特別な実装をしない限り、同じ値を持っていても別インスタンスなら等しくありません。

C#
public class UserClass
{
    public string Name { get; init; }
    public int Age { get; init; }
}

var c1 = new UserClass { Name = "Alice", Age = 30 };
var c2 = new UserClass { Name = "Alice", Age = 30 };

Console.WriteLine(c1 == c2);

出力は通常、次のようになります。

C#
False

一方、recordでは値が同じなら等しいと判断されます。

C#
public record UserRecord(string Name, int Age);

var r1 = new UserRecord("Alice", 30);
var r2 = new UserRecord("Alice", 30);

Console.WriteLine(r1 == r2);

出力は次のようになります。

C#
True

ただし、参照が同じかどうかを確認する場合はReferenceEqualsを使います。

C#
Console.WriteLine(ReferenceEquals(r1, r2));

出力は次のようになります。

C#
False

recordでは、値としては等しくても、インスタンスとしては別物というケースがあります。with式を使うときも、この違いを理解しておくことが大切です。

7. with式を使うメリット

7-1. 元のデータを壊さず安全に更新できる

with式の最大のメリットは、元のデータを壊さずに更新できることです。

C#
var original = new User("Alice", 30);

var updated = original with
{
    Age = 31
};

このとき、originalは変更されません。

C#
Console.WriteLine(original.Age); // 30
Console.WriteLine(updated.Age);  // 31

複数の処理で同じデータを参照している場合、元のデータが勝手に変更されるとバグの原因になります。

with式を使って新しい値を作る設計にすると、変更前と変更後を明確に分けられます。

7-2. コードが短く読みやすくなる

with式を使うと、コピー更新のコードが短くなります。

たとえば、次のようなrecordがあります。

C#
public record Product(
    int Id,
    string Name,
    int Price,
    string Category,
    bool IsActive
);

Priceだけを変更したい場合、コンストラクタで作り直すと次のようになります。

C#
var updated = new Product(
    product.Id,
    product.Name,
    1200,
    product.Category,
    product.IsActive
);

with式を使うと、変更箇所だけを書けます。

C#
var updated = product with
{
    Price = 1200
};

どの値を変更したのかが一目でわかるため、コードレビューもしやすくなります。

7-3. 状態管理や関数型スタイルと相性がよい

with式は、状態を直接変更せず、新しい状態を返すスタイルと相性がよいです。

C#
public record CounterState(int Count);

CounterState Increment(CounterState state)
{
    return state with
    {
        Count = state.Count + 1
    };
}

この関数は、受け取ったstateを直接変更しません。新しいCounterStateを返します。

C#
var state1 = new CounterState(0);
var state2 = Increment(state1);

Console.WriteLine(state1.Count); // 0
Console.WriteLine(state2.Count); // 1

このような書き方は、状態の変化を追いやすく、予期しない副作用を減らしやすいという利点があります。

7-4. テストしやすいコードを書きやすい

with式は、テストデータの作成にも便利です。

たとえば、基本となるテストユーザーを用意します。

C#
var baseUser = new User(
    Id: 1,
    Name: "Test User",
    Email: "test@example.com",
    IsActive: true
);

テストケースごとに一部だけ変更できます。

C#
var inactiveUser = baseUser with
{
    IsActive = false
};

var anotherEmailUser = baseUser with
{
    Email = "another@example.com"
};

毎回すべてのプロパティを指定する必要がないため、テストコードが読みやすくなります。

また、変更箇所が明確になるため、「このテストでは何を変えているのか」が伝わりやすくなります。

7-5. バグの原因になる副作用を減らせる

オブジェクトを直接変更する設計では、どこで値が変わったのか追いにくくなることがあります。

C#
user.Age = 31;

このような代入がいろいろな場所にあると、状態の変化を追跡するのが難しくなります。

一方、with式を使うと、変更前と変更後を別の値として扱えます。

C#
var updatedUser = user with
{
    Age = 31
};

この書き方では、元のuserは変わりません。新しい値としてupdatedUserが作られます。

そのため、意図しない副作用を減らし、処理の流れを明確にできます。

8. with式を使うときの注意点

8-1. 浅いコピーであることを理解する

with式は便利ですが、ディープコピーではありません。

C#
public record Profile(string Name, List<string> Tags);

var profile1 = new Profile(
    "Alice",
    new List<string> { "CSharp", "Backend" }
);

var profile2 = profile1 with
{
    Name = "Bob"
};

この場合、profile1とprofile2のTagsは同じList<string>を参照しています。

C#
profile2.Tags.Add("API");

Console.WriteLine(string.Join(", ", profile1.Tags));

出力例は次のようになります。

C#
CSharp, Backend, API

profile2側で追加した値が、profile1側にも見えています。

with式はトップレベルのオブジェクトをコピーしますが、内部にある参照型オブジェクトの中身まで自動的に複製するわけではありません。

8-2. 参照型プロパティの変更は元オブジェクトにも影響する場合がある

参照型プロパティが可変である場合、コピー後のオブジェクトから参照先を変更すると、元オブジェクトにも影響する場合があります。

C#
public record Document(
    string Title,
    StringBuilder Content
);

StringBuilderは可変オブジェクトです。

C#
var document1 = new Document(
    "Memo",
    new StringBuilder("Hello")
);

var document2 = document1 with
{
    Title = "New Memo"
};

document2.Content.Append(" World");

Console.WriteLine(document1.Content.ToString());

出力例は次のようになります。

C#
Hello World

document2.Contentを変更したつもりでも、document1.Contentにも影響しています。

このような場合は、参照型プロパティも明示的にコピーする必要があります。

C#
var document2 = document1 with
{
    Title = "New Memo",
    Content = new StringBuilder(document1.Content.ToString())
};

または、StringBuilderのような可変型ではなく、stringのような不変型を使えるか検討します。

8-3. initのみのプロパティと更新タイミング

initプロパティは、通常の代入では作成後に変更できません。

C#
public record User
{
    public string Name { get; init; }
}

次のコードはコンパイルエラーになります。

C#
var user = new User { Name = "Alice" };

user.Name = "Bob"; // エラー

しかし、with式では指定できます。

C#
var updated = user with
{
    Name = "Bob"
};

これは、with式が新しいオブジェクトを作るときの初期化処理として扱われるためです。

ただし、すべてのプロパティがwith式で更新できるわけではありません。更新したいプロパティには、initまたはsetが必要です。

C#
public record User
{
    public string Name { get; }
    
    public User(string name)
    {
        Name = name;
    }
}

このようにgetのみで、initもsetもないプロパティは、with式で変更できません。

C#
var user2 = user1 with
{
    Name = "Bob" // エラー
};

with式で更新したい値は、初期化可能なプロパティとして設計しておく必要があります。

8-4. 可変コレクションを持たせる場合のリスク

recordにList<T>やDictionary<TKey, TValue>などの可変コレクションを持たせる場合は注意が必要です。

C#
public record UserGroup(
    string Name,
    List<string> Users
);

このようなrecordは、一見イミュータブルに見えても、Usersの中身は変更できます。

C#
var group = new UserGroup(
    "Admins",
    new List<string> { "Alice" }
);

group.Users.Add("Bob");

recordそのもののプロパティを差し替えていなくても、内部のリストは変更できてしまいます。

より安全にするには、次のような設計を検討します。

C#
public record UserGroup(
    string Name,
    IReadOnlyList<string> Users
);