회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

차오름소프트는 다양한 산업군에서 실제 적용된 임베디드 기반 솔루션을 직접 개발·납품해온 기술 중심의 IT 기업입니다. 당사는 다수의 프로젝트를 통해 하드웨어와 소프트웨어를 유기적으로 연결하며, 고객 맞춤형 시스템을 성공적으로 구축해왔습니다.

실전 프로젝트로 증명된 임베디드 기술 역량

당사가 수행한 프로젝트는 단순한 시제품 수준이 아닌, 실제 고객 현장에 도입되어 운영 중인 고도화된 시스템입니다. 다음은 최근 납품 및 구축한 대표적인 사례입니다:

• RFID 기반 자동 출입 관리 시스템
• 산업용 패널 PC 연동 검사 시스템
• 계측기 연동 테스트 시퀀스 제어 프로그램
• ARM 보드 기반 영상 및 통신 제어 시스템
• 센서 데이터 수집 및 시각화 소프트웨어
• PLC 연동 검사 장비 제어 프로그램
• 로컬 장비 제어 및 상태 모니터링 시스템

이러한 프로젝트들은 C#, .NET, WPF, XAML 기반의 소프트웨어와 임베디드 하드웨어를 직접 연동한 결과물로, 시리얼 통신(RS232/RS485), TCP/IP, USB, 센서 모듈, PLC 등 다양한 인터페이스에 대한 실무 경험을 포함합니다.

고객 맞춤형 UI/UX와 통합 시스템 제공

각 프로젝트마다 UI/UX의 목적과 사용 환경이 달랐기에, 당사는 사용자 중심의 인터페이스 설계 또한 중시합니다. WPF 기반의 HMI(휴먼 머신 인터페이스), 운영자 모니터링 화면, 관리자 설정 기능 등 현장 사용자를 고려한 소프트웨어 설계에 집중해왔습니다.

또한, 단일 장비 제어를 넘어 전체 라인 제어 시스템 또는 클라우드 연동까지 아우르는 통합 시스템 구축도 가능하며, Azure IoT, 내부 DB 연동, 로그 관리 시스템 등 확장형 구조로 대응할 수 있습니다.

다양한 산업군에서 검증된 신뢰성

차오름소프트의 임베디드 솔루션은 제조, 검사, 품질관리, 물류, IoT 분야 등 다양한 산업 영역에서 적용되어 왔습니다. 프로젝트 수행 시 항상 현장 중심의 기술 적용과 정확한 요구사항 분석을 통해 완성도 높은 결과물을 제공해왔습니다.

함께 성장할 수 있는 기술 파트너

기술력은 결과로 말합니다. 차오름소프트는 단순 개발 대행을 넘어, 고객의 업무 효율 향상과 기술 경쟁력 확보를 위한 실질적인 파트너가 되고자 합니다.

임베디드 시스템 및 장비 제어 소프트웨어 개발이 필요하신가요? 지금 차오름소프트와 상담해보십시오.

포트폴리오 보기

https://www.chaoreumsoft.co.kr/bbs/board.php?bo_table=gallery&sca=%EC%9E%84%EB%B2%A0%EB%94%94%EB%93%9C

회사소개서 바로가기

포트폴리오 바로가기     

IT 기술이 단순한 소프트웨어 구현을 넘어, 물리적 장비 및 하드웨어와의 통합을 통해 실질적인 기능을 수행하는 방향으로 발전하고 있습니다.

당사는 다년간의 현장 경험을 바탕으로, 다양한 하드웨어 시스템과의 연동을 고려한 소프트웨어 개발 역량을 보유하고 있으며, 실제 운영 환경에서 안정적으로 작동하는 시스템 구축을 강점으로 합니다.

1. 다양한 하드웨어 연동 경험

• 산업용 센서 (온도, 압력, 진동 등)
• RFID/바코드 스캐너, 시리얼 통신 장비 (RS232/RS485)
• PLC 제어 시스템 및 장비 인터페이스
• 임베디드 보드 (ARM 기반 보드, Raspberry Pi 등)
• IoT 디바이스 및 게이트웨이
• 터치 패널, 키오스크, POS 시스템 등

2. 연동 기술 및 개발 방식

• C#, .NET 기반으로 하드웨어 통신 모듈 직접 구현
• WPF/XAML을 통한 HMI(휴먼 머신 인터페이스) 설계
• Serial, TCP/IP, USB 통신 프로토콜 대응
• 센서 데이터 수집 → 실시간 시각화/알람 처리/로깅 기능 구현
• Azure IoT Hub 등 클라우드 연동 구조 설계 및 배포
• 장비 제어/모니터링 소프트웨어 다수 구축 경험

3. 하드웨어-소프트웨어 통합에 강한 이유

하드웨어와의 통신은 단순한 코드 구현이 아닌, 현장 이해력과 실시간 처리 구조에 대한 경험이 반드시 필요합니다.

당사는 실제 하드웨어 환경에서 발생할 수 있는 다양한 상황(노이즈, 패킷 누락, 응답 지연 등)을 고려하여,

안정적이고 오류에 강한 소프트웨어 구조를 설계하고 있으며, 고객 맞춤형 시스템을 구현할 수 있는 기술 기반을 갖추고 있습니다.

신뢰할 수 있는 통합 기술 파트너

당사의 기술력은 단순히 '소프트웨어만 잘 만드는 회사'가 아닌,

하드웨어 환경을 이해하고 실무에 최적화된 통합 시스템을 구현할 수 있는 역량으로 차별화됩니다.

제어 시스템, 현장 장비, 스마트 디바이스 등 다양한 하드웨어 기반 프로젝트에 대응해온 경험을 바탕으로,

고객사의 요구에 정확히 부합하는 안정적인 솔루션을 제공하겠습니다.

회사소개서 바로가기

포트폴리오 바로가기     

당사의 소프트웨어 기술 역량을 소개합니다.

IT 산업의 발전은 빠르게 이루어지고 있으며, 기업의 디지털 경쟁력은 기술적 기반 위에서 결정됩니다.

당사는 다양한 산업군의 요구사항을 충족할 수 있는 실질적인 소프트웨어 개발 역량을 보유하고 있으며, 

다음과 같은 기술을 바탕으로 안정적이고 확장 가능한 시스템 구축을 제공하고 있습니다.

1. C# 및 .NET 기반 개발 역량

당사는 C# 언어에 대한 깊은 이해와 실무 경험을 바탕으로, 안정성과 생산성이 높은 소프트웨어를 개발하고 있습니다.

특히, .NET Core 기반의 애플리케이션 개발에 강점을 가지고 있으며, 다양한 플랫폼에서 구동 가능한 크로스 플랫폼 애플리케이션을 구현할 수 있습니다.

2. WPF 및 XAML을 활용한 데스크톱 애플리케이션 개발

고도화된 사용자 경험이 요구되는 환경에서는 Windows Presentation Foundation(WPF) 기반의 UI/UX 설계를 통해 차별화된 사용자 인터페이스를 제공합니다.XAML 마크업 언어를 활용한 레이아웃 설계로, 유지보수와 확장성 측면에서도 우수한 구조를 확보하고 있습니다.

3. ASP.NET Core 기반 웹 애플리케이션 개발

경량화와 고성능이 중요한 웹 환경에서는 ASP.NET Core 프레임워크를 활용하여, 빠르고 안전한 웹 서비스를 구현하고 있습니다.

RESTful API 설계, 인증/인가 시스템 통합, 웹 보안 대응 등 다양한 웹 서비스 구축 경험을 보유하고 있으며, 기업 맞춤형 웹 플랫폼을 안정적으로 제공합니다.

4. Microsoft Azure 기반 클라우드 시스템 설계

클라우드 환경에 최적화된 개발을 위해 Microsoft Azure를 적극 활용하고 있습니다.

가상 머신, 데이터베이스, 앱 서비스, DevOps 파이프라인 등 다양한 Azure 기능을 통해 유연한 시스템 아키텍처를 설계하며, 고객사의 비즈니스 환경에 맞춘 클라우드 전략을 수립합니다.

5. Linux 기반의 시스템 운영 및 환경 구성

당사는 Windows 기반뿐 아니라 Linux 환경에서도 다양한 서버 애플리케이션 및 백엔드 시스템을 운영할 수 있는 기술력을 갖추고 있습니다.

시스템 구성 자동화, 보안 설정, 배포 환경 최적화 등 인프라 전반에 걸친 실무 경험을 통해 안정적인 서비스 운영이 가능합니다.

회사소개서 바로가기

포트폴리오 바로가기     

최근 SI(System Integration) 기업들이 수익성을 높이고 경쟁 우위를 확보하기 위해 아웃소싱을 적극적으로 도입하고 있습니다. 

단순히 비용 절감 수단으로만 여겨지던 아웃소싱이 이제는 전문가 확보, 프로젝트 리스크 완화, 조직의 유연성 확보 등 다양한 이점을 통해 기업 가치 극대화의 주요 전략으로 떠오르고 있습니다. 

본 글에서는 SI 기업이 아웃소싱을 효율적으로 활용하여 안정적인 수익 기반을 마련하고, 장기적으로 경쟁력을 강화하는 방법에 대해 살펴보겠습니다.

1. SI 기업에서 아웃소싱이 필요한 이유

1) 전문 인력 부족과 인건비 절감

IT 시장 환경이 급변함에 따라 특정 기술을 보유한 전문가의 수요가 점점 늘어나고 있습니다. SI 기업은 특정 기술 스택이나 경험이 필요한 프로젝트에 맞춰 인력을 채용하기가 쉽지 않습니다. 이럴 때 아웃소싱은 즉각적으로 전문 인력을 확보할 수 있는 효과적인 솔루션이 됩니다.

인건비 절감: 

프로젝트 단위로 필요한 인력을 빠르게 투입할 수 있어 고정비 부담이 줄어듭니다.

최적화된 팀 구성: 

필요한 기술에 맞춰 전문성이 검증된 외부 인력을 유연하게 배치할 수 있어 결과물의 품질도 높일 수 있습니다.

2) 프로젝트 리스크 분산과 효율적인 자원 활용

SI 프로젝트는 규모가 크고 복잡도가 높아, 기획부터 개발, 테스트, 운영 및 유지보수 단계에 이르는 전 과정에서 다양한 리스크가 내재합니다.

리스크 분산: 

특정 영역을 아웃소싱 함으로써 기업 내부 자원에만 의존하지 않고, 외부 전문 업체의 역량과 프로세스를 활용하여 프로젝트 리스크를 분산시킬 수 있습니다.

핵심 역량 집중: 

기업 내부 팀은 기획, 프로젝트 관리, 품질 관리 등 전략적 가치가 높은 업무에 집중하고, 단순 반복적 혹은 비핵심 영역은 외부 전문가에게 맡겨 효율적인 자원 분배가 가능합니다.

3) 최신 기술 트렌드와 빠른 시장 대응

IT 기술은 끊임없이 발전하고 있으며, 신기술 학습과 적용은 기업 경쟁력의 핵심 요소입니다.

신기술 도입 가속화:

아웃소싱 파트너는 여러 클라이언트와 다양한 프로젝트를 경험하기 때문에, 보다 신속하게 트렌드를 파악하고 새로운 기술을 적용할 수 있는 역량을 지닙니다.

시장 대응 속도 향상: 

신기술 요구가 잦은 시장 환경에서, 기업 내부에서 모든 역량을 단기간에 확보하기는 쉽지 않습니다. 외부 전문 업체와의 협업을 통해 필요한 기술과 노하우를 빠르게 도입함으로써 시장 변화에 유연하게 대응할 수 있습니다.

2. 아웃소싱 성공을 위한 실무 전략

1) 명확한 요구사항 정의와 커뮤니케이션 구조 수립

아웃소싱을 통한 프로젝트 추진에서 가장 중요한 것은 명확한 요구사항 정의입니다.

​목표와 범위 구체화: 

프로젝트 목적, 목표, 핵심 기능, 예산, 일정 등을 구체적으로 문서화해 두어야 합니다.

커뮤니케이션 채널 명확화: 

요구사항 조정, 일정 공유, 진행 상황 보고 등을 위한 소통 방식을 미리 확립하고 담당자를 지정해야 합니다(예: Slack, 이메일, 주간 미팅 등).

2) 파트너 선정 기준 강화와 협상

효율적인 아웃소싱을 위해서는 파트너 선정이 무엇보다 중요합니다.

기술 역량 및 관련 레퍼런스 검증: 단순 스펙뿐 아니라 실제 유사 프로젝트 경험이 있는지를 확인해야 합니다.

문화적 적합성: 

장기적 관점에서는 기업 문화, 조직 가치, 프로젝트 관리 방식이 얼마나 잘 맞는지도 고려되어야 합니다.

지속적인 협력 관계 구축: 

단순히 계약 단위로 끝나는 것이 아니라, 장기적 파트너십 관점에서 협상하고 관계를 유지하면 프로젝트 완성도와 효율이 높아집니다.

3) 품질 및 성과 관리 프로세스 정립

아웃소싱 파트너에게 일부 업무를 맡기더라도, 기업은 최종 산출물에 대한 책임을 피할 수 없습니다.

정기적인 진행 상황 모니터링: 

성과 지표(KPI)를 설정하고, 일정 간격으로 진행 상황을 점검하여 이슈가 발생하기 전에 대응해야 합니다.

품질 관리와 테스트 전략: 

QA(Quality Assurance), 테스트 자동화 도입 등 품질 관리 프로세스를 체계화하여 외부 인력이 만든 결과물도 기업 표준에 부합하게끔 관리해야 합니다.

4) 유연한 계약 구조와 성과 보상 시스템

아웃소싱 계약에서는 고정형(Fixed Price)인지, 시간·자원 기반(Time & Materials)인지, 혹은 혼합형(Hybrid)인지에 따라 리스크와 이점이 다릅니다.

장기적인 파트너십 지향: 

프로젝트 규모와 성격에 따라 고정형 계약과 유연한 협상 방식을 병행하되, 파트너의 성과 창출에 따른 인센티브 구조를 설계하는 것도 고려해볼 수 있습니다.

성과 공유 모델: 

공동 사업 형태 혹은 기술 로열티 형태의 모델을 추가로 설계해, 상호 협력 시 추가 이익이 돌아갈 수 있는 구조도 점진적으로 확대되고 있습니다.

3. 아웃소싱을 통한 장기적 수익 모델 확보

1) 유지보수 및 운영 서비스 확대

SI 기업은 아웃소싱 관계를 통해 확보한 전문 인력과 노하우를 활용해 단순 프로젝트 납품에 그치지 않고, 운영 및 유지보수 서비스로 비즈니스 범위를 확장할 수 있습니다.

예측 유지보수와 서비스형 사업모델: 

클라우드, SaaS(Software as a Service), PaaS(Platform as a Service) 등이 확대되면서, 아웃소싱 파트너와 함께 운영/유지보수 체계를 고도화해 안정적인 수익을 창출할 수 있는 환경이 마련되고 있습니다.

2) 자체 솔루션 개발 및 라이선스 전략

아웃소싱을 통해 프로젝트 다수를 진행하면서 축적한 노하우를 바탕으로 자체 솔루션을 개발하고, 해당 솔루션을 라이선스로 판매하거나 서비스 형태로 제공하는 전략도 유효합니다.

지식 자산화: 

프로젝트 진행 중 개발된 특정 모듈이나 기능을 범용화하여 기업의 지적 자산으로 만들어 두면, 다양한 고객사에 재활용 가능합니다.

라이선스 수익:

솔루션에 대한 라이선스 계약을 통해 안정적인 캐시플로를 만들 수 있으며, 이를 통해 연구개발(R&D) 재투자가 가능해집니다.

3) IT 컨설팅 및 고부가가치 서비스 제공

단순 개발·구현 업무를 넘어, SI 기업이 컨설팅 영역으로 확장하여 고부가가치 서비스를 제공하는 사례가 늘어나고 있습니다. 비즈니스 프로세스 혁신(BPR), 디지털 트랜스포메이션(DT) 등의 분야로 발전 시킬 수 있으며, 외부 전문 업체와 협업해 기업 고객의 전체적 디지털 전략 수립에 참여할 수 있습니다.

새로운 수익 모델: 

단순한 외주 개발이 아니라, 자사의 경험과 업계 인사이트를 결합한 ‘통합 컨설팅 패키지’를 제공함으로써 프로젝트 가치와 이익을 동시에 높일 수 있습니다.

4. 아웃소싱을 넘어 지속 가능한 파트너십으로

SI 기업에서 아웃소싱은 더 이상 선택이 아닌 필수 전략으로 자리 잡았습니다. 그러나 단순히 비용 절감이나 인력 부족 해소를 위한 임시방편으로 접근하면, 장기적으로 시장에서의 경쟁 우위를 유지하기 어려울 수 있습니다. 지속 가능한 파트너십 관점에서 접근해야 하며, 다음 요소를 주의 깊게 살펴야 합니다.

협력과 상생: 

파트너의 기술력과 노하우를 인정하고, 성과를 공유하는 방안을 마련해 상호 간 ‘윈-윈’ 구조를 형성해야 합니다.

투명한 소통: 

정기적으로 정보를 공유하고, 문제 발생 시 적극적으로 해결책을 모색하는 커뮤니케이션 문화를 구축해야 합니다.

장기 비전 공감: 

단기적인 프로젝트 성공만이 아니라, 기업 전체의 성장 전략과 비전을 파트너와 공유함으로써 장기적 관계의 가치를 높일 수 있습니다.

맺음말

SI 기업에서의 아웃소싱은 단순한 외주 협력 이상의 의미를 지니고 있습니다. 급변하는 시장 환경 속에서 기술 경쟁력을 갖추고, 전문 인력을 효율적으로 운영하며, 리스크를 낮추는 데 있어 아웃소싱은 필수적인 성장 동력입니다.

