/// <summary>
/// Reads a single property signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the signature resides in.</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>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public new static PropertySignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
bool readToEnd,
RecursionProtection protection)
{
var signature = new PropertySignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
};
if (!reader.TryReadCompressedUInt32(out uint paramCount))
{
return(null);
}
signature.PropertyType = TypeSignature.FromReader(image, reader, false, protection);
for (int i = 0; i < paramCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(image, reader, protection));
}
if (readToEnd)
{
signature.ExtraData = reader.ReadToEnd();
}
return(signature);
}
/// <summary>
/// Reads a single method signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the field is defined in.</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>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public new static MethodSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
bool readToEnd,
RecursionProtection protection)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var signature = new MethodSignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
if (signature.IsGeneric)
{
if (!reader.TryReadCompressedUInt32(out uint genericParameterCount))
{
return(signature);
}
signature.GenericParameterCount = (int)genericParameterCount;
}
if (!reader.TryReadCompressedUInt32(out uint parameterCount))
{
return(signature);
}
signature.ReturnType = TypeSignature.FromReader(image, reader);
for (int i = 0; i < parameterCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(image, reader, protection));
}
if (readToEnd)
{
signature.ExtraData = reader.ReadToEnd();
}
return(signature);
}
public new static MethodSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var signature = new MethodSignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
if (signature.IsGeneric)
{
uint genericParameterCount;
if (!reader.TryReadCompressedUInt32(out genericParameterCount))
{
return(signature);
}
signature.GenericParameterCount = (int)genericParameterCount;
}
uint parameterCount;
if (!reader.TryReadCompressedUInt32(out parameterCount))
{
return(signature);
}
signature.ReturnType = TypeSignature.FromReader(header, reader);
for (int i = 0; i < parameterCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(header, reader));
}
return(signature);
}
public new static PropertySignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new PropertySignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
};
uint paramCount;
if (!reader.TryReadCompressedUInt32(out paramCount))
{
return(null);
}
signature.PropertyType = TypeSignature.FromReader(image, reader);
for (int i = 0; i < paramCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(image, reader));
}
return(signature);
}
public int GetParameterIndex(ParameterSignature parameter)
{
return _owner.Method.Signature.Parameters.IndexOf(parameter);
}
public static MsilInstruction Create(MsilOpCode code, ParameterSignature operand)
{
if (code.OperandType != MsilOperandType.InlineArgument && code.OperandType != MsilOperandType.ShortInlineArgument)
throw new ArgumentException("Opcode does not accept a parameter operand.", "code");
return new MsilInstruction(0, code, operand);
}
internal AssemblyParameterDefinition(Symbols.AbstractMethodDefinition method, ParameterSignature signature, ParameterDefinition definition)
{
_method = method;
_signature = signature;
_definition = definition;
}