Swagger(스웨거)란 무엇인가?

Swagger는 현재 OpenAPI Specification (OAS)라는 이름으로 표준화된 RESTful API 명세 및 문서화 도구입니다.

2015년 SmartBear Software에서 OpenAPI Initiative에 기증한 후, 현재는 Linux Foundation 산하에서 관리되고 있습니다.

핵심 개념

• API 명세의 표준화: REST API의 엔드포인트, 파라미터, 응답 구조를 JSON/YAML 형식으로 정의
• Code-First 접근: 소스코드로부터 API 문서를 자동 생성하여 문서와 구현 간 불일치 방지
• Interactive Documentation: 브라우저에서 직접 API를 테스트할 수 있는 UI 제공

Swagger가 필요한 이유

1. 개발 생산성 향상

• 자동 문서화: 수동으로 API 문서를 작성하고 유지보수하는 비용 절약
• 실시간 동기화: 코드 변경 시 문서가 자동으로 업데이트
• 타입 안전성: .NET의 강타입 시스템을 활용한 정확한 스키마 생성

2. 팀 협업 효율성

• 프론트엔드-백엔드 협업: 명확한 API 계약 정의를 통한 병렬 개발 지원
• API 계약 테스트: 구현 전 API 설계 검증 가능
• 버전 관리: API 변경사항 추적 및 하위 호환성 관리

3. 운영 및 테스트

• 통합 테스트: CI/CD 파이프라인에서 자동화된 API 테스트
• 모니터링: API 사용 패턴 분석 및 성능 모니터링 기반 제공

Swashbuckle.AspNetCore 아키텍처

Swashbuckle.AspNetCore는 .NET에서 Swagger/OpenAPI를 구현하는 가장 널리 사용되는 라이브러리입니다.

.NET 6+ 프로젝트에서 Swagger 구성

1. 패키지 설치

# Package Manager Console
Install-Package Swashbuckle.AspNetCore

# .NET CLI
dotnet add package Swashbuckle.AspNetCore

2. 기본 구성 (Program.cs)

var builder = WebApplication.CreateBuilder(args);

// 컨트롤러 서비스 등록
builder.Services.AddControllers();

// Swagger 서비스 등록
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(options =>
{
    options.SwaggerDoc("v1", new OpenApiInfo
    {
        Version = "v1",
        Title = "My API",
        Description = "ASP.NET Core Web API for demonstration",
        Contact = new OpenApiContact
        {
            Name = "Developer Name",
            Email = "developer@example.com"
        }
    });
});

var app = builder.Build();

// 개발 환경에서만 Swagger 활성화
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI(options =>
    {
        options.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
        options.RoutePrefix = string.Empty; // 루트 경로에서 Swagger UI 제공
    });
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

SwaggerGen의 동작 원리

SwaggerGen은 다음과 같은 과정을 통해 OpenAPI 문서를 생성합니다:

1. 어셈블리 스캔: 등록된 컨트롤러와 액션 메서드 탐색
2. 메타데이터 추출: 라우트, HTTP 메서드, 파라미터, 반환 타입 분석
3. 스키마 생성: .NET 타입을 JSON Schema로 변환
4. 문서 조합: OpenAPI 3.0 사양에 맞는 JSON 문서 생성

생성되는 OpenAPI 문서 예시

