<div id="readability-page-1" class="page"><section>

<ins data-ad-client="ca-pub-9527582522912841" data-ad-slot="8674651030" data-ad-format="auto" data-full-width-responsive="true" data-ad-type="inventory" data-ad-adfit-unit="DAN-we6apVVPwuoDAazb"></ins>



            



            <div><h3 data-ke-size="size23">Dapper&nbsp;(ORM)&nbsp;과&nbsp;EF&nbsp;비교하여&nbsp;WHERE&nbsp;조건&nbsp;검색&nbsp;비교하기</h3>


<p data-ke-size="size16">Dapper는 .NET에서 사용하는 가벼운 ORM(Object-Relational Mapper)입니다. Dapper는<span>&nbsp;</span>IQueryable<span>&nbsp;</span>인터페이스를 직접적으로 사용하지 않고, 대신 SQL 쿼리나 저장 프로시저를 실행하여 데이터베이스에서 데이터를 검색합니다. 따라서, Dapper를 사용하여 동적 쿼리를 구성하고자 할 때는 SQL 쿼리를 문자열로 조합하거나, 더 복잡한 쿼리가 필요한 경우 Dapper의<span>&nbsp;</span>DynamicParameters를 활용하여 조건을 동적으로 추가하는 방식을 사용할 수 있습니다.</p>
<p data-ke-size="size16">위의<span>&nbsp;</span>EmployeeSearchService<span>&nbsp;</span>클래스를 Dapper를 사용하여 구현한다면, 다음과 같이 작성할 수 있습니다:</p>


<h4 data-ke-size="size20">Dapper (ORM) 활용법</h4>
<pre id="code_1711381037109" data-ke-language="csharp" data-ke-type="codeblock"><code>using Dapper;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;

public class EmployeeSearchService
{
    private readonly IDbConnection _dbConnection;

    public EmployeeSearchService(IDbConnection dbConnection)
    {
        _dbConnection = dbConnection;
    }

    public IEnumerable&lt;Employee&gt; Search(string department, int? performanceRating, string position)
    {
        var sql = new StringBuilder("SELECT * FROM Employees WHERE 1=1");
        var parameters = new DynamicParameters();

        if (!string.IsNullOrEmpty(department))
        {
            sql.Append(" AND Department = @Department");
            parameters.Add("@Department", department);
        }

        if (performanceRating.HasValue)
        {
            sql.Append(" AND PerformanceRating &gt;= @PerformanceRating");
            parameters.Add("@PerformanceRating", performanceRating);
        }

        if (!string.IsNullOrEmpty(position))
        {
            sql.Append(" AND Position = @Position");
            parameters.Add("@Position", position);
        }

        var result = _dbConnection.Query&lt;Employee&gt;(sql.ToString(), parameters).ToList();
        return result;
    }
}</code></pre>


<p data-ke-size="size16">여기서는&nbsp;StringBuilder를&nbsp;사용하여&nbsp;SQL&nbsp;쿼리&nbsp;문자열을&nbsp;동적으로&nbsp;구성하고&nbsp;있습니다.&nbsp;초기&nbsp;쿼리는&nbsp;모든&nbsp;직원을&nbsp;선택하는&nbsp;SELECT&nbsp;*&nbsp;FROM&nbsp;Employees&nbsp;WHERE&nbsp;1=1로&nbsp;시작합니다.&nbsp;WHERE&nbsp;1=1은&nbsp;추가적인&nbsp;조건이&nbsp;붙기&nbsp;쉽도록&nbsp;만드는&nbsp;일종의&nbsp;트릭입니다.&nbsp;그리고&nbsp;각&nbsp;조건이&nbsp;존재할&nbsp;때마다&nbsp;쿼리&nbsp;문자열과&nbsp;DynamicParameters에&nbsp;해당&nbsp;조건을&nbsp;추가합니다.&nbsp;마지막으로,&nbsp;완성된&nbsp;SQL&nbsp;쿼리와&nbsp;파라미터를&nbsp;사용하여&nbsp;Dapper의&nbsp;Query&nbsp;메소드를&nbsp;호출하고,&nbsp;결과를&nbsp;IEnumerable&lt;Employee&gt;로&nbsp;반환합니다.&nbsp;Dapper를&nbsp;사용할&nbsp;때&nbsp;주의할&nbsp;점은&nbsp;SQL&nbsp;쿼리를&nbsp;직접&nbsp;작성한다는&nbsp;것이므로,&nbsp;SQL&nbsp;인젝션&nbsp;공격에&nbsp;대비하여&nbsp;사용자&nbsp;입력을&nbsp;안전하게&nbsp;처리해야&nbsp;합니다.&nbsp;Dapper의&nbsp;DynamicParameters를&nbsp;사용하는&nbsp;것은&nbsp;이러한&nbsp;위험을&nbsp;줄이는&nbsp;데&nbsp;도움이&nbsp;됩니다.</p>

