In this guide, you will create two C# ASP.NET Core Microservices. Both microservices have their own bounded context and domain model. Each microservice has its own database and REST API. One microservice publishes integration events, that the other microservice consumes.
This blog series provides a worked example, from beginning to end, showing you how to build a SPA with Vue.js, connect it to an HTTP API built with ASP.NET Core and to secure it with IdentityServer v4.
اینجا قسمتی هست که درخواست سمت api ارسال میشه. ممنون میشم بهم بگین که کجا ی کار ایراد داره!
dotnet new blazor --interactivity None
@page "/ssr-page/{Data:int}"
<PageTitle>An SSR component</PageTitle>
<h1>An SSR component rendered by a Minimal-API!</h1>
<div>
Data: @Data
</div>
@code {
[Parameter]
public int Data { get; set; }
} 
var builder = WebApplication.CreateBuilder(args);
// ...
builder.Services.AddRazorComponents();
// ...
// http://localhost:5227/ssr-component?data=2
// or it can be called directly http://localhost:5227/ssr-page/2
app.MapGet("/ssr-component",
(int data = 1) =>
{
var parameters = new Dictionary<string, object?>
{
{ nameof(SsrTest.Data), data },
};
return new RazorComponentResult<SsrTest>(parameters);
});
app.UseStaticFiles();
app.UseAntiforgery();
app.MapRazorComponents<App>();
app.Run();
// ... <LayoutView Layout="@typeof(MainLayout)">
<PageTitle>Home</PageTitle>
<h2>Welcome to your new app.</h2>
</LayoutView> // ...
builder.Services.AddRazorComponents()
.AddInteractiveServerComponents();
// ...
app.MapRazorComponents<App>().AddInteractiveServerRenderMode();
// ... <script src="_framework/blazor.web.js"></script>
@rendermode InteractiveServer
<h1>Counter</h1>
<p role="status">Current count: @_currentCount</p>
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
@code {
private int _currentCount;
private void IncrementCount()
{
_currentCount++;
}
} // http://localhost:5227/server-interactive-component
app.MapGet("/server-interactive-component", () => new RazorComponentResult<Counter>()); <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Interactive server component</title>
<base href="/"/>
</head>
<body>
<h1>Interactive server component</h1>
<Counter/>
<script src="_framework/blazor.web.js"></script>
</body>
</html> // http://localhost:5227/server-interactive-component
app.MapGet("/server-interactive-component", () => new RazorComponentResult<CounterInteractive>()); using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
namespace WebApi8x.Services;
public class BlazorStaticRendererService
{
private readonly HtmlRenderer _htmlRenderer;
public BlazorStaticRendererService(HtmlRenderer htmlRenderer) => _htmlRenderer = htmlRenderer;
public Task<string> StaticRenderComponentAsync<T>() where T : IComponent
=> RenderComponentAsync<T>(ParameterView.Empty);
public Task<string> StaticRenderComponentAsync<T>(Dictionary<string, object?> dictionary) where T : IComponent
=> RenderComponentAsync<T>(ParameterView.FromDictionary(dictionary));
private Task<string> RenderComponentAsync<T>(ParameterView parameters) where T : IComponent =>
_htmlRenderer.Dispatcher.InvokeAsync(async () =>
{
var output = await _htmlRenderer.RenderComponentAsync<T>(parameters);
return output.ToHtmlString();
});
} builder.Services.AddScoped<HtmlRenderer>(); builder.Services.AddScoped<BlazorStaticRendererService>();
app.MapGet("/static-renderer-service-test",
async (BlazorStaticRendererService renderer, int data = 1) =>
{
var parameters = new Dictionary<string, object?>
{
{ nameof(SsrTest.Data), data },
};
var html = await renderer.StaticRenderComponentAsync<SsrTest>(parameters);
return Results.Content(html, "text/html");
}); using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
namespace Core1RtmEmptyTest.Controllers
{
public class TestCookiesController : Controller
{
public IActionResult Index()
{
this.Response.Cookies.Append("key", "value", new CookieOptions
{
HttpOnly = true,
Path = this.Request.PathBase.HasValue ? this.Request.PathBase.ToString() : "/",
Secure = this.Request.IsHttps
});
return Content("OK!");
}
}
} 
Expires = DateTimeOffset.UtcNow.AddDays(2)
var value = this.Request.Cookies["key"];
public interface IRequestCookieCollection : IEnumerable<KeyValuePair<string, string>>, IEnumerable
{
string this[string key] { get; }
ICollection<string> Keys { get; }
bool ContainsKey(string key);
bool TryGetValue(string key, out string value);
} string cookieValue;
if (this.Request.Cookies.TryGetValue(key, out cookieValue))
{
// TODO: use the cookieValue
}
else
{
// this cookie doesn't exist.
} this.Response.Cookies.Delete("key"); 
public interface ISecureCookiesProvider
{
void Add(HttpContext context, string token, string value);
bool Contains(HttpContext context, string token);
string GetValue(HttpContext context, string token);
void Remove(HttpContext context, string token);
}
public class SecureCookiesProvider : ISecureCookiesProvider
{
private readonly IProtectionProvider _protectionProvider;
public SecureCookiesProvider(IProtectionProvider protectionProvider)
{
_protectionProvider = protectionProvider;
}
public void Add(HttpContext context, string token, string value)
{
value = _protectionProvider.Encrypt(value);
context.Response.Cookies.Append(token, value, getCookieOptions(context));
}
public bool Contains(HttpContext context, string token)
{
return context.Request.Cookies.ContainsKey(token);
}
public string GetValue(HttpContext context, string token)
{
string cookieValue;
if (!context.Request.Cookies.TryGetValue(token, out cookieValue))
{
return null;
}
return _protectionProvider.Decrypt(cookieValue);
}
public void Remove(HttpContext context, string token)
{
if (context.Request.Cookies.ContainsKey(token))
{
context.Response.Cookies.Delete(token);
}
}
/// <summary>
/// Expires at the end of the browser's session.
/// </summary>
private CookieOptions getCookieOptions(HttpContext context)
{
return new CookieOptions
{
HttpOnly = true,
Path = context.Request.PathBase.HasValue ? context.Request.PathBase.ToString() : "/",
Secure = context.Request.IsHttps
};
}
} public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.TryAddSingleton<IProtectionProvider, ProtectionProvider>();
services.TryAddSingleton<ISecureCookiesProvider, SecureCookiesProvider>(); 