하지만 성공적인 아웃소싱을 위해서는 명확한 목표 설정, 신뢰할 만한 파트너 선정, 지속적인 품질 관리, 그리고 협력 관계의 장기적 유지가 중요합니다. 

이를 통해 SI 기업은 안정적인 수익 기반을 마련하고, 프로젝트 전 과정에서 탄탄한 경쟁력을 갖출 수 있게 됩니다.

나아가 아웃소싱을 통해 확보한 역량과 데이터를 적극적으로 내재화하고, 자체 솔루션 개발이나 컨설팅 서비스 등 고부가가치 비즈니스로 확장함으로써 미래 지향적인 IT 생태계를 선도하는 기업으로 성장할 수 있을 것입니다.

OpenCV (Computer Vision Library) 

직렬화는 객체 데이터를 바이트 배열로 변환하는 과정이고, 역직렬화는 바이트 배열을 다시 객체 데이터로 변환하는 과정입니다. 

ZeroFormatter는 이 과정을 매우 빠르고 효율적으로 수행하도록 설계되어 있습니다.  

▶ 주요 특징

빠른 성능

ZeroFormatter는 .NET 직렬화 라이브러리 중 하나로, 매우 빠른 성능을 제공합니다. 특히 큰 데이터를 다룰 때 유용합니다.

Zero-Copy 설계 

직렬화된 데이터를 역직렬화할 때, ZeroFormatter는 메모리를 복사하지 않고 데이터를 바로 사용합니다. 이는 메모리 사용량을 줄이고 속도를 높이는 데 도움이 됩니다. 

버전 관리

ZeroFormatter는 데이터 구조가 변경되었을 때도 호환성을 유지하는 기능을 제공합니다. 즉, 기존 데이터를 새 버전의 데이터 구조로 변환하는 것이 가능합니다. 다양한 데이터 타입 지원: ZeroFormatter는 기본적인 값 타입뿐만 아니라 복잡한 사용자 정의 클래스, 컬렉션, 제네릭 타입 등을 모두 지원합니다.

압축 기능

ZeroFormatter는 데이터를 압축해 네트워크 전송이나 파일 저장 시의 효율성을 높일 수 있습니다.

▶ 단점 

텍스트 기반 직렬화 부족

이진 기반 직렬화 라이브러리이기 때문에 JSON이나 XML 같은 텍스트 기반 직렬화 방식과는 다릅니다. 텍스트 직렬화는 사람이 쉽게 읽고 수정할 수 있는 장점이 있지만, ZeroFormatter는 이진 포맷으로 저장되어 있어 디버깅이 어렵고, 사람이 직접 데이터를 확인하거나 수정하기 힘듭니다. 텍스트 기반 직렬화가 필요한 경우에는 적합하지 않을 수 있습니다.

플랫폼 제한 

주로 .NET 및 C#에 최적화되어 있어, 다른 언어나 플랫폼에서는 사용할 수 없습니다. 만약 여러 프로그래밍 언어 간의 직렬화 및 역직렬화를 지원해야 한다면, 범용적인 프로토콜 버퍼(Protocol Buffers)나 FlatBuffers와 같은 툴이 더 나을 수 있습니다. 

복잡한 구조에 대한 제한적인 지원 

기본적으로 C#에서 많이 사용하는 데이터 구조에 최적화되어 있지만, 매우 복잡한 데이터 구조나 특별한 커스텀이 필요한 경우 적합하지 않을 수 있습니다. 예를 들어, 복잡한 상속 구조나 동적으로 변경되는 데이터 구조에서는 제한이 있을 수 있습니다. 

활발하지 않은 커뮤니티

다른 직렬화 라이브러리들에 비해 ZeroFormatter의 사용자 커뮤니티가 상대적으로 작기 때문에 문제 발생 시 도움을 받기 어려울 수 있습니다. 공식 문서나 예제들이 충분히 존재하지 않으며, 새로운 기능 추가나 버그 수정이 다른 프로젝트에 비해 느릴 수 있습니다. 

메모리 사용

Zero-Copy 메커니즘을 통해 메모리 복사를 줄이긴 하지만, 모든 시나리오에서 이점이 있는 것은 아닙니다. 특히 작은 데이터를 처리하는 애플리케이션에서 메모리 사용량이 과다할 수 있으며, 가비지 컬렉션(GC)과 관련된 문제를 유발할 수도 있습니다. 

▶ 결론 

ZeroFormatter는 주로 성능이 중요한 애플리케이션에서 사용되며, 특히 게임 개발, 실시간 데이터 처리, 대용량 데이터 시스템에서 유용하게 쓰일 수 있습니다. 

하지만 JSON이나 XML 같은 텍스트 기반 직렬화 포맷에 비해 디버깅이 어려울 수 있다는 점도 고려해야 합니다. 

ZeroFormatter는 뛰어난 성능과 간단한 사용법을 제공하는 직렬화 라이브러리지만,  

텍스트 기반 직렬화의 부재, 플랫폼 제한, 복잡한 데이터 구조의 한계, 커뮤니티 지원 부족 등 몇 가지 단점이 있습니다. 

이러한 단점들을 고려해 사용 목적에 맞는지 판단하는 것이 중요합니다. 

회사소개서 바로가기

포트폴리오 바로가기    

회사소개서 바로가기

포트폴리오 바로가기    

소프트웨어 프로토타입 개발,소프트웨어 프로토타입 제작,소프트웨어 MVP 개발,소프트웨어 시제품 테스트,소프트웨어 프로토타입 테스트,애플리케이션 시제품 개발,소프트웨어 시제품 설계,소프트웨어 프로토타입 솔루션,빠른 소프트웨어 시제품 개발,맞춤형 소프트웨어 시제품 제작,소프트웨어 시제품 검증,프로토타입 소프트웨어 개발,소프트웨어 시제품 제작 비용 

WPF(Windows Presentation Foundation)는 Microsoft에서 개발한 차세대 GUI(Graphical User Interface) 프레임워크입니다.  

2006년 .NET Framework 3.0과 함께 출시되었으며, 윈도우 응용 프로그램의 사용자 인터페이스를 보다 효율적이고 아름답게 디자인할 수 있도록 지원합니다. WPF는 윈도우 XP, 윈도우 비스타, 윈도우 7, 윈도우10 등 다양한 윈도우 운영체제에서 실행 될 수 있습니다. 

WPF의 등장은 여러 가지 배경과 필요성에 의해 촉진되었습니다. 그 주요 이유들을 다음과 같이 설명할 수 있습니다: 

① 기존 기술의 한계 극복 

WinForms의 한계:

이전에 사용된 Windows Forms(WinForms)는 기본적으로 GDI/GDI+를 기반으로 하고 있어 복잡한 그래픽과 애니메이션을 구현하는 데 한계가 있었습니다. WinForms는 주로 픽셀 기반의 렌더링을 사용하므로, 고해상도 디스플레이에서의 확장성 문제가 발생했습니다. 

그래픽 성능: 

WinForms는 하드웨어 가속을 충분히 활용하지 못해 고성능 그래픽 애플리케이션 개발에 제약이 있었습니다. 

② 풍부한 사용자 경험 제공

향상된 그래픽과 애니메이션:

 WPF는 DirectX를 기반으로 하는 벡터 기반 렌더링 시스템을 도입하여 고해상도와 고성능 그래픽을 지원합니다. 이를 통해 개발자들은 더욱 풍부하고 다이나믹한 UI를 구현할 수 있습니다.

미디어 통합: 

WPF는 비디오, 오디오 등 멀티미디어 콘텐츠를 쉽게 통합할 수 있는 기능을 제공하여, 멀티미디어 중심의 애플리케이션 개발을 촉진했습니다.

▶ WPF(Windows Presentation Foundation) 개발팀 

WPF(Windows Presentation Foundation)를 개발한 사람은 Microsoft의 여러 개발자와 엔지니어로 구성된 팀입니다.  

WPF 개발에 주요 역할을 한 몇몇 인물들을 예로 들면: 

Chris Anderson:

Microsoft에서 WPF의 초기 아키텍트 중 한 명으로, WPF의 핵심 설계와 개념 정의에 중요한 역할을 했습니다. 

주요 업적

"The Zen of .NET":

.NET Framework의 철학과 디자인 패턴을 설명한 책인 "The Zen of .NET"의 저자입니다. 이 책은 .NET Framework 개발자들에게 유용한 가이드라인과 베스트 프랙티스를 제공합니다.
 

Microsoft Robotics Studio:

Microsoft Robotics Studio의 개발에도 기여했습니다. 이는 로봇 애플리케이션을 위한 개발 환경으로, 로봇 공학 및 제어 시스템에 대한 연구와 개발을 촉진했습니다.

Ian Ellison-Taylor:

Microsoft의 Windows Client Platform 팀에서 일하며 WPF의 개발과 출시를 이끌었습니다. 

주요 업적 

Silverlight:

WPF와 유사한 기술인 Silverlight의 개발을 이끌었습니다. Silverlight는 웹 애플리케이션에서 리치 인터넷 애플리케이션(RIA)을 제공하기 위한 프레임워크로, 웹 브라우저에서 풍부한 미디어 및 그래픽 콘텐츠를 구현할 수 있게 했습니다.

Windows 8 및 Windows Phone 개발:

Windows 8과 Windows Phone의 UI 및 개발 플랫폼의 설계와 구현에도 참여했습니다. 이는 새로운 타일 기반의 사용자 인터페이스와 앱 개발 모델을 도입하여, 사용자 경험을 혁신했습니다.

Rob Relyea:

WPF 팀의 프로그램 관리자 중 한 명으로, XAML 및 데이터 바인딩 기능의 개발을 주도했습니다. 

주요 업적 

Windows Live Writer:

Rob Relyea는 블로그 작성 도구인 Windows Live Writer의 개발에도 기여했습니다. 이 도구는 사용자가 블로그 포스트를 쉽게 작성하고 관리할 수 있게 도와주며, 다양한 블로그 플랫폼과의 호환성을 제공합니다.

Microsoft Expression Blend:

Rob은 디자이너와 개발자가 WPF 및 Silverlight 애플리케이션을 디자인하고 개발하는 데 사용하는 도구인 Microsoft Expression Blend의 개발에 참여했습니다. 이 도구는 XAML 기반의 UI 디자인을 시각적으로 구성하고 테스트할 수 있게 합니다.

이 외에도 많은 개발자와 디자이너, 프로덕트 매니저들이 WPF의 개발과 발전에 기여했습니다. WPF는 다양한 전문가들이 협력하여 만든 복잡하고 강력한 기술로, 현재도 꾸준히 업데이트되고 있습니다. 

▶ WPF로 개발된 주요 사례 

① Visual Studio

Visual Studio는 Microsoft의 통합 개발 환경(IDE)으로, 다양한 프로그래밍 언어를 지원하며, WPF를 사용하여 개발되었습니다. WPF의 강력한 데이터 바인딩, 템플릿, 스타일링 기능을 통해 Visual Studio는 직관적이고 효율적인 사용자 인터페이스를 제공할 수 있게 되었습니다. 특히, 코드 편집기와 같은 복잡한 UI 요소들을 효과적으로 구현하는 데 WPF가 중요한 역할을 했습니다. 

② Microsoft Expression Blend

Microsoft Expression Blend는 WPF와 Silverlight 애플리케이션을 디자인하고 개발하는 데 사용된 도구입니다. 디자이너와 개발자가 협력하여 풍부한 사용자 인터페이스를 제작할 수 있도록 지원합니다. WPF의 강력한 그래픽 렌더링과 애니메이션 기능을 활용하여, 디자이너는 XAML을 사용해 시각적으로 매력적이고 상호작용적인 UI를 만들 수 있습니다. 

③ Microsoft Surface SDK (Surface 1.0, Surface 2.0)

Microsoft Surface(현재의 Microsoft PixelSense)는 터치스크린 기반의 대형 디스플레이 장치로, 상호작용을 위한 애플리케이션을 개발하기 위해 WPF를 사용했습니다. Surface SDK는 WPF를 기반으로 개발되어, 개발자들이 터치, 제스처, 멀티터치 상호작용을 손쉽게 구현할 수 있게 했습니다. 이를 통해 교육, 게임, 상업용 애플리케이션 등 다양한 분야에서 혁신적인 터치 기반 애플리케이션이 탄생했습니다. 

④ AutoCAD

Autodesk의 AutoCAD는 건축, 엔지니어링, 디자인 분야에서 널리 사용되는 컴퓨터 지원 설계(CAD) 소프트웨어입니다. AutoCAD의 일부 버전은 WPF를 사용하여 개발되었습니다. WPF의 강력한 그래픽 렌더링 능력을 통해 AutoCAD는 고해상도와 복잡한 2D 및 3D 디자인을 효과적으로 처리할 수 있으며, 사용자 인터페이스를 개선하여 사용자 경험을 높였습니다. 

▶ WPF vs WINFORM 차이점 

WPF는 고급 UI와 그래픽 성능이 뛰어나고 유연한 반면, WinForms는 빠르고 간단한 개발에 유리합니다. 

▶ WPF의 주요 특징

벡터 기반 렌더링 시스템:

WPF는 DirectX를 기반으로 하여 모든 UI 요소를 벡터 그래픽으로 렌더링합니다. 이를 통해 크기와 해상도에 무관하게 고품질의 그래픽을 구현할 수 있습니다. 

데이터 바인딩: 

WPF는 강력한 데이터 바인딩 기능을 제공합니다. 이는 코드와 UI를 분리하고, 데이터 소스와 UI 요소 간의 자동 동기화를 가능하게 합니다. 

XAML:

WPF는 XAML(eXtensible Application Markup Language)을 사용하여 UI를 선언적으로 정의합니다. XAML은 디자이너와 개발자가 협력하여 작업할 수 있도록 도와줍니다.

스타일과 템플릿:

스타일과 템플릿을 사용하여 UI의 일관된 외형을 유지하고, 재사용 가능한 디자인을 쉽게 구현할 수 있습니다. 

애니메이션과 그래픽:

WPF는 벡터 그래픽과 애니메이션을 지원하여 화려하고 역동적인 UI를 만들 수 있습니다.

멀티미디어:

이미지, 비디오, 오디오 등 멀티미디어 요소를 손쉽게 통합할 수 있습니다.

레이아웃: 

다양한 레이아웃 컨트롤(Grid, StackPanel, WrapPanel 등)을 사용하여 유연하고 적응성 있는 UI를 디자인할 수 있습니다.

▶ WPF의 아키텍처 

PresentationFramework:

WPF의 핵심 요소를 포함하는 어셈블리로, 대부분의 WPF 컨트롤과 기본 클래스를 제공합니다. 

PresentationCore:

WPF의 그래픽 렌더링과 관련된 저수준 기능을 포함합니다. 

WindowsBase:

WPF의 기본 데이터 타입과 클래스들을 포함합니다. 

MILCore:

Media Integration Layer Core는 DirectX와 상호 작용하여 WPF의 그래픽 렌더링을 처리합니다. 

▶ WPF의 장점 

① 풍부한 그래픽과 멀티미디어 지원 

벡터 기반 렌더링: WPF는 벡터 기반 렌더링 시스템을 사용하여, 해상도와 화면 크기에 상관없이 고품질의 그래픽을 구현할 수 있습니다. 이는 특히 고해상도 디스플레이에서 유리합니다.

DirectX 통합: DirectX를 기반으로 하여 하드웨어 가속을 통한 고성능 그래픽을 지원합니다. 이를 통해 복잡한 그래픽과 애니메이션을 원활하게 처리할 수 있습니다.

멀티미디어 통합: WPF는 오디오, 비디오 등의 멀티미디어 콘텐츠를 쉽게 통합할 수 있는 기능을 제공하여, 멀티미디어 중심의 애플리케이션 개발을 촉진합니다.

② 강력한 데이터 바인딩

MVVM 패턴 지원: WPF는 데이터 바인딩을 강력하게 지원하며, MVVM(Model-View-ViewModel) 패턴을 구현하기 쉽게 합니다. 이를 통해 UI와 비즈니스 로직의 분리가 용이해지고, 코드의 유지보수성이 높아집니다.

유연한 바인딩 옵션: 데이터 바인딩을 통해 다양한 데이터 소스와 UI 요소 간의 동기화를 쉽게 처리할 수 있으며, One-way, Two-way 등의 다양한 바인딩 모드를 지원합니다.

③ 유연한 스타일링 및 템플릿

ControlTemplate: WPF의 ControlTemplate을 사용하면 컨트롤의 외관을 완전히 커스터마이징할 수 있습니다. 이를 통해 일관된 UI 디자인을 쉽게 적용할 수 있습니다.

DataTemplate: DataTemplate을 사용하여 데이터의 시각적 표현을 정의할 수 있습니다. 이를 통해 다양한 데이터 타입에 대해 맞춤형 UI를 제공할 수 있습니다.

스타일 재사용: WPF는 스타일을 정의하고 재사용할 수 있는 기능을 제공하여, UI의 일관성을 유지하면서 개발 효율성을 높입니다.

④ 강력한 레이아웃 시스템

다양한 레이아웃 패널: Grid, StackPanel, WrapPanel, DockPanel 등 다양한 레이아웃 패널을 제공하여, 복잡한 UI를 쉽게 구성할 수 있습니다.

동적 레이아웃: WPF의 레이아웃 시스템은 동적으로 크기와 위치를 조정할 수 있어, 다양한 화면 크기와 해상도에 적응하는 UI를 만들 수 있습니다.

⑤ 선언적 프로그래밍

XAML: WPF는 XAML(Extensible Application Markup Language)을 사용하여 UI를 선언적으로 정의할 수 있습니다. 이를 통해 UI 디자인과 비즈니스 로직을 분리하고, 디자이너와 개발자 간의 협업을 용이하게 합니다.

