Создаем SPA на C# и Blazor

@page "/counter"
 
<h1>Счётчик</h1>
 
<p>Текущее значение: @currentCount</p>
 
<button class="btn btn-primary" @onclick="IncrementCount">Увеличить</button>
 
@code {
    private int currentCount = 0;
 
    private void IncrementCount()
    {
        currentCount++;
    }
}

// Программа настраивается по-разному в зависимости от среды
public class Program
{
    public static async Task Main(string[] args)
    {
        var builder = WebAssemblyHostBuilder.CreateDefault(args);
        
        // Регистрируем разные сервисы в зависимости от режима
        builder.Services.AddScoped<IDataService>(sp => 
        {
            if (builder.HostEnvironment.IsDevelopment())
                return new LocalMockDataService();
            else
                return new RemoteApiDataService();
        });
 
        await builder.Build().RunAsync();
    }
}

public class MyComponent : ComponentBase
{
    [Parameter]
    public int Value { get; set; }
    
    protected override void OnInitialized()
    {
        // Первичная инициализация
    }
    
    protected override async Task OnParametersSetAsync()
    {
        // Обработка изменения параметров
    }
    
    protected override void OnAfterRender(bool firstRender)
    {
        // Доступ к DOM через JSInterop
    }
    
    public void Dispose()
    {
        // Освобождение ресурсов
    }
}

public class StateContainer
{
    private readonly List<Func<Task>> _listeners = new();
    
    public async Task UpdateState()
    {
        foreach (var listener in _listeners.ToList())
        {
            await listener();
        }
    }
    
    public void Subscribe(Func<Task> listener)
    {
        _listeners.Add(listener);
    }
    
    public void Unsubscribe(Func<Task> listener)
    {
        _listeners.Remove(listener);
    }
}

@implements IDisposable
@inject StateContainer State
 
@code {
    private Func<Task> _listener;
    
    protected override void OnInitialized()
    {
        _listener = async () => {
            await InvokeAsync(StateHasChanged);
        };
        State.Subscribe(_listener);
    }
    
    public void Dispose()
    {
        State.Unsubscribe(_listener);
    }
}

public void ConfigureServices(IServiceCollection services)
{
    // Синглтон - один экземпляр на всё приложение
    services.AddSingleton<IConfigService, ConfigService>();
    
    // Scoped - один экземпляр на запрос/сессию
    services.AddScoped<ICartService, CartService>();
    
    // Transient - новый экземпляр каждый раз при запросе сервиса
    services.AddTransient<IProductFormatter, ProductFormatter>();
}

@inject IProductService ProductService
@inject IJSRuntime JSRuntime
 
<h1>Товары</h1>
 
@if (products == null)
{
    <p>Загрузка...</p>
}
else
{
    foreach (var product in products)
    {
        <ProductCard Product="product" OnAddToCart="AddToCart" />
    }
}
 
@code {
    private List<Product> products;
    
    protected override async Task OnInitializedAsync()
    {
        products = await ProductService.GetProductsAsync();
    }
    
    private async Task AddToCart(Product product)
    {
        await JSRuntime.InvokeVoidAsync("showToast", $"{product.Name} добавлен в корзину");
    }
}

// Регистрация модуля как assembly в главном приложении
public static IEnumerable<Assembly> GetAssemblies()
{
    yield return typeof(Program).Assembly;
    yield return typeof(OrderModule.OrderEntryPoint).Assembly;
    yield return typeof(CatalogModule.CatalogEntryPoint).Assembly;
}

@page "/showcase"
 
<h1>Витрина компонентов</h1>
 
<h2>Кнопки</h2>
<Showcase Title="Основная кнопка">
    <PrimaryButton>Нажми меня</PrimaryButton>
</Showcase>
 
<Showcase Title="Кнопка с иконкой">
    <IconButton Icon="save" Text="Сохранить" />
</Showcase>
 
@code {
    // Простой вспомогательный компонент для демонстрации
    private class Showcase : ComponentBase
    {
        [Parameter] public string Title { get; set; }
        [Parameter] public RenderFragment ChildContent { get; set; }
    }
}

