C# Switch 식(Expression)

C# 8.0(2019년 9월)부터 도입된 Switch 식(Switch Expression)은 기존의 switch-case 문을 획기적으로 줄여주는 강력한 기능

람다 표현식(=>)을 쓰는 것처럼 간결하고 직관적인 분기 처리가 가능

기존 방식 (Statement)

public string GetGrade(int score)
{
    string grade;
    switch (score)
    {
        case 90:
            grade = "A";
            break;
        case 80:
            grade = "B";
            break;
        default:
            grade = "C";
            break;
    }
    return grade;
}

새로운 방식 (Expression)

public string GetGrade(int score) => score switch
{
    90 => "A",
    80 => "B",
    _  => "C"
};


또는 다른 범위 방식으로 (결과는 다름) 
score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    _     => "D"
};

• 위치 이동: switch 키워드가 변수 뒤로 이동 (score switch)
• 화살표 사용: case ... : 대신 람다 화살표 =>를 사용
• Default 처리: default: 대신 와일드카드 _를 사용
• 식(Expression): 그 자체가 ‘값’을 반환하므로 메서드의 리턴값으로 바로 사용할 수 있음

강력한 활용 패턴

C# 9.0(2020년 11월)부터 Switch 식이 단순 매핑이 아니라 패턴 매칭(Pattern Matching)과 결합됨

• Switch Expression 자체는 C# 8에서 처음 도입
• Pattern Matching 자체는 C# 7부터 지원
• Relational Pattern, Logical Pattern 등이 C# 9에서 추가

범위 비교 (Relational Pattern)

C# 9.0부터는 when 키워드 없이도 관계 연산자를 직접 사용

int temperature = 28;

string weather = temperature switch
{
    >= 30 => "폭염",
    >= 20 => "쾌적함",
    >= 10 => "쌀쌀함",
    _     => "추움"
};

여러 변수 동시에 비교 (Tuple Pattern)

두 개 이상의 상태를 조합해서 분기해야 할 때, if-else 중첩 없이 튜플 패턴으로 깔끔하게 해결

string state = "Running";
bool hasError = true;

// (상태, 에러여부)를 한 번에 검사
string message = (state, hasError) switch
{
    ("Running", false) => "정상 작동 중",
    ("Running", true)  => "작동 중이나 오류 발생",
    ("Stopped", _)     => "시스템 중지됨", // _는 true/false 상관없음
    _                  => "알 수 없는 상태"
};

객체 속성 비교 (Property Pattern)

객체 내부의 특정 프로퍼티 값에 따라 분기할 수도 있음

var user = new User { Role = "Admin", IsDeleted = false };

string accessLevel = user switch
{
    { Role: "Admin", IsDeleted: false } => "관리자 권한",
    { Role: "User", IsDeleted: false }  => "일반 사용자",
    { IsDeleted: true }                 => "삭제된 계정",
    _                                   => "접근 불가" // null 포함
};

// 객체가 null인 경우도 자동으로 _

리턴값이 없는 메서드(Action) 실행

Action 델리게이트를 반환받아 즉시 실행

switch expression은 “값”을 반환하므로 델리게이트(함수 포인터)를 반환하는 것도 가능

int command = 1;

// 1. 각 조건에 맞는 Action(행동)을 선택하고
// 2. 마지막의 ()로 즉시 실행합니다.
(command switch
{
    1 => (Action)(() => SaveData()),
    2 => () => LoadData(),
    _ => () => Console.WriteLine("대기")
})(); 
// 마지막 ()는 "반환된 델리게이트 실행"

The post C# Switch 식(Expression) appeared first on 어제와 내일의 나 그 사이의 이야기.

MySQL 서비스 관리 명령어

상태 확인

sudo systemctl status mysql

서비스 시작

sudo systemctl start mysql

서비스 재시작

# 설정 변경 후 MySQL 재시작 필요
sudo systemctl restart mysql

서비스 중지

sudo systemctl stop mysql

부팅 시 자동 시작

# 부팅 시 자동 시작 활성화
sudo systemctl enable mysql

# 부팅 시 자동 시작 비활성화
sudo systemctl disable mysql

설정 파일

sudo cat /etc/mysql/my.cnf

# 현재 상태 정보 확인
mysql -u root -p -e "SHOW STATUS;"

# MySQL 클라이언트로 현재 설정 값 확인
mysql -u root -p -e "SHOW VARIABLES;"

# 특정 설정 값만 필터링해서 보기 (예: buffer_pool_size)
mysql -u root -p -e "SHOW VARIABLES LIKE '%buffer_pool_size%';"

추가 유용한 명령어

# MySQL 프로세스 확인
ps aux | grep mysql

# MySQL 버전 확인
mysql -V
mysql -u root -p -e "SELECT version();"

# 사용자 목록 확인
mysql -u root -p -e "SELECT user, host FROM mysql.user;"

# 데이터베이스 목록 확인
mysql -u root -p -e "SHOW DATABASES;"

# 테이블 상태 확인
mysql -u root -p -e "SHOW TABLE STATUS;"

# 실행 중인 쿼리 확인
mysql -u root -p -e "SHOW PROCESSLIST;"

백업 및 복구

# 전체 데이터베이스 백업
sudo mysqldump -u root -p --all-databases > full_backup.sql

# 특정 데이터베이스 백업
sudo mysqldump -u root -p database_name > db_backup.sql

# 백업 파일로 복구
mysql -u root -p < full_backup.sql

The post MySQL 서비스 관리 명령어 (Ubuntu) appeared first on 어제와 내일의 나 그 사이의 이야기.

