如何访问.NET CLR Blob项？Roslyn相关CLR堆技术问询

Great question! Let's walk through how to access those #Blob heap items—especially the ones stored via System.Reflection.Metadata's GetOrAddConstantBlob() method.

1. First, Understand Blob Handles #

When you call GetOrAddConstantBlob(), it returns a BlobHandle—this is essentially an offset pointer to the start of your data in the #Blob heap. All references to blob data in metadata use these handles, so they're your starting point for accessing the actual bytes.

2. Reading Blobs During Roslyn Compilation #

If you're working directly within a Roslyn pipeline (like a code generator, analyzer, or custom compiler tool), you can use the MetadataReader to fetch the blob data directly:

• Grab the MetadataReader from your Compilation or ModuleDefinition instance.
• Use the BlobHandle returned by GetOrAddConstantBlob() to call reader.GetBlobBytes(handle), which gives you the raw byte array.
• If your blob is a UTF16 string (like you mentioned), convert the bytes to a string with Encoding.Unicode.GetString().

Here's a quick code snippet to illustrate:

// Assume you have a MetadataReader instance and a BlobHandle from GetOrAddConstantBlob()
byte[] blobBytes = reader.GetBlobBytes(blobHandle);
string constantString = Encoding.Unicode.GetString(blobBytes);

3. Accessing Blobs in Compiled Assemblies (Runtime) #

If you want to read blob data from a compiled .NET assembly at runtime, you'll need to load the assembly and parse its metadata:

1. Load the target assembly using Assembly.LoadFrom() or similar.
2. Get the manifest module and create a MetadataReader for it.
3. Locate the BlobHandle associated with the data you care about—these handles are often attached to things like field default values, custom attribute arguments, or constant definitions.

Example code to read field default value blobs:

using System.Reflection;
using System.Reflection.Metadata;
using System.Reflection.PortableExecutable;

// Load the assembly
using var targetAssembly = Assembly.LoadFrom("YourCompiledAssembly.dll");
var manifestModule = targetAssembly.ManifestModule;

// Create a MetadataReader
using var metadataProvider = ModuleMetadata.FromModule(manifestModule);
var reader = metadataProvider.GetMetadataReader();

// Iterate over fields in the first type to find default value blobs
var firstTypeHandle = reader.TypeDefinitions.First();
var firstType = reader.GetTypeDefinition(firstTypeHandle);
foreach (var fieldHandle in firstType.GetFields())
{
    var field = reader.GetFieldDefinition(fieldHandle);
    if (field.HasDefaultValue)
    {
        var defaultValueHandle = field.DefaultValue;
        if (defaultValueHandle.Kind == HandleKind.Blob)
        {
            byte[] blobBytes = reader.GetBlobBytes((BlobHandle)defaultValueHandle);
            // Parse the bytes based on what you stored—e.g., UTF16 string
            string value = Encoding.Unicode.GetString(blobBytes);
            Console.WriteLine($"Field {field.Name.GetString()}: Default value blob = {value}");
        }
    }
}

4. Important Things to Remember #

• The #Blob heap stores raw, untyped bytes—you need to know the format of the data you stored to parse it correctly. For UTF16 strings stored via GetOrAddConstantBlob(), there's no length prefix (unlike the #US heap, which includes length metadata for strings).
• Tools like dotPeek show #Blob content by resolving these BlobHandle references, reading the raw bytes, and rendering them in a human-readable format (like converting UTF16 bytes to a string).

内容的提问来源于stack exchange，提问作者RenniePet