<Router AppAssembly="@typeof(App).Assembly" 
       AdditionalAssemblies="@GetAdditionalAssemblies()">
    <Found Context="routeData">
        <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)">
            <NotAuthorized>
                <RedirectToLogin />
            </NotAuthorized>
            <Authorizing>
                <LoadingIndicator />
            </Authorizing>
        </AuthorizeRouteView>
    </Found>
    <NotFound>
        <CascadingAuthenticationState>
            <LayoutView Layout="@typeof(MainLayout)">
                <CustomNotFound />
            </LayoutView>
        </CascadingAuthenticationState>
    </NotFound>
</Router>

@inject NavigationManager Navigation
@inject StateService State
 
<button @onclick="NavigateWithState">Перейти и сохранить состояние</button>
 
@code {
    private void NavigateWithState()
    {
        // Сохраняем текущее состояние формы перед переходом
        State.TemporarilyStore("currentForm", formData);
        Navigation.NavigateTo("/next-page");
    }
}

@implements IDisposable
 
@code {
    protected override void OnInitialized()
    {
        Navigation.LocationChanged += HandleLocationChanged;
    }
 
    private void HandleLocationChanged(object sender, LocationChangedEventArgs e)
    {
        // Здесь можно восстановить состояние из хранилища
        // или выполнить другую логику при изменении URL
    }
 
    public void Dispose()
    {
        Navigation.LocationChanged -= HandleLocationChanged;
    }
}

public class StoreService<TState> where TState : class, new()
{
    private TState _state = new TState();
    private readonly List<Action<TState>> _subscribers = new();
 
    public TState GetState() => _state;
 
    public void Dispatch<TAction>(TAction action) where TAction : IAction
    {
        var reducer = ResolveReducer(action);
        _state = reducer.Reduce(_state, action);
        NotifySubscribers();
    }
 
    public void Subscribe(Action<TState> subscriber)
    {
        _subscribers.Add(subscriber);
    }
 
    public void Unsubscribe(Action<TState> subscriber)
    {
        _subscribers.Remove(subscriber);
    }
 
    private void NotifySubscribers()
    {
        foreach (var subscriber in _subscribers)
        {
            subscriber(_state);
        }
    }
 
    private IReducer<TState, TAction> ResolveReducer<TAction>(TAction action) where TAction : IAction
    {
        // Тут можно использовать фабрику или DI-контейнер для получения нужного редьюсера
        // Упрощенная версия для примера
        return new DefaultReducer<TState, TAction>();
    }
}

@inject StoreService<AppState> Store
@implements IDisposable
 
@code {
    private AppState currentState;
 
    protected override void OnInitialized()
    {
        currentState = Store.GetState();
        Store.Subscribe(StateHasChanged);
    }
 
    private void IncrementCounter()
    {
        Store.Dispatch(new IncrementAction { Amount = 1 });
    }
 
    public void Dispose()
    {
        Store.Unsubscribe(StateHasChanged);
    }
}

// В Startup.cs на сервере
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
   .AddJwtBearer(options =>
   {
       options.TokenValidationParameters = new TokenValidationParameters
       {
           ValidateIssuer = true,
           ValidateAudience = true,
           ValidateLifetime = true,
           ValidateIssuerSigningKey = true,
           ValidIssuer = Configuration["Jwt:Issuer"],
           ValidAudience = Configuration["Jwt:Issuer"],
           IssuerSigningKey = new SymmetricSecurityKey(
               Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]))
       };
   });

public class JwtAuthenticationStateProvider : AuthenticationStateProvider
{
    private readonly HttpClient _httpClient;
    private readonly ILocalStorageService _localStorage;
    
    public JwtAuthenticationStateProvider(
        HttpClient httpClient,
        ILocalStorageService localStorage)
    {
        _httpClient = httpClient;
        _localStorage = localStorage;
    }
    
