private static unsafe void GenerateMetadataForProperty(PropertyAnalysis property, byte *pMetadataBlob, ref uint offset, uint blobSize)
{
Debug.Assert(property != null);
Debug.Assert(pMetadataBlob != null);
// Check if this property is a nested struct.
InvokeTypeInfo invokeTypeInfo = property.typeInfo as InvokeTypeInfo;
if (invokeTypeInfo != null)
{
// Each nested struct is serialized as:
// TypeCode.Object : 4 bytes
// Number of properties : 4 bytes
// Property description 0...N
// Nested struct property name : NULL-terminated string.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)TypeCode.Object);
// Get the set of properties to be serialized.
PropertyAnalysis[] properties = invokeTypeInfo.properties;
if (properties != null)
{
// Write the count of serializable properties.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)properties.Length);
foreach (PropertyAnalysis prop in properties)
{
GenerateMetadataForProperty(prop, pMetadataBlob, ref offset, blobSize);
}
}
else
{
// This struct has zero serializable properties so we just write the property count.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)0);
}
// Write the property name.
fixed(char *pPropertyName = property.name)
{
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (byte *)pPropertyName, ((uint)property.name.Length + 1) * 2);
}
}
else
{
// Each primitive type is serialized as:
// TypeCode : 4 bytes
// PropertyName : NULL-terminated string
TypeCode typeCode = GetTypeCodeExtended(property.typeInfo.DataType);
Debug.Assert(typeCode != TypeCode.Object);
// Write the type code.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)typeCode);
// Write the property name.
fixed(char *pPropertyName = property.name)
{
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (byte *)pPropertyName, ((uint)property.name.Length + 1) * 2);
}
}
}
internal unsafe void GenerateMetadata(byte *pMetadataBlob, ref uint offset, uint blobSize)
{
TypeCode typeCode = GetTypeCodeExtended(ParameterType);
if (typeCode == TypeCode.Object)
{
// Each nested struct is serialized as:
// TypeCode.Object : 4 bytes
// Number of properties : 4 bytes
// Property description 0...N
// Nested struct property name : NULL-terminated string.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)TypeCode.Object);
InvokeTypeInfo invokeTypeInfo = TypeInfo as InvokeTypeInfo;
if (invokeTypeInfo == null)
{
throw new NotSupportedException();
}
// Get the set of properties to be serialized.
PropertyAnalysis[] properties = invokeTypeInfo.properties;
if (properties != null)
{
// Write the count of serializable properties.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)properties.Length);
foreach (PropertyAnalysis prop in properties)
{
GenerateMetadataForProperty(prop, pMetadataBlob, ref offset, blobSize);
}
}
else
{
// This struct has zero serializable properties so we just write the property count.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)0);
}
// Top-level structs don't have a property name, but for simplicity we write a NULL-char to represent the name.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, '\0');
}
else
{
// Write parameter type.
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)typeCode);
// Write parameter name.
fixed(char *pParameterName = ParameterName)
{
EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (byte *)pParameterName, ((uint)ParameterName.Length + 1) * 2);
}
}
}
internal unsafe uint GetMetadataLength()
{
uint ret = 0;
TypeCode typeCode = GetTypeCodeExtended(ParameterType);
if (typeCode == TypeCode.Object)
{
InvokeTypeInfo typeInfo = TypeInfo as InvokeTypeInfo;
if (typeInfo == null)
{
throw new NotSupportedException();
}
// Each nested struct is serialized as:
// TypeCode.Object : 4 bytes
// Number of properties : 4 bytes
// Property description 0...N
// Nested struct property name : NULL-terminated string.
ret += sizeof(uint) // TypeCode
+ sizeof(uint); // Property count
// Get the set of properties to be serialized.
PropertyAnalysis[] properties = typeInfo.properties;
if (properties != null)
{
foreach (PropertyAnalysis prop in properties)
{
ret += GetMetadataLengthForProperty(prop);
}
}
// For simplicity when writing a reader, we write a NULL char
// after the metadata for a top-level struct (for its name) so that
// readers don't have do special case the outer-most struct.
ret += sizeof(char);
}
else
{
ret += (uint)(sizeof(uint) + ((ParameterName.Length + 1) * 2));
}
return(ret);
}
private static uint GetMetadataLengthForProperty(PropertyAnalysis property)
{
Debug.Assert(property != null);
uint ret = 0;
// Check if this property is a nested struct.
InvokeTypeInfo invokeTypeInfo = property.typeInfo as InvokeTypeInfo;
if (invokeTypeInfo != null)
{
// Each nested struct is serialized as:
// TypeCode.Object : 4 bytes
// Number of properties : 4 bytes
// Property description 0...N
// Nested struct property name : NULL-terminated string.
ret += sizeof(uint) // TypeCode
+ sizeof(uint); // Property count
// Get the set of properties to be serialized.
PropertyAnalysis[] properties = invokeTypeInfo.properties;
if (properties != null)
{
foreach (PropertyAnalysis prop in properties)
{
ret += GetMetadataLengthForProperty(prop);
}
}
// Add the size of the property name.
ret += (uint)((property.name.Length + 1) * 2);
}
else
{
ret += (uint)(sizeof(uint) + ((property.name.Length + 1) * 2));
}
return(ret);
}
// Token: 0x060035F1 RID: 13809 RVA: 0x000CF5C0 File Offset: 0x000CD7C0
public static TraceLoggingTypeInfo <DataType> CreateDefaultTypeInfo <DataType>(List <Type> recursionCheck)
{
Type typeFromHandle = typeof(DataType);
if (recursionCheck.Contains(typeFromHandle))
{
throw new NotSupportedException(Environment.GetResourceString("EventSource_RecursiveTypeDefinition"));
}
recursionCheck.Add(typeFromHandle);
EventDataAttribute customAttribute = Statics.GetCustomAttribute <EventDataAttribute>(typeFromHandle);
TraceLoggingTypeInfo traceLoggingTypeInfo;
if (customAttribute != null || Statics.GetCustomAttribute <CompilerGeneratedAttribute>(typeFromHandle) != null)
{
TypeAnalysis typeAnalysis = new TypeAnalysis(typeFromHandle, customAttribute, recursionCheck);
traceLoggingTypeInfo = new InvokeTypeInfo <DataType>(typeAnalysis);
}
else if (typeFromHandle.IsArray)
{
Type elementType = typeFromHandle.GetElementType();
if (elementType == typeof(bool))
{
traceLoggingTypeInfo = new BooleanArrayTypeInfo();
}
else if (elementType == typeof(byte))
{
traceLoggingTypeInfo = new ByteArrayTypeInfo();
}
else if (elementType == typeof(sbyte))
{
traceLoggingTypeInfo = new SByteArrayTypeInfo();
}
else if (elementType == typeof(short))
{
traceLoggingTypeInfo = new Int16ArrayTypeInfo();
}
else if (elementType == typeof(ushort))
{
traceLoggingTypeInfo = new UInt16ArrayTypeInfo();
}
else if (elementType == typeof(int))
{
traceLoggingTypeInfo = new Int32ArrayTypeInfo();
}
else if (elementType == typeof(uint))
{
traceLoggingTypeInfo = new UInt32ArrayTypeInfo();
}
else if (elementType == typeof(long))
{
traceLoggingTypeInfo = new Int64ArrayTypeInfo();
}
else if (elementType == typeof(ulong))
{
traceLoggingTypeInfo = new UInt64ArrayTypeInfo();
}
else if (elementType == typeof(char))
{
traceLoggingTypeInfo = new CharArrayTypeInfo();
}
else if (elementType == typeof(double))
{
traceLoggingTypeInfo = new DoubleArrayTypeInfo();
}
else if (elementType == typeof(float))
{
traceLoggingTypeInfo = new SingleArrayTypeInfo();
}
else if (elementType == typeof(IntPtr))
{
traceLoggingTypeInfo = new IntPtrArrayTypeInfo();
}
else if (elementType == typeof(UIntPtr))
{
traceLoggingTypeInfo = new UIntPtrArrayTypeInfo();
}
else if (elementType == typeof(Guid))
{
traceLoggingTypeInfo = new GuidArrayTypeInfo();
}
else
{
traceLoggingTypeInfo = (TraceLoggingTypeInfo <DataType>)Statics.CreateInstance(typeof(ArrayTypeInfo <>).MakeGenericType(new Type[]
{
elementType
}), new object[]
{
Statics.GetTypeInfoInstance(elementType, recursionCheck)
});
}
}
else if (Statics.IsEnum(typeFromHandle))
{
Type underlyingType = Enum.GetUnderlyingType(typeFromHandle);
if (underlyingType == typeof(int))
{
traceLoggingTypeInfo = new EnumInt32TypeInfo <DataType>();
}
else if (underlyingType == typeof(uint))
{
traceLoggingTypeInfo = new EnumUInt32TypeInfo <DataType>();
}
else if (underlyingType == typeof(byte))
{
traceLoggingTypeInfo = new EnumByteTypeInfo <DataType>();
}
else if (underlyingType == typeof(sbyte))
{
traceLoggingTypeInfo = new EnumSByteTypeInfo <DataType>();
}
else if (underlyingType == typeof(short))
{
traceLoggingTypeInfo = new EnumInt16TypeInfo <DataType>();
}
else if (underlyingType == typeof(ushort))
{
traceLoggingTypeInfo = new EnumUInt16TypeInfo <DataType>();
}
else if (underlyingType == typeof(long))
{
traceLoggingTypeInfo = new EnumInt64TypeInfo <DataType>();
}
else
{
if (!(underlyingType == typeof(ulong)))
{
throw new NotSupportedException(Environment.GetResourceString("EventSource_NotSupportedEnumType", new object[]
{
typeFromHandle.Name,
underlyingType.Name
}));
}
traceLoggingTypeInfo = new EnumUInt64TypeInfo <DataType>();
}
}
else if (typeFromHandle == typeof(string))
{
traceLoggingTypeInfo = new StringTypeInfo();
}
else if (typeFromHandle == typeof(bool))
{
traceLoggingTypeInfo = new BooleanTypeInfo();
}
else if (typeFromHandle == typeof(byte))
{
traceLoggingTypeInfo = new ByteTypeInfo();
}
else if (typeFromHandle == typeof(sbyte))
{
traceLoggingTypeInfo = new SByteTypeInfo();
}
else if (typeFromHandle == typeof(short))
{
traceLoggingTypeInfo = new Int16TypeInfo();
}
else if (typeFromHandle == typeof(ushort))
{
traceLoggingTypeInfo = new UInt16TypeInfo();
}
else if (typeFromHandle == typeof(int))
{
traceLoggingTypeInfo = new Int32TypeInfo();
}
else if (typeFromHandle == typeof(uint))
{
traceLoggingTypeInfo = new UInt32TypeInfo();
}
else if (typeFromHandle == typeof(long))
{
traceLoggingTypeInfo = new Int64TypeInfo();
}
else if (typeFromHandle == typeof(ulong))
{
traceLoggingTypeInfo = new UInt64TypeInfo();
}
else if (typeFromHandle == typeof(char))
{
traceLoggingTypeInfo = new CharTypeInfo();
}
else if (typeFromHandle == typeof(double))
{
traceLoggingTypeInfo = new DoubleTypeInfo();
}
else if (typeFromHandle == typeof(float))
{
traceLoggingTypeInfo = new SingleTypeInfo();
}
else if (typeFromHandle == typeof(DateTime))
{
traceLoggingTypeInfo = new DateTimeTypeInfo();
}
else if (typeFromHandle == typeof(decimal))
{
traceLoggingTypeInfo = new DecimalTypeInfo();
}
else if (typeFromHandle == typeof(IntPtr))
{
traceLoggingTypeInfo = new IntPtrTypeInfo();
}
else if (typeFromHandle == typeof(UIntPtr))
{
traceLoggingTypeInfo = new UIntPtrTypeInfo();
}
else if (typeFromHandle == typeof(Guid))
{
traceLoggingTypeInfo = new GuidTypeInfo();
}
else if (typeFromHandle == typeof(TimeSpan))
{
traceLoggingTypeInfo = new TimeSpanTypeInfo();
}
else if (typeFromHandle == typeof(DateTimeOffset))
{
traceLoggingTypeInfo = new DateTimeOffsetTypeInfo();
}
else if (typeFromHandle == typeof(EmptyStruct))
{
traceLoggingTypeInfo = new NullTypeInfo <EmptyStruct>();
}
else if (Statics.IsGenericMatch(typeFromHandle, typeof(KeyValuePair <, >)))
{
Type[] genericArguments = Statics.GetGenericArguments(typeFromHandle);
traceLoggingTypeInfo = (TraceLoggingTypeInfo <DataType>)Statics.CreateInstance(typeof(KeyValuePairTypeInfo <, >).MakeGenericType(new Type[]
{
genericArguments[0],
genericArguments[1]
}), new object[]
{
recursionCheck
});
}
else if (Statics.IsGenericMatch(typeFromHandle, typeof(Nullable <>)))
{
Type[] genericArguments2 = Statics.GetGenericArguments(typeFromHandle);
traceLoggingTypeInfo = (TraceLoggingTypeInfo <DataType>)Statics.CreateInstance(typeof(NullableTypeInfo <>).MakeGenericType(new Type[]
{
genericArguments2[0]
}), new object[]
{
recursionCheck
});
}
else
{
Type type = Statics.FindEnumerableElementType(typeFromHandle);
if (!(type != null))
{
throw new ArgumentException(Environment.GetResourceString("EventSource_NonCompliantTypeError", new object[]
{
typeFromHandle.Name
}));
}
traceLoggingTypeInfo = (TraceLoggingTypeInfo <DataType>)Statics.CreateInstance(typeof(EnumerableTypeInfo <, >).MakeGenericType(new Type[]
{
typeFromHandle,
type
}), new object[]
{
Statics.GetTypeInfoInstance(type, recursionCheck)
});
}
return((TraceLoggingTypeInfo <DataType>)traceLoggingTypeInfo);
}