不変オブジェクト

オブジェクト指向(OO) および関数型プログラミングでは、不変オブジェクト(変更不可能な^[1]オブジェクト) は、作成後に状態を変更できないオブジェクトです。 ^{[2]これは、作成後に変更できる}可変オブジェクト(変更可能なオブジェクト)とは対照的です。^[3]場合によっては、内部で使用される属性の一部が変更されても、オブジェクトの状態が外部から見ると不変であるように見える場合でも、オブジェクトは不変であると見なされます。たとえば、高価な計算の結果をキャッシュするためにメモ化を使用するオブジェクトは、依然として不変オブジェクトと見なされます。

文字列やその他の具体的なオブジェクトは、通常、OOプログラミングの可読性と実行効率を向上させるために不変オブジェクトとして表現されます。不変オブジェクトは本質的にスレッドセーフであるため便利です。^[2]その他の利点としては、理解と推論が簡単で、可変オブジェクトよりもセキュリティが高いことが挙げられます。^[2]

命令型プログラミングでは、プログラム変数に保持され、内容が決して変化しない値は、実行中に変更される可能性のある変数と区別するために定数と呼ばれます。例としては、メートルからフィートへの変換係数や、小数点以下の桁数で 表した円周率などがあります。

読み取り専用フィールドは、プログラムの実行時に計算される場合があります (事前にわかっている定数とは異なります) が、初期化後は変更されることはありません。

時々、オブジェクトの特定のフィールドが不変であるという話があります。これは、オブジェクトの他の部分が変更可能である場合でも (弱い不変)、オブジェクトの状態のそれらの部分を変更する方法がないことを意味します。すべてのフィールドが不変の場合、オブジェクトは不変です。オブジェクト全体を別のクラスによって拡張できない場合、オブジェクトは強い不変 と呼ばれます。^[4]これは、たとえば、オブジェクトの特定のデータに関する特定の不変条件がオブジェクトの存続期間中同じままであることを明示的に強制するのに役立つ場合があります。一部の言語では、フィールドを不変として指定するキーワードを使用してこれを行います (例: C++、Java )。一部の言語では逆になります。OCaml では、constオブジェクトまたはレコードのフィールドはデフォルトで不変であり、そのように明示的にマークする必要があります。 finalmutable

ほとんどのオブジェクト指向言語では、参照を使用してオブジェクトを参照できます。このような言語の例としては、Java、C++、C#、VB.NET、およびPerl、Python、Rubyなどの多くのスクリプト言語があります。この場合、オブジェクトが参照を介して共有されるときにオブジェクトの状態が変化するかどうかが重要になります。

オブジェクトが不変であることがわかっている場合は、オブジェクト全体をコピーするのではなく、その参照を作成することをお勧めします。これは、データの重複を防ぎ、コンストラクターとデストラクタの呼び出しを回避することでメモリを節約するために行われます。また、実行速度が向上する可能性もあります。

参照のコピー手法は、可変オブジェクトに使用するのがはるかに困難です。可変オブジェクト参照のユーザーが変更すると、その参照の他のすべてのユーザーが変更を認識するためです。これが意図した効果でない場合は、他のユーザーに通知して正しく対応してもらうことが困難になる可能性があります。このような状況では、参照ではなくオブジェクト全体を防御的にコピーするのが、通常は簡単ですがコストのかかる解決策です。オブザーバー パターンは、可変オブジェクトへの変更を処理するための代替手法です。

可変オブジェクトと不変オブジェクトの利点を組み合わせた技術で、ほぼすべての最新ハードウェアで直接サポートされているのが、コピー オン ライト(COW) です。この技術を使用すると、ユーザーがシステムにオブジェクトのコピーを要求しても、システムは同じオブジェクトを指す新しい参照を作成するだけです。ユーザーが特定の参照を通じてオブジェクトを変更しようとすると、システムは実際のコピーを作成し、そのコピーに変更を適用して、新しいコピーを参照するように参照を設定します。他のユーザーは元のオブジェクトを参照しているため、影響を受けません。したがって、COW では、すべてのユーザーがオブジェクトの可変バージョンを持っているように見えますが、ユーザーがオブジェクトを変更しない場合は、不変オブジェクトのスペース節約と速度の利点が維持されます。コピー オン ライトは、アプリケーション プログラムが行う可能性のあるすべての処理を正しく行いながらメモリ スペースを節約できるため、 仮想メモリシステムでよく使用されます。