{
  "openapi": "3.0.1",
  "info": {
    "title": "My API",
    "version": "v1"
  },
  "paths": {
    "/api/products": {
      "get": {
        "tags": ["Products"],
        "summary": "제품 목록 조회",
        "responses": {
          "200": {
            "description": "성공",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Product"
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "Product": {
        "type": "object",
        "properties": {
          "id": { "type": "integer", "format": "int32" },
          "name": { "type": "string", "nullable": true }
        }
      }
    }
  }
}

Swagger UI 고급 활용

Swagger UI는 생성된 OpenAPI 문서를 기반으로 다음 기능을 제공합니다:

주요 기능

• HTTP 메서드별 분류: GET, POST, PUT, DELETE 등 시각적 구분
• 스키마 검증: 요청/응답 데이터 구조 실시간 검증
• Try it Out: 브라우저에서 직접 API 호출 및 결과 확인
• 모델 정의: 복잡한 객체 구조의 시각적 표현
• 인증 통합: 다양한 인증 방식 지원 (Bearer, API Key 등)

커스터마이징 옵션

app.UseSwaggerUI(options =>
{
    options.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
    options.DocumentTitle = "My API Documentation";
    options.DefaultModelsExpandDepth(2);
    options.DefaultModelRendering(ModelRendering.Model);
    options.DisplayRequestDuration();
    options.EnableDeepLinking();
    options.EnableFilter();
    options.ShowExtensions();
});

실무 필수 확장 기능

1. XML 주석 통합

프로젝트 파일 설정:

<PropertyGroup>
  <GenerateDocumentationFile>true</GenerateDocumentationFile>
  <NoWarn>$(NoWarn);1591</NoWarn>
</PropertyGroup>

Program.cs 구성:

builder.Services.AddSwaggerGen(options =>
{
    var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
    options.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename));
    
    // 상속된 XML 주석 포함
    options.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, "MyModels.xml"));
});

컨트롤러 예시:

/// <summary>
/// 제품 관리 API
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    /// <summary>
    /// 제품 목록을 조회합니다.
    /// </summary>
    /// <param name="pageSize">페이지당 항목 수 (기본값: 10)</param>
    /// <returns>제품 목록</returns>
    /// <response code="200">성공적으로 조회됨</response>
    /// <response code="400">잘못된 요청 파라미터</response>
    [HttpGet]
    [ProducesResponseType(typeof(IEnumerable<Product>), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    public async Task<ActionResult<IEnumerable<Product>>> GetProducts(
        [FromQuery] int pageSize = 10)
    {
        // 구현 로직
    }
}

2. JWT Bearer 인증 통합

builder.Services.AddSwaggerGen(options =>
{
    options.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Name = "Authorization",
        Type = SecuritySchemeType.Http,
        Scheme = "Bearer",
        BearerFormat = "JWT",
        In = ParameterLocation.Header,
        Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\""
    });

    options.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference
                {
                    Type = ReferenceType.SecurityScheme,
                    Id = "Bearer"
                }
            },
            Array.Empty<string>()
        }
    });
});

3. API 버전 관리

패키지 설치:

dotnet add package Microsoft.AspNetCore.Mvc.Versioning.ApiExplorer

구성:

builder.Services.AddApiVersioning(options =>
{
    options.DefaultApiVersion = new ApiVersion(1, 0);
    options.AssumeDefaultVersionWhenUnspecified = true;
    options.ApiVersionReader = ApiVersionReader.Combine(
        new UrlSegmentApiVersionReader(),
        new HeaderApiVersionReader("X-Version"),
        new MediaTypeApiVersionReader("ver"));
});

builder.Services.AddVersionedApiExplorer(setup =>
{
    setup.GroupNameFormat = "'v'VVV";
    setup.SubstituteApiVersionInUrl = true;
});

builder.Services.AddSwaggerGen();
builder.Services.ConfigureOptions<ConfigureSwaggerOptions>();

4. 사용자 정의 스키마 필터

public class EnumSchemaFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
        if (context.Type.IsEnum)
        {
            schema.Enum.Clear();
            Enum.GetNames(context.Type)
                .ToList()
                .ForEach(name => schema.Enum.Add(new OpenApiString(name)));
        }
    }
}

// 등록
builder.Services.AddSwaggerGen(options =>
{
    options.SchemaFilter<EnumSchemaFilter>();
});

성능 최적화 및 모범 사례

1. 프로덕션 환경 고려사항

// 조건부 Swagger 활성화
if (app.Environment.IsDevelopment() || app.Environment.IsStaging())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

// 또는 구성 기반 활성화
if (builder.Configuration.GetValue<bool>("EnableSwagger"))
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

2. 대용량 API 문서 최적화

builder.Services.AddSwaggerGen(options =>
{
    // 불필요한 스키마 제외
    options.SchemaFilter<ExcludeInternalTypesFilter>();
    
    // 문서 압축
    options.EnableAnnotations();
    
    // 메모리 사용량 최적화
    options.UseAllOfToExtendReferenceSchemas();
    options.UseOneOfForPolymorphism();
});

3. 보안 강화

