How to write a simple blog using Asp .Net MVC, Nhibernate, and Ninject. Part 1

Introduction

• In the first part, we will create the basic blog infrastructure. Let's create the necessary classes of models, data access components.
• In the second part, we implement controllers, action methods, and representations. At the end of the second part, we will have a working blog where we can see the latest posts, read the full text of the post, select posts by category or tag, and even search for interesting posts (posts).
• In the third part, we will create an admin console to manage posts, categories, and tags.
• In the fourth part, we will introduce the Disqus comment system in our blog. We will also introduce two new services: the AddThis exchange service and the Feedburner subscription service .

Technology

• ASP.NET MVC 4.0
• Fluent NHibernate and NHibernate
• SQL Server 2012
• Ninject
• jQuery

Creation of basic infrastructure.

Task 1. Display the latest blog post.

1. Create a basic solution
2. Create Domain Classes
3. Configure Fluent NHibernate and NHibernate
4. Create mapping classes, data access classes, and methods
5. Configure Ninject for JustBlog.Core
6. Configure Ninject for MVC Project
7. Create controller and actions
8. Create view

4.1 Creating a basic solution

4.2 Creating Domain Classes

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

Slug is a newspaper term. “Slug” is a short tag name that contains only letters, numbers, underscores or hyphens. Mostly used in URLs.

URL Slug
URL Slug is an SEO - and user-friendly part of the URL string for identifying, describing, and accessing a resource. Often an article’s page title is a suitable candidate for this.

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 Configuring Fluent NHibernate and NHibernate

4.4 Creating mapping classes, data access classes, and methods

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

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

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

Table("tbl_posts");

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

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

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

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

NHibernate ISession

ISession is a persistence manager interface that is used to store and retrieve objects from a database.

Persistent means that this instance should be implemented in such a way that it is preserved after the completion of the process that generated it. Unlike transient, which means that this instance of the object is temporary - it ceases to exist after the completion of the process that generated it. (comment translator).

4.5 Ninject settings for JustBlog.Core project

Ninject Module

The Ninject module is used to group matches / bindings related to a specific module in one class.

Bind().To();

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

NHibernate ISessionFactory

Unlike ISession, we need one instance of ISessionFactory throughout the application.

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

As the Fluent NHibernate Wiki tells us in general, setting up NHibernate using the Fluent NHibernate API is done using 5 main methods, 3 of which are required:

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

Fluently.Configure начинает процесс настройки
Database, настраивает строку подключения к базе данных
Mappings настраивает сопоставления на основе ваших классов сущностей
ExposeConfiguration не является обязательным, но позволяет создать схему базы данных из ваших сопоставлений (создаем таблицы из наших классов)
BuildSessionFactory это последний метод, и он создает экземпляр NHibernate SessionFactory на основе настроек предыдущих методов.

4.6 Ninject Setup for MVC Project

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