1. Docker 백그라운드 실행 명령어

컨테이너를 백그라운드(detached) 모드로 실행하여 터미널을 점유하지 않고 계속해서 동작하게 하는 명령어

// docker run -d [이미지 이름]
// -d 또는 --detach 옵션은 컨테이너를 백그라운드에서 실행하도록 지시
docker run -d -p 8080:80 nginx

2. 실행 중인 컨테이너 확인 명령어

현재 시스템에서 실행 중인 컨테이너를 확인하는 명령어

// ps는 "process status"의 약자로, 현재 실행 중인 컨테이너의 목록을 보여줌
docker ps


CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                                   NAMES
a1b2c3d4e5f6   nginx     "/docker-entrypoint.sh"  10 seconds ago   Up 8 seconds    0.0.0.0:8080->80/tcp, :::8080->80/tcp   web_server

// CONTAINER ID: 컨테이너의 고유 ID
// IMAGE: 컨테이너를 생성하는 데 사용된 이미지
// COMMAND: 컨테이너가 실행될 때 사용된 명령어
// CREATED: 컨테이너가 생성된 시점
// STATUS: 컨테이너의 현재 상태 (예: Up 5 minutes)
// PORTS: 포트 매핑 정보
// NAMES: 컨테이너에 할당된 이름

3. 모든 컨테이너 확인 명령어 (실행 중 + 정지)

실행 중인 컨테이너뿐만 아니라, 이전에 실행되었다가 현재는 정지된 모든 컨테이너를 확인하는 명령어

// -a 또는 --all 옵션은 모든 컨테이너를 표시하도록 지시
docker ps -a

CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS                      PORTS     NAMES
a1b2c3d4e5f6   nginx     "/docker-entrypoint.sh"  2 minutes ago   Up 2 minutes                ...       web_server
e6f5d4c3b2a1   ubuntu    "/bin/bash"              5 hours ago     Exited (0) 4 minutes ago              test_container

4. 기타 유용한 명령어

• docker stop
• docker start
• docker kill
• docker logs
• docker attach
• docker exec

// 컨테이너 중지: docker stop [컨테이너 ID 또는 이름]
// 실행 중인 컨테이너를 정상적으로 종료시킵니다.
docker stop web_server

// 컨테이너 시작: docker start [컨테이너 ID 또는 이름]
// 정지된 컨테이너를 다시 시작합니다.
docker start test_container

// 컨테이너 강제 종료: docker kill [컨테이너 ID 또는 이름]
// 컨테이너를 강제로 즉시 종료시킵니다.
docker kill web_server

// 컨테이너 로그 확인: docker logs [컨테이너 ID 또는 이름]
// 컨테이너의 표준 출력(stdout)과 표준 에러(stderr) 로그를 확인합니다.
docker logs web_server

// 컨테이너 접속: docker attach [컨테이너 ID 또는 이름]
// 백그라운드에서 실행 중인 컨테이너의 터미널에 연결합니다.
docker attach web_server

// 컨테이너 내부에 명령어 실행: docker exec [컨테이너 ID 또는 이름] [명령어]
// 실행 중인 컨테이너 내부에 새로운 프로세스를 실행합니다.
// 예시 : Nginx 컨테이너에서 bash 셸을 실행하여 내부로 접속
docker exec -it web_server /bin/bash

The post Docker 백그라운드 실행 명령어 appeared first on 어제와 내일의 나 그 사이의 이야기.

Docker 포트 매핑 (Port Mapping)

Docker에서 포트 매핑은 컨테이너 내부에서 실행 중인 서비스의 포트와 호스트 컴퓨터(Docker가 설치된 머신)의 포트를 연결하는 중요한 기능입니다.

포트 매핑 왜 필요한가?

Docker 컨테이너는 기본적으로 격리된 환경에서 실행됩니다.

즉, 컨테이너 내부에 웹 서버가 80번 포트에서 동작하더라도, 외부에서는 이 포트에 직접 접근할 수 없습니다.

컨테이너는 자체적인 IP 주소를 가지고 있으며, 호스트 컴퓨터와는 다른 네트워크 환경에 있습니다.

포트 매핑의 역할

포트 매핑은 컨테이너의 특정 포트를 호스트 컴퓨터의 특정 포트로 터널링(tunneling)하는 역할을 합니다.

이를 통해 외부 사용자는 호스트 컴퓨터의 포트를 통해 컨테이너 내부의 서비스에 접근할 수 있게 됩니다.

간단한 예시

Nginx 웹 서버를 실행하는 컨테이너를 생각해봅시다.

Nginx는 기본적으로 80번 포트에서 동작합니다.

이 컨테이너에 외부에서 접근할 수 있도록 하려면 다음과 같이 포트 매핑을 설정할 수 있습니다.

Bash

docker run -p 8080:80 nginx

• -p:
  포트 매핑 옵션
• 8080:
  호스트 컴퓨터의 포트로 외부에서 http://[호스트 IP]:8080으로 접속
• 80:
  컨테이너 내부의 포트로 Nginx가 이 포트에서 대기
• nginx:
  사용할 Docker 이미지 이름

호스트 컴퓨터의 8080번 포트로 들어오는 모든 네트워크 요청은 Docker에 의해 컨테이너의 80번 포트로 전달됩니다.

이로써 외부 사용자는 http://localhost:8080 (만약 로컬에서 실행했다면)으로 접속하여 컨테이너 내부의 Nginx 웹 서버에 접근할 수 있게 됩니다.

요약

The post Docker Port Mapping(포트 매핑) appeared first on 어제와 내일의 나 그 사이의 이야기.

