ASP.NET Core 8.0 시작하기
안녕하세요 여러분, Microsoft MVP이자 'C# 교과서' 및 'ASP.NET & Core를 다루는 기술'의 저자인 박용준입니다. 오늘 이 아티클을 통해 .NET 8의 ASP.NET Core 8.0을 소개할 예정입니다.
이 강좌의 목표는 ASP.NET Core 8.0의 기본 개념과 사용 방법을 소개하고 학습하는 것입니다. 우리는 마이크로소프트가 제공하는 다양한 ASP.NET Core 8.0 관련 Visual Studio 템플릿을 세세하게 분석하고 탐구할 예정입니다. 이 과정을 통해, 학습자는 ASP.NET Core 8.0의 주요 개념을 깊이 이해하게 될 것입니다.
본 강좌에서는 ASP.NET Core MVC, Web API, Razor Pages, Blazor, Minimal APIs, Identity 등 ASP.NET Core의 다양한 영역에 대해 맛보기 형태로 다룰 예정입니다. 이 기본적인 이해를 바탕으로, 이후 세부 강좌들에서 더 심도 있는 학습이 진행될 것입니다.
특히, 이 강좌에서는 ASP.NET Core 관련 프로젝트 템플릿의 기능과 구조를 깊이 있게 이해함으로써, 마이크로소프트 개발자들이 전달하고자 하는 ASP.NET Core의 효율적인 학습 경로를 파악하게 됩니다. 이러한 지식을 바탕으로, 학습자들은 ASP.NET Core 8.0의 전문가가 될 수 있는 기반을 마련할 수 있습니다.
> // .NET 8.0에서 ASP.NET Core 및 Blazor 템플릿을 마스터하기
NOTE
이 강좌는 ASP.NET Core 프로젝트에서 MVC(Razor Views), Web API, Razor Pages, Blazor(Razor Components), Minimal APIs, Identity 등을 통합하여 사용하는 방법에 초점을 맞춥니다. 단, SignalR과 gRPC 기술은 이 문서에서는 다루지 않습니다.
ASP.NET Core 8.0 소개
ASP.NET Core 8.0은 마이크로소프트가 개발한 오픈 소스 및 크로스 플랫폼 프레임워크로, 현대적인 인터넷 기반 애플리케이션을 구축하기 위한 강력한 도구입니다. 이 버전에서는 성능 향상, 더 나은 개발자 경험, 그리고 강화된 보안 기능을 제공하며, 클라우드 기반 환경에서의 운영에 최적화되어 있습니다. 신규 기능과 개선사항들은 개발의 생산성을 높이고, 애플리케이션을 더 안정적이며 관리하기 쉽게 만들어 줍니다.
2016년 6월에 ASP.NET Core 1.0 버전이 나온 이후로 벌써 ASP.NET Core 8.0이 되었네요. .NET 릴리스 주기는 다음 그림과 링크를 참고하세요.
그림: .NET 릴리스 주기
출처: https://dotnet.microsoft.com/ko-kr/platform/support/policy/dotnet-core
Unified web framework
ASP.NET Core는 .NET을 위한 현대적인 웹 프레임워크입니다. 아름다운 웹 UI와 강력한 백엔드 API 및 서비스를 구축할 수 있는 모든 것이 포함되어 있습니다. 다른 개발 플랫폼과 달리 여러 프레임워크를 조합해 웹 앱을 구축할 필요가 없으며, ASP.NET Core는 완전하고 일관된 웹 개발 솔루션을 제공합니다.
웹 UI의 경우, MVC와 Razor 페이지를 사용하여 동적인 서버 렌더링 UI를 구축할 수 있고, 인기 있는 자바스크립트 프레임워크와 통합하거나 Blazor를 사용하여 C#만으로 풍부한 인터랙티브 웹 UI를 구축할 수 있습니다.
서비스에 대해서는, 표준 기반 HTTP API, SignalR을 사용한 실시간 서비스, gRPC를 사용한 고성능 백엔드 서비스를 구축할 수 있습니다. ASP.NET Core에는 라우팅, 보안, 지역화, 캐싱, 압축 등과 같은 모든 크로스 커팅 관심사를 처리하는 데 필요한 풍부한 미들웨어가 포함되어 있습니다.
ASP.NET Core는 로깅, 구성, 종속성 주입 등과 같은 관심사를 처리하기 위한 클라우드 준비 .NET 플랫폼 확장과도 통합됩니다.
그런 다음 Kestrel과 같은 다양한 HTTP 서버를 사용하여 ASP.NET Core 앱을 호스팅할 수 있습니다. Kestrel은 내장된 초고속 및 크로스 플랫폼 웹 서버입니다.
어떤 종류의 웹 앱을 구축하려고 하든, ASP.NET Core는 필요한 모든 것을 갖추고 있어 앱에 집중하고 생산적으로 유지할 수 있습니다.
Industry leading performance
ASP.NET Core는 업계 최고의 성능을 제공합니다.
공개적인 TechEmpower 벤치마크에서 ASP.NET Core는 하드웨어를 최대한 활용하여 놀라운 초당 700만 요청을 처리하며, 이는 Node.js보다 11배 빠릅니다.
ASP.NET Core로 구축된 gRPC 서비스는 자바, 고(Go), C++, 러스트(Rust)보다 높은 처리량을 다룹니다.
.NET at Microsoft
ASP.NET Core는 벤치마크에서뿐만 아니라 실제 세계에서도 뛰어난 성능을 제공합니다. 세계에서 가장 큰 서비스 중 일부에 실제 세계 성능을 제공합니다.
마이크로소프트에서는 많은 제품과 서비스에 .NET을 광범위하게 사용합니다. 이러한 서비스들이 최신 .NET 버전과 ASP.NET Core를 사용하도록 업그레이드함에 따라 엄청난 성능 향상과 효율성 개선을 실현했습니다.
- Microsoft Graph는 Microsoft 365 생태계에서 데이터와 인텔리전스에 대한 통합 액세스를 제공합니다. 그들은 하루에 700억 개 이상의 요청을 처리합니다. .NET Fx에서 .NET 6로 업그레이드하면서 서비스당 CPU 사용량이 37% 감소했으며, 10억 개의 요청을 처리할 때마다 운영 비용을 91% 줄였습니다.
- Azure Active Directory의 게이트웨이 서비스는 하루에 1850억 개 이상의 요청을 처리합니다. .NET 6로 업그레이드하여 전체 CPU 사용량을 67% 줄이고 앱 효율성(처리량 대비 CPU 사용 비율)을 50% 향상시켰습니다.
- Microsoft Teams는 700개 이상의 API를 포함하는 50개 이상의 프로젝트를 .NET 6로 이전하여 CPU 사용량을 25% 줄이고 P99 지연 시간을 60% 감소시켰습니다.
- Azure Cosmos DB는 .NET 6로 업데이트하여 처리량을 500% 증가시켰습니다.
- Exchange Online은 P99 지연 시간을 80% 감소시켰습니다.
- Azure App Service는 하루에 1600억 개 이상의 요청을 처리하는 프론트엔드 역할의 처리량을 80% 증가시켰습니다. 그들은 리눅스 VM에서 nginx를 ASP.NET Core로 대체하여 gRPC 및 HTTP/2에 대한 지원을 가능하게 했습니다.
.NET 및 ASP.NET Core로 구축함으로써 효율적이고 확장 가능한 기반 위에 있다는 것을 안심할 수 있습니다.
.NET 7.0
.NET 플랫폼의 최신 버전인 .NET 7이 발표되었습니다. 이는 웹 개발자를 위한 ASP.NET Core의 개선 사항으로 가득 차 있습니다.
.NET 7에서 ASP.NET Core는 속도에 중점을 두고 구축되었습니다. .NET 6이 이미 빠른 속도를 제공했다면, .NET 7은 그보다 더 빠른 성능을 자랑합니다!
.NET 7에 최신 현대적인 프로토콜, 아키텍처, 표준에 대한 지원을 추가하여, 최고의 웹 경험을 제공합니다.
또한, .NET 7에서는 웹 개발을 간소화하여 모든 기능을 최대한 활용하면서도 빠르게 시작할 수 있도록 했습니다.
생산성 향상을 위해 출력 캐싱, 속도 제한, 요청 압축 해제 등과 같은 더 많은 미들웨어를 추가했습니다. SignalR 클라이언트 결과 및 Blazor 사용자 정의 요소와 같은 새로운 기능들은 개발자로서 여러분이 새로운 시나리오를 탐색하고 활용할 수 있게 도와줍니다.
Next level performance
.NET 6에서 ASP.NET Core가 제공했던 빠른 성능에도 불구하고, .NET 7에서는 더 빨라져 차세대 성능을 제공합니다.
.NET 플랫폼 전반에 걸친 성능 최적화 덕분에, .NET 7의 ASP.NET Core는 주요 TechEmpower 벤치마크에서 훨씬 더 빨라졌습니다: Plaintext에서 8% 더 빠르며, JSON 처리는 16% 빨라졌고, e2e Fortunes 테스트에서는 25% 더 빨라졌습니다.
.NET 7에서 ASP.NET Core의 HTTP/2 지원은 이제 매우 최적화되었습니다. .NET 7의 ASP.NET Core를 사용한 HTTP/2를 통한 gRPC 서버 스트리밍은 이제 Go보다 8배 더 빠릅니다.
More Cores, more Speed
.NET 7에서는 ASP.NET Core를 최적화하여 많은 코어를 가진 머신의 처리 능력을 최대한 활용할 수 있도록 했습니다. Azure의 대규모 80 코어 ARM64 Ampere Altra VM에서 실행할 때 .NET 6보다 ASP.NET Core의 속도가 다섯 배 빨라졌습니다.
이러한 모든 성능 향상은 운영 비용을 낮추고 사용자 경험을 개선하는 데 기여합니다.
Minimal APIs
ASP.NET Core를 사용하면 크고 작은 앱을 구축할 수 있습니다.
.NET 6에서 ASP.NET Core 시작을 간소화하고 인기 있는 MVC 기능을 스택 아래로 밀어내는 작업을 시작했습니다. 이 노력은 간소화된 호스팅 모델과 최소한의 API로 이어졌습니다.
최소한의 API는 웹 API 개발을 간소화하고, 다양한 MVC 기능을 더 널리 사용할 수 있게 하며, 성능을 향상시킵니다.
.NET 7에서 최소 API를 더욱 개선하여 API가 단순하면서도 강력할 수 있도록 했습니다.
- 공통 URL 접두사 아래에서 최소 API를 구성하고 함께 구성할 수 있도록 엔드포인트 그룹에 대한 지원을 추가했습니다.
- 이제 API와 그룹에 엔드포인트 필터를 추가하여 유효성 검사 및 로깅과 같은 크로스 커팅 기능을 추가할 수 있습니다.
- 최소 API를 더 명확하게 만들어 테스트가 쉬워지고 OpenAPI 생성 지원이 향상되었습니다.
- 또한 API의 인증 구성을 단순화하여 보안 엔드포인트를 더 쉽게 구축하고 테스트할 수 있도록 했습니다.
Blazor
.NET 7은 ASP.NET Core 및 Blazor를 사용하여 웹 UI를 구축하는 데 많은 개선 사항을 포함하고 있습니다. Blazor를 사용하면 재사용 가능한 컴포넌트를 사용하여 웹 UI를 C#으로 완전히 구축할 수 있습니다.
이러한 컴포넌트는 웹, 모바일, 데스크톱에서 공유될 수 있습니다. 컴포넌트를 서버에서 실행하거나, 브라우저의 WebAssembly에서, 혹은 하이브리드 네이티브 클라이언트 앱에서 실행할 수 있습니다.
이미 상당한 자바스크립트 투자가 있는 경우, .NET 7의 새로운 Blazor 사용자 정의 요소 지원을 사용하여 기존 자바스크립트 앱에 Blazor 컴포넌트를 통합할 수도 있습니다.
기본 웹 애플리케이션 구축 가이드
이 아티클에서 제공되는 ASP.NET Core 8.0을 사용하여 기본 웹 애플리케이션을 만드는 과정은 다음과 같습니다:
- 프로젝트 설정: 새 프로젝트를 시작하고, 필요한 설정을 구성합니다.
- 라우팅 및 미들웨어: 웹 요청을 처리하기 위한 라우팅을 설정하고, 필요한 미들웨어를 구성합니다.
- HTML 콘텐츠 렌더링: 클라이언트에게 HTML 콘텐츠를 제공하기 위한 응답을 구성합니다.
- 정적 파일 제공: 이미지, CSS, JavaScript 파일과 같은 정적 콘텐츠를 호스팅합니다.
- MVC 패턴 적용: Model-View-Controller 아키텍처를 사용하여 애플리케이션을 구조화합니다.
- Web API 구축: RESTful API를 만들어 다양한 클라이언트 애플리케이션과 통신합니다.
- Razor 페이지: Razor 페이지를 사용하여 서버 사이드 코드와 HTML을 혼합하여 페이지를 생성합니다.
- Blazor Server 애플리케이션: C#과 .NET을 사용하여 인터랙티브한 웹 UI를 만듭니다.
- Minimal API 사용: 더 간결한 코드로 API를 구성하여 개발을 간소화합니다.
각 단계별로 자세한 내용과 실습 예제를 통해 ASP.NET Core 8.0의 다양한 기능을 체험하고, 웹 애플리케이션 개발에 필요한 핵심 개념을 이해하게 됩니다. 이 강좌는 ASP.NET Core의 기초부터 고급 기능까지 폭넓게 다루며, 실제 프로젝트에 적용할 수 있는 실용적인 지식을 제공합니다.
ASP.NET Core 마인드맵 가이드
이 강좌는 회원 전용 강좌입니다. 최종 완성된 강의는 데브렉에서 서비스됩니다.
ASP.NET Core 8.0 개발 환경 구축
최신 버전의 Visual Studio 2022에 'ASP.NET 및 웹 개발' 워크로드를 설치하면 ASP.NET Core 8.0 개발 환경 구축이 완료가 됩니다.
만약, 자세한 내용을 알고자하면 다음 영상들을 참고하세요.
기본 웹 애플리케이션 만들기
웹 애플리케이션을 처음부터 만드는 것은 복잡해 보일 수 있지만, ASP.NET Core는 이 과정을 매우 단순화합니다. 본 글에서는 "Hello World!"를 웹 브라우저에 표시하는 매우 간단한 웹 애플리케이션을 만드는 두 단계를 거쳐 설명합니다.
1단계: 프로젝트 설정 - 세부화 및 개선
이 단계에서는 ASP.NET Core를 사용해 빈 웹 프로젝트를 구성하는 방법을 살펴보겠습니다. 목표는 간단한 웹 서버를 설정하여 루트 URL에 접근했을 때 메시지를 표시하는 것입니다.
기본 구조 설정
Program.cs 파일은 애플리케이션의 진입점으로, 여기서 애플리케이션 빌더를 생성하고 구성합니다. 기본 코드는 다음과 같습니다:
namespace VisualAcademy
{
public class Program
{
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello World!");
app.Run();
}
}
}
이 코드는 WebApplication.CreateBuilder 메서드를 사용해 애플리케이션 빌더를 초기화하고, 이를 통해 웹 애플리케이션 인스턴스를 생성합니다. 그 후, 루트 URL ("/")에 "Hello World!" 메시지를 매핑하고 애플리케이션을 실행합니다.
app.MapGet() 메서드는 주로 두 개의 매개변수를 받습니다:
- 경로 (Path): 클라이언트가 접근할 때 사용하는 URL 경로입니다. 예를 들어, 사용자가 'api/values' 경로로 요청을 보내면, 이 경로와 일치하는
MapGet()메서드가 처리합니다. - 처리 함수 (Handler function): 요청이 들어왔을 때 실행되는 함수입니다. 이 함수는 요청을 처리하고, 결과를 반환합니다.
Top Level Statement 사용
최신 C# 버전(9.0 버전 이상)에서는 더 간결한 Top Level Statement를 사용할 수 있습니다. 이를 통해 프로그램의 진입점을 더 간단하게 정의할 수 있습니다:
-namespace VisualAcademy
-{
- public class Program
- {
- public static void Main(string[] args)
- {
+ var builder = WebApplication.CreateBuilder(args);
+ var app = builder.Build();
+
+ app.MapGet("/", () => "Hello World!");
+
+ app.Run();
- }
- }
-}
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello World!");
app.Run();
이 코드는 네임스페이스와 클래스 선언을 생략하고 직접 애플리케이션 로직으로 들어갑니다. 이 방식은 코드를 더 간결하게 만들어 주며, 작은 프로젝트나 학습 목적의 프로젝트에 적합합니다.
HTML 콘텐츠 반환
때로는 웹 페이지에서 HTML 콘텐츠를 반환하고 싶을 수 있습니다. 이를 위해 반환되는 문자열에 HTML 태그를 포함시킬 수 있습니다:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "<h1>Hello World!</h1>");
app.Run();
이 경우, 사용자가 루트 URL로 접속하면 <h1> 태그로 감싸진 "Hello World!" 메시지를 볼 수 있습니다.
2단계: HTML 콘텐츠 렌더링
첫 시도에서 웹 브라우저가 HTML 태그를 텍스트로만 처리했기 때문에, 응답의 Content-Type을 text/html로 설정해주어야 했습니다. 이를 위해 Results.Content 메서드를 사용했습니다.
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => Results.Content("<h1>Hello World!</h1>", "text/html"));
app.Run();
이 변경으로 웹 서버는 이제 Content-Type이 text/html인 응답을 보내고, 웹 브라우저는 <h1>Hello World!</h1>를 HTML로 올바르게 해석하고 렌더링합니다.
C# 11.0 원시 문자열 리터럴 사용
C# 11에서 도입된 원시 문자열 리터럴(Raw string literals) 기능은 특히 HTML, JSON, XML 등 여러 줄에 걸쳐 있는 문자열을 다룰 때 매우 유용합니다. 이 기능을 사용하면 문자열 내에서 이스케이프 시퀀스를 사용하지 않고도 문자열을 그대로 표현할 수 있습니다. 아래 예시에서는 C# 11의 원시 문자열 리터럴을 사용하여 HTML 태그를 나타내고 있습니다.
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => Results.Content("<h1>Hello World!</h1>", "text/html"));
app.Run();
기존 코드에서는 단일 문자열 내에서 HTML을 표현하기 위해 이스케이프 시퀀스를 사용해야 했습니다. 하지만 C# 11에서는 원시 문자열 리터럴을 사용하여 이러한 복잡성을 줄일 수 있습니다.
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
// C# 11.0 버전의 원시 문자열 리터럴(Raw string literals)
string htmlTag = """
<html lang="ko">
<body>
<h1>Hello ASP.NET Core 8.0</h1>
</body>
</html>
""";
app.MapGet("/", () => Results.Content(htmlTag, "text/html"));
app.Run();
이 코드에서 htmlTag 변수는 원시 문자열 리터럴을 사용하여 다중 라인 HTML 문자열을 깔끔하게 표현합니다. 이 방법은 코드의 가독성을 향상시키고 문자열 리터럴 내에서의 복잡한 이스케이프 시퀀스 사용을 피할 수 있게 해줍니다. 이는 특히 웹 애플리케이션 개발에서 HTML, CSS, JavaScript 코드를 다룰 때 유용하게 사용될 수 있습니다.
app.MapGet() 메서드 라우팅 변경
ASP.NET Core의 app.MapGet() 메서드는 HTTP GET 요청에 대한 라우팅을 설정하는 데 사용됩니다. 이 메서드를 사용하여 특정 경로에 대한 요청을 처리할 액션을 정의할 수 있습니다. 라우팅을 변경하려면 app.MapGet() 메서드 내의 URL 경로와 처리 로직을 수정합니다.
기본 사용법
기본적으로 app.MapGet()은 두 개의 매개변수를 받습니다: 요청을 받을 경로와 해당 경로에 대한 요청을 처리할 함수입니다.
app.MapGet("/path", () => "Response");
경로 매개변수 사용
동적인 라우팅을 위해 경로 매개변수를 사용할 수 있습니다. 경로 매개변수는 중괄호 {} 안에 정의됩니다. 제가 평상시 강의할 때에는 라우트 파라미터(토큰)로 발음합니다.
app.MapGet("/items/{id}", (int id) => $"Item ID: {id}");
복잡한 라우팅
보다 복잡한 라우팅 로직을 처리하기 위해 람다 표현식이나 메서드를 사용할 수 있습니다.
app.MapGet("/users/{userId}/orders/{orderId}", (int userId, int orderId) => ProcessOrder(userId, orderId));
라우팅 변경
기존 라우팅을 변경하려면, MapGet() 메서드의 경로와 로직을 수정해야 합니다. 예를 들어, 경로를 /new-path로 변경하고, 새로운 응답 로직을 적용할 수 있습니다.
app.MapGet("/new-path", () => "New Response");
app.MapGet() 메서드를 활용하면 RESTful API를 구현하거나, 웹 애플리케이션에서 특정 HTTP GET 요청을 효과적으로 처리할 수 있습니다. 라우팅 변경을 통해 애플리케이션의 구조와 응답 방식을 유연하게 조정할 수 있습니다.
정적 파일(Static Files) 제공하기
ASP.NET Core 애플리케이션에서 정적 파일을 제공하는 것은 웹 개발의 가장 기본적인 부분입니다. 이들은 HTML, CSS, JavaScript, 이미지 등 변경되지 않는 파일들을 의미합니다. app.UseStaticFiles(); 코드는 이러한 정적 파일들을 웹에서 접근 가능하게 만듭니다. 기본적으로, ASP.NET Core는 wwwroot 폴더를 정적 파일의 기본 저장소로 사용합니다.
app.UseStaticFiles();
이 코드를 app.Build(); 이후에 추가하면 wwwroot 폴더에 있는 파일들을 웹에서 접근 가능하게 만듭니다.
코드: Program.cs
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
// C# 11.0 버전의 원시 문자열 리터럴(Raw string literals)
string htmlTag = """
<html lang="ko">
<body>
<h1>Hello ASP.NET Core 8.0</h1>
</body>
</html>
""";
app.MapGet("/html-content-rendering", () => Results.Content(htmlTag, "text/html"));
app.UseStaticFiles();
app.Run();
wwwroot 폴더에 순수한 HTML 문서 만들고 실행하기
ASP.NET Core 프로젝트에서 wwwroot 폴더는 기본적으로 정적 파일을 저장하고 제공하는 데 사용됩니다. 이 폴더에 HTML 파일을 추가하여 웹 브라우저에서 어떻게 정적 파일을 제공하는지 보여줄 수 있습니다. 다음 단계를 따라 간단한 HTML 파일을 만들고 실행해 보세요.
1. HTML 파일 생성
- 프로젝트의
wwwroot폴더를 엽니다. 이 폴더가 없다면 프로젝트 루트에wwwroot라는 이름의 새 폴더를 만듭니다. wwwroot폴더 내에index.html이라는 이름의 새 HTML 파일을 생성합니다.index.html파일을 열고 기본 HTML 구조를 작성합니다. 예를 들어, 아래와 같은 간단한 HTML 코드를 사용할 수 있습니다:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Welcome to ASP.NET Core</title>
</head>
<body>
<h1>Hello, world!</h1>
<p>Welcome to ASP.NET Core Static Files.</p>
</body>
</html>
2. 정적 파일 서비스 활성화
Program.cs파일을 열거나 프로그램 설정이 있는 파일(Startup.cs)을 엽니다.Configure메서드 영역에app.UseStaticFiles();코드를 확인합니다. 이 코드가 정적 파일 서비스를 활성화합니다.
3. 애플리케이션 실행
- 프로젝트를 빌드하고 실행합니다.
- 웹 브라우저를 열고 애플리케이션의 URL로 이동합니다. 기본 설정에서는
http://localhost:[포트번호]/가 됩니다. - 웹 브라우저에
index.html페이지의 내용이 표시되면 성공입니다.Hello, world!와 같은 메시지가 보여야 합니다.
이 과정을 통해 간단한 HTML 파일을 wwwroot 폴더에 추가하고, ASP.NET Core 애플리케이션을 통해 이 파일을 웹 브라우저에서 제공하는 방법을 확인할 수 있습니다.
UseDefaultFiles 확장 메서드
UseDefaultFiles메서드는 특정 디렉터리의 기본 파일을 지정합니다. 예를 들어, 웹 사이트의 루트로 이동할 때index.html이나default.html과 같은 기본 파일을 자동으로 서비스하도록 설정할 수 있습니다.- 기본적으로 이 메서드는
wwwroot폴더 내의default.htm,default.html,index.htm,index.html파일을 찾습니다. - 이 메서드는 파일을 서비스하는 것이 아니라, 요청된 경로가 디렉터리를 가리킬 때 해당 디렉터리의 기본 파일을 찾는 역할을 합니다.
app.UseDefaultFiles(); // 기본 파일 사용
app.UseStaticFiles(); // 정적 파일 제공
UseFileServer 확장 메서드
UseFileServer메서드는UseStaticFiles,UseDefaultFiles, 그리고UseDirectoryBrowser의 기능을 결합한 것입니다. 이것은 특정 폴더의 파일들을 서비스하고, 기본 파일을 설정하며, 디렉터리 브라우징 기능을 제공합니다.- 이 메서드는 많은 구성 옵션을 제공하여, 정적 파일 서비스에 대한 상세한 설정이 가능합니다.
UseFileServer는 더 강력하고 유연하지만, 경우에 따라 필요 이상의 기능을 제공할 수 있으므로, 애플리케이션의 요구 사항에 맞게 선택하는 것이 중요합니다.
app.UseFileServer(enableDirectoryBrowsing: true);
MVC 패턴 적용하기
MVC(Model-View-Controller) 패턴은 사용자 인터페이스를 구현하기 위한 강력한 방법으로, 애플리케이션을 세 가지 주요 구성 요소인 모델(Model), 뷰(View), 컨트롤러(Controller)로 나눕니다.
ASP.NET Core MVC 패턴은 ASP.NET Core Razor Views로도 부릅니다. 뷰를 담당하는 csthml 페이지에서는 Razor Syntax를 사용하여 프로그래밍합니다.
ASP.NET Core에서 MVC 패턴을 구현하기 위해서는 다음과 같은 코드를 사용합니다.
builder.Services.AddControllersWithViews();
이 코드는 MVC 패턴을 사용하기 위한 서비스를 추가합니다. 그리고 라우팅 및 엔드포인트를 구성하여 MVC 패턴을 완성합니다.
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
이 코드는 URL 경로를 통해 특정 컨트롤러의 액션에 매핑하는 기본 라우팅 규칙을 정의합니다.
최소한의 코드로 MVC 테스트하기
ASP.NET Core에서 MVC(Model-View-Controller) 패턴을 간단하게 테스트해볼 수 있는 방법은 몇 줄의 코드로 구성된 간소화된 MVC 컨트롤러를 만드는 것입니다.
간소화된 MVC 컨트롤러 만들기
프로젝트 설정:
- 먼저
Program.cs파일에서 MVC 서비스를 추가합니다.builder.Services.AddMvc();
- 먼저
라우팅 구성:
- MVC 컨트롤러를 위한 기본 라우팅을 설정합니다.
app.UseRouting(); app.MapDefaultControllerRoute();
- MVC 컨트롤러를 위한 기본 라우팅을 설정합니다.
간단한 MVC 컨트롤러 생성:
MvcController라는 간단한 컨트롤러를 추가합니다. 이 컨트롤러는 단일Hello액션을 포함합니다.public class MvcController : Controller { public string Hello() => "Hello, MVC"; }
애플리케이션 실행:
- 애플리케이션을 실행하고 브라우저에서
http://localhost:<port>/Mvc/Hello로 이동하여 결과를 확인합니다.
- 애플리케이션을 실행하고 브라우저에서
Program.cs 파일의 전체 소스 코드는 다음과 같습니다.
using Microsoft.AspNetCore.Mvc;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMvc();
var app = builder.Build();
#region HTTP
// C# 11.0 버전의 원시 문자열 리터럴(Raw string literals)
string htmlTag = """
<html lang="ko">
<body>
<h1>Hello ASP.NET Core 8.0</h1>
</body>
</html>
""";
app.MapGet("/html-content-rendering", () => Results.Content(htmlTag, "text/html"));
#endregion
#region HTML
app.UseDefaultFiles();
app.UseStaticFiles();
#endregion
app.UseRouting();
app.MapDefaultControllerRoute();
app.Run();
#region MVC
// /Mvc/Hello
public class MvcController : Controller
{
public string Hello() => "Hello, MVC";
}
#endregion
MVC 패턴 적용하기 연습
ASP.NET Core에서 MVC(Model-View-Controller) 패턴을 적용하는 방법은 위에서 언급한 서비스 추가 및 라우팅 설정을 포함합니다. 이제 Home 컨트롤러와 그 안의 Index 액션을 만들고, 이를 Program.cs 파일에서 순수 클래스 레벨로 실행하는 방법을 살펴보겠습니다.
Home 컨트롤러 생성
우선, Home 컨트롤러 클래스를 만듭니다. 이 클래스는 Controller 기반 클래스를 상속받아야 하며, 하나 이상의 액션을 포함해야 합니다.
using Microsoft.AspNetCore.Mvc;
namespace VisualAcademy.Controllers
{
public class HomeController : Controller
{
public IActionResult Hello()
{
return Content("<h1>안녕하세요. MVC!</h1>", "text/html; charset=utf-8");
}
}
}
뷰 페이지 만들고 실행하기
using Microsoft.AspNetCore.Mvc;
public class HomeController : Controller
{
public IActionResult Index()
{
return View();
}
}
위 코드에서 HomeController는 컨트롤러 클래스이며, Index 메서드는 액션을 정의합니다. Index 액션은 View를 반환합니다.
Index.cshtml 페이지 생성
Index.cshtml 페이지는 Views/Home 디렉터리 내에 위치해야 하며, 아래와 같은 간단한 HTML 콘텐츠를 포함할 수 있습니다.
@{
Layout = null;
}
<!DOCTYPE html>
<html>
<head>
<title>Home Page</title>
</head>
<body>
<h1>Welcome to ASP.NET Core MVC!</h1>
<p>비주얼아카데미 홈페이지에 오신 걸 환영합니다.</p>
</body>
</html>
Program.cs 파일에서 MVC 컨트롤러 실행
Program.cs 파일에서 MVC 컨트롤러를 실행하려면, 앞서 언급한 서비스 등록과 라우팅 설정이 필요합니다. 아래는 Program.cs 파일의 전체 예제입니다.
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Hosting;
var builder = WebApplication.CreateBuilder(args);
// MVC 서비스 추가
builder.Services.AddControllersWithViews();
var app = builder.Build();
// 라우팅 및 엔드포인트 구성
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
app.Run();
위 코드에서 AddControllersWithViews() 메서드를 사용하여 MVC 서비스를 추가하고, UseRouting 및 UseEndpoints를 사용하여 라우팅 및 엔드포인트를 구성합니다. 기본 라우트는 Home 컨트롤러의 Index 액션으로 설정됩니다.
이렇게 하면 ASP.NET Core 애플리케이션에서 MVC 패턴을 사용할 수 있으며, Home 컨트롤러와 Index 액션을 통해 기본 페이지를 제공할 수 있습니다.
MVC 뷰 페이지
코드: VisualAcademy\Controllers\HomeController.cs
using Microsoft.AspNetCore.Mvc;
namespace VisualAcademy.Controllers
{
public class HomeController : Controller
{
public IActionResult Index()
{
return View();
}
public IActionResult Hello()
{
return Content("<h1>안녕하세요. MVC!</h1>", "text/html; charset=utf-8");
}
}
}
코드: VisualAcademy\Views\Home\Index.cshtml
@{
ViewData["Title"] = "Home Page";
}
<div class="text-center">
<h1 class="display-4">Welcome</h1>
<p>Learn about <a href="https://learn.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
</div>
Startup.cs 파일 소개
ASP.NET Core 1.0 버전부터 5.0 버전까지의 기본 설정 파일인 Startup.cs 파일에 대한 간단한 소개입니다. ASP.NET Core 8.0에서는 Program.cs 파일에서 모든 기본 구성 설정을 완료합니다.
ASP.NET Core의 핵심: Startup.cs
ASP.NET Core 애플리케이션의 구성과 초기화에 있어 Startup.cs 파일은 중심적인 역할을 합니다. 이 파일은 애플리케이션 시작 시 실행되며, 서비스의 등록, 미들웨어 파이프라인의 설정 등을 담당합니다. Startup.cs는 주로 두 개의 주요 메서드, ConfigureServices와 Configure를 포함합니다.
ConfigureServices 메서드
ConfigureServices 메서드는 애플리케이션에서 사용될 서비스들을 정의하고 등록하는 역할을 합니다. 이곳에서 데이터베이스 컨텍스트, 옵션 패턴, MVC, Identity 서비스와 같은 의존성 주입(DI) 컨테이너에 서비스들을 추가합니다.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
// 다른 서비스들을 여기에 추가...
}
Configure 메서드
Configure 메서드는 HTTP 요청 파이프라인을 구성합니다. 여기서 미들웨어 컴포넌트를 추가하거나 설정하여, 요청이 처리되는 방식을 결정할 수 있습니다. 예를 들어, 정적 파일을 제공, MVC를 사용하여 요청 라우팅, 예외 처리 등을 설정할 수 있습니다.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
}
Startup.cs 파일의 중요성은 애플리케이션의 기본 구조를 설정하고 전체적인 동작 방식을 결정한다는 데 있습니다. 이 파일을 통해 개발자는 애플리케이션의 모든 주요 기능과 동작을 커스터마이즈할 수 있으며, 다양한 서비스와 미들웨어를 유연하게 조합하여 사용할 수 있습니다.
ASP.NET Core 5.0 및 이전 버전에서 Startup.cs는 애플리케이션의 출발점으로, 애플리케이션의 구성 및 동작을 이해하고 관리하는 데 필수적인 파일입니다.
HTTP 파이프라인과 미들웨어 소개
HTTP 파이프라인과 미들웨어는 ASP.NET Core의 핵심 개념 중 하나입니다. 이들은 HTTP 요청과 응답을 처리하는 방식을 정의합니다.
HTTP 파이프라인
- HTTP 파이프라인은 일련의 요청 처리 단계를 나타냅니다. 이 파이프라인은 여러 미들웨어 컴포넌트로 구성됩니다.
- 각 미들웨어는 순차적으로 요청을 받아 처리하고 다음 미들웨어로 전달하거나, 요청 처리를 종료합니다.
- 파이프라인 구성은
Program.cs, Startup.cs의Configure메서드 영역에서 정의합니다.
미들웨어
- 미들웨어는 요청을 처리하고, 응답을 생성하거나, 다음 미들웨어로 요청을 전달하는 역할을 합니다.
- 각 미들웨어는 자체적으로 특정 기능을 수행하며, 요청 처리 과정에서 중요한 역할을 합니다. 예를 들어, 인증, 로깅, 정적 파일 제공 등의 작업을 수행합니다.
- 미들웨어는
app.Use...형태의 메서드로 추가되며, 추가 순서가 요청 처리 순서를 결정합니다.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseStaticFiles();
app.UseAuthentication();
// 기타 미들웨어 구성
}
이렇게 HTTP 파이프라인과 미들웨어는 ASP.NET Core 애플리케이션에서 중요한 역할을 하며, 애플리케이션의 요청 및 응답 처리 방식을 결정하는 데 기여합니다.
Web API 사용하기
NOTE
ASP.NET Core Web API는 고성능, 크로스 플랫폼, 오픈 소스 프레임워크를 사용하여 HTTP 서비스를 구축하는데 사용되는 Microsoft의 기술입니다.
(이 강좌는 데브렉에서 서비스되는 회원 전용 강좌입니다.)
ASP.NET Core 1.0이 출시되었을 때, ASP.NET Core MVC와 ASP.NET Core Web API가 하나의 프레임워크 안에서 통합되어 사용되었습니다. 이 문서에서는 MVC에 이어서 Web API의 기본적인 사용법에 대해 알아보겠습니다.
Web API는 클라이언트 애플리케이션과 서버 애플리케이션 사이의 통신 인터페이스를 제공합니다.
TIP
박용준 강사는 JSON을 발음할 때 "제이손"을 기준으로 "제이슨"과 함께 사용합니다.
Web API 서비스 추가
builder.Services.AddControllers();
위 코드는 ASP.NET Core 애플리케이션에 Web API 서비스를 추가합니다. 이는 컨트롤러를 통해 API 요청을 처리할 수 있도록 해줍니다.
라우팅 및 엔드포인트 구성
ASP.NET Core에서 Web API를 사용하기 위한 필수적인 단계 중 하나는 라우팅 및 엔드포인트의 구성입니다. app.UseRouting(); 메서드는 요청을 처리하기 전에 라우팅 기능을 활성화합니다. app.UseEndpoints(); 내의 endpoints.MapControllers();는 API 컨트롤러의 경로를 자동으로 매핑하여 각 요청을 적절한 컨트롤러 액션으로 라우팅하는 역할을 합니다.
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
ASP.NET Core 8.0 Web API 프로젝트 템플릿에서 사용된 Program.cs 파일의 기본 코드는 다음과 같습니다.
코드: VisualAcademy.Apis/Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();
다음은 VisualAcademy.Apis 이름의 Web API의 프로젝트 파일의 내용입니다. Swagger UI를 사용하기 위한 패키지가 하나 포함된 것을 알 수 있습니다.
코드: VisualAcademy.Apis\VisualAcademy.Apis.csproj
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<InvariantGlobalization>true</InvariantGlobalization>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
</ItemGroup>
</Project>
Swagger 관련 코드가 모두 포함된 Program.cs 파일의 내용은 다음과 같습니다.
코드: VisualAcademy\Program.cs
using Microsoft.AspNetCore.Mvc;
var builder = WebApplication.CreateBuilder(args);
// Startup.ConfigureServices
// This method gets called by the runtime. Use this method to add services to the container.
// Add services to the container.
//builder.Services.AddMvc();
//builder.Services.AddControllers(); // Web API
builder.Services.AddControllersWithViews(); // MVC + Web API
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
// Startup.Configure
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
#region HTTP
// C# 11.0 버전의 원시 문자열 리터럴(Raw string literals)
string htmlTag = """
<html lang="ko">
<body>
<h1>Hello ASP.NET Core 8.0</h1>
</body>
</html>
""";
app.MapGet("/html-content-rendering", () => Results.Content(htmlTag, "text/html"));
#endregion
#region HTML
// app.UseDefaultFiles();
app.UseStaticFiles(); // 정적인 HTML, CSS, JS, 이미지 파일 등을 제공하는 미들웨어
#endregion
app.UseRouting(); // 라우팅 미들웨어
//app.MapDefaultControllerRoute();
//app.MapControllers(); // Web API
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();
#region MVC
// ~/Mvc/Hello
public class MvcController : Controller
{
public string Hello() => "Hello, MVC";
}
#endregion
Web API 컨트롤러 생성
컨트롤러는 클라이언트의 요청을 처리하는 핵심적인 부분입니다. 다음 코드는 간단한 HelloWebApiController를 생성하는 예시를 보여줍니다. [ApiController] 특성은 해당 클래스가 API 컨트롤러임을 나타냅니다. [Route("api/[controller]")] 특성은 모든 액션 메서드의 기본 경로 앞에 /api/를 자동으로 추가합니다. HttpGet 특성은 HTTP GET 요청을 처리하며, 여기서는 "Hello World from Web API!"라는 간단한 문자열을 반환합니다.
(이 강좌는 데브렉에서 서비스되는 회원 전용 강좌입니다.)
코드: HelloWebApiController.cs
using Microsoft.AspNetCore.Mvc;
namespace VisualAcademy.Apis;
[ApiController]
[Route("api/[controller]")]
public class HelloWebApiController : ControllerBase
{
[HttpGet]
public IActionResult Get()
{
return Ok("Hello Web API");
}
// JSON 형식으로 데이터를 반환하는 추가적인 액션 메서드
[HttpGet("GetJson")]
public IActionResult GetJson()
{
var data = new Dictionary<string, string>
{
{ "Message", "Hello World from Web API!" },
{ "Author", "VisualAcademy" }
};
return new JsonResult(data);
}
}
이 문서는 ASP.NET Core에서 Web API를 사용하는 기본적인 방법을 설명합니다. 추가적인 기능이나 복잡한 시나리오에 대해서는 박용준 강사가 진행한 ASP.NET Core Web API Fundamentals 강의를 참조하는 것이 좋습니다.
Web API 다루기
.http 파일 제공
HTTP 파일은 API 요청과 응답을 테스트하고 문서화하는 데 사용됩니다. .http 파일은 각 API 엔드포인트에 대한 요청 예시와 예상 응답을 포함하며, API 개발 및 테스트 과정에서 매우 유용합니다.
이 기능을 사용하면 POSTMAN과 같은 Web API 테스트 도구에서 제공하는 collection과 같은 기능을 코드 레벨로 관리할 수 있습니다. .http 파일을 사용하면 다음과 같은 이점이 있습니다:
- 직관적 문서화: API의 사용 방법과 예상되는 응답을 직관적으로 문서화할 수 있습니다.
- 버전 관리:
.http파일은 소스 코드와 함께 버전 관리 시스템에 포함될 수 있어, API의 변경 사항을 추적하기 쉽습니다. - 간편한 공유: 팀원 간에 API 요청 사항을 쉽게 공유하고 협업할 수 있습니다.
- 테스트 자동화: 일부 도구를 사용하면
.http파일을 바탕으로 자동화된 테스트를 구성할 수도 있습니다.
Endpoints Explorer
Endpoints Explorer는 ASP.NET Core 애플리케이션에서 사용 가능한 모든 엔드포인트를 탐색하고 검사할 수 있는 도구입니다. 이 도구는 다음과 같은 기능을 제공합니다:
- 엔드포인트 탐색: 애플리케이션 내에서 사용 가능한 모든 엔드포인트를 빠르게 찾아볼 수 있습니다.
- 라우트 정보 확인: 각 엔드포인트에 대한 라우트 경로 및 패턴을 확인할 수 있습니다.
- 컨트롤러 및 액션 검사: 연결된 컨트롤러와 액션에 대한 세부 정보를 파악할 수 있습니다.
- 메타데이터 관리: 각 엔드포인트의 메타데이터를 보고 관리할 수 있으며, 이를 통해 더 정교한 API 관리가 가능합니다.
이 도구를 활용함으로써 개발자는 ASP.NET Core 애플리케이션의 엔드포인트 구성을 더욱 쉽게 이해하고 관리할 수 있습니다.
Razor 페이지 활용하기
Razor 페이지는 서버에서 HTML을 동적으로 생성하는 ASP.NET Core의 핵심 기능입니다. 서비스 컬렉션에 builder.Services.AddRazorPages()를 추가하여 Razor 페이지 기능을 활성화하고, app.UseEndpoints(endpoints => { endpoints.MapRazorPages(); });를 통해 라우팅을 설정함으로써 서버 사이드 HTML 렌더링을 용이하게 합니다. 이 구성을 통해 개발자는 서버에서 HTML 렌더링 로직을 간편하게 구현할 수 있습니다.
builder.Services.AddRazorPages();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
Razor Pages 프로젝트 만들기
"RedPlus"라는 이름의 ASP.NET Core 8.0 Razor Pages 프로젝트를 생성하고 실행하는 단계별 가이드입니다. 이 가이드는 Visual Studio 2022 이상을 사용하는 것을 기준으로 하며, 다른 개발 환경을 사용하는 경우에도 적용할 수 있는 명령줄 도구(dotnet CLI) 방법을 포함합니다.
Visual Studio를 사용하는 경우
1. 프로젝트 생성
- Visual Studio를 열고 "Create a new project"를 선택합니다.
- "ASP.NET Core Web App" 프로젝트 템플릿을 검색하고 선택한 후 "Next"를 클릭합니다.
- 프로젝트 이름으로 "RedPlus"를 입력하고, 원하는 위치를 선택한 후 "Next"를 클릭합니다.
- ".NET 8.0"을 대상 프레임워크로 선택하고, "Next"를 클릭합니다.
- "Web Application" 옵션을 선택하여 Razor Pages를 활성화한 후 "Create"를 클릭합니다.
2. 프로젝트 구조 탐색
생성된 프로젝트에는 다음과 같은 주요 구성 요소가 포함됩니다:
Pages: Razor 페이지 및 페이지 모델이 위치합니다.wwwroot: 정적 파일(css, js, 이미지 등)을 저장합니다.appsettings.json: 애플리케이션 설정 파일입니다.Program.cs: 애플리케이션의 진입점으로, 미들웨어 및 서비스 구성을 담당합니다.
3. 간단한 Razor 페이지 추가
- "Pages" 폴더에서 마우스 오른쪽 버튼 클릭 > "Add" > "Razor Page" 선택합니다.
- "Empty" 템플릿을 선택하고, 파일 이름을 "HelloWorldPage.cshtml"로 지정한 후 "Add"를 클릭합니다.
- "HelloWorldPage.cshtml" 파일에 다음과 같은 Razor 마크업을 추가합니다:
@page @model HelloWorldModel <h1>Hello, world!</h1> <p>The time on the server is @DateTime.Now</p>
4. 프로젝트 실행
- "IIS Express" 버튼을 클릭하거나 F5 키를 눌러 디버깅 모드에서 프로젝트를 실행합니다.
- 웹 브라우저가 열리고, 애플리케이션의 홈페이지가 표시됩니다. URL에
/HelloWorldPage를 추가하여 새로 만든 페이지를 확인합니다.
이 가이드를 통해 ASP.NET Core 8.0을 사용한 Razor Pages 애플리케이션 개발의 기본적인 단계를 배우게 되었습니다.
Razor Pages 전용 설정
builder.Services.AddRazorPages(): 서비스 컨테이너에 Razor Pages를 추가하여, Razor Pages 애플리케이션에 필요한 서비스들을 등록합니다. 이는 Razor Pages가 올바르게 작동하는 데 필수적입니다.app.MapRazorPages(): 애플리케이션의 라우팅 시스템에 Razor Pages에 대한 라우트를 등록합니다. 이는 들어오는 요청을 적절한 Razor Page로 라우팅하기 위해 필요하며, 페이지 기반 라우팅을 활성화합니다.
Blazor Server 8.0 소개
Blazor Server는 실시간 웹 통신을 활용해 서버에서 .NET 코드를 실행하고 그 결과를 클라이언트에게 렌더링하는, Microsoft가 제공하는 웹 애플리케이션 프레임워크입니다. 이는 Angular, React, Vue와 같은 다른 주요 프레임워크와 비교될 수 있지만, 주된 차이점은 JavaScript 대신 C#을 사용한다는 점입니다.
버전 8.0으로 업데이트된 Blazor Server는 .NET 8.0 플랫폼의 핵심을 이루며, 서버에서 실행되는 인터랙티브한 웹 애플리케이션을 구축할 수 있는 혁신적인 도구를 개발자에게 제공합니다. 이 프레임워크는 C# 및 .NET 생태계 내에서 웹 애플리케이션 개발의 새로운 가능성을 열어, 개발자들이 JavaScript에 의존하지 않고도 풍부한 사용자 경험을 제공할 수 있는 서버 측 로직을 구현할 수 있게 합니다. Blazor Server 8.0은 웹 개발의 전통적 방법을 변화시켜, 더욱 강력하고 유연한 웹 애플리케이션 개발을 가능하게 합니다.
Blazor 간단 소개
.NET 8의 Blazor를 사용하면 서버와 클라이언트의 컴포넌트를 모두 사용하여 모든 웹 UI 요구 사항을 처리할 수 있습니다. 바로 전체 스택 웹 UI입니다!
Blazor는 이제 서버 측 렌더링에 대한 지원을 확장하여 컴포넌트를 포함한 정적 서버 렌더링, 개선된 탐색 및 양식 처리, 스트리밍 렌더링을 지원합니다. 이를 통해 페이지 로드 시간을 최적화하고 사용자 경험을 향상시킬 수 있습니다.
그런 다음 Blazor 서버를 사용하여 서버에서 또는 Blazor WebAssembly를 통해 클라이언트에서 필요한 곳에 풍부한 상호작용을 위한 Blazor 컴포넌트를 활성화할 수 있습니다.
Blazor 서버에서 Blazor WebAssembly로 런타임에 사용자를 자동으로 전환하여 로드 시간과 확장성을 개선할 수도 있습니다.
Blazor 애플리케이션 실행하기
Blazor Server는 클라이언트 사이드에서 실행되는 대신 서버에서 UI 컴포넌트를 처리하는 방식을 제공합니다. builder.Services.AddServerSideBlazor();를 호출하여 서비스를 추가하고, endpoints.MapBlazorHub();와 endpoints.MapFallbackToPage("/_Host");를 사용하여 Blazor 컴포넌트와 필요한 통신 경로를 설정합니다. 단, 이 명령은 .NET 8로 올라서면서 대대적으로 코드가 수정되었습니다.
다음 코드는 .NET 7.0 버전까지의 Blazor Server 설정 코드입니다.
builder.Services.AddServerSideBlazor();
...
app.UseEndpoints(endpoints =>
{
endpoints.MapBlazorHub();
endpoints.MapFallbackToPage("/_Host");
});
.NET 8.0 이후로는 다음과 같은 코드 형태로 Program.cs 파일에서 사용됩니다.
builder.Services.AddRazorComponents().AddInteractiveServerComponents();
...
app.MapRazorComponents<App>().AddInteractiveServerRenderMode();
핵심 특징
- 서버 측 로직 실행: Blazor Server 애플리케이션은 사용자의 인터랙션을 실시간으로 서버에 전달하고, 변경된 UI를 다시 사용자에게 전송하여 동적인 웹 경험을 제공합니다.
- SignalR 기반 실시간 통신: SignalR을 기반으로 하는 웹소켓 통신을 통해 서버와 클라이언트 간의 실시간 상호작용을 지원합니다. 이는 애플리케이션의 반응성과 사용자 경험을 크게 향상시킵니다.
- 향상된 성능과 확장성: Blazor Server 8.0은 성능 최적화와 함께 더 나은 확장성을 제공하여, 대규모 애플리케이션과 높은 트래픽을 처리할 수 있습니다.
- 개발자 친화적 도구: Visual Studio와 Visual Studio Code를 포함한 개발 도구는 Blazor Server 애플리케이션의 개발과 디버깅을 쉽고 효율적으로 만들어 줍니다.
- 컴포넌트 기반 아키텍처: UI를 재사용 가능한 컴포넌트로 구성하여, 개발 과정을 간소화하고 코드의 재사용성을 높일 수 있습니다.
Blazor Server 8.0의 새로운 기능
Blazor Server 8.0은 다음과 같은 새로운 기능과 개선 사항을 포함할 수 있습니다:
- 향상된 성능: 애플리케이션의 로딩 시간과 반응성을 개선하기 위한 성능 최적화.
- 개발자 도구 개선: 더 나은 디버깅 경험과 코드 편집 기능을 제공하는 개발 도구의 업그레이드.
- 새로운 API 및 컴포넌트: 개발자가 보다 풍부한 애플리케이션을 구축할 수 있도록 하는 새로운 컴포넌트와 API.
- 보안 강화: 애플리케이션의 보안을 강화하기 위한 새로운 기능 및 업데이트.
Blazor Server 8.0은 .NET 개발자들이 서버 측 로직을 활용하여 복잡하고 인터랙티브한 웹 애플리케이션을 효율적으로 구축할 수 있게 해주는 강력한 프레임워크입니다. 이를 통해 개발자는 클라이언트 측 개발에 대한 전통적인 접근법을 넘어서, .NET 생태계 내에서 일관된 개발 경험을 즐길 수 있습니다.
처음으로 Blazor Web App 만들기
Blazor Web App을 .NET 8.0 기반으로 만들고 실행하는 과정은 다음 단계를 따라 수행할 수 있습니다. 이 문서에서는 "Hawaso"라는 이름의 Blazor Server 애플리케이션을 생성하고, 인증을 포함하지 않는 형태로 구성하는 방법을 안내합니다.
준비 사항
- .NET 8.0 SDK가 설치되어 있어야 합니다. 설치되어 있지 않다면, Microsoft 공식 사이트에서 .NET 8.0 SDK를 다운로드하여 설치하세요.
- 코드 편집기 (예: Visual Studio Code, Visual Studio)
1. Blazor Server 애플리케이션 생성
명령 프롬프트(Command Prompt) 또는 터미널을 엽니다.
Blazor Server 프로젝트를 생성하고자 하는 디렉터리로 이동합니다.
다음 명령어를 실행하여 "Hawaso"라는 이름의 Blazor Server 애플리케이션을 생성합니다. 다음 명령은 참고만 하고 Visual Studio로 생성합니다.
dotnet new blazorserver -n Hawaso --no-https-n Hawaso: 프로젝트의 이름을 "Hawaso"로 지정합니다.--no-https: HTTPS를 사용하지 않도록 설정합니다. (로컬 개발 환경에서 간소화를 위함)
2. 프로젝트 폴더로 이동
생성된 "Hawaso" 프로젝트 폴더로 이동합니다.
cd Hawaso
3. 의존성 확인 및 프로젝트 구조 이해
생성된 프로젝트에는 Blazor Server 애플리케이션을 개발하기 위한 기본적인 파일 및 폴더 구조가 포함되어 있습니다. Program.cs, Components 폴더, wwwroot 등 주요 파일과 폴더를 확인해 보세요.
4. 애플리케이션 실행
프로젝트 디렉터리에서 다음 명령어를 실행하여 Blazor Server 애플리케이션을 실행합니다.
dotnet run
5. 웹 브라우저에서 애플리케이션 확인
dotnet run 명령어 실행 후, 콘솔에 표시된 로컬 호스트 주소 (예: http://localhost:5000)를 웹 브라우저에 입력하여 애플리케이션을 확인합니다.
6. 개발 시작
이제 Blazor Server 애플리케이션 개발을 시작할 수 있습니다. Components 폴더 내의 Razor 컴포넌트를 수정하여 애플리케이션의 UI를 변경하거나, wwwroot 폴더 내의 정적 파일을 조작하여 스타일이나 스크립트를 추가할 수 있습니다.
Minimal API 사용하기
ASP.NET Core 8.0의 Minimal APIs는 개발자가 간결하면서도 효율적인 방식으로 API 엔드포인트를 구성할 수 있게 해줍니다. 이들은 기본적인 구성요소와 람다 표현식을 사용하여 복잡한 설정 없이도 API를 빠르게 만들 수 있습니다. 여기서는 Minimal API의 기본 사용법부터 파라미터 사용, JSON 응답 반환, 그리고 서비스 및 미들웨어 통합까지 다양한 예제를 통해 소개합니다.
기본 문자열 응답 반환
가장 간단한 형태의 Minimal API 엔드포인트는 문자열을 반환하는 것입니다. 아래의 예제는 /hello 경로로 GET 요청을 받아 "Hello World from Minimal API!" 문자열을 반환합니다.
app.MapGet("/hello", () => "Hello World from Minimal API!");
JSON 응답 반환
Minimal API는 객체를 JSON으로 직렬화하여 반환하는 것도 간단합니다. 아래의 예제는 /helloworld 경로로 GET 요청을 받아 JSON 형태로 응답합니다.
app.MapGet("/helloworld", () => new { Hello = "World!" });
파라미터 사용 및 응답 커스터마이징
경로에서 파라미터를 추출하여 사용하는 것도 Minimal API의 기능 중 하나입니다. 다음 예제들은 경로 파라미터와 쿼리 파라미터를 사용하여 요청에 따라 다른 응답을 생성하는 방법을 보여줍니다.
app.MapGet("/old/{age}", (int age) => new { Age = age });
app.MapGet("/sayhello/{name}", (string name) => $"Hello {name} from Minimal API!");
app.MapGet("/json", () => Results.Json(new { Message = "Hello World", Date = DateTime.Now }));
서비스와 미들웨어 통합
Minimal API는 미들웨어 및 의존성 주입을 통한 서비스 통합을 지원합니다. 이를 통해 더 복잡한 로직을 처리하거나, 애플리케이션 전반에 걸쳐 재사용 가능한 컴포넌트를 만들 수 있습니다.
미들웨어 등록 예제:
사용자 정의 미들웨어인
RequestLoggingMiddleware를 등록하여 모든 요청을 로깅합니다.
app.UseMiddleware<RequestLoggingMiddleware>();
서비스 의존성 주입 예제:
IDateTimeProvider인터페이스를 구현한 서비스를 의존성 주입을 통해 사용합니다. 이 예제는/service경로로 GET 요청을 받을 때 현재 시간을 반환합니다.
app.MapGet("/service", (IDateTimeProvider service) => service.Now());
IDateTimeProvider 서비스 인터페이스
Minimal API에서 서비스를 사용하는 예제를 완성하기 위해, IDateTimeProvider 인터페이스와 그 구현 예를 제공합니다. 이 인터페이스는 현재 시간을 반환하는 메서드 Now를 정의합니다.
public interface IDateTimeProvider
{
DateTime Now();
}
public class DateTimeProvider : IDateTimeProvider
{
public DateTime Now() => DateTime.Now;
}
애플리케이션의 Startup 클래스 또는 초기화 코드에서 이 서비스를 DI 컨테이너에 등록해야 합니다.
builder.Services.AddSingleton<IDateTimeProvider, DateTimeProvider>();
이렇게 하면 IDateTimeProvider 서비스를 요청하는 모든 엔드포인트에서 현재 시간을 반환할 수 있는 DateTimeProvider의 인스턴스가 자동으로 주입됩니다.
Blazor Server 8.0 맛보기
다음 영상은 Blazor Server 프로젝트를 만들고 실행하는 전체 단계를 소개합니다.
Blazor Server 8.0 기반 VisualAcademy 프로젝트 생성
이번에는 Blazor Server 프로젝트를 먼저 만들고 MVC와 Razor Pages를 포함하는 내용입니다.
Blazor Server 8.0 프로젝트에 ASP.NET Core MVC를 함께 사용하도록 설정한 내용이 포함된 Program.cs 파일은 다음과 같습니다.
코드: Program.cs
using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using VisualAcademy.Components;
using VisualAcademy.Components.Account;
using VisualAcademy.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorComponents()
.AddInteractiveServerComponents(); // Blazor Server
builder.Services.AddControllersWithViews(); // MVC
builder.Services.AddRazorPages(); // Razor Page
builder.Services.AddCascadingAuthenticationState();
builder.Services.AddScoped<IdentityUserAccessor>();
builder.Services.AddScoped<IdentityRedirectManager>();
builder.Services.AddScoped<AuthenticationStateProvider, IdentityRevalidatingAuthenticationStateProvider>();
builder.Services.AddAuthentication(options =>
{
options.DefaultScheme = IdentityConstants.ApplicationScheme;
options.DefaultSignInScheme = IdentityConstants.ExternalScheme;
})
.AddIdentityCookies();
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection") ?? throw new InvalidOperationException("Connection string 'DefaultConnection' not found.");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();
builder.Services.AddIdentityCore<ApplicationUser>(options => options.SignIn.RequireConfirmedAccount = true)
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddSignInManager()
.AddDefaultTokenProviders();
builder.Services.AddSingleton<IEmailSender<ApplicationUser>, IdentityNoOpEmailSender>();
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseMigrationsEndPoint();
}
else
{
app.UseExceptionHandler("/Error", createScopeForErrors: true);
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
// 미들웨어 추가: 순서 중요
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseAntiforgery();
app.MapRazorComponents<App>()
.AddInteractiveServerRenderMode();
app.MapDefaultControllerRoute(); // MVC
// Add additional endpoints required by the Identity /Account Razor components.
app.MapAdditionalIdentityEndpoints();
app.MapRazorPages(); // Razor Pages
app.Run();
ASP.NET Core 8.0 Web API 맛보기
(이 강좌는 회원 전용 강좌입니다. 최종 완성된 강의는 데브렉에서 서비스됩니다.)
.NET 데이터 처리 기술
.NET 개발 환경은 강력한 데이터 처리 및 액세스 기능을 제공합니다. 이러한 기능은 다양한 데이터 소스와의 상호작용을 용이하게 하며, 개발자가 효율적으로 데이터 중심의 애플리케이션을 구축할 수 있도록 지원합니다. 여기서는 .NET에서 널리 사용되는 세 가지 데이터 처리 기술인 ADO.NET, Dapper, EF Core에 대해 간략히 소개합니다.
ADO.NET: 데이터 액세스의 견고한 기초
ADO.NET은 .NET 프레임워크의 일부로, 데이터베이스와의 상호작용을 위한 풍부한 기능을 제공합니다. 이것은 관계형 데이터베이스 뿐만 아니라 XML 기반 데이터와도 작업할 수 있는 유연성을 갖추고 있습니다. ADO.NET은 다양한 데이터 소스에 대한 연결, 명령 실행, 데이터 읽기, 그리고 데이터의 연결 해제를 관리하는 데 사용됩니다. 이 기술은 성능과 확장성을 중시하는 데이터 중심 애플리케이션에 이상적이며, 직접적이고 제어가 가능한 데이터 액세스 계층을 필요로 하는 경우에 주로 사용됩니다.
DevLec ADO.NET Fundamentals 강의
Dapper: 닷넷의 민첩한 ORM 솔루션
Dapper는 .NET 애플리케이션 개발을 위한 경량의 ORM(Object-Relational Mapping) 라이브러리입니다. Stack Overflow 팀에 의해 개발되었으며, 성능을 크게 저하시키지 않으면서도 개발의 편의성을 제공하는 것을 목표로 합니다. Dapper는 ADO.NET의 기능을 활용하여 구현되며, SQL 쿼리 실행과 결과 매핑을 단순화합니다. 이는 데이터베이스 작업을 위한 간결하고 효율적인 코드 작성을 가능하게 하여, 개발 속도를 높이고자 하는 개발자들에게 인기가 있습니다.
EF Core: 현대적인 데이터 액세스 패러다임
Entity Framework (EF) Core는 Microsoft가 개발한 고성능, 확장 가능한 .NET의 공식 데이터 액세스 기술입니다. EF Core는 ORM의 전체 기능을 제공하며, 개발자가 객체 지향 프로그래밍 방식을 사용하여 데이터베이스를 관리할 수 있도록 합니다. 코드 우선 접근 방식을 채택하여, 데이터 모델을 C# 클래스로 표현할 수 있으며, 이는 데이터베이스 스키마와 자동으로 매핑됩니다. EF Core는 다양한 데이터베이스 엔진을 지원하며, LINQ 쿼리, 데이터 마이그레이션, 그리고 모델 변경에 대한 자동 처리 등 고급 기능을 제공합니다.
VisualAcademy 프로젝트에 3가지 DB 처리 기술 적용
아래는 ASP.NET Core 프로젝트인 VisualAcademy에 ADO.NET, Dapper, 그리고 Entity Framework Core를 사용하기 위해 필요한 패키지를 설치하고 기본 설정을 하는 방법에 대한 단계별 가이드입니다. 이 내용을 따라하여 프로젝트에 필요한 데이터 처리 기술을 쉽게 통합할 수 있습니다.
준비 사항
- Visual Studio 또는 .NET CLI가 설치된 환경
- ASP.NET Core 프로젝트 (이 예제에서는 VisualAcademy 프로젝트)
1. Microsoft.Data.SqlClient 설치
Visual Studio 사용 시
- Visual Studio에서 프로젝트를 엽니다.
- 솔루션 탐색기에서 프로젝트를 마우스 오른쪽 버튼으로 클릭하고 "NuGet 패키지 관리..."를 선택합니다.
- "찾아보기" 탭을 선택하고 "Microsoft.Data.SqlClient"를 검색합니다.
- 패키지를 선택하고 "설치" 버튼을 클릭합니다.
.NET CLI 사용 시
dotnet add package Microsoft.Data.SqlClient
2. Dapper 설치
Visual Studio 사용 시
- 위의 Microsoft.Data.SqlClient 설치 방법을 따르되, "Dapper"로 검색하여 설치합니다.
.NET CLI 사용 시
dotnet add package Dapper
3. Entity Framework Core 설치
EF Core 설치
- 프로젝트에 사용할 특정 데이터베이스에 맞는 EF Core 데이터베이스 프로바이더를 설치해야 합니다. 예를 들어, SQL Server를 사용한다면
Microsoft.EntityFrameworkCore.SqlServer패키지를 설치합니다.
Visual Studio 사용 시
- "NuGet 패키지 관리..."에서 "Microsoft.EntityFrameworkCore.SqlServer"를 검색하여 설치합니다.
.NET CLI 사용 시
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
4. 각 기술별 기본 설정
ADO.NET
appsettings.json에 데이터베이스 연결 문자열을 추가합니다.
{
"ConnectionStrings": {
"DefaultConnection": "서버 연결 문자열"
}
}
Dapper
- Dapper는 ADO.NET 위에 구축되므로, ADO.NET 설정을 활용하여 사용할 수 있습니다.
Entity Framework Core
- EF Core 사용을 위해 모델 클래스와 DbContext를 정의합니다.
appsettings.json에 EF Core 데이터베이스 연결 문자열을 추가합니다.- Startup.cs 또는 Program.cs에서 DbContext를 서비스 컨테이너에 등록합니다.
services.AddDbContext<YourDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
5. 마이그레이션 생성 및 데이터베이스 업데이트 (EF Core에만 해당)
dotnet ef migrations add InitialCreate
dotnet ef database update
이 가이드를 따라 ASP.NET Core 프로젝트에 Microsoft.Data.SqlClient, Dapper, 및 Entity Framework Core를 성공적으로 설치하고 설정할 수 있습니다.
결론
ADO.NET, Dapper, EF Core는 각각 고유의 특성과 장점을 가지고 있습니다. 선택은 프로젝트의 요구 사항, 성능 고려사항, 그리고 개발 팀의 선호도에 따라 달라질 수 있습니다. ADO.NET은 직접적이고 세밀한 데이터 액세스 제어가 필요할 때, Dapper는 성능과 개발의 신속성을 동시에 추구할 때, EF Core는 풀 스택 ORM 솔루션과 코드 중심의 데이터 액세스를 원할 때 적합합니다
인증이 포함된 형태의 Blazor Server 프로젝트 생성
(내용 준비중입니다.)
SQL Server 데이터베이스 프로젝트
(내용 준비중입니다.)
모든 프로젝트 템플릿 통합
ASP.NET Core와 Blazor Server 관점에서만 보면, Blazor Web App 8.0 프로젝트보다는 Blazor Server 6.0 또는 7.0 프로젝트를 생성하고 난 후에 .NET 버전을 8.0으로 업그레이드를 한 후에 나머지 모든 기능들을 8.0 버전에 맞게 개발하는게 좋을 수 있습니다.
그래서, .NET 6.0 버전에서 통합 프로젝트를 만들고 이를 8.0 버전으로 업그레이드해서 사용하면 .NET 모든 영역의 기능들을 하나의 프로젝트에서 사용할 수 있는 장점을 가집니다.
.NET 8.0이 나와 있지만, .NET 6.0 버전의 다음 강좌가 아직도 프로젝트를 구성하는데 많은 도움이 될 것입니다.
인증 및 권한 부여의 완전 가이드
코드 조각
attribute 지시문으로 Authorize 특성 적용하여 인증된 사용자만 접근하는 컴포넌트 만들기
Authorize 특성 사용하기
이 문서는 Razor 페이지의 보안 설정을 구성하는 방법에 대해 설명합니다. UserList.razor 파일의 예제 코드를 통해 누구나 접근할 수 있는 페이지, 인증된 사용자만 접근할 수 있는 페이지, 그리고 특정 역할에 속한 사용자만 접근할 수 있는 페이지를 만드는 방법을 설명합니다.
예제 코드
파일 경로: \VisualAcademy\Components\Pages\Administrations\Users\UserList.razor
1. 누구나 접근 가능한 페이지
이 코드는 기본적인 UserList 페이지를 생성합니다. 누구나 이 페이지에 접근할 수 있습니다.
@page "/Administrations/Users"
@page "/Administrations/UserList"
<h3>UserList</h3>
@code {
}
2. 인증된 사용자만 접근 가능한 페이지
이 코드 조각은 인증된 사용자만 UserList 페이지에 접근할 수 있도록 설정합니다. @attribute [Authorize] 지시어가 추가되어 있습니다.
@page "/Administrations/Users"
@page "/Administrations/UserList"
@attribute [Authorize]
<h3>UserList</h3>
@code {
}
3. 특정 역할에 속한 사용자만 접근 가능한 페이지
이 코드 조각은 "Administrators" 역할에 포함된 사용자만 UserList 페이지에 접근할 수 있게 합니다. @attribute [Authorize(Roles = "Administrators")]를 사용하여 특정 역할을 지정합니다.
@page "/Administrations/Users"
@page "/Administrations/UserList"
@attribute [Authorize(Roles = "Administrators")]
<h3>UserList</h3>
@code {
}
마무리
이 문서는 다양한 보안 수준의 Razor 페이지를 구성하는 방법을 보여줍니다. 각 코드 조각은 페이지 접근을 제어하는 다른 방법을 설명하며, 이를 통해 사용자와 역할 기반의 보안 시스템을 구축할 수 있습니다.
기타
C# 12.0 기본 생성자(Primary Constructor) 소개
ASP.NET Core에서 .http 파일을 사용한 Basic 인증 구현
마무리: ASP.NET Core 8.0 탐험
이번 경험을 통해 ASP.NET Core 8.0의 다양한 기능들을 살펴볼 수 있었습니다. MVC, Web API, Razor Pages, Blazor Server, 그리고 Minimal APIs와 같은 기본 프로젝트 템플릿을 활용해 각 기술의 핵심을 맛보는 시간이었습니다.
하지만, 여정의 시작일 뿐입니다. 이제 이 각각의 기술들을 더 깊이 탐구하고, 다양한 가능성을 탐색할 시간입니다. 여러분이 더욱 폭넓은 지식을 얻고, 실력을 향상시킬 수 있는 다양한 강의와 자료들이 준비되어 있습니다.
더 많은 정보와 교육 자료를 찾고 계신다면, 아래 링크를 방문해보세요. 다양한 강의와 풍부한 내용이 여러분을 기다립니다.
이제 ASP.NET Core 8.0과 함께 여러분의 개발 여정을 다시 시작해보세요!
More
ASP.NET Core와 Blazor Server 강좌의 최종 목적지 데모 소스를 미리보기로 설치 후 실행하기
(이 강좌는 회원 전용 강좌입니다. 최종 완성된 강의는 데브렉에서 서비스됩니다.)