app.UseSwagger(options =>
{
    // JSON 문서 접근 제한
    options.PreSerializeFilters.Add((swagger, httpReq) =>
    {
        if (!httpReq.Headers.ContainsKey("X-API-Key"))
        {
            throw new UnauthorizedAccessException();
        }
    });
});

트러블슈팅 가이드

일반적인 문제와 해결책

모니터링 및 분석

Application Insights 통합

builder.Services.AddApplicationInsightsTelemetry();

// Swagger 사용량 추적
app.UseSwagger(options =>
{
    options.PreSerializeFilters.Add((swagger, httpReq) =>
    {
        var telemetryClient = httpReq.HttpContext.RequestServices
            .GetRequiredService<TelemetryClient>();
        telemetryClient.TrackEvent("SwaggerAccessed");
    });
});

요약 및 베스트 프랙티스

핵심 도구 정리

개발팀을 위한 권장사항

1. 개발 초기부터 Swagger 도입하여 API 설계 단계에서 문서화
2. XML 주석을 활용한 상세한 API 설명 작성
3. DTO 패턴 적용으로 명확한 API 계약 정의
4. 버전 관리 전략 수립으로 하위 호환성 보장
5. 보안 설정 통합으로 실제 운영 환경과 일치하는 테스트 환경 구축
6. CI/CD 파이프라인에 OpenAPI 스펙 검증 단계 포함

이러한 접근을 통해 Swagger/OpenAPI는 단순한 문서화 도구를 넘어서 API 개발 생명주기 전반을 지원하는 핵심 인프라가 될 수 있습니다.

The post Swagger/OpenAPI for .NET appeared first on 어제와 내일의 나 그 사이의 이야기.

LINQ – 이것이 C# 이다.

쿼리식 연산자의 종류

– from

– where

– orderby

– select

– group by

– join

– 여러 개의 데이터 원본에 질의

–  L I N Q  –

LINQ(Language INtegrated Query) 는 컬렉션을 편리하게 다루기 위한 목적으로 만들어진 질의(Query) 언어입니다.

질의란? 무엇인가에 대하여 물어본다는 뜻인데 데이터 질의란 데이터에 대해 물어본다는 말입니다.

기본적인 질문은 아래와 같습니다.

from : 어떤 데이터를 집합에서 찾을 것인가?

where : 어떤 값의 데이터를 찾을 것인가?

orderby : 어떤 기준으로 정렬할 것인가?

select : 어떤 항목을 추출할 것인가?

class Profile
    {
    
        public string Name { get; set; }
        public int Height { get; set; }

    }
    class MainApp
    {

        static void Main(string[] args)
        {
            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                                    };
        }

    }

위의 예시에서 키가 170 이상인 데이터만 찾아서 새 컬렉션으로 추가한다고 한다면?

using System;
using System.Collections.Generic;

namespace ConsoleApp2
{

    class Profile
    {
    
        public string Name { get; set; }
        public int Height { get; set; }

    }
    class MainApp
    {

        static void Main(string[] args)
        {
            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             // ...
                                    };

            List<Profile> profiles = new List<Profile>();
            foreach (Profile data in arrProfiles )
            {
                if (data.Height >= 170)
                {
                    profiles.Add(data);
                }
            }

            foreach (Profile data in profiles)
            {
                Console.WriteLine("{0} , {1}", data.Name , data.Height);

            }

        }
        
    }
}

코드에 잘못된 부분은 없으나 LINQ를 모르는 프로그래머의 코드 라는 평을 듣습니다.

다음예제는 LINQ를 사용한 예제입니다.

using System;
using System.Linq;

namespace ConsoleApp2
{

    class Profile
    {
        public string Name { get; set; }
        public int Height { get; set; }

    }
    
    class MainApp
    {

        static void Main(string[] args)
        {
        
            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             new Profile() { Name = "홍길동" , Height = 193 },
                             new Profile() { Name = "임꺽정" , Height = 170 }
                                    };


			//  LINQ
            var profiles = from profile in arrProfiles
                           where profile.Height >= 170
                           orderby profile.Height ascending
                           select profile;


            foreach (Profile data in profiles)
            {
                Console.WriteLine("{0} , {1}", data.Name, data.Height);
            }

        }
    }
}

– from – 

모든 쿼리식(Query Expression)은 반드시 from절로 시작합니다.