Docker에서 HTML 페이지 배포

기본적으로 웹 서버로 이동하여 HTML 페이지를 렌더링

웹 서버 nginx 이미지 가져오기

docker pull nginx

index.html 파일을 준비

<!DOCTYPE html>
<html lang="ko">
<head>
  <meta charset="UTF-8">
  <title>테스트 페이지</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      background-color: #f0f0f0;
      text-align: center;
      padding: 50px;
    }
    h1 {
      color: #333;
    }
    button {
      padding: 10px 20px;
      font-size: 16px;
    }
  </style>
</head>
<body>
  <h1>HTML 테스트 페이지</h1>
  <p>이 페이지는 테스트용으로 생성되었습니다.</p>
  <button onclick="alert('버튼이 클릭되었습니다!')">클릭해보세요</button>
</body>
</html>

nginx 이미지를 사용하여 Docker 컨테이너에 로드

Dockerfile 생성

도커파일은 확장자가 없음

FROM nginx
COPY ./SampleWebApp/ /usr/share/nginx/html

Dockerfile 이미지 생성

도커파일은 확장자가 없음

cd C:\Users\IKHO\Desktop\Docker 
// dockerfile 위치로 이동

ls 
// 파일 목록 확인

docker build -t sample_web_app:1.0.0 .
// docker build: 현재 디렉터리에 있는 Dockerfile을 기반으로 Docker 이미지를 만들라는 명령입니다.
// -t sample_web_app:1.0.0: 생성될 이미지의 이름과 태그를 지정합니다.
// sample_web_app이 이미지 이름
// 1.0.0은 버전 또는 태그 (나중에 버전별로 관리할 때 유용)

컨테이너를 생성 및 실행

docker run --name sample_web_app-container -p 9000:80 sample_web_app:1.0.0
// docker run   : 새로운 컨테이너를 생성하고 실행합니다
// --name sample_web_app-container   : 컨테이너의 이름을 sample_web_app-container로 설정합니다
// -p 9000:80   : 포트 매핑: 호스트의 9000 포트를 컨테이너의 80 포트에 연결합니다 (외부에서 localhost:9000으로 접근 가능)
// sample_web_app:1.0.0   : sample_web_app라는 이름과 1.0.0 태그가 붙은 이미지를 기반으로 컨테이너를 생성합니다



http://127.0.0.1:9000/

The post Docker에서 HTML 페이지 배포 appeared first on 어제와 내일의 나 그 사이의 이야기.

기본적인 Docker 명령어

docker --version

// Docker Hub에서 hello-world 이미지를 다운로드하는 명령어
docker pull hello-world

docker images

docker run hello-world

// 실행 중인 컨테이너 목록만 출력
docker ps

모든 컨테이너 목록 출력
// 중지된, 종료된, 에러 난 컨테이너도 포함해서 모두 보여줌
docker ps -a

docker ps // 컨테이너 확인
docker ps -a // 모든 컨테이너 확인
docker rm 5fea
docker rm 6c465
docker rm 0fe
docker rm 1957
docker ps -a // 모든 컨테이너 확인
docker images // 이미지 검색
docker rmi ec1538 // 이미지 제거

docker run -d ubuntu sleep 10

항목	의미
docker run	새로운 컨테이너를 생성하고 실행
-d	Detached mode → 백그라운드에서 실행
ubuntu	사용할 이미지 이름 (없으면 자동으로 Docker Hub에서 pull함)
sleep 10	컨테이너 내부에서 실행할 명령어 (10초 동안 대기)

.NET Image 추가

docker pull mcr.microsoft.com/dotnet/sdk:8.0
docker images

두 항목의 IMAGE ID가 동일
REPOSITORY: mcr.microsoft.com/dotnet/sdk
TAG: 9.0 → IMAGE ID: 08fe223b9022
TAG: latest → IMAGE ID: 08fe223b9022
이유: latest 태그는 별칭(alias) 이기 때문이다
도커에서 태그(TAG)는 특정 이미지 버전을 지칭하는 이름일 뿐이며, 동일한 이미지에 여러 개의 태그를 붙일 수 있습니다.
=> 9.0 버전의 이미지에 latest라는 이름을 추가로 붙여 놓은 것

The post 기본적인 Docker 명령어 연습 appeared first on 어제와 내일의 나 그 사이의 이야기.

현대 소프트웨어 개발에서 가상화 기술은 필수적인 요소입니다.

전통적인 가상머신(Virtual Machine)과 Docker 컨테이너 기술의 차이점을 알아봅니다.

• Infrastructure (물리적 하드웨어)
• Host OS (호스트 운영체제)
• Hypervisor (가상화 관리자)
• Guest OS (각 가상머신마다 독립된 운영체제)
• bins/lib (각 VM마다 독립된 바이너리/라이브러리)
• App 1, 2, 3 (애플리케이션들)

1. 아키텍처 비교

1.1 Virtual Machine 아키텍처

Virtual Machine은 다음과 같은 계층 구조를 가집니다:

특징:

• 각 가상머신은 독립된 Guest OS를 보유
• 하드웨어 가상화를 통한 완전한 격리
• Hypervisor가 하드웨어 리소스 관리

1.2 Docker 아키텍처

Docker는 다음과 같은 경량화된 구조를 가집니다:

특징:

• Guest OS 레이어 제거
• Host OS 커널 공유
• 컨테이너 단위의 프로세스 격리

2. 핵심 차이점 분석

2.1 운영체제 레이어

2.2 리소스 사용량

Virtual Machine