    public override async Task<AuthenticationState> GetAuthenticationStateAsync()
    {
        var savedToken = await _localStorage.GetItemAsync<string>("authToken");
        
        if (string.IsNullOrWhiteSpace(savedToken))
        {
            return new AuthenticationState(new ClaimsPrincipal(new ClaimsIdentity()));
        }
        
        _httpClient.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("bearer", savedToken);
            
        return new AuthenticationState(new ClaimsPrincipal(
            new ClaimsIdentity(ParseClaimsFromJwt(savedToken), "jwt")));
    }
    
    // Метод для разбора JWT и извлечения клэймов
    private IEnumerable<Claim> ParseClaimsFromJwt(string jwt)
    {
        var payload = jwt.Split('.')[1];
        var jsonBytes = ParseBase64WithoutPadding(payload);
        var keyValuePairs = JsonSerializer.Deserialize<Dictionary<string, object>>(jsonBytes);
        
        return keyValuePairs.Select(kvp => new Claim(kvp.Key, kvp.Value.ToString()));
    }
    
    // Вспомогательный метод для декодирования Base64Url
    private byte[] ParseBase64WithoutPadding(string base64)
    {
        switch (base64.Length % 4)
        {
            case 2: base64 += "=="; break;
            case 3: base64 += "="; break;
        }
        return Convert.FromBase64String(base64);
    }
    
    // Метод для установки аутентификационного состояния
    public void NotifyUserAuthentication(string token)
    {
        var authenticatedUser = new ClaimsPrincipal(
            new ClaimsIdentity(ParseClaimsFromJwt(token), "jwt"));
            
        var authState = Task.FromResult(new AuthenticationState(authenticatedUser));
        NotifyAuthenticationStateChanged(authState);
    }
    
    // Метод для сброса аутентификационного состояния
    public void NotifyUserLogout()
    {
        var anonymousUser = new ClaimsPrincipal(new ClaimsIdentity());
        var authState = Task.FromResult(new AuthenticationState(anonymousUser));
        NotifyAuthenticationStateChanged(authState);
    }
}

public class AuthService
{
    private readonly HttpClient _httpClient;
    private readonly ILocalStorageService _localStorage;
    private readonly JwtAuthenticationStateProvider _authStateProvider;
    
    public AuthService(
        HttpClient httpClient,
        ILocalStorageService localStorage,
        AuthenticationStateProvider authStateProvider)
    {
        _httpClient = httpClient;
        _localStorage = localStorage;
        _authStateProvider = authStateProvider as JwtAuthenticationStateProvider;
    }
    
    public async Task<bool> TryRefreshToken()
    {
        var refreshToken = await _localStorage.GetItemAsync<string>("refreshToken");
        
        if (string.IsNullOrEmpty(refreshToken))
            return false;
            
        var response = await _httpClient.PostAsync("api/auth/refresh", 
            new StringContent(JsonSerializer.Serialize(new { 
                Token = refreshToken 
            }), Encoding.UTF8, "application/json"));
            
        if (!response.IsSuccessStatusCode)
            return false;
            
        var result = await response.Content.ReadFromJsonAsync<LoginResult>();
        
        await _localStorage.SetItemAsync("authToken", result.Token);
        await _localStorage.SetItemAsync("refreshToken", result.RefreshToken);
        
        _authStateProvider.NotifyUserAuthentication(result.Token);
        
        return true;
    }
}

services.AddAuthentication(options =>
{
    options.DefaultScheme = "Cookies";
    options.DefaultChallengeScheme = "oidc";
})
.AddCookie("Cookies")
.AddOpenIdConnect("oidc", options =>
{
    options.Authority = "https://localhost:5001";
    options.ClientId = "blazor";
    options.ResponseType = "code";
    options.SaveTokens = true;
    options.GetClaimsFromUserInfoEndpoint = true;
    
    // Важно для CSRF-защиты в Blazor WebAssembly
    options.CorrelationCookie.SameSite = SameSiteMode.None;
    
    options.Scope.Add("api");
    options.Scope.Add("offline_access");
});

