mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
linux-packaging-mono/external/api-snapshot/profiles/net_4_x/Mono.Cecil.cs
Pat Tullmann 0cb742dafb binfmt-detector-cli: rewrite to support PE32+ binaries (#38) 
Rewrite with hard-coded offsets into the PE file format to discern
if a binary is PE32 or PE32+, and then to determine if it contains
a "CLR Data Directory" entry that looks valid.

Tested with PE32 and PE32+ compiled Mono binaries, PE32 and PE32+ native
binaries, and a random assortment of garbage files.

Former-commit-id: 9e7ac86ec84f653a2f79b87183efd5b0ebda001b
2023-10-16 20:16:47 +02:00

2720 lines
148 KiB
C#
Raw Permalink Blame History

// 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.
[assembly:System.Reflection.AssemblyVersionAttribute("0.11.1.0")]
[assembly:System.Diagnostics.DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly:System.Reflection.AssemblyCopyrightAttribute("Copyright © 2008 - 2018 Jb Evain")]
[assembly:System.Reflection.AssemblyFileVersionAttribute("0.11.1.0")]
[assembly:System.Reflection.AssemblyInformationalVersionAttribute("0.11.1.0")]
[assembly:System.Reflection.AssemblyProductAttribute("Mono.Cecil")]
[assembly:System.Reflection.AssemblyTitleAttribute("Mono.Cecil")]
[assembly:System.Runtime.CompilerServices.CompilationRelaxationsAttribute(8)]
[assembly:System.Runtime.CompilerServices.InternalsVisibleToAttribute("Mono.Cecil.Mdb, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")]
[assembly:System.Runtime.CompilerServices.InternalsVisibleToAttribute("Mono.Cecil.Pdb, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")]
[assembly:System.Runtime.CompilerServices.InternalsVisibleToAttribute("Mono.Cecil.Rocks, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")]
[assembly:System.Runtime.CompilerServices.InternalsVisibleToAttribute("Mono.Cecil.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")]
[assembly:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows=true)]
[assembly:System.Runtime.InteropServices.ComVisibleAttribute(false)]
[assembly:System.Runtime.InteropServices.GuidAttribute("fd225bb4-fa53-44b2-a6db-85f5e48dcb54")]
[assembly:System.Security.Permissions.SecurityPermissionAttribute(System.Security.Permissions.SecurityAction.RequestMinimum, SkipVerification=true)]
namespace Mono.Cecil
{
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct ArrayDimension
{
private int _dummyPrimitive;
public ArrayDimension(System.Nullable<int> lowerBound, System.Nullable<int> upperBound) { throw null; }
public bool IsSized { get { throw null; } }
public System.Nullable<int> LowerBound { get { throw null; } set { } }
public System.Nullable<int> UpperBound { get { throw null; } set { } }
public override string ToString() { throw null; }
}
public sealed partial class ArrayMarshalInfo : Mono.Cecil.MarshalInfo
{
public ArrayMarshalInfo() : base (default(Mono.Cecil.NativeType)) { }
public Mono.Cecil.NativeType ElementType { get { throw null; } set { } }
public int Size { get { throw null; } set { } }
public int SizeParameterIndex { get { throw null; } set { } }
public int SizeParameterMultiplier { get { throw null; } set { } }
}
public sealed partial class ArrayType : Mono.Cecil.TypeSpecification
{
public ArrayType(Mono.Cecil.TypeReference type) { }
public ArrayType(Mono.Cecil.TypeReference type, int rank) { }
public Mono.Collections.Generic.Collection<Mono.Cecil.ArrayDimension> Dimensions { get { throw null; } }
public override string FullName { get { throw null; } }
public override bool IsArray { get { throw null; } }
public override bool IsValueType { get { throw null; } set { } }
public bool IsVector { get { throw null; } }
public override string Name { get { throw null; } }
public int Rank { get { throw null; } }
}
[System.FlagsAttribute]
public enum AssemblyAttributes : uint
{
DisableJITCompileOptimizer = (uint)16384,
EnableJITCompileTracking = (uint)32768,
PublicKey = (uint)1,
Retargetable = (uint)256,
SideBySideCompatible = (uint)0,
WindowsRuntime = (uint)512,
}
public sealed partial class AssemblyDefinition : Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.ISecurityDeclarationProvider, System.IDisposable
{
internal AssemblyDefinition() { }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public Mono.Cecil.MethodDefinition EntryPoint { get { throw null; } set { } }
public string FullName { get { throw null; } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasSecurityDeclarations { get { throw null; } }
public Mono.Cecil.ModuleDefinition MainModule { get { throw null; } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.ModuleDefinition> Modules { get { throw null; } }
public Mono.Cecil.AssemblyNameDefinition Name { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.SecurityDeclaration> SecurityDeclarations { get { throw null; } }
public static Mono.Cecil.AssemblyDefinition CreateAssembly(Mono.Cecil.AssemblyNameDefinition assemblyName, string moduleName, Mono.Cecil.ModuleKind kind) { throw null; }
public static Mono.Cecil.AssemblyDefinition CreateAssembly(Mono.Cecil.AssemblyNameDefinition assemblyName, string moduleName, Mono.Cecil.ModuleParameters parameters) { throw null; }
public void Dispose() { }
public static Mono.Cecil.AssemblyDefinition ReadAssembly(System.IO.Stream stream) { throw null; }
public static Mono.Cecil.AssemblyDefinition ReadAssembly(System.IO.Stream stream, Mono.Cecil.ReaderParameters parameters) { throw null; }
public static Mono.Cecil.AssemblyDefinition ReadAssembly(string fileName) { throw null; }
public static Mono.Cecil.AssemblyDefinition ReadAssembly(string fileName, Mono.Cecil.ReaderParameters parameters) { throw null; }
public override string ToString() { throw null; }
public void Write() { }
public void Write(Mono.Cecil.WriterParameters parameters) { }
public void Write(System.IO.Stream stream) { }
public void Write(System.IO.Stream stream, Mono.Cecil.WriterParameters parameters) { }
public void Write(string fileName) { }
public void Write(string fileName, Mono.Cecil.WriterParameters parameters) { }
}
public enum AssemblyHashAlgorithm : uint
{
None = (uint)0,
Reserved = (uint)32771,
SHA1 = (uint)32772,
}
public sealed partial class AssemblyLinkedResource : Mono.Cecil.Resource
{
public AssemblyLinkedResource(string name, Mono.Cecil.ManifestResourceAttributes flags) { }
public AssemblyLinkedResource(string name, Mono.Cecil.ManifestResourceAttributes flags, Mono.Cecil.AssemblyNameReference reference) { }
public Mono.Cecil.AssemblyNameReference Assembly { get { throw null; } set { } }
public override Mono.Cecil.ResourceType ResourceType { get { throw null; } }
}
public sealed partial class AssemblyNameDefinition : Mono.Cecil.AssemblyNameReference
{
public AssemblyNameDefinition(string name, System.Version version) : base (default(string), default(System.Version)) { }
public override byte[] Hash { get { throw null; } }
}
public partial class AssemblyNameReference : Mono.Cecil.IMetadataScope, Mono.Cecil.IMetadataTokenProvider
{
public AssemblyNameReference(string name, System.Version version) { }
public Mono.Cecil.AssemblyAttributes Attributes { get { throw null; } set { } }
public string Culture { get { throw null; } set { } }
public string FullName { get { throw null; } }
public virtual byte[] Hash { get { throw null; } set { } }
public Mono.Cecil.AssemblyHashAlgorithm HashAlgorithm { get { throw null; } set { } }
public bool HasPublicKey { get { throw null; } set { } }
public bool IsRetargetable { get { throw null; } set { } }
public bool IsSideBySideCompatible { get { throw null; } set { } }
public bool IsWindowsRuntime { get { throw null; } set { } }
public virtual Mono.Cecil.MetadataScopeType MetadataScopeType { get { throw null; } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
public string Name { get { throw null; } set { } }
public byte[] PublicKey { get { throw null; } set { } }
public byte[] PublicKeyToken { get { throw null; } set { } }
public System.Version Version { get { throw null; } set { } }
public static Mono.Cecil.AssemblyNameReference Parse(string fullName) { throw null; }
public override string ToString() { throw null; }
}
[System.SerializableAttribute]
public sealed partial class AssemblyResolutionException : System.IO.FileNotFoundException
{
public AssemblyResolutionException(Mono.Cecil.AssemblyNameReference reference) { }
public AssemblyResolutionException(Mono.Cecil.AssemblyNameReference reference, System.Exception innerException) { }
public Mono.Cecil.AssemblyNameReference AssemblyReference { get { throw null; } }
}
public sealed partial class AssemblyResolveEventArgs : System.EventArgs
{
public AssemblyResolveEventArgs(Mono.Cecil.AssemblyNameReference reference) { }
public Mono.Cecil.AssemblyNameReference AssemblyReference { get { throw null; } }
}
public delegate Mono.Cecil.AssemblyDefinition AssemblyResolveEventHandler(object sender, Mono.Cecil.AssemblyNameReference reference);
public abstract partial class BaseAssemblyResolver : Mono.Cecil.IAssemblyResolver, System.IDisposable
{
protected BaseAssemblyResolver() { }
public event Mono.Cecil.AssemblyResolveEventHandler ResolveFailure { add { } remove { } }
public void AddSearchDirectory(string directory) { }
public void Dispose() { }
protected virtual void Dispose(bool disposing) { }
public string[] GetSearchDirectories() { throw null; }
public void RemoveSearchDirectory(string directory) { }
public virtual Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name) { throw null; }
public virtual Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name, Mono.Cecil.ReaderParameters parameters) { throw null; }
protected virtual Mono.Cecil.AssemblyDefinition SearchDirectory(Mono.Cecil.AssemblyNameReference name, System.Collections.Generic.IEnumerable<string> directories, Mono.Cecil.ReaderParameters parameters) { throw null; }
}
public sealed partial class ByReferenceType : Mono.Cecil.TypeSpecification
{
public ByReferenceType(Mono.Cecil.TypeReference type) { }
public override string FullName { get { throw null; } }
public override bool IsByReference { get { throw null; } }
public override bool IsValueType { get { throw null; } set { } }
public override string Name { get { throw null; } }
}
public sealed partial class CallSite : Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.IMethodSignature
{
public CallSite(Mono.Cecil.TypeReference returnType) { }
public Mono.Cecil.MethodCallingConvention CallingConvention { get { throw null; } set { } }
public bool ExplicitThis { get { throw null; } set { } }
public string FullName { get { throw null; } }
public bool HasParameters { get { throw null; } }
public bool HasThis { get { throw null; } set { } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
public Mono.Cecil.MethodReturnType MethodReturnType { get { throw null; } }
public Mono.Cecil.ModuleDefinition Module { get { throw null; } }
public string Name { get { throw null; } set { } }
public string Namespace { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.ParameterDefinition> Parameters { get { throw null; } }
public Mono.Cecil.TypeReference ReturnType { get { throw null; } set { } }
public Mono.Cecil.IMetadataScope Scope { get { throw null; } }
public override string ToString() { throw null; }
}
[System.Diagnostics.DebuggerDisplayAttribute("{AttributeType}")]
public sealed partial class CustomAttribute : Mono.Cecil.ICustomAttribute
{
public CustomAttribute(Mono.Cecil.MethodReference constructor) { }
public CustomAttribute(Mono.Cecil.MethodReference constructor, byte[] blob) { }
public Mono.Cecil.TypeReference AttributeType { get { throw null; } }
public Mono.Cecil.MethodReference Constructor { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeArgument> ConstructorArguments { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeNamedArgument> Fields { get { throw null; } }
public bool HasConstructorArguments { get { throw null; } }
public bool HasFields { get { throw null; } }
public bool HasProperties { get { throw null; } }
public bool IsResolved { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeNamedArgument> Properties { get { throw null; } }
public byte[] GetBlob() { throw null; }
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct CustomAttributeArgument
{
private object _dummy;
public CustomAttributeArgument(Mono.Cecil.TypeReference type, object value) { throw null; }
public Mono.Cecil.TypeReference Type { get { throw null; } }
public object Value { get { throw null; } }
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct CustomAttributeNamedArgument
{
private object _dummy;
public CustomAttributeNamedArgument(string name, Mono.Cecil.CustomAttributeArgument argument) { throw null; }
public Mono.Cecil.CustomAttributeArgument Argument { get { throw null; } }
public string Name { get { throw null; } }
}
public sealed partial class CustomMarshalInfo : Mono.Cecil.MarshalInfo
{
public CustomMarshalInfo() : base (default(Mono.Cecil.NativeType)) { }
public string Cookie { get { throw null; } set { } }
public System.Guid Guid { get { throw null; } set { } }
public Mono.Cecil.TypeReference ManagedType { get { throw null; } set { } }
public string UnmanagedType { get { throw null; } set { } }
}
public partial class DefaultAssemblyResolver : Mono.Cecil.BaseAssemblyResolver
{
public DefaultAssemblyResolver() { }
protected override void Dispose(bool disposing) { }
protected void RegisterAssembly(Mono.Cecil.AssemblyDefinition assembly) { }
public override Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name) { throw null; }
}
public partial class DefaultMetadataImporter : Mono.Cecil.IMetadataImporter
{
protected readonly Mono.Cecil.ModuleDefinition module;
public DefaultMetadataImporter(Mono.Cecil.ModuleDefinition module) { }
public virtual Mono.Cecil.AssemblyNameReference ImportReference(Mono.Cecil.AssemblyNameReference name) { throw null; }
public virtual Mono.Cecil.FieldReference ImportReference(Mono.Cecil.FieldReference field, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public virtual Mono.Cecil.MethodReference ImportReference(Mono.Cecil.MethodReference method, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public virtual Mono.Cecil.TypeReference ImportReference(Mono.Cecil.TypeReference type, Mono.Cecil.IGenericParameterProvider context) { throw null; }
protected Mono.Cecil.IMetadataScope ImportScope(Mono.Cecil.IMetadataScope scope) { throw null; }
protected virtual Mono.Cecil.IMetadataScope ImportScope(Mono.Cecil.TypeReference type) { throw null; }
}
public partial class DefaultReflectionImporter : Mono.Cecil.IReflectionImporter
{
protected readonly Mono.Cecil.ModuleDefinition module;
public DefaultReflectionImporter(Mono.Cecil.ModuleDefinition module) { }
public virtual Mono.Cecil.AssemblyNameReference ImportReference(System.Reflection.AssemblyName name) { throw null; }
public virtual Mono.Cecil.FieldReference ImportReference(System.Reflection.FieldInfo field, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public virtual Mono.Cecil.MethodReference ImportReference(System.Reflection.MethodBase method, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public virtual Mono.Cecil.TypeReference ImportReference(System.Type type, Mono.Cecil.IGenericParameterProvider context) { throw null; }
protected Mono.Cecil.AssemblyNameReference ImportScope(System.Reflection.Assembly assembly) { throw null; }
protected virtual Mono.Cecil.IMetadataScope ImportScope(System.Type type) { throw null; }
}
public sealed partial class EmbeddedResource : Mono.Cecil.Resource
{
public EmbeddedResource(string name, Mono.Cecil.ManifestResourceAttributes attributes, byte[] data) { }
public EmbeddedResource(string name, Mono.Cecil.ManifestResourceAttributes attributes, System.IO.Stream stream) { }
public override Mono.Cecil.ResourceType ResourceType { get { throw null; } }
public byte[] GetResourceData() { throw null; }
public System.IO.Stream GetResourceStream() { throw null; }
}
[System.FlagsAttribute]
public enum EventAttributes : ushort
{
None = (ushort)0,
RTSpecialName = (ushort)1024,
SpecialName = (ushort)512,
}
public sealed partial class EventDefinition : Mono.Cecil.EventReference, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider
{
public EventDefinition(string name, Mono.Cecil.EventAttributes attributes, Mono.Cecil.TypeReference eventType) : base (default(string), default(Mono.Cecil.TypeReference)) { }
public Mono.Cecil.MethodDefinition AddMethod { get { throw null; } set { } }
public Mono.Cecil.EventAttributes Attributes { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasOtherMethods { get { throw null; } }
public Mono.Cecil.MethodDefinition InvokeMethod { get { throw null; } set { } }
public override bool IsDefinition { get { throw null; } }
public bool IsRuntimeSpecialName { get { throw null; } set { } }
public bool IsSpecialName { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.MethodDefinition> OtherMethods { get { throw null; } }
public Mono.Cecil.MethodDefinition RemoveMethod { get { throw null; } set { } }
public override Mono.Cecil.EventDefinition Resolve() { throw null; }
}
public abstract partial class EventReference : Mono.Cecil.MemberReference
{
protected EventReference(string name, Mono.Cecil.TypeReference eventType) { }
public Mono.Cecil.TypeReference EventType { get { throw null; } set { } }
public override string FullName { get { throw null; } }
public abstract new Mono.Cecil.EventDefinition Resolve();
protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; }
}
public sealed partial class ExportedType : Mono.Cecil.IMetadataTokenProvider
{
public ExportedType(string @namespace, string name, Mono.Cecil.ModuleDefinition module, Mono.Cecil.IMetadataScope scope) { }
public Mono.Cecil.TypeAttributes Attributes { get { throw null; } set { } }
public Mono.Cecil.ExportedType DeclaringType { get { throw null; } set { } }
public string FullName { get { throw null; } }
public bool HasSecurity { get { throw null; } set { } }
public int Identifier { get { throw null; } set { } }
public bool IsAbstract { get { throw null; } set { } }
public bool IsAnsiClass { get { throw null; } set { } }
public bool IsAutoClass { get { throw null; } set { } }
public bool IsAutoLayout { get { throw null; } set { } }
public bool IsBeforeFieldInit { get { throw null; } set { } }
public bool IsClass { get { throw null; } set { } }
public bool IsExplicitLayout { get { throw null; } set { } }
public bool IsForwarder { get { throw null; } set { } }
public bool IsImport { get { throw null; } set { } }
public bool IsInterface { get { throw null; } set { } }
public bool IsNestedAssembly { get { throw null; } set { } }
public bool IsNestedFamily { get { throw null; } set { } }
public bool IsNestedFamilyAndAssembly { get { throw null; } set { } }
public bool IsNestedFamilyOrAssembly { get { throw null; } set { } }
public bool IsNestedPrivate { get { throw null; } set { } }
public bool IsNestedPublic { get { throw null; } set { } }
public bool IsNotPublic { get { throw null; } set { } }
public bool IsPublic { get { throw null; } set { } }
public bool IsRuntimeSpecialName { get { throw null; } set { } }
public bool IsSealed { get { throw null; } set { } }
public bool IsSequentialLayout { get { throw null; } set { } }
public bool IsSerializable { get { throw null; } set { } }
public bool IsSpecialName { get { throw null; } set { } }
public bool IsUnicodeClass { get { throw null; } set { } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
public string Name { get { throw null; } set { } }
public string Namespace { get { throw null; } set { } }
public Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } }
public Mono.Cecil.TypeDefinition Resolve() { throw null; }
public override string ToString() { throw null; }
}
[System.FlagsAttribute]
public enum FieldAttributes : ushort
{
Assembly = (ushort)3,
CompilerControlled = (ushort)0,
FamANDAssem = (ushort)2,
Family = (ushort)4,
FamORAssem = (ushort)5,
FieldAccessMask = (ushort)7,
HasDefault = (ushort)32768,
HasFieldMarshal = (ushort)4096,
HasFieldRVA = (ushort)256,
InitOnly = (ushort)32,
Literal = (ushort)64,
NotSerialized = (ushort)128,
PInvokeImpl = (ushort)8192,
Private = (ushort)1,
Public = (ushort)6,
RTSpecialName = (ushort)1024,
SpecialName = (ushort)512,
Static = (ushort)16,
}
public sealed partial class FieldDefinition : Mono.Cecil.FieldReference, Mono.Cecil.IConstantProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMarshalInfoProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider
{
public FieldDefinition(string name, Mono.Cecil.FieldAttributes attributes, Mono.Cecil.TypeReference fieldType) : base (default(string), default(Mono.Cecil.TypeReference)) { }
public Mono.Cecil.FieldAttributes Attributes { get { throw null; } set { } }
public object Constant { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } }
public bool HasConstant { get { throw null; } set { } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasDefault { get { throw null; } set { } }
public bool HasLayoutInfo { get { throw null; } }
public bool HasMarshalInfo { get { throw null; } }
public byte[] InitialValue { get { throw null; } set { } }
public bool IsAssembly { get { throw null; } set { } }
public bool IsCompilerControlled { get { throw null; } set { } }
public override bool IsDefinition { get { throw null; } }
public bool IsFamily { get { throw null; } set { } }
public bool IsFamilyAndAssembly { get { throw null; } set { } }
public bool IsFamilyOrAssembly { get { throw null; } set { } }
public bool IsInitOnly { get { throw null; } set { } }
public bool IsLiteral { get { throw null; } set { } }
public bool IsNotSerialized { get { throw null; } set { } }
public bool IsPInvokeImpl { get { throw null; } set { } }
public bool IsPrivate { get { throw null; } set { } }
public bool IsPublic { get { throw null; } set { } }
public bool IsRuntimeSpecialName { get { throw null; } set { } }
public bool IsSpecialName { get { throw null; } set { } }
public bool IsStatic { get { throw null; } set { } }
public Mono.Cecil.MarshalInfo MarshalInfo { get { throw null; } set { } }
public int Offset { get { throw null; } set { } }
public int RVA { get { throw null; } }
public override Mono.Cecil.FieldDefinition Resolve() { throw null; }
}
public partial class FieldReference : Mono.Cecil.MemberReference
{
public FieldReference(string name, Mono.Cecil.TypeReference fieldType) { }
public FieldReference(string name, Mono.Cecil.TypeReference fieldType, Mono.Cecil.TypeReference declaringType) { }
public override bool ContainsGenericParameter { get { throw null; } }
public Mono.Cecil.TypeReference FieldType { get { throw null; } set { } }
public override string FullName { get { throw null; } }
public virtual new Mono.Cecil.FieldDefinition Resolve() { throw null; }
protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; }
}
public sealed partial class FixedArrayMarshalInfo : Mono.Cecil.MarshalInfo
{
public FixedArrayMarshalInfo() : base (default(Mono.Cecil.NativeType)) { }
public Mono.Cecil.NativeType ElementType { get { throw null; } set { } }
public int Size { get { throw null; } set { } }
}
public sealed partial class FixedSysStringMarshalInfo : Mono.Cecil.MarshalInfo
{
public FixedSysStringMarshalInfo() : base (default(Mono.Cecil.NativeType)) { }
public int Size { get { throw null; } set { } }
}
public sealed partial class FunctionPointerType : Mono.Cecil.TypeSpecification, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.IMethodSignature
{
public FunctionPointerType() { }
public Mono.Cecil.MethodCallingConvention CallingConvention { get { throw null; } set { } }
public override bool ContainsGenericParameter { get { throw null; } }
public bool ExplicitThis { get { throw null; } set { } }
public override string FullName { get { throw null; } }
public bool HasParameters { get { throw null; } }
public bool HasThis { get { throw null; } set { } }
public override bool IsFunctionPointer { get { throw null; } }
public Mono.Cecil.MethodReturnType MethodReturnType { get { throw null; } }
public override Mono.Cecil.ModuleDefinition Module { get { throw null; } }
public override string Name { get { throw null; } set { } }
public override string Namespace { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.ParameterDefinition> Parameters { get { throw null; } }
public Mono.Cecil.TypeReference ReturnType { get { throw null; } set { } }
public override Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } }
public override Mono.Cecil.TypeReference GetElementType() { throw null; }
public override Mono.Cecil.TypeDefinition Resolve() { throw null; }
}
public sealed partial class GenericInstanceMethod : Mono.Cecil.MethodSpecification, Mono.Cecil.IGenericInstance, Mono.Cecil.IMetadataTokenProvider
{
public GenericInstanceMethod(Mono.Cecil.MethodReference method) { }
public override bool ContainsGenericParameter { get { throw null; } }
public override string FullName { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.TypeReference> GenericArguments { get { throw null; } }
public bool HasGenericArguments { get { throw null; } }
public override bool IsGenericInstance { get { throw null; } }
}
public sealed partial class GenericInstanceType : Mono.Cecil.TypeSpecification, Mono.Cecil.IGenericInstance, Mono.Cecil.IMetadataTokenProvider
{
public GenericInstanceType(Mono.Cecil.TypeReference type) { }
public override bool ContainsGenericParameter { get { throw null; } }
public override Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } }
public override string FullName { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.TypeReference> GenericArguments { get { throw null; } }
public bool HasGenericArguments { get { throw null; } }
public override bool IsGenericInstance { get { throw null; } }
}
public sealed partial class GenericParameter : Mono.Cecil.TypeReference, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider
{
public GenericParameter(Mono.Cecil.IGenericParameterProvider owner) : base (default(string), default(string)) { }
public GenericParameter(string name, Mono.Cecil.IGenericParameterProvider owner) : base (default(string), default(string)) { }
public Mono.Cecil.GenericParameterAttributes Attributes { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.GenericParameterConstraint> Constraints { get { throw null; } }
public override bool ContainsGenericParameter { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public Mono.Cecil.MethodReference DeclaringMethod { get { throw null; } }
public override Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } }
public override string FullName { get { throw null; } }
public bool HasConstraints { get { throw null; } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasDefaultConstructorConstraint { get { throw null; } set { } }
public bool HasNotNullableValueTypeConstraint { get { throw null; } set { } }
public bool HasReferenceTypeConstraint { get { throw null; } set { } }
public bool IsContravariant { get { throw null; } set { } }
public bool IsCovariant { get { throw null; } set { } }
public override bool IsGenericParameter { get { throw null; } }
public bool IsNonVariant { get { throw null; } set { } }
public override Mono.Cecil.MetadataType MetadataType { get { throw null; } }
public override Mono.Cecil.ModuleDefinition Module { get { throw null; } }
public override string Name { get { throw null; } }
public override string Namespace { get { throw null; } set { } }
public Mono.Cecil.IGenericParameterProvider Owner { get { throw null; } }
public int Position { get { throw null; } }
public override Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } }
public Mono.Cecil.GenericParameterType Type { get { throw null; } }
public override Mono.Cecil.TypeDefinition Resolve() { throw null; }
}
[System.FlagsAttribute]
public enum GenericParameterAttributes : ushort
{
Contravariant = (ushort)2,
Covariant = (ushort)1,
DefaultConstructorConstraint = (ushort)16,
NonVariant = (ushort)0,
NotNullableValueTypeConstraint = (ushort)8,
ReferenceTypeConstraint = (ushort)4,
SpecialConstraintMask = (ushort)28,
VarianceMask = (ushort)3,
}
public sealed partial class GenericParameterConstraint : Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider
{
public GenericParameterConstraint(Mono.Cecil.TypeReference constraintType) { }
public Mono.Cecil.TypeReference ConstraintType { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public bool HasCustomAttributes { get { throw null; } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
}
public enum GenericParameterType
{
Method = 1,
Type = 0,
}
public partial interface IAssemblyResolver : System.IDisposable
{
Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name);
Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name, Mono.Cecil.ReaderParameters parameters);
}
public partial interface IConstantProvider : Mono.Cecil.IMetadataTokenProvider
{
object Constant { get; set; }
bool HasConstant { get; set; }
}
public partial interface ICustomAttribute
{
Mono.Cecil.TypeReference AttributeType { get; }
Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeArgument> ConstructorArguments { get; }
Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeNamedArgument> Fields { get; }
bool HasConstructorArguments { get; }
bool HasFields { get; }
bool HasProperties { get; }
Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeNamedArgument> Properties { get; }
}
public partial interface ICustomAttributeProvider : Mono.Cecil.IMetadataTokenProvider
{
Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get; }
bool HasCustomAttributes { get; }
}
public partial interface IGenericInstance : Mono.Cecil.IMetadataTokenProvider
{
Mono.Collections.Generic.Collection<Mono.Cecil.TypeReference> GenericArguments { get; }
bool HasGenericArguments { get; }
}
public partial interface IGenericParameterProvider : Mono.Cecil.IMetadataTokenProvider
{
Mono.Collections.Generic.Collection<Mono.Cecil.GenericParameter> GenericParameters { get; }
Mono.Cecil.GenericParameterType GenericParameterType { get; }
bool HasGenericParameters { get; }
bool IsDefinition { get; }
Mono.Cecil.ModuleDefinition Module { get; }
}
public partial interface IMarshalInfoProvider : Mono.Cecil.IMetadataTokenProvider
{
bool HasMarshalInfo { get; }
Mono.Cecil.MarshalInfo MarshalInfo { get; set; }
}
public partial interface IMemberDefinition : Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider
{
Mono.Cecil.TypeDefinition DeclaringType { get; set; }
string FullName { get; }
bool IsRuntimeSpecialName { get; set; }
bool IsSpecialName { get; set; }
string Name { get; set; }
}
public partial interface IMetadataImporter
{
Mono.Cecil.AssemblyNameReference ImportReference(Mono.Cecil.AssemblyNameReference reference);
Mono.Cecil.FieldReference ImportReference(Mono.Cecil.FieldReference field, Mono.Cecil.IGenericParameterProvider context);
Mono.Cecil.MethodReference ImportReference(Mono.Cecil.MethodReference method, Mono.Cecil.IGenericParameterProvider context);
Mono.Cecil.TypeReference ImportReference(Mono.Cecil.TypeReference type, Mono.Cecil.IGenericParameterProvider context);
}
public partial interface IMetadataImporterProvider
{
Mono.Cecil.IMetadataImporter GetMetadataImporter(Mono.Cecil.ModuleDefinition module);
}
public partial interface IMetadataResolver
{
Mono.Cecil.FieldDefinition Resolve(Mono.Cecil.FieldReference field);
Mono.Cecil.MethodDefinition Resolve(Mono.Cecil.MethodReference method);
Mono.Cecil.TypeDefinition Resolve(Mono.Cecil.TypeReference type);
}
public partial interface IMetadataScope : Mono.Cecil.IMetadataTokenProvider
{
Mono.Cecil.MetadataScopeType MetadataScopeType { get; }
string Name { get; set; }
}
public partial interface IMetadataTokenProvider
{
Mono.Cecil.MetadataToken MetadataToken { get; set; }
}
public partial interface IMethodSignature : Mono.Cecil.IMetadataTokenProvider
{
Mono.Cecil.MethodCallingConvention CallingConvention { get; set; }
bool ExplicitThis { get; set; }
bool HasParameters { get; }
bool HasThis { get; set; }
Mono.Cecil.MethodReturnType MethodReturnType { get; }
Mono.Collections.Generic.Collection<Mono.Cecil.ParameterDefinition> Parameters { get; }
Mono.Cecil.TypeReference ReturnType { get; set; }
}
public partial interface IModifierType
{
Mono.Cecil.TypeReference ElementType { get; }
Mono.Cecil.TypeReference ModifierType { get; }
}
public sealed partial class InterfaceImplementation : Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider
{
public InterfaceImplementation(Mono.Cecil.TypeReference interfaceType) { }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public bool HasCustomAttributes { get { throw null; } }
public Mono.Cecil.TypeReference InterfaceType { get { throw null; } set { } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
}
public partial interface IReflectionImporter
{
Mono.Cecil.AssemblyNameReference ImportReference(System.Reflection.AssemblyName reference);
Mono.Cecil.FieldReference ImportReference(System.Reflection.FieldInfo field, Mono.Cecil.IGenericParameterProvider context);
Mono.Cecil.MethodReference ImportReference(System.Reflection.MethodBase method, Mono.Cecil.IGenericParameterProvider context);
Mono.Cecil.TypeReference ImportReference(System.Type type, Mono.Cecil.IGenericParameterProvider context);
}
public partial interface IReflectionImporterProvider
{
Mono.Cecil.IReflectionImporter GetReflectionImporter(Mono.Cecil.ModuleDefinition module);
}
public partial interface ISecurityDeclarationProvider : Mono.Cecil.IMetadataTokenProvider
{
bool HasSecurityDeclarations { get; }
Mono.Collections.Generic.Collection<Mono.Cecil.SecurityDeclaration> SecurityDeclarations { get; }
}
public sealed partial class LinkedResource : Mono.Cecil.Resource
{
public LinkedResource(string name, Mono.Cecil.ManifestResourceAttributes flags) { }
public LinkedResource(string name, Mono.Cecil.ManifestResourceAttributes flags, string file) { }
public string File { get { throw null; } set { } }
public byte[] Hash { get { throw null; } }
public override Mono.Cecil.ResourceType ResourceType { get { throw null; } }
}
[System.FlagsAttribute]
public enum ManifestResourceAttributes : uint
{
Private = (uint)2,
Public = (uint)1,
VisibilityMask = (uint)7,
}
public partial class MarshalInfo
{
public MarshalInfo(Mono.Cecil.NativeType native) { }
public Mono.Cecil.NativeType NativeType { get { throw null; } set { } }
}
public abstract partial class MemberReference : Mono.Cecil.IMetadataTokenProvider
{
internal MemberReference() { }
public virtual bool ContainsGenericParameter { get { throw null; } }
public virtual Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } }
public abstract string FullName { get; }
public virtual bool IsDefinition { get { throw null; } }
public bool IsWindowsRuntimeProjection { get { throw null; } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
public virtual Mono.Cecil.ModuleDefinition Module { get { throw null; } }
public virtual string Name { get { throw null; } set { } }
public Mono.Cecil.IMemberDefinition Resolve() { throw null; }
protected abstract Mono.Cecil.IMemberDefinition ResolveDefinition();
public override string ToString() { throw null; }
}
public enum MetadataKind
{
Ecma335 = 0,
ManagedWindowsMetadata = 2,
WindowsMetadata = 1,
}
public partial class MetadataResolver : Mono.Cecil.IMetadataResolver
{
public MetadataResolver(Mono.Cecil.IAssemblyResolver assemblyResolver) { }
public Mono.Cecil.IAssemblyResolver AssemblyResolver { get { throw null; } }
public static Mono.Cecil.MethodDefinition GetMethod(Mono.Collections.Generic.Collection<Mono.Cecil.MethodDefinition> methods, Mono.Cecil.MethodReference reference) { throw null; }
public virtual Mono.Cecil.FieldDefinition Resolve(Mono.Cecil.FieldReference field) { throw null; }
public virtual Mono.Cecil.MethodDefinition Resolve(Mono.Cecil.MethodReference method) { throw null; }
public virtual Mono.Cecil.TypeDefinition Resolve(Mono.Cecil.TypeReference type) { throw null; }
}
public enum MetadataScopeType
{
AssemblyNameReference = 0,
ModuleDefinition = 2,
ModuleReference = 1,
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct MetadataToken : System.IEquatable<Mono.Cecil.MetadataToken>
{
private int _dummyPrimitive;
public static readonly Mono.Cecil.MetadataToken Zero;
public MetadataToken(Mono.Cecil.TokenType type) { throw null; }
public MetadataToken(Mono.Cecil.TokenType type, int rid) { throw null; }
public MetadataToken(Mono.Cecil.TokenType type, uint rid) { throw null; }
public MetadataToken(uint token) { throw null; }
public uint RID { get { throw null; } }
public Mono.Cecil.TokenType TokenType { get { throw null; } }
public bool Equals(Mono.Cecil.MetadataToken other) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public static bool operator ==(Mono.Cecil.MetadataToken one, Mono.Cecil.MetadataToken other) { throw null; }
public static bool operator !=(Mono.Cecil.MetadataToken one, Mono.Cecil.MetadataToken other) { throw null; }
public int ToInt32() { throw null; }
public override string ToString() { throw null; }
public uint ToUInt32() { throw null; }
}
public enum MetadataType : byte
{
Array = (byte)20,
Boolean = (byte)2,
ByReference = (byte)16,
Byte = (byte)5,
Char = (byte)3,
Class = (byte)18,
Double = (byte)13,
FunctionPointer = (byte)27,
GenericInstance = (byte)21,
Int16 = (byte)6,
Int32 = (byte)8,
Int64 = (byte)10,
IntPtr = (byte)24,
MVar = (byte)30,
Object = (byte)28,
OptionalModifier = (byte)32,
Pinned = (byte)69,
Pointer = (byte)15,
RequiredModifier = (byte)31,
SByte = (byte)4,
Sentinel = (byte)65,
Single = (byte)12,
String = (byte)14,
TypedByReference = (byte)22,
UInt16 = (byte)7,
UInt32 = (byte)9,
UInt64 = (byte)11,
UIntPtr = (byte)25,
ValueType = (byte)17,
Var = (byte)19,
Void = (byte)1,
}
[System.FlagsAttribute]
public enum MethodAttributes : ushort
{
Abstract = (ushort)1024,
Assembly = (ushort)3,
CheckAccessOnOverride = (ushort)512,
CompilerControlled = (ushort)0,
FamANDAssem = (ushort)2,
Family = (ushort)4,
FamORAssem = (ushort)5,
Final = (ushort)32,
HasSecurity = (ushort)16384,
HideBySig = (ushort)128,
MemberAccessMask = (ushort)7,
NewSlot = (ushort)256,
PInvokeImpl = (ushort)8192,
Private = (ushort)1,
Public = (ushort)6,
RequireSecObject = (ushort)32768,
ReuseSlot = (ushort)0,
RTSpecialName = (ushort)4096,
SpecialName = (ushort)2048,
Static = (ushort)16,
UnmanagedExport = (ushort)8,
Virtual = (ushort)64,
VtableLayoutMask = (ushort)256,
}
public enum MethodCallingConvention : byte
{
C = (byte)1,
Default = (byte)0,
FastCall = (byte)4,
Generic = (byte)16,
StdCall = (byte)2,
ThisCall = (byte)3,
VarArg = (byte)5,
}
public sealed partial class MethodDefinition : Mono.Cecil.MethodReference, Mono.Cecil.Cil.ICustomDebugInformationProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.ISecurityDeclarationProvider
{
public MethodDefinition(string name, Mono.Cecil.MethodAttributes attributes, Mono.Cecil.TypeReference returnType) : base (default(string), default(Mono.Cecil.TypeReference)) { }
public bool AggressiveInlining { get { throw null; } set { } }
public Mono.Cecil.MethodAttributes Attributes { get { throw null; } set { } }
public Mono.Cecil.Cil.MethodBody Body { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.CustomDebugInformation> CustomDebugInformations { get { throw null; } }
public Mono.Cecil.Cil.MethodDebugInformation DebugInformation { get { throw null; } set { } }
public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } }
public override Mono.Collections.Generic.Collection<Mono.Cecil.GenericParameter> GenericParameters { get { throw null; } }
public bool HasBody { get { throw null; } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasCustomDebugInformations { get { throw null; } }
public override bool HasGenericParameters { get { throw null; } }
public bool HasOverrides { get { throw null; } }
public bool HasPInvokeInfo { get { throw null; } }
public bool HasSecurity { get { throw null; } set { } }
public bool HasSecurityDeclarations { get { throw null; } }
public Mono.Cecil.MethodImplAttributes ImplAttributes { get { throw null; } set { } }
public bool IsAbstract { get { throw null; } set { } }
public bool IsAddOn { get { throw null; } set { } }
public bool IsAssembly { get { throw null; } set { } }
public bool IsCheckAccessOnOverride { get { throw null; } set { } }
public bool IsCompilerControlled { get { throw null; } set { } }
public bool IsConstructor { get { throw null; } }
public override bool IsDefinition { get { throw null; } }
public bool IsFamily { get { throw null; } set { } }
public bool IsFamilyAndAssembly { get { throw null; } set { } }
public bool IsFamilyOrAssembly { get { throw null; } set { } }
public bool IsFinal { get { throw null; } set { } }
public bool IsFire { get { throw null; } set { } }
public bool IsForwardRef { get { throw null; } set { } }
public bool IsGetter { get { throw null; } set { } }
public bool IsHideBySig { get { throw null; } set { } }
public bool IsIL { get { throw null; } set { } }
public bool IsInternalCall { get { throw null; } set { } }
public bool IsManaged { get { throw null; } set { } }
public bool IsNative { get { throw null; } set { } }
public bool IsNewSlot { get { throw null; } set { } }
public bool IsOther { get { throw null; } set { } }
public bool IsPInvokeImpl { get { throw null; } set { } }
public bool IsPreserveSig { get { throw null; } set { } }
public bool IsPrivate { get { throw null; } set { } }
public bool IsPublic { get { throw null; } set { } }
public bool IsRemoveOn { get { throw null; } set { } }
public bool IsReuseSlot { get { throw null; } set { } }
public bool IsRuntime { get { throw null; } set { } }
public bool IsRuntimeSpecialName { get { throw null; } set { } }
public bool IsSetter { get { throw null; } set { } }
public bool IsSpecialName { get { throw null; } set { } }
public bool IsStatic { get { throw null; } set { } }
public bool IsSynchronized { get { throw null; } set { } }
public bool IsUnmanaged { get { throw null; } set { } }
public bool IsUnmanagedExport { get { throw null; } set { } }
public bool IsVirtual { get { throw null; } set { } }
public override string Name { get { throw null; } set { } }
public bool NoInlining { get { throw null; } set { } }
public bool NoOptimization { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.MethodReference> Overrides { get { throw null; } }
public Mono.Cecil.PInvokeInfo PInvokeInfo { get { throw null; } set { } }
public int RVA { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.SecurityDeclaration> SecurityDeclarations { get { throw null; } }
public Mono.Cecil.MethodSemanticsAttributes SemanticsAttributes { get { throw null; } set { } }
public override Mono.Cecil.MethodDefinition Resolve() { throw null; }
}
[System.FlagsAttribute]
public enum MethodImplAttributes : ushort
{
AggressiveInlining = (ushort)256,
CodeTypeMask = (ushort)3,
ForwardRef = (ushort)16,
IL = (ushort)0,
InternalCall = (ushort)4096,
Managed = (ushort)0,
ManagedMask = (ushort)4,
Native = (ushort)1,
NoInlining = (ushort)8,
NoOptimization = (ushort)64,
OPTIL = (ushort)2,
PreserveSig = (ushort)128,
Runtime = (ushort)3,
Synchronized = (ushort)32,
Unmanaged = (ushort)4,
}
public partial class MethodReference : Mono.Cecil.MemberReference, Mono.Cecil.IGenericParameterProvider, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.IMethodSignature
{
public MethodReference(string name, Mono.Cecil.TypeReference returnType) { }
public MethodReference(string name, Mono.Cecil.TypeReference returnType, Mono.Cecil.TypeReference declaringType) { }
public virtual Mono.Cecil.MethodCallingConvention CallingConvention { get { throw null; } set { } }
public override bool ContainsGenericParameter { get { throw null; } }
public virtual bool ExplicitThis { get { throw null; } set { } }
public override string FullName { get { throw null; } }
public virtual Mono.Collections.Generic.Collection<Mono.Cecil.GenericParameter> GenericParameters { get { throw null; } }
public virtual bool HasGenericParameters { get { throw null; } }
public virtual bool HasParameters { get { throw null; } }
public virtual bool HasThis { get { throw null; } set { } }
public virtual bool IsGenericInstance { get { throw null; } }
public virtual Mono.Cecil.MethodReturnType MethodReturnType { get { throw null; } set { } }
Mono.Cecil.GenericParameterType Mono.Cecil.IGenericParameterProvider.GenericParameterType { get { throw null; } }
public virtual Mono.Collections.Generic.Collection<Mono.Cecil.ParameterDefinition> Parameters { get { throw null; } }
public Mono.Cecil.TypeReference ReturnType { get { throw null; } set { } }
public virtual Mono.Cecil.MethodReference GetElementMethod() { throw null; }
public virtual new Mono.Cecil.MethodDefinition Resolve() { throw null; }
protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; }
}
public sealed partial class MethodReturnType : Mono.Cecil.IConstantProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMarshalInfoProvider, Mono.Cecil.IMetadataTokenProvider
{
public MethodReturnType(Mono.Cecil.IMethodSignature method) { }
public Mono.Cecil.ParameterAttributes Attributes { get { throw null; } set { } }
public object Constant { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public bool HasConstant { get { throw null; } set { } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasDefault { get { throw null; } set { } }
public bool HasFieldMarshal { get { throw null; } set { } }
public bool HasMarshalInfo { get { throw null; } }
public Mono.Cecil.MarshalInfo MarshalInfo { get { throw null; } set { } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
public Mono.Cecil.IMethodSignature Method { get { throw null; } }
public string Name { get { throw null; } set { } }
public Mono.Cecil.TypeReference ReturnType { get { throw null; } set { } }
}
[System.FlagsAttribute]
public enum MethodSemanticsAttributes : ushort
{
AddOn = (ushort)8,
Fire = (ushort)32,
Getter = (ushort)2,
None = (ushort)0,
Other = (ushort)4,
RemoveOn = (ushort)16,
Setter = (ushort)1,
}
public abstract partial class MethodSpecification : Mono.Cecil.MethodReference
{
internal MethodSpecification() : base (default(string), default(Mono.Cecil.TypeReference)) { }
public override Mono.Cecil.MethodCallingConvention CallingConvention { get { throw null; } set { } }
public override bool ContainsGenericParameter { get { throw null; } }
public override Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } }
public Mono.Cecil.MethodReference ElementMethod { get { throw null; } }
public override bool ExplicitThis { get { throw null; } set { } }
public override bool HasParameters { get { throw null; } }
public override bool HasThis { get { throw null; } set { } }
public override Mono.Cecil.MethodReturnType MethodReturnType { get { throw null; } set { } }
public override Mono.Cecil.ModuleDefinition Module { get { throw null; } }
public override string Name { get { throw null; } set { } }
public override Mono.Collections.Generic.Collection<Mono.Cecil.ParameterDefinition> Parameters { get { throw null; } }
public sealed override Mono.Cecil.MethodReference GetElementMethod() { throw null; }
}
[System.FlagsAttribute]
public enum ModuleAttributes
{
ILLibrary = 4,
ILOnly = 1,
Preferred32Bit = 131072,
Required32Bit = 2,
StrongNameSigned = 8,
}
[System.FlagsAttribute]
public enum ModuleCharacteristics
{
AppContainer = 4096,
DynamicBase = 64,
HighEntropyVA = 32,
NoSEH = 1024,
NXCompat = 256,
TerminalServerAware = 32768,
}
public sealed partial class ModuleDefinition : Mono.Cecil.ModuleReference, Mono.Cecil.Cil.ICustomDebugInformationProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider, System.IDisposable
{
internal ModuleDefinition() : base (default(string)) { }
public Mono.Cecil.TargetArchitecture Architecture { get { throw null; } set { } }
public Mono.Cecil.AssemblyDefinition Assembly { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.AssemblyNameReference> AssemblyReferences { get { throw null; } }
public Mono.Cecil.IAssemblyResolver AssemblyResolver { get { throw null; } }
public Mono.Cecil.ModuleAttributes Attributes { get { throw null; } set { } }
public Mono.Cecil.ModuleCharacteristics Characteristics { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.CustomDebugInformation> CustomDebugInformations { get { throw null; } }
public Mono.Cecil.MethodDefinition EntryPoint { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.ExportedType> ExportedTypes { get { throw null; } }
public string FileName { get { throw null; } }
[System.ObsoleteAttribute("Use FileName")]
public string FullyQualifiedName { get { throw null; } }
public bool HasAssemblyReferences { get { throw null; } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasCustomDebugInformations { get { throw null; } }
public bool HasDebugHeader { get { throw null; } }
public bool HasExportedTypes { get { throw null; } }
public bool HasModuleReferences { get { throw null; } }
public bool HasResources { get { throw null; } }
public bool HasSymbols { get { throw null; } }
public bool HasTypes { get { throw null; } }
public bool IsMain { get { throw null; } }
public Mono.Cecil.ModuleKind Kind { get { throw null; } set { } }
public Mono.Cecil.MetadataKind MetadataKind { get { throw null; } set { } }
public Mono.Cecil.IMetadataResolver MetadataResolver { get { throw null; } }
public override Mono.Cecil.MetadataScopeType MetadataScopeType { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.ModuleReference> ModuleReferences { get { throw null; } }
public System.Guid Mvid { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Resource> Resources { get { throw null; } }
public Mono.Cecil.TargetRuntime Runtime { get { throw null; } set { } }
public string RuntimeVersion { get { throw null; } set { } }
public Mono.Cecil.Cil.ISymbolReader SymbolReader { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.TypeDefinition> Types { get { throw null; } }
public Mono.Cecil.TypeSystem TypeSystem { get { throw null; } }
public static Mono.Cecil.ModuleDefinition CreateModule(string name, Mono.Cecil.ModuleKind kind) { throw null; }
public static Mono.Cecil.ModuleDefinition CreateModule(string name, Mono.Cecil.ModuleParameters parameters) { throw null; }
public void Dispose() { }
public System.Collections.Generic.IEnumerable<Mono.Cecil.CustomAttribute> GetCustomAttributes() { throw null; }
public Mono.Cecil.Cil.ImageDebugHeader GetDebugHeader() { throw null; }
public System.Collections.Generic.IEnumerable<Mono.Cecil.MemberReference> GetMemberReferences() { throw null; }
public Mono.Cecil.TypeDefinition GetType(string fullName) { throw null; }
public Mono.Cecil.TypeReference GetType(string fullName, bool runtimeName) { throw null; }
public Mono.Cecil.TypeDefinition GetType(string @namespace, string name) { throw null; }
public System.Collections.Generic.IEnumerable<Mono.Cecil.TypeReference> GetTypeReferences() { throw null; }
public System.Collections.Generic.IEnumerable<Mono.Cecil.TypeDefinition> GetTypes() { throw null; }
public bool HasTypeReference(string fullName) { throw null; }
public bool HasTypeReference(string scope, string fullName) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.FieldReference Import(Mono.Cecil.FieldReference field) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.FieldReference Import(Mono.Cecil.FieldReference field, Mono.Cecil.IGenericParameterProvider context) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.MethodReference Import(Mono.Cecil.MethodReference method) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.MethodReference Import(Mono.Cecil.MethodReference method, Mono.Cecil.IGenericParameterProvider context) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.TypeReference Import(Mono.Cecil.TypeReference type) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.TypeReference Import(Mono.Cecil.TypeReference type, Mono.Cecil.IGenericParameterProvider context) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.FieldReference Import(System.Reflection.FieldInfo field) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.FieldReference Import(System.Reflection.FieldInfo field, Mono.Cecil.IGenericParameterProvider context) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.MethodReference Import(System.Reflection.MethodBase method) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.MethodReference Import(System.Reflection.MethodBase method, Mono.Cecil.IGenericParameterProvider context) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.TypeReference Import(System.Type type) { throw null; }
[System.ObsoleteAttribute("Use ImportReference", false)]
public Mono.Cecil.TypeReference Import(System.Type type, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public Mono.Cecil.FieldReference ImportReference(Mono.Cecil.FieldReference field) { throw null; }
public Mono.Cecil.FieldReference ImportReference(Mono.Cecil.FieldReference field, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public Mono.Cecil.MethodReference ImportReference(Mono.Cecil.MethodReference method) { throw null; }
public Mono.Cecil.MethodReference ImportReference(Mono.Cecil.MethodReference method, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public Mono.Cecil.TypeReference ImportReference(Mono.Cecil.TypeReference type) { throw null; }
public Mono.Cecil.TypeReference ImportReference(Mono.Cecil.TypeReference type, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public Mono.Cecil.FieldReference ImportReference(System.Reflection.FieldInfo field) { throw null; }
public Mono.Cecil.FieldReference ImportReference(System.Reflection.FieldInfo field, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public Mono.Cecil.MethodReference ImportReference(System.Reflection.MethodBase method) { throw null; }
public Mono.Cecil.MethodReference ImportReference(System.Reflection.MethodBase method, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public Mono.Cecil.TypeReference ImportReference(System.Type type) { throw null; }
public Mono.Cecil.TypeReference ImportReference(System.Type type, Mono.Cecil.IGenericParameterProvider context) { throw null; }
public Mono.Cecil.IMetadataTokenProvider LookupToken(Mono.Cecil.MetadataToken token) { throw null; }
public Mono.Cecil.IMetadataTokenProvider LookupToken(int token) { throw null; }
public static Mono.Cecil.ModuleDefinition ReadModule(System.IO.Stream stream) { throw null; }
public static Mono.Cecil.ModuleDefinition ReadModule(System.IO.Stream stream, Mono.Cecil.ReaderParameters parameters) { throw null; }
public static Mono.Cecil.ModuleDefinition ReadModule(string fileName) { throw null; }
public static Mono.Cecil.ModuleDefinition ReadModule(string fileName, Mono.Cecil.ReaderParameters parameters) { throw null; }
public void ReadSymbols() { }
public void ReadSymbols(Mono.Cecil.Cil.ISymbolReader reader) { }
public void ReadSymbols(Mono.Cecil.Cil.ISymbolReader reader, bool throwIfSymbolsAreNotMaching) { }
public bool TryGetTypeReference(string fullName, out Mono.Cecil.TypeReference type) { throw null; }
public bool TryGetTypeReference(string scope, string fullName, out Mono.Cecil.TypeReference type) { throw null; }
public void Write() { }
public void Write(Mono.Cecil.WriterParameters parameters) { }
public void Write(System.IO.Stream stream) { }
public void Write(System.IO.Stream stream, Mono.Cecil.WriterParameters parameters) { }
public void Write(string fileName) { }
public void Write(string fileName, Mono.Cecil.WriterParameters parameters) { }
}
public enum ModuleKind
{
Console = 1,
Dll = 0,
NetModule = 3,
Windows = 2,
}
public sealed partial class ModuleParameters
{
public ModuleParameters() { }
public Mono.Cecil.TargetArchitecture Architecture { get { throw null; } set { } }
public Mono.Cecil.IAssemblyResolver AssemblyResolver { get { throw null; } set { } }
public Mono.Cecil.ModuleKind Kind { get { throw null; } set { } }
public Mono.Cecil.IMetadataImporterProvider MetadataImporterProvider { get { throw null; } set { } }
public Mono.Cecil.IMetadataResolver MetadataResolver { get { throw null; } set { } }
public Mono.Cecil.IReflectionImporterProvider ReflectionImporterProvider { get { throw null; } set { } }
public Mono.Cecil.TargetRuntime Runtime { get { throw null; } set { } }
public System.Nullable<uint> Timestamp { get { throw null; } set { } }
}
public partial class ModuleReference : Mono.Cecil.IMetadataScope, Mono.Cecil.IMetadataTokenProvider
{
public ModuleReference(string name) { }
public virtual Mono.Cecil.MetadataScopeType MetadataScopeType { get { throw null; } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
public string Name { get { throw null; } set { } }
public override string ToString() { throw null; }
}
public enum NativeType
{
ANSIBStr = 35,
Array = 42,
ASAny = 40,
Boolean = 2,
BStr = 19,
ByValStr = 34,
Currency = 15,
CustomMarshaler = 44,
Error = 45,
FixedArray = 30,
FixedSysString = 23,
Func = 38,
I1 = 3,
I2 = 5,
I4 = 7,
I8 = 9,
IDispatch = 26,
Int = 31,
IntF = 28,
IUnknown = 25,
LPStr = 20,
LPStruct = 43,
LPTStr = 22,
LPWStr = 21,
Max = 80,
None = 102,
R4 = 11,
R8 = 12,
SafeArray = 29,
Struct = 27,
TBStr = 36,
U1 = 4,
U2 = 6,
U4 = 8,
U8 = 10,
UInt = 32,
VariantBool = 37,
}
public sealed partial class OptionalModifierType : Mono.Cecil.TypeSpecification, Mono.Cecil.IModifierType
{
public OptionalModifierType(Mono.Cecil.TypeReference modifierType, Mono.Cecil.TypeReference type) { }
public override bool ContainsGenericParameter { get { throw null; } }
public override string FullName { get { throw null; } }
public override bool IsOptionalModifier { get { throw null; } }
public override bool IsValueType { get { throw null; } set { } }
public Mono.Cecil.TypeReference ModifierType { get { throw null; } set { } }
public override string Name { get { throw null; } }
}
[System.FlagsAttribute]
public enum ParameterAttributes : ushort
{
HasDefault = (ushort)4096,
HasFieldMarshal = (ushort)8192,
In = (ushort)1,
Lcid = (ushort)4,
None = (ushort)0,
Optional = (ushort)16,
Out = (ushort)2,
Retval = (ushort)8,
Unused = (ushort)53216,
}
public sealed partial class ParameterDefinition : Mono.Cecil.ParameterReference, Mono.Cecil.IConstantProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMarshalInfoProvider, Mono.Cecil.IMetadataTokenProvider
{
public ParameterDefinition(Mono.Cecil.TypeReference parameterType) { }
public ParameterDefinition(string name, Mono.Cecil.ParameterAttributes attributes, Mono.Cecil.TypeReference parameterType) { }
public Mono.Cecil.ParameterAttributes Attributes { get { throw null; } set { } }
public object Constant { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public bool HasConstant { get { throw null; } set { } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasDefault { get { throw null; } set { } }
public bool HasFieldMarshal { get { throw null; } set { } }
public bool HasMarshalInfo { get { throw null; } }
public bool IsIn { get { throw null; } set { } }
public bool IsLcid { get { throw null; } set { } }
public bool IsOptional { get { throw null; } set { } }
public bool IsOut { get { throw null; } set { } }
public bool IsReturnValue { get { throw null; } set { } }
public Mono.Cecil.MarshalInfo MarshalInfo { get { throw null; } set { } }
public Mono.Cecil.IMethodSignature Method { get { throw null; } }
public int Sequence { get { throw null; } }
public override Mono.Cecil.ParameterDefinition Resolve() { throw null; }
}
public abstract partial class ParameterReference : Mono.Cecil.IMetadataTokenProvider
{
internal ParameterReference() { }
protected Mono.Cecil.TypeReference parameter_type;
public int Index { get { throw null; } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
public string Name { get { throw null; } set { } }
public Mono.Cecil.TypeReference ParameterType { get { throw null; } set { } }
public abstract Mono.Cecil.ParameterDefinition Resolve();
public override string ToString() { throw null; }
}
public sealed partial class PinnedType : Mono.Cecil.TypeSpecification
{
public PinnedType(Mono.Cecil.TypeReference type) { }
public override bool IsPinned { get { throw null; } }
public override bool IsValueType { get { throw null; } set { } }
}
[System.FlagsAttribute]
public enum PInvokeAttributes : ushort
{
BestFitDisabled = (ushort)32,
BestFitEnabled = (ushort)16,
BestFitMask = (ushort)48,
CallConvCdecl = (ushort)512,
CallConvFastcall = (ushort)1280,
CallConvMask = (ushort)1792,
CallConvStdCall = (ushort)768,
CallConvThiscall = (ushort)1024,
CallConvWinapi = (ushort)256,
CharSetAnsi = (ushort)2,
CharSetAuto = (ushort)6,
CharSetMask = (ushort)6,
CharSetNotSpec = (ushort)0,
CharSetUnicode = (ushort)4,
NoMangle = (ushort)1,
SupportsLastError = (ushort)64,
ThrowOnUnmappableCharDisabled = (ushort)8192,
ThrowOnUnmappableCharEnabled = (ushort)4096,
ThrowOnUnmappableCharMask = (ushort)12288,
}
public sealed partial class PInvokeInfo
{
public PInvokeInfo(Mono.Cecil.PInvokeAttributes attributes, string entryPoint, Mono.Cecil.ModuleReference module) { }
public Mono.Cecil.PInvokeAttributes Attributes { get { throw null; } set { } }
public string EntryPoint { get { throw null; } set { } }
public bool IsBestFitDisabled { get { throw null; } set { } }
public bool IsBestFitEnabled { get { throw null; } set { } }
public bool IsCallConvCdecl { get { throw null; } set { } }
public bool IsCallConvFastcall { get { throw null; } set { } }
public bool IsCallConvStdCall { get { throw null; } set { } }
public bool IsCallConvThiscall { get { throw null; } set { } }
public bool IsCallConvWinapi { get { throw null; } set { } }
public bool IsCharSetAnsi { get { throw null; } set { } }
public bool IsCharSetAuto { get { throw null; } set { } }
public bool IsCharSetNotSpec { get { throw null; } set { } }
public bool IsCharSetUnicode { get { throw null; } set { } }
public bool IsNoMangle { get { throw null; } set { } }
public bool IsThrowOnUnmappableCharDisabled { get { throw null; } set { } }
public bool IsThrowOnUnmappableCharEnabled { get { throw null; } set { } }
public Mono.Cecil.ModuleReference Module { get { throw null; } set { } }
public bool SupportsLastError { get { throw null; } set { } }
}
public sealed partial class PointerType : Mono.Cecil.TypeSpecification
{
public PointerType(Mono.Cecil.TypeReference type) { }
public override string FullName { get { throw null; } }
public override bool IsPointer { get { throw null; } }
public override bool IsValueType { get { throw null; } set { } }
public override string Name { get { throw null; } }
}
[System.FlagsAttribute]
public enum PropertyAttributes : ushort
{
HasDefault = (ushort)4096,
None = (ushort)0,
RTSpecialName = (ushort)1024,
SpecialName = (ushort)512,
Unused = (ushort)59903,
}
public sealed partial class PropertyDefinition : Mono.Cecil.PropertyReference, Mono.Cecil.IConstantProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider
{
public PropertyDefinition(string name, Mono.Cecil.PropertyAttributes attributes, Mono.Cecil.TypeReference propertyType) { }
public Mono.Cecil.PropertyAttributes Attributes { get { throw null; } set { } }
public object Constant { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } }
public override string FullName { get { throw null; } }
public Mono.Cecil.MethodDefinition GetMethod { get { throw null; } set { } }
public bool HasConstant { get { throw null; } set { } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasDefault { get { throw null; } set { } }
public bool HasOtherMethods { get { throw null; } }
public bool HasParameters { get { throw null; } }
public bool HasThis { get { throw null; } set { } }
public override bool IsDefinition { get { throw null; } }
public bool IsRuntimeSpecialName { get { throw null; } set { } }
public bool IsSpecialName { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.MethodDefinition> OtherMethods { get { throw null; } }
public override Mono.Collections.Generic.Collection<Mono.Cecil.ParameterDefinition> Parameters { get { throw null; } }
public Mono.Cecil.MethodDefinition SetMethod { get { throw null; } set { } }
public override Mono.Cecil.PropertyDefinition Resolve() { throw null; }
}
public abstract partial class PropertyReference : Mono.Cecil.MemberReference
{
internal PropertyReference() { }
public abstract Mono.Collections.Generic.Collection<Mono.Cecil.ParameterDefinition> Parameters { get; }
public Mono.Cecil.TypeReference PropertyType { get { throw null; } set { } }
public abstract new Mono.Cecil.PropertyDefinition Resolve();
protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; }
}
public sealed partial class ReaderParameters
{
public ReaderParameters() { }
public ReaderParameters(Mono.Cecil.ReadingMode readingMode) { }
public bool ApplyWindowsRuntimeProjections { get { throw null; } set { } }
public Mono.Cecil.IAssemblyResolver AssemblyResolver { get { throw null; } set { } }
public bool InMemory { get { throw null; } set { } }
public Mono.Cecil.IMetadataImporterProvider MetadataImporterProvider { get { throw null; } set { } }
public Mono.Cecil.IMetadataResolver MetadataResolver { get { throw null; } set { } }
public Mono.Cecil.ReadingMode ReadingMode { get { throw null; } set { } }
public bool ReadSymbols { get { throw null; } set { } }
public bool ReadWrite { get { throw null; } set { } }
public Mono.Cecil.IReflectionImporterProvider ReflectionImporterProvider { get { throw null; } set { } }
public Mono.Cecil.Cil.ISymbolReaderProvider SymbolReaderProvider { get { throw null; } set { } }
public System.IO.Stream SymbolStream { get { throw null; } set { } }
public bool ThrowIfSymbolsAreNotMatching { get { throw null; } set { } }
}
public enum ReadingMode
{
Deferred = 2,
Immediate = 1,
}
public sealed partial class RequiredModifierType : Mono.Cecil.TypeSpecification, Mono.Cecil.IModifierType
{
public RequiredModifierType(Mono.Cecil.TypeReference modifierType, Mono.Cecil.TypeReference type) { }
public override bool ContainsGenericParameter { get { throw null; } }
public override string FullName { get { throw null; } }
public override bool IsRequiredModifier { get { throw null; } }
public override bool IsValueType { get { throw null; } set { } }
public Mono.Cecil.TypeReference ModifierType { get { throw null; } set { } }
public override string Name { get { throw null; } }
}
[System.SerializableAttribute]
public sealed partial class ResolutionException : System.Exception
{
public ResolutionException(Mono.Cecil.MemberReference member) { }
public ResolutionException(Mono.Cecil.MemberReference member, System.Exception innerException) { }
public Mono.Cecil.MemberReference Member { get { throw null; } }
public Mono.Cecil.IMetadataScope Scope { get { throw null; } }
}
public abstract partial class Resource
{
internal Resource() { }
public Mono.Cecil.ManifestResourceAttributes Attributes { get { throw null; } set { } }
public bool IsPrivate { get { throw null; } set { } }
public bool IsPublic { get { throw null; } set { } }
public string Name { get { throw null; } set { } }
public abstract Mono.Cecil.ResourceType ResourceType { get; }
}
public enum ResourceType
{
AssemblyLinked = 2,
Embedded = 1,
Linked = 0,
}
public sealed partial class SafeArrayMarshalInfo : Mono.Cecil.MarshalInfo
{
public SafeArrayMarshalInfo() : base (default(Mono.Cecil.NativeType)) { }
public Mono.Cecil.VariantType ElementType { get { throw null; } set { } }
}
public enum SecurityAction : ushort
{
Assert = (ushort)3,
Demand = (ushort)2,
Deny = (ushort)4,
InheritDemand = (ushort)7,
LinkDemand = (ushort)6,
NonCasDemand = (ushort)13,
NonCasInheritance = (ushort)15,
NonCasLinkDemand = (ushort)14,
PermitOnly = (ushort)5,
PreJitDeny = (ushort)12,
PreJitGrant = (ushort)11,
Request = (ushort)1,
RequestMinimum = (ushort)8,
RequestOptional = (ushort)9,
RequestRefuse = (ushort)10,
}
[System.Diagnostics.DebuggerDisplayAttribute("{AttributeType}")]
public sealed partial class SecurityAttribute : Mono.Cecil.ICustomAttribute
{
public SecurityAttribute(Mono.Cecil.TypeReference attributeType) { }
public Mono.Cecil.TypeReference AttributeType { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeNamedArgument> Fields { get { throw null; } }
public bool HasFields { get { throw null; } }
public bool HasProperties { get { throw null; } }
Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeArgument> Mono.Cecil.ICustomAttribute.ConstructorArguments { get { throw null; } }
bool Mono.Cecil.ICustomAttribute.HasConstructorArguments { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttributeNamedArgument> Properties { get { throw null; } }
}
public sealed partial class SecurityDeclaration
{
public SecurityDeclaration(Mono.Cecil.SecurityAction action) { }
public SecurityDeclaration(Mono.Cecil.SecurityAction action, byte[] blob) { }
public Mono.Cecil.SecurityAction Action { get { throw null; } set { } }
public bool HasSecurityAttributes { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.SecurityAttribute> SecurityAttributes { get { throw null; } }
public byte[] GetBlob() { throw null; }
}
public sealed partial class SentinelType : Mono.Cecil.TypeSpecification
{
public SentinelType(Mono.Cecil.TypeReference type) { }
public override bool IsSentinel { get { throw null; } }
public override bool IsValueType { get { throw null; } set { } }
}
public enum TargetArchitecture
{
AMD64 = 34404,
ARM = 448,
ARM64 = 43620,
ARMv7 = 452,
I386 = 332,
IA64 = 512,
}
public enum TargetRuntime
{
Net_1_0 = 0,
Net_1_1 = 1,
Net_2_0 = 2,
Net_4_0 = 3,
}
public enum TokenType : uint
{
Assembly = (uint)536870912,
AssemblyRef = (uint)587202560,
CustomAttribute = (uint)201326592,
CustomDebugInformation = (uint)922746880,
Document = (uint)805306368,
Event = (uint)335544320,
ExportedType = (uint)654311424,
Field = (uint)67108864,
File = (uint)637534208,
GenericParam = (uint)704643072,
GenericParamConstraint = (uint)738197504,
ImportScope = (uint)889192448,
InterfaceImpl = (uint)150994944,
LocalConstant = (uint)872415232,
LocalScope = (uint)838860800,
LocalVariable = (uint)855638016,
ManifestResource = (uint)671088640,
MemberRef = (uint)167772160,
Method = (uint)100663296,
MethodDebugInformation = (uint)822083584,
MethodSpec = (uint)721420288,
Module = (uint)0,
ModuleRef = (uint)436207616,
Param = (uint)134217728,
Permission = (uint)234881024,
Property = (uint)385875968,
Signature = (uint)285212672,
StateMachineMethod = (uint)905969664,
String = (uint)1879048192,
TypeDef = (uint)33554432,
TypeRef = (uint)16777216,
TypeSpec = (uint)452984832,
}
[System.FlagsAttribute]
public enum TypeAttributes : uint
{
Abstract = (uint)128,
AnsiClass = (uint)0,
AutoClass = (uint)131072,
AutoLayout = (uint)0,
BeforeFieldInit = (uint)1048576,
Class = (uint)0,
ClassSemanticMask = (uint)32,
ExplicitLayout = (uint)16,
Forwarder = (uint)2097152,
HasSecurity = (uint)262144,
Import = (uint)4096,
Interface = (uint)32,
LayoutMask = (uint)24,
NestedAssembly = (uint)5,
NestedFamANDAssem = (uint)6,
NestedFamily = (uint)4,
NestedFamORAssem = (uint)7,
NestedPrivate = (uint)3,
NestedPublic = (uint)2,
NotPublic = (uint)0,
Public = (uint)1,
RTSpecialName = (uint)2048,
Sealed = (uint)256,
SequentialLayout = (uint)8,
Serializable = (uint)8192,
SpecialName = (uint)1024,
StringFormatMask = (uint)196608,
UnicodeClass = (uint)65536,
VisibilityMask = (uint)7,
WindowsRuntime = (uint)16384,
}
public sealed partial class TypeDefinition : Mono.Cecil.TypeReference, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.ISecurityDeclarationProvider
{
public TypeDefinition(string @namespace, string name, Mono.Cecil.TypeAttributes attributes) : base (default(string), default(string)) { }
public TypeDefinition(string @namespace, string name, Mono.Cecil.TypeAttributes attributes, Mono.Cecil.TypeReference baseType) : base (default(string), default(string)) { }
public Mono.Cecil.TypeAttributes Attributes { get { throw null; } set { } }
public Mono.Cecil.TypeReference BaseType { get { throw null; } set { } }
public int ClassSize { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.CustomAttribute> CustomAttributes { get { throw null; } }
public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.EventDefinition> Events { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.FieldDefinition> Fields { get { throw null; } }
public override Mono.Collections.Generic.Collection<Mono.Cecil.GenericParameter> GenericParameters { get { throw null; } }
public bool HasCustomAttributes { get { throw null; } }
public bool HasEvents { get { throw null; } }
public bool HasFields { get { throw null; } }
public override bool HasGenericParameters { get { throw null; } }
public bool HasInterfaces { get { throw null; } }
public bool HasLayoutInfo { get { throw null; } }
public bool HasMethods { get { throw null; } }
public bool HasNestedTypes { get { throw null; } }
public bool HasProperties { get { throw null; } }
public bool HasSecurity { get { throw null; } set { } }
public bool HasSecurityDeclarations { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.InterfaceImplementation> Interfaces { get { throw null; } }
public bool IsAbstract { get { throw null; } set { } }
public bool IsAnsiClass { get { throw null; } set { } }
public bool IsAutoClass { get { throw null; } set { } }
public bool IsAutoLayout { get { throw null; } set { } }
public bool IsBeforeFieldInit { get { throw null; } set { } }
public bool IsClass { get { throw null; } set { } }
public override bool IsDefinition { get { throw null; } }
public bool IsEnum { get { throw null; } }
public bool IsExplicitLayout { get { throw null; } set { } }
public bool IsImport { get { throw null; } set { } }
public bool IsInterface { get { throw null; } set { } }
public bool IsNestedAssembly { get { throw null; } set { } }
public bool IsNestedFamily { get { throw null; } set { } }
public bool IsNestedFamilyAndAssembly { get { throw null; } set { } }
public bool IsNestedFamilyOrAssembly { get { throw null; } set { } }
public bool IsNestedPrivate { get { throw null; } set { } }
public bool IsNestedPublic { get { throw null; } set { } }
public bool IsNotPublic { get { throw null; } set { } }
public override bool IsPrimitive { get { throw null; } }
public bool IsPublic { get { throw null; } set { } }
public bool IsRuntimeSpecialName { get { throw null; } set { } }
public bool IsSealed { get { throw null; } set { } }
public bool IsSequentialLayout { get { throw null; } set { } }
public bool IsSerializable { get { throw null; } set { } }
public bool IsSpecialName { get { throw null; } set { } }
public bool IsUnicodeClass { get { throw null; } set { } }
public override bool IsValueType { get { throw null; } set { } }
public bool IsWindowsRuntime { get { throw null; } set { } }
public override Mono.Cecil.MetadataType MetadataType { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.MethodDefinition> Methods { get { throw null; } }
public override string Name { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.TypeDefinition> NestedTypes { get { throw null; } }
public short PackingSize { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.PropertyDefinition> Properties { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.SecurityDeclaration> SecurityDeclarations { get { throw null; } }
protected override void ClearFullName() { }
public override Mono.Cecil.TypeDefinition Resolve() { throw null; }
}
public partial class TypeReference : Mono.Cecil.MemberReference, Mono.Cecil.IGenericParameterProvider, Mono.Cecil.IMetadataTokenProvider
{
protected Mono.Collections.Generic.Collection<Mono.Cecil.GenericParameter> generic_parameters;
protected TypeReference(string @namespace, string name) { }
public TypeReference(string @namespace, string name, Mono.Cecil.ModuleDefinition module, Mono.Cecil.IMetadataScope scope) { }
public TypeReference(string @namespace, string name, Mono.Cecil.ModuleDefinition module, Mono.Cecil.IMetadataScope scope, bool valueType) { }
public override Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } }
public override string FullName { get { throw null; } }
public virtual Mono.Collections.Generic.Collection<Mono.Cecil.GenericParameter> GenericParameters { get { throw null; } }
public virtual bool HasGenericParameters { get { throw null; } }
public virtual bool IsArray { get { throw null; } }
public virtual bool IsByReference { get { throw null; } }
public virtual bool IsFunctionPointer { get { throw null; } }
public virtual bool IsGenericInstance { get { throw null; } }
public virtual bool IsGenericParameter { get { throw null; } }
public bool IsNested { get { throw null; } }
public virtual bool IsOptionalModifier { get { throw null; } }
public virtual bool IsPinned { get { throw null; } }
public virtual bool IsPointer { get { throw null; } }
public virtual bool IsPrimitive { get { throw null; } }
public virtual bool IsRequiredModifier { get { throw null; } }
public virtual bool IsSentinel { get { throw null; } }
public virtual bool IsValueType { get { throw null; } set { } }
public virtual Mono.Cecil.MetadataType MetadataType { get { throw null; } }
public override Mono.Cecil.ModuleDefinition Module { get { throw null; } }
Mono.Cecil.GenericParameterType Mono.Cecil.IGenericParameterProvider.GenericParameterType { get { throw null; } }
public override string Name { get { throw null; } set { } }
public virtual string Namespace { get { throw null; } set { } }
public virtual Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } }
protected virtual void ClearFullName() { }
public virtual Mono.Cecil.TypeReference GetElementType() { throw null; }
public virtual new Mono.Cecil.TypeDefinition Resolve() { throw null; }
protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; }
}
public abstract partial class TypeSpecification : Mono.Cecil.TypeReference
{
internal TypeSpecification() : base (default(string), default(string)) { }
public override bool ContainsGenericParameter { get { throw null; } }
public Mono.Cecil.TypeReference ElementType { get { throw null; } }
public override string FullName { get { throw null; } }
public override Mono.Cecil.MetadataType MetadataType { get { throw null; } }
public override Mono.Cecil.ModuleDefinition Module { get { throw null; } }
public override string Name { get { throw null; } set { } }
public override string Namespace { get { throw null; } set { } }
public override Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } }
public override Mono.Cecil.TypeReference GetElementType() { throw null; }
}
public abstract partial class TypeSystem
{
internal TypeSystem() { }
public Mono.Cecil.TypeReference Boolean { get { throw null; } }
public Mono.Cecil.TypeReference Byte { get { throw null; } }
public Mono.Cecil.TypeReference Char { get { throw null; } }
public Mono.Cecil.IMetadataScope CoreLibrary { get { throw null; } }
[System.ObsoleteAttribute("Use CoreLibrary")]
public Mono.Cecil.IMetadataScope Corlib { get { throw null; } }
public Mono.Cecil.TypeReference Double { get { throw null; } }
public Mono.Cecil.TypeReference Int16 { get { throw null; } }
public Mono.Cecil.TypeReference Int32 { get { throw null; } }
public Mono.Cecil.TypeReference Int64 { get { throw null; } }
public Mono.Cecil.TypeReference IntPtr { get { throw null; } }
public Mono.Cecil.TypeReference Object { get { throw null; } }
public Mono.Cecil.TypeReference SByte { get { throw null; } }
public Mono.Cecil.TypeReference Single { get { throw null; } }
public Mono.Cecil.TypeReference String { get { throw null; } }
public Mono.Cecil.TypeReference TypedReference { get { throw null; } }
public Mono.Cecil.TypeReference UInt16 { get { throw null; } }
public Mono.Cecil.TypeReference UInt32 { get { throw null; } }
public Mono.Cecil.TypeReference UInt64 { get { throw null; } }
public Mono.Cecil.TypeReference UIntPtr { get { throw null; } }
public Mono.Cecil.TypeReference Void { get { throw null; } }
}
public enum VariantType
{
Bool = 11,
BStr = 8,
CY = 6,
Date = 7,
Decimal = 14,
Dispatch = 9,
Error = 10,
I1 = 16,
I2 = 2,
I4 = 3,
I8 = 20,
Int = 22,
None = 0,
R4 = 4,
R8 = 5,
UI1 = 17,
UI2 = 18,
UI4 = 19,
UI8 = 21,
UInt = 23,
Unknown = 13,
Variant = 12,
}
public sealed partial class WriterParameters
{
public WriterParameters() { }
public bool DeterministicMvid { get { throw null; } set { } }
public bool HasStrongNameKey { get { throw null; } }
public byte[] StrongNameKeyBlob { get { throw null; } set { } }
public string StrongNameKeyContainer { get { throw null; } set { } }
public System.Reflection.StrongNameKeyPair StrongNameKeyPair { get { throw null; } set { } }
public System.IO.Stream SymbolStream { get { throw null; } set { } }
public Mono.Cecil.Cil.ISymbolWriterProvider SymbolWriterProvider { get { throw null; } set { } }
public System.Nullable<uint> Timestamp { get { throw null; } set { } }
public bool WriteSymbols { get { throw null; } set { } }
}
}
namespace Mono.Cecil.Cil
{
public sealed partial class AsyncMethodBodyDebugInformation : Mono.Cecil.Cil.CustomDebugInformation
{
public static System.Guid KindIdentifier;
public AsyncMethodBodyDebugInformation() { }
public AsyncMethodBodyDebugInformation(Mono.Cecil.Cil.Instruction catchHandler) { }
public Mono.Cecil.Cil.InstructionOffset CatchHandler { get { throw null; } set { } }
public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.MethodDefinition> ResumeMethods { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.InstructionOffset> Resumes { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.InstructionOffset> Yields { get { throw null; } }
}
public sealed partial class BinaryCustomDebugInformation : Mono.Cecil.Cil.CustomDebugInformation
{
public BinaryCustomDebugInformation(System.Guid identifier, byte[] data) { }
public byte[] Data { get { throw null; } set { } }
public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } }
}
public enum Code
{
Add = 87,
Add_Ovf = 180,
Add_Ovf_Un = 181,
And = 94,
Arglist = 191,
Beq = 58,
Beq_S = 45,
Bge = 59,
Bge_S = 46,
Bge_Un = 64,
Bge_Un_S = 51,
Bgt = 60,
Bgt_S = 47,
Bgt_Un = 65,
Bgt_Un_S = 52,
Ble = 61,
Ble_S = 48,
Ble_Un = 66,
Ble_Un_S = 53,
Blt = 62,
Blt_S = 49,
Blt_Un = 67,
Blt_Un_S = 54,
Bne_Un = 63,
Bne_Un_S = 50,
Box = 137,
Br = 55,
Break = 1,
Brfalse = 56,
Brfalse_S = 43,
Brtrue = 57,
Brtrue_S = 44,
Br_S = 42,
Call = 39,
Calli = 40,
Callvirt = 110,
Castclass = 115,
Ceq = 192,
Cgt = 193,
Cgt_Un = 194,
Ckfinite = 172,
Clt = 195,
Clt_Un = 196,
Constrained = 211,
Conv_I = 177,
Conv_I1 = 102,
Conv_I2 = 103,
Conv_I4 = 104,
Conv_I8 = 105,
Conv_Ovf_I = 178,
Conv_Ovf_I1 = 163,
Conv_Ovf_I1_Un = 127,
Conv_Ovf_I2 = 165,
Conv_Ovf_I2_Un = 128,
Conv_Ovf_I4 = 167,
Conv_Ovf_I4_Un = 129,
Conv_Ovf_I8 = 169,
Conv_Ovf_I8_Un = 130,
Conv_Ovf_I_Un = 135,
Conv_Ovf_U = 179,
Conv_Ovf_U1 = 164,
Conv_Ovf_U1_Un = 131,
Conv_Ovf_U2 = 166,
Conv_Ovf_U2_Un = 132,
Conv_Ovf_U4 = 168,
Conv_Ovf_U4_Un = 133,
Conv_Ovf_U8 = 170,
Conv_Ovf_U8_Un = 134,
Conv_Ovf_U_Un = 136,
Conv_R4 = 106,
Conv_R8 = 107,
Conv_R_Un = 117,
Conv_U = 190,
Conv_U1 = 176,
Conv_U2 = 175,
Conv_U4 = 108,
Conv_U8 = 109,
Cpblk = 212,
Cpobj = 111,
Div = 90,
Div_Un = 91,
Dup = 36,
Endfilter = 206,
Endfinally = 186,
Initblk = 213,
Initobj = 210,
Isinst = 116,
Jmp = 38,
Ldarg = 199,
Ldarga = 200,
Ldarga_S = 15,
Ldarg_0 = 2,
Ldarg_1 = 3,
Ldarg_2 = 4,
Ldarg_3 = 5,
Ldarg_S = 14,
Ldc_I4 = 32,
Ldc_I4_0 = 22,
Ldc_I4_1 = 23,
Ldc_I4_2 = 24,
Ldc_I4_3 = 25,
Ldc_I4_4 = 26,
Ldc_I4_5 = 27,
Ldc_I4_6 = 28,
Ldc_I4_7 = 29,
Ldc_I4_8 = 30,
Ldc_I4_M1 = 21,
Ldc_I4_S = 31,
Ldc_I8 = 33,
Ldc_R4 = 34,
Ldc_R8 = 35,
Ldelema = 140,
Ldelem_Any = 160,
Ldelem_I = 148,
Ldelem_I1 = 141,
Ldelem_I2 = 143,
Ldelem_I4 = 145,
Ldelem_I8 = 147,
Ldelem_R4 = 149,
Ldelem_R8 = 150,
Ldelem_Ref = 151,
Ldelem_U1 = 142,
Ldelem_U2 = 144,
Ldelem_U4 = 146,
Ldfld = 120,
Ldflda = 121,
Ldftn = 197,
Ldind_I = 76,
Ldind_I1 = 69,
Ldind_I2 = 71,
Ldind_I4 = 73,
Ldind_I8 = 75,
Ldind_R4 = 77,
Ldind_R8 = 78,
Ldind_Ref = 79,
Ldind_U1 = 70,
Ldind_U2 = 72,
Ldind_U4 = 74,
Ldlen = 139,
Ldloc = 202,
Ldloca = 203,
Ldloca_S = 18,
Ldloc_0 = 6,
Ldloc_1 = 7,
Ldloc_2 = 8,
Ldloc_3 = 9,
Ldloc_S = 17,
Ldnull = 20,
Ldobj = 112,
Ldsfld = 123,
Ldsflda = 124,
Ldstr = 113,
Ldtoken = 174,
Ldvirtftn = 198,
Leave = 187,
Leave_S = 188,
Localloc = 205,
Mkrefany = 173,
Mul = 89,
Mul_Ovf = 182,
Mul_Ovf_Un = 183,
Neg = 100,
Newarr = 138,
Newobj = 114,
No = 214,
Nop = 0,
Not = 101,
Or = 95,
Pop = 37,
Readonly = 218,
Refanytype = 217,
Refanyval = 171,
Rem = 92,
Rem_Un = 93,
Ret = 41,
Rethrow = 215,
Shl = 97,
Shr = 98,
Shr_Un = 99,
Sizeof = 216,
Starg = 201,
Starg_S = 16,
Stelem_Any = 161,
Stelem_I = 152,
Stelem_I1 = 153,
Stelem_I2 = 154,
Stelem_I4 = 155,
Stelem_I8 = 156,
Stelem_R4 = 157,
Stelem_R8 = 158,
Stelem_Ref = 159,
Stfld = 122,
Stind_I = 189,
Stind_I1 = 81,
Stind_I2 = 82,
Stind_I4 = 83,
Stind_I8 = 84,
Stind_R4 = 85,
Stind_R8 = 86,
Stind_Ref = 80,
Stloc = 204,
Stloc_0 = 10,
Stloc_1 = 11,
Stloc_2 = 12,
Stloc_3 = 13,
Stloc_S = 19,
Stobj = 126,
Stsfld = 125,
Sub = 88,
Sub_Ovf = 184,
Sub_Ovf_Un = 185,
Switch = 68,
Tail = 209,
Throw = 119,
Unaligned = 207,
Unbox = 118,
Unbox_Any = 162,
Volatile = 208,
Xor = 96,
}
public sealed partial class ConstantDebugInformation : Mono.Cecil.Cil.DebugInformation
{
public ConstantDebugInformation(string name, Mono.Cecil.TypeReference constant_type, object value) { }
public Mono.Cecil.TypeReference ConstantType { get { throw null; } set { } }
public string Name { get { throw null; } set { } }
public object Value { get { throw null; } set { } }
}
public abstract partial class CustomDebugInformation : Mono.Cecil.Cil.DebugInformation
{
internal CustomDebugInformation() { }
public System.Guid Identifier { get { throw null; } }
public abstract Mono.Cecil.Cil.CustomDebugInformationKind Kind { get; }
}
public enum CustomDebugInformationKind
{
AsyncMethodBody = 4,
Binary = 0,
DefaultNamespace = 3,
DynamicVariable = 2,
EmbeddedSource = 5,
SourceLink = 6,
StateMachineScope = 1,
}
public abstract partial class DebugInformation : Mono.Cecil.Cil.ICustomDebugInformationProvider, Mono.Cecil.IMetadataTokenProvider
{
internal DebugInformation() { }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.CustomDebugInformation> CustomDebugInformations { get { throw null; } }
public bool HasCustomDebugInformations { get { throw null; } }
public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } }
}
public partial class DefaultSymbolReaderProvider : Mono.Cecil.Cil.ISymbolReaderProvider
{
public DefaultSymbolReaderProvider() { }
public DefaultSymbolReaderProvider(bool throwIfNoSymbol) { }
public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; }
public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; }
}
public partial class DefaultSymbolWriterProvider : Mono.Cecil.Cil.ISymbolWriterProvider
{
public DefaultSymbolWriterProvider() { }
public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; }
public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; }
}
public sealed partial class Document : Mono.Cecil.Cil.DebugInformation
{
public Document(string url) { }
public byte[] EmbeddedSource { get { throw null; } set { } }
public byte[] Hash { get { throw null; } set { } }
public Mono.Cecil.Cil.DocumentHashAlgorithm HashAlgorithm { get { throw null; } set { } }
public System.Guid HashAlgorithmGuid { get { throw null; } set { } }
public Mono.Cecil.Cil.DocumentLanguage Language { get { throw null; } set { } }
public System.Guid LanguageGuid { get { throw null; } set { } }
public Mono.Cecil.Cil.DocumentLanguageVendor LanguageVendor { get { throw null; } set { } }
public System.Guid LanguageVendorGuid { get { throw null; } set { } }
public Mono.Cecil.Cil.DocumentType Type { get { throw null; } set { } }
public System.Guid TypeGuid { get { throw null; } set { } }
public string Url { get { throw null; } set { } }
}
public enum DocumentHashAlgorithm
{
MD5 = 1,
None = 0,
SHA1 = 2,
SHA256 = 3,
}
public enum DocumentLanguage
{
Basic = 4,
C = 1,
Cil = 8,
Cobol = 6,
Cpp = 2,
CSharp = 3,
FSharp = 12,
Java = 5,
JScript = 9,
MCpp = 11,
Other = 0,
Pascal = 7,
Smc = 10,
}
public enum DocumentLanguageVendor
{
Microsoft = 1,
Other = 0,
}
public enum DocumentType
{
Other = 0,
Text = 1,
}
public sealed partial class EmbeddedPortablePdbReader : Mono.Cecil.Cil.ISymbolReader, System.IDisposable
{
internal EmbeddedPortablePdbReader() { }
public void Dispose() { }
public Mono.Cecil.Cil.ISymbolWriterProvider GetWriterProvider() { throw null; }
public bool ProcessDebugHeader(Mono.Cecil.Cil.ImageDebugHeader header) { throw null; }
public Mono.Cecil.Cil.MethodDebugInformation Read(Mono.Cecil.MethodDefinition method) { throw null; }
}
public sealed partial class EmbeddedPortablePdbReaderProvider : Mono.Cecil.Cil.ISymbolReaderProvider
{
public EmbeddedPortablePdbReaderProvider() { }
public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; }
public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; }
}
public sealed partial class EmbeddedPortablePdbWriter : Mono.Cecil.Cil.ISymbolWriter, System.IDisposable
{
internal EmbeddedPortablePdbWriter() { }
public void Dispose() { }
public Mono.Cecil.Cil.ImageDebugHeader GetDebugHeader() { throw null; }
public Mono.Cecil.Cil.ISymbolReaderProvider GetReaderProvider() { throw null; }
public void Write(Mono.Cecil.Cil.MethodDebugInformation info) { }
}
public sealed partial class EmbeddedPortablePdbWriterProvider : Mono.Cecil.Cil.ISymbolWriterProvider
{
public EmbeddedPortablePdbWriterProvider() { }
public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; }
public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; }
}
public sealed partial class EmbeddedSourceDebugInformation : Mono.Cecil.Cil.CustomDebugInformation
{
public static System.Guid KindIdentifier;
public EmbeddedSourceDebugInformation(byte[] content, bool compress) { }
public bool Compress { get { throw null; } set { } }
public byte[] Content { get { throw null; } set { } }
public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } }
}
public sealed partial class ExceptionHandler
{
public ExceptionHandler(Mono.Cecil.Cil.ExceptionHandlerType handlerType) { }
public Mono.Cecil.TypeReference CatchType { get { throw null; } set { } }
public Mono.Cecil.Cil.Instruction FilterStart { get { throw null; } set { } }
public Mono.Cecil.Cil.Instruction HandlerEnd { get { throw null; } set { } }
public Mono.Cecil.Cil.Instruction HandlerStart { get { throw null; } set { } }
public Mono.Cecil.Cil.ExceptionHandlerType HandlerType { get { throw null; } set { } }
public Mono.Cecil.Cil.Instruction TryEnd { get { throw null; } set { } }
public Mono.Cecil.Cil.Instruction TryStart { get { throw null; } set { } }
}
public enum ExceptionHandlerType
{
Catch = 0,
Fault = 4,
Filter = 1,
Finally = 2,
}
public enum FlowControl
{
Branch = 0,
Break = 1,
Call = 2,
Cond_Branch = 3,
Meta = 4,
Next = 5,
Phi = 6,
Return = 7,
Throw = 8,
}
public partial interface ICustomDebugInformationProvider : Mono.Cecil.IMetadataTokenProvider
{
Mono.Collections.Generic.Collection<Mono.Cecil.Cil.CustomDebugInformation> CustomDebugInformations { get; }
bool HasCustomDebugInformations { get; }
}
public sealed partial class ILProcessor
{
internal ILProcessor() { }
public Mono.Cecil.Cil.MethodBody Body { get { throw null; } }
public void Append(Mono.Cecil.Cil.Instruction instruction) { }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.CallSite site) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction target) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction[] targets) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.VariableDefinition variable) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.FieldReference field) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.MethodReference method) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.ParameterDefinition parameter) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.TypeReference type) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, byte value) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, double value) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, int value) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, long value) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, sbyte value) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, float value) { throw null; }
public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, string value) { throw null; }
public void Emit(Mono.Cecil.Cil.OpCode opcode) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.CallSite site) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction target) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction[] targets) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.VariableDefinition variable) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.FieldReference field) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.MethodReference method) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.ParameterDefinition parameter) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.TypeReference type) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, byte value) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, double value) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, int value) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, long value) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, sbyte value) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, float value) { }
public void Emit(Mono.Cecil.Cil.OpCode opcode, string value) { }
public void InsertAfter(Mono.Cecil.Cil.Instruction target, Mono.Cecil.Cil.Instruction instruction) { }
public void InsertAfter(int index, Mono.Cecil.Cil.Instruction instruction) { }
public void InsertBefore(Mono.Cecil.Cil.Instruction target, Mono.Cecil.Cil.Instruction instruction) { }
public void Remove(Mono.Cecil.Cil.Instruction instruction) { }
public void RemoveAt(int index) { }
public void Replace(Mono.Cecil.Cil.Instruction target, Mono.Cecil.Cil.Instruction instruction) { }
public void Replace(int index, Mono.Cecil.Cil.Instruction instruction) { }
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct ImageDebugDirectory
{
public int AddressOfRawData;
public int Characteristics;
public short MajorVersion;
public short MinorVersion;
public int PointerToRawData;
public const int Size = 28;
public int SizeOfData;
public int TimeDateStamp;
public Mono.Cecil.Cil.ImageDebugType Type;
}
public sealed partial class ImageDebugHeader
{
public ImageDebugHeader() { }
public ImageDebugHeader(Mono.Cecil.Cil.ImageDebugHeaderEntry entry) { }
public ImageDebugHeader(Mono.Cecil.Cil.ImageDebugHeaderEntry[] entries) { }
public Mono.Cecil.Cil.ImageDebugHeaderEntry[] Entries { get { throw null; } }
public bool HasEntries { get { throw null; } }
}
public sealed partial class ImageDebugHeaderEntry
{
public ImageDebugHeaderEntry(Mono.Cecil.Cil.ImageDebugDirectory directory, byte[] data) { }
public byte[] Data { get { throw null; } }
public Mono.Cecil.Cil.ImageDebugDirectory Directory { get { throw null; } }
}
public enum ImageDebugType
{
CodeView = 2,
Deterministic = 16,
EmbeddedPortablePdb = 17,
}
public sealed partial class ImportDebugInformation : Mono.Cecil.Cil.DebugInformation
{
public ImportDebugInformation() { }
public bool HasTargets { get { throw null; } }
public Mono.Cecil.Cil.ImportDebugInformation Parent { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.ImportTarget> Targets { get { throw null; } }
}
public sealed partial class ImportTarget
{
public ImportTarget(Mono.Cecil.Cil.ImportTargetKind kind) { }
public string Alias { get { throw null; } set { } }
public Mono.Cecil.AssemblyNameReference AssemblyReference { get { throw null; } set { } }
public Mono.Cecil.Cil.ImportTargetKind Kind { get { throw null; } set { } }
public string Namespace { get { throw null; } set { } }
public Mono.Cecil.TypeReference Type { get { throw null; } set { } }
}
public enum ImportTargetKind : byte
{
DefineAssemblyAlias = (byte)6,
DefineNamespaceAlias = (byte)7,
DefineNamespaceInAssemblyAlias = (byte)8,
DefineTypeAlias = (byte)9,
ImportAlias = (byte)5,
ImportNamespace = (byte)1,
ImportNamespaceInAssembly = (byte)2,
ImportType = (byte)3,
ImportXmlNamespaceWithAlias = (byte)4,
}
public sealed partial class Instruction
{
internal Instruction() { }
public Mono.Cecil.Cil.Instruction Next { get { throw null; } set { } }
public int Offset { get { throw null; } set { } }
public Mono.Cecil.Cil.OpCode OpCode { get { throw null; } set { } }
public object Operand { get { throw null; } set { } }
public Mono.Cecil.Cil.Instruction Previous { get { throw null; } set { } }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.CallSite site) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction target) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction[] targets) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.VariableDefinition variable) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.FieldReference field) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.MethodReference method) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.ParameterDefinition parameter) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.TypeReference type) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, byte value) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, double value) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, int value) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, long value) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, sbyte value) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, float value) { throw null; }
public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, string value) { throw null; }
public int GetSize() { throw null; }
public override string ToString() { throw null; }
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct InstructionOffset
{
private object _dummy;
private int _dummyPrimitive;
public InstructionOffset(Mono.Cecil.Cil.Instruction instruction) { throw null; }
public InstructionOffset(int offset) { throw null; }
public bool IsEndOfMethod { get { throw null; } }
public int Offset { get { throw null; } }
}
public partial interface ISymbolReader : System.IDisposable
{
Mono.Cecil.Cil.ISymbolWriterProvider GetWriterProvider();
bool ProcessDebugHeader(Mono.Cecil.Cil.ImageDebugHeader header);
Mono.Cecil.Cil.MethodDebugInformation Read(Mono.Cecil.MethodDefinition method);
}
public partial interface ISymbolReaderProvider
{
Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream);
Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, string fileName);
}
public partial interface ISymbolWriter : System.IDisposable
{
Mono.Cecil.Cil.ImageDebugHeader GetDebugHeader();
Mono.Cecil.Cil.ISymbolReaderProvider GetReaderProvider();
void Write(Mono.Cecil.Cil.MethodDebugInformation info);
}
public partial interface ISymbolWriterProvider
{
Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream);
Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, string fileName);
}
public sealed partial class MethodBody
{
public MethodBody(Mono.Cecil.MethodDefinition method) { }
public int CodeSize { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.ExceptionHandler> ExceptionHandlers { get { throw null; } }
public bool HasExceptionHandlers { get { throw null; } }
public bool HasVariables { get { throw null; } }
public bool InitLocals { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.Instruction> Instructions { get { throw null; } }
public Mono.Cecil.MetadataToken LocalVarToken { get { throw null; } set { } }
public int MaxStackSize { get { throw null; } set { } }
public Mono.Cecil.MethodDefinition Method { get { throw null; } }
public Mono.Cecil.ParameterDefinition ThisParameter { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.VariableDefinition> Variables { get { throw null; } }
public Mono.Cecil.Cil.ILProcessor GetILProcessor() { throw null; }
}
public sealed partial class MethodDebugInformation : Mono.Cecil.Cil.DebugInformation
{
internal MethodDebugInformation() { }
public bool HasSequencePoints { get { throw null; } }
public Mono.Cecil.MethodDefinition Method { get { throw null; } }
public Mono.Cecil.Cil.ScopeDebugInformation Scope { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.SequencePoint> SequencePoints { get { throw null; } }
public Mono.Cecil.MethodDefinition StateMachineKickOffMethod { get { throw null; } set { } }
public System.Collections.Generic.IEnumerable<Mono.Cecil.Cil.ScopeDebugInformation> GetScopes() { throw null; }
public Mono.Cecil.Cil.SequencePoint GetSequencePoint(Mono.Cecil.Cil.Instruction instruction) { throw null; }
public System.Collections.Generic.IDictionary<Mono.Cecil.Cil.Instruction, Mono.Cecil.Cil.SequencePoint> GetSequencePointMapping() { throw null; }
public bool TryGetName(Mono.Cecil.Cil.VariableDefinition variable, out string name) { throw null; }
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct OpCode : System.IEquatable<Mono.Cecil.Cil.OpCode>
{
private int _dummyPrimitive;
public Mono.Cecil.Cil.Code Code { get { throw null; } }
public Mono.Cecil.Cil.FlowControl FlowControl { get { throw null; } }
public string Name { get { throw null; } }
public byte Op1 { get { throw null; } }
public byte Op2 { get { throw null; } }
public Mono.Cecil.Cil.OpCodeType OpCodeType { get { throw null; } }
public Mono.Cecil.Cil.OperandType OperandType { get { throw null; } }
public int Size { get { throw null; } }
public Mono.Cecil.Cil.StackBehaviour StackBehaviourPop { get { throw null; } }
public Mono.Cecil.Cil.StackBehaviour StackBehaviourPush { get { throw null; } }
public short Value { get { throw null; } }
public bool Equals(Mono.Cecil.Cil.OpCode opcode) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public static bool operator ==(Mono.Cecil.Cil.OpCode one, Mono.Cecil.Cil.OpCode other) { throw null; }
public static bool operator !=(Mono.Cecil.Cil.OpCode one, Mono.Cecil.Cil.OpCode other) { throw null; }
public override string ToString() { throw null; }
}
public static partial class OpCodes
{
public static readonly Mono.Cecil.Cil.OpCode Add;
public static readonly Mono.Cecil.Cil.OpCode Add_Ovf;
public static readonly Mono.Cecil.Cil.OpCode Add_Ovf_Un;
public static readonly Mono.Cecil.Cil.OpCode And;
public static readonly Mono.Cecil.Cil.OpCode Arglist;
public static readonly Mono.Cecil.Cil.OpCode Beq;
public static readonly Mono.Cecil.Cil.OpCode Beq_S;
public static readonly Mono.Cecil.Cil.OpCode Bge;
public static readonly Mono.Cecil.Cil.OpCode Bge_S;
public static readonly Mono.Cecil.Cil.OpCode Bge_Un;
public static readonly Mono.Cecil.Cil.OpCode Bge_Un_S;
public static readonly Mono.Cecil.Cil.OpCode Bgt;
public static readonly Mono.Cecil.Cil.OpCode Bgt_S;
public static readonly Mono.Cecil.Cil.OpCode Bgt_Un;
public static readonly Mono.Cecil.Cil.OpCode Bgt_Un_S;
public static readonly Mono.Cecil.Cil.OpCode Ble;
public static readonly Mono.Cecil.Cil.OpCode Ble_S;
public static readonly Mono.Cecil.Cil.OpCode Ble_Un;
public static readonly Mono.Cecil.Cil.OpCode Ble_Un_S;
public static readonly Mono.Cecil.Cil.OpCode Blt;
public static readonly Mono.Cecil.Cil.OpCode Blt_S;
public static readonly Mono.Cecil.Cil.OpCode Blt_Un;
public static readonly Mono.Cecil.Cil.OpCode Blt_Un_S;
public static readonly Mono.Cecil.Cil.OpCode Bne_Un;
public static readonly Mono.Cecil.Cil.OpCode Bne_Un_S;
public static readonly Mono.Cecil.Cil.OpCode Box;
public static readonly Mono.Cecil.Cil.OpCode Br;
public static readonly Mono.Cecil.Cil.OpCode Break;
public static readonly Mono.Cecil.Cil.OpCode Brfalse;
public static readonly Mono.Cecil.Cil.OpCode Brfalse_S;
public static readonly Mono.Cecil.Cil.OpCode Brtrue;
public static readonly Mono.Cecil.Cil.OpCode Brtrue_S;
public static readonly Mono.Cecil.Cil.OpCode Br_S;
public static readonly Mono.Cecil.Cil.OpCode Call;
public static readonly Mono.Cecil.Cil.OpCode Calli;
public static readonly Mono.Cecil.Cil.OpCode Callvirt;
public static readonly Mono.Cecil.Cil.OpCode Castclass;
public static readonly Mono.Cecil.Cil.OpCode Ceq;
public static readonly Mono.Cecil.Cil.OpCode Cgt;
public static readonly Mono.Cecil.Cil.OpCode Cgt_Un;
public static readonly Mono.Cecil.Cil.OpCode Ckfinite;
public static readonly Mono.Cecil.Cil.OpCode Clt;
public static readonly Mono.Cecil.Cil.OpCode Clt_Un;
public static readonly Mono.Cecil.Cil.OpCode Constrained;
public static readonly Mono.Cecil.Cil.OpCode Conv_I;
public static readonly Mono.Cecil.Cil.OpCode Conv_I1;
public static readonly Mono.Cecil.Cil.OpCode Conv_I2;
public static readonly Mono.Cecil.Cil.OpCode Conv_I4;
public static readonly Mono.Cecil.Cil.OpCode Conv_I8;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I1;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I1_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I2;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I2_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I4;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I4_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I8;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I8_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U1;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U1_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U2;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U2_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U4;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U4_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U8;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U8_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_R4;
public static readonly Mono.Cecil.Cil.OpCode Conv_R8;
public static readonly Mono.Cecil.Cil.OpCode Conv_R_Un;
public static readonly Mono.Cecil.Cil.OpCode Conv_U;
public static readonly Mono.Cecil.Cil.OpCode Conv_U1;
public static readonly Mono.Cecil.Cil.OpCode Conv_U2;
public static readonly Mono.Cecil.Cil.OpCode Conv_U4;
public static readonly Mono.Cecil.Cil.OpCode Conv_U8;
public static readonly Mono.Cecil.Cil.OpCode Cpblk;
public static readonly Mono.Cecil.Cil.OpCode Cpobj;
public static readonly Mono.Cecil.Cil.OpCode Div;
public static readonly Mono.Cecil.Cil.OpCode Div_Un;
public static readonly Mono.Cecil.Cil.OpCode Dup;
public static readonly Mono.Cecil.Cil.OpCode Endfilter;
public static readonly Mono.Cecil.Cil.OpCode Endfinally;
public static readonly Mono.Cecil.Cil.OpCode Initblk;
public static readonly Mono.Cecil.Cil.OpCode Initobj;
public static readonly Mono.Cecil.Cil.OpCode Isinst;
public static readonly Mono.Cecil.Cil.OpCode Jmp;
public static readonly Mono.Cecil.Cil.OpCode Ldarg;
public static readonly Mono.Cecil.Cil.OpCode Ldarga;
public static readonly Mono.Cecil.Cil.OpCode Ldarga_S;
public static readonly Mono.Cecil.Cil.OpCode Ldarg_0;
public static readonly Mono.Cecil.Cil.OpCode Ldarg_1;
public static readonly Mono.Cecil.Cil.OpCode Ldarg_2;
public static readonly Mono.Cecil.Cil.OpCode Ldarg_3;
public static readonly Mono.Cecil.Cil.OpCode Ldarg_S;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_0;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_1;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_2;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_3;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_4;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_5;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_6;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_7;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_8;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_M1;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_S;
public static readonly Mono.Cecil.Cil.OpCode Ldc_I8;
public static readonly Mono.Cecil.Cil.OpCode Ldc_R4;
public static readonly Mono.Cecil.Cil.OpCode Ldc_R8;
public static readonly Mono.Cecil.Cil.OpCode Ldelema;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_Any;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_I;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_I1;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_I2;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_I4;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_I8;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_R4;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_R8;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_Ref;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_U1;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_U2;
public static readonly Mono.Cecil.Cil.OpCode Ldelem_U4;
public static readonly Mono.Cecil.Cil.OpCode Ldfld;
public static readonly Mono.Cecil.Cil.OpCode Ldflda;
public static readonly Mono.Cecil.Cil.OpCode Ldftn;
public static readonly Mono.Cecil.Cil.OpCode Ldind_I;
public static readonly Mono.Cecil.Cil.OpCode Ldind_I1;
public static readonly Mono.Cecil.Cil.OpCode Ldind_I2;
public static readonly Mono.Cecil.Cil.OpCode Ldind_I4;
public static readonly Mono.Cecil.Cil.OpCode Ldind_I8;
public static readonly Mono.Cecil.Cil.OpCode Ldind_R4;
public static readonly Mono.Cecil.Cil.OpCode Ldind_R8;
public static readonly Mono.Cecil.Cil.OpCode Ldind_Ref;
public static readonly Mono.Cecil.Cil.OpCode Ldind_U1;
public static readonly Mono.Cecil.Cil.OpCode Ldind_U2;
public static readonly Mono.Cecil.Cil.OpCode Ldind_U4;
public static readonly Mono.Cecil.Cil.OpCode Ldlen;
public static readonly Mono.Cecil.Cil.OpCode Ldloc;
public static readonly Mono.Cecil.Cil.OpCode Ldloca;
public static readonly Mono.Cecil.Cil.OpCode Ldloca_S;
public static readonly Mono.Cecil.Cil.OpCode Ldloc_0;
public static readonly Mono.Cecil.Cil.OpCode Ldloc_1;
public static readonly Mono.Cecil.Cil.OpCode Ldloc_2;
public static readonly Mono.Cecil.Cil.OpCode Ldloc_3;
public static readonly Mono.Cecil.Cil.OpCode Ldloc_S;
public static readonly Mono.Cecil.Cil.OpCode Ldnull;
public static readonly Mono.Cecil.Cil.OpCode Ldobj;
public static readonly Mono.Cecil.Cil.OpCode Ldsfld;
public static readonly Mono.Cecil.Cil.OpCode Ldsflda;
public static readonly Mono.Cecil.Cil.OpCode Ldstr;
public static readonly Mono.Cecil.Cil.OpCode Ldtoken;
public static readonly Mono.Cecil.Cil.OpCode Ldvirtftn;
public static readonly Mono.Cecil.Cil.OpCode Leave;
public static readonly Mono.Cecil.Cil.OpCode Leave_S;
public static readonly Mono.Cecil.Cil.OpCode Localloc;
public static readonly Mono.Cecil.Cil.OpCode Mkrefany;
public static readonly Mono.Cecil.Cil.OpCode Mul;
public static readonly Mono.Cecil.Cil.OpCode Mul_Ovf;
public static readonly Mono.Cecil.Cil.OpCode Mul_Ovf_Un;
public static readonly Mono.Cecil.Cil.OpCode Neg;
public static readonly Mono.Cecil.Cil.OpCode Newarr;
public static readonly Mono.Cecil.Cil.OpCode Newobj;
public static readonly Mono.Cecil.Cil.OpCode No;
public static readonly Mono.Cecil.Cil.OpCode Nop;
public static readonly Mono.Cecil.Cil.OpCode Not;
public static readonly Mono.Cecil.Cil.OpCode Or;
public static readonly Mono.Cecil.Cil.OpCode Pop;
public static readonly Mono.Cecil.Cil.OpCode Readonly;
public static readonly Mono.Cecil.Cil.OpCode Refanytype;
public static readonly Mono.Cecil.Cil.OpCode Refanyval;
public static readonly Mono.Cecil.Cil.OpCode Rem;
public static readonly Mono.Cecil.Cil.OpCode Rem_Un;
public static readonly Mono.Cecil.Cil.OpCode Ret;
public static readonly Mono.Cecil.Cil.OpCode Rethrow;
public static readonly Mono.Cecil.Cil.OpCode Shl;
public static readonly Mono.Cecil.Cil.OpCode Shr;
public static readonly Mono.Cecil.Cil.OpCode Shr_Un;
public static readonly Mono.Cecil.Cil.OpCode Sizeof;
public static readonly Mono.Cecil.Cil.OpCode Starg;
public static readonly Mono.Cecil.Cil.OpCode Starg_S;
public static readonly Mono.Cecil.Cil.OpCode Stelem_Any;
public static readonly Mono.Cecil.Cil.OpCode Stelem_I;
public static readonly Mono.Cecil.Cil.OpCode Stelem_I1;
public static readonly Mono.Cecil.Cil.OpCode Stelem_I2;
public static readonly Mono.Cecil.Cil.OpCode Stelem_I4;
public static readonly Mono.Cecil.Cil.OpCode Stelem_I8;
public static readonly Mono.Cecil.Cil.OpCode Stelem_R4;
public static readonly Mono.Cecil.Cil.OpCode Stelem_R8;
public static readonly Mono.Cecil.Cil.OpCode Stelem_Ref;
public static readonly Mono.Cecil.Cil.OpCode Stfld;
public static readonly Mono.Cecil.Cil.OpCode Stind_I;
public static readonly Mono.Cecil.Cil.OpCode Stind_I1;
public static readonly Mono.Cecil.Cil.OpCode Stind_I2;
public static readonly Mono.Cecil.Cil.OpCode Stind_I4;
public static readonly Mono.Cecil.Cil.OpCode Stind_I8;
public static readonly Mono.Cecil.Cil.OpCode Stind_R4;
public static readonly Mono.Cecil.Cil.OpCode Stind_R8;
public static readonly Mono.Cecil.Cil.OpCode Stind_Ref;
public static readonly Mono.Cecil.Cil.OpCode Stloc;
public static readonly Mono.Cecil.Cil.OpCode Stloc_0;
public static readonly Mono.Cecil.Cil.OpCode Stloc_1;
public static readonly Mono.Cecil.Cil.OpCode Stloc_2;
public static readonly Mono.Cecil.Cil.OpCode Stloc_3;
public static readonly Mono.Cecil.Cil.OpCode Stloc_S;
public static readonly Mono.Cecil.Cil.OpCode Stobj;
public static readonly Mono.Cecil.Cil.OpCode Stsfld;
public static readonly Mono.Cecil.Cil.OpCode Sub;
public static readonly Mono.Cecil.Cil.OpCode Sub_Ovf;
public static readonly Mono.Cecil.Cil.OpCode Sub_Ovf_Un;
public static readonly Mono.Cecil.Cil.OpCode Switch;
public static readonly Mono.Cecil.Cil.OpCode Tail;
public static readonly Mono.Cecil.Cil.OpCode Throw;
public static readonly Mono.Cecil.Cil.OpCode Unaligned;
public static readonly Mono.Cecil.Cil.OpCode Unbox;
public static readonly Mono.Cecil.Cil.OpCode Unbox_Any;
public static readonly Mono.Cecil.Cil.OpCode Volatile;
public static readonly Mono.Cecil.Cil.OpCode Xor;
}
public enum OpCodeType
{
Annotation = 0,
Macro = 1,
Nternal = 2,
Objmodel = 3,
Prefix = 4,
Primitive = 5,
}
public enum OperandType
{
InlineArg = 14,
InlineBrTarget = 0,
InlineField = 1,
InlineI = 2,
InlineI8 = 3,
InlineMethod = 4,
InlineNone = 5,
InlinePhi = 6,
InlineR = 7,
InlineSig = 8,
InlineString = 9,
InlineSwitch = 10,
InlineTok = 11,
InlineType = 12,
InlineVar = 13,
ShortInlineArg = 19,
ShortInlineBrTarget = 15,
ShortInlineI = 16,
ShortInlineR = 17,
ShortInlineVar = 18,
}
public sealed partial class PortablePdbReader : Mono.Cecil.Cil.ISymbolReader, System.IDisposable
{
internal PortablePdbReader() { }
public void Dispose() { }
public Mono.Cecil.Cil.ISymbolWriterProvider GetWriterProvider() { throw null; }
public bool ProcessDebugHeader(Mono.Cecil.Cil.ImageDebugHeader header) { throw null; }
public Mono.Cecil.Cil.MethodDebugInformation Read(Mono.Cecil.MethodDefinition method) { throw null; }
}
public sealed partial class PortablePdbReaderProvider : Mono.Cecil.Cil.ISymbolReaderProvider
{
public PortablePdbReaderProvider() { }
public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; }
public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; }
}
public sealed partial class PortablePdbWriter : Mono.Cecil.Cil.ISymbolWriter, System.IDisposable
{
internal PortablePdbWriter() { }
public void Dispose() { }
public Mono.Cecil.Cil.ImageDebugHeader GetDebugHeader() { throw null; }
public Mono.Cecil.Cil.ISymbolReaderProvider GetReaderProvider() { throw null; }
public void Write(Mono.Cecil.Cil.MethodDebugInformation info) { }
}
public sealed partial class PortablePdbWriterProvider : Mono.Cecil.Cil.ISymbolWriterProvider
{
public PortablePdbWriterProvider() { }
public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; }
public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; }
}
public sealed partial class ScopeDebugInformation : Mono.Cecil.Cil.DebugInformation
{
public ScopeDebugInformation(Mono.Cecil.Cil.Instruction start, Mono.Cecil.Cil.Instruction end) { }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.ConstantDebugInformation> Constants { get { throw null; } }
public Mono.Cecil.Cil.InstructionOffset End { get { throw null; } set { } }
public bool HasConstants { get { throw null; } }
public bool HasScopes { get { throw null; } }
public bool HasVariables { get { throw null; } }
public Mono.Cecil.Cil.ImportDebugInformation Import { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.ScopeDebugInformation> Scopes { get { throw null; } }
public Mono.Cecil.Cil.InstructionOffset Start { get { throw null; } set { } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.VariableDebugInformation> Variables { get { throw null; } }
public bool TryGetName(Mono.Cecil.Cil.VariableDefinition variable, out string name) { throw null; }
}
public sealed partial class SequencePoint
{
public SequencePoint(Mono.Cecil.Cil.Instruction instruction, Mono.Cecil.Cil.Document document) { }
public Mono.Cecil.Cil.Document Document { get { throw null; } set { } }
public int EndColumn { get { throw null; } set { } }
public int EndLine { get { throw null; } set { } }
public bool IsHidden { get { throw null; } }
public int Offset { get { throw null; } }
public int StartColumn { get { throw null; } set { } }
public int StartLine { get { throw null; } set { } }
}
public sealed partial class SourceLinkDebugInformation : Mono.Cecil.Cil.CustomDebugInformation
{
public static System.Guid KindIdentifier;
public SourceLinkDebugInformation(string content) { }
public string Content { get { throw null; } set { } }
public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } }
}
public enum StackBehaviour
{
Pop0 = 0,
Pop1 = 1,
Pop1_pop1 = 2,
PopAll = 18,
Popi = 3,
Popi_pop1 = 4,
Popi_popi = 5,
Popi_popi8 = 6,
Popi_popi_popi = 7,
Popi_popr4 = 8,
Popi_popr8 = 9,
Popref = 10,
Popref_pop1 = 11,
Popref_popi = 12,
Popref_popi_popi = 13,
Popref_popi_popi8 = 14,
Popref_popi_popr4 = 15,
Popref_popi_popr8 = 16,
Popref_popi_popref = 17,
Push0 = 19,
Push1 = 20,
Push1_push1 = 21,
Pushi = 22,
Pushi8 = 23,
Pushr4 = 24,
Pushr8 = 25,
Pushref = 26,
Varpop = 27,
Varpush = 28,
}
public sealed partial class StateMachineScope
{
public StateMachineScope(Mono.Cecil.Cil.Instruction start, Mono.Cecil.Cil.Instruction end) { }
public Mono.Cecil.Cil.InstructionOffset End { get { throw null; } set { } }
public Mono.Cecil.Cil.InstructionOffset Start { get { throw null; } set { } }
}
public sealed partial class StateMachineScopeDebugInformation : Mono.Cecil.Cil.CustomDebugInformation
{
public static System.Guid KindIdentifier;
public StateMachineScopeDebugInformation() { }
public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } }
public Mono.Collections.Generic.Collection<Mono.Cecil.Cil.StateMachineScope> Scopes { get { throw null; } }
}
[System.SerializableAttribute]
public sealed partial class SymbolsNotFoundException : System.IO.FileNotFoundException
{
public SymbolsNotFoundException(string message) { }
}
[System.SerializableAttribute]
public sealed partial class SymbolsNotMatchingException : System.InvalidOperationException
{
public SymbolsNotMatchingException(string message) { }
}
[System.FlagsAttribute]
public enum VariableAttributes : ushort
{
DebuggerHidden = (ushort)1,
None = (ushort)0,
}
public sealed partial class VariableDebugInformation : Mono.Cecil.Cil.DebugInformation
{
public VariableDebugInformation(Mono.Cecil.Cil.VariableDefinition variable, string name) { }
public Mono.Cecil.Cil.VariableAttributes Attributes { get { throw null; } set { } }
public int Index { get { throw null; } }
public bool IsDebuggerHidden { get { throw null; } set { } }
public string Name { get { throw null; } set { } }
}
public sealed partial class VariableDefinition : Mono.Cecil.Cil.VariableReference
{
public VariableDefinition(Mono.Cecil.TypeReference variableType) { }
public bool IsPinned { get { throw null; } }
public override Mono.Cecil.Cil.VariableDefinition Resolve() { throw null; }
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct VariableIndex
{
private object _dummy;
private int _dummyPrimitive;
public VariableIndex(Mono.Cecil.Cil.VariableDefinition variable) { throw null; }
public VariableIndex(int index) { throw null; }
public int Index { get { throw null; } }
}
public abstract partial class VariableReference
{
internal VariableReference() { }
protected Mono.Cecil.TypeReference variable_type;
public int Index { get { throw null; } }
public Mono.Cecil.TypeReference VariableType { get { throw null; } set { } }
public abstract Mono.Cecil.Cil.VariableDefinition Resolve();
public override string ToString() { throw null; }
}
}
namespace Mono.Collections.Generic
{
public partial class Collection<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList
{
public Collection() { }
public Collection(System.Collections.Generic.ICollection<T> items) { }
public Collection(int capacity) { }
public int Capacity { get { throw null; } set { } }
public int Count { get { throw null; } }
public T this[int index] { get { throw null; } set { } }
bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { throw null; } }
int System.Collections.ICollection.Count { get { throw null; } }
bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
object System.Collections.ICollection.SyncRoot { get { throw null; } }
bool System.Collections.IList.IsFixedSize { get { throw null; } }
bool System.Collections.IList.IsReadOnly { get { throw null; } }
object System.Collections.IList.this[int index] { get { throw null; } set { } }
public void Add(T item) { }
public void Clear() { }
public bool Contains(T item) { throw null; }
public void CopyTo(T[] array, int arrayIndex) { }
public Mono.Collections.Generic.Collection<T>.Enumerator GetEnumerator() { throw null; }
public int IndexOf(T item) { throw null; }
public void Insert(int index, T item) { }
protected virtual void OnAdd(T item, int index) { }
protected virtual void OnClear() { }
protected virtual void OnInsert(T item, int index) { }
protected virtual void OnRemove(T item, int index) { }
protected virtual void OnSet(T item, int index) { }
public bool Remove(T item) { throw null; }
public void RemoveAt(int index) { }
protected void Resize(int new_size) { }
System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
int System.Collections.IList.Add(object value) { throw null; }
void System.Collections.IList.Clear() { }
bool System.Collections.IList.Contains(object value) { throw null; }
int System.Collections.IList.IndexOf(object value) { throw null; }
void System.Collections.IList.Insert(int index, object value) { }
void System.Collections.IList.Remove(object value) { }
void System.Collections.IList.RemoveAt(int index) { }
public T[] ToArray() { throw null; }
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable
{
private T current;
private object _dummy;
private int _dummyPrimitive;
public T Current { get { throw null; } }
object System.Collections.IEnumerator.Current { get { throw null; } }
public void Dispose() { }
public bool MoveNext() { throw null; }
public void Reset() { }
}
}
public sealed partial class ReadOnlyCollection<T> : Mono.Collections.Generic.Collection<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList
{
public ReadOnlyCollection(Mono.Collections.Generic.Collection<T> collection) { }
public ReadOnlyCollection(T[] array) { }
public static Mono.Collections.Generic.ReadOnlyCollection<T> Empty { get { throw null; } }
bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { throw null; } }
bool System.Collections.IList.IsFixedSize { get { throw null; } }
bool System.Collections.IList.IsReadOnly { get { throw null; } }
protected override void OnAdd(T item, int index) { }
protected override void OnClear() { }
protected override void OnInsert(T item, int index) { }
protected override void OnRemove(T item, int index) { }
protected override void OnSet(T item, int index) { }
}
}
Reference in New Issue View Git Blame Copy Permalink