• 메모리: GB 단위 (OS + 애플리케이션)
• 디스크: 수 GB ~ 수십 GB
• CPU: OS 오버헤드 포함
• 네트워크: 가상 네트워크 스택

Docker

• 메모리: MB 단위 (애플리케이션만)
• 디스크: MB ~ GB 단위
• CPU: 최소한의 오버헤드
• 네트워크: Host 네트워크 스택 공유

2.3 성능 비교

3. 장단점 비교

3.1 Virtual Machine

장점

• 완전한 격리: 하드웨어 레벨의 보안 격리
• OS 다양성: 다양한 운영체제 동시 실행 가능
• 성숙한 기술: 오랜 기간 검증된 안정성
• 강력한 보안: 하이퍼바이저 레벨 보안

단점

• 높은 리소스 사용량: OS 오버헤드
• 느린 시작: 부팅 시간 필요
• 관리 복잡성: 각 VM의 OS 관리 필요
• 낮은 밀도: 제한적인 VM 수

3.2 Docker

장점

• 경량성: 최소한의 리소스 사용
• 빠른 시작: 초 단위 컨테이너 시작
• 높은 밀도: 단일 호스트에 많은 컨테이너
• 일관성: “한 번 빌드, 어디서든 실행”
• DevOps 친화적: CI/CD 파이프라인 최적화

단점

• 보안 취약점: 커널 공유로 인한 잠재적 위험
• OS 제약: Linux 컨테이너는 Linux에서만
• 복잡한 네트워킹: 컨테이너 간 통신 설정
• 데이터 지속성: 컨테이너 재시작 시 데이터 손실 위험

4. 사용 사례별 권장사항

4.1 Virtual Machine이 적합한 경우

기업 환경

• 레거시 애플리케이션 운영
• 서로 다른 OS가 필요한 환경
• 강력한 보안 격리가 필요한 경우
• 규제 준수가 중요한 산업

기술적 요구사항

• Windows와 Linux 애플리케이션 동시 운영
• 커널 수준의 소프트웨어 개발
• 완전한 네트워크 격리 필요
• 다양한 OS 버전 테스트

4.2 Docker가 적합한 경우

현대적 애플리케이션 개발

• 마이크로서비스 아키텍처
• 클라우드 네이티브 애플리케이션
• 지속적 통합/배포 (CI/CD)
• 개발 환경 표준화

운영 효율성

• 빠른 스케일링이 필요한 서비스
• 리소스 효율성이 중요한 환경
• 개발팀 간 환경 일관성
• 컨테이너 오케스트레이션 (Kubernetes)

5. 하이브리드 접근법

많은 조직에서는 두 기술을 함께 사용합니다:

5.1 VM 위의 Docker

• VM으로 기본 격리 제공
• VM 내에서 Docker로 애플리케이션 컨테이너화
• 보안과 효율성의 균형

5.2 클라우드 환경

• AWS ECS, Google Cloud Run 등
• 관리형 컨테이너 서비스
• 인프라 추상화

6. 결론

Virtual Machine과 Docker는 각각 고유한 장점과 적용 영역을 가지고 있습니다.

Virtual Machine은 강력한 격리와 다양한 OS 지원이 필요한 전통적인 엔터프라이즈 환경에 적합하며,

Docker는 현대적인 클라우드 네이티브 애플리케이션 개발과 운영에 최적화되어 있습니다.

성공적인 시스템 설계를 위해서는 각 기술의 특성을 정확히 이해하고, 프로젝트의 요구사항에 맞는 적절한 선택을 하는 것이 중요합니다.

많은 경우 두 기술을 적절히 조합하여 사용하는 하이브리드 접근법이 최적의 결과를 제공할 수 있습니다.

The post Docker / Virtual Machine 차이점 appeared first on 어제와 내일의 나 그 사이의 이야기.

Dependency Inversion Principle(DIP, 의존성 역전 원리)

https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/architectural-principles#dependency-inversion

The direction of dependency within the application should be in the direction of abstraction, not implementation details.
애플리케이션 내의 종속성 방향은 구현 세부 사항이 아닌 추상화 방향이어야 합니다.
Most applications are written such that compile-time dependency flows in the direction of runtime execution, producing a direct dependency graph.
대부분의 애플리케이션은 컴파일 타임 종속성이 런타임 실행 방향으로 흐르도록 작성되어 직접적인 종속성 그래프를 생성합니다.

That is, if class A calls a method of class B and class B calls a method of class C, then at compile time class A will depend on class B, and class B will depend on class C.
즉, class A가 class B의 메서드를 호출하고 class B가 class C의 메서드를 호출하는 경우 컴파일 타임에 class A는 class B에 종속되고 class B는 class C에 종속됩니다.

코드 구조에서 세부 구현 내용에 의존하지 말고, 더 추상적이고 일반적인 개념에 의존해야 한다는 뜻
이렇게 하면 코드가 더 유연해지고, 변경하기 쉽고, 재사용하기도 쉬워진다.
예를 들어, 어떤 기능을 직접 호출하는 것보다 그 기능을 일반적으로 설명하는 인터페이스를 사용하는 것이 더 좋다는 의미)

Applying the dependency inversion principle allows A to call methods on an abstraction that B implements, making it possible for A to call B at run time, but for B to depend on an interface controlled by A at compile time (thus, inverting the typical compile-time dependency).
종속성 반전 원칙을 적용하면 A가 B가 구현하는 추상화에 대한 메서드를 호출할 수 있으므로 A가 런타임에 B를 호출할 수 있지만 B는 컴파일 타임에 A에 의해 제어되는 인터페이스에 의존할 수 있습니다
(따라서 일반적인 컴파일 타임 종속성을 반전시킵니다). 

