使用大量同构数据库时Dapper的内存占用问题咨询

Great question—this is a super common concern when scaling Dapper across fleets of identical databases, so let’s break down exactly what’s happening under the hood.

Core Truth: Dapper’s Cache Doesn’t Care About Connection Strings #

First, let’s get this straight: Dapper’s caching mechanism is 100% disconnected from your connection strings. The things it caches are all about your queries and data types, not which database you’re connecting to:

• Reflection-derived entity mappings (how your C# class properties map to database columns)
• Parsed query text (parameter positions, SQL structure, etc.)
• Compiled delegates for fast parameter binding and result materialization (the heavy lifting that avoids repeated reflection)

All of these are cached using keys based on:

• The exact SQL query text
• The type of parameters you’re passing (e.g., an anonymous type new { Id = 1 } or a strongly-typed CustomerParams class)
• The type of results you’re expecting (e.g., Customer, Order, etc.)

So if you run the same query with the same parameter/result types across 10,000 different databases (each with their own connection string), Dapper will reuse the exact same cache entry every single time. No duplicate cache entries, no extra memory bloat from connection strings here.

What Does Use Memory With Multiple Connections? #

The only memory overhead you’ll see comes from database connection instances themselves—but even that is managed by .NET’s connection pooling. By default, .NET maintains a pool of idle connections for each unique connection string. The default max pool size is 100, so even with thousands of connection strings, you won’t end up with thousands of active connections unless your workload demands it (and you can adjust this via the Max Pool Size parameter in your connection string if needed).

Connection instances are relatively lightweight, so this overhead is minimal compared to the query/type caching that Dapper handles.

Edge Case to Watch For #

The only scenario where you’d see extra cache bloat is if you accidentally use different result/parameter types for identical queries across databases. For example, if you dynamically generate a new Customer class for each database (instead of reusing a single shared class), Dapper would create separate cache entries for each unique type. But since you mentioned all databases have identical structures, you’re almost certainly reusing the same entity classes—so this isn’t a problem for you.

Final Verdict #

You don’t have to worry about significant memory increases from using thousands of different connection strings with Dapper. The cache is optimized around your queries and data types, not the specific database you’re connecting to. As long as you’re reusing the same entity types and query logic across all databases, your memory footprint will be nearly identical to a single-database scenario.

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