services.AddAuthentication()
    .AddGoogle("Google", options =>
    {
        options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
        options.ClientId = "your-google-client-id";
        options.ClientSecret = "your-google-client-secret";
    })
    .AddGitHub("GitHub", options =>
    {
        options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
        options.ClientId = "your-github-client-id";
        options.ClientSecret = "your-github-client-secret";
    });

@inject NavigationManager NavigationManager
 
<button @onclick="LoginWithGoogle">Войти через Google</button>
 
@code {
    private void LoginWithGoogle()
    {
        var callbackUrl = NavigationManager.BaseUri + "authentication/login-callback";
        var encodedUrl = Uri.EscapeDataString(callbackUrl);
        NavigationManager.NavigateTo(
            $"https://localhost:5001/connect/authorize?provider=Google&return_url={encodedUrl}",
            forceLoad: true);
    }
}

@inject AntiforgeryService AntiforgeryService
 
<EditForm Model="@model" OnValidSubmit="@HandleValidSubmit">
    <DataAnnotationsValidator />
    <ValidationSummary />
    
    <input type="hidden" name="__csrfToken" value="@csrfToken" />
    
    <p>
        <label>
            Username:
            <InputText @bind-Value="model.Username" />
        </label>
    </p>
    <p>
        <label>
            Password:
            <InputText type="password" @bind-Value="model.Password" />
        </label>
    </p>
    
    <button type="submit">Submit</button>
</EditForm>
 
@code {
    private LoginModel model = new();
    private string csrfToken;
    
    protected override async Task OnInitializedAsync()
    {
        csrfToken = await AntiforgeryService.GetTokenAsync();
    }
    
    private async Task HandleValidSubmit()
    {
        // При отправке запроса добавляем CSRF-токен в заголовок
        using var message = new HttpRequestMessage(HttpMethod.Post, "api/login");
        message.Headers.Add("X-CSRF-TOKEN", csrfToken);
        message.Content = new StringContent(
            JsonSerializer.Serialize(model),
            Encoding.UTF8,
            "application/json");
            
        var response = await HttpClient.SendAsync(message);
        // Обработка ответа...
    }
}

public class AntiforgeryService
{
    private readonly HttpClient _httpClient;
    
    public AntiforgeryService(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }
    
    public async Task<string> GetTokenAsync()
    {
        var response = await _httpClient.GetAsync("api/antiforgery/token");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

@page "/admin-panel"
@attribute [Authorize(Roles = "Admin")]
 
<h1>Админ-панель</h1>
<p>Только админы могут видеть эту страницу</p>

// В Startup.cs на сервере
services.AddAuthorization(options =>
{
 options.AddPolicy("RequireTwoFactor", policy =>
     policy.RequireClaim("amr", "mfa"));
     
 options.AddPolicy("SeniorDevelopers", policy =>
     policy.RequireAssertion(context => 
         context.User.HasClaim(c => c.Type == "EmploymentYears") &&
         int.Parse(context.User.FindFirst("EmploymentYears").Value) > 5));
});

@page "/critical-operation"
@attribute [Authorize(Policy = "RequireTwoFactor")]
 
<h1>Критическая операция</h1>
<p>Если вы это видите, значит у вас включена 2FA</p>

<Router AppAssembly="@typeof(Program).Assembly">
 <Found Context="routeData">
     <AuthorizeRouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)">
         <NotAuthorized>
             <h1>Доступ запрещен</h1>
             <p>У вас недостаточно прав для просмотра этой страницы.</p>
             
