チェンジセット 1793 (default)


以下の違いを無視:
日時:
2026/07/21 16:00:32 (2ヵ月前)
更新者:
hizuya@…
ログメッセージ:
  • Via.Convert 系で Nullable への変換に対応。
場所:
framework/trunk
ファイル:
3個の更新

凡例:

未変更
追加
削除

  • framework/trunk/TestLibrary/Sources/TypeConversionConstraint.cs

    r1792 r1793  
    3737    { 
    3838        /// <summary> 
     39        /// <see langword="null"/> 値を受け付けるかどうか。 
     40        /// </summary> 
     41        private static readonly bool CanAcceptNull = ((Func<bool>)delegate 
     42        { 
     43            Type outputType = typeof(TOutput); 
     44            return !outputType.IsValueType 
     45                || Nullable.GetUnderlyingType(outputType) != null; 
     46        })(); 
     47 
     48 
     49        /// <summary> 
    3950        /// 型変換を行うデリゲート。 
    4051        /// </summary> 
    … …  
    96107        public override ConstraintResult ApplyTo<TActual>(TActual actual) 
    97108        { 
    98             if (!(actual is TInput)) 
    99             { 
    100                 return new ConstraintResult( 
    101                     this, 
    102                     actual, 
    103                     ConstraintStatus.Failure); 
    104             } 
    105  
    106109            object convertedValue; 
    107110 
    108             // ReSharper disable once CatchAllClause 
    109             try 
    110             { 
    111                 convertedValue = converter((TInput)(object)actual); 
    112             } 
    113             catch (Exception exception) 
    114             { 
    115                 if (!IsConversionException(exception)) 
    116                 { 
    117                     // ReSharper disable once ExceptionNotDocumented 
    118                     throw; 
    119                 } 
    120  
    121                 return new TypeConversionConstraintResult( 
    122                     this, 
    123                     actual, 
    124                     null, 
    125                     exception, 
    126                     null, 
    127                     ConstraintStatus.Failure); 
    128             } 
    129  
     111            if (ReferenceEquals(actual, null)) 
     112            { 
     113                // 検証する値が null の場合 
     114 
     115                // 変換後の型が null 値を許容しない場合 
     116                if (!CanAcceptNull) 
     117                { 
     118                    return new ConstraintResult( 
     119                        this, 
     120                        null, 
     121                        ConstraintStatus.Failure); 
     122                } 
     123 
     124                // null 値に変換 (変換後の型が class か Nullable) 
     125                convertedValue = default(TOutput); 
     126            } 
     127            else 
     128            { 
     129                // 検証する値が null 以外の場合 
     130 
     131                // 検証する値が変換後の型に変換できない場合 
     132                if (!(actual is TInput)) 
     133                { 
     134                    return new ConstraintResult( 
     135                        this, 
     136                        actual, 
     137                        ConstraintStatus.Failure); 
     138                } 
     139 
     140                // ReSharper disable once CatchAllClause 
     141                try 
     142                { 
     143                    // 変換を試みる 
     144                    convertedValue = converter((TInput)(object)actual); 
     145                } 
     146                catch (Exception exception) 
     147                { 
     148                    // 変換系の例外以外の場合はそのまま例外を投げる 
     149                    if (!IsConversionException(exception)) 
     150                    { 
     151                        // ReSharper disable once ExceptionNotDocumented 
     152                        throw; 
     153                    } 
     154 
     155                    // 変換エラーを返す 
     156                    return new TypeConversionConstraintResult( 
     157                        this, 
     158                        actual, 
     159                        null, 
     160                        exception, 
     161                        null, 
     162                        ConstraintStatus.Failure); 
     163                } 
     164            } 
     165 
     166            // 右辺値が無い場合 
    130167            if (innerConstraint == null) 
    131168            { 
    … …  
    139176            } 
    140177 
     178            // 右辺を変換後の値で評価 
    141179            ConstraintResult innerResult = 
    142180                innerConstraint.ApplyTo(convertedValue); 
    143181 
     182            // 右辺の評価結果を返す 
    144183            return new TypeConversionConstraintResult( 
    145184                this, 

  • framework/trunk/TestLibrary/Sources/Via.cs

    r1792 r1793  
    151151        public static ConstraintExpression Boolean() 
    152152        { 
    153             return Convert<string, bool>(bool.Parse); 
     153            return Convert<bool?>(); 
    154154        } 
    155155 
    … …  
    157157        /// 検証する値の型を <see cref="byte"/> に変換し、変換した値で後続の検証を行います。 
    158158        /// </summary> 
     159        /// <returns> 
     160        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     161        /// </returns> 
     162        public static ConstraintExpression Byte() 
     163        { 
     164            return Convert<byte?>(); 
     165        } 
     166 
     167        /// <summary> 
     168        /// 検証する値の型を <see cref="byte"/> に変換し、変換した値で後続の検証を行います。 
     169        /// </summary> 
    159170        /// <param name="style">変換元の値のスタイル</param> 
    160171        /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
    … …  
    166177            IFormatProvider provider) 
    167178        { 
    168             return Convert<string, byte>( 
     179            return ConvertNullable<string, byte>( 
    169180                value => byte.Parse(value, style, provider)); 
     181        } 
     182 
     183        /// <summary> 
     184        /// 検証する値の型を <see cref="sbyte"/> に変換し、変換した値で後続の検証を行います。 
     185        /// </summary> 
     186        /// <returns> 
     187        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     188        /// </returns> 
     189        public static ConstraintExpression SByte() 
     190        { 
     191            return Convert<sbyte?>(); 
    170192        } 
    171193 
    … …  
    183205            IFormatProvider provider) 
    184206        { 
    185             return Convert<string, sbyte>( 
     207            return ConvertNullable<string, sbyte>( 
    186208                value => sbyte.Parse(value, style, provider)); 
    187209        } 
    … …  
    190212        /// 検証する値の型を <see cref="short"/> に変換し、変換した値で後続の検証を行います。 
    191213        /// </summary> 
     214        /// <returns> 
     215        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     216        /// </returns> 
     217        public static ConstraintExpression Int16() 
     218        { 
     219            return Convert<short?>(); 
     220        } 
     221 
     222        /// <summary> 
     223        /// 検証する値の型を <see cref="short"/> に変換し、変換した値で後続の検証を行います。 
     224        /// </summary> 
    192225        /// <param name="style">変換元の値のスタイル</param> 
    193226        /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
    … …  
    199232            IFormatProvider provider) 
    200233        { 
    201             return Convert<string, short>( 
     234            return ConvertNullable<string, short>( 
    202235                value => short.Parse(value, style, provider)); 
     236        } 
     237 
     238        /// <summary> 
     239        /// 検証する値の型を <see cref="ushort"/> に変換し、変換した値で後続の検証を行います。 
     240        /// </summary> 
     241        /// <returns> 
     242        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     243        /// </returns> 
     244        public static ConstraintExpression UInt16() 
     245        { 
     246            return Convert<ushort?>(); 
    203247        } 
    204248 
    … …  
    216260            IFormatProvider provider) 
    217261        { 
    218             return Convert<string, ushort>( 
     262            return ConvertNullable<string, ushort>( 
    219263                value => ushort.Parse(value, style, provider)); 
    220264        } 
    … …  
    223267        /// 検証する値の型を <see cref="int"/> に変換し、変換した値で後続の検証を行います。 
    224268        /// </summary> 
     269        /// <returns> 
     270        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     271        /// </returns> 
     272        public static ConstraintExpression Int32() 
     273        { 
     274            return Convert<int?>(); 
     275        } 
     276 
     277        /// <summary> 
     278        /// 検証する値の型を <see cref="int"/> に変換し、変換した値で後続の検証を行います。 
     279        /// </summary> 
    225280        /// <param name="style">変換元の値のスタイル</param> 
    226281        /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
    … …  
    232287            IFormatProvider provider) 
    233288        { 
    234             return Convert<string, int>( 
     289            return ConvertNullable<string, int>( 
    235290                value => int.Parse(value, style, provider)); 
     291        } 
     292 
     293        /// <summary> 
     294        /// 検証する値の型を <see cref="uint"/> に変換し、変換した値で後続の検証を行います。 
     295        /// </summary> 
     296        /// <returns> 
     297        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     298        /// </returns> 
     299        public static ConstraintExpression UInt32() 
     300        { 
     301            return Convert<uint?>(); 
    236302        } 
    237303 
    … …  
    249315            IFormatProvider provider) 
    250316        { 
    251             return Convert<string, uint>( 
     317            return ConvertNullable<string, uint>( 
    252318                value => uint.Parse(value, style, provider)); 
    253319        } 
    … …  
    256322        /// 検証する値の型を <see cref="long"/> に変換し、変換した値で後続の検証を行います。 
    257323        /// </summary> 
     324        /// <returns> 
     325        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     326        /// </returns> 
     327        public static ConstraintExpression Int64() 
     328        { 
     329            return Convert<long?>(); 
     330        } 
     331 
     332        /// <summary> 
     333        /// 検証する値の型を <see cref="long"/> に変換し、変換した値で後続の検証を行います。 
     334        /// </summary> 
    258335        /// <param name="style">変換元の値のスタイル</param> 
    259336        /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
    … …  
    265342            IFormatProvider provider) 
    266343        { 
    267             return Convert<string, long>( 
     344            return ConvertNullable<string, long>( 
    268345                value => long.Parse(value, style, provider)); 
     346        } 
     347 
     348        /// <summary> 
     349        /// 検証する値の型を <see cref="ulong"/> に変換し、変換した値で後続の検証を行います。 
     350        /// </summary> 
     351        /// <returns> 
     352        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     353        /// </returns> 
     354        public static ConstraintExpression UInt64() 
     355        { 
     356            return Convert<ulong?>(); 
    269357        } 
    270358 
    … …  
    282370            IFormatProvider provider) 
    283371        { 
    284             return Convert<string, ulong>( 
     372            return ConvertNullable<string, ulong>( 
    285373                value => ulong.Parse(value, style, provider)); 
    286374        } 
    … …  
    289377        /// 検証する値の型を <see cref="float"/> に変換し、変換した値で後続の検証を行います。 
    290378        /// </summary> 
     379        /// <returns> 
     380        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     381        /// </returns> 
     382        public static ConstraintExpression Single() 
     383        { 
     384            return Convert<float?>(); 
     385        } 
     386 
     387        /// <summary> 
     388        /// 検証する値の型を <see cref="float"/> に変換し、変換した値で後続の検証を行います。 
     389        /// </summary> 
    291390        /// <param name="style">変換元の値のスタイル</param> 
    292391        /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
    … …  
    298397            IFormatProvider provider) 
    299398        { 
    300             return Convert<string, float>( 
     399            return ConvertNullable<string, float>( 
    301400                value => float.Parse(value, style, provider)); 
    302401        } 
    … …  
    305404        /// 検証する値の型を <see cref="double"/> に変換し、変換した値で後続の検証を行います。 
    306405        /// </summary> 
     406        /// <returns> 
     407        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     408        /// </returns> 
     409        public static ConstraintExpression Double() 
     410        { 
     411            return Convert<double?>(); 
     412        } 
     413 
     414        /// <summary> 
     415        /// 検証する値の型を <see cref="double"/> に変換し、変換した値で後続の検証を行います。 
     416        /// </summary> 
    307417        /// <param name="style">変換元の値のスタイル</param> 
    308418        /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
    … …  
    314424            IFormatProvider provider) 
    315425        { 
    316             return Convert<string, double>( 
     426            return ConvertNullable<string, double>( 
    317427                value => double.Parse(value, style, provider)); 
    318428        } 
    319429 
    320430        /// <summary> 
    321         /// 検証する値の型を <see cref="Decimal"/> に変換し、変換した値で後続の検証を行います。 
     431        /// 検証する値の型を <see cref="decimal"/> に変換し、変換した値で後続の検証を行います。 
     432        /// </summary> 
     433        /// <returns> 
     434        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     435        /// </returns> 
     436        public static ConstraintExpression Decimal() 
     437        { 
     438            return Convert<decimal?>(); 
     439        } 
     440 
     441        /// <summary> 
     442        /// 検証する値の型を <see cref="decimal"/> に変換し、変換した値で後続の検証を行います。 
    322443        /// </summary> 
    323444        /// <param name="style">変換元の値のスタイル</param> 
    … …  
    330451            IFormatProvider provider) 
    331452        { 
    332             return Convert<string, decimal>( 
     453            return ConvertNullable<string, decimal>( 
    333454                value => decimal.Parse(value, style, provider)); 
     455        } 
     456 
     457        /// <summary> 
     458        /// 検証する値の型を <see cref="System.DateTime"/> に変換し、変換した値で後続の検証を行います。 
     459        /// </summary> 
     460        /// <returns> 
     461        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     462        /// </returns> 
     463        public static ConstraintExpression DateTime() 
     464        { 
     465            return Convert<DateTime?>(); 
    334466        } 
    335467 
    … …  
    357489            } 
    358490 
    359             return Convert<string, DateTime>( 
     491            return ConvertNullable<string, DateTime>( 
    360492                value => System.DateTime.ParseExact(value, format, provider, style)); 
    361493        } 
    … …  
    378510            DateTimeStyles style) 
    379511        { 
    380             return Convert<string, DateTime>( 
     512            return ConvertNullable<string, DateTime>( 
    381513                value => System.DateTime.ParseExact(value, formats, provider, style)); 
     514        } 
     515 
     516        /// <summary> 
     517        /// 検証する値の型を <see cref="System.DateTimeOffset"/> に変換し、変換した値で後続の検証を行います。 
     518        /// </summary> 
     519        /// <returns> 
     520        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     521        /// </returns> 
     522        public static ConstraintExpression DateTimeOffset() 
     523        { 
     524            return Convert<DateTimeOffset?>(); 
    382525        } 
    383526 
    … …  
    405548            } 
    406549 
    407             return Convert<string, DateTimeOffset>( 
     550            return ConvertNullable<string, DateTimeOffset>( 
    408551                value => System.DateTimeOffset.ParseExact(value, format, provider, style)); 
    409552        } 
    … …  
    426569            DateTimeStyles style) 
    427570        { 
    428             return Convert<string, DateTimeOffset>( 
     571            return ConvertNullable<string, DateTimeOffset>( 
    429572                value => System.DateTimeOffset.ParseExact(value, formats, provider, style)); 
    430573        } 
    … …  
    433576        /// 検証する値の型を <see cref="System.TimeSpan"/> に変換し、変換した値で後続の検証を行います。 
    434577        /// </summary> 
    435         /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
     578        /// <returns> 
     579        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     580        /// </returns> 
     581        public static ConstraintExpression TimeSpan() 
     582        { 
     583            return Convert<TimeSpan?>(); 
     584        } 
     585 
     586        /// <summary> 
     587        /// 検証する値の型を <see cref="System.TimeSpan"/> に変換し、変換した値で後続の検証を行います。 
     588        /// </summary> 
     589        /// <param name="format">変換に必要な形式を定義する形式指定子。</param> 
     590        /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
     591        /// <param name="style">変換元の値のスタイル</param> 
    436592        /// <returns> 
    437593        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
    438594        /// </returns> 
    439595        public static ConstraintExpression TimeSpan( 
    440             IFormatProvider provider) 
    441         { 
    442             return Convert<string, TimeSpan>( 
    443                 value => System.TimeSpan.Parse(value, provider)); 
     596            string format, 
     597            IFormatProvider provider, 
     598            TimeSpanStyles style) 
     599        { 
     600            return ConvertNullable<string, TimeSpan>( 
     601                value => System.TimeSpan.ParseExact(value, format, provider, style)); 
     602        } 
     603 
     604        /// <summary> 
     605        /// 検証する値の型を <see cref="System.TimeSpan"/> に変換し、変換した値で後続の検証を行います。 
     606        /// </summary> 
     607        /// <param name="formats">変換元の値に許可された形式を定義する形式指定子の配列。</param> 
     608        /// <param name="provider">変換に必要なカルチャ固有の書式情報を提供するオブジェクト。</param> 
     609        /// <param name="style">変換元の値のスタイル</param> 
     610        /// <returns> 
     611        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     612        /// </returns> 
     613        public static ConstraintExpression TimeSpan( 
     614            string[] formats, 
     615            IFormatProvider provider, 
     616            TimeSpanStyles style) 
     617        { 
     618            return ConvertNullable<string, TimeSpan>( 
     619                value => System.TimeSpan.ParseExact(value, formats, provider, style)); 
    444620        } 
    445621 
    … …  
    452628        public static ConstraintExpression Guid() 
    453629        { 
    454             return Convert<string, Guid>( 
    455                 System.Guid.Parse); 
     630            return Convert<Guid?>(); 
     631        } 
     632 
     633        /// <summary> 
     634        /// 検証する値の型を <see cref="System.Guid"/> に変換し、変換した値で後続の検証を行います。 
     635        /// </summary> 
     636        /// <param name="format">変換に必要な形式を定義する形式指定子。</param> 
     637        /// <returns> 
     638        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     639        /// </returns> 
     640        public static ConstraintExpression Guid( 
     641            string format) 
     642        { 
     643            return ConvertNullable<string, Guid>( 
     644                value => System.Guid.ParseExact(value, format)); 
     645        } 
     646 
     647 
     648        /// <summary> 
     649        /// 検証する値の型をデリゲートを使用して変換し、変換した値で後続の検証を行います。 
     650        /// </summary> 
     651        /// <typeparam name="TInput">変換元の型。</typeparam> 
     652        /// <typeparam name="TOutput">変換後の型。</typeparam> 
     653        /// <param name="converter">型変換を行うデリゲート。</param> 
     654        /// <returns> 
     655        /// 一連の検証を行う <see cref="ConstraintExpression"/>。 
     656        /// </returns> 
     657        /// <exception cref="ArgumentNullException"> 
     658        /// <paramref name="converter"/> は <see langword="null"/> です。 
     659        /// </exception> 
     660        private static ConstraintExpression ConvertNullable<TInput, TOutput>( 
     661            Converter<TInput, TOutput> converter) 
     662            where TOutput : struct 
     663        { 
     664            ConstraintExpression expression = new ConstraintExpression(); 
     665 
     666            return expression.Append( 
     667                new TypeConversionOperator<TInput, TOutput?>( 
     668                    value => ReferenceEquals(value, null) 
     669                        ? (TOutput?)null 
     670                        : converter(value))); 
    456671        } 
    457672    } 

  • framework/trunk/TestTest/Sources/ViaTest.cs

    r1792 r1793  
    209209 
    210210        /// <summary> 
     211        /// 内部的に <see cref="TypeConverter"/> を使用して 
    211212        /// <see cref="bool"/> に変換するテストです。 
    212213        /// </summary> 
    213214        [Test] 
    214         public void TestConvertBoolean() 
     215        public void TestConvertBooleanByTypeConverter() 
    215216        { 
    216217            Assert.That( 
    … …  
    220221 
    221222        /// <summary> 
     223        /// 内部的に <see cref="TypeConverter"/> を使用して 
    222224        /// <see cref="byte"/> に変換するテストです。 
    223225        /// </summary> 
    224226        [Test] 
    225         public void TestConvertByte() 
     227        public void TestConvertByteByTypeConverter() 
     228        { 
     229            Assert.That( 
     230                "123", 
     231                Via.Byte().TypeOf<byte>().And.EqualTo((byte)123)); 
     232        } 
     233 
     234        /// <summary> 
     235        /// 内部的に <see cref="byte.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     236        /// <see cref="byte"/> に変換するテストです。 
     237        /// </summary> 
     238        [Test] 
     239        public void TestConvertByteByParse() 
    226240        { 
    227241            Assert.That( 
    … …  
    231245 
    232246        /// <summary> 
     247        /// 内部的に <see cref="TypeConverter"/> を使用して 
    233248        /// <see cref="sbyte"/> に変換するテストです。 
    234249        /// </summary> 
    235250        [Test] 
    236         public void TestConvertSByte() 
     251        public void TestConvertSByteByTypeConverter() 
     252        { 
     253            Assert.That( 
     254                "123", 
     255                Via.SByte().TypeOf<sbyte>().And.EqualTo((sbyte)123)); 
     256        } 
     257 
     258        /// <summary> 
     259        /// 内部的に <see cref="sbyte.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     260        /// <see cref="sbyte"/> に変換するテストです。 
     261        /// </summary> 
     262        [Test] 
     263        public void TestConvertSByteByParse() 
    237264        { 
    238265            Assert.That( 
    … …  
    242269 
    243270        /// <summary> 
     271        /// 内部的に <see cref="TypeConverter"/> を使用して 
    244272        /// <see cref="short"/> に変換するテストです。 
    245273        /// </summary> 
    246274        [Test] 
    247         public void TestConvertInt16() 
     275        public void TestConvertInt16ByTypeConverter() 
     276        { 
     277            Assert.That( 
     278                "123", 
     279                Via.Int16().TypeOf<short>().And.EqualTo((short)123)); 
     280        } 
     281 
     282        /// <summary> 
     283        /// 内部的に <see cref="short.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     284        /// <see cref="short"/> に変換するテストです。 
     285        /// </summary> 
     286        [Test] 
     287        public void TestConvertInt16ByParse() 
    248288        { 
    249289            Assert.That( 
    … …  
    253293 
    254294        /// <summary> 
     295        /// 内部的に <see cref="TypeConverter"/> を使用して 
    255296        /// <see cref="ushort"/> に変換するテストです。 
    256297        /// </summary> 
    257298        [Test] 
    258         public void TestConvertUInt16() 
     299        public void TestConvertUInt16ByTypeConverter() 
     300        { 
     301            Assert.That( 
     302                "123", 
     303                Via.UInt16().TypeOf<ushort>().And.EqualTo((ushort)123)); 
     304        } 
     305 
     306        /// <summary> 
     307        /// 内部的に <see cref="ushort.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     308        /// <see cref="ushort"/> に変換するテストです。 
     309        /// </summary> 
     310        [Test] 
     311        public void TestConvertUInt16ByParse() 
    259312        { 
    260313            Assert.That( 
    … …  
    264317 
    265318        /// <summary> 
     319        /// 内部的に <see cref="TypeConverter"/> を使用して 
    266320        /// <see cref="int"/> に変換するテストです。 
    267321        /// </summary> 
    268322        [Test] 
    269         public void TestConvertInt32() 
     323        public void TestConvertInt32ByTypeConverter() 
     324        { 
     325            Assert.That( 
     326                "123", 
     327                Via.Int32().TypeOf<int>().And.EqualTo(123)); 
     328        } 
     329 
     330        /// <summary> 
     331        /// 内部的に <see cref="int.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     332        /// <see cref="int"/> に変換するテストです。 
     333        /// </summary> 
     334        [Test] 
     335        public void TestConvertInt32ByParse() 
    270336        { 
    271337            Assert.That( 
    … …  
    275341 
    276342        /// <summary> 
     343        /// 内部的に <see cref="TypeConverter"/> を使用して 
    277344        /// <see cref="uint"/> に変換するテストです。 
    278345        /// </summary> 
    279346        [Test] 
    280         public void TestConvertUInt32() 
     347        public void TestConvertUInt32ByTypeConverter() 
     348        { 
     349            Assert.That( 
     350                "123", 
     351                Via.UInt32().TypeOf<uint>().And.EqualTo(123U)); 
     352        } 
     353 
     354        /// <summary> 
     355        /// 内部的に <see cref="uint.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     356        /// <see cref="uint"/> に変換するテストです。 
     357        /// </summary> 
     358        [Test] 
     359        public void TestConvertUInt32ByParse() 
    281360        { 
    282361            Assert.That( 
    … …  
    286365 
    287366        /// <summary> 
     367        /// 内部的に <see cref="TypeConverter"/> を使用して 
    288368        /// <see cref="long"/> に変換するテストです。 
    289369        /// </summary> 
    290370        [Test] 
    291         public void TestConvertInt64() 
     371        public void TestConvertInt64ByTypeConverter() 
     372        { 
     373            Assert.That( 
     374                "123", 
     375                Via.Int64().TypeOf<long>().And.EqualTo(123L)); 
     376        } 
     377 
     378        /// <summary> 
     379        /// 内部的に <see cref="long.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     380        /// <see cref="long"/> に変換するテストです。 
     381        /// </summary> 
     382        [Test] 
     383        public void TestConvertInt64ByParse() 
    292384        { 
    293385            Assert.That( 
    … …  
    297389 
    298390        /// <summary> 
     391        /// 内部的に <see cref="TypeConverter"/> を使用して 
    299392        /// <see cref="ulong"/> に変換するテストです。 
    300393        /// </summary> 
    301394        [Test] 
    302         public void TestConvertUInt64() 
     395        public void TestConvertUInt64ByTypeConverter() 
     396        { 
     397            Assert.That( 
     398                "123", 
     399                Via.UInt64().TypeOf<ulong>().And.EqualTo(123LU)); 
     400        } 
     401 
     402        /// <summary> 
     403        /// 内部的に <see cref="ulong.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     404        /// <see cref="ulong"/> に変換するテストです。 
     405        /// </summary> 
     406        [Test] 
     407        public void TestConvertUInt64ByParse() 
    303408        { 
    304409            Assert.That( 
    … …  
    308413 
    309414        /// <summary> 
     415        /// 内部的に <see cref="TypeConverter"/> を使用して 
    310416        /// <see cref="float"/> に変換するテストです。 
    311417        /// </summary> 
    312418        [Test] 
    313         public void TestConvertSingle() 
     419        public void TestConvertSingleByTypeConverter() 
     420        { 
     421            Assert.That( 
     422                "123.5", 
     423                Via.Single().TypeOf<float>().And.EqualTo(123.5F)); 
     424        } 
     425 
     426        /// <summary> 
     427        /// 内部的に <see cref="float.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     428        /// <see cref="float"/> に変換するテストです。 
     429        /// </summary> 
     430        [Test] 
     431        public void TestConvertSingleByParse() 
    314432        { 
    315433            Assert.That( 
    … …  
    319437 
    320438        /// <summary> 
     439        /// 内部的に <see cref="TypeConverter"/> を使用して 
    321440        /// <see cref="double"/> に変換するテストです。 
    322441        /// </summary> 
    323442        [Test] 
    324         public void TestConvertDouble() 
     443        public void TestConvertDoubleByTypeConverter() 
     444        { 
     445            Assert.That( 
     446                "123.5", 
     447                Via.Double().TypeOf<double>().And.EqualTo(123.5D)); 
     448        } 
     449 
     450        /// <summary> 
     451        /// 内部的に <see cref="double.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     452        /// <see cref="double"/> に変換するテストです。 
     453        /// </summary> 
     454        [Test] 
     455        public void TestConvertDoubleByParse() 
    325456        { 
    326457            Assert.That( 
    … …  
    330461 
    331462        /// <summary> 
     463        /// 内部的に <see cref="TypeConverter"/> を使用して 
    332464        /// <see cref="decimal"/> に変換するテストです。 
    333465        /// </summary> 
    334466        [Test] 
    335         public void TestConvertDecimal() 
     467        public void TestConvertDecimalByTypeConverter() 
     468        { 
     469            Assert.That( 
     470                "123.5", 
     471                Via.Decimal().TypeOf<decimal>().And.EqualTo(123.5M)); 
     472        } 
     473 
     474        /// <summary> 
     475        /// 内部的に <see cref="decimal.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     476        /// <see cref="decimal"/> に変換するテストです。 
     477        /// </summary> 
     478        [Test] 
     479        public void TestConvertDecimalByParse() 
    336480        { 
    337481            Assert.That( 
    … …  
    341485 
    342486        /// <summary> 
     487        /// 内部的に <see cref="TypeConverter"/> を使用して 
    343488        /// <see cref="DateTime"/> に変換するテストです。 
    344489        /// </summary> 
    345490        [Test] 
    346         public void TestConvertDateTime() 
     491        public void TestConvertDateTimeByTypeConverter() 
     492        { 
     493            Assert.That( 
     494                "2026-04-20T12:34:56.987+09:00", 
     495                Via.DateTime().TypeOf<DateTime>().And.EqualTo( 
     496                    new DateTime(2026, 4, 20, 12, 34, 56, 987))); 
     497        } 
     498 
     499        /// <summary> 
     500        /// 内部的に <see cref="DateTime.ParseExact(string,string,System.IFormatProvider,System.Globalization.DateTimeStyles)"/> を使用して 
     501        /// <see cref="DateTime"/> に変換するテストです。 
     502        /// </summary> 
     503        [Test] 
     504        public void TestConvertDateTimeByParseExact() 
    347505        { 
    348506            Assert.That( 
    … …  
    353511 
    354512        /// <summary> 
    355         /// 複数の書式を指定して <see cref="DateTime"/> に変換するテストです。 
     513        /// 内部的に <see cref="DateTime.ParseExact(string,string[],System.IFormatProvider,System.Globalization.DateTimeStyles)"/> を使用して 
     514        /// <see cref="DateTime"/> に変換するテストです。 
    356515        /// </summary> 
    357516        /// <param name="value">対象の値。</param> 
    … …  
    359518        [TestCase("2026-04-20T12:34:56.9870000")] 
    360519        [TestCase("20260420_123456.987")] 
    361         public void TestConvertDateTimeWithParseExact(string value) 
     520        public void TestConvertDateTimeByParseExactMultiFormats(string value) 
    362521        { 
    363522            Assert.That( 
    … …  
    368527 
    369528        /// <summary> 
     529        /// 内部的に <see cref="TypeConverter"/> を使用して 
    370530        /// <see cref="DateTimeOffset"/> に変換するテストです。 
    371531        /// </summary> 
    372532        [Test] 
    373         public void TestConvertDateTimeOffset() 
     533        public void TestConvertDateTimeOffsetByTypeConverter() 
     534        { 
     535            Assert.That( 
     536                "2026-04-20T12:34:56.987+09:00", 
     537                Via.DateTimeOffset().TypeOf<DateTimeOffset>().And.EqualTo( 
     538                    new DateTimeOffset(2026, 4, 20, 12, 34, 56, 987, new TimeSpan(9, 0, 0)))); 
     539        } 
     540 
     541        /// <summary> 
     542        /// 内部的に <see cref="DateTimeOffset.ParseExact(string,string,System.IFormatProvider,System.Globalization.DateTimeStyles)"/> を使用して 
     543        /// <see cref="DateTimeOffset"/> に変換するテストです。 
     544        /// </summary> 
     545        [Test] 
     546        public void TestConvertDateTimeOffsetByParseExact() 
    374547        { 
    375548            Assert.That( 
    … …  
    380553 
    381554        /// <summary> 
    382         /// 複数の書式を指定して <see cref="DateTimeOffset"/> に変換するテストです。 
     555        /// 内部的に <see cref="DateTimeOffset.ParseExact(string,string[],System.IFormatProvider,System.Globalization.DateTimeStyles)"/> を使用して 
     556        /// <see cref="DateTimeOffset"/> に変換するテストです。 
    383557        /// </summary> 
    384558        /// <param name="value">対象の値。</param> 
    … …  
    386560        [TestCase("2026-04-20T12:34:56.9870000+05:00")] 
    387561        [TestCase("20260420_123456.987+05:00")] 
    388         public void TestConvertDateTimeOffsetWithParseExact(string value) 
     562        public void TestConvertDateTimeOffsetByParseExactMultiFormats(string value) 
    389563        { 
    390564            Assert.That( 
    … …  
    395569 
    396570        /// <summary> 
     571        /// 内部的に <see cref="TypeConverter"/> を使用して 
    397572        /// <see cref="TimeSpan"/> に変換するテストです。 
    398573        /// </summary> 
    399574        [Test] 
    400         public void TestConvertTimeSpan() 
     575        public void TestConvertTimeSpanByTypeConverter() 
    401576        { 
    402577            Assert.That( 
    403578                "7.12:34:56.789", 
    404                 Via.TimeSpan(null).TypeOf<TimeSpan>().And.EqualTo( 
     579                Via.TimeSpan().TypeOf<TimeSpan>().And.EqualTo( 
    405580                    new TimeSpan(7, 12, 34, 56, 789))); 
    406581        } 
    407582 
    408583        /// <summary> 
     584        /// 内部的に <see cref="TimeSpan.ParseExact(string,string,System.IFormatProvider,System.Globalization.TimeSpanStyles)"/> を使用して 
     585        /// <see cref="TimeSpan"/> に変換するテストです。 
     586        /// </summary> 
     587        [Test] 
     588        public void TestConvertTimeSpanByParseExact() 
     589        { 
     590            Assert.That( 
     591                "7.12:34:56.789", 
     592                Via.TimeSpan("c", null, TimeSpanStyles.None).TypeOf<TimeSpan>().And.EqualTo( 
     593                    new TimeSpan(7, 12, 34, 56, 789))); 
     594        } 
     595 
     596        /// <summary> 
     597        /// 内部的に <see cref="TimeSpan.ParseExact(string,string[],System.IFormatProvider,System.Globalization.TimeSpanStyles)"/> を使用して 
     598        /// <see cref="TimeSpan"/> に変換するテストです。 
     599        /// </summary> 
     600        [Test] 
     601        public void TestConvertTimeSpanByParseExactMultiFormats() 
     602        { 
     603            Assert.That( 
     604                "7.12:34:56.789", 
     605                Via.TimeSpan(new[] { "G", "c" }, null, TimeSpanStyles.None).TypeOf<TimeSpan>().And.EqualTo( 
     606                    new TimeSpan(7, 12, 34, 56, 789))); 
     607        } 
     608 
     609        /// <summary> 
     610        /// 内部的に <see cref="TypeConverter"/> を使用して 
    409611        /// <see cref="Guid"/> に変換するテストです。 
    410612        /// </summary> 
    … …  
    421623        [TestCase(@"{0x12345678, 0x2345, 0x3456, {0x45,0x67,0x56,0x78,0x9A,0xBC,0xDE,0xF0}}")] 
    422624        [TestCase(@"{0x12345678, 0x2345, 0x3456, {0x45,0x67,0x56,0x78,0x9a,0xbc,0xde,0xf0}}")] 
    423         public void TestConvertGuid(string value) 
     625        public void TestConvertGuidByTypeConverter(string value) 
    424626        { 
    425627            Assert.That( 
    … …  
    430632        } 
    431633 
     634        /// <summary> 
     635        /// 内部的に <see cref="Guid.ParseExact"/> を使用して 
     636        /// <see cref="Guid"/> に変換するテストです。 
     637        /// </summary> 
     638        /// <param name="value">対象の値。</param> 
     639        [Test] 
     640        [TestCase(@"12345678-2345-3456-4567-56789ABCDEF0")] 
     641        [TestCase(@"12345678-2345-3456-4567-56789abcdef0")] 
     642        public void TestConvertGuidByParseExact(string value) 
     643        { 
     644            Assert.That( 
     645                value, 
     646                Via.Guid("D").TypeOf<Guid>().And.EqualTo( 
     647                // ReSharper disable once ExceptionNotDocumented 
     648                    new Guid(@"12345678-2345-3456-4567-56789ABCDEF0"))); 
     649        } 
     650 
     651        #endregion 
     652 
     653        #region 変換型の種類 (null 値) 
     654 
     655        /// <summary> 
     656        /// 内部的に <see cref="TypeConverter"/> を使用して 
     657        /// <see cref="bool"/> に変換するテストです。 
     658        /// </summary> 
     659        /// <param name="value">対象の値。</param> 
     660        [Test] 
     661        [TestCase(null)] 
     662        [TestCase("true")] 
     663        public void TestConvertNullBooleanByTypeConverter(string value) 
     664        { 
     665            Assert.That( 
     666                value, 
     667                Via.Boolean().Null.Or.TypeOf<bool>().And.EqualTo(true)); 
     668        } 
     669 
     670        /// <summary> 
     671        /// 内部的に <see cref="TypeConverter"/> を使用して 
     672        /// <see cref="byte"/> に変換するテストです。 
     673        /// </summary> 
     674        /// <param name="value">対象の値。</param> 
     675        [Test] 
     676        [TestCase(null)] 
     677        [TestCase("123")] 
     678        public void TestConvertNullByteByTypeConverter(string value) 
     679        { 
     680            Assert.That( 
     681                value, 
     682                Via.Byte().Null.Or.TypeOf<byte>().And.EqualTo((byte)123)); 
     683        } 
     684 
     685        /// <summary> 
     686        /// 内部的に <see cref="byte.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     687        /// <see cref="byte"/> に変換するテストです。 
     688        /// </summary> 
     689        /// <param name="value">対象の値。</param> 
     690        [Test] 
     691        [TestCase(null)] 
     692        [TestCase("123")] 
     693        public void TestConvertNullByteByParse(string value) 
     694        { 
     695            Assert.That( 
     696                value, 
     697                Via.Byte(NumberStyles.None, null).Null.Or.TypeOf<byte>().And.EqualTo((byte)123)); 
     698        } 
     699 
     700        /// <summary> 
     701        /// 内部的に <see cref="TypeConverter"/> を使用して 
     702        /// <see cref="sbyte"/> に変換するテストです。 
     703        /// </summary> 
     704        /// <param name="value">対象の値。</param> 
     705        [Test] 
     706        [TestCase(null)] 
     707        [TestCase("123")] 
     708        public void TestConvertNullSByteByTypeConverter(string value) 
     709        { 
     710            Assert.That( 
     711                value, 
     712                Via.SByte().Null.Or.TypeOf<sbyte>().And.EqualTo((sbyte)123)); 
     713        } 
     714 
     715        /// <summary> 
     716        /// 内部的に <see cref="sbyte.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     717        /// <see cref="sbyte"/> に変換するテストです。 
     718        /// </summary> 
     719        /// <param name="value">対象の値。</param> 
     720        [Test] 
     721        [TestCase(null)] 
     722        [TestCase("123")] 
     723        public void TestConvertNullSByteByParse(string value) 
     724        { 
     725            Assert.That( 
     726                value, 
     727                Via.SByte(NumberStyles.None, null).Null.Or.TypeOf<sbyte>().And.EqualTo((sbyte)123)); 
     728        } 
     729 
     730        /// <summary> 
     731        /// 内部的に <see cref="TypeConverter"/> を使用して 
     732        /// <see cref="short"/> に変換するテストです。 
     733        /// </summary> 
     734        /// <param name="value">対象の値。</param> 
     735        [Test] 
     736        [TestCase(null)] 
     737        [TestCase("123")] 
     738        public void TestConvertNullInt16ByTypeConverter(string value) 
     739        { 
     740            Assert.That( 
     741                value, 
     742                Via.Int16().Null.Or.TypeOf<short>().And.EqualTo((short)123)); 
     743        } 
     744 
     745        /// <summary> 
     746        /// 内部的に <see cref="short.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     747        /// <see cref="short"/> に変換するテストです。 
     748        /// </summary> 
     749        /// <param name="value">対象の値。</param> 
     750        [Test] 
     751        [TestCase(null)] 
     752        [TestCase("123")] 
     753        public void TestConvertNullInt16ByParse(string value) 
     754        { 
     755            Assert.That( 
     756                value, 
     757                Via.Int16(NumberStyles.None, null).Null.Or.TypeOf<short>().And.EqualTo((short)123)); 
     758        } 
     759 
     760        /// <summary> 
     761        /// 内部的に <see cref="TypeConverter"/> を使用して 
     762        /// <see cref="ushort"/> に変換するテストです。 
     763        /// </summary> 
     764        /// <param name="value">対象の値。</param> 
     765        [Test] 
     766        [TestCase(null)] 
     767        [TestCase("123")] 
     768        public void TestConvertNullUInt16ByTypeConverter(string value) 
     769        { 
     770            Assert.That( 
     771                value, 
     772                Via.UInt16().Null.Or.TypeOf<ushort>().And.EqualTo((ushort)123)); 
     773        } 
     774 
     775        /// <summary> 
     776        /// 内部的に <see cref="ushort.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     777        /// <see cref="ushort"/> に変換するテストです。 
     778        /// </summary> 
     779        /// <param name="value">対象の値。</param> 
     780        [Test] 
     781        [TestCase(null)] 
     782        [TestCase("123")] 
     783        public void TestConvertNullUInt16ByParse(string value) 
     784        { 
     785            Assert.That( 
     786                value, 
     787                Via.UInt16(NumberStyles.None, null).Null.Or.TypeOf<ushort>().And.EqualTo((ushort)123)); 
     788        } 
     789 
     790        /// <summary> 
     791        /// 内部的に <see cref="TypeConverter"/> を使用して 
     792        /// <see cref="int"/> に変換するテストです。 
     793        /// </summary> 
     794        /// <param name="value">対象の値。</param> 
     795        [Test] 
     796        [TestCase(null)] 
     797        [TestCase("123")] 
     798        public void TestConvertNullInt32ByTypeConverter(string value) 
     799        { 
     800            Assert.That( 
     801                value, 
     802                Via.Int32().Null.Or.TypeOf<int>().And.EqualTo(123)); 
     803        } 
     804 
     805        /// <summary> 
     806        /// 内部的に <see cref="int.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     807        /// <see cref="int"/> に変換するテストです。 
     808        /// </summary> 
     809        /// <param name="value">対象の値。</param> 
     810        [Test] 
     811        [TestCase(null)] 
     812        [TestCase("123")] 
     813        public void TestConvertNullInt32ByParse(string value) 
     814        { 
     815            Assert.That( 
     816                value, 
     817                Via.Int32(NumberStyles.None, null).Null.Or.TypeOf<int>().And.EqualTo(123)); 
     818        } 
     819 
     820        /// <summary> 
     821        /// 内部的に <see cref="TypeConverter"/> を使用して 
     822        /// <see cref="uint"/> に変換するテストです。 
     823        /// </summary> 
     824        /// <param name="value">対象の値。</param> 
     825        [Test] 
     826        [TestCase(null)] 
     827        [TestCase("123")] 
     828        public void TestConvertNullUInt32ByTypeConverter(string value) 
     829        { 
     830            Assert.That( 
     831                value, 
     832                Via.UInt32().Null.Or.TypeOf<uint>().And.EqualTo(123U)); 
     833        } 
     834 
     835        /// <summary> 
     836        /// 内部的に <see cref="uint.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     837        /// <see cref="uint"/> に変換するテストです。 
     838        /// </summary> 
     839        /// <param name="value">対象の値。</param> 
     840        [Test] 
     841        [TestCase(null)] 
     842        [TestCase("123")] 
     843        public void TestConvertNullUInt32ByParse(string value) 
     844        { 
     845            Assert.That( 
     846                value, 
     847                Via.UInt32(NumberStyles.None, null).Null.Or.TypeOf<uint>().And.EqualTo(123U)); 
     848        } 
     849 
     850        /// <summary> 
     851        /// 内部的に <see cref="TypeConverter"/> を使用して 
     852        /// <see cref="long"/> に変換するテストです。 
     853        /// </summary> 
     854        /// <param name="value">対象の値。</param> 
     855        [Test] 
     856        [TestCase(null)] 
     857        [TestCase("123")] 
     858        public void TestConvertNullInt64ByTypeConverter(string value) 
     859        { 
     860            Assert.That( 
     861                value, 
     862                Via.Int64().Null.Or.TypeOf<long>().And.EqualTo(123L)); 
     863        } 
     864 
     865        /// <summary> 
     866        /// 内部的に <see cref="long.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     867        /// <see cref="long"/> に変換するテストです。 
     868        /// </summary> 
     869        /// <param name="value">対象の値。</param> 
     870        [Test] 
     871        [TestCase(null)] 
     872        [TestCase("123")] 
     873        public void TestConvertNullInt64ByParse(string value) 
     874        { 
     875            Assert.That( 
     876                value, 
     877                Via.Int64(NumberStyles.None, null).Null.Or.TypeOf<long>().And.EqualTo(123L)); 
     878        } 
     879 
     880        /// <summary> 
     881        /// 内部的に <see cref="TypeConverter"/> を使用して 
     882        /// <see cref="ulong"/> に変換するテストです。 
     883        /// </summary> 
     884        /// <param name="value">対象の値。</param> 
     885        [Test] 
     886        [TestCase(null)] 
     887        [TestCase("123")] 
     888        public void TestConvertNullUInt64ByTypeConverter(string value) 
     889        { 
     890            Assert.That( 
     891                value, 
     892                Via.UInt64().Null.Or.TypeOf<ulong>().And.EqualTo(123LU)); 
     893        } 
     894 
     895        /// <summary> 
     896        /// 内部的に <see cref="ulong.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     897        /// <see cref="ulong"/> に変換するテストです。 
     898        /// </summary> 
     899        /// <param name="value">対象の値。</param> 
     900        [Test] 
     901        [TestCase(null)] 
     902        [TestCase("123")] 
     903        public void TestConvertNullUInt64ByParse(string value) 
     904        { 
     905            Assert.That( 
     906                value, 
     907                Via.UInt64(NumberStyles.None, null).Null.Or.TypeOf<ulong>().And.EqualTo(123LU)); 
     908        } 
     909 
     910        /// <summary> 
     911        /// 内部的に <see cref="TypeConverter"/> を使用して 
     912        /// <see cref="float"/> に変換するテストです。 
     913        /// </summary> 
     914        /// <param name="value">対象の値。</param> 
     915        [Test] 
     916        [TestCase(null)] 
     917        [TestCase("123.5")] 
     918        public void TestConvertNullSingleByTypeConverter(string value) 
     919        { 
     920            Assert.That( 
     921                value, 
     922                Via.Single().Null.Or.TypeOf<float>().And.EqualTo(123.5F)); 
     923        } 
     924 
     925        /// <summary> 
     926        /// 内部的に <see cref="float.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     927        /// <see cref="float"/> に変換するテストです。 
     928        /// </summary> 
     929        /// <param name="value">対象の値。</param> 
     930        [Test] 
     931        [TestCase(null)] 
     932        [TestCase("123.5")] 
     933        public void TestConvertNullSingleByParse(string value) 
     934        { 
     935            Assert.That( 
     936                value, 
     937                Via.Single(NumberStyles.AllowDecimalPoint, null).Null.Or.TypeOf<float>().And.EqualTo(123.5F)); 
     938        } 
     939 
     940        /// <summary> 
     941        /// 内部的に <see cref="TypeConverter"/> を使用して 
     942        /// <see cref="double"/> に変換するテストです。 
     943        /// </summary> 
     944        /// <param name="value">対象の値。</param> 
     945        [Test] 
     946        [TestCase(null)] 
     947        [TestCase("123.5")] 
     948        public void TestConvertNullDoubleByTypeConverter(string value) 
     949        { 
     950            Assert.That( 
     951                value, 
     952                Via.Double().Null.Or.TypeOf<double>().And.EqualTo(123.5D)); 
     953        } 
     954 
     955        /// <summary> 
     956        /// 内部的に <see cref="double.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     957        /// <see cref="double"/> に変換するテストです。 
     958        /// </summary> 
     959        /// <param name="value">対象の値。</param> 
     960        [Test] 
     961        [TestCase(null)] 
     962        [TestCase("123.5")] 
     963        public void TestConvertNullDoubleByParse(string value) 
     964        { 
     965            Assert.That( 
     966                value, 
     967                Via.Double(NumberStyles.AllowDecimalPoint, null).Null.Or.TypeOf<double>().And.EqualTo(123.5D)); 
     968        } 
     969 
     970        /// <summary> 
     971        /// 内部的に <see cref="TypeConverter"/> を使用して 
     972        /// <see cref="decimal"/> に変換するテストです。 
     973        /// </summary> 
     974        /// <param name="value">対象の値。</param> 
     975        [Test] 
     976        [TestCase(null)] 
     977        [TestCase("123.5")] 
     978        public void TestConvertNullDecimalByTypeConverter(string value) 
     979        { 
     980            Assert.That( 
     981                value, 
     982                Via.Decimal().Null.Or.TypeOf<decimal>().And.EqualTo(123.5M)); 
     983        } 
     984 
     985        /// <summary> 
     986        /// 内部的に <see cref="decimal.Parse(string,System.Globalization.NumberStyles,System.IFormatProvider)"/> を使用して 
     987        /// <see cref="decimal"/> に変換するテストです。 
     988        /// </summary> 
     989        /// <param name="value">対象の値。</param> 
     990        [Test] 
     991        [TestCase(null)] 
     992        [TestCase("123.5")] 
     993        public void TestConvertNullDecimalByParse(string value) 
     994        { 
     995            Assert.That( 
     996                value, 
     997                Via.Decimal(NumberStyles.AllowDecimalPoint, null).Null.Or.TypeOf<decimal>().And.EqualTo(123.5M)); 
     998        } 
     999 
     1000        /// <summary> 
     1001        /// 内部的に <see cref="TypeConverter"/> を使用して 
     1002        /// <see cref="DateTime"/> に変換するテストです。 
     1003        /// </summary> 
     1004        /// <param name="value">対象の値。</param> 
     1005        [Test] 
     1006        [TestCase(null)] 
     1007        [TestCase("2026-04-20T12:34:56.987+09:00")] 
     1008        public void TestConvertNullDateTimeByTypeConverter(string value) 
     1009        { 
     1010            Assert.That( 
     1011                value, 
     1012                Via.DateTime().Null.Or.TypeOf<DateTime>().And.EqualTo( 
     1013                    new DateTime(2026, 4, 20, 12, 34, 56, 987))); 
     1014        } 
     1015 
     1016        /// <summary> 
     1017        /// 内部的に <see cref="DateTime.ParseExact(string,string,System.IFormatProvider,System.Globalization.DateTimeStyles)"/> を使用して 
     1018        /// <see cref="DateTime"/> に変換するテストです。 
     1019        /// </summary> 
     1020        /// <param name="value">対象の値。</param> 
     1021        [Test] 
     1022        [TestCase(null)] 
     1023        [TestCase("2026-04-20T12:34:56.9870000")] 
     1024        public void TestConvertNullDateTimeByParseExact(string value) 
     1025        { 
     1026            Assert.That( 
     1027                value, 
     1028                Via.DateTime("O", null, DateTimeStyles.None).Null.Or.TypeOf<DateTime>().And.EqualTo( 
     1029                    new DateTime(2026, 4, 20, 12, 34, 56, 987))); 
     1030        } 
     1031 
     1032        /// <summary> 
     1033        /// 内部的に <see cref="DateTime.ParseExact(string,string[],System.IFormatProvider,System.Globalization.DateTimeStyles)"/> を使用して 
     1034        /// <see cref="DateTime"/> に変換するテストです。 
     1035        /// </summary> 
     1036        /// <param name="value">対象の値。</param> 
     1037        [Test] 
     1038        [TestCase(null)] 
     1039        [TestCase("2026-04-20T12:34:56.9870000")] 
     1040        [TestCase("20260420_123456.987")] 
     1041        public void TestConvertNullDateTimeByParseExactMultiFormats(string value) 
     1042        { 
     1043            Assert.That( 
     1044                value, 
     1045                Via.DateTime(new[] { "O", @"yyyyMMdd_HHmmss.fff" }, null, DateTimeStyles.None).Null.Or.TypeOf<DateTime>().And.EqualTo( 
     1046                    new DateTime(2026, 4, 20, 12, 34, 56, 987))); 
     1047        } 
     1048 
     1049        /// <summary> 
     1050        /// 内部的に <see cref="TypeConverter"/> を使用して 
     1051        /// <see cref="DateTimeOffset"/> に変換するテストです。 
     1052        /// </summary> 
     1053        /// <param name="value">対象の値。</param> 
     1054        [Test] 
     1055        [TestCase(null)] 
     1056        [TestCase("2026-04-20T12:34:56.987+09:00")] 
     1057        public void TestConvertNullDateTimeOffsetByTypeConverter(string value) 
     1058        { 
     1059            Assert.That( 
     1060                value, 
     1061                Via.DateTimeOffset().Null.Or.TypeOf<DateTimeOffset>().And.EqualTo( 
     1062                    new DateTimeOffset(2026, 4, 20, 12, 34, 56, 987, new TimeSpan(9, 0, 0)))); 
     1063        } 
     1064 
     1065        /// <summary> 
     1066        /// 内部的に <see cref="DateTimeOffset.ParseExact(string,string,System.IFormatProvider,System.Globalization.DateTimeStyles)"/> を使用して 
     1067        /// <see cref="DateTimeOffset"/> に変換するテストです。 
     1068        /// </summary> 
     1069        /// <param name="value">対象の値。</param> 
     1070        [Test] 
     1071        [TestCase(null)] 
     1072        [TestCase("2026-04-20T12:34:56.9870000+05:00")] 
     1073        public void TestConvertNullDateTimeOffsetByParseExact(string value) 
     1074        { 
     1075            Assert.That( 
     1076                value, 
     1077                Via.DateTimeOffset("O", null, DateTimeStyles.None).Null.Or.TypeOf<DateTimeOffset>().And.EqualTo( 
     1078                    new DateTimeOffset(2026, 4, 20, 12, 34, 56, 987, new TimeSpan(5, 0, 0)))); 
     1079        } 
     1080 
     1081        /// <summary> 
     1082        /// 内部的に <see cref="DateTimeOffset.ParseExact(string,string[],System.IFormatProvider,System.Globalization.DateTimeStyles)"/> を使用して 
     1083        /// <see cref="DateTimeOffset"/> に変換するテストです。 
     1084        /// </summary> 
     1085        /// <param name="value">対象の値。</param> 
     1086        [Test] 
     1087        [TestCase(null)] 
     1088        [TestCase("2026-04-20T12:34:56.9870000+05:00")] 
     1089        [TestCase("20260420_123456.987+05:00")] 
     1090        public void TestConvertNullDateTimeOffsetByParseExactMultiFormats(string value) 
     1091        { 
     1092            Assert.That( 
     1093                value, 
     1094                Via.DateTimeOffset(new[] { "O", @"yyyyMMdd_HHmmss.fffK" }, null, DateTimeStyles.None).Null.Or.TypeOf<DateTimeOffset>().And.EqualTo( 
     1095                    new DateTimeOffset(2026, 4, 20, 12, 34, 56, 987, new TimeSpan(5, 0, 0)))); 
     1096        } 
     1097 
     1098        /// <summary> 
     1099        /// 内部的に <see cref="TypeConverter"/> を使用して 
     1100        /// <see cref="TimeSpan"/> に変換するテストです。 
     1101        /// </summary> 
     1102        /// <param name="value">対象の値。</param> 
     1103        [Test] 
     1104        [TestCase(null)] 
     1105        [TestCase("7.12:34:56.789")] 
     1106        public void TestConvertNullTimeSpanByTypeConverter(string value) 
     1107        { 
     1108            Assert.That( 
     1109                value, 
     1110                Via.TimeSpan().Null.Or.TypeOf<TimeSpan>().And.EqualTo( 
     1111                    new TimeSpan(7, 12, 34, 56, 789))); 
     1112        } 
     1113 
     1114        /// <summary> 
     1115        /// 内部的に <see cref="TimeSpan.ParseExact(string,string,System.IFormatProvider,System.Globalization.TimeSpanStyles)"/> を使用して 
     1116        /// <see cref="TimeSpan"/> に変換するテストです。 
     1117        /// </summary> 
     1118        /// <param name="value">対象の値。</param> 
     1119        [Test] 
     1120        [TestCase(null)] 
     1121        [TestCase("7.12:34:56.789")] 
     1122        public void TestConvertNullTimeSpanByParseExact(string value) 
     1123        { 
     1124            Assert.That( 
     1125                value, 
     1126                Via.TimeSpan("c", null, TimeSpanStyles.None).Null.Or.TypeOf<TimeSpan>().And.EqualTo( 
     1127                    new TimeSpan(7, 12, 34, 56, 789))); 
     1128        } 
     1129 
     1130        /// <summary> 
     1131        /// 内部的に <see cref="TimeSpan.ParseExact(string,string[],System.IFormatProvider,System.Globalization.TimeSpanStyles)"/> を使用して 
     1132        /// <see cref="TimeSpan"/> に変換するテストです。 
     1133        /// </summary> 
     1134        /// <param name="value">対象の値。</param> 
     1135        [Test] 
     1136        [TestCase(null)] 
     1137        [TestCase("7.12:34:56.789")] 
     1138        public void TestConvertNullTimeSpanByParseExactMultiFormats(string value) 
     1139        { 
     1140            Assert.That( 
     1141                value, 
     1142                Via.TimeSpan(new[] { "G", "c" }, null, TimeSpanStyles.None).Null.Or.TypeOf<TimeSpan>().And.EqualTo( 
     1143                    new TimeSpan(7, 12, 34, 56, 789))); 
     1144        } 
     1145 
     1146        /// <summary> 
     1147        /// 内部的に <see cref="TypeConverter"/> を使用して 
     1148        /// <see cref="Guid"/> に変換するテストです。 
     1149        /// </summary> 
     1150        /// <param name="value">対象の値。</param> 
     1151        [Test] 
     1152        [TestCase(null)] 
     1153        [TestCase(@"1234567823453456456756789ABCDEF0")] 
     1154        [TestCase(@"1234567823453456456756789abcdef0")] 
     1155        [TestCase(@"12345678-2345-3456-4567-56789ABCDEF0")] 
     1156        [TestCase(@"12345678-2345-3456-4567-56789abcdef0")] 
     1157        [TestCase(@"{12345678-2345-3456-4567-56789ABCDEF0}")] 
     1158        [TestCase(@"{12345678-2345-3456-4567-56789abcdef0}")] 
     1159        [TestCase(@"(12345678-2345-3456-4567-56789ABCDEF0)")] 
     1160        [TestCase(@"(12345678-2345-3456-4567-56789abcdef0)")] 
     1161        [TestCase(@"{0x12345678, 0x2345, 0x3456, {0x45,0x67,0x56,0x78,0x9A,0xBC,0xDE,0xF0}}")] 
     1162        [TestCase(@"{0x12345678, 0x2345, 0x3456, {0x45,0x67,0x56,0x78,0x9a,0xbc,0xde,0xf0}}")] 
     1163        public void TestConvertNullGuidByTypeConverter(string value) 
     1164        { 
     1165            Assert.That( 
     1166                value, 
     1167                Via.Guid().Null.Or.TypeOf<Guid>().And.EqualTo( 
     1168                // ReSharper disable once ExceptionNotDocumented 
     1169                    new Guid(@"12345678-2345-3456-4567-56789ABCDEF0"))); 
     1170        } 
     1171 
     1172        /// <summary> 
     1173        /// 内部的に <see cref="Guid.ParseExact"/> を使用して 
     1174        /// <see cref="Guid"/> に変換するテストです。 
     1175        /// </summary> 
     1176        /// <param name="value">対象の値。</param> 
     1177        [Test] 
     1178        [TestCase(null)] 
     1179        [TestCase(@"12345678-2345-3456-4567-56789ABCDEF0")] 
     1180        [TestCase(@"12345678-2345-3456-4567-56789abcdef0")] 
     1181        public void TestConvertNullGuidByParseExact(string value) 
     1182        { 
     1183            Assert.That( 
     1184                value, 
     1185                Via.Guid("D").Null.Or.TypeOf<Guid>().And.EqualTo( 
     1186                // ReSharper disable once ExceptionNotDocumented 
     1187                    new Guid(@"12345678-2345-3456-4567-56789ABCDEF0"))); 
     1188        } 
     1189 
    4321190        #endregion 
    4331191    } 
※ 詳しい使い方は TracChangeset を参照してください。