asp.net-core-mvc Handledning
Komma igång med asp.net-core-mvc

Anmärkningar

Installation eller installation

Installera Visual Studio

Om du inte har Visual Studio installerat kan du ladda ner gratis Visual Studio Community Edition här . Om du redan har det installerat kan du gå vidare till nästa steg.

Skapa en ASP.NET Core MVC-applikation.

1. Öppna Visual Studio.
2. Välj Arkiv> Nytt projekt.
3. Välj webb under det språk du väljer i avsnittet Mallar till vänster.
4. Välj en önskad projekttyp i dialogrutan.
5. Valfritt: Välj ett .NET-ramverk som du vill rikta in dig på
6. Namnge ditt projekt och ange om du vill skapa en lösning för projektet.
7. Klicka på OK för att skapa projektet.

Du får en annan dialog för att välja den mall du vill använda för projektet:

Var och en av beskrivningarna är självförklarande. För detta första projekt väljer du webbapplikation , som kommer att innehålla alla standardkonfigurationer, autentisering och en del befintligt innehåll.

Eftersom detta är en introduktionsapplikation och inte kräver någon säkerhet eller verifiering, kan du ändra autentiseringsalternativet till Ingen autentisering till höger i dialogrutan och klicka på OK för att skapa projektet .

Du bör sedan se det nya projektet i Solution Explorer:

Tryck på F5 för att köra applikationen och starta en felsökningssession, som kommer att starta applikationen i din standardwebbläsare:

Du kan nu se att ditt projekt är igång lokalt och är redo som en utgångspunkt för dig att bygga din applikation.

PS: Används Komma igång med asp.net-core- ämnet från asp.net-core- dokumentationen.

Lägg till MVC Middleware

Om du skapade ett tomt projekt eller fortfarande inte har mvc konfigurerat i din applikation kan du lägga till beroende:

"Microsoft.AspNetCore.Mvc": "1.0.1"

Till din project.json fil under "dependencies" .

Och registrera MVC-mellanprogram i din startklasse:

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

Observera att vi har både services.AddMvc() och services.AddMvcCore() . Om du börjar med asp.net core , eller om du vill ha den så som den är, bör du hålla med services.AddMvc() . Men om du vill ha en avancerad upplevelse kan du börja med en minimal MVC-pipeline och lägga till funktioner för att få ett anpassat ramverk med services.AddMvcCore() . Se den här diskussionen för mer information om AddMvcCore

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

Nu kan du berätta för din applikationsbyggare att använda mvc:

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

eller med standard routing:

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

Grunder för injektion av beroende

Nästan alla styrenheter behöver vissa externa beroenden för att fungera. Här är ett sätt att konfigurera ett beroendeobjekt (eller dess fabrik) och skicka det till en controller. Om du gör det kommer det att hjälpa till att upprätthålla en oroande skillnad , hålla koden tydlig och testbar.

Säg att vi har ett gränssnitt och dess implementering som behöver vissa värden från config i sin konstruktor:

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

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

Det används i någon kontrollklass:

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);
}

Man kan injicera detta beroende i regulatorn konstruktören ringer services.AddTransient inne Startup.ConfigureServices metod:

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"]));
    }

    ...
}

Här är Data:ConnectionString en sökväg till en inställning i appsettings.json filen:

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

Livsledningshantering

För att hantera det injicerade objektets livstid, tillsammans med AddTransient ytterligare två alternativ: AddSingleton och AddScoped . Den sista innebär att objektets livstid skopas till en HTTP-begäran.

versioner

Officiell färdplan @ Github

* Hänvisningar till årskvartal (Q1, Q2, Q3, Q4) är kalenderbaserade