⑥ 애니메이션과 트랜지션

스토리보드: WPF는 스토리보드를 통해 복잡한 애니메이션 시퀀스를 정의하고 적용할 수 있습니다. 이를 통해 사용자 인터페이스에 생동감을 더할 수 있습니다.

애니메이션 API: 다양한 애니메이션 API를 제공하여, 위치, 크기, 색상 등의 속성을 애니메이션화할 수 있습니다.

⑦ 강력한 이벤트 모델

라우트 이벤트: WPF는 라우트 이벤트와 버블링 이벤트를 지원하여, 이벤트 처리를 유연하게 할 수 있습니다. 이를 통해 컨트롤 간의 상호작용을 쉽게 관리할 수 있습니다.

⑧ 풍부한 컨트롤 라이브러리

기본 컨트롤: WPF는 Button, TextBox, ListBox 등 기본적인 UI 컨트롤을 비롯하여 TreeView, DataGrid 등의 고급 컨트롤을 제공합니다.

사용자 정의 컨트롤: 사용자가 직접 컨트롤을 정의하고, 이를 재사용할 수 있는 기능을 제공합니다.

⑨ 일관된 개발 환경

.NET 통합: WPF는 .NET Framework와 완전히 통합되어, 기존 .NET 기술과의 호환성을 유지하면서도 새로운 기능을 제공합니다. 이를 통해 개발자들이 기존의 지식을 활용하면서도 최신 기술을 쉽게 도입할 수 있습니다.

⑩ 향상된 유지보수와 확장성

모듈화: WPF 애플리케이션은 모듈화가 가능하여, 유지보수와 확장이 용이합니다. 이를 통해 대규모 애플리케이션의 복잡성을 효과적으로 관리할 수 있습니다.

▶ WPF의 단점 

① 학습 곡선이 높다

복잡한 개념: WPF는 XAML, 데이터 바인딩, 템플릿, 스타일 등 많은 새로운 개념을 포함하고 있어, 기존 Windows Forms 개발자에게는 익숙해지기 어려울 수 있습니다.

MVVM 패턴: WPF는 MVVM(Model-View-ViewModel) 패턴을 강력하게 권장하는데, 이 패턴을 이해하고 구현하는 데 시간이 걸릴 수 있습니다.

② 성능 문제

초기 로드 시간: WPF 애플리케이션은 다른 프레임워크보다 초기 로드 시간이 더 길어질 수 있습니다. 이는 특히 복잡한 애니메이션이나 고해상도 그래픽을 많이 사용하는 경우 더욱 두드러집니다.

메모리 사용: WPF는 리소스를 많이 사용하므로, 특히 대규모 애플리케이션에서 메모리 사용량이 많아질 수 있습니다.

그래픽 성능: 복잡한 그래픽 연산이나 애니메이션을 많이 사용할 경우, 최적화가 잘되지 않으면 성능 저하가 발생할 수 있습니다.

③ 디자인 도구의 제한

Blend 사용의 복잡성: WPF 애플리케이션을 디자인할 때 Blend for Visual Studio를 사용하는 것이 권장되지만, 이 도구는 처음 사용하는 개발자에게 복잡하고 직관적이지 않을 수 있습니다.

디자이너와의 협업: WPF의 강력한 스타일링과 템플릿 기능은 디자인과 개발을 분리할 수 있지만, 디자이너가 XAML을 잘 이해해야 효과적으로 협업할 수 있습니다.

④ 브라우저 호환성 부족

웹 통합 어려움: WPF는 기본적으로 데스크탑 애플리케이션을 위한 프레임워크이므로, 웹 브라우저와의 통합이 어렵습니다. 이는 웹 기반 애플리케이션 개발에 적합하지 않습니다.

Silverlight의 종료: WPF의 웹 기반 버전인 Silverlight가 더 이상 지원되지 않으므로, WPF 애플리케이션을 웹으로 배포하는 것이 어려워졌습니다.

⑤ 플랫폼 종속성

Windows 종속: WPF는 Windows 운영체제 전용 프레임워크이므로, 다른 운영체제(예: macOS, Linux)에서는 사용할 수 없습니다. 이는 크로스 플랫폼 애플리케이션 개발에 제약이 됩니다.

.NET Framework 종속: WPF는 .NET Framework에 종속적이므로, 이를 사용하지 않는 다른 환경에서는 WPF 애플리케이션을 실행할 수 없습니다.

⑥ 기존 기술과의 호환성 문제

WinForms와의 통합 어려움: WPF와 WinForms를 통합하여 사용하는 것이 가능하지만, 두 프레임워크 간의 상호 운용성 문제로 인해 복잡한 구성이 필요할 수 있습니다.

레거시 코드 통합: 기존의 WinForms 또는 다른 기술로 작성된 애플리케이션을 WPF로 마이그레이션하는 데 많은 작업과 시간이 필요할 수 있습니다.

⑦ 업데이트와 지원 문제

업데이트 빈도: WPF는 최근 몇 년 동안 큰 업데이트가 많이 이루어지지 않았습니다. 이는 최신 기술 트렌드와 요구에 맞춘 기능 개선이 느리다는 것을 의미할 수 있습니다.

커뮤니티 및 리소스: 다른 최신 프레임워크와 비교했을 때, WPF 관련 커뮤니티와 온라인 리소스가 상대적으로 적을 수 있습니다.

개발 프로젝트는 종종 다양한 이유로 실패할 수 있습니다. 이를 예방하기 위해 실패의 원인을 분석하고, 피해야 할 개발 방식을 이해하는 것이 중요합니다. 이 글에서는 일반적으로 실패로 이어지는 몇 가지 개발 방식을 살펴보겠습니다.

문제점
요구사항이 명확하지 않으면 개발 팀은 잘못된 방향으로 나아갈 수 있습니다. 이는 결국 잘못된 제품을 만들게 하고, 고객의 요구를 충족시키지 못하게 만듭니다.

불충분한 계획

문제점
계획이 부실하면 프로젝트 일정이 지연되고 예산이 초과될 수 있습니다. 이는 개발 팀의 사기를 떨어뜨리고 프로젝트의 성공 가능성을 낮춥니다.

해결책

명확하고 현실적인 프로젝트 계획을 세웁니다.

각 단계마다 명확한 목표와 마일스톤을 설정합니다.

과도한 기술적 부채

문제점
기술적 부채를 무시하거나 축적하면 유지보수 비용이 증가하고, 새로운 기능을 추가하는 것이 점점 어려워집니다.

해결책

기술적 부채를 줄이기 위한 지속적인 리팩토링을 수행합니다.

새로운 코드를 작성할 때 기술적 부채를 최소화하도록 노력합니다.

소통의 부족

문제점
개발 팀 내에서, 혹은 고객과의 소통이 부족하면 오해가 발생하고, 이는 프로젝트 실패로 이어질 수 있습니다.

해결책

정기적인 회의와 상태 보고를 통해 팀 내 소통을 촉진합니다.

고객과의 지속적인 피드백 루프를 유지합니다.

불충분한 테스트

문제점
테스트가 불충분하면 제품에 버그가 많아지고, 이는 사용자 경험을 저해하며 신뢰도를 떨어뜨립니다.

해결책

철저한 테스트 계획을 수립하고 모든 기능에 대해 테스트를 수행합니다.

자동화된 테스트를 도입하여 테스트의 효율성과 효과를 높입니다.

변화 관리의 실패

문제점
변화 관리를 제대로 하지 않으면 요구사항 변경에 신속하게 대응할 수 없고, 이는 프로젝트의 방향성을 잃게 만듭니다.

해결책

변화 관리 프로세스를 수립하고 이를 엄격히 준수합니다.

요구사항 변경 시 영향 분석을 철저히 수행합니다.

결론

성공적인 개발을 위해서는 명확한 요구사항 정의, 충분한 계획, 기술적 부채 관리, 원활한 소통, 철저한 테스트, 그리고 변화 관리가 필수적입니다. 이러한 요소들을 간과한다면 프로젝트는 실패할 가능성이 높아집니다. 반면, 이를 잘 관리한다면 성공적인 프로젝트를 달성할 수 있을 것입니다.

 

 

안녕하세요. 오늘은 외주 개발 실패 프로젝트에 대해 이야기해보려고 합니다. 특히, 다른 업체에서 실패한 프로젝트를 저희가 어떻게 성공적으로 마무리 했는지 공유하고자 합니다.

 

회사소개서 바로가기

포트폴리오 바로가기     

 

회사소개서 바로가기

포트폴리오 바로가기    

예비 창업 패키지 소프트웨어 외주 개발,예비 창업 패키지 소프트웨어 외주 용역 업체,초기 창업 패키지 외주 개발,초기 창업 패키지 소프트웨어 외주 개발,정부 지원 사업 외주 개발 

회사소개서 바로가기

포트폴리오 바로가기    

 WPF 외주 개발 

윈도우10에 추가된 가상 데스크탑을 활용하면 사용자의 PC나 노트북의 화면이 하나여도, 화면이 여러 개인 것과 같은 업무 효율을 얻을 수 있다. 예를 들어 바탕화면을 세 개 만든 후 첫 번째 바탕화면에 인터넷 창을 띄우고, 두 번째 화면에 워드 프로세서를 띄운다. 세 번째 화면은 여유분으로 남겨두거나 참고 자료로 활용할 PDF 파일 등을 띄운 후 마우스나 단축키를 이용해 바탕화면을 전환해가며 업무를 처리하면 된다. 화면이 여러 개면 화면에 맞춰 사용자의 시선이 이동한다. 반면 가상 데스크탑은 사용자의 시선은 고정되어 있고, 바탕화면이 고정된 시선에 맞춰 이동하는 것으로 이해하면 된다.

바탕화면 하단 작업 표시줄 왼쪽 끝에 '작업 보기'란 아이콘이 있다. 이를 누른 후 화면 오른쪽 하단 '새 데스크톱'을 누르면 바탕화면을 추가할 수 있다. 바탕화면은 메모리가 허락하는 한도까지 계속 생성할 수 있으나, 현실적으로 3~4개 정도를 추가하고 전환해가며 사용하는 것을 추천한다.

다른 바탕화면으로 이동하고 싶다면 작업 보기를 선택한 후 해당 바탕화면을 선택하거나, 단축키(Ctrl키 + 윈도우키 + 좌, 우 방향키)를 누르면 된다. 바탕화면을 새로 생성하는 단축키는 Ctrl키 + 윈도우키 + D키이다. 특정 바탕화면을 종료하고 싶다면 '작업 보기'를 선택한 후 특정 바탕화면에 마우스 커서를 가져가면 종료(X) 아이콘이 뜨는데, 이를 누르면 된다. 현재 사용 중인 바탕화면을 종료하고 싶다면 Ctrl키 + 윈도우키 + F4키를 누르면 된다. 사용 중인 바탕화면에서 앱이나 응용 프로그램을 실행 중이었다면, 다른 바탕화면으로 앱과 응용 프로그램이 넘어온다.

특정 바탕화면에서 다른 바탕화면으로 앱이나 응용 프로그램을 옮기고 싶다면 '작업 보기'를 선택한 후 해당 앱을 다른 바탕화면으로 집어서 옮기면(드래그) 된다.

모니터를 여러 대 사용하고 있는데 가상 데스크탑을 이용하면 어떻게 될까? 모니터 여러 대에서 표시되는 각각의 바탕화면을 하나의 바탕화면으로 합쳐서 인식한다. 풀HD 해상도(1,920x1,080)의 모니터 2대를 사용하고 있었다면, 3,840x1,080 해상도의 바탕화면을 생성한다. 마찬가지로 모니터를 3대 이용하고 있었다면 가상 데스크탑을 통해 생성되는 바탕화면의 가로 해상도도 더욱 늘어난다. 가상 데스크탑은 모니터가 하나일 때 뿐만 아니라 모니터가 여러 대 일때 이용해도 편리하다.

VirtualDesktop

  VirtualDesktop is C# wrapper for IVirtualDesktopManager on Windows 11 (and Windows 10).

상세링크

https://github.com/Grabacr07/VirtualDesktop 

CancellationToken를 이용하여 사용 하길 권장.

대체 방법 

CancellationToken을 사용 하여 Thread.Abort를 호출 하는 대신 작업 단위 처리를 중단합니다. 다음 예제에서는 CancellationToken 합니다.

변경 내용 

메서드가 호출되는 경우 .NET 5 이상 버전을 대상으로 하는 프로젝트에서는 컴파일 시간 경고 SYSLIB0006이 발생 합니다.

이전에는 Thread.Abort 호출이 컴파일 시간 경고가 생성되지 않았지만, 런타임에 PlatformNotSupportedException을 throw 합니다.

.NET 5부터 Thread.Abort는 경고로 사용되지 않는 것으로 표시됩니다. 

해당 메서드를 호출하면 컴파일러 경고 SYSLIB0006이 생성 됩니다. 

메서드의 구현은 변경되지 않으며 계속해서 PlatformNotSupportedException을 throw합니다.

변경 이유 

Thread.Abort가 .NET Framework를 제외한 모든 .NET 구현 에서 항상 PlatformNotSupportedException을 throw하는 것을 고려하여 메서드가 호

출된 위치로 주의를 끌기 위해 ObsoleteAttribute가 메서드에 추가되었습니다.

현재 스레드가 아닌 다른 스레드를 중단하도록 호출 Thread.Abort 할 때 어떤 코드가 실행 되었거나 throw될 때 ThreadAbortException 실행 하

또한 애플리케이션의 상태 또는 유지를 담당하는 애플리케이션 및 사용자 상태를 확인 할 수 없습니다.

예를 들어 호출 Thread.Abort 은 정적 생성자의 실행 또는 관리 되거나 관리되지 않는 리소스의 릴리스를 방지 할 수 있습니다. 

이러한 이유로 Thread.Abort 항상 .NET Core 및 .NET 5 이상에서 PlatformNotSupportedException 예외 처리 합니다.

연결이 끊긴 시나리오에서 DbContext는 엔터티가 현재 DbContext 인스턴스의 범위를 벗어나 추가되거나 수정되었기 때문에 연결이 끊긴 엔터티를 인식하지 못합니다.

따라서 데이터베이스에 대한 CUD(Create, Update, Delete) 작업을 수행하려면 연결이 끊긴 엔터티를 적절한 EntityState가 있는 컨텍스트에 연결해야 합니다.

다음 그림은 연결이 끊긴 시나리오의 CUD 작업을 보여줍니다.

위 그림과 같이 연결이 끊긴 엔터티(DbContext에서 추적하지 않는 엔터티)는 적절한 EntityState를 사용하여 DbContext에 연결해야 합니다.

예를 들어 새 엔터티에 대해 추가된 상태, 편집된 엔터티에 대해 수정된 상태 및 삭제된 엔터티에 대해 삭제됨 상태로, SaveChanges() 메서드가 호출될 때 데이터베이스에 INSERT, UPDATE 또는 DELETE 명령이 생성됩니다.

연결이 끊긴 시나리오에서 Entity Framework Core를 사용하여 DB 테이블에 레코드를 삽입, 업데이트 또는 삭제하려면 다음 단계를 수행해야 합니다.

1. 적절한 EntityState를 사용하여 DbContext에 엔터티를 연결합니다. 추가, 수정 또는 삭제됨

2. SaveChanges() 메서드 호출

다음 예는 위의 단계를 사용하여 데이터베이스에 새 레코드를 삽입하는 방법을 보여줍니다.

//Disconnected entity
var std = new Student(){ Name = "Bill" };

using (var context = new SchoolContext())
{
    //1. Attach an entity to context with Added EntityState
    context.Add<Student>(std);
    
    //or the followings are also valid
    // context.Students.Add(std);
    // context.Entry<Student>(std).State = EntityState.Added;
    // context.Attach<Student>(std);
                  
    //2. Calling SaveChanges to insert a new record into Students table
    context.SaveChanges();
}

위의 예에서 std는 Student 엔터티의 연결이 끊긴 인스턴스입니다. context.Add<Student>() 메서드는 학생 엔터티를 추가됨 상태의 컨텍스트에 연결합니다. SaveChanges() 메서드는 다음 INSERT 문을 빌드하고 실행합니다.

exec sp_executesql N'SET NOCOUNT ON;
INSERT INTO [Students] ([Name])
VALUES (@p0);
SELECT [StudentId]
FROM [Students]
WHERE @@ROWCOUNT = 1 AND [StudentId] = scope_identity();',N'@p0 nvarchar(4000), 
@p1 nvarchar(4000) ',@p0=N'Bill'
go

EF Core는 추가됨 상태로 엔터티를 추가하는 여러 방법을 제공합니다. 위의 예에서 context.Students.Add(std);, context.Entry<Student>(std).State = EntityState.Added; 및 context.Attach<Student>(std); 위와 동일한 INSERT 문이 생성됩니다.

Entity Framework Core는 연결이 끊긴 엔터티를 추가된 EntityState로 연결하는 다음 DbContext 및 DbSet 메서드를 제공하며, 이 메서드는 차례로 데이터베이스에서 INSERT 문을 실행합니다.

참고: 위의 DbContext 메서드는 EF Core에 도입되었습니다(EF 6 이하에서는 사용할 수 없음). DbContext 및 DbSet 메서드는 모두 동일한 작업을 수행합니다. 어느 것을 사용할지는 코딩 패턴과 선호도에 따라 다릅니다.

단일 엔트리 업데이트

다음 예는 연결이 끊긴 엔터티를 업데이트하는 방법을 보여줍니다.

// Disconnected Student entity
var stud = new Student(){ StudentId = 1, Name = "Bill" };

stud.Name = "Steve"; 