等しいオブジェクトのコピーの代わりに常に参照を使用する方法は、インターンと呼ばれます。インターンを使用すると、2 つのオブジェクトは、その参照 (通常はポインタまたは整数として表される) が等しい場合にのみ等しいとみなされます。一部の言語ではこれを自動的に行います。たとえば、Python は短い文字列を自動的にインターンします。インターンを実装するアルゴリズムが、可能な限りすべてのケースでインターンを実行することが保証されている場合、オブジェクトの等価性の比較はポインタの比較に簡略化されます。これにより、ほとんどのアプリケーションで速度が大幅に向上します。(アルゴリズムが包括的であるとは保証されていない場合でも、オブジェクトが等しく同じ参照を使用する場合は、高速パスケースが改善される可能性があります。)インターンは一般に、不変オブジェクトにのみ役立ちます。

不変オブジェクトは、マルチスレッド アプリケーションで役立ちます。複数のスレッドは、他のスレッドによってデータが変更されることを気にすることなく、不変オブジェクトによって表されるデータに対して操作を行うことができます。そのため、不変オブジェクトは可変オブジェクトより もスレッドセーフであると考えられています。

不変性は、コンピュータのメモリに格納されているオブジェクトが書き込み不可能であることを意味するものではありません。むしろ、不変性は、プログラマーがオブジェクトの通常のインターフェースを通じて何ができるかを示すコンパイル時の構造であり、必ずしもプログラマーが絶対に何ができるかを示すものではありません (たとえば、型システムを回避したり、CまたはC++のconst の正確さに違反したりすること)。

Python、Java ^{[5] : 80}、.NET Frameworkでは、文字列は不変オブジェクトです。Javaと.NET Frameworkはどちらも文字列の可変バージョンを持っています。Java ^{[5] : 84}ではこれらはStringBufferとStringBuilder（Javaの可変バージョンString）であり、.NETではこれはStringBuilder（.Netの可変バージョンString）です。Python 3には、という名前の可変文字列（バイト）バリアントがありますbytearray。^[6]

さらに、Java のすべてのプリミティブ ラッパー クラスは不変です。

同様のパターンとしては、不変インターフェースと不変ラッパーがあります。

純粋な関数型プログラミング言語では、言語を拡張せずに (たとえば、可変参照ライブラリまたは外部関数インターフェースを介して) 可変オブジェクトを作成することはできないため、すべてのオブジェクトは不変です。

Adaでは、任意のオブジェクトは、キーワードを使用して変数(つまり、変更可能、通常は暗黙のデフォルト) またはconstant(つまり、不変)として宣言されますconstant。

  型 Some_typeは 新しいIntegerです 。-- もっと複雑なものでも構いません。x : constant Some_type := 1です。-- 不変です。y : Some_typeです。-- 可変です。  
      
    

サブプログラム パラメータは、 inモードでは不変ですが、in outモードとoutモードでは変更可能です。

  手順 Do_it ( a : in  Integer ;  b : in  out  Integer ;  c : out  Integer ) は
  begin 
    -- a は不変です
    b :=  b  +  a ; 
    c :=  a ; 
  end  Do_it ;

C#では、ステートメントを使用してクラスのフィールドの不変性を強制できますreadonly。^{[7] : 239} すべてのフィールドを不変として強制することで、不変型が得られます。

クラスAnImmutableType { public readonly double _value ; public AnImmutableType ( double x ) { _value = x ; } public AnImmutableType Square () { return new AnImmutableType ( _value * _value ); } } 

       
       
     
           
    
       
     
             
    

C#には不変のレコードがあります。^{[8] [9]}

レコードPerson (文字列FirstName 、文字列LastName );    

C++ では、 のconst 正しい実装により、Cartユーザーはクラスのインスタンスを作成し、メソッドconstの 2 つの異なるバージョンを提供することで、必要に応じてそれらを (不変) または可変として使用できますitems()。(C++ では、インスタンス専用のコンストラクターを提供する必要はなく、実際には不可能であることに注意してくださいconst。)