<blockquote data-ke-style="style1"><span>Dapper&nbsp;자체는&nbsp;IQueryable&lt;T&gt;&nbsp;인터페이스를&nbsp;직접&nbsp;사용하는&nbsp;방식을&nbsp;지원하지&nbsp;않습니다.&nbsp;</span></blockquote>



<p data-ke-size="size16">Dapper는&nbsp;주로&nbsp;마이크로&nbsp;ORM&nbsp;(Object-Relational&nbsp;Mapper)으로,&nbsp;데이터베이스에서&nbsp;데이터를&nbsp;조회하거나&nbsp;조작할&nbsp;때&nbsp;사용되는&nbsp;경량화된&nbsp;라이브러리입니다.&nbsp;이는&nbsp;SQL&nbsp;쿼리를&nbsp;직접&nbsp;작성하고,&nbsp;그&nbsp;결과를&nbsp;객체로&nbsp;매핑하는&nbsp;과정을&nbsp;단순화해줍니다.&nbsp;</p>

<p data-ke-size="size16">IQueryable&lt;T&gt;&nbsp;인터페이스는&nbsp;LINQ&nbsp;(Language&nbsp;Integrated&nbsp;Query)의&nbsp;일부로,&nbsp;컴파일&nbsp;타임에&nbsp;타입&nbsp;검사가&nbsp;가능한&nbsp;쿼리를&nbsp;구성하고,&nbsp;이&nbsp;쿼리의&nbsp;실행을&nbsp;지연시킬&nbsp;수&nbsp;있게&nbsp;해줍니다.&nbsp;IQueryable&lt;T&gt;을&nbsp;사용하면,&nbsp;쿼리의&nbsp;구성만&nbsp;정의하고,&nbsp;실제&nbsp;데이터베이스에&nbsp;대한&nbsp;쿼리&nbsp;실행은&nbsp;나중에&nbsp;이루어집니다.&nbsp;이는&nbsp;<b><span><u>Entity&nbsp;Framework</u></span></b>와&nbsp;같은&nbsp;ORM에서&nbsp;주로&nbsp;사용되며,&nbsp;쿼리의&nbsp;결과가&nbsp;필요한&nbsp;시점까지&nbsp;쿼리&nbsp;실행을&nbsp;지연시키고,&nbsp;필요한&nbsp;경우&nbsp;쿼리를&nbsp;수정하거나&nbsp;추가적인&nbsp;조건을&nbsp;적용할&nbsp;수&nbsp;있게&nbsp;해줍니다.&nbsp;</p>

<p data-ke-size="size16">Dapper를&nbsp;사용할&nbsp;때는&nbsp;SQL&nbsp;쿼리&nbsp;또는&nbsp;저장&nbsp;프로시저를&nbsp;직접&nbsp;작성하고,&nbsp;이를&nbsp;통해&nbsp;데이터를&nbsp;조회합니다.&nbsp;따라서,&nbsp;Dapper와&nbsp;IQueryable&lt;T&gt;를&nbsp;직접적으로&nbsp;함께&nbsp;사용하는&nbsp;것은&nbsp;불가능합니다.&nbsp;</p>

