ASP.NET Core

https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0
Admin
ASP.NET Core is a cross-platform framework for building fast, secure, and cloud-based web...
Tokens:2,557
Snippets:11
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Deploy ASP.NET Core to Azure App Service

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Guidance on deploying ASP.NET Core applications to Azure App Service. This section covers the deployment process and considerations for hosting.

```bash
# Example Azure CLI command for deploying an ASP.NET Core app
# Ensure you have logged in using 'az login'
# Replace 'MyResourceGroup', 'MyAppName', and 'myappserviceplan' with your values

az group create --name MyResourceGroup --location westus2
az appservice plan create --name myappserviceplan --resource-group MyResourceGroup --sku B1 --is-linux
az webapp create --name MyAppName --resource-group MyResourceGroup --plan myappserviceplan --runtime "DOTNETCORE:7.0"

# Deploy your application code (e.g., from a zip file or Git repository)
# az webapp deployment source config-zip --resource-group MyResourceGroup --name MyAppName --src zip your_app.zip

```

--------------------------------

### Build a Web API with ASP.NET Core

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Learn to develop HTTP services using ASP.NET Core. This section covers choosing between controller-based APIs and minimal APIs, and provides guidance on creating both.

```csharp
/// <summary>
/// Creates a new minimal web API.
/// </summary>
/// <remarks>
/// This example demonstrates the creation of a minimal API endpoint.
/// </remarks>
/// <returns>A 201 Created response.</returns>
app.MapPost("/todos", async (Todo todo, TodoDb db) =>
{
    db.Todos.Add(todo);
    await db.SaveChangesAsync();

    return TypedResults.Created($"/todos/{todo.Id}", todo);
});

/// <summary>
/// Creates a new web API using controllers.
/// </summary>
/// <remarks>
/// This example demonstrates a basic controller-based API endpoint.
/// </remarks>
[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
    private readonly ProductDb _context;

    public ProductsController(ProductDb context)
    {
        _context = context;
    }

    // GET: api/Products
    [HttpGet]
    public async Task<ActionResult<IEnumerable<Product>>> GetProducts()
    {
        return await _context.Products.ToListAsync();
    }
}
```

--------------------------------

### Hosting ASP.NET Core on Linux with Nginx

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Instructions for hosting ASP.NET Core applications on Linux servers using Nginx as a reverse proxy. This includes configuration steps for Nginx.

```nginx
# Example Nginx configuration for an ASP.NET Core application

server {
    listen 80;
    server_name your_domain.com;

    location / {
        proxy_pass http://localhost:5000; # Assuming your app runs on port 5000
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection keep-alive;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

```

--------------------------------

### Develop Web Apps Using the Model-View-Controller (MVC) Pattern in ASP.NET Core

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Build web applications using the Model-View-Controller design pattern. This section covers creating your first ASP.NET Core MVC app, Views, Controllers, and routing.

```csharp
// Example of an MVC Controller

// HomeController.cs
public class HomeController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public IActionResult About()
    {
        ViewBag.Message = "Your application description page.";
        return View();
    }

    public IActionResult Contact()
    {
        ViewBag.Message = "Your contact page.";
        return View();
    }
}

// Views/Home/Index.cshtml
@{ 
    ViewData["Title"] = "Home Page";
}

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
</div>
```

--------------------------------

### Build Data-Driven Web Apps with ASP.NET Core

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Create data-driven web applications in ASP.NET Core. This covers data binding in Blazor, using SQL Server Express with Razor Pages, and Entity Framework Core with Razor Pages and MVC.

```csharp
// Example using Entity Framework Core with Razor Pages

// Data/MyDbContext.cs
public class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options)
        : base(options)
    {
    }

    public DbSet<Product> Products { get; set; }
}

// Pages/Products.cshtml.cs
public class ProductsPageModel : PageModel
{
    private readonly MyDbContext _context;

    public ProductsPageModel(MyDbContext context)
    {
        _context = context;
    }

    public IList<Product> Products { get; private set; }

    public async Task OnGetAsync()
    {
        Products = await _context.Products.ToListAsync();
    }
}

// Pages/Products.cshtml
@page
@model ProductsPageModel

<h2>Products</h2>

<ul>
    @foreach (var product in Model.Products)
    {
        <li>@product.Name - $@product.Price</li>
    }
</ul>
```

--------------------------------

### Develop Client-Side Blazor Web Apps with ASP.NET Core

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Build interactive web UIs with reusable UI components that can leverage WebAssembly for near-native performance. This covers creating Blazor applications and using reusable components.

```csharp
// Example of a reusable Blazor component

@* MyCounter.razor *@

<h1>Counter</h1>

<p role="status">Current count: @currentCount</p>

<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>

@code {
    private int currentCount = 0;

    private void IncrementCount()
    {
        currentCount++;
    }
}
```

--------------------------------

### ASP.NET Core Integration Tests

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Write and execute integration tests for your ASP.NET Core applications. This covers testing the interactions between different components and services.

