Поиск страниц в проекте на Razor

@page
@model WebMedCalculator.Pages.SearchModel
@{
    ViewData["Title"] = "Suche";
}
 
<div class="container mt-4">
    <h2>Suchergebnisse für "@Model.Q"</h2>
 
    @if (Model.Results.Count == 0)
    {
        <div class="alert alert-warning mt-3">
            Keine Ergebnisse gefunden für "@Model.Q".
        </div>
    }
    else
    {
        <div class="list-group mt-3">
            @foreach (var result in Model.Results)
            {
                <a href="@result.Url" class="list-group-item list-group-item-action">
                    <h5>@result.Title</h5>
                    @if (!string.IsNullOrEmpty(result.Snippet))
                    {
                        <p class="mb-0 text-muted">...@result.Snippet...</p>
                    }
                    <small class="text-muted">@result.Url</small>
                </a>
            }
        </div>
    }
</div>

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using System.Text.RegularExpressions;
using Microsoft.Extensions.Hosting;
 
namespace WebMedCalculator.Pages
{
    public class SearchModel : PageModel
    {
        private readonly IWebHostEnvironment _environment;
 
        public SearchModel(IWebHostEnvironment environment)
        {
            _environment = environment;
        }
 
        [BindProperty(SupportsGet = true)]
        public string? Q { get; set; }
 
        public List<ResultItem> Results { get; set; } = new();
 
        public void OnGet()
        {
            if (string.IsNullOrWhiteSpace(Q))
                return;
 
            var pagesPath = Path.Combine(_environment.ContentRootPath, "Pages");
            Console.WriteLine($"Content Root: {_environment.ContentRootPath}");
            Console.WriteLine($"pagesPath: {pagesPath}");
 
            var files = Directory.EnumerateFiles(pagesPath, "*.cshtml", SearchOption.AllDirectories)
                               .Where(f => !f.EndsWith(".cshtml.cs"));
            Console.WriteLine($"Found {files.Count()} files: {string.Join(", ", files)}");
 
            foreach (var file in files)
            {
                string content = System.IO.File.ReadAllText(file);
                string fileName = Path.GetFileNameWithoutExtension(file);
                string relativePath = GetRelativePath(file, pagesPath);
 
                string? title = GetPageTitle(content, fileName);
                string plainTextContent = GetSearchableContent(content);
 
                if (IsMatchFound(plainTextContent, title, fileName, relativePath))
                {
                    Results.Add(new ResultItem
                    {
                        Title = title ?? fileName,
                        Url = relativePath,
                        Snippet = GetContentSnippet(plainTextContent)
                    });
                }
            }
        }
 
        // Rest des Codes bleibt unverändert
        private string GetRelativePath(string fullPath, string basePath)
        {
            string relativePath = fullPath
                .Replace(basePath, "")
                .Replace("\\", "/")
                .Replace(".cshtml", "");
 
            return relativePath.StartsWith("/") ? relativePath : "/" + relativePath;
        }
 
        private string? GetPageTitle(string content, string fileName)
        {
            var titleMatch = Regex.Match(content, @"@ViewData\[""Title""\]\s*=\s*""(.+?)""");
            if (titleMatch.Success)
                return titleMatch.Groups[1].Value;
 
            var hMatch = Regex.Match(content, @"<h\d[^>]*>(.*?)<\/h\d>", RegexOptions.IgnoreCase);
            return hMatch.Success ? hMatch.Groups[1].Value : fileName;
        }
 
        private string GetSearchableContent(string content)
        {
            string withoutRazor = Regex.Replace(content, @"@\{(.*?)\}|@[A-Za-z0-9_.]+", "", RegexOptions.Singleline);
            return Regex.Replace(withoutRazor, @"<[^>]+>", " ")
                       .Replace("\n", " ")
                       .Replace("\r", " ")
                       .Trim();
        }
 
        private bool IsMatchFound(string content, string? title, string fileName, string relativePath)
        {
            if (string.IsNullOrWhiteSpace(Q))
                return false;
 
            string query = Q.Trim();
            StringComparison comparison = StringComparison.OrdinalIgnoreCase;
 
            return (title != null && title.Contains(query, comparison)) ||
                   fileName.Contains(query, comparison) ||
                   relativePath.Contains(query, comparison) ||
                   content.Contains(query, comparison);
        }
 
        private string GetContentSnippet(string content)
        {
            if (string.IsNullOrWhiteSpace(Q))
                return string.Empty;
 
            int pos = content.IndexOf(Q, StringComparison.OrdinalIgnoreCase);
            if (pos < 0)
                return string.Empty;
 
            int start = Math.Max(0, pos - 50);
            int end = Math.Min(content.Length, pos + Q.Length + 50);
            return content[start..end].Trim();
        }
 
        public class ResultItem
        {
            public string Title { get; set; } = "";
            public string Url { get; set; } = "";
            public string Snippet { get; set; } = "";
        }
    }
}