<blockquote data-ke-style="style1"><span>Dapper는&nbsp;쿼리를&nbsp;실행한&nbsp;직후&nbsp;데이터를&nbsp;객체로&nbsp;매핑하며,&nbsp;이&nbsp;과정에서&nbsp;쿼리의&nbsp;지연&nbsp;실행이나&nbsp;LINQ&nbsp;to&nbsp;Entities와&nbsp;같은&nbsp;IQueryable&lt;T&gt;의&nbsp;기능을&nbsp;이용할&nbsp;수&nbsp;<span>없습니다</span></span></blockquote>



<h4 data-ke-size="size20">Entity Framework : IQueryable 사용법</h4>

<p data-ke-size="size16">이&nbsp;방식은&nbsp;유연하고&nbsp;확장&nbsp;가능하며,&nbsp;사용자가&nbsp;어떤&nbsp;조합의&nbsp;조건을&nbsp;선택하든지&nbsp;간에&nbsp;유효한&nbsp;쿼리를&nbsp;생성할&nbsp;수&nbsp;있습니다.&nbsp;추가적으로,&nbsp;사용자로부터&nbsp;더&nbsp;많은&nbsp;필터&nbsp;조건을&nbsp;받아야&nbsp;한다면,&nbsp;Search&nbsp;메소드에&nbsp;더&nbsp;많은&nbsp;매개변수를&nbsp;추가하고,&nbsp;각&nbsp;조건에&nbsp;대해&nbsp;유사한&nbsp;방식으로&nbsp;필터를&nbsp;적용하면&nbsp;됩니다.&nbsp;이&nbsp;예시는&nbsp;LINQ를&nbsp;사용하여&nbsp;데이터베이스&nbsp;쿼리를&nbsp;동적으로&nbsp;구성하는&nbsp;방법을&nbsp;보여줍니다.&nbsp;Entity&nbsp;Framework와&nbsp;같은&nbsp;ORMs(Object-Relational&nbsp;Mappers)와&nbsp;함께&nbsp;사용될&nbsp;경우,&nbsp;이&nbsp;쿼리는&nbsp;SQL&nbsp;쿼리로&nbsp;변환되어&nbsp;실제&nbsp;데이터베이스에서&nbsp;실행됩니다.</p>

<pre id="code_1711382165721" data-ke-language="csharp" data-ke-type="codeblock"><code>using System;
using System.Linq;
using System.Linq.Expressions;
using System.Collections.Generic;

// Employee 클래스는 데이터베이스의 직원 테이블을 나타냅니다.
public class Employee
{
    public string Department { get; set; }
    public int PerformanceRating { get; set; }
    public string Position { get; set; }
    // 여기에 더 많은 속성들이 있을 수 있습니다.
}

public class EmployeeSearchService
{
    private IQueryable&lt;Employee&gt; _employees;

    public EmployeeSearchService(IQueryable&lt;Employee&gt; employees)
    {
        _employees = employees;
    }

    public IQueryable&lt;Employee&gt; Search(string department, int? performanceRating, string position)
    {
        // 쿼리를 시작합니다.
        var query = _employees;

        // 각 조건을 검사하고 해당되는 경우 쿼리에 필터를 추가합니다.
        if (!string.IsNullOrEmpty(department))
        {
            query = query.Where(x =&gt; x.Department == department);
        }
        if (performanceRating.HasValue)
        {
            query = query.Where(x =&gt; x.PerformanceRating &gt;= performanceRating.Value);
        }
        if (!string.IsNullOrEmpty(position))
        {
            query = query.Where(x =&gt; x.Position == position);
        }

        return query;
    }
}</code></pre>
<p data-ke-size="size16">.</p>



<h4 data-ke-size="size20"><span>Entity Framework</span>&nbsp; - Func&lt;employee, bool&gt; 타입의 람다 표현식</h4>