At run time, the flow of program execution remains unchanged, but the introduction of interfaces means that different implementations of these interfaces can easily be plugged in.
런타임에 프로그램 실행의 흐름은 변경되지 않지만 인터페이스의 도입은 이러한 인터페이스의 다른 구현을 쉽게 연결할 수 있음을 의미합니다.

Dependency inversion is a key part of building loosely coupled applications, since implementation details can be written to depend on and implement higher-level abstractions, rather than the other way around.
종속성 반전은 느슨하게 결합된 애플리케이션을 구축하는 데 있어 중요한 부분인데, 그 이유는 구현 세부 정보를 작성하여 더 높은 수준의 추상화에 의존하고 구현하도록 할 수 있기 때문입니다.

The resulting applications are more testable, modular, and maintainable as a result.
그 결과 응용 프로그램은 더 쉽게 테스트할 수 있고, 모듈화되며, 유지 관리가 더 용이합니다. 

The practice of dependency injection is made possible by following the dependency inversion principle.
종속성 주입의 연습은 종속성 반전 원칙을 따름으로써 가능합니다.

애플리케이션의 의존성을 구체적인 구현이 아니라 추상화된 개념에 맞추는 것

대부분의 애플리케이션은 A 클래스가 B 클래스를, B 클래스가 C 클래스를 호출하는 형태로 작성됩니다.

이는 A가 B에, B가 C에 의존하게 만든다는 뜻입니다. 종속성 반전 원칙을 적용하면 A는 B의 구체적인 구현이 아니라 B가 구현하는 추상 개념에 의존하게 됩니다.

이렇게 하면 코드를 더 쉽게 테스트할 수 있고, 변경 및 유지보수가 용이해집니다.

간단히 말해, 코드를 유연하고 재사용 가능하게 만들어줍니다.

종속성 반전 적용 전

// 엔진 클래스
public class Engine
{
    public void Start()
    {
        Console.WriteLine("Engine starts.");
    }
}

// 자동차 클래스
public class Car
{
    private Engine _engine = new Engine();

    public void Start()
    {
        _engine.Start();
        Console.WriteLine("Car starts.");
    }
}

// 메인 프로그램
public class Program
{
    public static void Main(string[] args)
    {
        Car car = new Car();
        car.Start();
    }
}

종속성 반전 적용 후

// 인터페이스 정의
public interface IEngine
{
    void Start();
}

// 엔진 클래스
public class Engine : IEngine
{
    public void Start()
    {
        Console.WriteLine("Engine starts.");
    }
}

// 전기 엔진 클래스
public class ElectricEngine : IEngine
{
    public void Start()
    {
        Console.WriteLine("Electric engine starts.");
    }
}

// 자동차 클래스
public class Car
{
    private IEngine _engine;

    public Car(IEngine engine)
    {
        _engine = engine;
    }

    public void Start()
    {
        _engine.Start();
        Console.WriteLine("Car starts.");
    }
}

// 메인 프로그램
public class Program
{
    public static void Main(string[] args)
    {
        IEngine engine = new Engine();
        Car car = new Car(engine);
        car.Start();
        
        IEngine electricEngine = new ElectricEngine();
        Car electricCar = new Car(electricEngine);
        electricCar.Start();
    }
}

The post Dependency Inversion Principle(DIP, 의존성 역전 원리) appeared first on 어제와 내일의 나 그 사이의 이야기.

https://azure.microsoft.com/ko-kr

The post Deploying ASP.NET Web API To Azure appeared first on 어제와 내일의 나 그 사이의 이야기.

Consuming REST Web APIs

1. 프로젝트 생성(MVC UI)

ASP.Net Core Web App (MVC)

2. GET Controller 생성

HttpClient 적용

.Net에서 제공하는 HttpClient Class

https://learn.microsoft.com/ko-kr/dotnet/api/system.net.http.httpclient?view=net-8.0

HTTP 요청을 보내고 URI로 식별된 리소스에서 HTTP 응답을 수신하기 위한 클래스를 제공합니다.

public class HttpClient : System.Net.Http.HttpMessageInvoker

사용 예제

// HttpClient는 매번 사용될 때마다 인스턴스화되지 않고, 애플리케이션 전체에서 한 번만 인스턴스화되어야 합니다. 참고 사항을 참조하세요.
static readonly HttpClient client = new HttpClient();

static async Task Main()
{
    // 비동기 네트워크 메서드를 try/catch 블록 내에서 호출하여 예외를 처리합니다.
    try
    {
        // 비동기적으로 GET 요청을 보냅니다.
        using HttpResponseMessage response = await client.GetAsync("http://www.contoso.com/");
        
        // 요청이 성공적으로 완료되었는지 확인합니다.
        response.EnsureSuccessStatusCode();
        
        // 응답 본문을 문자열로 읽어옵니다.
        string responseBody = await response.Content.ReadAsStringAsync();
        
        // 위의 세 줄은 아래 새로운 헬퍼 메서드로 대체할 수 있습니다.
        // string responseBody = await client.GetStringAsync(uri);
        
        // 응답 본문을 콘솔에 출력합니다.
        Console.WriteLine(responseBody);
    }
    catch (HttpRequestException e)
    {
        // 예외가 발생했을 때 예외 메시지를 콘솔에 출력합니다.
        Console.WriteLine("\nException Caught!");
        Console.WriteLine("Message :{0} ", e.Message);
    }
}

HttpClient를 사용하려면, Program.cs 파일에 HttpClient Factory를 설정

