/// <summary>
/// Constructor
/// </summary>
/// <param name="arrayType">Array type</param>
public ArraySig(TypeSig arrayType)
: base(arrayType)
{
this.sizes = ThreadSafeListCreator.Create <uint>();
this.lowerBounds = ThreadSafeListCreator.Create <int>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="callingConvention">调用约定</param>
/// <param name="genParamCount">通用参数的数量</param>
public MethodSig(CallingConvention callingConvention, uint genParamCount)
{
this.callingConvention = callingConvention;
this.genParamCount = genParamCount;
this.parameters = ThreadSafeListCreator.Create <TypeSig>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="callingConvention">Calling convention (must have Property set)</param>
internal PropertySig(CallingConvention callingConvention)
{
this.callingConvention = callingConvention;
this.parameters = ThreadSafeListCreator.Create <TypeSig>();
}
/// <summary>
/// Gets the locals
/// </summary>
/// <param name="sig">this</param>
/// <returns>All locals</returns>
public static IList <TypeSig> GetLocals(this LocalSig sig)
{
return(sig == null?ThreadSafeListCreator.Create <TypeSig>() : sig.Locals);
}
/// <summary>
/// 默认构造函数
/// </summary>
public MethodSig()
{
this.parameters = ThreadSafeListCreator.Create <TypeSig>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="callingConvention">Calling convention (must have GenericInst set)</param>
/// <param name="size">Number of generic args</param>
internal GenericInstMethodSig(CallingConvention callingConvention, uint size)
{
this.callingConvention = callingConvention;
this.genericArgs = ThreadSafeListCreator.Create <TypeSig>((int)size);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="args">Generic args</param>
public GenericInstMethodSig(IList <TypeSig> args)
{
this.callingConvention = CallingConvention.GenericInst;
this.genericArgs = ThreadSafeListCreator.Create <TypeSig>(args);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="ctor">Custom attribute constructor</param>
/// <param name="arguments">Constructor arguments. The list is now owned by this instance.</param>
/// <param name="namedArguments">Named arguments. The list is now owned by this instance.</param>
/// <param name="blobReader">A reader that returns the original custom attribute blob data</param>
internal CustomAttribute(ICustomAttributeType ctor, List <CAArgument> arguments, List <CANamedArgument> namedArguments, IBinaryReader blobReader)
{
this.ctor = ctor;
this.arguments = arguments == null?ThreadSafeListCreator.Create <CAArgument>() : ThreadSafeListCreator.MakeThreadSafe(arguments);
this.namedArguments = namedArguments == null?ThreadSafeListCreator.Create <CANamedArgument>() : ThreadSafeListCreator.MakeThreadSafe(namedArguments);
this.blobReader = blobReader;
}
/// <summary>
/// Creates a new instruction with an instruction target list operand
/// </summary>
/// <param name="targets">The targets</param>
/// <returns>A new <see cref="Instruction"/> instance</returns>
public Instruction ToInstruction(IList <Instruction> targets)
{
return(Instruction.Create(this, ThreadSafeListCreator.MakeThreadSafe(targets)));
}
/// <summary>Initializes <see cref="overrides"/></summary>
protected virtual void InitializeOverrides()
{
Interlocked.CompareExchange(ref overrides, ThreadSafeListCreator.Create <MethodOverride>(), null);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="ctor">Custom attribute constructor</param>
/// <param name="arguments">Constructor arguments or <c>null</c> if none</param>
/// <param name="namedArguments">Named arguments or <c>null</c> if none</param>
/// <param name="blobReader">A reader that returns the original custom attribute blob data</param>
public CustomAttribute(ICustomAttributeType ctor, IEnumerable <CAArgument> arguments, IEnumerable <CANamedArgument> namedArguments, IBinaryReader blobReader)
{
this.ctor = ctor;
this.arguments = arguments == null?ThreadSafeListCreator.Create <CAArgument>() : ThreadSafeListCreator.Create <CAArgument>(arguments);
this.namedArguments = namedArguments == null?ThreadSafeListCreator.Create <CANamedArgument>() : ThreadSafeListCreator.Create <CANamedArgument>(namedArguments);
this.blobReader = blobReader;
}
/// <summary>Initializes <see cref="customDebugInfos"/></summary>
protected virtual void InitializeCustomDebugInfos()
{
Interlocked.CompareExchange(ref customDebugInfos, ThreadSafeListCreator.Create <PdbCustomDebugInfo>(), null);
}
/// <inheritdoc/>
public override ThreadSafe.IList <int> GetLowerBounds()
{
return(ThreadSafeListCreator.Create <int>());
}
/// <inheritdoc/>
public override ThreadSafe.IList <uint> GetSizes()
{
return(ThreadSafeListCreator.Create <uint>());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="locals">All locals</param>
public LocalSig(IList <TypeSig> locals)
{
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.Create <TypeSig>(locals);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="action">The security action</param>
/// <param name="securityAttrs">The security attributes (now owned by this)</param>
public DeclSecurityUser(SecurityAction action, IList <SecurityAttribute> securityAttrs)
{
this.action = action;
this.securityAttributes = ThreadSafeListCreator.MakeThreadSafe(securityAttrs);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="locals">All locals (this instance now owns it)</param>
/// <param name="dummy">Dummy</param>
internal LocalSig(IList <TypeSig> locals, bool dummy)
{
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.MakeThreadSafe(locals);
}
/// <summary>Initializes <see cref="securityAttributes"/></summary>
protected virtual void InitializeSecurityAttributes()
{
Interlocked.CompareExchange(ref securityAttributes, ThreadSafeListCreator.Create <SecurityAttribute>(), null);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="arg1">Generic arg #1</param>
/// <param name="arg2">Generic arg #2</param>
/// <param name="arg3">Generic arg #3</param>
public GenericInstMethodSig(TypeSig arg1, TypeSig arg2, TypeSig arg3)
{
this.callingConvention = CallingConvention.GenericInst;
this.genericArgs = ThreadSafeListCreator.Create <TypeSig>(arg1, arg2, arg3);
}
/// <summary>Initializes <see cref="declSecurities"/></summary>
protected virtual void InitializeDeclSecurities()
{
Interlocked.CompareExchange(ref declSecurities, ThreadSafeListCreator.Create <DeclSecurity>(), null);
}
/// <summary>
/// Gets the parameters
/// </summary>
/// <param name="sig">this</param>
/// <returns>The parameters</returns>
public static IList <TypeSig> GetParams(this MethodBaseSig sig)
{
return(sig == null?ThreadSafeListCreator.Create <TypeSig>() : sig.Params);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="attrType">Attribute type</param>
/// <param name="namedArguments">Named arguments that will be owned by this instance</param>
public SecurityAttribute(ITypeDefOrRef attrType, IList <CANamedArgument> namedArguments)
{
this.attrType = attrType;
this.namedArguments = ThreadSafeListCreator.MakeThreadSafe(namedArguments ?? new List <CANamedArgument>());
}
/// <summary>
/// Gets the generic arguments
/// </summary>
/// <param name="sig">this</param>
/// <returns>All generic arguments</returns>
public static IList <TypeSig> GetGenericArguments(this GenericInstMethodSig sig)
{
return(sig == null?ThreadSafeListCreator.Create <TypeSig>() : sig.GenericArguments);
}
/// <inheritdoc/>
protected override void InitializeInternal()
{
var hotHeapVersion = GetHotHeapVersion(peImage.FileName, mdHeader.VersionString);
IImageStream imageStream = null, fullStream = null;
DotNetStream dns = null;
List <HotStream> hotStreams = null;
HotStream hotStream = null;
var newAllStreams = new List <DotNetStream>(allStreams);
try
{
var mdRva = cor20Header.MetaData.VirtualAddress;
for (int i = mdHeader.StreamHeaders.Count - 1; i >= 0; i--)
{
var sh = mdHeader.StreamHeaders[i];
var rva = mdRva + sh.Offset;
var fileOffset = peImage.ToFileOffset(rva);
imageStream = peImage.CreateStream(fileOffset, sh.StreamSize);
switch (sh.Name)
{
case "#Strings":
if (stringsStream == null)
{
stringsStream = new StringsStream(imageStream, sh);
imageStream = null;
newAllStreams.Add(stringsStream);
continue;
}
break;
case "#US":
if (usStream == null)
{
usStream = new USStream(imageStream, sh);
imageStream = null;
newAllStreams.Add(usStream);
continue;
}
break;
case "#Blob":
if (blobStream == null)
{
blobStream = new BlobStream(imageStream, sh);
imageStream = null;
newAllStreams.Add(blobStream);
continue;
}
break;
case "#GUID":
if (guidStream == null)
{
guidStream = new GuidStream(imageStream, sh);
imageStream = null;
newAllStreams.Add(guidStream);
continue;
}
break;
case "#~":
if (tablesStream == null)
{
tablesStream = new TablesStream(imageStream, sh);
imageStream = null;
newAllStreams.Add(tablesStream);
continue;
}
break;
case "#!":
if (hotStreams == null)
{
hotStreams = new List <HotStream>();
}
fullStream = peImage.CreateFullStream();
hotStream = HotStream.Create(hotHeapVersion, imageStream, sh, fullStream, fileOffset);
fullStream = null;
hotStreams.Add(hotStream);
newAllStreams.Add(hotStream);
hotStream = null;
imageStream = null;
continue;
}
dns = new DotNetStream(imageStream, sh);
imageStream = null;
newAllStreams.Add(dns);
dns = null;
}
}
finally
{
if (imageStream != null)
{
imageStream.Dispose();
}
if (fullStream != null)
{
fullStream.Dispose();
}
if (dns != null)
{
dns.Dispose();
}
if (hotStream != null)
{
hotStream.Dispose();
}
newAllStreams.Reverse();
allStreams = ThreadSafeListCreator.MakeThreadSafe(newAllStreams);
}
if (tablesStream == null)
{
throw new BadImageFormatException("Missing MD stream");
}
if (hotStreams != null)
{
hotStreams.Reverse();
InitializeHotStreams(hotStreams);
}
tablesStream.Initialize(peImage);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="callingConvention">调用约定</param>
public MethodSig(CallingConvention callingConvention)
{
this.callingConvention = callingConvention;
this.parameters = ThreadSafeListCreator.Create <TypeSig>();
}
/// <summary>
/// Initializes <see cref="otherMethods"/>, <see cref="addMethod"/>,
/// <see cref="invokeMethod"/> and <see cref="removeMethod"/>.
/// </summary>
protected virtual void InitializeEventMethods_NoLock()
{
otherMethods = ThreadSafeListCreator.Create <MethodDef>();
}
/// <summary>
/// Default constructor
/// </summary>
public PropertySig()
{
this.callingConvention = CallingConvention.Property;
this.parameters = ThreadSafeListCreator.Create <TypeSig>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="local1">Local type #1</param>
/// <param name="local2">Local type #2</param>
/// <param name="local3">Local type #3</param>
public LocalSig(TypeSig local1, TypeSig local2, TypeSig local3)
{
this.callingConvention = CallingConvention.LocalSig;
this.locals = ThreadSafeListCreator.Create <TypeSig>(local1, local2, local3);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="hasThis"><c>true</c> if instance, <c>false</c> if static</param>
public PropertySig(bool hasThis)
{
this.callingConvention = CallingConvention.Property | (hasThis ? CallingConvention.HasThis : 0);
this.parameters = ThreadSafeListCreator.Create <TypeSig>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="genericType">The generic type</param>
/// <param name="genArgs">Generic arguments</param>
public GenericInstSig(ClassOrValueTypeSig genericType, IList <TypeSig> genArgs)
{
this.genericType = genericType;
this.genericArgs = ThreadSafeListCreator.Create <TypeSig>(genArgs);
}
