klod68/in-memory-search-registry

---

name: in-memory-search-registry description: "Use when building a searchable in-memory catalog or registry for documentation sites, admin panels, or type/API browsers where you need keyword matching, fuzzy search, and ranked results without an external search engine or database. Covers RegistryService with weighted scoring across name, description, keywords, and method names; Levenshtein fuzzy matching; synonym expansion; category and subcategory filtering; and singleton DI registration for datasets of hundreds to low thousands of items. Domain: Search, Data Access Patterns. Level: Intermediate. Tags: search, registry, fuzzy-matching, in-memory, catalog, filtering."

In-Memory Search Registry

Problem

Your application needs a searchable catalog of items (types, products, docs, features) with:

• Full-text-like search without a database or external engine
• Category and subcategory filtering
• Fuzzy matching for typos and partial terms
• Synonym support (e.g., "cache" matches "caching", "memory store")
• Fast startup and zero infrastructure

Solution: Registration-Based Registry with Weighted Search

Build a RegistryService that holds searchable items in memory, populated at startup, and queried via a scoring-based search algorithm.

Implementation

1. Define the searchable item model

/// <summary>
/// Represents an item in the searchable registry.
/// </summary>
public sealed record SearchableItem
{
    public required string Name { get; init; }
    public required string FullName { get; init; }
    public required string Description { get; init; }
    public required string Category { get; init; }
    public string? Subcategory { get; init; }
    public string[] Keywords { get; init; } = [];
    public string[] MethodNames { get; init; } = [];
    public string? Icon { get; init; }
    public string? Url { get; init; }
}

2. Build the registry service

/// <summary>
/// In-memory registry with search, filtering, and categorization.
/// </summary>
public sealed class RegistryService
{
    private readonly List<SearchableItem> _items = [];

    public void Register(SearchableItem item)
    {
        ArgumentNullException.ThrowIfNull(item);
        _items.Add(item);
    }

    public void RegisterRange(IEnumerable<SearchableItem> items)
    {
        foreach (var item in items)
            Register(item);
    }

    public IReadOnlyList<SearchableItem> GetAll() => _items.AsReadOnly();

    public IEnumerable<string> GetCategories() =>
        _items.Select(t => t.Category).Distinct().OrderBy(c => c);

    public IEnumerable<string> GetSubcategories(string category) =>
        _items.Where(t => t.Category == category && t.Subcategory is not null)
              .Select(t => t.Subcategory!)
              .Distinct()
              .OrderBy(s => s);
}

3. Add weighted search with scoring

public sealed record SearchResult(SearchableItem Item, double Score);

// Add to RegistryService:
public IEnumerable<SearchResult> Search(
    string query,
    int maxResults = 20,
    string? category = null,
    bool useFuzzyMatching = false,
    bool useSynonyms = false)
{
    if (string.IsNullOrWhiteSpace(query))
        return [];

    var terms = query.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
    var candidates = category is null ? _items : _items.Where(t => t.Category == category);

    return candidates
        .Select(item => new SearchResult(item, CalculateScore(item, terms, useFuzzyMatching, useSynonyms)))
        .Where(r => r.Score > 0)
        .OrderByDescending(r => r.Score)
        .Take(maxResults);
}

private static double CalculateScore(SearchableItem item, string[] terms, bool fuzzy, bool synonyms)
{
    double score = 0;

    foreach (var term in terms)
    {
        // Exact name match (highest weight)
        if (item.Name.Contains(term, StringComparison.OrdinalIgnoreCase))
            score += 10;

        // Description match
        if (item.Description.Contains(term, StringComparison.OrdinalIgnoreCase))
            score += 3;

        // Keyword match
        if (item.Keywords.Any(k => k.Contains(term, StringComparison.OrdinalIgnoreCase)))
            score += 5;

        // Method name match
        if (item.MethodNames.Any(m => m.Contains(term, StringComparison.OrdinalIgnoreCase)))
            score += 4;

        // Fuzzy matching (edit distance)
        if (fuzzy && score == 0)
        {
            if (IsFuzzyMatch(item.Name, term))
                score += 2;
        }

        // Synonym expansion
        if (synonyms)
        {
            var expanded = GetSynonyms(term);
            foreach (var syn in expanded)
            {
                if (item.Name.Contains(syn, StringComparison.OrdinalIgnoreCase))
                    score += 4;
                if (item.Keywords.Any(k => k.Contains(syn, StringComparison.OrdinalIgnoreCase)))
                    score += 2;
            }
        }
    }

    return score;
}

