Create a New ASP.NET Core MVC Project

ASP.NET Core MVC is a lightweight, open-source framework for building modern, high-performance web applications. It is part of the ASP.NET Core ecosystem and follows the Model-View-Controller (MVC) design pattern, which separates application logic, UI, and data.

---

Key Concepts of ASP.NET Core MVC

1. Model Represents the application's data and business logic. It handles data retrieval, storage, and processing. Example: Database entities like User, Order, or Product.

2. View Handles the presentation layer by defining the structure and layout of the UI. Example: Razor templates used to display data to users.

3. Controller Acts as a mediator between the Model and the View. It handles user input, processes requests, and returns responses. Example: HomeController processes a user request to fetch and display data.

---

1. Separation of Concerns

• MVC organizes the codebase into distinct layers (Model, View, Controller), making applications easier to develop, maintain, and scale.

• Promotes reusability and testability.

2. Cross-Platform

• ASP.NET Core MVC runs on Windows, macOS, and Linux, allowing developers to deploy applications on diverse platforms.

3. Razor View Engine

• Combines C# and HTML in a seamless way for dynamic web page rendering.

• Simplifies creating reusable UI components.

4. Performance

• Built on the high-performance ASP.NET Core runtime, making it suitable for modern, scalable web applications.

5. Modern Development Practices

• Supports features like Dependency Injection (DI), Asynchronous Programming, and Tag Helpers, promoting cleaner and efficient code.

6. Integrated with .NET Ecosystem

• Works seamlessly with Entity Framework Core, SignalR, and other .NET libraries to build robust, full-stack applications.

7. Built-In Security Features

• Provides built-in support for authentication, authorization, and protection against CSRF and XSS attacks.

8. Open Source and Community Driven

• Backed by Microsoft and a vibrant community, ensuring frequent updates, bug fixes, and a wealth of learning resources.

---

• Dynamic Web Applications: For applications that require a blend of server-side and client-side rendering.

• Enterprise Applications: When building scalable and secure applications for businesses.

• Full-Stack Applications: For developers looking to use a single framework for backend and frontend.

• Custom Web Solutions: When you need fine-grained control over the application’s behavior, routing, and views.

---

Step-by-Step Guide

1. Prerequisites

• Install the .NET SDK.

• Use Visual Studio or Visual Studio Code.

---

2. Create a New ASP.NET Core MVC Project

Run the following command to create a new MVC project:

dotnet new mvc -n BlogMvc
cd BlogMvc

---

3. Add Dependencies for Ulid

Install the NUlid package for Ulid support:

dotnet add package NUlid

---

4. Define the Blog Post Model

Create a Models folder and add the BlogPost and Comment classes.

using NUlid;

namespace BlogMvc.Models
{
    public class BlogPost
    {
        public Ulid Id { get; set; } = Ulid.NewUlid(); // Auto-generate Ulid
        public string Author { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public List<string> Tags { get; set; } = new List<string>();
        public DateTime PublishedDate { get; set; } = DateTime.UtcNow;
        public List<Comment> Comments { get; set; } = new List<Comment>();
    }

    public class Comment
    {
        public string Author { get; set; }
        public string Content { get; set; }
        public DateTime PostedDate { get; set; } = DateTime.UtcNow;
    }
}

---

5. Create an In-Memory Repository

Create a Repositories folder and add a BlogPostRepository to manage blog posts.

using BlogMvc.Models;

namespace BlogMvc.Repositories
{
    public class BlogPostRepository
    {
        private static List<BlogPost> blogPosts = new();

        public IEnumerable<BlogPost> GetAll() => blogPosts;

        public BlogPost? GetById(Ulid id) => blogPosts.FirstOrDefault(p => p.Id == id);

        public void Add(BlogPost post) => blogPosts.Add(post);