             <a href="login">Войдите</a> или <a href="/">вернитесь на главную</a>.
         </NotAuthorized>
     </AuthorizeRouteView>
 </Found>
 <NotFound>
     <LayoutView Layout="@typeof(MainLayout)">
         <h1>Страница не найдена</h1>
     </LayoutView>
 </NotFound>
</Router>

@page "/user-comment"
 
<h3>Комментарий пользователя</h3>
 
@* Этот HTML не будет выполнен, а будет отрендерен как текст *@
<p>@userComment</p>
 
@code {
 private string userComment = "<script>alert('XSS!');</script>";
}

@page "/rich-content"
 
<h3>Форматированный контент</h3>
 
@((MarkupString)htmlContent)
 
@code {
 // ВНИМАНИЕ: никогда не делайте так с данными от пользователя!
 private string htmlContent = "<p>Это <strong>форматированный</strong> текст.</p>";
}

@inject HtmlSanitizer Sanitizer
 
@page "/sanitized-content"
 
<h3>Безопасно отображенный пользовательский контент</h3>
 
@((MarkupString)sanitizedHtml)
 
@code {
 private string userInput = "<script>alert('XSS!');</script><p>Легитимный текст</p>";
 private string sanitizedHtml;
 
 protected override void OnInitialized()
 {
     // Очищаем HTML от потенциально опасных элементов
     sanitizedHtml = Sanitizer.Sanitize(userInput);
 }
}

[Route("api/[controller]")]
[ApiController]
[ServiceFilter(typeof(ApiExceptionFilter))]
public class ProductsController : ControllerBase
{
 private readonly IProductService _productService;
 
 public ProductsController(IProductService productService)
 {
     _productService = productService;
 }
 
 [HttpGet]
 [Authorize(Policy = "ReadProducts")]
 public async Task<ActionResult<List<ProductDto>>> GetProducts()
 {
     var products = await _productService.GetProductsAsync();
     return Ok(products);
 }
 
 [HttpPost]
 [Authorize(Policy = "CreateProducts")]
 [ValidateModelState]
 public async Task<ActionResult<ProductDto>> CreateProduct(CreateProductDto productDto)
 {
     var product = await _productService.CreateProductAsync(productDto);
     return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product);
 }
 
 [HttpGet("{id}")]
 [Authorize(Policy = "ReadProducts")]
 public async Task<ActionResult<ProductDto>> GetProduct(int id)
 {
     var product = await _productService.GetProductByIdAsync(id);
     
     if (product == null)
         return NotFound();
         
     return Ok(product);
 }
}

public class ApiExceptionFilter : IExceptionFilter
{
 private readonly IWebHostEnvironment _env;
 private readonly ILogger<ApiExceptionFilter> _logger;
 
 public ApiExceptionFilter(IWebHostEnvironment env, ILogger<ApiExceptionFilter> logger)
 {
     _env = env;
     _logger = logger;
 }
 
 public void OnException(ExceptionContext context)
 {
     _logger.LogError(context.Exception, context.Exception.Message);
     
     var error = new ApiError
     {
         Id = Guid.NewGuid().ToString(),
         Status = 500,
         Title = "Произошла ошибка при выполнении запроса"
     };
     
     if (_env.IsDevelopment())
     {
         error.Detail = context.Exception.StackTrace;
     }
     
     context.Result = new ObjectResult(error)
     {
         StatusCode = 500
     };
     
     context.ExceptionHandled = true;
 }
}

// В файле service-worker.published.js
self.addEventListener('fetch', event => {
   if (event.request.method === 'GET') {
       // Стратегия cache-first для статических ресурсов
       if (event.request.url.includes('/css/') || 
           event.request.url.includes('/js/') || 
           event.request.url.includes('/fonts/')) {
           event.respondWith(
               caches.match(event.request)
                   .then(response => response || fetch(event.request)
                       .then(r => {
                           return caches.open('static-resources')
                               .then(cache => {
                                   cache.put(event.request, r.clone());
                                   return r;
                               });
                       }))
           );
           return;
       }
   }
   
   event.respondWith(
       fetch(event.request)
           .catch(() => caches.match(event.request))
   );
});

public class CachedProductRepository : IProductRepository
{
   private readonly ApiProductRepository _apiRepository;
   private readonly LocalStorageProductRepository _localRepository;
   
   public CachedProductRepository(
       ApiProductRepository apiRepository,
       LocalStorageProductRepository localRepository)
   {
       _apiRepository = apiRepository;
       _localRepository = localRepository;
   }
   