using (var context = new SchoolContext())
{
    context.Update<Student>(stud);

    // or the followings are also valid
    // context.Students.Update(stud);
    // context.Attach<Student>(stud).State = EntityState.Modified;
    // context.Entry<Student>(stud).State = EntityState.Modified; 

    context.SaveChanges(); 
}

위의 예에서 stud는 유효한 Key 속성 값(StudentId = 1)을 가지고 있기 때문에 기존 Student 엔터티 개체라고 가정합니다.

Entity Framework Core는 지정된 엔터티를 컨텍스트에 연결하고 EntityState를 Modified로 설정하는 DbContext.Update() 메서드를 도입했습니다. 또는 DbSet.Update() 메서드(context.Students.Update(stud))를 사용하여 동일한 작업을 수행할 수도 있습니다.

위의 예는 데이터베이스에서 다음 UPDATE 문을 실행합니다.

exec sp_executesql N'SET NOCOUNT ON;
UPDATE [Students] SET [Name] = @p0
WHERE [StudentId] = @p1;
SELECT @@ROWCOUNT;
',N'@p1 int,@p0 nvarchar(4000)',@p1=1,@p0=N'Steve'
go

여러개 엔트리 업데이트

​DbContext.UpdateRange 또는 DbSet.UpdateRange 메서드를 사용하여 엔터티 컬렉션 또는 배열을 DbContext에 연결하고 해당 EntityState를 한 번에 수정됨으로 설정합니다.

var modifiedStudent1 = new Student()
{
    StudentId = 1,
    Name = "Bill"
};

var modifiedStudent2 = new Student()
{
    StudentId = 3,
    Name = "Steve"
};

var modifiedStudent3 = new Student()
{
    StudentId = 3,
    Name = "James"
};

IList<Student> modifiedStudents = new List<Student>()
{
    modifiedStudent1,
    modifiedStudent2,
    modifiedStudent3
};

using (var context = new SchoolContext())
{
    context.UpdateRange(modifiedStudents);
    
    // or the followings are also valid
    //context.UpdateRange(modifiedStudent1, modifiedStudent2, modifiedStudent3);
    //context.Students.UpdateRange(modifiedStudents);
    //context.Students.UpdateRange(modifiedStudent1, modifiedStudent2, modifiedStudent3);
                
    context.SaveChanges();
}

보시다시피 UpdateRange 메서드에는 두 개의 오버로드가 있습니다.

하나의 오버로드는 엔터티 컬렉션을 사용하고 두 번째 오버로드는 object[]를 매개변수로 사용합니다. DbSet.UpdateRange 메서드는 DbContext.UpdateRange 메서드와 동일한 방식으로 작동합니다.

EF Core는 위의 예에서 모든 엔터티에 대한 UPDATE 문을 빌드하여 성능을 개선하고 단일 데이터베이스 왕복으로 실행합니다.

​exec sp_executesql N'SET NOCOUNT ON; 

UPDATE [Students] SET [Name] = @p0
WHERE [StudentId] = @p1;
SELECT @@ROWCOUNT;

UPDATE [Students] SET [Name] = @p2
WHERE [StudentId] = @p3;
SELECT @@ROWCOUNT;

UPDATE [Students] SET [Name] = @p4
WHERE [StudentId] = @p5;
SELECT @@ROWCOUNT;

',N'@p1 int,@p0 nvarchar(4000),@p3 int,@p2 nvarchar(4000),@p5 int,@p4 nvarchar(4000)',
@p1=1,@p0=N'Bill',@p3=2,@p2=N'Steve',@p5=3,@p4=N'James'
go

엔트리 상태 변경

Update 메서드는 키 속성 값을 기반으로 EntityState를 설정합니다. 루트 또는 자식 엔터티의 키 속성이 비어 있거나 지정된 데이터 형식의 null 또는 기본값인 경우 Update() 메서드는 이를 새 엔터티로 간주하고 해당 EntityState를 Entity Framework Core 2.x에서 추가됨으로 설정합니다.

public static void Main()
{
    var newStudent = new Student()
    {
        Name = "Bill"
    };

    var modifiedStudent = new Student()
    {
        StudentId = 1,
        Name = "Steve"
    };

    using (var context = new SchoolContext())
    {
        context.Update<Student>(newStudent);
        context.Update<Student>(modifiedStudent);

        DisplayStates(context.ChangeTracker.Entries());
    }
}
private static void DisplayStates(IEnumerable<EntityEntry> entries)
{
    foreach (var entry in entries)
    {
        Console.WriteLine($"Entity: {entry.Entity.GetType().Name},
                 State: {entry.State.ToString()} ");
    }
}

Entity: Student, State: Added
Entity: Student, State: Modified 

위의 예에서 newStudent에는 Key 속성 값(StudentId)이 없습니다. 따라서 Update() 메서드는 이를 추가됨으로 표시하지만 modifyStudent에는 값이 있으므로 수정됨으로 표시됩니다.

Exception:

​Update 및 UpdateRange 메서드는 DbContext의 인스턴스가 이미 동일한 키 속성 값을 가진 엔터티를 추적하고 있는 경우 InvalidOperationException을 throw합니다. 다음 예를 고려하십시오.

var student = new Student()
{
    StudentId = 1,
    Name = "Steve"
};

using (var context = new SchoolContext())
{
    // loads entity in a conext whose StudentId is 1
    context.Students.First<Student>(s => s.StudentId == 1); 

    // throws an exception as it already tracking entity with StudentId=1
    context.Update<Student>(student); 

    context.SaveChanges();
}

위의 예에서 컨텍스트 개체는 StudentId가 1인 Student 엔터티를 로드하고 추적을 시작합니다. 따라서 동일한 키 값으로 엔터티를 연결하면 다음 예외가 발생합니다.

The instance of entity type 'Student' cannot be tracked because another instance with the same key value for {'StudentId'} is already being tracked. When attaching existing entities, ensure that only one entity instance with a given key value is attached. Consider using 'DbContextOptionsBuilder.EnableSensitiveDataLogging' to see the conflicting key values. 

다음 예는 연결이 끊긴 시나리오에서 엔터티를 삭제하는 다양한 방법을 보여줍니다.

// entity to be deleted
var student = new Student() {
        StudentId = 1
};

using (var context = new SchoolContext()) 
{
    context.Remove<Student>(student);
   
    // or the followings are also valid
    // context.RemoveRange(student);
    //context.Students.Remove(student);
    //context.Students.RemoveRange(student);
    //context.Attach<Student>(student).State = EntityState.Deleted;
    //context.Entry<Student>(student).State = EntityState.Deleted;
    
    context.SaveChanges();
}

위의 예에서 유효한 StudentId가 있는 Studnet 엔터티는 Remove() 또는 RemoveRange() 메서드를 사용하여 컨텍스트에서 제거됩니다. 데이터는 SaveChanges()의 데이터베이스에서 삭제됩니다. 위의 예는 데이터베이스에서 다음 삭제 명령을 실행합니다.

exec sp_executesql N'SET NOCOUNT ON;
DELETE FROM [Students]
WHERE [StudentId] = @p0;
SELECT @@ROWCOUNT;
',N'@p0 int',@p0=1
go

참고: DbContext.Remove() 및 DbContext.RemoveRange() 메서드는 삭제 작업을 쉽게 하기 위해 EF Core에 새로 도입되었습니다.

Exception

Remove() 또는 RemoveRange() 메서드에서 지정된 엔터티의 키 값이 해당 데이터베이스 테이블에 없으면 EF Core에서 예외가 발생합니다. 다음 예제에서는 예외를 발생시킵니다.

var student = new Student() {
    StudentId = 50
};

using (var context = new SchoolContext()) {

    context.Remove<Student>(student);

    context.SaveChanges();
}

위의 예에서 StudentId = 50인 Student는 데이터베이스에 존재하지 않습니다. 따라서 EF Core는 다음을 던집니다.

DbUpdateConcurrencyException:

Database operation expected to affect 1 row(s) but actually affected 0 row(s). Data may have been modified or deleted since entities were loaded.

var student = new Student() {
    StudentId = 50
};

using (var context = new SchoolContext()) 
{
    try
    {
        context.Remove<Student>(deleteStudent);
        context.SaveChanges();
    }    
    catch (DbUpdateConcurrencyException ex)
    {
        throw new Exception("Record does not exist in the database");
    }
    catch (Exception ex)
    {
        throw;
    }
}

레코드 여러개 삭제

DbContext.RemoveRange() 또는 DbSet.RemoveRange() 메서드를 사용하여 여러 엔터티를 한 번에 제거할 수 있습니다.

IList<Student> students = new List<Student>() {
    new Student(){ StudentId = 1 },
    new Student(){ StudentId = 2 },
    new Student(){ StudentId = 3 },
    new Student(){ StudentId = 4 }
};

using (var context = new SchoolContext()) 
{
    context.RemoveRange(students);
    
    // or
    // context.Students.RemoveRange(students);
    
    context.SaveChanges();
}

위의 예는 단일 데이터베이스 방식에서 데이터베이스에서 4개의 레코드를 삭제합니다. 따라서 EF Core는 성능을 향상시켰습니다.

exec sp_executesql N'SET NOCOUNT ON;
DELETE FROM [Students]
WHERE [StudentId] = @p0;
SELECT @@ROWCOUNT;


DELETE FROM [Students]
WHERE [StudentId] = @p1;
SELECT @@ROWCOUNT;

DELETE FROM [Students]
WHERE [StudentId] = @p2;
SELECT @@ROWCOUNT;


DELETE FROM [Students]
WHERE [StudentId] = @p3;
SELECT @@ROWCOUNT;

',N'@p0 int,@p1 int',@p0=1,@p1=2,@p2=3,@p3=4
go

관련 데이터 삭제

엔터티가 일대일 또는 일대다와 같은 다른 엔터티와 관계가 있는 경우 루트 엔터티가 삭제될 때 관련 데이터를 삭제하는 것은 관계가 구성되는 방식에 따라 다릅니다.

예를 들어 Student 및 Grade 엔터티에 일대다 관계가 있다고 가정합니다. 

특정 GradeId에 대한 많은 학생 기록이 있습니다. 데이터베이스에서 관련 학생 기록이 있는 성적을 삭제하려고 하면 EF에서 참조 무결성 오류가 발생합니다. 이 문제를 해결하기 위해 Fluent API를 사용하여 참조 제약 조건 작업 옵션을 정의할 수 있습니다. 예를 들어 아래와 같이 관계에 대한 계단식 삭제 옵션을 구성할 수 있습니다.

modelBuilder.Entity<Student>()
    .HasOne<Grade>(s => s.Grade)
    .WithMany(g => g.Students)
    .HasForeignKey(s => s.GradeId)
    .OnDelete(DeleteBehavior.Cascade);

이제 Grade 엔터티를 삭제하면 관련된 모든 학생 레코드도 데이터베이스에서 삭제됩니다.

SetNull, ClientSetNull 및 Restrict와 같이 EF Core에서 사용할 수 있는 다른 참조 제약 조건 작업 옵션이 있습니다.

첫 번째 EF Core 애플리케이션 장에서 EF Core API는 도메인 클래스가 규칙을 따르고 있기 때문에 추가 구성 없이 도메인 및 컨텍스트 클래스를 기반으로 데이터베이스 스키마를 만듭니다.

기본 규칙을 이해 하려면 다음 샘플 엔터티 및 컨텍스트 클래스를 고려하세요.

public class Student
{
    public int StudentId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime DateOfBirth { get; set; }
    public byte[] Photo { get; set; }
    public decimal Height { get; set; }
    public float Weight { get; set; }

    public int GradeId { get; set; }
    public Grade Grade { get; set; }
}

public class Grade
{
    public int Id { get; set; }
    public string GradeName { get; set; }
    public string Section { get; set; }

    public IList<Student> Students { get; set; }
}

public class SchoolContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    { 
        optionsBuilder.UseSqlServer(@"Server=.\SQLEXPRESS;Database=SchoolDB;Trusted_Connection=True;");
    }

    public DbSet<Student> Students { get; set; }
}

EF Core 규칙과 EF Core API가 위 엔터티에 대한 데이터베이스를 만드는 방법을 이해해 보겠습니다.

Schema

EF Core는 기본적으로 dbo 스키마에 모든 데이터베이스 개체를 만듭니다.

Table

EF Core는 속성과 이름이 같은 컨텍스트 클래스의 모든 DbSet<TEntity> 속성에 대한 데이터베이스 테이블을 만듭니다. 

또한 DbSet 속성으로 포함되지 않지만 다른 DbSet 엔터티의 참조 속성을 통해 연결할 수 있는 엔터티에 대한 테이블을 만듭니다. 

위의 예에서 EF Core는 SchoolContext 클래스의 DbSet<Student> 속성에 대한 Students 테이블과 Student 엔터티 클래스의 Grade 속성에 대한 Grade 테이블을 생성합니다. 이는 SchoolContext 클래스에 DbSet<Grade> 속성이 포함되어 있지 않더라도.

Column

EF Core는 기본적으로 속성과 이름이 같은 엔터티 클래스의 모든 스칼라 속성에 대한 열을 만듭니다.

데이터베이스의 해당 테이블 간의 관계를 구축하는 데 참조 및 컬렉션 속성을 사용 합니다.

Column Data Type

데이터베이스 테이블의 열에 대한 데이터 형식은 데이터베이스 공급자가 C# 데이터 형식을 선택한 데이터베이스의 데이터 형식에 매핑한 방법에 따라 다릅니다. 다음 표에는 C# 데이터 형식과 SQL Server 열 데이터 형식 간의 매핑이 나와 있습니다.

Nullable Column

NotNull Column

Primary Key

EF Core는 Id 또는 <Entity Class Name>Id(대소문자 구분 안 함)라는 속성에 대한 기본 키 열을 만듭니다. 

예를 들어 EF Core는 학생 클래스에 id, ID, iD, Id, studentid, StudentId, STUDENTID 또는 sTUdentID라는 속성이 포함된 경우 Students 테이블에 PrimaryKey로 열을 만듭니다.

Foreign Key

• <Reference Navigation Property Name>Id
• <Reference Navigation Property Name><Principal Primary Key Property Name>

예는 (Student 및 Grade 엔터티)에서 EF Core는 다음 그림과 같이 Students 테이블에 외래 키 열 GradeId를 만듭니다.

다음 표에는 다양한 참조 속성 이름과 기본 키 속성 이름에 대한 외래 키 열 이름이 나와 있습니다.

Index

EF Core는 기본적으로 Primary key 열에 클러스터 형 인덱스를 만들고 ForeignKey 열에 비 클러스터형 인덱스를 만듭니다.

이를 시연하기 위해 Visual Studio 17(또는 그 이상)을 사용하여 .NET Core 콘솔 애플리케이션을 생성합니다.

.NET Core 콘솔 애플리케이션은 Visual Studio 2017 또는 .NET Core용 CLI(명령줄 인터페이스)를 사용하여 만들 수 있습니다. 

여기서는 Visual Studio 2017을 사용하겠습니다.

.NET Core 콘솔 애플리케이션을 만들려면 Visual Studio 2017을 열고 메뉴에서 파일 -> 새로 만들기 -> 프로젝트를 선택합니다. 

그러면 아래와 같이 새 프로젝트 팝업이 열립니다.

새 프로젝트 팝업의 왼쪽 창에서 설치됨 -> Visual C#을 확장하고 가운데 창에서 콘솔 앱(.NET Core) 템플릿을 선택합니다. 프로젝트 이름 및 위치를 입력하고 확인 버튼을 클릭하면 아래와 같이 콘솔 애플리케이션이 생성됩니다.

이제 패키지 관리자 콘솔을 사용하여 콘솔 애플리케이션에 EF Core를 설치해야 합니다. 메뉴에서 도구 -> NuGet 패키지 관리자 -> 패키지 관리자 콘솔을 선택하고 다음 명령을 실행하여 SQL Server 공급자 패키지를 설치합니다.

Install-Package Microsoft.EntityFrameworkCore.SqlServer 

모델 생성 

Entity Framework에는 기본 데이터베이스와 통신하기 위한 모델(Entity Data Model)이 있어야 합니다. 도메인 클래스의 모양, 데이터 주석 및 Fluent API 구성을 기반으로 모델을 빌드합니다.

EF 모델에는 개념적 모델, 저장소 모델 및 개념적 모델과 저장소 모델 간의 매핑의 세 부분이 포함됩니다. 코드 우선 접근 방식에서 EF는 도메인 클래스(엔티티 클래스), 컨텍스트 클래스 및 구성을 기반으로 개념적 모델을 빌드합니다. EF Core는 사용하는 공급자를 기반으로 스토리지 모델 및 매핑을 빌드합니다. 예를 들어, 스토리지 모델은 DB2와 비교하여 SQL Server의 경우 다릅니다.

EF는 기본 데이터베이스에 대한 CRUD(만들기, 읽기, 업데이트, 삭제) 작업에 이 모델을 사용합니다.

따라서 먼저 엔터티 클래스와 컨텍스트 클래스를 만들어야 합니다. 다음은 Student 및 Course에 대한 간단한 엔터티 클래스입니다.

public class Student
{
    public int StudentId { get; set; }
    public string Name { get; set; }
}

public class Course
{
    public int CourseId { get; set; }
    public string CourseName { get; set; }
}

이제 이전 장에서 설명한 것처럼 DbContext를 파생하여 컨텍스트 클래스를 만들어야 합니다. 다음 SchoolContext 클래스는 컨텍스트 클래스라고도 합니다.

