mcs/class/referencesource/mscorlib/system/diagnostics/eventing/TraceLogging/SimpleTypeInfos.cs

   1 using System;
   2 using System.Collections.Generic;
   3
   4 #if ES_BUILD_STANDALONE
   5 namespace Microsoft.Diagnostics.Tracing
   6 #else
   7 namespace System.Diagnostics.Tracing
   8 #endif
   9 {
  10     #region NullTypeInfo
  11
  12     /// <summary>
  13     /// TraceLogging: Type handler for empty or unsupported types.
  14     /// </summary>
  15     /// <typeparam name="DataType">The type to handle.</typeparam>
  16     internal sealed class NullTypeInfo<DataType>
  17         : TraceLoggingTypeInfo<DataType>
  18     {
  19         public override void WriteMetadata(
  20             TraceLoggingMetadataCollector collector,
  21             string name,
  22             EventFieldFormat format)
  23         {
  24             collector.AddGroup(name);
  25         }
  26
  27         public override void WriteData(TraceLoggingDataCollector collector, ref DataType value)
  28         {
  29             return;
  30         }
  31
  32         public override object GetData(object value)
  33         {
  34             return null;
  35         }
  36     }
  37
  38     #endregion
  39
  40     #region Primitive scalars
  41
  42     /// <summary>
  43     /// TraceLogging: Type handler for Boolean.
  44     /// </summary>
  45     internal sealed class BooleanTypeInfo
  46         : TraceLoggingTypeInfo<Boolean>
  47     {
  48         public override void WriteMetadata(
  49             TraceLoggingMetadataCollector collector,
  50             string name,
  51             EventFieldFormat format)
  52         {
  53             collector.AddScalar(name, Statics.Format8(format, TraceLoggingDataType.Boolean8));
  54         }
  55
  56         public override void WriteData(TraceLoggingDataCollector collector, ref Boolean value)
  57         {
  58             collector.AddScalar(value);
  59         }
  60     }
  61
  62     /// <summary>
  63     /// TraceLogging: Type handler for Byte.
  64     /// </summary>
  65     internal sealed class ByteTypeInfo
  66         : TraceLoggingTypeInfo<Byte>
  67     {
  68         public override void WriteMetadata(
  69             TraceLoggingMetadataCollector collector,
  70             string name,
  71             EventFieldFormat format)
  72         {
  73             collector.AddScalar(name, Statics.Format8(format, TraceLoggingDataType.UInt8));
  74         }
  75
  76         public override void WriteData(TraceLoggingDataCollector collector, ref Byte value)
  77         {
  78             collector.AddScalar(value);
  79         }
  80     }
  81
  82     /// <summary>
  83     /// TraceLogging: Type handler for SByte.
  84     /// </summary>
  85     internal sealed class SByteTypeInfo
  86         : TraceLoggingTypeInfo<SByte>
  87     {
  88         public override void WriteMetadata(
  89             TraceLoggingMetadataCollector collector,
  90             string name,
  91             EventFieldFormat format)
  92         {
  93             collector.AddScalar(name, Statics.Format8(format, TraceLoggingDataType.Int8));
  94         }
  95
  96         public override void WriteData(TraceLoggingDataCollector collector, ref SByte value)
  97         {
  98             collector.AddScalar(value);
  99         }
 100     }
 101
 102     /// <summary>
 103     /// TraceLogging: Type handler for Int16.
 104     /// </summary>
 105     internal sealed class Int16TypeInfo
 106         : TraceLoggingTypeInfo<Int16>
 107     {
 108         public override void WriteMetadata(
 109             TraceLoggingMetadataCollector collector,
 110             string name,
 111             EventFieldFormat format)
 112         {
 113             collector.AddScalar(name, Statics.Format16(format, TraceLoggingDataType.Int16));
 114         }
 115
 116         public override void WriteData(TraceLoggingDataCollector collector, ref Int16 value)
 117         {
 118             collector.AddScalar(value);
 119         }
 120     }
 121
 122     /// <summary>
 123     /// TraceLogging: Type handler for UInt16.
 124     /// </summary>
 125     internal sealed class UInt16TypeInfo
 126         : TraceLoggingTypeInfo<UInt16>
 127     {
 128         public override void WriteMetadata(
 129             TraceLoggingMetadataCollector collector,
 130             string name,
 131             EventFieldFormat format)
 132         {
 133             collector.AddScalar(name, Statics.Format16(format, TraceLoggingDataType.UInt16));
 134         }
 135
 136         public override void WriteData(TraceLoggingDataCollector collector, ref UInt16 value)
 137         {
 138             collector.AddScalar(value);
 139         }
 140     }
 141
 142     /// <summary>
 143     /// TraceLogging: Type handler for Int32.
 144     /// </summary>
 145     internal sealed class Int32TypeInfo
 146         : TraceLoggingTypeInfo<Int32>
 147     {
 148         public override void WriteMetadata(
 149             TraceLoggingMetadataCollector collector,
 150             string name,
 151             EventFieldFormat format)
 152         {
 153             collector.AddScalar(name, Statics.Format32(format, TraceLoggingDataType.Int32));
 154         }
 155
 156         public override void WriteData(TraceLoggingDataCollector collector, ref Int32 value)
 157         {
 158             collector.AddScalar(value);
 159         }
 160     }
 161
 162     /// <summary>
 163     /// TraceLogging: Type handler for UInt32.
 164     /// </summary>
 165     internal sealed class UInt32TypeInfo
 166         : TraceLoggingTypeInfo<UInt32>
 167     {
 168         public override void WriteMetadata(
 169             TraceLoggingMetadataCollector collector,
 170             string name,
 171             EventFieldFormat format)
 172         {
 173             collector.AddScalar(name, Statics.Format32(format, TraceLoggingDataType.UInt32));
 174         }
 175
 176         public override void WriteData(TraceLoggingDataCollector collector, ref UInt32 value)
 177         {
 178             collector.AddScalar(value);
 179         }
 180     }
 181
 182     /// <summary>
 183     /// TraceLogging: Type handler for Int64.
 184     /// </summary>
 185     internal sealed class Int64TypeInfo
 186         : TraceLoggingTypeInfo<Int64>
 187     {
 188         public override void WriteMetadata(
 189             TraceLoggingMetadataCollector collector,
 190             string name,
 191             EventFieldFormat format)
 192         {
 193             collector.AddScalar(name, Statics.Format64(format, TraceLoggingDataType.Int64));
 194         }
 195
 196         public override void WriteData(TraceLoggingDataCollector collector, ref Int64 value)
 197         {
 198             collector.AddScalar(value);
 199         }
 200     }
 201
 202     /// <summary>
 203     /// TraceLogging: Type handler for UInt64.
 204     /// </summary>
 205     internal sealed class UInt64TypeInfo
 206         : TraceLoggingTypeInfo<UInt64>
 207     {
 208         public override void WriteMetadata(
 209             TraceLoggingMetadataCollector collector,
 210             string name,
 211             EventFieldFormat format)
 212         {
 213             collector.AddScalar(name, Statics.Format64(format, TraceLoggingDataType.UInt64));
 214         }
 215
 216         public override void WriteData(TraceLoggingDataCollector collector, ref UInt64 value)
 217         {
 218             collector.AddScalar(value);
 219         }
 220     }
 221
 222     /// <summary>
 223     /// TraceLogging: Type handler for IntPtr.
 224     /// </summary>
 225     internal sealed class IntPtrTypeInfo
 226         : TraceLoggingTypeInfo<IntPtr>
 227     {
 228         public override void WriteMetadata(
 229             TraceLoggingMetadataCollector collector,
 230             string name,
 231             EventFieldFormat format)
 232         {
 233             collector.AddScalar(name, Statics.FormatPtr(format, Statics.IntPtrType));
 234         }
 235
 236         public override void WriteData(TraceLoggingDataCollector collector, ref IntPtr value)
 237         {
 238             collector.AddScalar(value);
 239         }
 240     }
 241
 242     /// <summary>
 243     /// TraceLogging: Type handler for UIntPtr.
 244     /// </summary>
 245     internal sealed class UIntPtrTypeInfo
 246         : TraceLoggingTypeInfo<UIntPtr>
 247     {
 248         public override void WriteMetadata(
 249             TraceLoggingMetadataCollector collector,
 250             string name,
 251             EventFieldFormat format)
 252         {
 253             collector.AddScalar(name, Statics.FormatPtr(format, Statics.UIntPtrType));
 254         }
 255
 256         public override void WriteData(TraceLoggingDataCollector collector, ref UIntPtr value)
 257         {
 258             collector.AddScalar(value);
 259         }
 260     }
 261
 262     /// <summary>
 263     /// TraceLogging: Type handler for Double.
 264     /// </summary>
 265     internal sealed class DoubleTypeInfo
 266         : TraceLoggingTypeInfo<Double>
 267     {
 268         public override void WriteMetadata(
 269             TraceLoggingMetadataCollector collector,
 270             string name,
 271             EventFieldFormat format)
 272         {
 273             collector.AddScalar(name, Statics.Format64(format, TraceLoggingDataType.Double));
 274         }
 275
 276         public override void WriteData(TraceLoggingDataCollector collector, ref Double value)
 277         {
 278             collector.AddScalar(value);
 279         }
 280     }
 281
 282     /// <summary>
 283     /// TraceLogging: Type handler for Single.
 284     /// </summary>
 285     internal sealed class SingleTypeInfo
 286         : TraceLoggingTypeInfo<Single>
 287     {
 288         public override void WriteMetadata(
 289             TraceLoggingMetadataCollector collector,
 290             string name,
 291             EventFieldFormat format)
 292         {
 293             collector.AddScalar(name, Statics.Format32(format, TraceLoggingDataType.Float));
 294         }
 295
 296         public override void WriteData(TraceLoggingDataCollector collector, ref Single value)
 297         {
 298             collector.AddScalar(value);
 299         }
 300     }
 301
 302     /// <summary>
 303     /// TraceLogging: Type handler for Char.
 304     /// </summary>
 305     internal sealed class CharTypeInfo
 306         : TraceLoggingTypeInfo<Char>
 307     {
 308         public override void WriteMetadata(
 309             TraceLoggingMetadataCollector collector,
 310             string name,
 311             EventFieldFormat format)
 312         {
 313             collector.AddScalar(name, Statics.Format16(format, TraceLoggingDataType.Char16));
 314         }
 315
 316         public override void WriteData(TraceLoggingDataCollector collector, ref Char value)
 317         {
 318             collector.AddScalar(value);
 319         }
 320     }
 321
 322     #endregion
 323
 324     #region Primitive arrays
 325
 326     /// <summary>
 327     /// TraceLogging: Type handler for Boolean[].
 328     /// </summary>
 329     internal sealed class BooleanArrayTypeInfo
 330         : TraceLoggingTypeInfo<Boolean[]>
 331     {
 332         public override void WriteMetadata(
 333             TraceLoggingMetadataCollector collector,
 334             string name,
 335             EventFieldFormat format)
 336         {
 337             collector.AddArray(name, Statics.Format8(format, TraceLoggingDataType.Boolean8));
 338         }
 339
 340         public override void WriteData(TraceLoggingDataCollector collector, ref Boolean[] value)
 341         {
 342             collector.AddArray(value);
 343         }
 344     }
 345
 346     /// <summary>
 347     /// TraceLogging: Type handler for Byte[].
 348     /// </summary>
 349     internal sealed class ByteArrayTypeInfo
 350         : TraceLoggingTypeInfo<Byte[]>
 351     {
 352         public override void WriteMetadata(
 353             TraceLoggingMetadataCollector collector,
 354             string name,
 355             EventFieldFormat format)
 356         {
 357             switch (format)
 358             {
 359                 default:
 360                     collector.AddBinary(name, Statics.MakeDataType(TraceLoggingDataType.Binary, format));
 361                     break;
 362                 case EventFieldFormat.String:
 363                     collector.AddBinary(name, TraceLoggingDataType.CountedMbcsString);
 364                     break;
 365                 case EventFieldFormat.Xml:
 366                     collector.AddBinary(name, TraceLoggingDataType.CountedMbcsXml);
 367                     break;
 368                 case EventFieldFormat.Json:
 369                     collector.AddBinary(name, TraceLoggingDataType.CountedMbcsJson);
 370                     break;
 371                 case EventFieldFormat.Boolean:
 372                     collector.AddArray(name, TraceLoggingDataType.Boolean8);
 373                     break;
 374                 case EventFieldFormat.Hexadecimal:
 375                     collector.AddArray(name, TraceLoggingDataType.HexInt8);
 376                     break;
 377 #if false
 378                 case EventSourceFieldFormat.Signed:
 379                     collector.AddArray(name, TraceLoggingDataType.Int8);
 380                     break;
 381                 case EventSourceFieldFormat.Unsigned:
 382                     collector.AddArray(name, TraceLoggingDataType.UInt8);
 383                     break;
 384 #endif
 385             }
 386         }
 387
 388         public override void WriteData(TraceLoggingDataCollector collector, ref Byte[] value)
 389         {
 390             collector.AddBinary(value);
 391         }
 392     }
 393
 394     /// <summary>
 395     /// TraceLogging: Type handler for SByte[].
 396     /// </summary>
 397     internal sealed class SByteArrayTypeInfo
 398         : TraceLoggingTypeInfo<SByte[]>
 399     {
 400         public override void WriteMetadata(
 401             TraceLoggingMetadataCollector collector,
 402             string name,
 403             EventFieldFormat format)
 404         {
 405             collector.AddArray(name, Statics.Format8(format, TraceLoggingDataType.Int8));
 406         }
 407
 408         public override void WriteData(TraceLoggingDataCollector collector, ref SByte[] value)
 409         {
 410             collector.AddArray(value);
 411         }
 412     }
 413
 414     /// <summary>
 415     /// TraceLogging: Type handler for Int16[].
 416     /// </summary>
 417     internal sealed class Int16ArrayTypeInfo
 418         : TraceLoggingTypeInfo<Int16[]>
 419     {
 420         public override void WriteMetadata(
 421             TraceLoggingMetadataCollector collector,
 422             string name,
 423             EventFieldFormat format)
 424         {
 425             collector.AddArray(name, Statics.Format16(format, TraceLoggingDataType.Int16));
 426         }
 427
 428         public override void WriteData(TraceLoggingDataCollector collector, ref Int16[] value)
 429         {
 430             collector.AddArray(value);
 431         }
 432     }
 433
 434     /// <summary>
 435     /// TraceLogging: Type handler for UInt16[].
 436     /// </summary>
 437     internal sealed class UInt16ArrayTypeInfo
 438         : TraceLoggingTypeInfo<UInt16[]>
 439     {
 440         public override void WriteMetadata(
 441             TraceLoggingMetadataCollector collector,
 442             string name,
 443             EventFieldFormat format)
 444         {
 445             collector.AddArray(name, Statics.Format16(format, TraceLoggingDataType.UInt16));
 446         }
 447
 448         public override void WriteData(TraceLoggingDataCollector collector, ref UInt16[] value)
 449         {
 450             collector.AddArray(value);
 451         }
 452     }
 453
 454     /// <summary>
 455     /// TraceLogging: Type handler for Int32[].
 456     /// </summary>
 457     internal sealed class Int32ArrayTypeInfo
 458         : TraceLoggingTypeInfo<Int32[]>
 459     {
 460         public override void WriteMetadata(
 461             TraceLoggingMetadataCollector collector,
 462             string name,
 463             EventFieldFormat format)
 464         {
 465             collector.AddArray(name, Statics.Format32(format, TraceLoggingDataType.Int32));
 466         }
 467
 468         public override void WriteData(TraceLoggingDataCollector collector, ref Int32[] value)
 469         {
 470             collector.AddArray(value);
 471         }
 472     }
 473
 474     /// <summary>
 475     /// TraceLogging: Type handler for UInt32[].
 476     /// </summary>
 477     internal sealed class UInt32ArrayTypeInfo
 478         : TraceLoggingTypeInfo<UInt32[]>
 479     {
 480         public override void WriteMetadata(
 481             TraceLoggingMetadataCollector collector,
 482             string name,
 483             EventFieldFormat format)
 484         {
 485             collector.AddArray(name, Statics.Format32(format, TraceLoggingDataType.UInt32));
 486         }
 487
 488         public override void WriteData(TraceLoggingDataCollector collector, ref UInt32[] value)
 489         {
 490             collector.AddArray(value);
 491         }
 492     }
 493
 494     /// <summary>
 495     /// TraceLogging: Type handler for Int64[].
 496     /// </summary>
 497     internal sealed class Int64ArrayTypeInfo
 498         : TraceLoggingTypeInfo<Int64[]>
 499     {
 500         public override void WriteMetadata(
 501             TraceLoggingMetadataCollector collector,
 502             string name,
 503             EventFieldFormat format)
 504         {
 505             collector.AddArray(name, Statics.Format64(format, TraceLoggingDataType.Int64));
 506         }
 507
 508         public override void WriteData(TraceLoggingDataCollector collector, ref Int64[] value)
 509         {
 510             collector.AddArray(value);
 511         }
 512     }
 513
 514     /// <summary>
 515     /// TraceLogging: Type handler for UInt64[].
 516     /// </summary>
 517     internal sealed class UInt64ArrayTypeInfo
 518         : TraceLoggingTypeInfo<UInt64[]>
 519     {
 520         public override void WriteMetadata(
 521             TraceLoggingMetadataCollector collector,
 522             string name,
 523             EventFieldFormat format)
 524         {
 525             collector.AddArray(name, Statics.Format64(format, TraceLoggingDataType.UInt64));
 526         }
 527
 528         public override void WriteData(TraceLoggingDataCollector collector, ref UInt64[] value)
 529         {
 530             collector.AddArray(value);
 531         }
 532     }
 533
 534     /// <summary>
 535     /// TraceLogging: Type handler for IntPtr[].
 536     /// </summary>
 537     internal sealed class IntPtrArrayTypeInfo
 538         : TraceLoggingTypeInfo<IntPtr[]>
 539     {
 540         public override void WriteMetadata(
 541             TraceLoggingMetadataCollector collector,
 542             string name,
 543             EventFieldFormat format)
 544         {
 545             collector.AddArray(name, Statics.FormatPtr(format, Statics.IntPtrType));
 546         }
 547
 548         public override void WriteData(TraceLoggingDataCollector collector, ref IntPtr[] value)
 549         {
 550             collector.AddArray(value);
 551         }
 552     }
 553
 554     /// <summary>
 555     /// TraceLogging: Type handler for UIntPtr[].
 556     /// </summary>
 557     internal sealed class UIntPtrArrayTypeInfo
 558         : TraceLoggingTypeInfo<UIntPtr[]>
 559     {
 560         public override void WriteMetadata(
 561             TraceLoggingMetadataCollector collector,
 562             string name,
 563             EventFieldFormat format)
 564         {
 565             collector.AddArray(name, Statics.FormatPtr(format, Statics.UIntPtrType));
 566         }
 567
 568         public override void WriteData(TraceLoggingDataCollector collector, ref UIntPtr[] value)
 569         {
 570             collector.AddArray(value);
 571         }
 572     }
 573
 574     /// <summary>
 575     /// TraceLogging: Type handler for Char[].
 576     /// </summary>
 577     internal sealed class CharArrayTypeInfo
 578         : TraceLoggingTypeInfo<Char[]>
 579     {
 580         public override void WriteMetadata(
 581             TraceLoggingMetadataCollector collector,
 582             string name,
 583             EventFieldFormat format)
 584         {
 585             collector.AddArray(name, Statics.Format16(format, TraceLoggingDataType.Char16));
 586         }
 587
 588         public override void WriteData(TraceLoggingDataCollector collector, ref Char[] value)
 589         {
 590             collector.AddArray(value);
 591         }
 592     }
 593
 594     /// <summary>
 595     /// TraceLogging: Type handler for Double[].
 596     /// </summary>
 597     internal sealed class DoubleArrayTypeInfo
 598         : TraceLoggingTypeInfo<Double[]>
 599     {
 600         public override void WriteMetadata(
 601             TraceLoggingMetadataCollector collector,
 602             string name,
 603             EventFieldFormat format)
 604         {
 605             collector.AddArray(name, Statics.Format64(format, TraceLoggingDataType.Double));
 606         }
 607
 608         public override void WriteData(TraceLoggingDataCollector collector, ref Double[] value)
 609         {
 610             collector.AddArray(value);
 611         }
 612     }
 613
 614     /// <summary>
 615     /// TraceLogging: Type handler for Single[].
 616     /// </summary>
 617     internal sealed class SingleArrayTypeInfo
 618     : TraceLoggingTypeInfo<Single[]>
 619     {
 620         public override void WriteMetadata(
 621             TraceLoggingMetadataCollector collector,
 622             string name,
 623             EventFieldFormat format)
 624         {
 625             collector.AddArray(name, Statics.Format32(format, TraceLoggingDataType.Float));
 626         }
 627
 628         public override void WriteData(TraceLoggingDataCollector collector, ref Single[] value)
 629         {
 630             collector.AddArray(value);
 631         }
 632     }
 633
 634     #endregion
 635
 636     #region Enum scalars
 637
 638     internal sealed class EnumByteTypeInfo<EnumType>
 639         : TraceLoggingTypeInfo<EnumType>
 640     {
 641         public override void WriteMetadata(
 642             TraceLoggingMetadataCollector collector,
 643             string name,
 644             EventFieldFormat format)
 645         {
 646             collector.AddScalar(name, Statics.Format8(format, TraceLoggingDataType.UInt8));
 647         }
 648
 649         public override void WriteData(TraceLoggingDataCollector collector, ref EnumType value)
 650         {
 651             collector.AddScalar(EnumHelper<Byte>.Cast(value));
 652         }
 653
 654         public override object GetData(object value)
 655         {
 656             return value;
 657         }
 658     }
 659
 660     internal sealed class EnumSByteTypeInfo<EnumType>
 661         : TraceLoggingTypeInfo<EnumType>
 662     {
 663         public override void WriteMetadata(
 664             TraceLoggingMetadataCollector collector,
 665             string name,
 666             EventFieldFormat format)
 667         {
 668             collector.AddScalar(name, Statics.Format8(format, TraceLoggingDataType.Int8));
 669         }
 670
 671         public override void WriteData(TraceLoggingDataCollector collector, ref EnumType value)
 672         {
 673             collector.AddScalar(EnumHelper<SByte>.Cast(value));
 674         }
 675
 676         public override object GetData(object value)
 677         {
 678             return value;
 679         }
 680     }
 681
 682     internal sealed class EnumInt16TypeInfo<EnumType>
 683         : TraceLoggingTypeInfo<EnumType>
 684     {
 685         public override void WriteMetadata(
 686             TraceLoggingMetadataCollector collector,
 687             string name,
 688             EventFieldFormat format)
 689         {
 690             collector.AddScalar(name, Statics.Format16(format, TraceLoggingDataType.Int16));
 691         }
 692
 693         public override void WriteData(TraceLoggingDataCollector collector, ref EnumType value)
 694         {
 695             collector.AddScalar(EnumHelper<Int16>.Cast(value));
 696         }
 697
 698         public override object GetData(object value)
 699         {
 700             return value;
 701         }
 702     }
 703
 704     internal sealed class EnumUInt16TypeInfo<EnumType>
 705         : TraceLoggingTypeInfo<EnumType>
 706     {
 707         public override void WriteMetadata(
 708             TraceLoggingMetadataCollector collector,
 709             string name,
 710             EventFieldFormat format)
 711         {
 712             collector.AddScalar(name, Statics.Format16(format, TraceLoggingDataType.UInt16));
 713         }
 714
 715         public override void WriteData(TraceLoggingDataCollector collector, ref EnumType value)
 716         {
 717             collector.AddScalar(EnumHelper<UInt16>.Cast(value));
 718         }
 719
 720         public override object GetData(object value)
 721         {
 722             return value;
 723         }
 724     }
 725
 726     internal sealed class EnumInt32TypeInfo<EnumType>
 727         : TraceLoggingTypeInfo<EnumType>
 728     {
 729         public override void WriteMetadata(
 730             TraceLoggingMetadataCollector collector,
 731             string name,
 732             EventFieldFormat format)
 733         {
 734             collector.AddScalar(name, Statics.Format32(format, TraceLoggingDataType.Int32));
 735         }
 736
 737         public override void WriteData(TraceLoggingDataCollector collector, ref EnumType value)
 738         {
 739             collector.AddScalar(EnumHelper<Int32>.Cast(value));
 740         }
 741
 742         public override object GetData(object value)
 743         {
 744             return value;
 745         }
 746     }
 747
 748     internal sealed class EnumUInt32TypeInfo<EnumType>
 749         : TraceLoggingTypeInfo<EnumType>
 750     {
 751         public override void WriteMetadata(
 752             TraceLoggingMetadataCollector collector,
 753             string name,
 754             EventFieldFormat format)
 755         {
 756             collector.AddScalar(name, Statics.Format32(format, TraceLoggingDataType.UInt32));
 757         }
 758
 759         public override void WriteData(TraceLoggingDataCollector collector, ref EnumType value)
 760         {
 761             collector.AddScalar(EnumHelper<UInt32>.Cast(value));
 762         }
 763
 764         public override object GetData(object value)
 765         {
 766             return value;
 767         }
 768     }
 769
 770     internal sealed class EnumInt64TypeInfo<EnumType>
 771         : TraceLoggingTypeInfo<EnumType>
 772     {
 773         public override void WriteMetadata(
 774             TraceLoggingMetadataCollector collector,
 775             string name,
 776             EventFieldFormat format)
 777         {
 778             collector.AddScalar(name, Statics.Format64(format, TraceLoggingDataType.Int64));
 779         }
 780
 781         public override void WriteData(TraceLoggingDataCollector collector, ref EnumType value)
 782         {
 783             collector.AddScalar(EnumHelper<Int64>.Cast(value));
 784         }
 785
 786         public override object GetData(object value)
 787         {
 788             return value;
 789         }
 790     }
 791
 792     internal sealed class EnumUInt64TypeInfo<EnumType>
 793         : TraceLoggingTypeInfo<EnumType>
 794     {
 795         public override void WriteMetadata(
 796             TraceLoggingMetadataCollector collector,
 797             string name,
 798             EventFieldFormat format)
 799         {
 800             collector.AddScalar(name, Statics.Format64(format, TraceLoggingDataType.UInt64));
 801         }
 802
 803         public override void WriteData(TraceLoggingDataCollector collector, ref EnumType value)
 804         {
 805             collector.AddScalar(EnumHelper<UInt64>.Cast(value));
 806         }
 807
 808         public override object GetData(object value)
 809         {
 810             return value;
 811         }
 812     }
 813
 814     #endregion
 815
 816     #region Other built-in types
 817
 818     /// <summary>
 819     /// TraceLogging: Type handler for String.
 820     /// </summary>
 821     internal sealed class StringTypeInfo
 822         : TraceLoggingTypeInfo<String>
 823     {
 824         public override void WriteMetadata(
 825             TraceLoggingMetadataCollector collector,
 826             string name,
 827             EventFieldFormat format)
 828         {
 829             collector.AddBinary(name, Statics.MakeDataType(TraceLoggingDataType.CountedUtf16String, format));
 830         }
 831
 832         public override void WriteData(TraceLoggingDataCollector collector, ref String value)
 833         {
 834             collector.AddBinary(value);
 835         }
 836
 837         public override object GetData(object value)
 838         {
 839             object val = base.GetData(value);
 840             if (null == val)
 841                 val = "";
 842
 843             return val;
 844         }
 845     }
 846
 847     /// <summary>
 848     /// TraceLogging: Type handler for Guid.
 849     /// </summary>
 850     internal sealed class GuidTypeInfo
 851         : TraceLoggingTypeInfo<Guid>
 852     {
 853         public override void WriteMetadata(
 854             TraceLoggingMetadataCollector collector,
 855             string name,
 856             EventFieldFormat format)
 857         {
 858             collector.AddScalar(name, Statics.MakeDataType(TraceLoggingDataType.Guid, format));
 859         }
 860
 861         public override void WriteData(TraceLoggingDataCollector collector, ref Guid value)
 862         {
 863             collector.AddScalar(value);
 864         }
 865     }
 866
 867     /// <summary>
 868     /// TraceLogging: Type handler for Guid[].
 869     /// </summary>
 870     internal sealed class GuidArrayTypeInfo
 871     : TraceLoggingTypeInfo<Guid[]>
 872     {
 873         public override void WriteMetadata(
 874             TraceLoggingMetadataCollector collector,
 875             string name,
 876             EventFieldFormat format)
 877         {
 878             collector.AddArray(name, Statics.MakeDataType(TraceLoggingDataType.Guid, format));
 879         }
 880
 881         public override void WriteData(TraceLoggingDataCollector collector, ref Guid[] value)
 882         {
 883             collector.AddArray(value);
 884         }
 885     }
 886
 887     /// <summary>
 888     /// TraceLogging: Type handler for DateTime.
 889     /// </summary>
 890     internal sealed class DateTimeTypeInfo
 891         : TraceLoggingTypeInfo<DateTime>
 892     {
 893         public override void WriteMetadata(
 894             TraceLoggingMetadataCollector collector,
 895             string name,
 896             EventFieldFormat format)
 897         {
 898             collector.AddScalar(name, Statics.MakeDataType(TraceLoggingDataType.FileTime, format));
 899         }
 900
 901         public override void WriteData(TraceLoggingDataCollector collector, ref DateTime value)
 902         {
 903             var ticks = value.Ticks;
 904             collector.AddScalar(ticks < 504911232000000000 ? 0 : ticks - 504911232000000000);
 905         }
 906     }
 907
 908     /// <summary>
 909     /// TraceLogging: Type handler for DateTimeOffset.
 910     /// </summary>
 911     internal sealed class DateTimeOffsetTypeInfo
 912         : TraceLoggingTypeInfo<DateTimeOffset>
 913     {
 914         public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
 915         {
 916             var group = collector.AddGroup(name);
 917             group.AddScalar("Ticks", Statics.MakeDataType(TraceLoggingDataType.FileTime, format));
 918             group.AddScalar("Offset", TraceLoggingDataType.Int64);
 919         }
 920
 921         public override void WriteData(TraceLoggingDataCollector collector, ref DateTimeOffset value)
 922         {
 923             var ticks = value.Ticks;
 924             collector.AddScalar(ticks < 504911232000000000 ? 0 : ticks - 504911232000000000);
 925             collector.AddScalar(value.Offset.Ticks);
 926         }
 927     }
 928
 929     /// <summary>
 930     /// TraceLogging: Type handler for TimeSpan.
 931     /// </summary>
 932     internal sealed class TimeSpanTypeInfo
 933         : TraceLoggingTypeInfo<TimeSpan>
 934     {
 935         public override void WriteMetadata(
 936             TraceLoggingMetadataCollector collector,
 937             string name,
 938             EventFieldFormat format)
 939         {
 940             collector.AddScalar(name, Statics.MakeDataType(TraceLoggingDataType.Int64, format));
 941         }
 942
 943         public override void WriteData(TraceLoggingDataCollector collector, ref TimeSpan value)
 944         {
 945             collector.AddScalar(value.Ticks);
 946         }
 947     }
 948
 949     /// <summary>
 950     /// TraceLogging: Type handler for Decimal. (Note: not full-fidelity, exposed as Double.)
 951     /// </summary>
 952     internal sealed class DecimalTypeInfo
 953         : TraceLoggingTypeInfo<Decimal>
 954     {
 955         public override void WriteMetadata(
 956             TraceLoggingMetadataCollector collector,
 957             string name,
 958             EventFieldFormat format)
 959         {
 960             collector.AddScalar(name, Statics.MakeDataType(TraceLoggingDataType.Double, format));
 961         }
 962
 963         public override void WriteData(TraceLoggingDataCollector collector, ref decimal value)
 964         {
 965             collector.AddScalar((double)value);
 966         }
 967     }
 968
 969     /// <summary>
 970     /// TraceLogging: Type handler for KeyValuePair.
 971     /// </summary>
 972     /// <typeparam name="K">Type of the KeyValuePair's Key property.</typeparam>
 973     /// <typeparam name="V">Type of the KeyValuePair's Value property.</typeparam>
 974     internal sealed class KeyValuePairTypeInfo<K, V>
 975         : TraceLoggingTypeInfo<KeyValuePair<K, V>>
 976     {
 977         private readonly TraceLoggingTypeInfo<K> keyInfo;
 978         private readonly TraceLoggingTypeInfo<V> valueInfo;
 979
 980         public KeyValuePairTypeInfo(List<Type> recursionCheck)
 981         {
 982             this.keyInfo = TraceLoggingTypeInfo<K>.GetInstance(recursionCheck);
 983             this.valueInfo = TraceLoggingTypeInfo<V>.GetInstance(recursionCheck);
 984         }
 985
 986         public override void WriteMetadata(
 987             TraceLoggingMetadataCollector collector,
 988             string name,
 989             EventFieldFormat format)
 990         {
 991             var group = collector.AddGroup(name);
 992             this.keyInfo.WriteMetadata(group, "Key", EventFieldFormat.Default);
 993             this.valueInfo.WriteMetadata(group, "Value", format);
 994         }
 995
 996         public override void WriteData(
 997             TraceLoggingDataCollector collector,
 998             ref KeyValuePair<K, V> value)
 999         {
1000             var key = value.Key;
1001             var val = value.Value;
1002             this.keyInfo.WriteData(collector, ref key);
1003             this.valueInfo.WriteData(collector, ref val);
1004         }
1005
1006         public override object GetData(object value)
1007         {
1008             var serializedType = new Dictionary<string, object>();
1009             var keyValuePair = (KeyValuePair<K, V>) value;
1010             serializedType.Add("Key", this.keyInfo.GetData(keyValuePair.Key));
1011             serializedType.Add("Value", this.valueInfo.GetData(keyValuePair.Value));
1012             return serializedType;
1013         }
1014     }
1015
1016     /// <summary>
1017     /// TraceLogging: Type handler for Nullable.
1018     /// </summary>
1019     /// <typeparam name="T">Type of the Nullable's Value property.</typeparam>
1020     internal sealed class NullableTypeInfo<T>
1021         : TraceLoggingTypeInfo<Nullable<T>>
1022         where T : struct
1023     {
1024         private readonly TraceLoggingTypeInfo<T> valueInfo;
1025
1026         public NullableTypeInfo(List<Type> recursionCheck)
1027         {
1028             this.valueInfo = TraceLoggingTypeInfo<T>.GetInstance(recursionCheck);
1029         }
1030
1031         public override void WriteMetadata(
1032             TraceLoggingMetadataCollector collector,
1033             string name,
1034             EventFieldFormat format)
1035         {
1036             var group = collector.AddGroup(name);
1037             group.AddScalar("HasValue", TraceLoggingDataType.Boolean8);
1038             this.valueInfo.WriteMetadata(group, "Value", format);
1039         }
1040
1041         public override void WriteData(
1042             TraceLoggingDataCollector collector,
1043             ref Nullable<T> value)
1044         {
1045             var hasValue = value.HasValue;
1046             collector.AddScalar(hasValue);
1047             var val = hasValue ? value.Value : default(T);
1048             this.valueInfo.WriteData(collector, ref val);
1049         }
1050     }
1051
1052     #endregion
1053 }