1. 프로젝트 구조 설정

먼저 ASP.NET Core MVC 프로젝트를 생성하고 필요한 패키지를 설치해요:

dotnet new mvc -n BlogApp
cd BlogApp
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools
dotnet add package Microsoft.EntityFrameworkCore.Design

2. 모델 클래스 정의

Models 폴더에 다음 클래스들을 추가해요:

// Models/Category.cs
public class Category
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Slug { get; set; }
    
    public virtual ICollection<Post> Posts { get; set; }
}

// Models/Post.cs
public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public string Slug { get; set; }
    public DateTime CreatedAt { get; set; } = DateTime.Now;
    public bool IsPublished { get; set; }
    public DateTime? PublishedAt { get; set; }
    
    public int CategoryId { get; set; }
    public virtual Category Category { get; set; }
    
    public virtual ICollection<Comment> Comments { get; set; }
    public virtual ICollection<Tag> Tags { get; set; }
}

// Models/Comment.cs
public class Comment
{
    public int Id { get; set; }
    public string Author { get; set; }
    public string Email { get; set; }
    public string Content { get; set; }
    public DateTime CreatedAt { get; set; } = DateTime.Now;
    public bool IsApproved { get; set; }
    
    public int PostId { get; set; }
    public virtual Post Post { get; set; }
}

// Models/Tag.cs
public class Tag
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Slug { get; set; }
    
    public virtual ICollection<Post> Posts { get; set; }
}

3. DbContext 클래스 생성

Data 폴더를 만들고 BlogDbContext 클래스를 추가해요:

// Data/BlogDbContext.cs
using Microsoft.EntityFrameworkCore;
using BlogApp.Models;

namespace BlogApp.Data
{
    public class BlogDbContext : DbContext
    {
        public BlogDbContext(DbContextOptions<BlogDbContext> options)
            : base(options)
        {
        }
        
        public DbSet<Category> Categories { get; set; }
        public DbSet<Post> Posts { get; set; }
        public DbSet<Comment> Comments { get; set; }
        public DbSet<Tag> Tags { get; set; }
        
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // 다대다 관계 설정 (Post와 Tag)
            modelBuilder.Entity<Post>()
                .HasMany(p => p.Tags)
                .WithMany(t => t.Posts)
                .UsingEntity(j => j.ToTable("PostTags"));
                
            // 카테고리 삭제 시 포스트도 삭제
            modelBuilder.Entity<Post>()
                .HasOne(p => p.Category)
                .WithMany(c => c.Posts)
                .HasForeignKey(p => p.CategoryId)
                .OnDelete(DeleteBehavior.Cascade);
                
            // 포스트 삭제 시 댓글도 삭제
            modelBuilder.Entity<Comment>()
                .HasOne(c => c.Post)
                .WithMany(p => p.Comments)
                .HasForeignKey(c => c.PostId)
                .OnDelete(DeleteBehavior.Cascade);
                
            // 시드 데이터 추가
            modelBuilder.Entity<Category>().HasData(
                new Category { Id = 1, Name = "기술", Slug = "technology" },
                new Category { Id = 2, Name = "생활", Slug = "lifestyle" }
            );
        }
    }
}

4. 서비스 등록 및 연결 문자열 설정

Program.cs 파일에 DbContext를 등록해요:

// Program.cs
using BlogApp.Data;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// DbContext 등록
builder.Services.AddDbContext<BlogDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("DefaultConnection")));

// 나머지 서비스 등록
builder.Services.AddControllersWithViews();

var app = builder.Build();
// 미들웨어 설정...
app.Run();

appsettings.json에 연결 문자열을 추가해요:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=BlogApp;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

5. 마이그레이션 생성 및 적용

dotnet ef migrations add InitialCreate
dotnet ef database update

6. 리포지토리 패턴 구현

데이터 액세스 로직을 캡슐화하기 위해 리포지토리 패턴을 적용해볼게요:

// Repositories/IPostRepository.cs
public interface IPostRepository
{
    Task<IEnumerable<Post>> GetAllPostsAsync();
    Task<Post> GetPostByIdAsync(int id);
    Task<Post> GetPostBySlugAsync(string slug);
    Task<IEnumerable<Post>> GetPostsByCategoryAsync(int categoryId);
    Task<IEnumerable<Post>> GetPostsByTagAsync(int tagId);
    Task AddPostAsync(Post post);
    Task UpdatePostAsync(Post post);
    Task DeletePostAsync(int id);
}

// Repositories/PostRepository.cs
public class PostRepository : IPostRepository
{
    private readonly BlogDbContext _context;
    
    public PostRepository(BlogDbContext context)
    {
        _context = context;
    }
    
    public async Task<IEnumerable<Post>> GetAllPostsAsync()
    {
        return await _context.Posts
            .Include(p => p.Category)
            .Include(p => p.Comments.Where(c => c.IsApproved))
            .Include(p => p.Tags)
            .OrderByDescending(p => p.CreatedAt)
            .ToListAsync();
    }
    
    public async Task<Post> GetPostByIdAsync(int id)
    {
        return await _context.Posts
            .Include(p => p.Category)
            .Include(p => p.Comments.Where(c => c.IsApproved))
            .Include(p => p.Tags)
            .FirstOrDefaultAsync(p => p.Id == id);
    }
    
