asp.net-core-mvc Zelfstudie
Aan de slag met asp.net-core-mvc

Opmerkingen

Installatie of instellingen

Visual Studio installeren

Als u Visual Studio niet hebt geïnstalleerd, kunt u de gratis Visual Studio Community Edition hier downloaden . Als u het al hebt geïnstalleerd, kunt u doorgaan naar de volgende stap.

Een ASP.NET Core MVC-toepassing maken.

1. Open Visual Studio.
2. Selecteer Bestand> Nieuw project.
3. Selecteer Web in de taal van uw keuze in het gedeelte Sjablonen aan de linkerkant.
4. Kies het gewenste projecttype in het dialoogvenster.
5. Optioneel: kies een .NET Framework dat u wilt targeten
6. Geef uw project een naam en geef aan of u een oplossing voor het project wilt maken.
7. Klik op OK om het project te maken.

U krijgt een ander dialoogvenster om de sjabloon te selecteren die u voor het project wilt gebruiken:

Elk van de beschrijvingen spreekt voor zich. Selecteer voor dit eerste project de webtoepassing , die alle standaardconfiguraties, authenticatie en sommige bestaande inhoud zal bevatten.

Aangezien dit een introductietoepassing is en geen beveiliging of verificatie vereist, kunt u de verificatieoptie wijzigen in Geen verificatie aan de rechterkant van het dialoogvenster en op OK klikken om het project te maken .

U zou het nieuwe project dan in Solution Explorer moeten zien:

Druk op F5 om de toepassing uit te voeren en een foutopsporingssessie te starten, waarmee de toepassing wordt gestart in uw standaardbrowser:

U kunt nu zien dat uw project lokaal operationeel is en klaar is als startpunt voor het bouwen van uw applicatie.

PS: Gebruikt Aan de slag met asp.net-core onderwerp van de asp.net-core Documentation.

MVC Middleware toevoegen

Als u een leeg project hebt gemaakt of als u nog steeds geen mvc hebt geconfigureerd in uw toepassing, kunt u afhankelijkheid toevoegen:

"Microsoft.AspNetCore.Mvc": "1.0.1"

Naar uw project.json bestand onder "dependencies" .

En registreer MVC-middleware in uw Startup-klasse:

public void ConfigureServices(IServiceCollection services)
{
    ...
    services.AddMvc();
}

Merk op dat we zowel services.AddMvc() als services.AddMvcCore() . Als je begint met asp.net core , of je wilt het zoals het is, moet je doorgaan met services.AddMvc() . Maar als u een geavanceerde ervaring wilt, kunt u beginnen met een minimale MVC-pijplijn en functies toevoegen om een aangepast kader te krijgen met behulp van services.AddMvcCore() . Zie deze discussie voor meer informatie over AddMvcCore

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddMvcCore()
        .AddAuthorization()
        .AddJsonFormatters(j => j.Formatting = Formatting.Indented);
}

Nu kunt u uw applicatiebouwer vertellen om de mvc te gebruiken:

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    ...
    app.UseMvc();
}

of met standaardrouting:

app.UseMvc(routes =>
{
    routes.MapRoute(
        name: "default",
        template: "{controller=Home}/{action=Index}/{id?}");
});

Afhankelijkheid injectie basics

Bijna elke controller heeft externe afhankelijkheden nodig om te werken. Hier is een manier om een afhankelijkheidsobject (of de fabrieksinstelling) ervan te configureren en door te geven aan een controller. Als u dit doet, blijft een scheiding van zorgen behouden , blijft de code duidelijk en testbaar.

Stel, we hebben een interface en de implementatie ervan die enkele waarden van config nodig heeft in de constructor:

public interface ISomeDependency
{
    async Task<IEnumerable<string>> GetItemsAsync(string key);
}

public class SomeDependency : ISomeDependency
{
    public SomeDependency(string connectionString)
    {
        ...
    }
    ...
}

Het wordt gebruikt in sommige controllerklassen:

public class SomeController : Controller
{
    private reanonly ISomeDependency dependency;

    public SomeController(ISomeDependency dependency)
    {
        ...
        this.dependency = dependency;
    }

    ...

    public async Task<IEnumerable<string>> Get(string key) =>
        await dependency.GetItemsAsync(key);
}

Men kan deze afhankelijkheid injecteren in de controllerconstructor die services.AddTransient aanroept. Startup.ConfigureServices in de Startup.ConfigureServices methode:

public class Startup
{
    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder().
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
        ...
        Configuration = builder.Build();
    }

    public IConfigurationRoot Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        ...
        services.AddTransient(serviceProvider =>
            new MyDependency(Configuration["Data:ConnectionString"]));
    }

    ...
}

Here Data:ConnectionString is een pad naar een instelling in het bestand appsettings.json :

{
  ...
  },
  "Data": {
    "ConnectionString": "some connection string"
  }
}

Lifetime management

Om een levensduur van het geïnjecteerde object te beheren, samen met AddTransient , bestaan nog twee opties: AddSingleton en AddScoped . De laatste betekent dat de levensduur van het object wordt bereikt voor een HTTP-verzoek.

versies

Officiële routekaart @ Github

* Verwijzingen naar jaarlijkse kwartalen (Q1, Q2, Q3, Q4) zijn op kalenderbasis