1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Security;
#if ES_BUILD_STANDALONE
namespace Microsoft.Diagnostics.Tracing
#else
namespace System.Diagnostics.Tracing
#endif
{
/// <summary>
/// TraceLogging: Used when implementing a custom TraceLoggingTypeInfo.
/// The instance of this type is provided to the TypeInfo.WriteData method.
/// All operations are forwarded to the current thread's DataCollector.
/// Note that this abstraction would allow us to expose the custom
/// serialization system to partially-trusted code. If we end up not
/// making custom serialization public, or if we only expose it to
/// full-trust code, this abstraction is unnecessary (though it probably
/// doesn't hurt anything).
/// </summary>
[SecuritySafeCritical]
internal unsafe class TraceLoggingDataCollector
{
internal static readonly TraceLoggingDataCollector Instance = new TraceLoggingDataCollector();
private TraceLoggingDataCollector()
{
return;
}
/// <summary>
/// Marks the start of a non-blittable array or enumerable.
/// </summary>
/// <returns>Bookmark to be passed to EndBufferedArray.</returns>
public int BeginBufferedArray()
{
return DataCollector.ThreadInstance.BeginBufferedArray();
}
/// <summary>
/// Marks the end of a non-blittable array or enumerable.
/// </summary>
/// <param name="bookmark">The value returned by BeginBufferedArray.</param>
/// <param name="count">The number of items in the array.</param>
public void EndBufferedArray(int bookmark, int count)
{
DataCollector.ThreadInstance.EndBufferedArray(bookmark, count);
}
/// <summary>
/// Adds the start of a group to the event.
/// This has no effect on the event payload, but is provided to allow
/// WriteMetadata and WriteData implementations to have similar
/// sequences of calls, allowing for easier verification of correctness.
/// </summary>
public TraceLoggingDataCollector AddGroup()
{
return this;
}
public void AddScalar(PropertyValue value)
{
var scalar = value.ScalarValue;
DataCollector.ThreadInstance.AddScalar(&scalar, value.ScalarLength);
}
/// <summary>
/// Adds an Int64 value to the event payload.
/// </summary>
/// <param name="value">Value to be added.</param>
public void AddScalar(long value)
{
DataCollector.ThreadInstance.AddScalar(&value, sizeof(long));
}
/// <summary>
/// Adds a Double value to the event payload.
/// </summary>
/// <param name="value">Value to be added.</param>
public void AddScalar(double value)
{
DataCollector.ThreadInstance.AddScalar(&value, sizeof(double));
}
/// <summary>
/// Adds a counted String value to the event payload.
/// </summary>
/// <param name="value">
/// Value to be added. A null value is treated as a zero-length string.
/// </param>
public void AddBinary(string value)
{
DataCollector.ThreadInstance.AddBinary(value, value == null ? 0 : value.Length * 2);
}
public void AddArray(PropertyValue value, int elementSize)
{
Array array = (Array)value.ReferenceValue;
DataCollector.ThreadInstance.AddArray(array, array == null ? 0 : array.Length, elementSize);
}
}
}
|