<p data-ke-size="size16">Func&lt;Employee, bool&gt; 타입의 람다 표현식을 조건으로 사용하는 방식은 Entity Framework (EF)에서 LINQ 쿼리를 작성할 때 유용하게 활용됩니다. Entity Framework는 LINQ를 사용하여 데이터베이스 쿼리를 작성하고 실행할 수 있게 해주는 ORM(Object-Relational Mapper)입니다. EF를 사용할 때, IQueryable&lt;T&gt; 인터페이스를 통해 데이터베이스 쿼리를 구성하고, 이 쿼리는 실행 시점까지 지연됩니다.</p>

<p data-ke-size="size16">이 때, Func&lt;T, bool&gt; 타입의 람다 표현식을 사용하여 특정 조건에 따라 데이터를 필터링할 수 있습니다. 예를 들어, 주어진 조건에 따라 Employee 객체를 필터링하는 LINQ 쿼리를 작성할 수 있습니다. Where 메서드에 Func&lt;Employee, bool&gt; 타입의 람다 표현식을 전달함으로써, 해당 조건을 만족하는 Employee 객체만 선택됩니다. 이런 방식은 EF를 사용하는 어플리케이션에서 데이터를 조회할 때 매우 자주 사용됩니다.</p>

<pre id="code_1711382797995" data-ke-language="csharp" data-ke-type="codeblock"><code>using System;
using System.Linq;
using System.Collections.Generic;
using System.Data.Entity; // EF 6 이하에서는 System.Data.Entity를 사용합니다. EF Core에서는 Microsoft.EntityFrameworkCore를 사용합니다.

public class EmployeeContext : DbContext
{
    public DbSet&lt;Employee&gt; Employees { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        using (var context = new EmployeeContext())
        {
            string targetDepartment = "IT";
            int? targetRating = 4;

            // Func&lt;Employee, bool&gt;을 사용하여 조건 생성
            Func&lt;Employee, bool&gt; condition = x =&gt;
            {
                bool matchesDepartment = string.IsNullOrEmpty(targetDepartment) || x.Department.Equals(targetDepartment);
                bool matchesRating = !targetRating.HasValue || x.PerformanceRating &gt;= targetRating.Value;
                
                return matchesDepartment &amp;&amp; matchesRating;
            };

            // 직원 쿼리를 위한 조건을 사용하여 데이터베이스에서 데이터를 조회
            var employees = context.Employees.Where(condition).ToList();

            // 결과 출력
            foreach (var employee in employees)
            {
                Console.WriteLine($"{employee.Firstname} {employee.Lastname}");
            }
        }
    }
}</code></pre></div>
            




                    

                    



</section></div>

심재운 블로그