이를 통해 효율적으로 HttpClient 인스턴스를 관리하고, 특히 성능 문제를 해결할 수 있음

Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

// HttpClient 삽입
builder.Services.AddHttpClient();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // 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.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        // Index 액션 메서드
        public async Task<IActionResult> Index()
        {
            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();
                
                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");
                
                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();
                
                // 응답 본문을 문자열로 읽어옴
                var stringResponse = await httpResponseMessage.Content.ReadAsStringAsync();
                
                // 응답 내용을 ViewBag에 저장
                ViewBag.Response = stringResponse;
                
                // 응답 메시지를 반환
                return Ok(httpResponseMessage);
            }
            catch (Exception ex)
            {
                // 예외를 로깅 (로그 기록)
            }
            
            // View를 반환
            return View();
        }
    }
}

3. Index.cshtml , _Layout.cshtml 생성 및 수정

Index.cshtml

@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}

<h1 class="mt-3">Regions</h1>

@if (ViewBag.Respose is not null)
{
    <p>ViewBag.Respose</p>
}

_Layout.cshtml

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>@ViewData["Title"] - NZWalksUI</title>
    <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css" />
    <link rel="stylesheet" href="~/css/site.css" asp-append-version="true" />
    <link rel="stylesheet" href="~/NZWalksUI.styles.css" asp-append-version="true" />
</head>
<body>
    <header>
        <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
            <div class="container-fluid">
                <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">NZWalksUI</a>
                <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent"
                        aria-expanded="false" aria-label="Toggle navigation">
                    <span class="navbar-toggler-icon"></span>
                </button>
                <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                    <ul class="navbar-nav flex-grow-1">
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Regions" asp-action="Index">Regions</a>
                        </li>
                    </ul>
                </div>
            </div>
        </nav>
    </header>
    <div class="container">
        <main role="main" class="pb-3">
            @RenderBody()
        </main>
    </div>

    <footer class="border-top footer text-muted">
        <div class="container">
            &copy; 2024 - NZWalksUI - <a asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
        </div>
    </footer>
    <script src="~/lib/jquery/dist/jquery.min.js"></script>
    <script src="~/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
    <script src="~/js/site.js" asp-append-version="true"></script>
    @await RenderSectionAsync("Scripts", required: false)
</body>
</html>

4. RegionDto.cs 생성 및 Index.cshtml 적용

RegionDto.cs

namespace NZWalksUI.Models.DTO
{
    public class RegionDto
    {
        public Guid Id { get; set; }
        public string Code { get; set; }
        public string Name { get; set; }
        public string? RegionImageUrl { get; set; } // Nullable
    }
}

Index.cshtml

@model IEnumerable<NZWalksUI.Models.DTO.RegionDto> <!-- 뷰 모델을 IEnumerable<RegionDto>로 설정 -->

@* MVC를 빈 프로젝트에 대해 활성화하는 방법에 대한 추가 정보는 https://go.microsoft.com/fwlink/?LinkID=397860를 참조 *@

@{} <!-- 블록 코드, 현재 비어 있음 -->

<h1 class="mt-3">Regions</h1> <!-- 페이지 제목 -->

<table>
    <thead>
        <tr>
            <th>Id</th> <!-- Id 열 -->
            <th>Code</th> <!-- Code 열 -->
            <th>Name</th> <!-- Name 열 -->
        </tr>
    </thead>
    <tbody>
        @foreach (var walk in Model) <!-- Model을 반복하여 각 walk에 대해 테이블 행 생성 -->
        {
            <tr>
                <th>@walk.Id</th> <!-- 현재 walk의 Id 표시 -->
                <th>@walk.Code</th> <!-- 현재 walk의 Code 표시 -->
                <th>@walk.Name</th> <!-- 현재 walk의 Name 표시 -->
            </tr>
        }
    </tbody>
</table>

5. POST Method 생성

Index.cshtml 수정

@model IEnumerable<NZWalksUI.Models.DTO.RegionDto>
@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}

<h1 class="mt-3">Regions</h1>

<div class="d-flex justify-content-end">
    <a class="btn btn-secondary" asp-controller="Regions" asp-action="Add">Add Region</a>
</div>


<table class="table-bordered">
    <thead>
        <tr>
            <th>Id</th>
            <th>Code</th>
            <th>Name</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var walk in Model)
        {
            <tr>
                <td>@walk.Id</td>
                <td>@walk.Code</td>
                <td>@walk.Name</td>
            </tr>
        }
    </tbody>
</table>

AddRegionViewModel.cs 생성

namespace NZWalksUI.Models
{
    public class AddRegionViewModel
    {
        public string Code { get; set; }
        public string Name { get; set; }
        public string RegionImageUrl { get; set; }
    }
}

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;
using NZWalksUI.Models;
using NZWalksUI.Models.DTO;
using System.Net.Http;
using System.Text;
using System.Text.Json;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        [HttpGet]
        // Index 액션 메서드
        public async Task<IActionResult> Index()
        {
            List<RegionDto> response = new List<RegionDto>();
            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();

                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");

                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();

                // 응답 본문을 JSON으로 읽어와 리스트에 추가
                response.AddRange(await httpResponseMessage.Content.ReadFromJsonAsync<IEnumerable<RegionDto>>());
            }
            catch (HttpRequestException e)
            {
                // 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"Request error: {e.Message}");
            }
            catch (Exception ex)
            {
                // 기타 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"An error occurred: {ex.Message}");
            }

            // View를 반환
            return View(response);
        }

        [HttpGet]
        public IActionResult Add()
        {
            return View(); // Add View 반환
        }

        [HttpPost]
        public async Task<IActionResult> Add(AddRegionViewModel model)
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri("https://localhost:7256/api/regions"),
                Content = new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json") // JSON 요청 본문 설정
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode(); // 요청이 성공적으로 완료되었는지 확인

            var response = await httpResponseMessage.Content.ReadFromJsonAsync<RegionDto>();

            if (response is not null)
            {
                return RedirectToAction("Index", "Regions"); // Index 액션으로 리디렉션
            }

            return View(); // View 반환
        }
    }
}