   public async Task<IEnumerable<Product>> GetAllAsync()
   {
       try
       {
           // Пробуем получить свежие данные с API
           var products = await _apiRepository.GetAllAsync();
           // Кэшируем их локально
           await _localRepository.SaveAllAsync(products);
           return products;
       }
       catch (Exception)
       {
           // В случае ошибки используем локальный кэш
           return await _localRepository.GetAllAsync();
       }
   }
}

@inject IProductService ProductService
 
@foreach (var product in products)
{
   <ProductCard Product="product" />
}
 
@code {
   private List<Product> products = new();
   
   protected override async Task OnInitializedAsync()
   {
       await foreach (var batch in ProductService.GetProductBatchesAsync())
       {
           products.AddRange(batch);
           StateHasChanged(); // Обновляем UI после каждой порции
       }
   }
}

@page "/product/{id:int}"
@using System.Reflection
@implements IDisposable
 
@if (isLoaded)
{
   <DynamicComponent Type="@componentType" Parameters="@parameters" />
}
else
{
   <p>Загрузка редактора продукта...</p>
}
 
@code {
   [Parameter] public int Id { get; set; }
   private bool isLoaded;
   private Type componentType;
   private Dictionary<string, object> parameters;
   
   protected override async Task OnParametersSetAsync()
   {
       if (componentType == null)
       {
           try
           {
               // Загружаем дополнительную сборку "по требованию"
               var assemblies = await JsonSerializer.DeserializeAsync<string[]>(
                   await HttpClient.GetStreamAsync("_framework/lazyAssemblies.json"),
                   new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
                   
               if (assemblies.Contains("ProductEditor.dll"))
               {
                   await JSRuntime.InvokeVoidAsync("import", "_framework/ProductEditor.dll");
                   var assembly = Assembly.Load("ProductEditor");
                   componentType = assembly.GetType("ProductEditor.ProductEditorComponent");
               }
               
               parameters = new Dictionary<string, object>
               {
                   { "ProductId", Id }
               };
               
               isLoaded = true;
           }
           catch
           {
               // Обработка ошибок загрузки
           }
       }
   }
}

@inject IJSRuntime JS
 
@code {
   private async Task MeasureOperationAsync(Func<Task> operation, string operationName)
   {
       await JS.InvokeVoidAsync("performance.mark", $"{operationName}-start");
       await operation();
       await JS.InvokeVoidAsync("performance.mark", $"{operationName}-end");
       await JS.InvokeVoidAsync("performance.measure", 
           operationName, 
           $"{operationName}-start", 
           $"{operationName}-end");
       
       var measurements = await JS.InvokeAsync<Performance[]>("performance.getEntriesByType", "measure");
       Console.WriteLine($"{operationName} took {measurements[0].Duration}ms");
   }
}

public class RenderTrackingComponent : ComponentBase
{
   private static readonly Dictionary<string, int> _renderCounts = new();
   
   protected override void OnAfterRender(bool firstRender)
   {
       var componentName = this.GetType().Name;
       
       if (!_renderCounts.ContainsKey(componentName))
       {
           _renderCounts[componentName] = 0;
       }
       
       _renderCounts[componentName]++;
       
       if (_renderCounts[componentName] % 10 == 0)
       {
           Console.WriteLine($"{componentName} rendered {_renderCounts[componentName]} times");
       }
   }
}

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
   services.AddMvc()
       .AddRazorPagesOptions(options =>
       {
           options.RootDirectory = "/";
       });
   
   // Включаем пререндеринг
   services.AddServerSideBlazor()
       .AddCircuitOptions(options =>
       {
           options.DetailedErrors = true;
       });
   
   // Обязательно регистрируем те же сервисы, что и в клиенте
   services.AddSingleton<WeatherForecastService>();
}
 
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
   // ...
   app.UseEndpoints(endpoints =>
   {
       endpoints.MapBlazorHub();
       endpoints.MapFallbackToPage("/_Host");
   });
}