namespace EFCoreTutorials
{
    public class SchoolContext : DbContext
    {
        public DbSet<Student> Students { get; set; }
        public DbSet<Course> Courses { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        { 
            optionsBuilder.UseSqlServer(@"Server=.\SQLEXPRESS;Database=SchoolDB;Trusted_Connection=True;");
        }
    }
}

위의 컨텍스트 클래스에는 기본 데이터베이스의 Students 및 Courses 테이블에 매핑될 Student 및 Course 유형에 대한 두 개의 DbSet<TEntity> 속성이 포함됩니다. 

OnConfiguring() 메서드에서 DbContextOptionsBuilder의 인스턴스는 사용할 데이터베이스를 지정하는 데 사용됩니다.

DbContextOptionsBuilder에 확장 메서드 UseSqlServer를 추가한 MS SQL Server 공급자를 설치했습니다.

연결 문자열 "Server=.\SQLEXPRESS;Database=SchoolDB;Trusted_Connection=True;" UseSqlServer 메서드에서 데이터베이스 정보를 제공합니다. Server=는 사용할 DB 서버를 지정하고 Database=는 생성할 데이터베이스의 이름을 지정하며 Trusted_Connection=True는 Windows 인증 모드를 지정합니다. EF Core는 마이그레이션을 실행할 때 이 연결 문자열을 사용하여 데이터베이스를 만듭니다.

컨텍스트 및 엔터티 클래스를 만든 후에는 마이그레이션을 추가하여 데이터베이스를 만들 차례입니다.

마이그레이션 추가 

EF Core에는 모델을 기반으로 데이터베이스를 만들거나 업데이트하기 위한 다양한 마이그레이션 명령이 포함되어 있습니다.

이 시점에서 SchoolDB 데이터베이스는 없습니다. 

따라서 마이그레이션을 추가하여 모델(엔티티 및 컨텍스트)에서 데이터베이스를 생성해야 합니다.

NuGet 패키지 관리자 콘솔과 dotnet CLI(명령줄 인터페이스)를 사용하여 마이그레이션 명령을 실행할 수 있습니다.

Visual Studio의 도구 -> NuGet 패키지 관리자 -> 패키지 관리자 콘솔에서 NuGet 패키지 관리자 콘솔을 열고 다음 명령을 입력합니다.

PM> add-migration CreateSchoolDB 

dotnet CLI를 사용하는 경우 다음 명령어를 입력합니다.

> dotnet ef migrations add CreateSchoolDB 

그러면 아래와 같이 프로젝트에 Migrations라는 새 폴더가 생성되고 ModelSnapshot 파일이 생성됩니다.

마이그레이션을 생성한 후에도 아래와 같이 패키지 관리자 콘솔에서 update-database 명령을 사용하여 데이터베이스를 생성해야 합니다.

PM> update-database –verbose 

dotnet CLI에서 다음 명령어를 입력합니다.

> dotnet ef database update 

이렇게 하면 UseSqlServer() 메서드의 연결 문자열에 지정된 이름과 위치로 데이터베이스가 생성됩니다. 아래와 같이 각 DbSet 속성(Students 및 Courses)에 대한 테이블을 생성합니다.

이것은 데이터베이스를 만들기 위한 첫 번째 마이그레이션이었습니다. 이제 도메인 클래스 또는 구성을 추가하거나 업데이트할 때마다 add-migration 및 update-database 명령을 사용하여 데이터베이스를 모델과 동기화해야 합니다.

데이터 읽기 또는 쓰기 

이제 아래와 같이 컨텍스트 클래스를 사용하여 데이터를 저장하고 검색할 수 있습니다.

namespace EFCoreTutorials
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var context = new SchoolContext()) {

                var std = new Student()
                {
                     Name = "Bill"
                };

                context.Students.Add(std);
                context.SaveChanges();
            }
        }
    }
}

Entity Framework에는 엔터티 데이터를 저장하는 두 가지 지속성 시나리오(연결됨 및 연결 끊김)가 있습니다. 

연결된 시나리오에서는 DbContext의 동일한 인스턴스가 엔터티를 검색하고 저장하는 데 사용되지만 연결이 끊긴 시나리오에서는 다릅니다. 

이장에서는 연결된 시나리오에서 데이터를 저장하는 방법을 배웁니다.

다음 그림은 연결된 시나리오에서 CUD(Create, Update, Delete) 작업을 보여줍니다.

위 그림과 같이 Entity Framework는 DbContext.SaveChanges() 메서드가 호출될 때 EntityState가 Added, Modified 또는 Deleted인 엔터티에 대해 INSERT, UPDATE 및 DELETE 문을 빌드하고 실행 합니다. 연결된 시나리오에서 DbContext의 인스턴스는 모든 엔터티를 추적하므로 엔터티가 생성, 수정 또는 삭제될 때마다 각 엔터티에 적절한 EntityState를 자동으로 설정합니다.

데이터 삽입

DbSet.Add 메서드를 사용하여 새 엔터티를 컨텍스트(DbContext의 인스턴스)에 추가합니다. 그러면 SaveChanges() 메서드를 호출할 때 데이터베이스에 새 레코드가 삽입됩니다.

using (var context = new SchoolDBEntities())
{
    var std = new Student()
    {
        FirstName = "Bill",
        LastName = "Gates"
    };
    context.Students.Add(std);

    context.SaveChanges();
}

위의 예에서 context.Students.Add(std)는 새로 생성된 Student 엔터티 인스턴스를 Added EntityState가 있는 컨텍스트에 추가 합니다. context.SaveChanges() 메서드는 데이터베이스에 대해 다음 INSERT 문을 빌드하고 실행 합니다.

exec sp_executesql N'INSERT [dbo].[Students]([FirstName], [LastName])
VALUES (@0, @1)
SELECT [StudentId]
FROM [dbo].[Students]
WHERE @@ROWCOUNT > 0 AND [StudentId] = scope_identity()',N
''@0 nvarchar(max) ,@1 nvarchar(max) ',@0=N'Bill',@1=N'Gates'
go

데이터 업데이트 

연결된 시나리오에서 EF Core API는 컨텍스트를 사용하여 검색된 모든 엔터티를 추적합니다. 따라서 엔터티 데이터를 편집할 때 EF는 자동으로 EntityState를 수정됨으로 표시하므로 SaveChanges() 메서드를 호출할 때 데이터베이스에서 문이 업데이트됩니다.

using (var context = new SchoolContext())
{
    var std = context.Students.First<Student>(); 
    std.FirstName = "Steve";
    context.SaveChanges();
}

위의 예에서는 context.Students.First<student>()를 사용하여 데이터베이스에서 첫 번째 학생을 검색합니다. FirstName을 수정하는 즉시 컨텍스트는 DbContext 인스턴스(컨텍스트)의 범위에서 수행된 수정으로 인해 EntityState를 Modified로 설정합니다. 따라서 SaveChanges() 메서드를 호출하면 데이터베이스에서 다음 Update 문을 빌드하고 실행합니다.

exec sp_executesql N'SET NOCOUNT ON;
UPDATE [Students] SET [FirstName] = @p0
WHERE [StudentId] = @p1;
SELECT @@ROWCOUNT;
',N'@p1 int,@p0 nvarchar(4000)',@p1=1,@p0=N'Steve'
Go

업데이트 문에서 EF Core API는 값이 수정된 속성을 포함하며 나머지는 무시됩니다. 위의 예에서는 FirstName 속성만 편집되었으므로 update 문에는 FirstName 열만 포함됩니다.

데이터 삭제

DbSet.Remove() 또는 DbContext.Remove 메서드를 사용하여 데이터베이스 테이블의 레코드를 삭제합니다.

using (var context = new SchoolContext())
{
    var std = context.Students.First<Student>();
    context.Students.Remove(std);

    // or
    // context.Remove<Student>(std);

    context.SaveChanges();
}

위의 예에서 context.Students.Remove(std) 또는 context.Remove<Students>(std)는 std 엔터티 개체를 삭제됨으로 표시합니다. 따라서 EF Core는 데이터베이스에서 다음 DELETE 문을 빌드하고 실행합니다.

exec sp_executesql N'SET NOCOUNT ON;
DELETE FROM [Students]
WHERE [StudentId] = @p0;
SELECT @@ROWCOUNT;
',N'@p0 int',@p0=1
Go

따라서 연결된 시나리오에서 Entity Framework Core의 데이터를 추가, 업데이트 또는 삭제하는 것은 매우 쉽습니다.

Entity Framework Core에서 쿼리 

Entity Framework Core의 쿼리는 더 최적화된 SQL 쿼리와 C#/VB.NET 함수를 LINQ-to-Entities 쿼리에 포함하는 기능을 통해 EF 6.x와 동일하게 유지됩니다.

쿼리의 C#/VB.NET 함수 

EF Core에는 쿼리에 C# 또는 VB.NET 함수를 포함할 수 있는 LINQ-to-Entities의 새로운 기능이 있습니다. EF 6에서는 불가능했습니다.

private static void Main(string[] args)
{
    var context = new SchoolContext();
    var studentsWithSameName = context.Students
                                      .Where(s => s.FirstName == GetName())
                                      .ToList();
}

public static string GetName() {
    return "Bill";
}

위의 L2E 쿼리에서 Where 절에 GetName() C# 함수를 포함했습니다. 그러면 데이터베이스에서 다음 쿼리가 실행됩니다.

exec sp_executesql N'SELECT [s].[StudentId], [s].[DoB], [s].[FirstName], 
    [s].[GradeId], [s].[LastName], [s].[MiddleName]
FROM [Students] AS [s]
WHERE [s].[FirstName] = @__GetName_0',N'@__GetName_0 nvarchar(4000)',
    @__GetName_0=N'Bill'
Go

Eager Loading 

Entity Framework Core는 Include() 확장 메서드 및 프로젝션 쿼리를 사용하여 EF 6과 마찬가지로 관련 엔터티의 즉시 로드를 지원합니다. 이 외에도 여러 수준의 관련 엔터티를 로드하는 ThenInclude() 확장 메서드도 제공합니다. (EF 6은 ThenInclude() 메서드를 지원하지 않습니다.)

Include 

EF 6과 달리 Include() 메서드의 매개 변수로 람다 식을 지정하여 아래와 같이 탐색 속성을 지정할 수 있습니다.

var context = new SchoolContext();

var studentWithGrade = context.Students
                           .Where(s => s.FirstName == "Bill")
                           .Include(s => s.Grade)
                           .FirstOrDefault();

위의 예에서 .Include(s => s.Grade)는 단일 SQL 쿼리에서 데이터베이스의 Student 엔터티 데이터와 함께 로드할 참조 속성을 지정하기 위해 람다 식 s => s.Grade를 전달합니다. 위 쿼리는 데이터베이스에서 다음 SQL 쿼리를 실행합니다.

SELECT TOP(1) [s].[StudentId], [s].[DoB], [s].[FirstName], [s].[GradeId],[s].[LastName], 
        [s].[MiddleName], [s.Grade].[GradeId], [s.Grade].[GradeName], [s.Grade].[Section]
FROM [Students] AS [s]
LEFT JOIN [Grades] AS [s.Grade] ON [s].[GradeId] = [s.Grade].[GradeId]
WHERE [s].[FirstName] = N'Bill'

EF 6에서와 같이 Include() 메서드에서 속성 이름을 문자열로 지정할 수도 있습니다.

var context = new SchoolContext();

var studentWithGrade = context.Students
                        .Where(s => s.FirstName == "Bill")
                        .Include("Grade")
                        .FirstOrDefault();

속성 이름의 철자가 틀리거나 존재하지 않는 경우 런타임 예외가 발생하므로 위의 예는 권장되지 않습니다. 컴파일 시간 동안 오류를 감지할 수 있도록 항상 람다 식과 함께 Include() 메서드를 사용합니다.

Include() 확장 메서드는 아래와 같이 FromSql() 메서드 뒤에도 사용할 수 있습니다.

var context = new SchoolContext();

var studentWithGrade = context.Students
                        .FromSql("Select * from Students where FirstName ='Bill'")
                        .Include(s => s.Grade)
                        .FirstOrDefault();   

참고: Include() 확장 메서드는 DbSet.Find() 메서드 이후에 사용할 수 없습니다. 예를 들어 EF Core 2.0에서는 context.Students.Find(1).Include()가 불가능합니다. 이는 향후 버전에서 가능할 수 있습니다.

Multiple Include 

Include() 메서드를 여러 번 사용하여 동일한 엔터티의 여러 탐색 속성을 로드합니다. 예를 들어 다음 코드는 학생의 Grade 및 StudentCourses 관련 엔터티를 로드합니다.

var context = new SchoolContext();

var studentWithGrade = context.Students.Where(s => s.FirstName == "Bill")
                        .Include(s => s.Grade)
                        .Include(s => s.StudentCourses)
                        .FirstOrDefault();

위의 쿼리는 단일 데이터베이스 왕복에서 두 개의 SQL 쿼리를 실행합니다.

SELECT TOP(1) [s].[StudentId], [s].[DoB], [s].[FirstName], [s].[GradeId], [s].[LastName], 
        [s].[MiddleName], [s.Grade].[GradeId], [s.Grade].[GradeName], [s.Grade].[Section]
FROM [Students] AS [s]
LEFT JOIN [Grades] AS [s.Grade] ON [s].[GradeId] = [s.Grade].[GradeId]
WHERE [s].[FirstName] = N'Bill'
ORDER BY [s].[StudentId]
Go

SELECT [s.StudentCourses].[StudentId], [s.StudentCourses].[CourseId]
FROM [StudentCourses] AS [s.StudentCourses]
INNER JOIN (
    SELECT DISTINCT [t].*
    FROM (
        SELECT TOP(1) [s0].[StudentId]
        FROM [Students] AS [s0]
        LEFT JOIN [Grades] AS [s.Grade0] ON [s0].[GradeId] = [s.Grade0].[GradeId]
        WHERE [s0].[FirstName] = N'Bill'
        ORDER BY [s0].[StudentId]
    ) AS [t]
) AS [t0] ON [s.StudentCourses].[StudentId] = [t0].[StudentId]
ORDER BY [t0].[StudentId]
Go

ThenInclude 

EF Core는 여러 수준의 관련 엔터티를 로드하는 새로운 ThenInclude() 확장 메서드를 도입했습니다. 다음 예를 고려하십시오.

var context = new SchoolContext();

var student = context.Students.Where(s => s.FirstName == "Bill")
                        .Include(s => s.Grade)
                            .ThenInclude(g => g.Teachers)
                        .FirstOrDefault();

위의 예에서 .Include(s => s.Grade) 는 Student 엔터티의 Grade 참조 탐색 속성을 로드합니다. .ThenInclude(g => g.Teachers)는 Grade 엔터티의 Teacher 컬렉션 속성을 로드합니다. thenInclude 메서드는 Include 메서드 다음에 호출해야 합니다. 위의 내용은 데이터베이스에서 다음 SQL 쿼리를 실행합니다.

SELECT TOP(1) [s].[StudentId], [s].[DoB], [s].[FirstName], [s].[GradeId], [s].[LastName],
         [s].[MiddleName], [s.Grade].[GradeId], [s.Grade].[GradeName], [s.Grade].[Section]
FROM [Students] AS [s]
LEFT JOIN [Grades] AS [s.Grade] ON [s].[GradeId] = [s.Grade].[GradeId]
WHERE [s].[FirstName] = N'Bill'
ORDER BY [s.Grade].[GradeId]
Go

SELECT [s.Grade.Teachers].[TeacherId], [s.Grade.Teachers].[GradeId], [s.Grade.Teachers].[Name]
FROM [Teachers] AS [s.Grade.Teachers]
INNER JOIN (
    SELECT DISTINCT [t].*
    FROM (
        SELECT TOP(1) [s.Grade0].[GradeId]
        FROM [Students] AS [s0]
        LEFT JOIN [Grades] AS [s.Grade0] ON [s0].[GradeId] = [s.Grade0].[GradeId]
        WHERE [s0].[FirstName] = N'Bill'
        ORDER BY [s.Grade0].[GradeId]
    ) AS [t]
) AS [t0] ON [s.Grade.Teachers].[GradeId] = [t0].[GradeId]
ORDER BY [t0].[GradeId]
go

Projection Query 

Include() 또는 ThenInclude() 메서드 대신 프로젝션 쿼리를 사용하여 여러 관련 엔터티를 로드할 수도 있습니다. 다음 예제에서는 Student, Grade 및 Teacher 엔터티를 로드하는 프로젝션 쿼리를 보여 줍니다.

var context = new SchoolContext();

var stud = context.Students.Where(s => s.FirstName == "Bill")
                        .Select(s => new
                        {
                            Student = s,
                            Grade = s.Grade,
                            GradeTeachers = s.Grade.Teachers
                        })
                        .FirstOrDefault();

위의 예에서 .Select 확장 메서드는 결과에 Student, Grade 및 Teacher 엔터티를 포함하는 데 사용됩니다. 위의 thenInclude() 메서드와 동일한 SQL 쿼리를 실행합니다.

Lazy Loading 

Entity Framework Core 2.0에서는 지연 로드가 지원되지 않습니다.

Explicit Loading 

Entity Explicit 로딩은 EF 6에서와 같은 방식으로 작동합니다.

엔터티 프레임워크는 데이터베이스와 같은 세 가지 유형의 관계를 지원합니다. 1) 일대일 2) 일대다 3) 다대다

다음 그림은 해당 EDM의 비주얼 디자이너와 모든 엔터티 및 이들 간의 관계를 보여줍니다.

엔터티 프레임워크에서 각 관계(연관)를 어떻게 관리하는지 살펴보겠습니다.

일대일 관계 

위의 그림에서 볼 수 있듯이 Student와 StudentAddress는 일대일 관계(0 또는 1)를 갖습니다.

학생은 하나 또는 0개의 주소만 가질 수 있습니다.

StudentAddress 엔터티는 PrimaryKey와 ForeignKey로 StudentId 속성을 모두 가지므로 일대일 관계가 됩니다.

