Dotsider.Core.Analysis.Models
Classes
Section titled “Classes”Records that a requested identity was rewritten by .NET Framework binding policy. Carried on AppliedPolicy so the UI can render “↪ redirected 1.0.0.0 → 13.0.0.0 via app.config” without inventing new AssemblyProvenance values for redirected hits — a redirect-applied AppLocal hit is still AppLocal, just with this annotation attached.
public sealed record AppliedPolicy : IEquatable<AppliedPolicy>The complete diff result between two assemblies.
public sealed record AssemblyDiffResult : IEquatable<AssemblyDiffResult>The result of opening an assembly file via AssemblyLoader, distinguishing between direct loads, apphost companion redirects, and single-file bundle entry extractions.
public abstract record AssemblyOpenResult : IEquatable<AssemblyOpenResult>The file is a native apphost with a companion managed .dll on disk. The caller decides when to redirect (e.g. showing a dialog first).
public sealed record AssemblyOpenResult.ApphostWithCompanion : AssemblyOpenResult, IEquatable<AssemblyOpenResult>, IEquatable<AssemblyOpenResult.ApphostWithCompanion>The file is a single-file bundle. The entry assembly has been extracted from the bundle and is ready for analysis.
public sealed record AssemblyOpenResult.BundleEntry : AssemblyOpenResult, IEquatable<AssemblyOpenResult>, IEquatable<AssemblyOpenResult.BundleEntry>Direct load — the file is a .dll or .exe with metadata, a raw WebAssembly module, or a native binary with no metadata and no ReadyToRun header (unknown format).
public sealed record AssemblyOpenResult.Direct : AssemblyOpenResult, IEquatable<AssemblyOpenResult>, IEquatable<AssemblyOpenResult.Direct>The file is a Native AOT compiled .NET binary: a valid PE, ELF, or Mach-O with no COR header whose image embeds a validated ReadyToRun header. No metadata is available, but PE structure, native import/export/load-config directories, and raw strings are.
public sealed record AssemblyOpenResult.NativeAot : AssemblyOpenResult, IEquatable<AssemblyOpenResult>, IEquatable<AssemblyOpenResult.NativeAot>Information about a referenced assembly from the AssemblyRef metadata table.
public sealed record AssemblyRefInfo : IEquatable<AssemblyRefInfo>Outcome of an identity-based assembly resolution. Carries everything the dependency-graph builder and UI need: the resolved assembly or module (or null on failure), the provenance classifying how the file was located, the candidate path of an identity-mismatched simple-name hit, and — for .NET Framework binds — the policy-layer attribution and the effective bound identity.
public sealed record AssemblyResolution : IEquatable<AssemblyResolution>Aggregated .NET Framework binding policy assembled from framework unification, machine.config, publisher-policy assemblies, and the application configuration file. Layers are stored in document order with first-match semantics — the same model the CLR applies — and later layers (machine.config > publisher > app > framework unification) override earlier ones when they target the same identity.
public sealed record BindingPolicy : IEquatable<BindingPolicy>Output of NetFxRuntimeVersion): the redirects, codeBase entries, per-identity publisher-policy disablements, probing privatePath segments, and the runtime-scoped publisher-policy bypass flag found in a single configuration file.
public sealed record BindingPolicyParseResult : IEquatable<BindingPolicyParseResult>One <bindingRedirect> entry parsed from a .NET Framework configuration file
or a publisher-policy assembly’s embedded XML resource.
public sealed record BindingRedirect : IEquatable<BindingRedirect>Describes a single file entry within a .NET single-file bundle.
public sealed record BundleEntry : IEquatable<BundleEntry>The parsed manifest header of a .NET single-file bundle.
public sealed record BundleManifest : IEquatable<BundleManifest>CLR (Common Language Runtime) header information from the PE file’s COR20 header.
public sealed record ClrHeader : IEquatable<ClrHeader>One <codeBase> entry parsed from a .NET Framework configuration file or
publisher-policy assembly. CodeBase entries are honored only for strong-named binds at
the version specified.
public sealed record CodeBaseEntry : IEquatable<CodeBaseEntry>One of several methods a name query matched. Overloads share a name, so an ambiguous query surfaces every candidate rather than guessing which the caller meant.
public sealed record CorrelationCandidate : IEquatable<CorrelationCandidate>The result of a CorrelationQuery: an Outcome with exactly the payload that outcome carries — a Report when resolved, a candidate list when ambiguous, a Message explaining a miss or an unavailable index.
public sealed record CorrelationQueryResult : IEquatable<CorrelationQueryResult>The resolved correlation payload shared verbatim by every programmatic surface — the CLI
--correlate option, the session correlate-method command, and the MCP
correlate_method tool — so a method’s pre-ILC IL and its native code are reported
identically wherever they are requested.
public sealed record CorrelationReport : IEquatable<CorrelationReport>One native symbol carrying a correlated method’s compiled code, flattened for the programmatic surfaces (CLI, session, MCP) that report a correlation.
public sealed record CorrelationReportSymbol : IEquatable<CorrelationReportSymbol>A snapshot of runtime performance counters at a point in time.
public sealed record CounterSnapshot : IEquatable<CounterSnapshot>Information about a custom attribute applied to a metadata entity.
public sealed record CustomAttributeInfo : IEquatable<CustomAttributeInfo>Display-ready PE debug directory entry information.
public sealed record DebugDirectoryInfo : IEquatable<DebugDirectoryInfo>The result of building a transitive assembly dependency graph. Contains the public topology consumed by serializers (Nodes, Edges) and the internal navigation metadata consumed by the TUI (NavigationById).
public sealed record DependencyGraphResult : IEquatable<DependencyGraphResult>An ILC dependency graph read from a DGML file, with the reverse index needed to answer “why is this in my binary”: a breadth-first walk from any node toward its dependers ends at a root — a node nothing depends on — and the chain back down is the explanation.
public sealed class DgmlGraphOne edge of an ILC dependency graph: the source node depends on the target node, so the target is in the binary because the source needed it.
public sealed record DgmlLink : IEquatable<DgmlLink>One node of an ILC dependency graph. The label is the compiler’s node name — the same
string an mstat size entry stores as its NodeName, which is how the two files join.
public sealed record DgmlNode : IEquatable<DgmlNode>One step of a root-to-node dependency chain — the answer to “why is this in my binary,” read top-down: the root kept the second step, which kept the third, and so on to the node that was asked about.
public sealed record DgmlPathStep : IEquatable<DgmlPathStep>A single diff entry wrapping an item from either side.
public sealed record DiffEntry<T> : IEquatable<DiffEntry<T>>Summary statistics for the diff.
public sealed record DiffSummary : IEquatable<DiffSummary>Embedded source decoded from a portable PDB document.
public sealed record EmbeddedSourceInfo : IEquatable<EmbeddedSourceInfo>A single entry in the PE export table.
public sealed record ExportedFunctionInfo : IEquatable<ExportedFunctionInfo>Information about a field defined in the assembly’s FieldDef metadata table.
public sealed record FieldDefInfo : IEquatable<FieldDefInfo>A directed edge from a referencing assembly to a referenced assembly in the transitive dependency graph. Edges are retained for cycles and diamonds: revisiting an already-seen target identity emits a new edge but does not re-expand the target’s subtree.
public sealed record GraphEdge : IEquatable<GraphEdge>Internal per-node metadata describing how a dependency graph node was resolved and the context under which it was reached. Used by the TUI for Enter-to-open navigation and framework filtering. Never serialized — this data must not leak through CLI, diagnostics, or MCP surfaces that publish graph topology.
public sealed record GraphNavigationContext : IEquatable<GraphNavigationContext>A node in the transitive assembly dependency graph. Topology only — layout coordinates and rendered labels are the responsibility of the view layer, which projects the visible subgraph into a separate render model so filters and viewport changes rebalance without perturbing this record.
public sealed record GraphNode : IEquatable<GraphNode>A single decoded IL (Intermediate Language) instruction.
public sealed record IlInstruction : IEquatable<IlInstruction>Represents the resolved target of an IL code navigation (go-to-definition) action.
public abstract record IlNavigationTarget : IEquatable<IlNavigationTarget>A field in an external (referenced) assembly.
public sealed record IlNavigationTarget.ExternalField : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.ExternalField>A method in an external (referenced) assembly.
public sealed record IlNavigationTarget.ExternalMethod : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.ExternalMethod>A type in an external (referenced) assembly.
public sealed record IlNavigationTarget.ExternalType : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.ExternalType>A MethodSpec whose metadata could not be decoded into a navigable target.
public sealed record IlNavigationTarget.GenericInstantiation : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.GenericInstantiation>A field defined in the current assembly.
public sealed record IlNavigationTarget.LocalField : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.LocalField>A method defined in the current assembly.
public sealed record IlNavigationTarget.LocalMethod : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.LocalMethod>A type defined in the current assembly.
public sealed record IlNavigationTarget.LocalType : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.LocalType>A token that could not be resolved to any known target.
public sealed record IlNavigationTarget.Unresolved : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.Unresolved>A token kind that is recognized but not supported for navigation.
public sealed record IlNavigationTarget.Unsupported : IlNavigationTarget, IEquatable<IlNavigationTarget>, IEquatable<IlNavigationTarget.Unsupported>A single function imported from a native module.
public sealed record ImportedFunctionInfo : IEquatable<ImportedFunctionInfo>A module referenced by a PE, ELF, Mach-O, or WebAssembly import table, with the functions imported from it.
public sealed record ImportedModuleInfo : IEquatable<ImportedModuleInfo>Parsed PE load configuration directory. Pointer-width fields are widened to UInt64 so a single record covers PE32 and PE32+ images. Fields beyond the directory’s declared size are zero — real-world load configs are truncated at many historical lengths.
public sealed record LoadConfigInfo : IEquatable<LoadConfigInfo>Per-loaded-identity entry interned in LoadedAssemblyCache. When two distinct requested
identities redirect to the same loaded identity, both Loaded
values reference-equal this single entry, faithfully modeling the CLR’s “already loaded”
reuse: only one filesystem read per loaded identity.
public sealed record LoadedAssemblyEntry : IEquatable<LoadedAssemblyEntry>A PDB local variable slot and the IL range where its name is active.
public sealed record LocalSlotInfo : IEquatable<LocalSlotInfo>One managed assembly’s contribution to a managed↔native correlation build: its simple name (ILC embeds it in every mangled symbol) and its method definitions.
public sealed record ManagedMethodSource : IEquatable<ManagedMethodSource>Information about a referenced member (method or field) from the MemberRef metadata table.
public sealed record MemberRefInfo : IEquatable<MemberRefInfo>One pre-ILC managed method joined to its native evidence: the symbols that carry its compiled code and the mstat rows that carry its sizes.
public sealed record MethodCorrelation : IEquatable<MethodCorrelation>Portable PDB debug information for a method.
public sealed record MethodDebugInfo : IEquatable<MethodDebugInfo>Information about a method defined in the assembly’s MethodDef metadata table.
public sealed record MethodDefInfo : IEquatable<MethodDefInfo>One named global data region from an ILC size report — embedded metadata, hydration
tables, dispatch maps, and the like. Blob names come from the compiler’s node type names
(for example Metadata or InterfaceDispatchMap), with same-named regions
summed into one entry.
public sealed record MstatBlob : IEquatable<MstatBlob>The contents of an ILC size report (.mstat), produced by publishing a Native AOT
project with IlcGenerateMstatFile. The file is itself a valid ECMA-335 assembly whose
assembly version carries the format version and whose data lives in IL streams; this record
is the decoded result. Sections absent from older format versions are empty lists.
public sealed record MstatData : IEquatable<MstatData>One method-body fold from an ILC size report (format 2.2+): the compiler emitted a single body and pointed these identical methods at it, so only the original contributes size.
public sealed record MstatDeduplicatedMethod : IEquatable<MstatDeduplicatedMethod>The complete result of comparing two ILC size reports: a hierarchical delta tree for treemap rendering, headline figures, the flat contributor list a CI log prints, and the per-assembly / per-namespace aggregates that size budgets evaluate against.
public sealed record MstatDiffResult : IEquatable<MstatDiffResult>One frozen object from an ILC size report (format 2.1+) — an object allocated at compile
time and baked into the image, most commonly a string literal. For back-compat these bytes
are also summed into the ArrayOfFrozenObjects blob entry.
public sealed record MstatFrozenObject : IEquatable<MstatFrozenObject>One embedded manifest resource from an ILC size report (format 2.1+). For back-compat
these bytes are also summed into the ResourceData blob entry.
public sealed record MstatManifestResource : IEquatable<MstatManifestResource>One compiled method body from an ILC size report. Sizes are bytes of native artifact, not IL: ILC compiles each body once, so the sum over all methods is the code contribution to the binary.
public sealed record MstatMethod : IEquatable<MstatMethod>One field-RVA data entry from an ILC size report (format 2.1+) — the initial data of a
field mapped directly into the image, typically compiler-generated arrays behind
collection expressions and ReadOnlySpan literals. For back-compat these bytes are
also summed into the FieldRvaData blob entry.
public sealed record MstatRvaField : IEquatable<MstatRvaField>One normalized entry of an MstatSizeIndex: raw report rows aggregated under a build-stable identity key, with the structured hierarchy fields a consumer needs to place the entry in an assembly → namespace → type → leaf tree without parsing display strings.
public sealed record MstatSizeEntry : IEquatable<MstatSizeEntry>A resolved mstat input: the decoded report plus where it came from. Produced by
MstatLocator from either a bare .mstat file or
a Native AOT binary with a size-report sidecar.
public sealed record MstatSource : IEquatable<MstatSource>One constructed type from an ILC size report. The size is the type’s MethodTable data — the runtime type structure — not the code of its methods, which is reported per method.
public sealed record MstatType : IEquatable<MstatType>Facts extracted from the embedded ReadyToRun header of a Native AOT binary. Every Native AOT image embeds this header (signature “RTR\0”) so the runtime can locate its module sections; its presence with no COR header identifies the binary as Native AOT compiled .NET.
public sealed record NativeAotInfo : IEquatable<NativeAotInfo>One decoded native instruction. The model is structured — bytes, structured operands, flow and target metadata, and source attribution — so navigation, JSON/MCP output, syntax decoration, and future diffing read facts rather than parse text. OperandText and the rendered listing line are projections; Address is the semantic key and DisplayLine the presentation key, mirroring IlInstruction for the shared IL-Inspector plumbing.
public sealed record NativeInstruction : IEquatable<NativeInstruction>One decoded operand of a NativeInstruction, carried structurally so navigation, JSON/MCP output, syntax decoration, and future diffing never parse the rendered text. The Text is the display projection; the typed fields describe what it renders.
public sealed record NativeOperand : IEquatable<NativeOperand>One address→source mapping row recovered from a native sidecar (PDB C13 line table, DWARF/dSYM line program): the virtual address a source line begins at, its byte length, and the file and 1-based line number.
public sealed record NativeSourceLine : IEquatable<NativeSourceLine>An address-sorted map from virtual address to source file and line, aggregated from a native
binary’s debug sidecar. Int32%40) resolves an instruction address to its source
location the way NativeSymbol%40) resolves an address to a symbol,
letting the disassembler annotate the listing with // file:line where the sidecar has data.
public sealed record NativeSourceMap : IEquatable<NativeSourceMap>One native symbol recovered from a binary: a function, a compiler-generated data blob, or a nameless boundary. The address is carried in every form a consumer might need — virtual address for display and cross-symbol ordering, PE RVA, file offset when the address is file-backed, and the containing section — so the UI, hex views, and disassembly never have to recompute a mapping.
public sealed record NativeSymbol : IEquatable<NativeSymbol>The native symbols recovered from a binary, plus the provenance and status needed to explain the result. Symbols are ordered by VirtualAddress, which NativeSymbol%40) relies on to resolve an address to its containing symbol — the lookup the disassembly and hex views use to name code.
public sealed record NativeSymbolInfo : IEquatable<NativeSymbolInfo>Per-root metadata required to drive a CLR-accurate .NET Framework bind. Built once per analyzed root via AssemblyAnalyzer); carried alongside the analyzer through every resolution surface (Dep Graph, IL navigation, General-tab drill-in, type-forwarder chase) so that every code path produces the same answer for any .NET Framework reference.
public sealed record NetFxBindingContext : IEquatable<NetFxBindingContext>Result of a single .NET Framework bind. Carries the requested identity, the effective identity after policy was applied, the loaded identity (when binding succeeded), the file path the CLR would load, the provenance classification, the policy-layer attribution, and (when binding failed) a human-readable reason for UI surfacing.
public sealed record NetFxBindResult : IEquatable<NetFxBindResult>Represents a file entry within a NuGet package (.nupkg).
public sealed record NuGetFileEntry : IEquatable<NuGetFileEntry>A line of output captured from the traced process’s stdout or stderr.
public sealed record OutputLine : IEquatable<OutputLine>Describes where portable PDB information was found, or why it could not be used.
public sealed record PdbProvenance : IEquatable<PdbProvenance>Aggregated PE header information for a .NET assembly.
public sealed record PeHeaders : IEquatable<PeHeaders>The attached pre-ILC companions of a Native AOT binary: the root managed input and any validated local reference assemblies.
public sealed class PreIlcCompanionSetThe pre-ILC build outputs found for a Native AOT binary: the managed input assembly ILC compiled, its portable PDB, and any mstat/DGML sidecars discovered in the build’s intermediate tree. A result exists whenever anything was found — mstat/DGML-only results feed silent fallbacks, while the attach/offer flow gates on HasAttachableCompanion.
public sealed record PreIlcSidecars : IEquatable<PreIlcSidecars>One contiguous block of a precompiled ReadyToRun method’s native code, derived from a single runtime function. A method body is not one slice: it is the ordered list of these ranges (hot entry, funclets, cold), each of which is disassembled, sized, and navigated on its own.
public sealed record ReadyToRunCodeRange : IEquatable<ReadyToRunCodeRange>One component assembly of a composite ReadyToRun image, from the ComponentAssemblies
section joined to the manifest and its MVIDs. Its native code lives in the composite; its
metadata is resolved from a sibling assembly matched by name and MVID.
public sealed record ReadyToRunComponent : IEquatable<ReadyToRunComponent>The parsed facts about a PE image’s crossgen2 ReadyToRun header. Present whenever an image
claims to be ReadyToRun (a managed native header directory or an RTR_HEADER export);
Status says whether it is usable, so a corrupt or unsupported image surfaces
its diagnostic rather than masquerading as plain managed.
public sealed record ReadyToRunInfo : IEquatable<ReadyToRunInfo>A managed method joined to its precompiled ReadyToRun native code: the owning assembly identity, the MethodDef token (or the instantiation for a generic), and the full ordered list of ReadyToRunCodeRange blocks that make up the body.
public sealed record ReadyToRunMethodEntry : IEquatable<ReadyToRunMethodEntry>The resolved ReadyToRun correlation for one method, shared verbatim by the CLI
--r2r-correlate option, the MCP correlate_r2r_method tool, and the session
r2r-correlate command. Carries both rendered text and structured instruction arrays so
programmatic callers get the IL and native code, not just formatted output.
public sealed record ReadyToRunMethodReport : IEquatable<ReadyToRunMethodReport>The result of a ReadyToRunCorrelationQuery: an Outcome with exactly the payload that outcome carries — a Report when resolved, a candidate list when ambiguous, a Message explaining a miss or an unavailable image.
public sealed record ReadyToRunQueryResult : IEquatable<ReadyToRunQueryResult>One row of a crossgen2 image’s READYTORUN_SECTION table: a section type and the
{RVA, Size} data directory that locates it. Rendered by the PE/Metadata “R2R Sections”
tab for ReadyToRun images.
public sealed record ReadyToRunSectionEntry : IEquatable<ReadyToRunSectionEntry>A type recovered from a Native AOT binary’s embedded NativeFormat metadata. ILC strips ECMA-335 metadata, but the reflection and stack-trace metadata it keeps still names the binary’s own types and methods, so a stripped binary can describe itself.
public sealed record RecoveredType : IEquatable<RecoveredType>The result of resolving an assembly reference to an assembly file, a bundle entry, or an authenticated sibling module.
public abstract record ResolvedAssembly : IEquatable<ResolvedAssembly>The assembly was found inside a single-file bundle.
public sealed record ResolvedAssembly.FromBundle : ResolvedAssembly, IEquatable<ResolvedAssembly>, IEquatable<ResolvedAssembly.FromBundle>The assembly was found as a file on disk.
public sealed record ResolvedAssembly.FromFile : ResolvedAssembly, IEquatable<ResolvedAssembly>, IEquatable<ResolvedAssembly.FromFile>Represents a metadata-bearing sibling module whose bytes were read and authenticated while resolving the manifest assembly’s File table entry.
public sealed record ResolvedModule : ResolvedAssembly, IEquatable<ResolvedAssembly>, IEquatable<ResolvedModule>Information about a managed resource embedded in the assembly.
public sealed record ResourceInfo : IEquatable<ResourceInfo>One entry in a Native AOT binary’s ReadyToRun section table. Each section describes a runtime data region — frozen objects, GC statics, dehydrated data, or a readonly blob such as the embedded metadata — the way an ECMA-335 table describes a managed assembly.
public sealed record RtrSection : IEquatable<RtrSection>Information about a single PE section (e.g., .text, .rsrc, .reloc).
public sealed record SectionInfo : IEquatable<SectionInfo>A source sequence point decoded from a portable PDB.
public sealed record SequencePointInfo : IEquatable<SequencePointInfo>One size budget: a scope plus at least one limit. Parsed from the spec grammar
([scope:]limit(,limit)* — for example total:max=25mb,growth=1% or
ns=System.Text.Json:growth=10kb) by
SizeBudgetParser, or from a budget file’s object form
which can also carry a name, description, severity, and per-budget contributor count.
public sealed record SizeBudget : IEquatable<SizeBudget>The outcome of evaluating one size budget: the measured values, any breached limits, and the top positive regressions inside the budget’s scope — the rows that explain a growth breach, never diluted by improvements elsewhere.
public sealed record SizeBudgetEvaluation : IEquatable<SizeBudgetEvaluation>The outcome of checking a build against a set of size budgets. The check fails — Passed is false — only when an error-severity budget breached; warning breaches surface through HasWarnings without failing the check.
public sealed record SizeBudgetReport : IEquatable<SizeBudgetReport>One breached limit of a size budget. Every figure is expressed in bytes — for the percent metric the limit is resolved against the baseline so the overage stays a byte count — with the percentages carried alongside where they apply.
public sealed record SizeBudgetViolation : IEquatable<SizeBudgetViolation>The byte totals of one assembly or namespace on both sides of a size diff. Aggregates cover all attributable bytes for their scope — methods, MethodTables, RVA fields, frozen objects via their owner, and (for assemblies) resources — so a scoped size budget measures what the scope actually contributes.
public sealed record SizeDiffAggregate : IEquatable<SizeDiffAggregate>One changed entry of a size diff in flat form — the shape a CI log or a budget violation prints. Contributors carry the same identity and attribution as their tree leaves.
public sealed record SizeDiffContributor : IEquatable<SizeDiffContributor>Entry counts for one node kind in a size diff, split by direction. Grown and shrunk are the two signs of a changed entry; unchanged entries are counted here but never appear in the delta tree.
public sealed record SizeDiffKindCounts : IEquatable<SizeDiffKindCounts>A node in the hierarchical size-difference tree between two Native AOT builds. The tree contains changed subtrees only — added, removed, grown, and shrunk entries; unchanged mass is summarized in SizeDiffSummary instead of carried as zero-delta nodes.
public sealed record SizeDiffNode : IEquatable<SizeDiffNode>The headline figures of a size diff between two Native AOT builds. Totals are mstat
attributable bytes — the same figures analyze --size reports for each build alone.
public sealed record SizeDiffSummary : IEquatable<SizeDiffSummary>A node in the size treemap hierarchy. Can be assembly, namespace, type, or method — or, for Native AOT trees, a data category and its entries.
public sealed record SizeNode : IEquatable<SizeNode>The basis-resolved totals of a size comparison: file sizes when every provided input is a
binary, mstat attributable totals when a bare .mstat is anywhere in the pair — both
sides always share one basis so the figures stay comparable.
public sealed record SizeTotals : IEquatable<SizeTotals>Source Link mappings decoded from portable PDB custom debug information.
public sealed record SourceLinkInfo : IEquatable<SourceLinkInfo>A single Source Link document mapping.
public sealed record SourceLinkMapping : IEquatable<SourceLinkMapping>A string extracted from the assembly, along with its source and offset.
public sealed record StringEntry : IEquatable<StringEntry>A single traced runtime event captured from the EventPipe session.
public sealed record TraceEventEntry : IEquatable<TraceEventEntry>Summary statistics aggregated from all collected trace events.
public sealed record TraceSummary : IEquatable<TraceSummary>Information about a type defined in the assembly’s TypeDef metadata table.
public sealed record TypeDefInfo : IEquatable<TypeDefInfo>Information about a referenced type from the TypeRef metadata table.
public sealed record TypeRefInfo : IEquatable<TypeRefInfo>One WebAssembly data segment.
public sealed record WasmDataSegmentInfo : IEquatable<WasmDataSegmentInfo>One WebAssembly element segment declaration.
public sealed record WasmElementSegmentInfo : IEquatable<WasmElementSegmentInfo>One WebAssembly export entry.
public sealed record WasmExportInfo : IEquatable<WasmExportInfo>A WebAssembly function, imported or defined in the code section.
public sealed record WasmFunctionInfo : IEquatable<WasmFunctionInfo>One WebAssembly global declaration.
public sealed record WasmGlobalInfo : IEquatable<WasmGlobalInfo>One WebAssembly import entry.
public sealed record WasmImportInfo : IEquatable<WasmImportInfo>A run-length encoded local declaration inside a WebAssembly function body.
public sealed record WasmLocalInfo : IEquatable<WasmLocalInfo>One WebAssembly memory declaration.
public sealed record WasmMemoryInfo : IEquatable<WasmMemoryInfo>Parsed facts for a WebAssembly module, including its functions and optional .NET symbol map.
public sealed record WasmModuleInfo : IEquatable<WasmModuleInfo>One section in a WebAssembly module, including custom sections.
public sealed record WasmSectionInfo : IEquatable<WasmSectionInfo>One WebAssembly table declaration.
public sealed record WasmTableInfo : IEquatable<WasmTableInfo>One WebAssembly exception tag declaration.
public sealed record WasmTagInfo : IEquatable<WasmTagInfo>One WebAssembly function type from the type section.
public sealed record WasmTypeInfo : IEquatable<WasmTypeInfo>Parsed provenance for a Webcil managed assembly, including whether it was wrapped inside a WebAssembly module. Webcil is a .NET metadata container used by browser-wasm publishes, so dotsider routes it through the managed metadata and IL experience.
public sealed record WebcilInfo : IEquatable<WebcilInfo>Structs
Section titled “Structs”Decides which of an mstat’s 2.1+ detail sections carry the bytes that the format
double-reports into blob buckets. Every 2.x report sums frozen object, field RVA, and
resource bytes into the ArrayOfFrozenObjects, FieldRvaData, and
ResourceData blobs for back-compat; a reader must pick, per section, either the
detail entries or the bucket blob — never both. Sharing this policy between
SizeAnalyzer, MstatSizeIndex,
and MstatDiffer is what keeps their totals identical.
public readonly struct MstatSectionPolicy : IEquatable<MstatSectionPolicy>The column ranges of the mnemonic, operands, and target within a rendered disassembly line, set by NativeDisassembler’s text formatter. The TUI decoration providers highlight and hit-test by these spans rather than re-parsing the line, so the rendered text stays a pure projection of the structured instruction.
public readonly struct NativeLineLayout : IEquatable<NativeLineLayout>A resolved reference to the symbol containing a target address, with the offset into it — so a
call or branch landing inside a function displays honestly as Foo+0x12 rather than
failing or pretending an exact hit.
public readonly struct NativeSymbolRef : IEquatable<NativeSymbolRef>Describes how an assembly in the dependency graph was located — or why it could not be.
public enum AssemblyProvenanceCoarse classification of an analyzed binary.
public enum BinaryKindIdentifies the type of file embedded in a .NET single-file bundle.
public enum BundleFileType : byteThe outcome of a CorrelationQuery: how a method-or-address query resolved against an attached companion set’s correlation index.
public enum CorrelationQueryOutcomeDescribes the kind of difference detected between two assembly elements.
public enum DiffKindWhat a dependency-graph node represents. Managed graphs contain only assemblies; the Native AOT graph adds the binary’s native import modules.
public enum GraphNodeKindDistinguishes whether a MemberRef entry refers to a method or a field.
public enum MemberRefKindHow a pre-ILC managed method relates to the native image it was compiled into.
public enum MethodCorrelationStatusThe report section a normalized MstatSizeEntry came from. Each section has its own identity key shape and attribution rules; see MstatSizeIndex.
public enum MstatSectionKindThe instruction-set architecture a native code window is decoded as. Carried on NativeSymbolInfo from the real image (or the selected fat-Mach-O slice) so the disassembler never has to guess from an ambiguous machine string.
public enum NativeArchitectureHow a decoded instruction affects control flow. Drives listing navigation (which instructions carry a jumpable target) and future analysis without re-parsing the mnemonic.
public enum NativeFlowKindA coarse classification of a decoded instruction by function, for grouping, coloring, and summaries without inspecting the mnemonic string.
public enum NativeInstructionCategoryThe kind of a decoded operand, so consumers (JSON, decoration, diffing) read structure rather than parsing the rendered text.
public enum NativeOperandKindWhat a native symbol represents. Native AOT binaries carry compiler-generated code and data symbols beyond ordinary functions; this classification drives the Size Map’s category grouping and the symbol view’s presentation.
public enum NativeSymbolKindWhere a binary’s native symbols came from. The three primary sources carry names and (mostly) sizes; the three fallback sources recover only function boundaries from unwind data and are lower fidelity — they can miss leaf and thunk functions.
public enum NativeSymbolSourceThe outcome of probing a binary for native symbols. When no symbols are returned, the status distinguishes the reasons — missing, mismatched, corrupt, ambiguous, or fallback-only — so callers can explain the result instead of showing an empty table with no cause.
public enum NativeSymbolStatusWhat a decoded instruction’s resolved TargetAddress points at, so the view can style and navigate a call/branch/data reference correctly.
public enum NativeTargetKindEffective process bitness for a .NET Framework root assembly. Models actual runtime
architecture, not the PE’s compile-time descriptor — AnyCPU is a compile-time attribute
that resolves to host bitness at load time, so there is no MSIL runtime arch.
public enum NetFxArchitecture.NET Framework CLR version a NetFxBindingContext targets. The CLR version (not
the product TFM) drives the binding pipeline because the GAC layout, machine.config path,
framework runtime directory, reference-assemblies tree, and appliesTo filter all switch
on the CLR generation: Clr2 covers .NET Framework 2.0 / 3.0 / 3.5 SP1 (process
runs on v2.0.50727); Clr4 covers .NET Framework 4.0 through 4.8.x
(process runs on v4.0.30319).
public enum NetFxRuntimeVersionPortable PDB discovery outcomes that are meaningful to .NET developers.
public enum PdbProvenanceKindIdentifies which layer of .NET Framework binding policy rewrote a requested assembly
identity. The CLR walks app config first, then publisher policy (unless bypassed by
<publisherPolicy apply="no"/>), then machine.config; later layers override
earlier ones, so the effective winner is machine.config > publisher > app >
framework unification.
public enum PolicyLayerHow the pre-ILC managed input of a Native AOT binary was located, ordered from most to least authoritative.
public enum PreIlcAssemblyOriginThe portable-PDB situation of a located pre-ILC managed assembly.
public enum PreIlcPdbStatusWhat a ReadyToRunCodeRange represents within a precompiled method’s body. An R2R method owns one hot entry, zero or more funclets, and an optional disjoint cold range.
public enum ReadyToRunCodeRangeKindWhy a managed method does or does not have inspectable ReadyToRun native code. Distinguishing these keeps a correlation report honest — a missing composite or unresolved component metadata is not the same as a genuinely IL-only method.
public enum ReadyToRunNativeAvailabilityThe outcome of a ReadyToRunCorrelationQuery: how a method-or-address query resolved against a ReadyToRun image.
public enum ReadyToRunQueryOutcomeThe ReadyToRunSectionType ids from a crossgen2 image’s READYTORUN_SECTION table
(readytorun.h). Distinct from the Native AOT module-section ids (200–399) that
RtrSection names; a classic R2R section table uses these 100-range ids with a
12-byte {Type, RVA, Size} row layout.
public enum ReadyToRunSectionTypeThe outcome of probing a PE image for a crossgen2 ReadyToRun header. This is a parse status,
not a coverage measure — whether not every method is precompiled is
IsPartialImage (the READYTORUN_FLAG_PARTIAL flag), not a
status value here.
public enum ReadyToRunStatusWhat a total-size figure measures. A binary on disk and the sum of its mstat entries are different numbers (headers, alignment, and unreported bytes sit between them), so every report states which basis it used.
public enum SizeBasisThe limit a size budget enforces.
public enum SizeBudgetMetricWhat a size budget measures: the whole binary, one namespace subtree, or one assembly.
public enum SizeBudgetScopeHow a failed size budget affects the outcome: an error fails the check (the CI gate exits non-zero), a warning is reported but never changes the exit code.
public enum SizeBudgetSeverityThe granularity level of a SizeNode in the size breakdown tree. The kinds beyond Method appear only in Native AOT trees, built from an mstat report or, when none sits beside the binary, from its merged native symbols.
public enum SizeNodeKindIdentifies the source from which a string was extracted.
public enum StringSourceCategory of a traced runtime event, used for coloring in the events table.
public enum TraceEventCategoryCurrent state of the traced process lifecycle.
public enum TraceProcessStateThe external item kind used by WebAssembly import and export sections.
public enum WasmExternalKindThe outcome of probing a WebAssembly module’s dotnet.native.js.symbols sidecar.
public enum WasmSymbolMapStatus