public CustomAttributeNamedArgument(CustomAttributeArgumentMemberType argumentMemberType, TypeSignature argumentType, string memberName, CustomAttributeArgument argument)
{
ArgumentMemberType = argumentMemberType;
ArgumentType = argumentType;
MemberName = memberName;
Argument = argument;
}
public static CustomAttributeArgument FromReader(MetadataHeader header, TypeSignature typeSignature, IBinaryStreamReader reader)
{
var signature = new CustomAttributeArgument()
{
StartOffset = reader.Position,
ArgumentType = typeSignature
};
if (typeSignature.ElementType != ElementType.SzArray)
{
signature.Elements.Add(ElementSignature.FromReader(header, typeSignature, reader));
}
else
{
var arrayType = ((SzArrayTypeSignature)typeSignature).BaseType;
var elementCount = reader.CanRead(sizeof (uint)) ? reader.ReadUInt32() : uint.MaxValue;
if (elementCount != uint.MaxValue)
{
for (uint i = 0; i < elementCount; i++)
{
signature.Elements.Add(ElementSignature.FromReader(header, arrayType, reader));
}
}
}
return signature;
}
public CustomAttributeNamedArgument(CustomAttributeArgumentMemberType argumentMemberType,
TypeSignature argumentType, string memberName, CustomAttributeArgument argument)
{
ArgumentMemberType = argumentMemberType;
ArgumentType = argumentType;
MemberName = memberName;
Argument = argument;
}
public static CustomAttributeNamedArgument FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new CustomAttributeNamedArgument
{
ArgumentMemberType =
(reader.CanRead(sizeof(byte))
? (CustomAttributeArgumentMemberType)reader.ReadByte()
: CustomAttributeArgumentMemberType.Field),
ArgumentType = TypeSignature.ReadFieldOrPropType(image, reader),
MemberName = reader.ReadSerString(),
};
signature.Argument = CustomAttributeArgument.FromReader(image, signature.ArgumentType, reader);
return(signature);
}
/// <summary>
/// Reads a single custom attribute at the current position of the provided stream reader.
/// </summary>
/// <param name="parent">The parent custom attribute the signature is associated to.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="readToEnd">Determines whether any extra data after the signature should be read and
/// put into the <see cref="ExtendableBlobSignature.ExtraData"/> property.</param>
/// <returns>The read argument.</returns>
public static CustomAttributeSignature FromReader(
CustomAttribute parent,
IBinaryStreamReader reader,
bool readToEnd = false)
{
if (!reader.CanRead(sizeof(ushort)) || reader.ReadUInt16() != 0x0001)
{
throw new ArgumentException("Signature doesn't refer to a valid custom attribute signature.");
}
var signature = new CustomAttributeSignature();
if (parent.Constructor?.Signature is MethodSignature methodSignature)
{
foreach (var parameter in methodSignature.Parameters)
{
signature.FixedArguments.Add(CustomAttributeArgument.FromReader(
parent.Image,
parameter.ParameterType,
reader));
}
}
var namedElementCount = reader.CanRead(sizeof(ushort)) ? reader.ReadUInt16() : 0;
for (uint i = 0; i < namedElementCount; i++)
{
signature.NamedArguments.Add(CustomAttributeNamedArgument.FromReader(parent.Image, reader));
}
if (readToEnd)
{
signature.ExtraData = reader.ReadToEnd();
}
return(signature);
}
public static CustomAttributeSignature FromReader(CustomAttribute parent, IBinaryStreamReader reader)
{
long position = reader.Position;
if (!reader.CanRead(sizeof(ushort)) || reader.ReadUInt16() != 0x0001)
{
throw new ArgumentException("Signature doesn't refer to a valid custom attribute signature.");
}
var signature = new CustomAttributeSignature()
{
StartOffset = position,
};
if (parent.Constructor != null)
{
var methodSignature = parent.Constructor.Signature as MethodSignature;
if (methodSignature != null)
{
foreach (var parameter in methodSignature.Parameters)
{
signature.FixedArguments.Add(CustomAttributeArgument.FromReader(parent.Header,
parameter.ParameterType, reader));
}
}
}
var namedElementCount = reader.CanRead(sizeof(ushort)) ? reader.ReadUInt16() : 0;
for (uint i = 0; i < namedElementCount; i++)
{
signature.NamedArguments.Add(CustomAttributeNamedArgument.FromReader(parent.Header, reader));
}
return(signature);
}
public static void ValidateArgument(CustomAttributeArgument originalArgument, CustomAttributeArgument argument)
{
Assert.AreEqual(originalArgument.Elements.Count, argument.Elements.Count);
for (int i = 0; i < originalArgument.Elements.Count; i++)
Assert.AreEqual(originalArgument.Elements[i].Value, argument.Elements[i].Value);
}