        public void Update(BlogPost updatedPost)
        {
            var post = GetById(updatedPost.Id);
            if (post == null) return;

            post.Author = updatedPost.Author;
            post.Title = updatedPost.Title;
            post.Content = updatedPost.Content;
            post.Tags = updatedPost.Tags;
            post.PublishedDate = updatedPost.PublishedDate;
            post.Comments = updatedPost.Comments;
        }

        public void Delete(Ulid id) => blogPosts.RemoveAll(p => p.Id == id);
    }
}

---

6. Create the Blog Controller

In the Controllers folder, add a new controller called BlogController.

using BlogMvc.Models;
using BlogMvc.Repositories;
using Microsoft.AspNetCore.Mvc;

namespace BlogMvc.Controllers
{
    public class BlogController : Controller
    {
        private readonly BlogPostRepository _repository = new();

        public IActionResult Index()
        {
            var posts = _repository.GetAll();
            return View(posts);
        }

        public IActionResult Details(string id)
        {
            var post = _repository.GetById(Ulid.Parse(id));
            if (post == null) return NotFound();

            return View(post);
        }

        public IActionResult Create() => View();

        [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult Create(BlogPost blogPost)
        {
            if (!ModelState.IsValid) return View(blogPost);

            blogPost.Id = Ulid.NewUlid();
            _repository.Add(blogPost);
            return RedirectToAction(nameof(Index));
        }

        public IActionResult Edit(string id)
        {
            var post = _repository.GetById(Ulid.Parse(id));
            if (post == null) return NotFound();

            return View(post);
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult Edit(string id, BlogPost updatedPost)
        {
            if (!ModelState.IsValid) return View(updatedPost);

            updatedPost.Id = Ulid.Parse(id);
            _repository.Update(updatedPost);
            return RedirectToAction(nameof(Index));
        }

        public IActionResult Delete(string id)
        {
            var post = _repository.GetById(Ulid.Parse(id));
            if (post == null) return NotFound();

            return View(post);
        }

        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public IActionResult DeleteConfirmed(string id)
        {
            _repository.Delete(Ulid.Parse(id));
            return RedirectToAction(nameof(Index));
        }
    }
}

---

7. Create Views

In the Views folder, create a Blog folder. Add the following views:

1. Index.cshtml Displays all blog posts.

   @model IEnumerable<BlogMvc.Models.BlogPost>
   
   <h1>Blog Posts</h1>
   <a asp-action="Create">Create New</a>
   <ul>
       @foreach (var post in Model)
       {
           <li>
               <a asp-action="Details" asp-route-id="@post.Id.ToString()">@post.Title</a> by @post.Author
           </li>
       }
   </ul>

2. Details.cshtml Displays a single blog post.

   @model BlogMvc.Models.BlogPost
   
   <h1>@Model.Title</h1>
   <p>@Model.Content</p>
   <p><strong>Author:</strong> @Model.Author</p>
   <p><strong>Tags:</strong> @string.Join(", ", Model.Tags)</p>
   <a asp-action="Edit" asp-route-id="@Model.Id.ToString()">Edit</a> |
   <a asp-action="Delete" asp-route-id="@Model.Id.ToString()">Delete</a>

3. Create.cshtml Form for creating a blog post.

   @model BlogMvc.Models.BlogPost
   
   <h1>Create Blog Post</h1>
   <form asp-action="Create">
       <div>
           <label>Author</label>
           <input asp-for="Author" />
       </div>
       <div>
           <label>Title</label>
           <input asp-for="Title" />
       </div>
       <div>
           <label>Content</label>
           <textarea asp-for="Content"></textarea>
       </div>
       <button type="submit">Save</button>
   </form>

4. Edit.cshtml Form for editing a blog post (similar to Create.cshtml).

5. Delete.cshtml Confirmation for deleting a blog post.

   @model BlogMvc.Models.BlogPost
   
   <h1>Delete Blog Post</h1>
   <p>Are you sure you want to delete "@Model.Title"?</p>
   <form asp-action="DeleteConfirmed" asp-route-id="@Model.Id.ToString()">
       <button type="submit">Yes</button>
       <a asp-action="Index">No</a>
   </form>