ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveCast C# (CSharp) Méthode

		public ResolveResult ResolveCast(IType targetType, ResolveResult expression)
		{
			// C# 4.0 spec: §7.7.6 Cast expressions
			Conversion c = conversions.ExplicitConversion(expression, targetType);
			if (expression.IsCompileTimeConstant && !c.IsUserDefined) {
				TypeCode code = ReflectionHelper.GetTypeCode(targetType);
				if (code >= TypeCode.Boolean && code <= TypeCode.Decimal && expression.ConstantValue != null) {
					try {
						return new ConstantResolveResult(targetType, CSharpPrimitiveCast(code, expression.ConstantValue));
					} catch (OverflowException) {
						return new ErrorResolveResult(targetType);
					} catch (InvalidCastException) {
						return new ErrorResolveResult(targetType);
					}
				} else if (code == TypeCode.String) {
					if (expression.ConstantValue == null || expression.ConstantValue is string)
						return new ConstantResolveResult(targetType, expression.ConstantValue);
					else
						return new ErrorResolveResult(targetType);
				} else if (targetType.Kind == TypeKind.Enum) {
					code = ReflectionHelper.GetTypeCode(GetEnumUnderlyingType(targetType));
					if (code >= TypeCode.SByte && code <= TypeCode.UInt64 && expression.ConstantValue != null) {
						try {
							return new ConstantResolveResult(targetType, CSharpPrimitiveCast(code, expression.ConstantValue));
						} catch (OverflowException) {
							return new ErrorResolveResult(targetType);
						} catch (InvalidCastException) {
							return new ErrorResolveResult(targetType);
						}
					}
				}
			}
			return new ConversionResolveResult(targetType, expression, c, checkForOverflow);
		}
		

        public void Addition()
        {
            TestOperator(MakeResult(typeof(short)), BinaryOperatorType.Add, MakeResult(typeof(byte?)),
                         Conversion.ImplicitNullableConversion, Conversion.ImplicitNullableConversion, typeof(int?));

            AssertConstant(3.0, resolver.ResolveBinaryOperator(
                               BinaryOperatorType.Add, MakeConstant(1.0f), MakeConstant(2.0)));

            AssertConstant("Text", resolver.ResolveBinaryOperator(
                               BinaryOperatorType.Add, MakeConstant("Te"), MakeConstant("xt")));

            AssertConstant("", resolver.ResolveBinaryOperator(
                               BinaryOperatorType.Add, MakeConstant(null), resolver.ResolveCast(ResolveType(typeof(string)), MakeConstant(null))));

            AssertError(typeof(ReflectionHelper.Null), resolver.ResolveBinaryOperator(
                            BinaryOperatorType.Add, MakeConstant(null), MakeConstant(null)));

            TestOperator(MakeResult(typeof(int?)), BinaryOperatorType.Add, MakeResult(typeof(uint?)),
                         Conversion.ImplicitNullableConversion, Conversion.ImplicitNullableConversion, typeof(long?));

            TestOperator(MakeResult(typeof(ushort?)), BinaryOperatorType.Add, MakeResult(typeof(ushort?)),
                         Conversion.ImplicitNullableConversion, Conversion.ImplicitNullableConversion, typeof(int?));

            TestOperator(MakeConstant(1), BinaryOperatorType.Add, MakeConstant(null),
                         Conversion.ImplicitNullableConversion, Conversion.NullLiteralConversion, typeof(int?));
        }