쿼리식의 대상이 될 데이터 원본(Data Source)과 데이터 원본 안에 들어 있는 각 요소 데이터를 나타내는

범위 변수(Range Variable) (= 쿼리 변수(Query Variable)) 를  from 절에서 지정합니다.

데이터 원본은 아무 형식이나 사용할 수 없고, IEnumerable<T> 인터페이스를 상속하는 형식만 가능합니다.

https://learn.microsoft.com/ko-kr/dotnet/api/system.collections.generic.ienumerable-1?view=net-6.0

배열 또는 컬렉션 객체들은 이를 상속하므로 모드 from절의 데이터 원본으로 사용할 수 있습니다.

범위변수는 foreach 문의 반복변수와 비슷합니다.

단. 반복변수는 데이터 원본으로부터 데이터를 담아내지만, 범위 변수는 실제로 데이터를 담지않습니다.

그래서 쿼리식 외부에서 선언된 변수에 범위 변수의 데이터를 복사해 넣는다든가 하는 일은 할 수 없습니다.

범위변수는 오로지 LINQ 질의 안에서만 통용됩니다.

using System;
using System.Linq;

namespace ConsoleApp2
{

    class MainApp
    {

        static void Main(string[] args)
        {
            int[] intArr = { 10, 41, 7, 67, 3, 13, 15, 25, 76, 89, 44, 33, 22, 1 };

            var evenNumber = from data in intArr
                             where data % 2 == 0
                             orderby data descending 
                             select data;

            foreach (int data1 in evenNumber)
            {
                Console.Write(" 짝수 : {0}  ", data1);
            }

        }
    }
}

– where – 

where 은 필터 역할(Filter)을 하는 연산자 입니다.

from 절이 데이터의 원본으로부터 뽑아낸 범위 변수가 가져야 하는 조건을 where 연산자에 인수로 입력하면

LINQ는 해당조건에 부합하는 데이터만을 걸러냅니다. 

– orderby – 

orderby는 정렬을 수행하는 연산자 입니다.

위의 예제

orderby profile.Height ascending  // 오름차순 정렬

orderby data descending  // 내림차순 정렬

와 같이 사용합니다.

– select – 

select 절은 최종 결과를 추출하는 쿼리식의 마침표 같은 존재입니다.

from 절에서 데이터 원본으로부터 범위 변수를 뽑아내고

where 절에서 이 범위 변수의 조건을 검사한 후

orderby 절에서 결과를 정리하고

select 문을 통하여 최종 결과를 추출해내는 것 입니다.

var profiles = from profile in arrProfiles
               where profile.Height >= 170
               orderby profile.Height
               select profile;

LINQ 질의 결과는 IEnumerable<T>로 반환되는데, 이떄 형식 매개변수T는 Select 문에 의해 결정됩니다.

위의 질의 결과는 IEnumerable<profile> 형식입니다.

만약 select 문에서 profile 객체 전체가 아닌 Name 프로퍼티만 추출하면 IEnumerable<string> 형식으로 컴파일 됩니다.

var profiles = from profile in arrProfiles
               where profile.Height >= 170
               orderby profile.Height ascending
               select profile.Name;


foreach (string data in profiles)
{
	Console.WriteLine("{0} ", data);
}

또한 select 문의 무명 형식을 이용하여 새로운 형식을 즉석에서 만들 수 있습니다.

using System;
using System.Linq;

namespace ConsoleApp2
{

    class Profile
    {
        public string Name { get; set; }
        public int Height { get; set; }

    }

    class MainApp
    {

        static void Main(string[] args)
        {

            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             new Profile() { Name = "홍길동" , Height = 193 },
                             new Profile() { Name = "임꺽정" , Height = 170 }
                                    };


            //  LINQ
            var profiles = from profile in arrProfiles
                           where profile.Height >= 170
                           orderby profile.Height 
                           select new { Name = profile.Name, InchHeight = profile.Height * 0.393 };


            foreach (var data in profiles)
            {
                Console.WriteLine("{0} ", data);
            }

            Console.WriteLine(profiles.GetType());
        }
    }
}

–  group by  –

group by 문을 통하여 분류 기준에 따라 데이터를 그룹화 할 수 있습니다.

group A by B into c

A 에서는 from 절에서 뽑아낸 범위 변수를, B에는 분류 기준을, C에는 그룹 변수를 위치시키면 됩니다.

Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             new Profile() { Name = "홍길동" , Height = 193 },
                             new Profile() { Name = "임꺽정" , Height = 170 }
                         };

위의 예제를 175 미만 / 이상 으로 분류합니다.

var listprofiles = from profile in arrProfiles
        	   group profile by profile.Height < 175 into g
            	   select new { GroupKey = g.Key, profiles = g };

그룹변수 g에는 height 값이 175미만인 객체는 컬레션과 175 이상인 객체의 컬렉션이 입력되고,

select 문이 추출하는 새로운 무명형식은 컬렉션의 컬렉션이 됩니다. 

그리고 이 무명형식의 Profiles 필드는 바로 이 그룹 변수 g를 담게됩니다.

using System;
using System.Linq;

namespace ConsoleApp2
{

    class Profile
    {
        public string Name { get; set; }
        public int Height { get; set; }

    }

    class MainApp
    {

        static void Main(string[] args)
        {

            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             new Profile() { Name = "홍길동" , Height = 193 },
                             new Profile() { Name = "임꺽정" , Height = 170 }
                                    };


            //  LINQ
            var listprofiles = from profile in arrProfiles
                               group profile by profile.Height < 175 into g
                               select new { GroupKey = g.Key, profiles = g };

            foreach (var Group in listprofiles)
            {
                Console.WriteLine(" - 175cm 미만? : {0}", Group.GroupKey);
                foreach (var data in Group.profiles)
                {
                    Console.WriteLine("{0} :  {1}", data.Name, data.Height);
                }
            }

        }
    }
}

–  join  –

– 내부 조인

내부조인(Inner) 은 교집합과 비슷합니다.

두 데이터 원본 사이에서 일치하는 데이터들만 연결한 후 반환합니다. 기준은 원본 데이터 입니다.

내부조인을 수행 할떄 기준 데이터 원본에는 존재하지만 연결할 데이터 원본에는 존재하지 않는 데이터는 조인 결과에 포함되지 않습니다.

반대의 경우도 마찬가지 입니다.

using System;
using System.Linq;

namespace ConsoleApp2
{

    class Profile
    {
        public string Name { get; set; }
        public int Height { get; set; }

        public int Number { get; set; }

    }

    class Profile2
    {
        public string Star { get; set; }
        public int Number { get; set; }

    }

    class MainApp
    {

        static void Main(string[] args)
        {

            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             new Profile() { Name = "홍길동" , Height = 193 },
                             new Profile() { Name = "임꺽정" , Height = 170 }
                                    };

            Profile2[] arr2Profiles = {
                             new Profile2() { Star = "정우성" , Number = 111 },
                             new Profile2() { Star = "김태희" , Number = 222 },
                             new Profile2() { Star = "이문세" , Number = 333 },
                             new Profile2() { Star = "하동훈" , Number = 444 },
                          // new Profile2() { Star = "홍길동" , Number = 555 },
                             new Profile2() { Star = "임꺽정" , Number = 666 }
                                    };


            //  LINQ
            var listJoin = from data1 in arrProfiles
                           join data2 in arr2Profiles on data1.Name equals data2.Star
                           select new
                           {
                               Name = data1.Name,
                               Number = data2.Number,
                               Height = data1.Height
                           };
            foreach (var data3 in listJoin)
            {
                Console.WriteLine("Name(star) : {0}, Number : {1}, Height : {2}", data3.Name, data3.Number, data3.Height);
                //  홍길동 포함 X
            }



        }
    }
}

