C# Language
주조

비고

기본 유형으로 객체 캐스트

주어진 다음의 정의 :

public interface IMyInterface1
{
    string GetName();
}

public interface IMyInterface2
{
    string GetName();
}

public class MyClass : IMyInterface1, IMyInterface2
{
    string IMyInterface1.GetName()
    {
        return "IMyInterface1";
    }

    string IMyInterface2.GetName()
    {
        return "IMyInterface2";
    }
}

객체를 기본 유형으로 변환하는 예제 :

    MyClass obj = new MyClass();

    IMyInterface1 myClass1 = (IMyInterface1)obj;
    IMyInterface2 myClass2 = (IMyInterface2)obj;

    Console.WriteLine("I am : {0}", myClass1.GetName());
    Console.WriteLine("I am : {0}", myClass2.GetName());

    // Outputs :
    // I am : IMyInterface1
    // I am : IMyInterface2

노골적인 주조

특정 유형의 값임을 알고있는 경우 해당 유형이 필요한 컨텍스트에서 값을 사용하기 위해 해당 값을 해당 유형으로 명시 적으로 형변환 할 수 있습니다.

object value = -1;
int number = (int) value;
Console.WriteLine(Math.Abs(number));

우리가 통과 시도하는 경우 value 직접 Math.Abs() 하기 때문에, 우리는 컴파일시 예외를 얻을 것 Math.Abs() 걸리는 과부하가없는 object 매개 변수로합니다.

value int 로 value 할 수없는 경우이 예제의 두 번째 행은 InvalidCastException 을 발생시킵니다.

안전한 명시 적 캐스팅 (`as '연산자)

생각하는 유형의 값인지 확실하지 않은 경우 as 연산자를 사용하여 값을 안전하게 캐스팅 할 수 있습니다. 그 값이 그 형태가 아닌 경우, 결과의 값은 null 됩니다.

object value = "-1";
int? number = value as int?;
if(number != null)
{
    Console.WriteLine(Math.Abs(number.Value));
}

null 값에는 유형이 없으므로, as 키워드는 null 값을 3 null 할 때 안전하게 null 합니다.

암시 적 주조

컴파일러가 항상 해당 유형으로 변환 할 수 있음을 알고있는 경우 값은 해당 유형으로 자동 변환됩니다.

int number = -1;
object value = number;
Console.WriteLine(value);

이 예제에서는 컴파일러가 모든 int 를 object s에 캐스팅 할 수 있다는 것을 알고 있기 때문에 일반적인 명시 적 캐스팅 구문을 사용할 필요가 없었습니다. 사실, 우리는 변수를 생성하지 않고 -1 object 를 기대하는 Console.WriteLine() 의 인수로 직접 전달할 수 있습니다.

Console.WriteLine(-1);

전송하지 않고 호환성 확인하기

값 유형이 주어진 유형을 확장 또는 구현하는지 여부를 알아야하지만 실제로 그 유형으로 형변환하지 않으려면 is 연산자를 사용할 수 있습니다.

if(value is int)
{
   Console.WriteLine(value + "is an int");
}

명시 적 수치 변환

명시 적 형변환 연산자는 서로 확장하거나 구현하지 않더라도 숫자 유형의 변환을 수행하는 데 사용할 수 있습니다.

double value = -1.1;
int number = (int) value;

대상 유형의 원래 유형보다 정밀도가 낮은 경우 정밀도가 손실됩니다. 예를 들어 위의 예에서 double 값으로 -1.1 은 정수 값으로 -1 됩니다.

또한 숫자 변환은 컴파일 타임 유형에 의존하므로 숫자 유형이 객체에 "박스"로 묶여 있으면 작동하지 않습니다.

object value = -1.1;
int number = (int) value; // throws InvalidCastException

변환 연산자

C #에서는 형식에서 사용자 지정 변환 연산자를 정의 할 수 있습니다.이 연산자를 사용하면 명시 적 또는 암시 적 캐스트를 사용하여 값을 다른 형식으로 변환하거나 변환 할 수 있습니다. 예를 들어 JavaScript 표현식을 나타내는 클래스를 생각해보십시오.

public class JsExpression
{
    private readonly string expression;
    public JsExpression(string rawExpression)
    {
        this.expression = rawExpression;
    }
    public override string ToString()
    {
        return this.expression;
    }
    public JsExpression IsEqualTo(JsExpression other)
    {
        return new JsExpression("(" + this + " == " + other + ")");
    }
}

두 개의 JavaScript 값을 비교하는 JsExpression을 만들려면 다음과 같이하면됩니다.

JsExpression intExpression = new JsExpression("-1");
JsExpression doubleExpression = new JsExpression("-1.0");
Console.WriteLine(intExpression.IsEqualTo(doubleExpression)); // (-1 == -1.0)

그러나 명시 적 변환 을 사용할 때 단순 변환을 허용하기 위해 명시 적 변환 연산자 를 JsExpression 추가 할 수 있습니다.

public static explicit operator JsExpression(int value)
{
    return new JsExpression(value.ToString());
}
public static explicit operator JsExpression(double value)
{
    return new JsExpression(value.ToString());
}

// Usage:
JsExpression intExpression = (JsExpression)(-1);
JsExpression doubleExpression = (JsExpression)(-1.0);
Console.WriteLine(intExpression.IsEqualTo(doubleExpression)); // (-1 == -1.0)

또는, 우리는 구문이 훨씬 간단하게 암시 이러한 연산자를 변경할 수 있습니다.

public static implicit operator JsExpression(int value)
{
    return new JsExpression(value.ToString());
}
public static implicit operator JsExpression(double value)
{
    return new JsExpression(value.ToString());
}

// Usage:
JsExpression intExpression = -1;
Console.WriteLine(intExpression.IsEqualTo(-1.0)); // (-1 == -1.0)

LINQ 주조 작업

다음과 같은 유형이 있다고 가정합니다.

interface IThing {  }
class Thing : IThing {  }

LINQ를 사용하면 Enumerable.Cast<>() 및 Enumerable.OfType<>() 확장 메서드를 통해 IEnumerable<> 의 컴파일 타임 제네릭 형식을 변경하는 프로젝션을 만들 수 있습니다.

IEnumerable<IThing> things = new IThing[] {new Thing()};
IEnumerable<Thing> things2 = things.Cast<Thing>();
IEnumerable<Thing> things3 = things.OfType<Thing>();

때 things2 평가의 Cast<>() 메소드에 모든 값을 캐스팅해야 할 것이다 things 에 Thing 들. 캐스트 할 수없는 값이 발견되면 (자), InvalidCastException 가 Throw됩니다.

things3 이 평가 될 때 OfType<>() 메소드는 똑같은 작업을 수행합니다. 단, 캐스팅 할 수없는 값이 발견되면 예외를 던지기보다는 단순히 값을 생략합니다.

이러한 메소드의 제네릭 유형으로 인해 변환 연산자를 호출하거나 숫자 변환을 수행 할 수 없습니다.

double[] doubles = new[]{1,2,3}.Cast<double>().ToArray(); // Throws InvalidCastException

해결 방법으로 .Select() 내부에서 캐스트를 수행하기 만하면됩니다.

double[] doubles = new[]{1,2,3}.Select(i => (double)i).ToArray();