Add.cshtml

@model NZWalksUI.Models.AddRegionViewModel;

@*
*@

@{
}

<h1 class="mt-3">Add Region</h1>

<form method="post">

    <div class="mt-3">
        <label class="form-label">Code</label>
        <input type="text" class="form-control" asp-for="Code" />
    </div>

    <div class="mt-3">
        <label class="form-label">Name</label>
        <input type="text" class="form-control" asp-for="Name" />
    </div>

    <div class="mt-3">
        <label class="form-label">Image URL</label>
        <input type="text" class="form-control" asp-for="RegionImageUrl" />
    </div>

    <div class="mt-3">
        <button type="submit" class="btn btn-primary">Save</button>
    </div>

</form>

6. 단일 편집 기능

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;
using NZWalksUI.Models;
using NZWalksUI.Models.DTO;
using System.Net.Http;
using System.Text;
using System.Text.Json;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        [HttpGet]
        // Index 액션 메서드
        public async Task<IActionResult> Index()
        {
            List<RegionDto> response = new List<RegionDto>();


            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();

                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");
               

                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();

                // // 응답 본문을 문자열로 읽어옴
                // var stringResponse = await httpResponseMessage.Content.ReadAsStringAsync();


                response.AddRange(await httpResponseMessage.Content.ReadFromJsonAsync<IEnumerable<RegionDto>>());

            }
            catch (HttpRequestException e)
            {
                // 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"Request error: {e.Message}");
            }
            catch (Exception ex)
            {
                // 기타 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"An error occurred: {ex.Message}");
            }

            // View를 반환
            return View(response);
        }

        [HttpGet]
        public IActionResult Add()
        { 
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Add(AddRegionViewModel model)
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri("https://localhost:7256/api/regions"),
                Content = new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync<RegionDto>();

            if (respose is not null)
            {
                return RedirectToAction("Index", "Regions");
            }

            return View();
        }

        [HttpGet]
        public async Task<IActionResult> Edit(Guid id)
        {
            ViewBag.Id = id;
            return View();
        
        }
    }
}

Edite View 생성

Edit.cshtml

@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}

<h1 class="mt-3">Edit Region</h1>

<p>
    @ViewBag.Id
</p>

Index.cshtml 수정

@model IEnumerable<NZWalksUI.Models.DTO.RegionDto>
@*
    For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
*@
@{
}

<h1 class="mt-3">Regions</h1>

<div class="d-flex justify-content-end">
    <a class="btn btn-secondary" asp-controller="Regions" asp-action="Add">Add Region</a>
</div>


<table class="table-bordered">
    <thead>
        <tr>
            <th>Id</th>
            <th>Code</th>
            <th>Name</th>
            <th> </th>
        </tr>
    </thead>
    <tbody>
        @foreach (var walk in Model)
        {
            <tr>
                <td>@walk.Id</td>
                <td>@walk.Code</td>
                <td>@walk.Name</td>
                <td>
                    <a asp-controller="Regions" asp-action="Edit" asp-route-id="@walk.Id" 
                    class="btn btn-light">Eidt</a>
                </td>
            </tr>
        }
    </tbody>
</table>

Error.cshtml 수정

@model NZWalksUI.Models.DTO.RegionDto

@{
}

<h1 class="mt-3">Edit Region</h1>

@if (Model is not null)
{
    <form method="post">
        <div class="mt-3">
            <label class="form-label">Id</label>
            <input type="text" class="form-control" asp-for="Id"  readonly/>
        </div>
        <div class="mt-3">
            <label class="form-label">Code</label>
            <input type="text" class="form-control" asp-for="Code" />
        </div>

        <div class="mt-3">
            <label class="form-label">Name</label>
            <input type="text" class="form-control" asp-for="Name" />
        </div>

        <div class="mt-3">
            <label class="form-label">Image URL</label>
            <input type="text" class="form-control" asp-for="RegionImageUrl" />
        </div>

        <div class="mt-3">
            <button type="submit" class="btn btn-primary">Save</button>
        </div>

    </form>
}

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;
using NZWalksUI.Models;
using NZWalksUI.Models.DTO;
using System.Net.Http;
using System.Reflection;
using System.Text;
using System.Text.Json;
using static System.Net.WebRequestMethods;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        [HttpGet]
        // Index 액션 메서드
        public async Task<IActionResult> Index()
        {
            List<RegionDto> response = new List<RegionDto>();


            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();

                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");
               

                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();

                // // 응답 본문을 문자열로 읽어옴
                // var stringResponse = await httpResponseMessage.Content.ReadAsStringAsync();


                response.AddRange(await httpResponseMessage.Content.ReadFromJsonAsync<IEnumerable<RegionDto>>());

            }
            catch (HttpRequestException e)
            {
                // 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"Request error: {e.Message}");
            }
            catch (Exception ex)
            {
                // 기타 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"An error occurred: {ex.Message}");
            }

            // View를 반환
            return View(response);
        }

        [HttpGet]
        public IActionResult Add()
        { 
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Add(AddRegionViewModel model)
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri("https://localhost:7256/api/regions"),
                Content = new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync<RegionDto>();

            if (respose is not null)
            {
                return RedirectToAction("Index", "Regions");
            }

            return View();
        }

        [HttpGet]
        public async Task<IActionResult> Edit(Guid id)
        {
            var client = httpClientFactory.CreateClient();

            var response = await client.GetFromJsonAsync<RegionDto>($"https://localhost:7256/api/regions/{id.ToString()}");

            if (response is not null) 
            { 
                return View(response);
            }

            return View(null);
        
        }

        [HttpPost]
        public async Task<IActionResult> Edit(RegionDto request) 
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Put,
                RequestUri = new Uri($"https://localhost:7256/api/regions/{request.Id}"),
                Content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync<RegionDto>();

            if (respose is not null)
            {
                return RedirectToAction("Edit", "Regions");
            }

            return View();
        }

    }
}