クラスCart { public : Cart ( std :: vector < Item > items ) : items_ ( items ) {}  
 
     

  std :: vector < Item >& items () { return items_ ; } const std :: vector < Item >& items () const { return items_ ; }     
         

  int ComputeTotalCost () const { /* 価格の合計を返す */ }     

 プライベート: 
std :: vector <Item> items_ ; } ;​   

別のオブジェクトへのポインターまたは参照であるデータ メンバーがある場合、非 const メソッド内でのみ、指し示されているまたは参照されているオブジェクトを変更できることに注意してください。

C++ では、キーワードを介して抽象的な (ビット単位ではなく) 不変性も提供されmutable、これによりメソッド内からメンバー変数constを変更できます。

クラスCart { public : Cart ( std :: vector < Item > items ) : items_ ( items ) {}  
 
     

  const std :: vector < Item >& items () const { return items_ ; }       

  int ComputeTotalCost () const { if ( total_cost_ ) { return * total_cost_ ; }   
      
       
    

    int total_cost = 0 ; for ( const auto & item : items_ ) { total_cost += item . Cost (); } total_cost_ = total_cost ; return total_cost ; }   
          
        
    
      
     
  

 プライベート: 
std :: vector < Item > items_ ;可変std :: optional < int > total_cost_ ; };   
    

Dには、変更できない変数に対して、との 2 つの型修飾子が存在します。 ^[10] C++ の、Java の、C# の とは異なり、これらは推移的であり、そのような変数の参照を通じて到達可能なものに再帰的に適用されます。 と の違いは、それらが何に適用されるかということです。は変数のプロパティです。参照される値への可変参照が合法的に存在する可能性があります。つまり、値は実際に変更できます。対照的に、 は参照される値の特性です。値と、そこから推移的に到達可能なものは変更できません (型システムを壊さずに、未定義の動作につながる)。その値への参照はすべて、または としてマークされている必要があります。基本的に、修飾されていない型 に対して、は(可変)と の互いに素な和集合です。 constimmutableconstfinalreadonlyconstimmutableconstimmutableconstimmutableTconst(T)Timmutable(T)

クラスC { /*可変*/ Object mField ; const Object cField ;不変Object iField ; }  
    
          
      

可変Cオブジェクトの場合、mFieldに書き込むことができます。 オブジェクトの場合const(C)、 はmField変更できませんが、 を継承しますconst。iFieldはより強力な保証であるため、依然として不変です。 の場合immutable(C)、すべてのフィールドが不変です。

次のような関数の場合:

void func ( C m , const C c , immutable C i ) { /* 括弧内 */ }        
  

中括弧内では、cは と同じオブジェクトを参照している可能性があります。mそのため、 への変更によって間接m的に変更される可能性cもあります。また、 はcと同じオブジェクトを参照している可能性がありますiが、その場合の値は不変であるため、変更はありません。ただし、mと はi同じオブジェクトを正当に参照することはできません。

保証の言語では、 mutable には保証がありません (関数がオブジェクトを変更する可能性があります)、const関数が何も変更しないという外向きのみの保証であり、 immutable双方向の保証です (関数は値を変更せず、呼び出し元も値を変更してはいけません)。

宣言時点での直接割り当てまたはコンストラクターconstによって初期化されるか初期化される必要がある値。 immutable

constパラメータは値が可変かどうかを忘れてしまうため、同様の構造でinoutある は、ある意味では可変性情報の変数として機能します。 型の関数は、可変、const、不変の引数に対して型指定された値をconst(S) function(const(T))返しますconst(S)。対照的に、 型の関数は、可変引数に対して を、値に対して を、値 に対して をinout(S) function(inout(T))返します。STconst(S)const(T)immutable(S)immutable(T)

不変値を可変値にキャストすると、元の値が可変値から取得された場合でも、変更時に未定義の動作が発生します。可変値を不変値にキャストすることは、その後に可変参照が残っていない場合に合法です。「式が一意であり、推移的に参照するすべての式が一意または不変である場合、式は可変 (...) から不変に変換できます。」^[10]コンパイラが一意性を証明できない場合、キャストは明示的に実行でき、可変参照が存在しないことを確認するのはプログラマの責任です。

型はstringの別名でありimmutable(char)[]、つまり不変の文字のメモリの型付きスライスです。^[11]部分文字列の作成は、ポインタと長さフィールドをコピーして変更するだけなので安価であり、基になるデータは変更できないので安全です。 型のオブジェクトはconst(char)[]文字列を参照できますが、可変バッファも参照できます。