Dapper (ORM) 과 EF 비교하여 WHERE 조건 검색 비교하기
 
 
Dapper는 .NET에서 사용하는 가벼운 ORM(Object-Relational Mapper)입니다. Dapper는 IQueryable 인터페이스를 직접적으로 사용하지 않고, 대신 SQL 쿼리나 저장 프로시저를 실행하여 데이터베이스에서 데이터를 검색합니다. 따라서, Dapper를 사용하여 동적 쿼리를 구성하고자 할 때는 SQL 쿼리를 문자열로 조합하거나, 더 복잡한 쿼리가 필요한 경우 Dapper의 DynamicParameters를 활용하여 조건을 동적으로 추가하는 방식을 사용할 수 있습니다.
위의 EmployeeSearchService 클래스를 Dapper를 사용하여 구현한다면, 다음과 같이 작성할 수 있습니다:
 
 
Dapper (ORM) 활용법
using Dapper;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
public class EmployeeSearchService
{
    private readonly IDbConnection _dbConnection;
    public EmployeeSearchService(IDbConnection dbConnection)
    {
        _dbConnection = dbConnection;
    }
    public IEnumerable<Employee> Search(string department, int? performanceRating, string position)
    {
        var sql = new StringBuilder("SELECT * FROM Employees WHERE 1=1");
        var parameters = new DynamicParameters();
        if (!string.IsNullOrEmpty(department))
        {
            sql.Append(" AND Department = @Department");
            parameters.Add("@Department", department);
        }
        if (performanceRating.HasValue)
        {
            sql.Append(" AND PerformanceRating >= @PerformanceRating");
            parameters.Add("@PerformanceRating", performanceRating);
        }
        if (!string.IsNullOrEmpty(position))
        {
            sql.Append(" AND Position = @Position");
            parameters.Add("@Position", position);
        }
        var result = _dbConnection.Query<Employee>(sql.ToString(), parameters).ToList();
        return result;
    }
}
 
 
여기서는 StringBuilder를 사용하여 SQL 쿼리 문자열을 동적으로 구성하고 있습니다. 초기 쿼리는 모든 직원을 선택하는 SELECT * FROM Employees WHERE 1=1로 시작합니다. WHERE 1=1은 추가적인 조건이 붙기 쉽도록 만드는 일종의 트릭입니다. 그리고 각 조건이 존재할 때마다 쿼리 문자열과 DynamicParameters에 해당 조건을 추가합니다. 마지막으로, 완성된 SQL 쿼리와 파라미터를 사용하여 Dapper의 Query 메소드를 호출하고, 결과를 IEnumerable<Employee>로 반환합니다. Dapper를 사용할 때 주의할 점은 SQL 쿼리를 직접 작성한다는 것이므로, SQL 인젝션 공격에 대비하여 사용자 입력을 안전하게 처리해야 합니다. Dapper의 DynamicParameters를 사용하는 것은 이러한 위험을 줄이는 데 도움이 됩니다.
 
Dapper 자체는 IQueryable<T> 인터페이스를 직접 사용하는 방식을 지원하지 않습니다. 
 
 
 
Dapper는 주로 마이크로 ORM (Object-Relational Mapper)으로, 데이터베이스에서 데이터를 조회하거나 조작할 때 사용되는 경량화된 라이브러리입니다. 이는 SQL 쿼리를 직접 작성하고, 그 결과를 객체로 매핑하는 과정을 단순화해줍니다. 
 
IQueryable<T> 인터페이스는 LINQ (Language Integrated Query)의 일부로, 컴파일 타임에 타입 검사가 가능한 쿼리를 구성하고, 이 쿼리의 실행을 지연시킬 수 있게 해줍니다. IQueryable<T>을 사용하면, 쿼리의 구성만 정의하고, 실제 데이터베이스에 대한 쿼리 실행은 나중에 이루어집니다. 이는 Entity Framework와 같은 ORM에서 주로 사용되며, 쿼리의 결과가 필요한 시점까지 쿼리 실행을 지연시키고, 필요한 경우 쿼리를 수정하거나 추가적인 조건을 적용할 수 있게 해줍니다. 
 
Dapper를 사용할 때는 SQL 쿼리 또는 저장 프로시저를 직접 작성하고, 이를 통해 데이터를 조회합니다. 따라서, Dapper와 IQueryable<T>를 직접적으로 함께 사용하는 것은 불가능합니다. 
 
Dapper는 쿼리를 실행한 직후 데이터를 객체로 매핑하며, 이 과정에서 쿼리의 지연 실행이나 LINQ to Entities와 같은 IQueryable<T>의 기능을 이용할 수 없습니다
 
 
 
Entity Framework : IQueryable 사용법
 
이 방식은 유연하고 확장 가능하며, 사용자가 어떤 조합의 조건을 선택하든지 간에 유효한 쿼리를 생성할 수 있습니다. 추가적으로, 사용자로부터 더 많은 필터 조건을 받아야 한다면, Search 메소드에 더 많은 매개변수를 추가하고, 각 조건에 대해 유사한 방식으로 필터를 적용하면 됩니다. 이 예시는 LINQ를 사용하여 데이터베이스 쿼리를 동적으로 구성하는 방법을 보여줍니다. Entity Framework와 같은 ORMs(Object-Relational Mappers)와 함께 사용될 경우, 이 쿼리는 SQL 쿼리로 변환되어 실제 데이터베이스에서 실행됩니다.
 
