So schreiben Sie ein einfaches Blog mit Asp .Net MVC, Nhibernate und Ninject: Teil 1

  • Tutorial
Übersetzung
  1. Einleitung


    Es gibt verschiedene Möglichkeiten, Technologie zu studieren: Bücher lesen, an Konferenzen teilnehmen, Beispiele erstellen und andere. Ich denke, eine der besten Möglichkeiten ist es, mit der zu untersuchenden Technologie etwas Nützliches für sich selbst zu schaffen. Ein Blog ist eines der nützlichen Dinge, die Sie leicht tun können. In einer Reihe von Artikeln lernen wir Schritt für Schritt ASP.NET MVC kennen, indem wir ein Blog von Grund auf neu erstellen.

    Der Einfachheit halber werden wir kein Kommentarsystem erstellen, sondern Disqus verwenden . Versuchen Sie, selbst ein Kommentarsystem zu erstellen, dies ist eine gute Übung für Sie.

    Für die Anwendungsentwicklung verwenden wir ASP.NET MVC 4. Ich bin nicht stark im Entity Framework und wir verwenden Fluent NHibernate / NHibernate, um ein Datenzugriffssystem (DAL) zu erstellen. Wenn Sie möchten, können Sie das Entity Framework verwenden. Für die Abhängigkeitsinjektion verwenden wir Ninject wegen seiner Einfachheit.

    • Im ersten Teil erstellen wir die grundlegende Blog-Infrastruktur. Lassen Sie uns die erforderlichen Klassen von Modellen und Datenzugriffskomponenten erstellen.
    • Im zweiten Teil implementieren wir Controller, Aktionsmethoden und Repräsentationen. Am Ende des zweiten Teils werden wir einen Arbeitsblog haben, in dem wir die neuesten Beiträge sehen, den vollständigen Text des Beitrags lesen, Beiträge nach Kategorie oder Tag auswählen und sogar nach interessanten Beiträgen (Posts) suchen können.
    • Im dritten Teil erstellen wir eine Administrationskonsole zum Verwalten von Posts, Kategorien und Tags.
    • Im vierten Teil werden wir das Disqus- Kommentarsystem in unserem Blog vorstellen . Wir werden auch zwei neue Dienste einführen: den AddThis- Austauschdienst und den Feedburner- Abonnementdienst .

  2. Technologie


    • ASP.NET MVC 4.0
    • Fließendes NHibernate und NHibernate
    • SQL Server 2012
    • Ninject
    • jQuery


  3. Schaffung einer Basisinfrastruktur.


    In diesem Teil beschreiben wir die Aufgaben, die wir ausführen müssen:

    Aufgabe 1. Den letzten Blog-Beitrag

    anzeigen . Aufgabe 2. Beiträge einer bestimmten Kategorie

    anzeigen. Aufgabe 3. Beiträge basierend auf dem Tag anzeigen. Aufgabe 4. Nach

    Beiträgen

    suchen . Aufgabe 5. Den vollständigen Beitrag

    anzeigen . Aufgabe 6. Beiträge anzeigen einer bestimmten Kategorie im Widget

    Aufgabe 7. Beiträge basierend auf dem Tag im Widget

    anzeigen Aufgabe 8. Den letzten Beitrag im Widget anzeigen

    Aufgabe 1. Zeigen Sie den neuesten Blog-Beitrag an.


    Um diese Aufgabe zu erfüllen, müssen wir eine Auswahl von Blog-Posts aus der Datenbank treffen und diese in einer Ansicht anzeigen.


    Diese Aufgabe ist groß genug, also teilen wir sie in mehrere kleinere Unteraufgaben auf, die sich leichter getrennt ausführen lassen

    1. Erstellen Sie eine Basislösung
    2. Erstellen Sie Domänenklassen
    3. Konfigurieren Sie Fluent NHibernate und NHibernate
    4. Erstellen Sie Zuordnungsklassen, Datenzugriffsklassen und Methoden
    5. Konfigurieren Sie Ninject für JustBlog.Core
    6. Konfigurieren Sie Ninject für MVC Project
    7. Erstellen Sie Controller und Aktionen
    8. Ansicht erstellen


    4.1 Erstellen einer Basislösung

    Erstellen Sie ein MVC 4-Webanwendungsprojekt und nennen Sie es JustBlog .


    Wählen Sie im Fenster "Vorlage auswählen " die Option "Leere Vorlage" .


    Erstellen Sie eine Klassenbibliothek und nennen Sie sie JustBlog.Core . Es wird empfohlen, Domänenklassen und Datenzugriffskomponenten in separaten Projekten zu speichern, damit wir die Anwendung in Bezug auf Entwicklung, Test und Bereitstellung einfacher verwalten können. Vergessen Sie nicht , einen Link hinzuzufügen JustBlog.Core in JustBlog .

    Die Lösung sollte wie folgt aussehen.


    4.2 Erstellen von Domänenklassen

    Erstellen Sie im Projekt JustBlog.Core einen neuen Ordner mit dem Namen Objects , um die Domänenklassen darin abzulegen . Für unser Blog müssen drei Klassen erstellt werden: Post , Category und Tag . Jeder Beitrag gehört zu einer Kategorie , kann aber mit vielen Tags markiert werden . Zwischen Post- und Category- Many-to-One- Beziehungen und zwischen Post- und Tag- Many-to-Many- Beziehungen .

    Die Beziehung zwischen den Klassen wird im folgenden Screenshot gezeigt



    : Unsere Post-Klasse wird unten gezeigt.

    namespace JustBlog.Core.Objects
    {
        public class Post
        {
            public virtual int Id
            { get; set; }
            public virtual string Title
            { get; set; }
            public virtual string ShortDescription
            { get; set; }
            public virtual string Description
            { get; set; }
            public virtual string Meta
            { get; set; }
            public virtual string UrlSlug
            { get; set; }
            public virtual bool Published
            { get; set; }
            public virtual DateTime PostedOn
            { get; set; }
            public virtual DateTime? Modified
            { get; set; }
            public virtual Category Category
            { get; set; }
            public virtual IList Tags
            { get; set; }
        }
    }
    


    Die meisten Eigenschaften sind selbsterklärend. Die UrlSlug- Eigenschaft ist eine Alternative zur Title- Eigenschaft und wird für die Adressierung verwendet.

    Slug ist ein Zeitungsbegriff. "Slug" ist ein kurzer Markierungsname, der nur Buchstaben, Zahlen, Unterstriche oder Bindestriche enthält. Wird hauptsächlich in URLs verwendet.


    Beispielsweise haben wir einen Beitrag mit dem Titel "Advanced Linq in C #" im August 2010 veröffentlicht. Wir erstellen eine URL für diesen Beitrag unter http // localhost / archive / 2010/8 / Advanced Linq in C # . Der Beitragstitel kann Sonderzeichen enthalten (in diesem Beispiel "#"), und nicht alle Server können Anforderungen verarbeiten, die Sonderzeichen enthalten. Anstatt die Title- Eigenschaft direkt in der URL zu verwenden, verwenden wir alternativen Text, der wie ein Beitragstitel aussieht, und nehmen ihn aus der Slug-URL- Eigenschaft .

    In diesem Fall verwenden wir anstelle von "Advanced Linq in C #" in der URL den angezeigten Text (Slug) "advanced_linq_in_csharp".Die Adresse lautet daher http // localhost / archive / 2010/8 / advanced_linq_in_csharp. In Teil 3 lernen wir, wie aus dem Post-Titel automatisch ein Slug erstellt wird.

    URL Slug
    URL Slug ist ein SEO - und benutzerfreundlicher Teil der URL-Zeichenfolge zum Identifizieren, Beschreiben und Zugreifen auf eine Ressource. Oft ist der Seitentitel eines Artikels ein geeigneter Kandidat dafür.


    Die Meta- Eigenschaft wird zum Speichern von Post-Description-Metadaten und für SEO verwendet. Alle Eigenschaften werden als virtuell markiert, da NHibernate zur Laufzeit einen Proxyserver erstellt und alle Eigenschaften dieser Klasse für die Arbeit virtuell sein müssen.

    Die Klassen Category und Tag sind sehr einfach und werden im Folgenden gezeigt. Wir verwenden die UrlSlug- Eigenschaft aus demselben Grund, den wir oben erläutert haben.

    namespace JustBlog.Core.Objects
    {
        public class Category
        {
            public virtual int Id
            { get; set; }
            public virtual string Name
            { get; set; }
            public virtual string UrlSlug
            { get; set; }
            public virtual string Description
            { get; set; }
            public virtual IList Posts
            { get; set; }
        }
    }
    


    namespace JustBlog.Core.Objects
    {
        public class Tag
        {
            public virtual int Id
            { get; set; }
            public virtual string Name
            { get; set; }
            public virtual string UrlSlug
            { get; set; }
            public virtual string Description
            { get; set; }
            public virtual IList Posts
            { get; set; }
        }
    }
    


    4.3 Konfigurieren von Fluent NHibernate und NHibernate

    Für den Zugriff auf die Datenbank verwenden wir NHibernate zusammen mit Fluent NHibernate . NHibernate ist ein ORM-Tool wie das Entity Framework, bei dem Beziehungen zwischen Klassen und Datenbanktabellen über XML-Dateien abgebildet werden. Fluent NHibernate ist eine Erweiterung für NHibernate, die das Mapping mit XML-Dateien durch das Mapping mit speziellen Klassen ersetzt. Das Vergleichen von Klassen ist viel einfacher als das Verwenden von XML-Dateien.

    Mit der Nuget Package Manager-Konsole können Sie problemlos Verweise auf NHibernate- und Fluent NHibernate-Assemblys hinzufügen . Öffnen Sie Package Manager über das Menü Tools -> Library Package Manager -> Package Manager Console .

    Führen Sie in der Konsole den folgenden Befehl aus.

    PM> Install-Package FluentNHibernate

    Wenn die Installation erfolgreich war, werden die folgenden Assemblys im Ordner "Referenzen" des JustBlog.Core- Projekts angezeigt .

    FluentNHibernate
    NHibernate
    Iesi.Collections

    4.4 Erstellen von Zuordnungsklassen, Datenzugriffsklassen und Methoden

    Als nächstes müssen wir die erforderlichen Mapping-Klassen erstellen. Die Zuordnungsklasse wird verwendet, um die Klasse und ihre Eigenschaften der Tabelle und ihren Spalten zuzuordnen. Erstellen Sie im JustBlog.Core- Projekt einen neuen Ordner mit dem Namen Mappings , um alle Mapping-Klassen zu speichern.

    Um eine Zuordnungsklasse zu erstellen, müssen wir sie von der generischen ClassMap- Klasse des Fluent NHibernate-Frameworks erben. Alle Zuordnungen müssen im Konstruktor durchgeführt werden.
    Die Zuordnungsklasse für die Post- Klasse .

    using FluentNHibernate.Mapping;
    using JustBlog.Core.Objects;
    namespace JustBlog.Core.Mappings
    {
        public class PostMap: ClassMap
        {
            public PostMap()
            {
                Id(x => x.Id);
                Map(x => x.Title).Length(500).Not.Nullable();
                Map(x => x.ShortDescription).Length(5000).Not.Nullable();
                Map(x => x.Description).Length(5000).Not.Nullable();
                Map(x => x.Meta).Length(1000).Not.Nullable();
                Map(x => x.UrlSlug).Length(200).Not.Nullable();
                Map(x => x.Published).Not.Nullable();
                Map(x => x.PostedOn).Not.Nullable();
                Map(x => x.Modified);
                References(x => x.Category).Column("Category").Not.Nullable();
                HasManyToMany(x => x.Tags).Table("PostTagMap");
            }
        }
    }
    


    Die Erweiterungsmethode Id repräsentiert den Namen der Eigenschaft, die als Primärschlüssel für die Tabellenspalte festgelegt werden soll.

    Die Map- Erweiterungsmethode wird verwendet, um die Eigenschaft einer Tabellenspalte zuzuordnen. Während der Eigenschaftenzuordnung können wir die Größe der Spalte angeben, angeben, ob das Speichern von NULL-Werten zulässig ist, oder andere Spezifikationen angeben.

    Zum Beispiel:

    Map(x => x.ShortDescription).Length(5000).Not.Nullable();
    


    Wenn sich der generierte Spaltenname vom Eigenschaftsnamen unterscheidet, müssen wir den Spaltennamen mit der Column- Erweiterungsmethode übergeben .

    Map(x => x.Title).Column("post_title")
    


    Die References- Methode wird verwendet, um die 1: 1- Beziehung zwischen Post und Category mithilfe der Schlüsselspalte für die externe Kategorie der Post- Tabelle darzustellen . Die HasManyToMany- Methode wird verwendet, um die Viele-zu-Viele-Beziehung zwischen Post und Tag über eine PostTagMap- Staging-Tabelle darzustellen . Sie können mehr über das erfahren Fluent NHibernate und metodoh Erweiterungen hier .

    Standardmäßig Fluent NHibernateAngenommen, der Tabellenname stimmt genau mit dem Klassennamen überein, und die Spaltennamen stimmen genau mit den Eigenschaftennamen überein. Wenn der Tabellenname unterschiedlich ist, müssen wir die Tabelle der Klasse mithilfe der Table- Erweiterungsmethode zuordnen .

    Zum Beispiel:

    Table("tbl_posts");
    


    Die Mapping-Klassen für Category und Tag sind bis auf die Beziehung zu Post identisch . Kategorie bezieht sich auf den Beitrag einer Eins-zu-viele , während der Tag ist ein Beitrag Haltung von many-to-many .

    namespace JustBlog.Core.Mappings
    {
        public class CategoryMap: ClassMap
        {
            public CategoryMap()
            {
                Id(x => x.Id);
                Map(x => x.Name).Length(50).Not.Nullable();
                Map(x => x.UrlSlug).Length(50).Not.Nullable();
                Map(x => x.Description).Length(200);
                HasMany(x => x.Posts).Inverse().Cascade.All().KeyColumn("Category");
            }
        }
    }
    


    Die Inverse () - Erweiterungsmethode macht die andere Seite der Beziehung für die Erhaltung verantwortlich.

    Die Erweiterungsmethode Cascade.All () löst einen kaskadierenden Ereignisaufruf (in der Hierarchie) in den Entitäten der Auflistung aus (daher werden beim Speichern einer Kategorie auch Beiträge gespeichert).

    namespace JustBlog.Core.Mappings
    {
        public class TagMap: ClassMap
        {
            public TagMap()
            {
                Id(x => x.Id);
                Map(x => x.Name).Length(50).Not.Nullable();
                Map(x => x.UrlSlug).Length(50).Not.Nullable();
                Map(x => x.Description).Length(200);
                HasManyToMany(x => x.Posts).Cascade.All().Inverse().Table("PostTagMap");
            }
        }
    }
    


    Wir werden die Repository- Vorlage verwenden, um auf die Datenbank zuzugreifen. Wir verwenden diese Vorlage, um den Datenzugriffscode von den Controllern zu trennen, und dies wird uns dabei helfen, den Komponententest unserer Controller zu vereinfachen. Der Kern der Repository-Vorlage ist eine Schnittstelle, die Beschreibungen aller Datenzugriffsmethoden enthält. Erstellen Sie

    im JustBlog.Core- Projekt eine IBlogRepository- Schnittstelle mit zwei Methoden.

    using JustBlog.Core.Objects;
    namespace JustBlog.Core
    {
        public interface IBlogRepository
        {
            IList Posts(int pageNo, int pageSize);
            int TotalPosts();
        }
    }
    


    Die Posts- Methode wird verwendet, um die zuletzt veröffentlichten paginierten Posts gemäß den an sie übergebenen Werten zurückzugeben. Die TotalPosts- Methode gibt die Gesamtzahl der veröffentlichten Beiträge zurück. Als nächstes werden wir die Schnittstelle mit anderen Methoden füllen.

    Im JustBlog.Core- Projekt eine Klasse namens BlogRepository und implementieren Sie die Schnittstelle.

    using JustBlog.Core.Objects;
    using NHibernate;
    using NHibernate.Criterion;
    using NHibernate.Linq;
    using NHibernate.Transform;
    using System.Collections.Generic;
    using System.Linq;
    namespace JustBlog.Core
    {
        public class BlogRepository: IBlogRepository
        {
            // NHibernate object
            private readonly ISession _session;
            public BlogRepository(ISession session)
            {
                _session = session;
            }
            public IList Posts(int pageNo, int pageSize)
            {
            var posts = _session.Query()
                                  .Where(p => p.Published)
                                  .OrderByDescending(p => p.PostedOn)
                                  .Skip(pageNo * pageSize)
                                  .Take(pageSize)
                                  .Fetch(p => p.Category)
                                  .ToList();
    		}
            var postIds = posts.Select(p => p.Id).ToList();
            return _session.Query()
                  .Where(p => postIds.Contains(p.Id))
                  .OrderByDescending(p => p.PostedOn)
                  .FetchMany(p => p.Tags)
                  .ToList();
            }
            public int TotalPosts()
            {
                return _session.Query().Where(p => p.Published).Count();
            }
        }
    }
    


    Der gesamte Datenbankzugriff sollte über das NHibernate ISession- Objekt erfolgen . Wenn wir eine Sammlung von Posts über ISession lesen , werden die Kategorien- und Tags- Abhängigkeiten standardmäßig nicht ausgefüllt . Mit den Methoden Fetch und FetchMany wird NHibernate angewiesen, sie sofort auszufüllen.

    Bei dem Verfahren der Beiträge , die Beiträge zu bekommen, bitten wir um das Doppelte der Datenbank , weil wir nicht verwenden können FetchMany zusammen mit Methoden überspringen und Nehmenin Linq Anfrage. Also wählen wir zuerst alle Posts aus und wählen dann die Posts unter Verwendung ihrer IDs erneut aus, um ihre Tags zu erhalten. In diesem Diskussionsthread finden Sie weitere Informationen zu diesem Problem.

    NHibernate ISession

    ISession ist eine Persistenzmanager-Schnittstelle, die zum Speichern und Abrufen von Objekten aus einer Datenbank verwendet wird.

    Persistent bedeutet, dass diese Instanz so implementiert werden sollte, dass sie nach Abschluss des Prozesses, der sie generiert hat, erhalten bleibt. Im Gegensatz zu transient, was bedeutet, dass diese Instanz des Objekts temporär ist, ist sie nach Abschluss des Prozesses, der sie generiert hat, nicht mehr vorhanden. (Kommentar Übersetzer).


    4.5 Ninject-Einstellungen für das JustBlog.Core-Projekt

    Durch Dependency Injection (DI) wird vermieden, dass bestimmte Abhängigkeitsimplementierungen innerhalb einer Klasse instanziiert werden. Diese Abhängigkeiten werden normalerweise über den Konstruktor, manchmal aber auch über die Eigenschaften in die Klasse eingefügt. Einer der Hauptvorteile der Abhängigkeitsinjektion ist das Testen von Einheiten, und wir werden es sehen, wenn wir in Teil 3

    Komponententests für Steuerungen schreiben. Es gibt viele Frameworks zur Vereinfachung der Abhängigkeitsinjektion, wie z. B. Castle Windsor, Unity, Autofac, StructureMap, Ninject usw. Wir haben uns entschieden Ninject, weil es einfach zu bedienen ist.

    Installieren Sie Ninject im JustBlog.Core- Projekt, indem Sie die folgenden Befehle in der Package Manager-Konsole ausführen .

    PM> Install-Package Ninject
    PM> Install-Package Ninject.Web.Common


    Nach erfolgreicher Ausführung der Befehle sehen wir, dass die Assemblys Ninject und NinjectWeb.Common zum Projekt hinzugefügt wurden. Zusammen mit Baugruppen auch Datei hinzufügen NinjectWebCommon.cs einen Ordner App_Start . In naher Zukunft werde ich erklären, warum wir die Ninject.Web.Common-Erweiterung installieren müssen.

    Wir können Ninject auf zwei Arten konfigurieren , entweder mit Global.asax.cs oder über die App_Start- Datei . Wir werden den ersten Ansatz verwenden, so wenden Sie sich bitte die Datei löschen NinjectWebCommon.cs Ordner App_Start sowie Löschen Sie nicht benötigte Montage Referenzen WebActivator und Microsoft.Web.Infrastructure des Projekts.

    Die Hauptfunktionalität eines DI-Frameworks besteht in der Bindung von Schnittstellen an bestimmte Implementierungen dieser Schnittstellen. Das Verknüpfen einer Schnittstelle mit einer bestimmten Implementierung wird als Bindung bezeichnet. Mit Ninject-Modulen können wir die einem bestimmten Ninject-Modul zugeordneten Bindungen gruppieren. Alle Bindungen und Module werden in die Ninject-Hauptkomponente des Kernel-Kernels geladen. Wenn eine Anwendung eine Instanz einer bestimmten Klasse benötigt, die die Schnittstelle implementiert, stellt der Kernel sie der Anwendung zur Verfügung.

    Ninject-Modul

    Das Ninject-Modul dient zum Gruppieren von Übereinstimmungen / Bindungen, die sich auf ein bestimmtes Modul in einer Klasse beziehen.


    Die BlogRepository- Klasse ist von Nibernate ISession abhängig . Um eine Instanz von ISession zu erstellen , benötigen wir eine andere Nibernate-Schnittstelle namens ISessionFactory . Erstellen wir im JustBlog.Core- Projekt ein ninject- Modul einer Klasse namens RepositoryModule , das beide Schnittstellen verbindet.

    Erstellt q Das Ninject-Modul muss von der abstrakten NinjectModule- Klasse erben und die Load- Methode implementieren . In der Load-Methode binden wir beide Schnittstellen mit der Bind- Methode an Methoden .

    Die Bind- Methode wird verwendet, um eine Schnittstelle an eine Klasse zu binden, die sie implementiert.

    Zum Beispiel:

    Bind().To();
    


    Wir können die Schnittstelle auch einer Methode zuordnen, die eine Implementierung der Schnittstelle erstellt und zurückgibt.

    Bind().ToMethod(c => {
        var foo = new Foo();
        return foo;
    });
    


    NHibernate ISessionFactory

    Im Gegensatz zu ISession benötigen wir in der gesamten Anwendung eine Instanz von ISessionFactory.


    using FluentNHibernate.Cfg;
    using FluentNHibernate.Cfg.Db;
    using JustBlog.Core.Objects;
    using NHibernate;
    using NHibernate.Cache;
    using NHibernate.Tool.hbm2ddl;
    using Ninject;
    using Ninject.Modules;
    using Ninject.Web.Common;
    namespace JustBlog.Core
    {
        public class RepositoryModule: NinjectModule
        {
            public override void Load()
            {
                Bind()
                    .ToMethod
                    (
                        e =>
                            Fluently.Configure()
                            .Database(MsSqlConfiguration.MsSql2008.ConnectionString(c =>
                                c.FromConnectionStringWithKey("JustBlogDbConnString")))
                            .Cache(c => c.UseQueryCache().ProviderClass())
                            .Mappings(m => m.FluentMappings.AddFromAssemblyOf())
                            .ExposeConfiguration(cfg => new SchemaExport(cfg).Execute(true, true, false))
                            .BuildConfiguration()
                            .BuildSessionFactory()
                    )
                    .InSingletonScope();
                Bind()
                    .ToMethod((ctx) => ctx.Kernel.Get().OpenSession())
                    .InRequestScope();
            }
        }
    }
    

    Wie im Fluent NHibernate-Wiki allgemein zu lesen ist, werden für die Einrichtung von NHibernate mithilfe der Fluent NHibernate-API 5 Hauptmethoden verwendet, von denen 3 erforderlich sind:

    Fluently.Configure()
      .Database(/* your database settings */)
      .Mappings(/* your mappings */)
      .ExposeConfiguration(/* alter Configuration */) // optional
      .BuildSessionFactory();
    


    Fluently.Configure startet den Abstimmungsprozess
    der Datenbank , konfiguriert die Verbindungszeichenfolge der Datenbank
    Mappings Vergleich passt auf der Grundlage Ihrer Entitätsklassen
    ExposeConfiguration optional ist, aber können Sie das Datenbankschema Ihrer Vergleiche erstellen (um eine Tabelle unserer Klassen zu erstellen)
    BuildSessionFactory dieses letztere Verfahren, und es Erstellt eine Instanz von NHibernate SessionFactory basierend auf den Einstellungen der vorherigen Methoden.



    Die Cache-Methode ist optional und konfiguriert den Provider so, dass Anforderungen zwischengespeichert werden.

    In Ninject sind viele Erweiterungen verfügbar. Eine davon ist Ninject.Web.Common, die einige allgemeine Funktionen enthält, die für WebForms- und MVC-Anwendungen erforderlich sind. Wir müssen sicherstellen, dass Ninject während der Ausführung der Abfrage dieselbe Instanz von ISession zurückgibt. Die im Ninject.Web.Common-Namespace definierte InRequestScope () - Erweiterungsmethode teilt Ninject mit, dass für jede von ASP.NET empfangene HTTP-Anforderung nur eine Instanz der Klasse erstellt werden muss. Die InSingletonScope () - Erweiterungsmethode erstellt einen Singleton, der in der gesamten Anwendung verfügbar ist.

    4.6 Ninject Setup für MVC Project

    Alle Datenbankaufrufe von Controllern erfolgen über die IBlogRepository- Schnittstelle . Um eine Instanz einer Klasse zu implementieren, die IBlogRepository im Controller implementiert , müssen Sie Ninject in der MVC-Anwendung konfigurieren. Es gibt eine Erweiterung (Ninject.Mvc3), die speziell für die Unterstützung von MVC-Anwendungen erstellt wurde.

    Installieren Sie Ninject.Mvc3 in unserem JustBlog- Projekt, indem Sie den folgenden Befehl ausführen . Nach erfolgreicher Befehlsausführung werden die folgenden Assemblys zum MVC-Projekt hinzugefügt: Ninject Ninject.Web.Common Ninject.Web.Mvc Löschen Sie die Datei NinjectWebCommon.cs aus dem Ordner App_Start. Vererben Sie unsere globale Anwendungsklasse von der NinjectHttpApplication- Klasse und überschreiben Sie die Methode

    PM> Install-Package Ninject.Mvc3








    CreateKernel .
    Ändern Sie die Datei Global.asax.cs wie unten gezeigt.

    using Ninject;
    using Ninject.Web.Common;
    using System.Web.Mvc;
    using System.Web.Routing;
    namespace JustBlog
    {
        public class MvcApplication : NinjectHttpApplication
        {
            protected override IKernel CreateKernel()
            {
                var kernel = new StandardKernel();
                kernel.Load(new RepositoryModule());
    			kernel.Bind().To();
                return kernel;
            }
            protected override void OnApplicationStarted()
            {
                RouteConfig.RegisterRoutes(RouteTable.Routes);
                base.OnApplicationStarted();
            }
        }
    }
    


    In der CreateKernel- Methode erstellen wir eine StandardKernel- Instanz vom Typ IKernel und geben sie zurück . IKernel ist der Kern der Anwendung, in der wir unsere Bindungen angeben und wenn wir eine Instanz benötigen, die einer Schnittstelle zugeordnet ist, stellt sie uns diese zur Verfügung.

    Mit einer Instanz der StandardKernel- Klasse führen wir einige wichtige Dinge aus. Zuerst laden wir eine Instanz unseres Repository- Moduls , das alle mit den NHibernate- Schnittstellen verbundenen Bindungen enthält, und binden dann die IBlogRepository- Schnittstelle direkt an ihre BlogRepository- Implementierung . Am Ende des Beispiels wurde der Anwendungsstartcode schließlich in die OnApplicationStarted-Methode verschoben.

    Das ist alles über die Konfiguration von Ninject in der App. Im nächsten Teil werden wir mit der Arbeit an Controllern und Views beginnen.


Jetzt auch beliebt: