C#_using 지시문, 문장

1. using 지시문

using 지시문을 사용하면 네임스페이스에 정의된 형식을 해당 형식의 정규화된 네임스페이스를 지정하지 않고도 사용할 수 있다. using 지시문의 기본 형태는 아래의 예에서 볼 수 있듯이 단일 네임스페이스에서 모든 형식을 가져온다.

using System.Text;

using 지시문에 다음과 같은 두 개의 한정자를 적용할 수 있다.

 

  1. global 한정자는 프로젝트에 있는 모든 소스 파일에 동일한 using 지시문을 추가하는 것과 같은 효과가 있다. 이 한정자는 C# 10에서 도입되었다.

  2. static 수정자는 네임스페이스에 있는 모든 형식을 가져오는 대신 단일 형식에서 static 멤버 및 중첩 형식을 가져온다. 이 한정자는 C# 6.0에서 도입되었다.

 

프로젝트의 모든 소스 파일에서 특정 형식의 정적 멤버를 가져오기 위해 두 한정자를 결합할 수 있다.

'using 별칭 지시문'을 사용하여 네임스페이스 또는 형식의 별칭을 만들 수도 있다.

using Project = PC.MyCompany.Project;

'using 별칭 지시문'에 global 한정자를 사용할 수 있다. global 한정자가 없는 using 지시문의 범위는 해당 지시문이 나타나는 파일. using 지시문은 소스 파일의 시작 부분, 네임스페이스 또는 형식 선언 앞에 나타날 수 있다. 

using 지시문은 모든 네임스페이스에 나타날 수 있지만 global 한정자가 사용되지 않는 한 해당 네임스페이스에 선언된 네임스페이스 또는 형식 앞에 나타날 수 있다. 이 경우 지시문은 모든 네임스페이스 및 형식 선언 앞에 나타나야 한다. 

이렇게 하지 않으면 컴파일러 오류 CS1529가 생성됨.

 

using 지시문을 만들어서 네임스페이스를 지정할 필요 없이 네임스페이스에서 이 형식을 사용. using 지시문은 지정한 네임스페이스 안에 중첩된 어떠한 네임스페이스에 대해서도 액세스 권한을 제공하지 않는다. 네임스페이스는 두 가지 범주인 사용자 정의 및 시스템 정의로 구분된다. 사용자 정의 네임스페이스는 코드에서 정의된 네임스페이스. 

 

global 한정자

using 지시문에 global 한정자를 추가하는 것은 컴파일(일반적으로 프로젝트)의 모든 파일에 using이 적용된다는 것을 의미. global using 지시문은 C# 10에 추가되었다. 구문은 다음과 같다.

global using <fully-qualified-namespace>;

여기서 '정규화된 네임스페이스'는 네임스페이스를 지정하지 않고 형식을 참조할 수 있는 네임스페이스의 정규화된 이름.

 

global using 지시문은 모든 소스 코드 파일의 시작 부분에 나타날 수 있다. 하나의 파일에서 모든 global using 지시문은 다음과 같은 항목 앞에 나타나야 한다.

 

1. global 한정자가 없는 모든 using 지시문

2. 해당 파일의 모든 네임스페이스와 형식 선언

 

global using 지시문은 모든 소스 파일에 추가할 수 있다. 일반적으로 모두 한곳에 유지하는 것이 좋다. 하나의 파일 안에서 또는 파일 간에 global using 지시문의 순서는 중요하지 않다.

 

global 한정자는 static 한정자와 함께 사용할 수 있다. global 한정자는 'using 별칭 지시문'에 적용할 수 있다. 두 경우 모두 지시문의 범위는 현재 컴파일의 모든 파일이다. 아래 예제에서는 프로젝트에 포함된 모든 파일의 System.Math에서 선언된 모든 메서드를 사용할 수 있도록 설정한다.

global using static System.Math;

프로젝트 파일에 <Using> 항목을 추가하여 네임스페이스를 전역적으로 포함할 수도 있다

(예: <Using Include="My.Awesome.Namespace" />).

 

static 한정자

using static 지시문은 형식 이름을 지정하지 않고 정적 멤버 및 중첩 형식에 액세스할 수 있는 형식의 이름을 지정.

using static 지시문은 C# 6에서 도입되었다. 구문은 다음과 같다.

using static <fully-qualified-type-name>;

<fully-qualified-type-name>은 형식 이름을 지정하지 않고 정적 멤버 및 중첩 형식을 참조할 수 있는 형식의 이름이다. 정규화된 형식 이름(전체 네임스페이스와 형식 이름)을 제공하지 않으면 C#은 컴파일러 오류 CS0246 "형식 또는 네임스페이스 이름  'type/namespace'를 찾을 수 없습니다. using 지시문 또는 어셈블리 참조가 누락되었는지 확인하세요."를 생성한다.

 