const または不変値の浅いコピーを作成すると、不変性の外側の層が削除されます。不変の文字列 ( immutable(char[])) をコピーすると、文字列 ( immutable(char)[]) が返されます。不変のポインタと長さがコピーされ、コピーは可変です。参照されるデータはコピーされず、例では修飾子が保持されますimmutable。これは、たとえば関数を使用して、より深いコピーを作成することで削除できますdup。

不変オブジェクトの典型的な例は、JavaStringクラス のインスタンスである。

String s = "ABC" ; s . toLowerCase (); // これは何も達成しません!   
 

このメソッドは、含まれるtoLowerCase()データ「ABC」を変更しませんs。代わりに、新しい String オブジェクトがインスタンス化され、その構築時にデータ「abc」が与えられます。この String オブジェクトへの参照がtoLowerCase()メソッドによって返されます。String にデータ「abc」を含めるにはs、別の方法が必要です。

s = s .toLowerCase ( );  

ここで、String はs「abc」を含む新しい String オブジェクトを参照します。Stringクラスの宣言の構文には、これを不変として強制するものは何もありません。むしろ、String クラスのメソッドはいずれも String オブジェクトに含まれるデータに影響を与えないため、String オブジェクトは不変になります。

キーワードfinal(詳細な記事)は不変のプリミティブ型とオブジェクト参照を実装する際に使用されますが、^[12]それだけではオブジェクト自体を不変にすることはできません。以下の例を参照してください。

プリミティブ型変数 ( int、long、shortなど) は、定義後に再割り当てされる可能性があります。 を使用すると、これを防ぐことができますfinal。

int i = 42 ; //intはプリミティブ型ですi = 43 ; // OK    
   

final int j = 42 ; j = 43 ; // コンパイルされません。j は final なので再割り当てできません    
   

参照型は、キーワードを使用するだけでは不変にできませんfinal。final再割り当てのみを防ぎます。

final MyObject m = new MyObject (); //m は参照型ですm . data = 100 ; // OK。オブジェクト m の状態を変更できます (m は可変で、final はこの事実を変更しません) m = new MyObject (); // コンパイルされません。m は final なので再割り当てできません      
   
    

プリミティブラッパー（Integer、、、、、、、）もすべて不変です。不変クラスは、いくつかの簡単なガイドラインに従うことでLong実装ShortできDoubleますFloat。[ ¹³Character ]ByteBoolean

JavaScriptでは、すべてのプリミティブ型 (Undefined、Null、Boolean、Number、BigInt、String、Symbol) は不変ですが、カスタム オブジェクトは通常は可変です。

function doSomething ( x ) { /* ここで x を変更すると、元の x が変更されますか? */ }; var str = 'a string' ; var obj = { an : 'object' }; doSomething ( str ); // 文字列、数値、bool 型は不変で、関数はコピーを取得しますdoSomething ( obj ); // オブジェクトは参照によって渡され、関数内で変更可能ですdoAnotherThing ( str , obj ); // `str` は変更されていませんが、`obj` は変更されている可能性があります。    
   
      
         
         
  

オブジェクトの不変性をシミュレートするには、プロパティを読み取り専用 (書き込み可能: false) として定義します。

var obj = {}; Object . defineProperty ( obj , 'foo' , { value : 'bar' , writable : false }); obj . foo = 'bar2' ; // 無視される   
       
   

ただし、上記の方法では、新しいプロパティを追加できます。または、Object.freeze を使用して既存のオブジェクトを不変にすることもできます。

var obj = { foo : 'bar' }; Object . freeze ( obj ); obj . foo = 'bars' ; // プロパティを編集できないため、無視されますobj . foo2 = 'bar2' ; // プロパティを追加できないため、無視されます      

   
   

ECMA262 の実装により、JavaScript は再割り当てできない不変の参照を作成することができます。ただし、const宣言を使用することは、読み取り専用参照の値が不変であることを意味するわけではなく、名前を新しい値に割り当てることができないというだけです。

定数ALWAYS_IMMUTABLE = true ;   

try { ALWAYS_IMMUTABLE = false ; } catch ( err ) { console . log ( "不変参照を再割り当てできません。" ); } 
    
   
  


