テンプレートテスト

結論から先に書くと、両方を指定することはできません。  恐らくですが、`base` と `this` を両方指定したいと思うということは、コンストラクタ内で行う処理を全て共通化したいということなのだと思います。   私の場合はそうでした。  そして、私の場合はデフォルト引数を使うことで解決しました。  また、`base` や `this` を指定した場合（または指定しなかった場合）に、どのようにコンストラクタが呼ばれるかをきちんと把握すれば、もしかしたらどちらかを指定するだけで事足りるかもしれません。  というわけでいろいろ試してみました。  ## 環境  - Visual Studio 2019 - .NET Core 3.1  ## サンプル１  基底クラス `SampleBase` と、派生クラス `Sample` に、それぞれ引数なしと引数ありのコンストラクタを作成しています。  ### パターン１  `base` も `this` も指定しない場合です。  ```cs public static void Main() {     new Sample();     Console.WriteLine("----------");     new Sample("foo"); }  /// <summary>/// 基底クラス /// </summary>abstract class SampleBase {     public SampleBase()     {         Console.WriteLine("SampleBase コンストラクタ引数なし");     }      public SampleBase(string foo)     {         Console.WriteLine($"SampleBase コンストラクタ引数あり:{foo}");     } }  /// <summary>/// 派生クラス /// </summary>class Sample : SampleBase {     public Sample()     {         Console.WriteLine("Sample コンストラクタ引数なし");     }      public Sample(string foo)     {         Console.WriteLine($"Sample コンストラクタ引数あり:{foo}");     } } ```  **出力結果**  ```sh SampleBase コンストラクタ引数なし Sample コンストラクタ引数なし ---------- SampleBase コンストラクタ引数なし Sample コンストラクタ引数あり:foo ```  派生クラス `Sample` は引数の有無によって呼ばれるコンストラクタが違いますが、基底クラス `SampleBase` はいずれの場合も引数なしのコンストラクタが呼ばれています。  ### パターン２  パターン１をベースに、基底クラスの引数ありコンストラクタを使うために、派生クラス `Sample` で `base` を指定しています。  ```cs public static void Main() {     new Sample();     Console.WriteLine("----------");     new Sample("foo"); }  /// <summary>/// 基底クラス /// </summary>abstract class SampleBase {     public SampleBase()     {         Console.WriteLine("SampleBase コンストラクタ引数なし");     }      public SampleBase(string foo)     {         Console.WriteLine($"SampleBase コンストラクタ引数あり:{foo}");     } }  /// <summary>/// 派生クラス /// </summary>class Sample : SampleBase {     public Sample()     {         Console.WriteLine("Sample コンストラクタ引数なし");     }      public Sample(string foo) : base(foo)     {         Console.WriteLine($"Sample コンストラクタ引数あり:{foo}");     } } ```  **出力結果**  ```sh SampleBase コンストラクタ引数なし Sample コンストラクタ引数なし ---------- SampleBase コンストラクタ引数あり:foo Sample コンストラクタ引数あり:foo ```  引数を指定しなかった場合は、`Sample` `SampleBase` ともに引数なしのコンストラクタがコールされます。 引数を指定した場合は、`Sample` `SampleBase` ともに引数ありのコンストラクタがコールされます。  まぁここらへんまでは当たり前ですね。   ### パターン３  パターン２をベースに、基底クラス `SampleBase` の引数ありコンストラクタで `this` を指定しています。  ```cs public static void Main() {     new Sample();     Console.WriteLine("----------");     new Sample("foo"); }  /// <summary>/// 基底クラス /// </summary>abstract class SampleBase {     public SampleBase()     {         Console.WriteLine("SampleBase コンストラクタ引数なし");     }      public SampleBase(string foo) : this()     {         Console.WriteLine($"SampleBase コンストラクタ引数あり:{foo}");     } }  /// <summary>/// 派生クラス /// </summary>class Sample : SampleBase {     public Sample()     {         Console.WriteLine("Sample コンストラクタ引数なし");     }      public Sample(string foo) : base(foo)     {         Console.WriteLine($"Sample コンストラクタ引数あり:{foo}");     } } ```  **出力結果**  ```sh SampleBase コンストラクタ引数なし Sample コンストラクタ引数なし ---------- SampleBase コンストラクタ引数なし SampleBase コンストラクタ引数あり:foo Sample コンストラクタ引数あり:foo ```  引数を指定した場合、基底クラスのコンストラクタは両方呼ばれます。    ### パターン４  パターン３をベースに、派生クラス `Sample` の引数なしコンストラクタで基底クラス `SampleBase` の引数ありコンストラクタを呼んでいます。  ```cs public static void Main() {     new Sample();     Console.WriteLine("----------");     new Sample("foo"); }  /// <summary>/// 基底クラス /// </summary>abstract class SampleBase {     public SampleBase()     {         Console.WriteLine("SampleBase コンストラクタ引数なし");     }      public SampleBase(string foo) : this()     {         Console.WriteLine($"SampleBase コンストラクタ引数あり:{foo}");     } }  /// <summary>/// 派生クラス /// </summary>class Sample : SampleBase {     public Sample() : base(null)     {         Console.WriteLine("Sample コンストラクタ引数なし");     }      public Sample(string foo) : this()     {         Console.WriteLine($"Sample コンストラクタ引数あり:{foo}");     } } ```  **出力結果**  ```sh SampleBase コンストラクタ引数なし SampleBase コンストラクタ引数あり: Sample コンストラクタ引数なし ---------- SampleBase コンストラクタ引数なし SampleBase コンストラクタ引数あり: Sample コンストラクタ引数なし Sample コンストラクタ引数あり:foo ```  引数を指定した場合は全てのコンストラクタが呼ばれています。  多分これが一番問題のパターン。  派生クラス `Sample` の引数の値を基底クラス `SampleBase` に渡しつつ、コンストラクタ内の処理は各クラスの引数なしコンストラクタに集約したい。  しかし、派生クラス `Sample` の引数ありコンストラクタで `base` と `this` の両方を指定することはできません。    かと言って、このパターンのようにやると `this` を指定したときに引数の情報が失われてしまいます（当たり前ですが）。  というわけで、代替案が次のサンプルです。  ## サンプル２（代替案）  派生クラス `Sample` のコンストラクタを引数ありの１つのみにし、デフォルト引数を定義する方法です。  ```cs public static void Main() {     new Sample();     Console.WriteLine("----------");     new Sample("foo"); }  /// <summary>/// 基底クラス /// </summary>abstract class SampleBase {     public SampleBase()     {         Console.WriteLine("SampleBase コンストラクタ引数なし");     }      public SampleBase(string foo) : this()     {         Console.WriteLine($"SampleBase コンストラクタ引数あり:{foo}");     } }  /// <summary>/// 派生クラス /// </summary>class Sample : SampleBase {     public Sample(string foo = null) : base(foo)     {         Console.WriteLine($"Sample コンストラクタ引数あり:{foo}");     } } ```  **出力結果**  ```sh SampleBase コンストラクタ引数なし SampleBase コンストラクタ引数あり: Sample コンストラクタ引数あり: ---------- SampleBase コンストラクタ引数なし SampleBase コンストラクタ引数あり:foo Sample コンストラクタ引数あり:foo ```  私の場合はこれで解決しました。