using static 지시문은 정적 멤버(또는 중첩 형식)가 있는 모든 형식에 적용된다(인스턴스 멤버가 있는 경우에도). 그러나 인스턴스 멤버는 형식 인스턴스를 통해서만 호출할 수 있다. 형식 이름을 사용하여 액세스를 한정할 필요 없이 형식의 정적 멤버에 액세스 할 수 있다.

using static System.Console;
using static System.Math;
class Program
{
    static void Main()
    {
    	WriteLine(Sqrt(3*3 + 4*4)); // Console. 생략 가능
    }
}

일반적으로 정적 멤버를 호출할 때 멤버 이름과 함께 형식 이름을 제공. 형식의 멤버를 호출하기 위해 동일한 형식 이름을 반복해서 입력하면 코드가 복잡하고 난해해질 수 있다. 예를 들어, Circle 클래스에 대한 다음 정의에서는 Math 클래스의 여러 멤버를 참조한다.

using System;

public class Circle
{
    public Circle(double radius)
    {
    	Radius = radius;
    }
    
    public double Radius { get; set; }
    
    public double Diameter
    {
    	get { return 2 * Radius; }
    }
    
    public double Circumference
    {
    	get { return 2 * Radius * Math.PI; }
    }
    
    public double Area
    {
    	get { return Math.PI * Math.Pow(Radius, 2); }
    }
}

멤버를 참조할 때마다 Math 클래스를 명시적으로 참조할 필요가 없으므로 using static 지시문은 보다 깔끔한 코드를 생성

using System;
using static System.Math;

public class Circle
{
    public Circle(double radius)
    {
    	Radius = radius;
    }
    
    public double Radius { get; set; }
    
    public double Diameter
    {
    	get { return 2 * Radius; }
    }
    
    public double Circumference
    {
    	get { return 2 * Radius * PI; } // Math. 생략 가능
    }
    
    public double Area
    {
    	get { return PI * Pow(Radius, 2); } // Math. 생략 가능
    }
}

using static은 액세스 가능한 정적 멤버와 지정된 형식에 선언된 중첩된 형식만 가져온다. 상속된 멤버는 가져오지 않는다. 

using static을 사용하면 지정된 형식에 선언된 확장 메서드를 확장 메서드 조회에 사용할 수 있다. 그러나 확장 메서드의 이름은 코드의 정규화되지 않은 참조에 대한 범위로 가져오지 않는다.

 

같은 컴파일 단위 또는 네임스페이스에서 여러 using static 지시문을 통해 다양한 형식에서 가져온 같은 이름을 사용하는 메서드는 메서드 그룹을 구성한다. 이들 메서드 그룹 내에서 오버로드 확인은 일반 C# 규칙을 따른다.

 

다음 예제에서는 형식 이름을 지정할 필요 없이 using static 지시문을 사용하여 Console, Math 및 String 클래스의 정적 멤버를 사용 가능하게 한다.

using System;
using static System.Console;
using static System.Math;
using static System.String;

class Program
{
    static void Main()
    {
    	Write("Enter a circle's radius: "); // Console. 생략 가능
        var input = ReadLine();
        if (!IsNullOrEmpty(input) && double.TryParse(input, out var radius))
        {
            var c = new Circle(radius);
            
            string s = "\nInformation about the circle:\n";
            s = s + Format("	Radius: {0:N2}\n", c.Radius);
            s = s + Format("	Diameter: {0:N2}\n", c.Diameter);
            s = s + Format("	Circumfernece: {0:N2}\n", c.Circumference);
            s = s + Format("	Area: {0:N2}\n", c.Area);
            WriteLine(s); // Console. 생략 가능
        }
        else
        {
            WriteLine("Invalid input...");
        }
    }
}

public class Circle
    public Circle(double radius)
    {
    	Radius = radius;
    }
    
    public double Radius { get; set; }
    
    public double Diameter
    {
    	get { return 2 * Radius; }
    }
    
    public double Circumference
    {
    	get { return 2 * Radius * PI; } // Math. 생략 가능
    }
    
    public double Area
    {
    	get { return PI * Pow(Radius, 2); } // Math. 생략 가능
    }
}
// The example displays the following output:
//       Enter a circle's radius: 12.45
//
//       Information about the circle:
//          Radius: 12.45
//          Diameter: 24.90
//          Circumference: 78.23
//          Area: 486.95