public partial class Student
{
    public Student()
    {
        this.Courses = new HashSet<Course>();
    }
    
    public int StudentID { get; set; }
    public string StudentName { get; set; }
    public Nullable<int> StandardId { get; set; }
    public byte[] RowVersion { get; set; }
    
    public virtual StudentAddress StudentAddress { get; set; }
    }
    
public partial class StudentAddress
{
    public int StudentID { get; set; }
    public string Address1 { get; set; }
    public string Address2 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    
    public virtual Student Student { get; set; }
}

위의 예에서 StudentId 속성은 PrimaryKey와 ForeignKey여야 합니다. 이는 컨텍스트 클래스의 OnModelCreating 메서드에서 Fluent API를 사용하여 구성할 수 있습니다.

일대다 관계 

이를 나타내기 위해 Standard 엔터티에는 Teachers 컬렉션 탐색 속성(복수형임을 유의 하십시오)이 있으며, 이는 하나의 Standard에 Teacher(많은 교사) 컬렉션이 있을 수 있음을 나타냅니다. 그리고 Teacher 엔터티에는 Teacher가 하나의 표준과 연결되어 있음을 나타내는 Standard 탐색 속성(참조 속성)이 있습니다. 또한 StandardId 외래 키(표준 엔터티의 PK)도 포함합니다. 이렇게 하면 일대다 관계가 됩니다.

public partial class Standard
{
    public Standard()
    {
        this.Teachers = new HashSet<Teacher>();
    }
    
    public int StandardId { get; set; }
    public string StandardName { get; set; }
    public string Description { get; set; }
    
    public virtual ICollection<Teacher> Teachers { get; set; }
}

public partial class Teacher
{
    public Teacher()
    {
        this.Courses = new HashSet<Course>();
    }
    
    public int TeacherId { get; set; }
    public string TeacherName { get; set; }
    public Nullable<int> TeacherType { get; set; }
  

다대다 관계 

데이터베이스에는 두 테이블(Student 및 Course 테이블)의 기본 키를 포함하는 StudentCourse 조인 테이블이 포함됩니다. Entity Framework는 CSDL 및 비주얼 디자이너에서 조인 테이블에 대한 엔터티 집합(DbSet 속성)이 없어 다대다 관계를 나타냅니다. 대신 매핑을 통해 이를 관리합니다.

위 그림에서 볼 수 있듯이 Student 엔터티에는 Courses 컬렉션 탐색 속성이 포함되어 있고 Course 엔터티에는 Students 컬렉션 탐색 속성이 포함되어 있어 둘 사이의 다대다 관계를 나타냅니다.

다음 코드 조각은 Student 및 Course 엔터티 클래스를 보여줍니다.

public partial class Student
{
    public Student()
    {
        this.Courses = new HashSet<Course>();
    }
    
    public int StudentID { get; set; }
    public string StudentName { get; set; }
    public Nullable<int> StandardId { get; set; }
    public byte[] RowVersion { get; set; }
    
    public virtual ICollection<Course> Courses { get; set; }
}
    
public partial class Course
{
    public Course()
    {
        this.Students = new HashSet<Student>();
    }
    
    public int CourseId { get; set; }
    public string CourseName { get; set; }
    public System.Data.Entity.Spatial.DbGeography Location { get; set; }
    
    public virtual ICollection<Student> Students { get; set; }
}

참고: 엔터티 프레임워크는 조인 테이블(이 경우 StudentCourse)에 두 테이블의 PK 이외의 열이 포함되지 않은 경우에만 다대다 관계를 지원합니다. 조인 테이블에 DateCreated와 같은 추가 열이 포함된 경우 EDM은 중간 테이블에도 엔터티를 생성하므로 다대다 엔터티에 대한 CRUD 작업을 수동으로 관리해야 합니다.

XML 보기에서 EDM을 엽니다. SSDL(스토리지 스키마)에는 StudentCourse 엔티티 세트가 있지만 CSDL에는 없는 것을 볼 수 있습니다. 대신 Student 및 Course 엔터티의 탐색 속성에 매핑됩니다. MSL(C-S Mapping)에는 <AssociationSetMapping/> 섹션의 StudentCourse 테이블에 학생과 코스 간의 매핑이 있습니다.

따라서 다대다 관계는 EDM에서 C-S 매핑으로 관리되고 있습니다. 따라서 과정에 학생을 추가하거나 학생 엔터티에 과정을 추가하고 저장하면 추가된 학생 및 과정의 PK가 StudentCourse 테이블에 삽입됩니다. 따라서 이 매핑은 두 엔터티 간의 편리한 연결을 직접 가능하게 할 뿐만 아니라 이러한 조인에 대한 쿼리, 삽입 및 업데이트를 관리합니다.

컨텍스트 클래스(DbContext에서 파생됨)는 데이터베이스 테이블 및 뷰에 매핑되는 엔터티에 대한 DbSet 유형 속성을 포함 해야 합니다.

DbSet 클래스의 중요한 메서드가 나열되어 있습니다.

 

Entity Framework Core: DbContext

public class SchoolContext : DbContext
{
    public SchoolContext()
    {
  
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
    }
    //entities
    public DbSet<Student> Students { get; set; }
    public DbSet<Course> Courses { get; set; }
} 

Entity Framework Core에서 기존 데이터베이스에 대한 컨텍스트 및 엔터티 클래스를 만드는 방법을 배웁니다.

기존 데이터베이스에 대한 엔터티 및 컨텍스트 클래스를 생성하는 것을 데이터베이스 우선 접근 방식이라고 합니다.

EF Core는 EF 6과 유사한 엔터티 및 컨텍스트 클래스를 생성하기 위한 DB 모델 및 마법사용 비주얼 디자이너를 지원하지 않습니다.

따라서 Scaffold-DbContext 명령을 사용 하여 리버스 엔지니어링을 수행 해야 합니다.

이 명령은 기존 데이터베이스의 스키마를 기반으로 엔터티 및 컨텍스트 클래스(DbContext 파생)를 만듭니다.

아래 표시된 로컬 MS SQL Server에서 다음 SchoolDB 데이터베이스에 대한 엔터티 및 컨텍스트 클래스를 생성해 보겠습니다.

Scaffold-DbContext Command

Scaffold-DbContext [-Connection] [-Provider] [-OutputDir] [-Context] [-Schemas>] [-Tables>] 
                    [-DataAnnotations] [-Force] [-Project] [-StartupProject] [<CommonParameters>]

PM> Scaffold-DbContext "Server=.\SQLExpress;Database=SchoolDB;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models

Database=SchoolDB; 클래스를 생성할 데이터베이스 이름 "SchoolDB"를 지정합니다.

Trusted_Connection=True; Windows 인증을 지정합니다. Windows 자격 증명을 사용하여 SQL Server에 연결합니다.

두 번째 매개변수는 공급자 이름입니다.

우리는 SQL Server용 공급자를 사용하므로 Microsoft.EntityFrameworkCore.SqlServer입니다.

-OutputDir 매개변수는 이 경우 Models 폴더인 모든 클래스를 생성하려는 디렉토리를 지정합니다.

Scaffold-DbContext 명령에 대한 자세한 도움말을 보려면 다음 명령을 사용하십시오.

PM> get-help scaffold-dbcontext –detailed

위의 Scaffold-DbContext 명령은 Models폴더의 모든 엔터티에 대한 Fluent API 구성을 사용하여 SchoolDB 데이터베이스 및 컨텍스트 클래스(DbContext 파생)의 각 테이블에 대한 엔터티 클래스를 만듭니다.

다음은 Student 테이블에 대해 생성된 Student 엔터티 클래스입니다.

using System;
using System.Collections.Generic;

namespace EFCoreTutorials.Models
{
    public partial class Student
    {
        public Student()
        {
            StudentCourse = new HashSet<StudentCourse>();
        }

        public int StudentId { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public int? StandardId { get; set; }

        public Standard Standard { get; set; }
        public StudentAddress StudentAddress { get; set; }
        public ICollection<StudentCourse> StudentCourse { get; set; }
    }
}

다음은 데이터를 저장 하거나 검색하는 데 사용할 수 있는 SchoolDBContext 클래스입니다.

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

namespace EFCoreTutorials.Models
{
    public partial class SchoolDBContext : DbContext
    {
        public virtual DbSet<Course> Course { get; set; }
        public virtual DbSet<Standard> Standard { get; set; }
        public virtual DbSet<Student> Student { get; set; }
        public virtual DbSet<StudentAddress> StudentAddress { get; set; }
        public virtual DbSet<StudentCourse> StudentCourse { get; set; }
        public virtual DbSet<Teacher> Teacher { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (!optionsBuilder.IsConfigured)
            {
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
                optionsBuilder.UseSqlServer(@"Server=.\SQLExpress;Database=SchoolDB;Trusted_Connection=True;");
            }
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Course>(entity =>
            {
                entity.Property(e => e.CourseName)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.HasOne(d => d.Teacher)
                    .WithMany(p => p.Course)
                    .HasForeignKey(d => d.TeacherId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("FK_Course_Teacher");
            });

            modelBuilder.Entity<Standard>(entity =>
            {
                entity.Property(e => e.Description)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.StandardName)
                    .HasMaxLength(50)
                    .IsUnicode(false);
            });

            modelBuilder.Entity<Student>(entity =>
            {
                entity.Property(e => e.StudentId).HasColumnName("StudentID");

                entity.Property(e => e.FirstName)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.LastName)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.HasOne(d => d.Standard)
                    .WithMany(p => p.Student)
                    .HasForeignKey(d => d.StandardId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("FK_Student_Standard");
            });

            modelBuilder.Entity<StudentAddress>(entity =>
            {
                entity.HasKey(e => e.StudentId);

                entity.Property(e => e.StudentId)
                    .HasColumnName("StudentID")
                    .ValueGeneratedNever();

                entity.Property(e => e.Address1)
                    .IsRequired()
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.Address2)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.City)
                    .IsRequired()
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.Property(e => e.State)
                    .IsRequired()
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.HasOne(d => d.Student)
                    .WithOne(p => p.StudentAddress)
                    .HasForeignKey<StudentAddress>(d => d.StudentId)
                    .HasConstraintName("FK_StudentAddress_Student");
            });

            modelBuilder.Entity<StudentCourse>(entity =>
            {
                entity.HasKey(e => new { e.StudentId, e.CourseId });

                entity.HasOne(d => d.Course)
                    .WithMany(p => p.StudentCourse)
                    .HasForeignKey(d => d.CourseId)
                    .OnDelete(DeleteBehavior.ClientSetNull)
                    .HasConstraintName("FK_StudentCourse_Course");

                entity.HasOne(d => d.Student)
                    .WithMany(p => p.StudentCourse)
                    .HasForeignKey(d => d.StudentId)
                    .HasConstraintName("FK_StudentCourse_Student");
            });

            modelBuilder.Entity<Teacher>(entity =>
            {
                entity.Property(e => e.StandardId).HasDefaultValueSql("((0))");

                entity.Property(e => e.TeacherName)
                    .HasMaxLength(50)
                    .IsUnicode(false);

                entity.HasOne(d => d.Standard)
                    .WithMany(p => p.Teacher)
                    .HasForeignKey(d => d.StandardId)
                    .OnDelete(DeleteBehavior.Cascade)
                    .HasConstraintName("FK_Teacher_Standard");
            });
        }
    }
}

DotNet CLI 

dotnet 명령줄 인터페이스를 사용하여 EF Core 명령을 실행하는 경우 명령 프롬프트를 열고 루트 폴더로 이동하여 다음 dotnet ef dbcontext scaffold 명령을 실행합니다.

> dotnet ef dbcontext scaffold "Server=.\SQLEXPRESS;Database=SchoolDB;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -o Models 

여기에서는 Visual Studio 2017을 사용하여 .NET Core 애플리케이션에서 Entity Framework Core 2.0을 설치하고 사용하는 방법을 배웁니다.

EF Core는 .NET Core 및 표준 .NET 프레임워크의 일부가 아닙니다. NuGet 패키지로 제공됩니다. 애플리케이션에서 EF Core를 사용하려면 다음 두 가지에 대해 NuGet 패키지를 설치 해야 합니다.

• EF Core DB provider
• EF Core tools

액세스하려는 데이터베이스에 대한 공급자 패키지를 선택합니다.

 

 

공급자 NuGet 패키지는 Microsoft.EntityFrameworkCore.Relational 및 System.Data.SqlClient와 같은 다른 종속 패키지도 설치 했습니다.

이를 통해 Visual Studio 내의 PMC(패키지 관리자 콘솔)에서 직접 스캐폴딩, 마이그레이션 등을 위한 EF Core 명령을 실행할 수 있습니다.

이제 프로젝트의 루트 폴더에서 명령 프롬프트(또는 터미널)를 열고 아래와 같이 dotnet ef로 시작하는 CLI에서 EF Core 명령을 실행합니다.

 

Entity Framework Core는 EF 6.x 이후의 새 버전의 Entity Framework입니다. 오픈 소스로 가볍고 확장 가능하며, Entity Framework 데이터 액세스 기술의 플랫폼 간 버전입니다.

Entity Framework는 O/RM(개체/관계형 매핑) 프레임워크입니다. 개발자에게 데이터베이스의 데이터에 액세스하고 저장하기 위한 자동화된 메커니즘을 제공하는 ADO.NET의 향상된 기능입니다.

EF Core는 .NET Core 애플리케이션과 함께 사용 하기 위한 것입니다. 또한 표준 .NET 4.5+ 프레임워크 기반 응용 프로그램과 함께 사용 할 수도 있습니다.

아래 그림 지원되는 애플리케이션 유형, .NET Framework 및 OS를 보여 줍니다.

EF CORE 버전 기록 

 

EF Core Roadmap: docs.microsoft.com/en-us/ef/core/what-is-new/roadmap

Track EF Core's issues at https://github.com/aspnet/EntityFrameworkCore/issues

EF Core Official Documentation: https://docs.microsoft.com/ef/core

EF CORE 개발 접근 방식 

EF Core는 두 가지 개발 접근 방식을 지원 합니다. 1) 코드 우선 2) 데이터베이스 우선

EF Core는 주로 코드 우선 접근 방식을 대상으로 합니다.

DB 모델용 비주얼 디자이너 또는 마법사가 EF Core 2.0부터 지원되지 않기 때문에 데이터베이스 우선 접근 방식을 거의 지원하지 않습니다.

코드 우선 접근 방식에서 EF Core API는 도메인 클래스에 제공된 규칙 및 구성을 기반으로 마이그레이션을 사용하여 데이터베이스와 테이블을 만듭니다. 이 접근 방식은 DDD(Domain Driven Design)에서 유용합니다.

데이터베이스 우선 접근 방식에서 EF Core API는 EF Core 명령을 사용하여 기존 데이터베이스를 기반으로 도메인 및 컨텍스트 클래스를 만듭니다. 이것은 비주얼 디자이너 또는 마법사를 지원하지 않기 때문에 EF Core에서 제한적으로 지원 됩니다.

EF Cre vs EF 6 

Entity Framework Core는 .NET Core 애플리케이션용 Entity Framework의 새롭고 향상된 버전 입니다. EF Core는 새롭기 때문에 아직 EF 6 만큼 성숙하지 않습니다.

EF Core는 EF 6 과 마찬가지로 다음 기능 및 개념을 계속 지원 합니다.

• DbContext & DbSet
• Data Model
• Querying using Linq-to-Entities
• Change Tracking
• SaveChanges
• Migrations

EF Core는 EF 6의 대부분의 기능을 점진적으로 포함 할 예정입니다. 

그러나 다음과 같이 EF Core 2.0에서 지원되지 않는 EF 6의 일부 기능이 있습니다.

• EDMX/ Graphical Visualization of Model
• Entity Data Model Wizard (for DB-First approach)
• ObjectContext API
• Querying using Entity SQL.
• Automated Migration
• Inheritance: Table per type (TPT)
• Inheritance: Table per concrete class (TPC)
• Many-to-Many without join entity
• Entity Splitting
• Spatial Data
• Lazy loading of related data
• Stored procedure mapping with DbContext for CUD operation
• Seed data
• Automatic migration

EF Core에는 EF 6.x에서 지원되지 않는 다음과 같은 새로운 기능이 포함 되어 있습니다.

• Easy relationship configuration
• Batch INSERT, UPDATE, and DELETE operations
• In-memory provider for testing
• Support for IoC (Inversion of Control)
• Unique constraints
• Shadow properties
• Alternate keys
• Global query filter
• Field mapping
• DbContext pooling
• Better patterns for handling disconnected entity graphs

여기에서 EF Core와 EF 6의 차이점에 대해 자세히 알아 보세요.

EF Core 데이터베이스 공급자 

Entity Framework Core는 공급자 모델을 사용하여 다양한 데이터베이스에 액세스합니다.

EF Core에는 설치해야 하는 NuGet 패키지로 공급자가 포함되어 있습니다.

 

구매 재고관리 입출고 수입품 관리 프로그램 구축 판매 정산 프로그램 설계/개발 접수 내용 정리 및 문서화 자동화 프로그램 견적서 작성 및 관리 윈도우 프로그램 개발 재택근무 관리 소프트웨어 개발 재고관리 프로그램 개발 해상 운임 비용 정리 및 통계 프로그램 개발 및 구축 입주민 관리 프로그램 개발 유휴자원 중계 시스템 개발 비행 일지 기록 프로그램 개발 매출 관리 자재 출고 계획 관리 프로그램 개발 유통사 고객 데이터 프로그램 개발 현장 유지보수 관리 전산 프로그램 개발 부품 창고 재고 관리 프로그램 개발 엑셀파일 데이터 정리/가공 프로그램 개발 생산 관리 윈도우 프로그램 개발 적정 포장 박스 산정 윈도우 프로그램 개발 실험 결과 처리 프로그램 개발 자재비 원가 계산 윈도우 프로그램 개발 