2020/07/02

NO IMAGE

[C#] xUnit で MemberData を使ったテストがテストエクスプローラーで1つのテストとして表示される

C# xUnit

これだとデバッグが非常にやりにくいので、`InlineData` と同じように複数のテストケースとして表示する方法がないか調べてみると、以下の記事が見つかりました。  - https://stackoverflow.com/questions/30574322/memberdata-tests-show-up-as-one-test-instead-of-many  Visual Studio のテストエクスプローラーで各テストケースを別々の項目として表示するためには、テストケースの型に `IXunitSerializable` を実装する必要があるみたいです。  ## 環境  - Visual Studio 2017 - .NET Core 2.2 - xUnit 2.4.1  ## サンプル  ### 変更前  例えば、`MemberData` を使ったテストコードは以下のような感じになっていると思います。  ```cs [Theory,     MemberData(nameof(TestData))] public void TestMethod(int param1, string param2) {     // Do something test }  public static IEnumerable<object[]> TestData() {     yield return new object[] { 0, "hoge" };     yield return new object[] { 1, "fuga" }; } ```  ### 変更後  `IXunitSerializable` を実装するためにテストデータクラス `TestCaseData` を作成します。  ```cs [Theory,     MemberData(nameof(TestData))] public void TestMethod(TestCaseData testCaseData) {     var param1 = testCaseData.Param1;     var param2 = testCaseData.Param2;          // Do something test }  public class TestCaseData : IXunitSerializable {     public int Param1 { get; set; }     public string Param2 { get; set; }          public void Serialize(IXunitSerializationInfo info)     {         info.AddValue(nameof(Param1), Param1.ToString());         info.AddValue(nameof(Param2), Param2.ToString());     }      public void Deserialize(IXunitSerializationInfo info) { } }  public static IEnumerable<object[]> TestData() {     yield return new object[] {         new TestCaseData{             Param1 = 0,             Param2 = "hoge"         }     };     yield return new object[] {         new TestCaseData{             Param1 = 1,             Param2 = "fuga"         }     }; } ```  結構面倒です。  ## もう少し汎用的になるように改良してみる  上記のままだと、テストケースの度に `IXunitSerializable` を実装する必要があり面倒なので、何とかして共通化できないかと思い、とりあえず以下の２案が思い浮かびました。  ### ジェネリックを使って汎用的に実装する  `IXunitSerializable` を実装した `ValidateTestCase` を作成し、ジェネリックでテストケースクラスの型を指定してやります。  ```cs [Theory,     MemberData(nameof(TestData))] public void TestMethod(ValidateTestCase<TestCaseData> testCaseData) {     var param1 = testCaseData.Param.Param1;     var param2 = testCaseData.Param.Param2;          // Do something test }  public class ValidateTestCase<T> : IXunitSerializable {     public T Param { get; set; }      public void Serialize(IXunitSerializationInfo info)     {         // JSON を使う場合         info.AddValue(nameof(Param), JsonConvert.SerializeObject(Param));          // ハッシュ値を使う場合         // info.AddValue(nameof(Param), GetHashCode());          // GUID を使う場合         // info.AddValue(nameof(Param), Guid.NewGuid().ToString());     }      public void Deserialize(IXunitSerializationInfo info) { } }  public class TestCaseData {     public int Param1 { get; set; }     public string Param2 { get; set; } }  public static IEnumerable<object[]> TestData() {     yield return new object[] {         new ValidateTestCase<TestCaseData>{             Param = new TestCaseData(){                 Param1 = 0,                 Param2 = "hoge"             }         }     };     yield return new object[] {         new ValidateTestCase<TestCaseData>{             Param = new TestCaseData(){                 Param1 = 1,                 Param2 = "fuga"             }         }     }; } ```  `Serialize` メソッドで登録する文字列を `ToString()` から JSON でのシリアライズに変更しているのがポイントです。  クラスに対して `ToString()` するとクラス名が出力されるので、全てのテストで同じ文字列になってしまい、テストエクスプローラーでは単一のテストとして表示されてしまいました。   この文字列は一連のテストケースにおいてユニークでないとダメなようです。   なので、テストパラメーターには重複はないという前提で、JSON でシリアライズしてみました。  ただし、テストケースクラス `TestCaseData` にデリゲートを含んでいる場合は上手くいかなかったので、そういう場合はハッシュ値や GUID などを使ったほうが良いと思います。   （ハッシュ値は被ることもあるかもしれないので、GUID のほうが確実か？）  ### 抽象クラスを作成して汎用的に実装する  上記だと毎回 `ValidateTestCase` と `T` の２つのクラスをインスタンス化しないといけなくてちょっと面倒なので、同じような感じで抽象クラスで実装してみました。  自クラス `this` に対してシリアライズを行っています。  ```cs [Theory,     MemberData(nameof(TestData))] public void TestMethod(TestCaseData testCaseData) {     var param1 = testCaseData.Param1;     var param2 = testCaseData.Param2;          // Do something test }  public abstract class XunitSerializableBase : IXunitSerializable {     public void Serialize(IXunitSerializationInfo info)     {         // JSON を使う場合         info.AddValue(nameof(XunitSerializableBase), JsonConvert.SerializeObject(Param));          // ハッシュ値を使う場合         // info.AddValue(nameof(XunitSerializableBase), GetHashCode());          // GUID を使う場合         // info.AddValue(nameof(XunitSerializableBase), Guid.NewGuid().ToString());     }      public void Deserialize(IXunitSerializationInfo info) { } }  public class TestCaseData : XunitSerializableBase {     public int Param1 { get; set; }     public string Param2 { get; set; } }   public static IEnumerable<object[]> TestData() {     yield return new object[] {         new TestCaseData{             Param1 = 0,             Param2 = "hoge"         }     };     yield return new object[] {         new TestCaseData{             Param1 = 1,             Param2 = "fuga"         }     }; } ```  ちょっとだけ記述量が減りました。  ## 他の案は？  上記のリンク先にある `DjvuTheory` が便利そうだったので試しましたが、.NET Core 2.2 だと動きませんでした。   自分で修正しようともしてみましたが、何故かうまくいかず断念。   これが使えたら `Theory` を`DjvuTheory` に置換するだけでいけそうだったのに残念です。

2020/06/26

NO IMAGE

[C#] ClassData でテストデータを作成する際に、テストクラス内のリソースにアクセスしたい

C# xUnit

ここでいうリソースとは、例えばテスト用のデータベースだとか、外部ファイルなどです。    あくまで私が思いついた一例ですが、概要としては、以下です。  - テストメソッドの引数にデリゲートを用意し、テストメソッド内からリソースを渡す - テストデータ作成用のクラスで、リソースに対する処理を記述  ## 環境  - Visual Studio 2017 - .NET Core 2.2  ## サンプルコード  `resource` がデータベースなどの外部のリソースを想定しています。  ### テスト対象のクラス  以下のようなクラスをテストしたいとします。  ```cs // テストしたいクラス public class Target {     // テストしたいメソッド     public int Add(IList<int> resource)     {         // 例えば、データベースなどから値を読み込んで、何か処理をした値を返すなど         // ここでは全レコードを読み込んで総和を返すようなことを想定         return resource.Sum();     } } ```  ### テストコード  以下がテストコードです。   解説はコメントに書いてある通りです。  ```cs using System; using System.Collections; using System.Collections.Generic; using System.Linq; using Xunit; using Xunit.Abstractions;  namespace TestProject {     // テストを行うクラス     public class TestClass     {         ITestOutputHelper output;         Target target;         readonly IList<int> resource;// 例えば、データベースやファイルなどの外部リソース          public TestClass(ITestOutputHelper output)         {             // デバッグ用にテストエクスプローラーに出力できるようにしておく             this.output = output;              // リソースの初期化（実際には IClassFixture を使うなどする）             resource = new List<int> { 1, 2 };              // テストクラスのインスタンスを作成             target = new Target();         }          [Theory,             ClassData(typeof(TestData))]         public void TestMethod(             // テスト前にリソースに対して行う処理（戻り値が必要なら Func にする）             Action<IList<int>> action,             // テスト実行後の期待値             int expected             )         {             // テストに必要な前処理を行う             action(resource);              // デバッグ用にテスト前のリソースの状態を出力             output.WriteLine($"resource: {string.Join(", ", resource)}");              // テストの実行             var result = target.Add(resource);              // デバッグ用に結果を出力             output.WriteLine($"result: {result.ToString()}");              // 結果の確認             Assert.Equal(expected, result);          }     }      // テストデータを作成するクラス     class TestData : IEnumerable<object[]>    {         List<object[]> _testData = new List<object[]>();          public TestData()         {             // いくつかのパターンでテストデータを作成してみる              // テストケース１（リソースの中身を書き換え）             Action<IList<int>> action = resource =>            {                 resource[0] = 1;                 resource[1] = 2;             };             _testData.Add(new object[] {                 action,                 3             });              // テストケース２（リソースに要素を追加）             _testData.Add(new object[] {                 new Action<IList<int>>(resource => resource.Add(3)),                 6             });              // テストケース３（リソースをクリア）             action = resource => resource.Clear();             _testData.Add(new object[] {                 action,                 0             });         }          public IEnumerator<object[]> GetEnumerator() => _testData.GetEnumerator();          IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();     } } ```  ### 実行結果  **テストケース1**  ```sh resource: 1, 2 result: 3 ```  **テストケース2**  ```sh resource: 1, 2, 3 result: 6 ```  **テストケース3**  ```sh resource:  result: 0 ```

2020/06/25

NO IMAGE

[C#] nameof 演算子の代わりにフルネームを返すメソッドを作る

- https://stackoverflow.com/questions/27898178/why-does-nameof-return-only-last-name  例えば、以下のようなクラスがあったとして、  ```cs class SpeciesFamily {     public string Name { get; set; } }  class Species {     public SpeciesFamily Family { get; set; }     public string Name { get; set; } }  class Cat {     public Species Species { get; set; } } ```  `Species.Family.Name` という文字列を `nameof` 演算子を使って取得しようとすると、以下のようなコードになってしまいます。  ```cs var fullName = $"{nameof(Species)}.{nameof(Species.Family)}.{nameof(SpeciesFamily.Name)}" ```  同じクラス名やプロパティ名を何度も書くことになるので、階層が深くなればなるほど面倒です。  これに対して、フルネームを簡単に取得できるようにしたメソッドのサンプルが以下の２つです。   （階層が浅いと記述量はあまり変わりませんが・・・）  ## サンプルコード1  ```cs public static string GetMemberString<T>(System.Linq.Expressions.Expression<Func<T, object>> member) {     if (member == null)     {         throw new ArgumentNullException("member");     }      var propertyRefExpr = member.Body;     var memberExpr = propertyRefExpr as System.Linq.Expressions.MemberExpression;      if (memberExpr == null)     {         var unaryExpr = propertyRefExpr as System.Linq.Expressions.UnaryExpression;          if (unaryExpr != null && unaryExpr.NodeType == System.Linq.Expressions.ExpressionType.Convert)         {             memberExpr = unaryExpr.Operand as System.Linq.Expressions.MemberExpression;              if (memberExpr != null)             {                 return memberExpr.Member.Name;             }         }     }     else     {         //gets something line "m.Field1.Field2.Field3", from here we just remove the prefix "m."         string body = member.Body.ToString();         return body.Substring(body.IndexOf('.') + 1);     }      throw new ArgumentException("No property reference expression was found.", "member"); } ```  **使い方**  ```cs // Will return a string containing "Species.Family.Name". var fullName = GetMemberString<Cat>(x => x.Species.Family.Name) ```  ## サンプルコード2  ```cs public static class NameOf<TSource>{     #region Public Methods      public static string Full(Expression<Func<TSource, object>> expression)     {         var memberExpression = expression.Body as MemberExpression;         if (memberExpression == null)         {             if (expression.Body is UnaryExpression unaryExpression && unaryExpression.NodeType == ExpressionType.Convert)                 memberExpression = unaryExpression.Operand as MemberExpression;         }          var result = memberExpression.ToString();         result = result.Substring(result.IndexOf('.') + 1);          return result;     }      public static string Full(string sourceFieldName, Expression<Func<TSource, object>> expression)     {         var result = Full(expression);         result = string.IsNullOrEmpty(sourceFieldName) ? result : sourceFieldName + "." + result;         return result;     }      #endregion } ```  **使い方**  ```cs // Will return a string containing "Species.Family.Name". var fullName = NameOf<Cat>.Full(c => c.Species.Family.Name);  // Will return a string containing "cat.Species.Name". var fullNameWithPrefix = NameOf<Cat>.Full("cat", c => c.Species.Name); ```  `"cat"` のようにプレフィックスが指定できるので、こちらのほうがより汎用的かと思います。  また、`"cat"` の部分も `nameof` 演算子を使えば、文字列の記述を完全に無くすことができます。

2020/06/24

NO IMAGE

[ASP.NET Core] ModelState のチェックを無効化

ASP.NET Core C#

2020/06/23

NO IMAGE

[C#] Null 許容型かどうかを判別する

## 環境  - Visual Studio 2017 - .NET Core 2.2  ## サンプルコード  ```cs public static void Main() {     var personClass = new PersonClass();     var personStruct = new PersonStruct();     var persons = new List<PersonClass>();      IsNullable(typeof(int));// False     IsNullable(typeof(int?));// True     IsNullable(typeof(PersonClass));// True     IsNullable(typeof(PersonStruct));// False     IsNullable(personClass.GetType());// True     IsNullable(personClass.Age.GetType());// False     IsNullable(personClass.Name?.GetType());// True     IsNullable(personStruct.GetType());// False     IsNullable(personStruct.Age.GetType());// False     IsNullable(personStruct.Name?.GetType());// True     IsNullable(typeof(List<>));// True     IsNullable(persons.GetType());// True }  static bool IsNullable(Type type) {     var ret =          type == null || // Null条件演算子用にこの条件を入れているだけなので、場合によっては不要         !type.IsValueType || // 値型でない -> Nullable         Nullable.GetUnderlyingType(type) != null;// 非Null許容型が取得できる -> Null許容演算子が指定されている -> Nullable      Console.WriteLine(ret);// デバッグ用に表示     return ret; }  public class PersonClass {     public int Age { get; set; }     public string Name { get; set; } }  public struct PersonStruct {     public int Age { get; set; }     public string Name { get; set; } } ```  間違いや他に良い方法があれば教えてください。

2020/06/19

NO IMAGE

[C#] 非同期メソッドのモック

2020/06/18

NO IMAGE

[C#] リストをデシリアライズしたときに項目が追加登録されてしまう

## 環境  - Visual Studio 2017 - .NET Core 2.2  ## サンプルコード  以下のようなクラスをシリアライズ、デシリアライズするとします。  ```cs public class SampleData {     public IList<int> Hoge { get; set; } = new List<int> { 1 }; } ```  ```cs var data = new SampleData();  // シリアライズ var serialized = JsonConvert.SerializeObject(data); Console.WriteLine(serialized);  // デシリアライズ（このタイミングでリストの項目が２つになっている！） var deserialized = JsonConvert.DeserializeObject<SampleData>(serialized); Console.WriteLine($"Hoge Count: {deserialized.Hoge.Count()}");  // もう一度シリアライズして確認 var serialized2 = JsonConvert.SerializeObject(deserialized); Console.WriteLine(serialized2); ```  **出力結果**  ```bat {"Hoge":[1]} Hoge Count: 2 {"Hoge":[1,1]} ```  デシリアライズ時に項目が１つ増えています。   シリアライズした内容はリストを置換するではなく、リストに追加登録されるからです。   いや、これほんとにはまった。  ## ObjectCreationHandling.Replace を指定する  初期値を含めないようにするにはデシリアライズ時のオプションで `ObjectCreationHandling.Replace` を指定する必要があります。  ```cs var deserialized = JsonConvert.DeserializeObject<SampleData>(serialized, new JsonSerializerSettings {        ObjectCreationHandling = ObjectCreationHandling.Replace, });  ```  こちらの動作のほうが直観的だと思うので、こちらが既定値のほうが良いと思うのですが、私だけでしょうか？   ちなみに `DataContractJsonSerializer` を使った場合は既定で置換してくれました。

2020/06/17

NO IMAGE

[C#] DateTime 型を含むデータのシリアライズ

## 環境  - Visual Studio 2017 - .NET Core 2.2  ## サンプルコード  以下のようなクラスをシリアライズしたいとします。  ```cs public class Person {     public DateTime Birth { get; set; } = DateTime.Today;     public string Name { get; set; } = "Name";     public int Age { get; set; } = 20; } ```  `DataContractJsonSerializer` を使ってシリアライズしてみます。  ```cs static public string Serialize<T>(T value) {     var serializer = new DataContractJsonSerializer(typeof(T));     var serializedData = string.Empty;     using (var memoryStream = new MemoryStream())     {         serializer.WriteObject(memoryStream, value);         serializedData = Encoding.UTF8.GetString(memoryStream.ToArray());     }     return serializedData; } ```  ```cs var data = new Person(); var serialized = Serialize(data); Console.WriteLine(serialized); ```  **出力結果**  ```bat {"Age":20,"Birth":"\/Date(1592319600000+0900)\/","Name":"Name"} ```  ### 例外が発生するパターン  ここで、上記の `DateTime` 型である `Birth` の初期値を未設定にすると、`DateTime.MinValue` が初期値になりますが、この場合に以下の例外が発生します。  ```bat System.Runtime.Serialization.SerializationException : DateTime values that are greater than DateTime.MaxValue or smaller than DateTime.MinValue when converted to UTC cannot be serialized to JSON. ---- System.ArgumentOutOfRangeException : Specified argument was out of the range of valid values. ```  `DataContractJsonSerializer` は `DateTime` を UTC に変換してシリアライズしようとしますが、MinValueだった場合、JST だと -9 時間することになるので、アンダーフローを起こすのが原因らしいです。  ## 対処方法  とりあえず思いついたのは以下です。  ### その１　DateTimeOffset を使う  型を変更できるなら `DateTimeOffset` に変更すればシリアライズ可能になります。  ### その２　他のパーサーを使う  例えば、Newtonsoft.Json を使うと `DateTime` が `MinValue` であっても以下のように ISO 形式で文字列に変換されるため、シリアライズ可能です。  ```cs var data = new Person(); var serialized = JsonConvert.SerializeObject(data); Console.WriteLine(serialized); ```  **出力結果**  ```bat {"Birth":"0001-01-01T00:00:00","Name":"Name","Age":20} ```