4. Fuzzy matching (Levenshtein distance)

private static bool IsFuzzyMatch(string source, string target, int maxDistance = 2)
{
    if (Math.Abs(source.Length - target.Length) > maxDistance)
        return false;

    var distance = LevenshteinDistance(source.ToLowerInvariant(), target.ToLowerInvariant());
    return distance <= maxDistance;
}

private static int LevenshteinDistance(string s, string t)
{
    var n = s.Length;
    var m = t.Length;
    var d = new int[n + 1, m + 1];

    for (var i = 0; i <= n; i++) d[i, 0] = i;
    for (var j = 0; j <= m; j++) d[0, j] = j;

    for (var i = 1; i <= n; i++)
    for (var j = 1; j <= m; j++)
    {
        var cost = s[i - 1] == t[j - 1] ? 0 : 1;
        d[i, j] = Math.Min(
            Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1),
            d[i - 1, j - 1] + cost);
    }

    return d[n, m];
}

5. Synonym dictionary

private static readonly Dictionary<string, string[]> _synonyms = new(StringComparer.OrdinalIgnoreCase)
{
    ["cache"]      = ["caching", "memory", "store", "redis"],
    ["validate"]   = ["validation", "check", "verify", "guard"],
    ["page"]       = ["pagination", "paging", "paged"],
    ["encrypt"]    = ["encryption", "decrypt", "hash", "security"],
    ["date"]       = ["datetime", "time", "calendar", "timestamp"],
    ["log"]        = ["logging", "logger", "trace", "audit"],
    ["retry"]      = ["resilience", "backoff", "fault-tolerance"],
};

private static string[] GetSynonyms(string term)
{
    if (_synonyms.TryGetValue(term, out var synonyms))
        return synonyms;

    // Reverse lookup: if the term is a synonym value, find the key
    return _synonyms
        .Where(kvp => kvp.Value.Any(v => v.Equals(term, StringComparison.OrdinalIgnoreCase)))
        .Select(kvp => kvp.Key)
        .ToArray();
}

6. Register at startup via extension method

public static class RegistryServiceExtensions
{
    public static IServiceCollection AddSearchRegistry(this IServiceCollection services)
    {
        var registry = new RegistryService();

        // Register items from any source: reflection, config, hardcoded
        registry.RegisterRange(LoadItemsFromReflection());
        // registry.RegisterRange(LoadItemsFromConfig(config));

        services.AddSingleton(registry);
        return services;
    }
}

When to Use

• Documentation sites with searchable type/API catalogs
• Small-to-medium datasets (hundreds to low thousands of items)
• Applications needing search without external infrastructure (Elasticsearch, Azure Search)
• Internal tools, dashboards, or admin panels

When NOT to Use

• Large datasets (10k+ items) — use a proper search engine
• Full-text search over long documents — use Lucene.NET or Azure AI Search
• Distributed systems where multiple instances need shared search state

Gotchas

1. Thread safety: The List<T> is fine if populated once at startup and read-only afterward. If items are added at runtime, switch to ConcurrentBag<T> or use locking.
2. Synonym maintenance: The synonym dictionary is manual. For production, consider loading from config or a shared resource.
3. Score tuning: The weight values (10, 5, 4, 3, 2) are starting points. Tune based on user behavior analytics.
4. Case sensitivity: Always use StringComparison.OrdinalIgnoreCase for search comparisons.

Related Skills

• Analytics with Concurrent Collections (track search behavior)
• AI Chatbot with Contextual Knowledge Injection (use registry as knowledge source)