ASP.NET Core

ASP.NET Core는 Windows, macOS 또는 Linux에서 클라우드 기반 최신 웹 앱을 빌드하기 위한 오픈 소스 플랫폼 간 프레임워크 입니다.

주요 장점

• 웹 UI 및 웹 API를 동일한 과정으로 빌드
• 테스트 가능성을 고려하여 설계
  
• Razor Pages는 더 쉽고 더 생산적으로 코딩 페이지에 초점을 맞춘 시나리오를 생성
  
• Blazor를 사용하여 JavaScript와 함께 브라우저에서 C#을 사용(.NET으로 작성된 서버 및 클라이언트 앱을 공유)
  
• Windows, macOS 및 Linux에서 개발하고 실행
  
• 오픈 소스이며 커뮤니티에 중점
  
• 최신 클라이언트 쪽 프레임워크 및 워크플로개발을 통합
  
• gRPC를 사용하여 RPC(원격 프로시저 호출) 서비스 호스팅을 지원
  
• 클라우드를 갖춘 환경 기반 구성 시스템
  
• 종속성 주입이 기본 제공
  
• 간단한 고성능 모듈식 HTTP 요청 파이프라인을 포함
  
• Kestrel, IIS, HTTP.sys, Nginx, Apache, Docker  
  
• Side-by-side 버전 관리
  
• 최신 웹 개발을 간소화하는 도구를 포함

주요 비교 사항

웹 개발자의 의견은 다르기 때문에 ASP.NET Core 으로 이동 할 가치가 있는지에 대한 질문은 여전히 ​​열려 있습니다. 

결정은 신중하게 고려 되어야 하고 강력한 주장에 의해 뒷받침 되어야 합니다. 

그럼에도 불구하고 Asp.NET Core는 우리의 현재이자 미래입니다. 

그리고 아직 끝나지 않았습니다. 

곧 .NET 5에서 무엇을 기대할 수 있는지 알게 될 것입니다. 

시리얼 통신 데이터 모니터링 프로그램 개발,시리얼 통신 모니터링,시리얼 통신 테스트 프로그램,시리얼 통신 후킹, HW 시리얼 통신, 시리얼통신 모듈 개발 , RS232 통신 , RS232C통신 , RS485 통신 

바코드 생성 c# 프로그램 수정 , AutoCad 자동 작성 프로그램 개발 , 여러대의 컴퓨터 원격 제어 관리 프로그램 개발,영상 스트리밍 멀티뷰어 솔루션 개발,기업 정보 크롤링 윈도우 프로그램 개발,POS 영수증 데이터 전송하는 윈도우용 프로그램 개발,전지 FCS C#/BizActor 개발,장비에서 전송받은 SMS 발송 서버 구축 및 개발,교과목 설계 지원 프로그램 개발,아두이노 보드 통신 윈도우 GUI 프로그램 개발

- 다양한 경험(소프트웨어 / 하드웨어 개발)을 바탕으로 고객이 만족하는 방향으로 더 많은 포트폴리오는 사이트 방문해 주시면 볼 수 있습니다.

- 통합 프로그램 외주 개발, 고객 주문형 프로그램 개발, IT 개발 컨설팅

홈페이지 주소

http://www.chaoreumsoft.co.kr/ 

회사소개서 바로가기

- Language / Platform

C#, WPF, C, JavaScirpt , .Net Core, .Net Framework , .Net Standard , .Net5,6 ASP.NET MVC Core , AWS , Azure

- DBMS

Mssql, Oracle, Mysql, Mariadb , SqlLite , Nosql

- Communication

TCP/IP , RS232/485, Bluetooth , WIFI, NFC , CAN , ZigBee m RoLa , Modbus , FTP , HTTP , SPI , I2C

- Hardware

Atmega 시리즈, ESP 8266 / 32 , 라즈베리파이 ,아두이노, STM32

- Embedded

freertos , fatfs , lwip , http core , webserver coremotor 제어(dc, bldc , motrol control board)

- Tools

Visual Studio , Eclipse , Code Vision , KEIL ARM , Arduino IDE , Truestudio , Atmel Studio, Nextion Editor

VisualLcdStudio, TinyCad

 

시험 장비 프로그램 , Windows 위주의 응용 프로그램 개발 및 제작, 윈도우 어플리케이션 개발 , PC 프로그램 개발 , WPF 개발  , 외주 용역 프로그램 , SI 개발  , 소프트웨어 개발  , 응용소프트웨어 개발  , WPF 외주 개발   , WPF SI 개발  , WPF C# 외주 개발 , 모니터링 프로그램 개발 , C# 모니터링 프로그램 개발 , WPF 모니터링 프로그램 개발 , 스타트업 외주 개발 , 프로그램 외주 개발

프레임워크 : .Net Standard , .net Core 3.1

설명 : C# 기반의 간단한 Rest API , http , 소규모 전용 서버(웹소켓 , API 연동) 등 개발 가능

       다양한 포맷 지원 가능

ex) URL 링크에 따른 Json 보여주기

적용범위

  서버 어플리케이션 개발시 동시에 간단한 웹서버 운영시

  간단한 API 사용자 정의용으로 개발시

  REST API 사용시

  내부적으로 사용자 정의 사용시(모니터링 데이터를 실시간으로 조회(클라이언트 프로그램 And 브라우저 ))

성공 적인 소프트웨어를 개발 하기 위해선 많은 계획과 브레인스토밍이 필요 합니다. 

올바른 프레임워크를 결정하는 것은 제품 소유자와 CTO 모두 에게 어려운 일입니다. 

개발자는 자신의 선택을 옹호하는 경향이 있으며, 그들 중 하나는 프로그래밍 언어의 장점 목록을 제공 하고 다른 개발자는 수천 가지 단점을 찾을 수 있습니다. 결국 잘못된 선택은 돈과 시간의 낭비로 이어 집니다.

.NET Core와 Java의 두 가지 옵션으로 선택 범위를 좁혔습니다. 

오늘날 대규모 앱을 개발하는 데 사용하는 주요 플랫폼이지만 최종 사용자에게 효율적인 소프트웨어를 제공하기 위해 알아야 하는 기

본적인 차이점이 있습니다. 사용 통계를 간단히 살펴보겠습니다. 

2021년 기준으로 상위 1000대 웹사이트 중 18.6%가 ASP .NET을 사용하고 있는 반면 Java는 22.1%의 웹사이트를 운영하고 있습니다.

구식 자바의 유산

 현재 Java는 세계 최고의 프로그래밍 언어 중 하나입니다. 1996년에 처음 출시되었지만 Java는 전 세계적으로 5번째로 인기 있는 프로그래밍 언 어로 여전히 인기를 얻고 있습니다. 매우 흥미롭게도 Java는 비교적 배우고 작업 하기 쉽습니다. 소스 코드를 작성 하면 바이트 코드로 컴파일되며 다양한 장치의 요구 사항에 따라 JVM(Java Virtual Machine)이 다른 플랫폼에서 동일한 코드를 실행하고 실행할 수 있습니다.

금융 및 주식 시장에서 IoT 및 전자 상거래에 이르기까지 개발자는 생각 할 수 있는 모든 틈새 시장에서 Java를 사용합니다. Oracle OpenJDK 또는 Oracle JDK(Java Development Kit)와 같은 무료 기술입니다. Java를 사용하면 Scala, Groovy, Kotlin 등과 같은 다른 언어로 작업할 수도 있습니다. 

.NET을 통한 더욱 유망한 접근 방식

 Microsoft는 2002년에 Microsoft 제품 사용자만을 위해 .NET을 도입 했습니다. iOS, Android 또는 Linux에서 앱을 코딩하거나 실행할 수 없도록 하는 제한된 소스 시스템이었습니다. 과거에는 제한된 사용으로 인해 회사에서 이 프레임워크를 제대로 인식하지 못했습니다. 

2016년에 Microsoft는 이 프레임워크에 대한 전체적인 인식을 바꾼 .NET Core를 시장에 출시 했습니다. 이제 Java의 좋은 경쟁자가 되었으며 회사는 다양한 소프트웨어 프로젝트에서 이 플랫폼을 효율적으로 사용합니다.