7. 삭제 기능

Edit.cshtml 수정

@model NZWalksUI.Models.DTO.RegionDto

@{
}

<h1 class="mt-3">Edit Region</h1>

@if (Model is not null)
{
    <form method="post">
        <div class="mt-3">
            <label class="form-label">Id</label>
            <input type="text" class="form-control" asp-for="Id"  readonly/>
        </div>
        <div class="mt-3">
            <label class="form-label">Code</label>
            <input type="text" class="form-control" asp-for="Code" />
        </div>

        <div class="mt-3">
            <label class="form-label">Name</label>
            <input type="text" class="form-control" asp-for="Name" />
        </div>

        <div class="mt-3">
            <label class="form-label">Image URL</label>
            <input type="text" class="form-control" asp-for="RegionImageUrl" />
        </div>

        <div class="mt-3 d-flex justify-content-between">
            <button type="submit" class="btn btn-primary">Save</button>
            <button type="submit" asp-controller="Regions" asp-action="Delete" class="btn btn-danger">Delete</button>
        </div>

    </form>
}

RegionsController.cs 수정

using Microsoft.AspNetCore.Mvc;
using NZWalksUI.Models;
using NZWalksUI.Models.DTO;
using System.Text;
using System.Text.Json;

namespace NZWalksUI.Controllers
{
    public class RegionsController : Controller
    {
        private readonly IHttpClientFactory httpClientFactory;

        // Http 클라이언트 팩토리를 삽입하기 위한 생성자를 생성
        public RegionsController(IHttpClientFactory httpClientFactory)
        {
            this.httpClientFactory = httpClientFactory;
        }

        [HttpGet]
        // Index 액션 메서드
        public async Task<IActionResult> Index()
        {
            List<RegionDto> response = new List<RegionDto>();


            try
            {
                // Get All Regions From Web API
                // 새로운 Http 클라이언트가 생성
                var client = httpClientFactory.CreateClient();

                // Web API로 GET 요청을 보냄
                var httpResponseMessage = await client.GetAsync("https://localhost:7256/api/regions");
               

                // 요청이 성공적으로 완료되었는지 확인
                httpResponseMessage.EnsureSuccessStatusCode();

                // // 응답 본문을 문자열로 읽어옴
                // var stringResponse = await httpResponseMessage.Content.ReadAsStringAsync();


                response.AddRange(await httpResponseMessage.Content.ReadFromJsonAsync<IEnumerable<RegionDto>>());

            }
            catch (HttpRequestException e)
            {
                // 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"Request error: {e.Message}");
            }
            catch (Exception ex)
            {
                // 기타 예외 발생 시 예외 메시지를 로그로 기록
                Console.WriteLine($"An error occurred: {ex.Message}");
            }

            // View를 반환
            return View(response);
        }

        [HttpGet]
        public IActionResult Add()
        { 
            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Add(AddRegionViewModel model)
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Post,
                RequestUri = new Uri("https://localhost:7256/api/regions"),
                Content = new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync<RegionDto>();

            if (respose is not null)
            {
                return RedirectToAction("Index", "Regions");
            }

            return View();
        }

        [HttpGet]
        public async Task<IActionResult> Edit(Guid id)
        {
            var client = httpClientFactory.CreateClient();

            var response = await client.GetFromJsonAsync<RegionDto>($"https://localhost:7256/api/regions/{id.ToString()}");

            if (response is not null) 
            { 
                return View(response);
            }

            return View(null);
        
        }

        [HttpPost]
        public async Task<IActionResult> Edit(RegionDto request) 
        {
            var client = httpClientFactory.CreateClient();

            var httpRequestMessage = new HttpRequestMessage()
            {
                Method = HttpMethod.Put,
                RequestUri = new Uri($"https://localhost:7256/api/regions/{request.Id}"),
                Content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json")
            };

            var httpResponseMessage = await client.SendAsync(httpRequestMessage);
            httpResponseMessage.EnsureSuccessStatusCode();

            var respose = await httpResponseMessage.Content.ReadFromJsonAsync<RegionDto>();

            if (respose is not null)
            {
                return RedirectToAction("Edit", "Regions");
            }

            return View();
        }

        [HttpPost]
        public async Task<IActionResult> Delete(RegionDto request)
        {
            try 
            {
                var client = httpClientFactory.CreateClient();

                var httpResponseMessage = await client.DeleteAsync($"https://localhost:7256/api/regions/{request.Id}");
                httpResponseMessage.EnsureSuccessStatusCode();

                return RedirectToAction("Index", "Regions");

            }
            catch (Exception ex) 
            { 
            
            }

            return View("Edit");
        }

    }
}

The post Consuming REST Web APIs appeared first on 어제와 내일의 나 그 사이의 이야기.