– 외부 조인

    }

    class Profile2
    {
        public string Star { get; set; }
        public int Number { get; set; }

    }

    class MainApp
    {

        static void Main(string[] args)
        {

            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             new Profile() { Name = "홍길동" , Height = 193 },
                             new Profile() { Name = "임꺽정" , Height = 170 }
                                    };

            Profile2[] arr2Profiles = {
                             new Profile2() { Star = "정우성" , Number = 111 },
                             new Profile2() { Star = "김태희" , Number = 222 },
                             new Profile2() { Star = "이문세" , Number = 333 },
                             new Profile2() { Star = "하동훈" , Number = 444 },
                             new Profile2() { Star = "홍길동" },
                             new Profile2() { Star = "임꺽정" , Number = 666 }
                                    };


            //  LINQ
            var listJoin = from data1 in arrProfiles
                           join data2 in arr2Profiles on data1.Name equals data2.Star into ps
                           from data2 in ps.DefaultIfEmpty(new Profile2() { Number = 0 } )
                           select new
                           {
                               Name = data1.Name,
                               Number = data2.Number,
                               Height = data1.Height
                           };
            foreach (var data3 in listJoin)
            {
                Console.WriteLine("Name(star) : {0}, Number : {1}, Height : {2}", data3.Name, data3.Number, data3.Height);
            }

        }
    }
}

–  여러 개의 데이터 원본에 질의  –

LINQ 쿼리식은 데이터 원본에 접근하기 위해 from 절을 사용합니다.

여러 개의 데이터 원본에 접근하려면 이 from 문을 중첩해서 사용하면 됩니다.

using System;
using System.Linq;

namespace ConsoleApp2
{

    class Class
    {
        public string Name { get; set; }
        public int[] Score { get; set; }
    }

    class MainApp
    {

        static void Main(string[] args)
        {
        
            Class[] arrClass =
            {
                new Class() { Name = "연두반", Score = new int[]{ 70,24 } },
                new Class() { Name = "분홍반", Score = new int[]{ 60,45,87,72 } },
                new Class() { Name = "파랑반", Score = new int[]{ 92,30,85,94 } },
                new Class() { Name = "노랑반", Score = new int[]{ 90,88,0,10 } }
            };

            var Classes = from c in arrClass
                          from s in c.Score
                          where s < 60
                          orderby s
                          select new { c.Name, Lowest = s };

            foreach (var data in Classes)
            {
                Console.WriteLine(" 낙제 : {0} ", data);
            }
        }
    }
}

https://learn.microsoft.com/ko-kr/dotnet/csharp/programming-guide/concepts/linq/query-expression-syntax-for-standard-query-operators

위의 링크는 C#에서 지원하는 11가지의 쿼리식 문법입니다.

53개의  표준 LINQ 연산자

https://m.blog.naver.com/PostView.naver?isHttpsRedirect=true&blogId=ljc8808&logNo=220662771778 <- 출처

쿼리식과 메소드를 함께 사용한다면 모두 사용 가능합니다.

using System;
using System.Linq;

namespace ConsoleApp2
{

    class Profile
    {
        public string Name { get; set; }
        public int Height { get; set; }

    }

    class MainApp
    {

        static void Main(string[] args)
        {

            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             new Profile() { Name = "홍길동" , Height = 193 },
                             new Profile() { Name = "임꺽정" , Height = 170 }
                                    };


            //  LINQ
            double average = (from profile in arrProfiles
                              where profile.Height < 180
                              select profile).Average(profile => profile.Height);

            Console.WriteLine("키 180 미만 평균 : {0}", average);
        }
    }
}

using System;
using System.Linq;

namespace ConsoleApp2
{

    class Profile
    {
        public string Name { get; set; }
        public int Height { get; set; }

        public int Number { get; set; }

    }

    class MainApp
    {

        static void Main(string[] args)
        {

            Profile[] arrProfiles = {
                             new Profile() { Name = "정우성" , Height = 186 },
                             new Profile() { Name = "김태희" , Height = 158 },
                             new Profile() { Name = "이문세" , Height = 171 },
                             new Profile() { Name = "하동훈" , Height = 163 },
                             new Profile() { Name = "홍길동" , Height = 193 },
                             new Profile() { Name = "임꺽정" , Height = 170 }
                                    };

            //  LINQ
            var profiles = arrProfiles.Where(profile => profile.Height < 175)
                                     .OrderBy(profile => profile.Height)
                                     .Select(profile => new { 
                                        Name = profile.Name,
                                        InchHeight = profile.Height * 0.393
                                     });

            foreach (var data in profiles)
            {
                Console.WriteLine("{0}  {1}",data.Name , data.InchHeight);
            }
        }
    }
}

The post LINQ – 이것이 C# 이다. appeared first on 어제와 내일의 나 그 사이의 이야기.