현재 최신 .NET 6 릴리스가 출시되었으며 모든 주요 운영 체제가 이 릴리스와 호환됩니다. 즉시 사용할 수 있도록 앱을 개발 및 사용자 지정하기 위한 여러 추가 기능, 라이브러리 및 타사 도구와 함께 기본 .NET 도구를 사용할 수 있습니다. 객체 지향 패러다임을 따르며 C++와 같은 언어(C#, F# 등)와 호환됩니다.

.NET Core vs Java : 유사점 

이 두 기술 중 소프트웨어 프로젝트 성공에 더 나은 기술은 전적으로 비즈니스 요구 사항에 달려 있습니다. 개발자는 이 두 프레임워크를 모두 사용하여 모든 유형의 엔터프라이즈 수준 소프트웨어를 구축 합니다. 

Java와 .NET Core는 모두 개체 지향적이며 코드를 개별 모듈로 구성하는 데 도움이 되는 모듈식 프로그래밍을 지원 합니다. 

그 결과 디버깅이 더 쉬워지고 유연성이 보장 되며 코드를 재사용할 수 있습니다.

따라서 고부하 시스템 및 복잡한 아키텍처로 작업해야 하는 경우 이것이 최선의 옵션입니다.

이 두 가지 기술을 사용하는 잘 정립된 회사를 보여 드리겠습니다.

.NET Core -> Microsoft, Accenture, StackOverflow, Cisco, Dell, Intel 등

Java -> 구글, 링크드인, 스포티파이, 인스타그램, 넷플릭스, 우버 등

.NET Core vs Java : 주요 유사점 

기본 

.NET Core는 Microsoft는 .NET을 오픈 소스 프레임워크로 개발 했으며 , Java는 James Gosling은 Sun Microsystems가 1995년에 출시한 프로그래밍 언어로 개발 했습니다.

운영시스템

.NET과 Java 모두 Windows와 Linux를 서버로 사용 가능

Java는 다양한 운영 체제에서 실행되는 데 도움이 되는 특정 JVM을 사용합니다. 코드를 한 번만 작성하면 모든 곳에서 사용할 수 있습니다.

.NET Core에 대해서는 Microsoft가 처음에 완전히 제어하고 Windows에서만 실행 했지만 곧 다른 운영 체제와도 호환 되도록 접근 방식을 크게 변경했습니다. 따라서 .NET Core 프레임워크는 대규모 수정을 거쳤으며 라이선스 비용 없이 완전히 크로스 플랫폼, 오픈 소스입니다. 

지원언어

JNI(Java Native Interface) 도구는 이 프레임워크가 다른 언어와 통합되는 데 도움이 됩니다. 이와 관련하여 Kotlin은 Java와 완전히 호환되기 때문에 최근에 상당한 명성을 얻었다는 점을 언급해야 합니다. 따라서 Kotlin과 Java로 동시에 제품을 개발할 수 있습니다. 결과적으로 이전 Java 프로젝트의 손실을 방지하고 Kotlin에서 새 기능을 작성할 수 있습니다.

.NET Core는 어떻습니까? VB.NET, C++, C#, F# 등을 포함하여 약 20개의 다른 언어를 지원합니다. 따라서 ASP.NET Core 프레임워크를 사용한 엔터프라이즈 애플리케이션 개발은 보다 유연하고 효율적입니다.

통합 개발 환경 및 도구 

IDE는 앱을 빌드하고 테스트하기 위해 개발자에게 다른 중요한 도구를 제공할 수 있는 중요한 소프트웨어 도구입니다. 

Java에는 Oracle NetBeans, Oracle JDeveloper, IntelliJ Idea 및 Eclipse의 4가지 기본 IDE가 있습니다.

그러한 IDE는 코드를 쉽게 작성할 수 있도록 디버거, 컴파일러, 코드 편집기 및 Maven과 같은 요소와 같은 소수의 리소스를 제공

이 도메인을 처음 접하더라도 이러한 사용자 친화적인 플랫폼을 쉽게 사용할 수 있습니다. 

예를 들어, Eclipse IDE는 개발자가 코드를 쉽게 작성하고 테스트하는 데 도움이 되는 몇 가지 플러그인을 제공합니다.

반면 Visual Studio는 언어별 환경을 포함하여 많은 기능을 제공하는 .NET 앱용 기본 IDE입니다.

 이 .NET IDE를 컴파일, 편집 등과 같은 다양한 개발 작업을 돕는 다양한 문서 인터페이스가 있는 단일 작업 공간으로 사용할 수 있습니다.

Visual Studio의 주요 기능은 시간을 절약하고 개발 프로세스의 속도를 높이며 앱의 동작과 모양을 사용자 지정하는 데 도움이 될 수 있는 디자인 타임에 생성하는 것입니다.

성능비교 

오랫동안 .NET Core 앱과 Java 앱 사이에는 성능 차이가 크지 않았습니다. Microsoft는 많은 개선했지만 결정을 내리기 전에 고려해야 할 차별화 요소가 여전히 많이 있습니다.

능률

Java는 인터프리터 언어이므로 코드를 실행한 후 기계어로 변환할 수 있습니다. 그리고 .NET Core에 대해서는 시작할 시스템에서 코드를 컴파일하고 실행합니다. 이것이 C#이 런타임 환경에서 보다 효율적으로 작동하는 이유입니다.

커뮤니티

Java가 크로스 플랫폼 프레임워크로 등장한 지 거의 26년이 되었습니다. 따라서 수년 동안 Java를 사용해 온 대규모 개발자 커뮤니티가 있습니다. 이러한 커뮤니티는 Java 앱 개발에 대한 통찰력과 경험을 제공할 수 있으므로 매우 중요합니다.

.NET은 최신 엔터프라이즈 소프트웨어 개발 동향을 따르는 비교적 새로운 기술입니다. 그것은 여전히 ​​​​항상 지원을 제공하는 숙련된 개발자와 함께 강력한 커뮤니티를 가지고 있습니다.

보안

.NET Core와 Java는 보안 면에서 놀랍습니다. 이러한 프레임워크는 코드 서명 프로세스를 지원하고 샌드박스 실행을 배포합니다. 이전에 Java는 몇 가지 보안 문제를 겪었지만 곧 수정하고 추가 보안 조치도 추가했습니다. Java에서 오류를 범할 가능성은 거의 없으며 도달 범위로 이어집니다.

.NET Core에 대해 말하자면, 비공개 소스였을 때 더 안전했습니다. 이 프레임워크에는 더 이상 이 권한이 없지만 Microsoft는 오픈 소스 시스템에 대해 효과적인 조치를 취했습니다.

학습속도

둘 다 비교적 배우고 사용하기 쉽습니다. 

Java는 오랜 기간의 앱 개발 및 커뮤니티 영향에 대한 더 많은 리소스와 문서를 가지고 있으나, .Net Core는 조금 더 어려울 수 있습니다.

인기도 및 점유율

현재 Java는 학습속도 빠르고 커뮤니티가 크며 무료 교육 리소스가 많은 가장 인기 있는 프레임워크 중 하나 입니다. 

매년 점점 더 많은 뉴비들이 이 언어를 선택하는 이유입니다. 게다가 Monster와 인디드의 많은 공석은 Java 프로그래머가 .NET 프로그래머보다 수요가 더 높다는 것을 보여줍니다. 

2020년 4월 현재 Monster는 ASP.NET 개발자를 위한 8,500개 이상의 일자리와 Java 개발자를 위한 41,000개 이상의 일자리를 평가하고 있습니다.

하지만 .NET Core의 성과도 만만치 않습니다. .NET Core는 1,792,664개의 활성 웹 사이트가 있는 전체 웹의 선도적인 기술입니다. 영국, 미국, 중국 및 기타 158개 국가와 같은 많은 국가에서 1위를 차지하고 있습니다.

2020년 말에 실시된 CodinGame 개발자 설문조사에 따르면 .NET Core는 전 세계 개발자들 사이에서 세 번째로 인기 있는 네트워크입니다.

이제 이러한 프레임워크의 몇 가지 장점과 단점을 비교 하겠습니다.

Java 장점

 이식 가능한 언어로 웹사이트를 개발 할 운영 체제 또는 시스템을 선택할 수 있는 옵션을 제공

 다형성 코드, 상속, 추상화, 객체, 클래스 등과 관련된 객체 지향 언어 / 동일한 코드를 재사용하고 모듈식 프로그램 생성

 Travis CI 및 Jenkins와 같은 최신 통합 도구의 도움으로 Java 앱을 다른 플랫폼과 완벽하게 통합

 이전 버전과의 호환성에 따른 다른 Java 플랫폼 간에 쉽게 마이그레이션

 보안이 필수적인 부분인 고급 프로그래밍 언어

 분산 컴퓨팅은 동적 네트워크 기능과 통합 되므로 매우 쉬움

Java 단점 

 비교적 사용하기 쉽지만 빌드된 앱에는 성능 문제가 있을 수 있습니다. C 또는 C++와 같은 기본적으로 컴파일된 프로그래밍 언어와 비교할 때 훨씬 느립니다. 메모리도 많이 소모합니다.

가비지 수집은 메모리를 관리하고 최적화 합니다. 따라서 가비지 수집기를 실행할 때마다 다른 모든 스레드는 작동을 중지하여 가비지 수집기 스레드의 기능을 허용합니다. 결과적으로 앱 성능에 영향을 미침

단일 패러다임 언어입니다. Java 5. 0에는 정적 가져오기가 포함되어 있으며 이전 버전에 비해 절차적 패러다임이 더 효과적으로 수용됩니다.

.NET Core 장점

개발자가 .NET Core를 선택하는 주된 이유 중 하나는 다양한 언어로 프로그래밍할 수 있는 권한을 부여하기 때문입니다. 따라서 이 프레임워크는 매우 사용자 친화적이고 다재다능 합니다.

비즈니스 요구 사항에 따라 개발자는 모든 언어의 가장 좋은 부분을 사용하고 조직만을 위한 강력한 웹 사이트를 구축

완벽한 수평 확장성을 제공 하므로 Microsoft 개발자 네트워크에서 많은 고급 도구 제공

불필요한 코드를 없애고 개발 프로세스를 가속화하는 재사용 가능한 많은 구성 요소를 사용

플랫폼 간 앱 개발은 Mac, Linux 및 Windows에서 앱을 빌드하고 실행. 즉, 전체 백엔드에 대해 동일한 C# 코드를 사용하게 됩니다.

 일반적으로 코드가 작기 때문에 유지 관리가 더 쉽습니다. 전문 개발자는 더 적은 수의 명령문 으로 쉽게 최적화할 수 있지만 새로운 개발자에게는 어려울 수 있습니다.

.NET Core 단점

다른 언어에 비해 인터넷에는 제한된 .NET Core 리소스가 있습니다. 따라서 이 프레임워크에 대해 배우고 싶다면 사용할 수 있는 문서가 많지 않습니다.

Microsoft는 정기적으로 업데이트하지만 .NET 생태계에서 도구는 매우 까다롭고 어렵습니다. 앱을 빌드하고 예외의 주요 근거를 식별하려는 경우 프레임워크와 문서가 지속적으로 업데이트되기 때문에 약간 까다로울 수 있습니다.

Visual Studio IDE 및 기타 서비스에 투자해야 하므로 .NET Core를 사용하여 앱을 개발하는 것은 비용이 발생

.NET Core 대 Java: 무엇을 선택? 

포인트 1: 웹 개발을 위한 충분한 자원이 있습니까?

너무 간단하게 들리나요? 설마. 적절한 구조는 나중에 큰 문제가 될 수 있는 중요한 요소입니다.

일반적으로 조직에는 자체 팀이 있지만 소프트웨어 프로젝트를 아웃소싱하는 다른 회사도 많이 있습니다. 따라서 자격을 갖춘 팀이 없는 경우 아웃소싱 파트너를 선택하는 것이 가능한 옵션입니다.

아웃소싱 회사에 비즈니스 요구 사항을 충족할 수 있는 숙련된 .NET 또는 Java 개발자가 있는지 확인 해야 합니다. 그런 다음 제품 아이디어에 대해 논의하고 선호하는 프로그래밍 언어를 선택하십시오. 함수형 프로그래밍과 객체 지향 프로그래밍 중에서 선택할 수 있습니다.

포인트 2: 복잡한 웹사이트/앱을 지원할 수 있는 인프라가 있습니까?

이 질문에 "예" 라고 답한 경우 .NET Core를 사용한 엔터프라이즈 앱 개발을 추천 드립니다. .NET Core는 모든 언어에서 최상의 결과를 얻을 수 있으므로 복잡한 웹 사이트 또는 앱을 개발하는 데 특히 유용합니다.

그렇지 않은 경우 보다 유연한 접근 방식을 제공할 수 있으므로 Java를 사용하는 것이 좋습니다.

포인트 3: 예산과 시간은 어떻습니까?

예, 예산은 넘을 수 없는 주요 관심사 중 하나입니다.

Microsoft 제품을 사용해 왔으며 조직을 운영하기 위해 Windows 기반 솔루션에 의존하고 예산이 빠듯 하다면 적은 비용으로 .NET Core 개발을 선택하고 ASP.NET 개발자를 고용하는 데 드는 비용을 합산하십시오.

반면에 올바른 도구를 신중하게 선택하고 지원 시스템에 액세스하지 않으면 Java 엔터프라이즈 앱을 개발하는데 많은 비용이 들 수 있습니다.

포인트 4: 풍부한 그래픽 사용자 인터페이스를 갖춘 앱을 원하십니까, 아니면 과도한 데이터 로드를 처리하기를 원하십니까?

NET Core를 사용하면 풍부한 그래픽 사용자 인터페이스가 있는 앱을 쉽게 개발할 수 있지만 Java는 많은 양의 데이터 또는 많은 수의 사용자를 관리할 수 있는 효과적인 앱을 빌드하는 데 더 적합합니다.

언제 .NET Core를 사용해야 합니까?

  Enterprise app development

  Websites and web apps

  Gaming

  Client apps

언제 JAVA 를 사용해야 합니까?

  Embedded systems

  Android apps

  Software (Jira, Eclipse)

  Enterprise apps (Spotify, Pinterest)

  Web apps (Gmail, Google Docs)

결론

.NET Core와 Java에는 옳고 그름, 좋거나 나쁜 선택이 없습니다. 

두 프레임워크 모두 장/단점이 있으며 동적이며 미래 지향적인 엔터프라이즈 수준 앱을 구축하는 데 도움이 됩니다.

따라서 두개의 프레임워크를 선택하는 것은 개발 기술과 리소스, 조직의 요구 사항 및 최종 사용자의 요구사항에 전적으로 달려 있습니다.

어느 것이 더 나은 프레임워크 인지에 대한 대답을 하자면, 이 경쟁적인 시장에서 번성하려면 이 두 기술이 모두 필요하다고 말하고 싶습니다. 

각각의 장점을 최대한 활용하여 고급 웹사이트와 앱을 구축이 가능 합니다.

우리는 귀하의 비즈니스 요구 사항을 충족하고 Java와 .NET Core 사이에서 선택하는 이러한 딜레마를 없애도록 도울 수 있습니다.

서버 쪽 애플리케이션을 빌드하는 데 지원되는 두 가지 .NET 구현에는 .NET Framework 및 .NET 5(.NET Core 포함)가 있습니다. 두 구현은 여러 가지 동일한 구성 요소를 공유하므로 둘 간에 코드를 공유할 수 있습니다. 그러나 두 구현 간에는 기본적인 차이가 있으며 수행할 항목에 따라 선택이 달라집니다. 이 문서에서는 각각 사용하는 경우에 대한 지침을 제공합니다.

NET 5 사용

- 플랫폼 간 요구 사항

- 마이크로 서비스를 대상

- Docker 컨테이너를 사용

- 고성능 및 확장 가능한 시스템이 필요

- .NET 버전이 애플리케이션별로 함께 필요

 .NET Framework를 사용

- 현재 .NET Framework를 사용

- .NET 5에 사용할 수 없는 타사 .NET 라이브러리 또는 NuGet 패키지를 사용

- .NET 5에 사용할 수 없는 .NET 기술을 사용

- .NET 5를 지원하지 않는 플랫폼을 사용

.NET 5에 사용할 수 없는 .NET 기술

일부 .NET Framework 기술은 .NET 5에서 사용할 수 없습니다. 

다음 목록은 .NET 5에서 제공 되지 않는 가장 일반적인 기술입니다.

* ASP.NET Web Forms 애플리케이션: ASP.NET Web Forms는 .NET Framework에서만 사용할 수 있습니다. 

  ASP.NET Core는 ASP.NET Web Forms에 사용할 수 없습니다.

* ASP.NET Web Page 애플리케이션: ASP.NET Web Page 는 ASP.NET Core에 포함되지 않습니다.

* WCF 서비스 구현. .NET 5에서 WCF 서비스를 사용할 수 있는 WCF 클라이언트 라이브러리가 있더라도 WCF 서버 구현은 현재 .NET Framework에서만 사용할 수 있습니다.

* 워크플로 관련 서비스: Windows WF(Workflow Foundation), 워크플로 서비스(단일 서비스의 WCF + WF) 및 WCF Data Services(이전의 “ADO.NET Data Services”)는 .NET Framework에서만 사용할 수 있습니다.

* 언어 지원: Visual Basic 및 F#은 현재 .NET 5에서 지원되지만 일부 프로젝트 형식에서는 지원되지 않습니다. 지원되는 프로젝트 템플릿 목록은 dotnet new에 대한 템플릿 옵션을 참조하세요.

자세한 링크 : https://docs.microsoft.com/ko-kr/dotnet/core/porting/net-framework-tech-unavailable

* 시작 시간, 처리량, 메모리 사용량, 안정성과 진단 기능을 갖춘 전체 플랫폼 목표

.NET 5 = .NET Core vNext 

.NET 5 is the next step forward with .NET Core. The project aims to improve .NET in a few key ways: 

• Produce a single .NET runtime and framework that can be used everywhere and that has uniform runtime behaviors and developer experiences.
• Expand the capabilities of .NET by taking the best of .NET Core, .NET Framework, Xamarin and Mono.
• Build that product out of a single code-base that developers (Microsoft and the community) can work on and expand together and that improves all scenarios.

This new project and direction are a game-changer for .NET. With .NET 5, your code and project files will look and feel the same no matter which type of app you’re building. You’ll have access to the same runtime, API and language capabilities with each app. This includes new performance improvements that get committed to corefx, practically daily.

Everything you love about .NET Core will continue to exist:

• Open source and community-oriented on GitHub.
• Cross-platform implementation.
• Support for leveraging platform-specific capabilities, such as Windows Forms and WPF on Windows and the native bindings to each native platform from Xamarin.
• High performance.
• Side-by-side installation.
• Small project files (SDK-style).
• Capable command-line interface (CLI).
• Visual Studio, Visual Studio for Mac, and Visual Studio Code integration.

Here’s what will be new:

• You will have more choice on runtime experiences (more on that below).
• Java interoperability will be available on all platforms.
• Objective-C and Swift interoperability will be supported on multiple operating systems.
• CoreFX will be extended to support static compilation of .NET (ahead-of-time – AOT), smaller footprints and support for more operating systems.

We will ship .NET Core 3.0 this September, .NET 5 in November 2020, and then we intend to ship a major version of .NET once a year, every November:

We’re skipping the version 4 because it would confuse users that are familiar with the .NET Framework, which has been using the 4.x series for a long time. Additionally, we wanted to clearly communicate that .NET 5 is the future for the .NET platform.

We are also taking the opportunity to simplify naming. We thought that if there is only one .NET going forward, we don’t need a clarifying term like “Core”. The shorter name is a simplification and also communicates that .NET 5 has uniform capabilities and behaviors. Feel free to continue to use the “.NET Core” name if you prefer it.

Runtime experiences

High throughput and high productivity

From the very beginning, .NET has relied on a just-in-time compiler (JIT) to translate Intermediate Language (IL) code to optimized machine code. Since that time, we’ve built an industry-leading JIT-based managed runtime that is capable of very high throughput and also enabled developer experiences that make programming fast and easy.

JITs are well suited for long-running cloud and client scenarios. They are able to generate code that targets a specific machine configuration, including specific CPU instructions. A JIT can also re-generate methods at runtime, a technique used to JIT quickly while still having the option to produce a highly-tuned version of the code if this becomes a frequently used method.

Our efforts to make ASP.NET Core run faster on the TechEmpower benchmarks is a good example of the power of JIT and our investments in CoreCLR. Our efforts to harden .NET Core for containers also demonstrates the runtime’s ability to dynamically adapt to constrained environments.

Developer tools are another good example where JIT shines, such as with the dotnet watch tool or edit and continue. Tools often require compiling and loading code multiple times in a single process without restarting and need to do it very quickly.

Developers using .NET Core or .NET Framework have primarily relied on JIT. As a result, this experience should seem familiar.

The default experience for most .NET 5 workloads will be using the JIT-based CoreCLR runtime. The two notable exceptions are iOS and client-side Blazor (web assembly) since both require ahead-of-time (AOT) native compilation.

Fast startup, low footprint, and lower memory usage

The Mono Project has spent much of its effort focused on mobile and gaming consoles. A key capability and outcome of that project is an AOT compiler for .NET, based on the industry-leading LLVM compiler project. The Mono AOT compiler enables .NET code to be built into a single native code executable that can run on a machine, much like C++ code. AOT-compiled apps can run efficiently in small places, and trades throughput for startup if needed.

The Blazor project is already using the Mono AOT. It will be one of the first projects to transition to .NET 5. We are using it as one of the scenarios to prove out this plan.

There are two types of AOT solutions:

• solutions that require 100% AOT compilation.
• solutions where most code is AOT-compiled but where a JIT or interpreter is available and used for code patterns that are not friendly to AOT (like generics).

The Mono AOT supports both cases. The first type of AOT is required by Apple for iOS and some game consoles, typically for security reasons. The second is the preferred choice since it offers the benefits of AOT without any of its drawbacks.

.NET Native is the AOT compiler we use for Windows UWP applications and is an example of the first type of AOT listed above. With that particular implementation, we limited the .NET APIs and capabilities that you can use. We learned from that experience that AOT solutions need to cover the full spectrum of .NET APIs and patterns.

AOT compilation will remain required for iOS, web assembly and some game consoles. We will make AOT compilation an option for applications that are more appliance-like, that require fast startup and/or low footprint.

Fundamentals and overlapping experiences

Microsoft에서 개발한 .NET Framework와 .NET Core의 표준이다. 

.NET Standard 기반 라이브러리의 경우 모든 .NET 기반 프로젝트에서 사용할 수 있다는 장점이 있다.

.NET Standard는 버전에 따라 특정 플랫폼에서 노출되는 유형과 API만 선언 

버전별 테이블

현재 2.0은 .Net framework를 지원

2.1은 .Net framework를 지원안함. 아래링크 상세 설명

참고 링크 : https://devblogs.microsoft.com/dotnet/announcing-net-standard-2-1/ 

결론

 * .NET 표준 라이브러리가 지원(프레임 워크 호환성)

 * 하나의 라이브러리리로 앱/어플리케이션/웹 등 통합으로 개발이 가능 하도록 하기 위하여 사용

 * 유지보수 측면에서는 기준 라이브러리만 고치면 되기 때문에 좋을듯

Azure Machine Learning은 기계 학습 프로젝트 수명 주기를 가속화하고 간편하게 관리할 수 있는 클라우드 서비스입니다. 기계 학습 전문가, 데이터 과학자 및 엔지니어는 이 서비스를 사용하여 일상적인 워크플로, 즉, 모델의 학습 및 배포와 MLOps 관리를 수행할 수 있습니다.

Azure Machine Learning에서 모델을 만들 수도 있고 Pytorch, TensorFlow 또는 scikit-learn과 같은 오픈 소스 플랫폼에서 빌드된 모델을 사용할 수도 있습니다. MLOps 도구를 사용하여 모델을 모니터링, 재학습 및 재배포할 수 있습니다.

Azure Machine Learning의 대상 고객은 누구입니까?

 

Azure Machine Learning의 MLOps에 대해 자세히 알아보세요. 

결론, 코딩을 하지 않고 툴을 이용하여 ML를 이용한다.

R언어란

통계 계산과 그래픽을 위한 프로그래밍 언어이다. 뉴질랜드의 로버트 잰틀맨과 로스 이하카가 개발하였다. 1993년 처음으로 공개되었다. R은 GPL 하에 배포되는 S 프로그래밍 언어의 구현으로 GNU S라고도 한다.

장점

* 오픈소스, 무료 소프트웨어

* 포괄적인 통계플랫폼 : 다양한 라이브러리, 다양한 분석기법, 정형/비정형

* 시각화 기능으로 수학 기호를 포함할 수 있는 출판물 수준의 그래프를 제공

* 웹 어플리케이션 개발 프레임워크인 Shiny의 고도화로 통계 또는 머신러닝 모델을 웹과 연동 가능

단점

* 통계 최적화를 위해 성능을 희생했다

* 인터프리터언어로서 R코드가 실행될때, 변경될 때마다 다시 해석하므로 비교적 느리다.

* 프로그램 자체의 한국어 기능을 제공하지 않는다. 

동작원리

R은 싱글스레드이므로 1개의 CPU코어만 사용한다. 멀티코어를 활용하려면 병렬프로그래밍 기법이 필요하다. 

R은 R코드를 메인 메모리에 올려둔다. R 해석기는 R코드를 기계코드로 변환하고 기계코드로 CPU가 처리한다. 

인메모리에서 처리하기 때문에 빠르지만, 최대 데이터 크기는 사용가능한 RAM의 크기에 따라 달라진다. 

통합개발환경

통합 개발 환경으로 RStudio가 가장 무난하다. R 본체가 설치되어 있어야 작동하며, 훨씬 편리한 인터페이스를 제공하는 것이 강점. 단, 폴더 경로나 파일 이름에 한글이 들어가면 제대로 작동하지 않을 수 있으니 주의할 것. 특히 사용자 계정 이름이 한글일 경우 기본 폴더 경로 자체에 한글이 들어가게 되므로 제대로 실행되지 않는다. 이 경우 관리자 권한으로 실행시키면 된다. 

그 외의 IDE나 에디터들에는 다음이 있다. 보통 R에 대한 문법 검사와 코드 색상을 지원하는 플러그인 형태로 제공 

* ConTEXT

* Eclipse (StatET)

* Emacs (Emacs Speaks Statistics)

* LyX (modules for knitr and Sweave)

* vim

* jEdit

* Kate

* Revolution R Enterprise DevelopR (part of Revolution R Enterprise)

* Sublime Text

* TextMate

* Atom

* WinEdt (R Package RWinEdt)

* Tinn-R

* Notepad++

* IntelliJ IDEA

* Visual Studio

* Visual Studio Code

* Architect

시각화 패키지 

데이터를 그래프 등 보기 좋게 시각화해주는 패키지들 

* ggplot2

* ggvis

* googleVis

* rCharts

* ggiraphExtra

* plotly

* wordcloud

C#과 연동방법

* R.NET을 이용한 C# 연동