@inherits ComponentBase
 
<div>
   <h3>@Title</h3>
   <p>@Content</p>
</div>
 
@code {
   [Parameter] public string Title { get; set; }
   [Parameter] public string Content { get; set; }
   
   private string _previousTitle;
   private string _previousContent;
   
   protected override bool ShouldRender()
   {
       // Перерисовываем только если реально изменились данные
       bool shouldRender = !string.Equals(Title, _previousTitle) ||
                         !string.Equals(Content, _previousContent);
                        
       _previousTitle = Title;
       _previousContent = Content;
       
       return shouldRender;
   }
}

<div style="height: 500px; overflow-y: auto;" @onscroll="OnScroll">
   @foreach (var item in visibleItems)
   {
       <ItemComponent Item="item" />
   }
</div>
 
@code {
   [Parameter] public List<Item> Items { get; set; }
   
   private List<Item> visibleItems = new();
   private int startIndex = 0;
   private readonly int pageSize = 20;
   
   protected override void OnParametersSet()
   {
       LoadVisibleItems();
   }
   
   private void OnScroll(EventArgs e)
   {
       // Определение текущей позиции скролла и загрузка новых элементов
       // при необходимости
   }
   
   private void LoadVisibleItems()
   {
       visibleItems = Items
           .Skip(startIndex)
           .Take(pageSize)
           .ToList();
   }
}

<Virtualize Context="product" Items="@allProducts" ItemSize="50" OverscanCount="10">
   <ProductListItem Product="product" />
</Virtualize>

@inject IJSRuntime JS
 
@if (useClientRendering)
{
   <div id="chart-container"></div>
}
else
{
   <HeavyServerChartComponent Data="data" />
}
 
@code {
   private bool useClientRendering;
   private List<DataPoint> data;
   
   protected override async Task OnInitializedAsync()
   {
       data = await DataService.GetDataAsync();
       
       // Определяем стратегию рендеринга в зависимости от размера данных
       useClientRendering = data.Count > 1000;
   }
   
   protected override async Task OnAfterRenderAsync(bool firstRender)
   {
       if (firstRender && useClientRendering)
       {
           await JS.InvokeVoidAsync("renderChart", data);
       }
   }
}

@page "/concurrency-trap"
 
<button @onclick="StartLongRunningTask">Запустить долгую операцию</button>
<button @onclick="QuickOperation">Быстрая операция</button>
 
<p>Статус: @status</p>
 
@code {
   private string status = "Готов";
   
   private async Task StartLongRunningTask()
   {
       status = "Начинаем долгую операцию...";
       // Этот вызов заблокирует весь UI!
       await Task.Delay(5000);
       status = "Долгая операция завершена";
   }
   
   private void QuickOperation()
   {
       status = "Выполнена быстрая операция";
   }
}

private async Task StartLongRunningTask()
{
    status = "Начинаем долгую операцию...";
    await Task.Run(async () => 
    {
        await Task.Delay(5000);
        // Важно: обновления UI должны происходить в исходном потоке
        await InvokeAsync(() => {
            status = "Долгая операция завершена";
            StateHasChanged();
        });
    });
}

// Так делать НЕ надо!
@foreach (var item in Items)
{
    <ItemComponent Item="item" OnChanged="@(() => StateHasChanged())" />
}

@foreach (var item in Items)
{
    <ItemComponent Item="item" OnChanged="@(() => ItemChanged(item))" />
}
 
@code {
    private void ItemChanged(Item changedItem)
    {
        // Делаем что-то с конкретным измененным элементом,
        // без полной перерисовки родителя
    }
}

[Fact]
public void Counter_IncrementButton_IncrementsValue()
{
    // Arrange - рендерим компонент
    using var ctx = new TestContext();
    var cut = ctx.RenderComponent<Counter>();
    var initialCount = cut.Find("p").TextContent;
    
    // Act - нажимаем на кнопку
    cut.Find("button").Click();
    
    // Assert - проверяем, что счетчик увеличился
    Assert.NotEqual(initialCount, cut.Find("p").TextContent);
}