const arr = [ 1 , 2 , 3 ]; arr.push ( 4 ); console.log ( arr ); // [ 1 , 2 , 3, 4 ]     

 

Reactが導入されて以来、JavaScriptでは不変状態の使用がトレンドとなり、 ReduxのようなFluxのような状態管理パターンが好まれるようになりました。^[14]

Perlでは、すべての属性を読み取り専用として宣言するだけで、Moo ライブラリを使用して不変クラスを作成できます。

パッケージImmutable ; Mooを使用します; 
 

値がある=> ( is => 'ro' 、# 読み取り専用デフォルト=> 'data' 、 # コンストラクターに値を指定してオーバーライドできます: Immutable->new(value => 'something else'); );   
              
       
                       


1 ;

不変クラスを作成するには、以前は 2 つの手順が必要でした。まず、オブジェクト属性の変更を防ぐアクセサー (自動または手動) を作成し、次に、そのクラスのインスタンスのインスタンス データが直接変更されるのを防ぎます (これは通常、ハッシュ参照に格納され、Hash::Util の lock_hash 関数でロックできます)。

package Immutable ; use strict ; use warnings ; use base qw(Class::Accessor) ; # 読み取り専用アクセサーを作成__PACKAGE__ -> mk_ro_accessors ( qw(value) ); use Hash::Util 'lock_hash' ; 
 
 
  


  

sub new { my $class = shift ; return $class if ref ( $class ); die "new への引数は、キー => 値のペアである必要があります\n" until ( @_ % 2 == 0 ); my %defaults = ( value => 'data' , ); my $obj = { %defaults , @_ , }; bless $obj , $class ; # オブジェクト データの変更を防止lock_hash %$obj ; } 1 ;  
       
       
     
             
       
          
    
       
        
        
    
      
    
     

または、手動で記述したアクセサーの場合:

パッケージImmutable ; strictを使用する; warningsを使用する; Hash::Util 'lock_hash'を使用する; 
 
 
  

sub new { my $class = shift ; return $class if ref ( $class ); die "new への引数は、キー => 値のペアである必要があります\n" unless ( @_ % 2 == 0 ); my %defaults = ( value => 'data' , ); my $obj = { %defaults , @_ , }; bless $obj , $class ; # オブジェクト データの変更を防止lock_hash %$obj ; }  
       
       
     
             
       
          
    
       
        
        
    
      
    
     


# 読み取り専用アクセサ
sub value { my $self = shift ; if ( my $new_value = shift ) { # 新しい値を設定しようとしていますdie "このオブジェクトは変更できません\n" ; } else { return $self -> { value } } } 1 ;  
       
         
        
         
      
         
    

Pythonでは、一部の組み込み型 (数値、ブール値、文字列、タプル、frozenset) は不変ですが、カスタム クラスは一般的に可変です。クラス内の不変性をシミュレートするには、属性の設定と削除をオーバーライドして例外を発生させます。

class  ImmutablePoint : 
"""2 つの属性 'x' と 'y' を持つ不変クラス。"""    

    __スロット__  =  [ 'x' ,  'y' ]

    def  __setattr__ ( self ,  * args ): 
        TypeErrorが発生します ( "不変インスタンスを変更できません。" )

    __delattr__  =  __setattr__

    def  __init__ ( self ,  x ,  y ): 
        # インスタンス データを保存するために self.value = value は使用できなくなりました。 # そのため、スーパークラス
        super () . __setattr__ ( 'x' , x ) super () . __setattr__ ( 'y' , y )を明示的に呼び出す必要があります。
         
         

Python 3.6 以降で利用可能な標準ライブラリ ヘルパー collections.namedtuple と entering.NamedTuple は、単純な不変クラスを作成します。次の例は、上記の例とほぼ同等ですが、タプルのような機能もいくつか追加されています。

 入力からインポート NamedTupleインポートコレクション 
 

ポイント = コレクション. namedtuple ( 'Point' ,  [ 'x' ,  'y' ])

# 以下は上記と同様の namedtuple を作成します。
class  Point ( NamedTuple ): 
    x :  int 
    y :  int

Python 3.7 で導入されたデータクラスにより、開発者は凍結されたインスタンスで不変性をエミュレートできます。凍結されたデータクラスが構築されると、呼び出されるとオーバーライドdataclassesされ__setattr__()、例外が発生します。 __delattr__()FrozenInstanceError

 データクラス からデータクラスをインポート 

@dataclass ( frozen = True )
クラス Point : 
    x :  int 
    y :  int

Racket は、コアのペア型 (「コンス セル」) を不変にすることで、他のSchememcons実装とは大きく異なります。代わりに、、などを介してmcar、並列の可変ペア型を提供しますset-mcar!。さらに、不変文字列やベクトルなど、多くの不変型がサポートされており、これらは広く使用されています。新しい構造体は、フィールドが明示的に可変と宣言されていない限り、または構造体全体が不変でない限り、デフォルトで不変です。

( struct foo1 ( x y )) ; すべてのフィールドは不変( struct foo2 ( x [ y #:mutable ])) ; 1 つの変更可能なフィールド( struct foo3 ( x y ) #:mutable ) ; すべてのフィールドは変更可能                
     
       

この言語は、関数的に実装された不変ハッシュ テーブルと不変辞書もサポートします。

Rust の所有権システムにより、開発者は不変の変数を宣言し、不変の参照を渡すことができます。デフォルトでは、すべての変数と参照は不変です。可変の変数と参照は、mutキーワードを使用して明示的に作成されます。

Rust の定数項目は常に不変です。

// 定数項目は常に不変です
const ALWAYS_IMMUTABLE : bool = true ;   

構造 体オブジェクト{ x : usize , y : usize , } 
    
    


fn  main () { // 可変変数を明示的に宣言するlet mut mutable_obj = Object { x : 1 , y : 2 }; mutable_obj . x = 3 ; // OK 
    
            
       

    let mutable_ref = & mut mutable_obj ; mutable_ref.x = 1 ; // OK​    
       

    let immutable_ref = & mutable_obj ; immutable_ref . x = 3 ; // エラー E0594   
       

    // デフォルトでは、変数は不変です。let 
immutable_obj = Object { x : 4 , y : 5 } ; immutable_obj . x = 6 ; // エラー E0596           
       

    let mutable_ref2 = & mut immutable_obj ; // エラー E0596   
          

    let immutable_ref2 = & immutable_obj ; immutable_ref2 . x = 6 ; // エラー E0594 }   
       
    

Scalaでは、任意のエンティティ (狭義にはバインディング) を可変または不変として定義できます。宣言では、val不変エンティティには (値) を使用し、var可変エンティティには (変数) を使用できます。不変バインディングは再割り当てできませんが、可変オブジェクトを参照する場合があり、そのオブジェクトに対して変更メソッドを呼び出すことは可能です。バインディングは不変ですが、基礎となるオブジェクトは可変である可能性があります。

たとえば、次のコード スニペット:

val maxValue = 100 var currentValue = 1   
   

不変エンティティmaxValue(整数型はコンパイル時に推論されます) と という名前の可変エンティティを定義しますcurrentValue。

Listデフォルトでは、やなどのコレクションクラスはMap不変であるため、更新メソッドは既存のインスタンスを変更するのではなく、新しいインスタンスを返します。これは非効率的に思えるかもしれませんが、これらのクラスの実装と不変性の保証は、新しいインスタンスが既存のノードを再利用できることを意味し、特にコピーを作成する場合には非常に効率的です。^{[15] [より良いソースが必要]}

• クロージュア
• アーラン
• ファ#
• ハスケル
• ミューテーターメソッド
• プロローグ
• スカラ
• Tcl

この記事にはPerlデザインパターンブックからの一部資料が含まれています。

無料辞書『ウィクショナリー』で「mutable」を調べてください。

• 3 つの簡単な手順で C# の不変オブジェクトを作成します。
• 記事 Java の理論と実践: 変異させるべきか、変異させざるべきか? Brian Goetz 著、IBM DeveloperWorks より – Internet Archive に保存されたコピー Brian Goetz 著、IBM DeveloperWorks より – Internet Archive に保存されたコピー
• JavaPractices.com の不変オブジェクト
• ポートランドパターンリポジトリからの不変オブジェクト
• Facebook による Immutable.js
• C# の不変構造は、2017 年 12 月 21 日にWayback Machineの Codeplex のオープンソース プロジェクトにアーカイブされました。
• Microsoft による .NET 公式ライブラリの不変コレクション
• Tutlane.com による C# の不変オブジェクト