```csharp
// Example of an integration test for an API endpoint

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Test.Execution;
using Microsoft.Extensions.DependencyInjection;
using System.Net.Http;
using Xunit;

public class ApiIntegrationTests : IClassFixture<TestWebApplicationFactory<Program>> // Assuming Program is your application's startup class
{
    private readonly TestWebApplicationFactory<Program> _factory;

    public ApiIntegrationTests(TestWebApplicationFactory<Program> factory)
    {
        _factory = factory;
    }

    [Fact]
    public async Task Get_Products_ReturnsSuccessStatusCode()
    {
        // Arrange
        var client = _factory.CreateClient();

        // Act
        var response = await client.GetAsync("/api/Products");

        // Assert
        response.EnsureSuccessStatusCode(); // Status Code 200-299
        Assert.Equal("application/json; charset=utf-8", response.Content.Headers.ContentType?.ToString());
    }
}

// You would typically have a TestWebApplicationFactory class defined elsewhere
/*
public class TestWebApplicationFactory<TStartup> : WebApplicationFactory<TStartup>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureServices(services =>
        {
            // Override services for testing, e.g., replace DbContext with an in-memory version
        });
    }
}
*/
```

--------------------------------

### Develop High-Throughput Services with gRPC in ASP.NET Core

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Build high-performance services that prioritize contracts using gRPC in ASP.NET Core. This covers creating gRPC clients and servers, and understanding gRPC concepts in C#.

```csharp
// Example of a gRPC Service

// GreeterService.cs
using Grpc.Core;
using Shared;

public class GreeterService : Greeter.GreeterBase
{
    private readonly ILogger<GreeterService> _logger;
    public GreeterService(ILogger<GreeterService> logger)
    {
        _logger = logger;
    }

    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = "Hello " + request.Name
        });
    }
}

// Shared proto file (e.g., greet.proto)
/*
proto-3;

package greet;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}
*/
```

--------------------------------

### ASP.NET Core Unit Testing with Razor Pages

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Learn how to perform unit tests on your Razor Pages in ASP.NET Core. This includes strategies for testing page handlers and associated logic.

```csharp
// Example of unit testing a Razor Page handler

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Moq;
using Xunit;

public class IndexPageModelTests
{
    [Fact]
    public void OnGet_ReturnsPageWithItems()
    {
        // Arrange
        var mockLogger = new Mock<ILogger<IndexModel>>();
        var pageModel = new IndexModel(mockLogger.Object);

        // Act
        pageModel.OnGet();

        // Assert
        Assert.NotNull(pageModel.Items);
        Assert.NotEmpty(pageModel.Items);
        Assert.Equal(3, pageModel.Items.Count);
    }

    [Fact]
    public void OnPostSomething_RedirectsToIndex()
    {
        // Arrange
        var mockLogger = new Mock<ILogger<IndexModel>>();
        var pageModel = new IndexModel(mockLogger.Object);

        // Act
        var result = pageModel.OnPostSomething();

        // Assert
        var redirectResult = Assert.IsType<RedirectToPageResult>(result);
        Assert.Null(redirectResult.PageName); // Redirects to the current page
    }
}
```

--------------------------------

### Add Real-Time Functionality with SignalR in ASP.NET Core

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Add real-time functionality to your web application, enabling server-side code to push content instantly. This includes creating SignalR applications and using it with Blazor and TypeScript.

```csharp
// Example of a SignalR Hub

// ChatHub.cs
using Microsoft.AspNetCore.SignalR;

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

// Client-side JavaScript example
/*
const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chatHub")
    .build();

connection.on("ReceiveMessage", function (user, message) {
    // ... display message ...
});

connection.start().catch(err => {
    console.error(err.toString());
});
*/
```

--------------------------------

### Build Page-Centric Web UIs with Razor Pages in ASP.NET Core

Source: https://learn.microsoft.com/es-es/aspnet/core/?view=aspnetcore-9.0/index

Develop page-focused web applications with a clear separation of concerns using Razor Pages. This includes creating your first Razor Pages app and consuming web APIs.

```csharp
// Example of a Razor Page handler method

// MyPage.cshtml.cs
public class IndexModel : PageModel
{
    private readonly ILogger<IndexModel> _logger;
    public List<string> Items { get; private set; }

    public IndexModel(ILogger<IndexModel> logger)
    {
        _logger = logger;
    }

    public void OnGet()
    {
        Items = new List<string> { "Item 1", "Item 2", "Item 3" };
        _logger.LogInformation("OnGet called.");
    }

    public IActionResult OnPostSomething()
    {
        // Handle POST request logic
        return RedirectToPage();
    }
}

// MyPage.cshtml
@page
@model IndexModel

<h3>My List</h3>
<ul>
    @foreach (var item in Model.Items)
    {
        <li>@item</li>
    }
</ul>

<form method="post" asp-page-handler="Something">
    <button type="submit">Post Something</button>
</form>
```
Tokens:
Raw