public class ApiTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;
 
    public ApiTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory;
    }
 
    [Fact]
    public async Task GetProducts_ReturnsSuccessAndProducts()
    {
        // Arrange
        var client = _factory
            .WithWebHostBuilder(builder =>
            {
                builder.ConfigureServices(services =>
                {
                    // Подменяем аутентификацию на тестовую
                    services.AddAuthentication("Test")
                        .AddScheme<AuthenticationSchemeOptions, TestAuthHandler>(
                            "Test", options => { });
                });
            })
            .CreateClient(new WebApplicationFactoryClientOptions
            {
                AllowAutoRedirect = false
            });
 
        client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Test");
 
        // Act
        var response = await client.GetAsync("/api/products");
 
        // Assert
        response.EnsureSuccessStatusCode();
        var products = await response.Content.ReadFromJsonAsync<List<ProductDto>>();
        Assert.NotEmpty(products);
    }
}

[Fact]
public async Task Login_SuccessfulLogin_RedirectsToDashboard()
{
    // Arrange
    await using var browser = await Playwright.Chromium.LaunchAsync();
    var page = await browser.NewPageAsync();
    await page.GotoAsync("https://localhost:5001/login");
    
    // Act
    await page.FillAsync("#username", "test@example.com");
    await page.FillAsync("#password", "P@ssw0rd!");
    await page.ClickAsync("button[type=submit]");
    
    // Assert
    await page.WaitForURLAsync("**/dashboard");
    Assert.Contains("Welcome", await page.TextContentAsync("h1"));
}

services.AddSignalR()
    .AddStackExchangeRedis(options =>
    {
        options.Configuration.ChannelPrefix = "blazor_";
        options.Configuration.ClientName = "blazor-server";
        options.Configuration.EndPoints.Add("localhost:6379");
    });

services.AddSignalR().AddAzureSignalR(options =>
{
    options.ServerStickyMode = 
        Microsoft.Azure.SignalR.ServerStickyMode.Required;
});

// Сгенерированный клиент
[global::System.CodeDom.Compiler.GeneratedCode("StrawberryShake", "12.0.0")]
public partial class GetProductsQuery : IGetProductsQuery
{
    private readonly IOperationExecutor<IGetProductsResult> _operationExecutor;
 
    public GetProductsQuery(IOperationExecutor<IGetProductsResult> operationExecutor)
    {
        _operationExecutor = operationExecutor;
    }
 
    public async Task<IGetProductsResult> ExecuteAsync(
        CancellationToken cancellationToken = default)
    {
        return await _operationExecutor
            .ExecuteAsync(this, cancellationToken);
    }
}

@inject IGetProductsQuery ProductsQuery
 
@if (products == null)
{
    <p>Loading...</p>
}
else
{
    <ProductList Products="products" />
}
 
@code {
    private IReadOnlyList<IProductInfo> products;
 
    protected override async Task OnInitializedAsync()
    {
        var result = await ProductsQuery.ExecuteAsync();
        products = result.Data?.Products;
    }
}

public interface IProductApi
{
    [Get("/api/products")]
    Task<List<ProductDto>> GetProductsAsync();
    
    [Get("/api/products/{id}")]
    Task<ProductDto> GetProductAsync(int id);
    
    [Post("/api/products")]
    Task<ProductDto> CreateProductAsync([Body] CreateProductDto product);
}

// В Program.cs
builder.Services.AddRefitClient<IProductApi>()
    .ConfigureHttpClient(c => c.BaseAddress = new Uri("https://api.example.com"));
    
// В компоненте
@inject IProductApi ProductApi
 
@code {
    private async Task CreateProduct(CreateProductDto dto)
    {
        try
        {
            var newProduct = await ProductApi.CreateProductAsync(dto);
            // Обработка успешного создания
        }
        catch (ApiException ex) when (ex.StatusCode == HttpStatusCode.BadRequest)
        {
            // Обработка ошибки валидации
        }
    }
}