using System;
using System.Linq;
using System.Linq.Expressions;
using System.Collections.Generic;
// Employee 클래스는 데이터베이스의 직원 테이블을 나타냅니다.
public class Employee
{
    public string Department { get; set; }
    public int PerformanceRating { get; set; }
    public string Position { get; set; }
    // 여기에 더 많은 속성들이 있을 수 있습니다.
}
public class EmployeeSearchService
{
    private IQueryable<Employee> _employees;
    public EmployeeSearchService(IQueryable<Employee> employees)
    {
        _employees = employees;
    }
    public IQueryable<Employee> Search(string department, int? performanceRating, string position)
    {
        // 쿼리를 시작합니다.
        var query = _employees;
        // 각 조건을 검사하고 해당되는 경우 쿼리에 필터를 추가합니다.
        if (!string.IsNullOrEmpty(department))
        {
            query = query.Where(x => x.Department == department);
        }
        if (performanceRating.HasValue)
        {
            query = query.Where(x => x.PerformanceRating >= performanceRating.Value);
        }
        if (!string.IsNullOrEmpty(position))
        {
            query = query.Where(x => x.Position == position);
        }
        return query;
    }
}
.
 
 
 
Entity Framework  - Func<employee, bool> 타입의 람다 표현식
 
Func<Employee, bool> 타입의 람다 표현식을 조건으로 사용하는 방식은 Entity Framework (EF)에서 LINQ 쿼리를 작성할 때 유용하게 활용됩니다. Entity Framework는 LINQ를 사용하여 데이터베이스 쿼리를 작성하고 실행할 수 있게 해주는 ORM(Object-Relational Mapper)입니다. EF를 사용할 때, IQueryable<T> 인터페이스를 통해 데이터베이스 쿼리를 구성하고, 이 쿼리는 실행 시점까지 지연됩니다.
 
이 때, Func<T, bool> 타입의 람다 표현식을 사용하여 특정 조건에 따라 데이터를 필터링할 수 있습니다. 예를 들어, 주어진 조건에 따라 Employee 객체를 필터링하는 LINQ 쿼리를 작성할 수 있습니다. Where 메서드에 Func<Employee, bool> 타입의 람다 표현식을 전달함으로써, 해당 조건을 만족하는 Employee 객체만 선택됩니다. 이런 방식은 EF를 사용하는 어플리케이션에서 데이터를 조회할 때 매우 자주 사용됩니다.
 
using System;
using System.Linq;
using System.Collections.Generic;
using System.Data.Entity; // EF 6 이하에서는 System.Data.Entity를 사용합니다. EF Core에서는 Microsoft.EntityFrameworkCore를 사용합니다.
public class EmployeeContext : DbContext
{
    public DbSet<Employee> Employees { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        using (var context = new EmployeeContext())
        {
            string targetDepartment = "IT";
            int? targetRating = 4;
            // Func<Employee, bool>을 사용하여 조건 생성
            Func<Employee, bool> condition = x =>
            {
                bool matchesDepartment = string.IsNullOrEmpty(targetDepartment) || x.Department.Equals(targetDepartment);
                bool matchesRating = !targetRating.HasValue || x.PerformanceRating >= targetRating.Value;
                
                return matchesDepartment && matchesRating;
            };
            // 직원 쿼리를 위한 조건을 사용하여 데이터베이스에서 데이터를 조회
            var employees = context.Employees.Where(condition).ToList();
            // 결과 출력
            foreach (var employee in employees)
            {
                Console.WriteLine($"{employee.Firstname} {employee.Lastname}");
            }
        }
    }
}

Dapper (ORM) 과 EF 비교하여 WHERE 조건 검색 비교하기

댓글