이 예제에서는 using static  지시문을 Double 형식에 적용했을 수도 있다. 해당 지시문을 추가하면 형식 이름을 지정하지  않고 TryParse(String, Double) 멤버를 호출할 수 있다. 그러나 형식 이름 없이 TryParse를 사용하면 어떤 숫자 형식의 TryParse 메서드가 호출되었는지 알아보기 위해 using static 지시문을 확인해야 하기 때문에 코드의 가독성이 떨어진다.

 

using static은 enum 형식에도 적용된다. 열거형을 사용하여 using static을 추가하면 열거형 멤버를 사용하는 데 더 이상 형식이 필요하지 않다.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

class Program
{
    public static void Main()
    {
    	Color color = green;
    }
}

using 별칭

using 별칭 지시문을 만들면 네임스페이스 또는 형식에 대한 식별자를 더 쉽게 한정할 수 있다. 모든 using 지시문에서, 앞에 오는 using 지시문과 관계없이 정규화된 네임스페이스 또는 형식을 사용해야한다. using 별칭은 using 지시문 선언에 사용할 수 없다. 예를 들어, 다음 예제는 컴파일러 오류를 생성한다.

using s = System.Text;
using s.RegularExpressions; // Generates a compiler error.

다음 예제에서는 using 네임스페이스에 대한 별칭을 정의 및 사용하는 방법을 보여준다.

namespace PC
{
    // Define an alias for the nested namespace.
    using Project = PC.MyCompany.Project;
    class A
    {
    	void M()
        {
            // Use the alias
            var mc = new Project.MyClass();
        }
    }
    namespace MyCompany
    {
    	namespace Project
        {
            public class MyClass { }
        }
    }
}

using 별칭 지시문은 오른쪽에 개방형 제네릭 형식을 가질 수 없다. 예를 들어, List<T>에 대해서는 using 별칭을 만들 수 없지만 List<int>에 대해서는 만들 수 있다.

 

다음 예제에서는 클래스에 대한 using 지시문 및 using 별칭을 정의하는 방법을 보여준다.

using System;

// Using alias directive for a class.
using AliasToMyClass = NameSpace1.MyClass;

// Using alias directive for a generic class.
using UsingAlias = NameSpace2.MyClass<int>;

namespace NameSpace1
{
    public class MyClass
    {
    	public override string ToString()
        {
            return "You are in NameSpace1.MyClass.";
        }
    }
}

namespace NameSpace2
{
    class MyClass<T>
    {
    	public override string ToString()
        {
            return "You are in NameSpace2.MyClass.";
        }
    }
}

namespace NameSpace3
{
    class MainClass
    {
    	static void Main()
        {
            var instance1 = new AliasToMyClass();
            Console.WriteLine(instance1);
            
            var instance2 = new UsingAlias();
            Console.WriteLine(instance2);
        }
    }
}
// Output:
//    You are in NameSpace1.MyClass.
//	  You are in NameSpace2.MyClass.

출처 : 마이크로소프트(https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/using-directive)

using 지시문 - C# 참조

2. using 문장

 

개체 범위를 정의 할때 사용한다. 그 범위를 벗어나면 자동으로 dispose(처분)된다. file, font, DB의 같은 경우에 사용할 때 일정 부분의 메모리를 잡아먹는데 이 부분에서 컴퓨터의 자원이 할당되는 것이다. 메서드나 어떤 형식의 로직이 끝날 때 이 부분을 다시 반납해야 성능이 개선되고 프로그램의 문제가 발생하지 않는다. 즉 성능이 좋은 프로그램이 된다는 이야기다.

 

다음의 예제를 보자.

using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand(queryString, connection);
    command.Connection.Open();
    command.ExecuteNonQuery();
}

DB는 사용하고 폐기해줘야 성능 개선에 도움이 된다. connection을 했을 때 { }안에서 자동으로 자원이 할당되고, { }범위를 벗어나게 되면 자동으로 dispose가 된다.

 

또한 using문을 사용하는데 에러가 발생했을 때 dispose가 되지 않는 경우도 있는데 이 부분은 finally 부분에 넣어 dispose가 되도록 명시하면 된다.

using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlConnection connection = new SqlConnection(connectionString);
 
    try 
    {            
        SqlCommand command = new SqlCommand(queryString, connection);
        command.Connection.Open();
        command.ExecuteNonQuery(); 
    }
    finally
    {
        if (connection != null)
            ((IDisposable)connection).Dispose();
    }
}

출처 : https://magpienote.tistory.com/65

c# using 문 사용 법 사용 이유