    public async Task<Post> GetPostBySlugAsync(string slug)
    {
        return await _context.Posts
            .Include(p => p.Category)
            .Include(p => p.Comments.Where(c => c.IsApproved))
            .Include(p => p.Tags)
            .FirstOrDefaultAsync(p => p.Slug == slug);
    }
    
    public async Task<IEnumerable<Post>> GetPostsByCategoryAsync(int categoryId)
    {
        return await _context.Posts
            .Where(p => p.CategoryId == categoryId)
            .Include(p => p.Category)
            .Include(p => p.Comments.Where(c => c.IsApproved))
            .Include(p => p.Tags)
            .OrderByDescending(p => p.CreatedAt)
            .ToListAsync();
    }
    
    public async Task<IEnumerable<Post>> GetPostsByTagAsync(int tagId)
    {
        return await _context.Posts
            .Where(p => p.Tags.Any(t => t.Id == tagId))
            .Include(p => p.Category)
            .Include(p => p.Comments.Where(c => c.IsApproved))
            .Include(p => p.Tags)
            .OrderByDescending(p => p.CreatedAt)
            .ToListAsync();
    }
    
    public async Task AddPostAsync(Post post)
    {
        await _context.Posts.AddAsync(post);
        await _context.SaveChangesAsync();
    }
    
    public async Task UpdatePostAsync(Post post)
    {
        _context.Posts.Update(post);
        await _context.SaveChangesAsync();
    }
    
    public async Task DeletePostAsync(int id)
    {
        var post = await _context.Posts.FindAsync(id);
        if (post != null)
        {
            _context.Posts.Remove(post);
            await _context.SaveChangesAsync();
        }
    }
}

서비스 등록:

// Program.cs에 추가
builder.Services.AddScoped<IPostRepository, PostRepository>();

7. 컨트롤러 구현

// Controllers/PostsController.cs
public class PostsController : Controller
{
    private readonly IPostRepository _postRepository;
    
    public PostsController(IPostRepository postRepository)
    {
        _postRepository = postRepository;
    }
    
    // 모든 포스트 목록 표시
    public async Task<IActionResult> Index()
    {
        var posts = await _postRepository.GetAllPostsAsync();
        return View(posts);
    }
    
    // 특정 포스트 상세 보기
    public async Task<IActionResult> Details(string slug)
    {
        if (string.IsNullOrEmpty(slug))
        {
            return NotFound();
        }
        
        var post = await _postRepository.GetPostBySlugAsync(slug);
        if (post == null)
        {
            return NotFound();
        }
        
        return View(post);
    }
    
    // 카테고리별 포스트 목록
    public async Task<IActionResult> Category(int id)
    {
        var posts = await _postRepository.GetPostsByCategoryAsync(id);
        return View("Index", posts);
    }
    
    // 태그별 포스트 목록
    public async Task<IActionResult> Tag(int id)
    {
        var posts = await _postRepository.GetPostsByTagAsync(id);
        return View("Index", posts);
    }
    
    // 새 포스트 생성 폼
    [HttpGet]
    public IActionResult Create()
    {
        return View();
    }
    
    // 포스트 생성 처리
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Create(Post post)
    {
        if (ModelState.IsValid)
        {
            post.CreatedAt = DateTime.Now;
            post.Slug = GenerateSlug(post.Title);
            
            await _postRepository.AddPostAsync(post);
            return RedirectToAction(nameof(Index));
        }
        return View(post);
    }
    
    // 슬러그 생성 헬퍼 메서드
    private string GenerateSlug(string title)
    {
        // 간단한 슬러그 생성 로직
        return title.ToLower()
            .Replace(" ", "-")
            .Replace(".", "")
            .Replace(",", "")
            .Replace("!", "")
            .Replace("?", "");
    }
}

8. 뷰 구현

포스트 목록 뷰 예시:

@model IEnumerable<BlogApp.Models.Post>

@{
    ViewData["Title"] = "블로그 포스트";
}

<h1>블로그 포스트</h1>

<p>
    <a asp-action="Create" class="btn btn-primary">새 포스트 작성</a>
</p>

<div class="row">
    @foreach (var post in Model)
    {
        <div class="col-md-6 mb-4">
            <div class="card">
                <div class="card-body">
                    <h5 class="card-title">@post.Title</h5>
                    <h6 class="card-subtitle mb-2 text-muted">
                        카테고리: <a asp-action="Category" asp-route-id="@post.CategoryId">@post.Category.Name</a>
                    </h6>
                    <p class="card-text">
                        @(post.Content.Length > 200 
                            ? post.Content.Substring(0, 200) + "..." 
                            : post.Content)
                    </p>
                    <div class="d-flex justify-content-between">
                        <a asp-action="Details" asp-route-slug="@post.Slug" class="card-link">자세히 보기</a>
                        <small class="text-muted">@post.CreatedAt.ToString("yyyy-MM-dd")</small>
                    </div>
                    <div class="mt-2">
                        @foreach (var tag in post.Tags)
                        {
                            <a asp-action="Tag" asp-route-id="@tag.Id" class="badge bg-secondary me-1">@tag.Name</a>
                        }
                    </div>
                </div>
                <div class="card-footer text-muted">
                    댓글 @post.Comments.Count개
                </div>
            </div>
        </div>
    }
</div>