IT. Expert System.

C#

Explicit conversions


The following conversions are classified as explicit conversions:

  • All implicit conversions.

  • Explicit numeric conversions.

  • Explicit enumeration conversions.

  • Explicit nullable conversions.

  • Explicit reference conversions.

  • Explicit interface conversions.

  • Unboxing conversions.

  • User-defined explicit conversions.

Explicit conversions can occur in cast expressions .

The set of explicit conversions includes all implicit conversions. This means that redundant cast expressions are allowed.

The explicit conversions that are not implicit conversions are conversions that cannot be proven to always succeed, conversions that are known to possibly lose information, and conversions across domains of types sufficiently different to merit explicit notation.

      1. Explicit numeric conversions

The explicit numeric conversions are the conversions from a numeric-type to another numeric-type for which an implicit numeric conversion does not already exist:

  • From sbyte to byte, ushort, uint, ulong, or char.

  • From byte to sbyte and char.

  • From short to sbyte, byte, ushort, uint, ulong, or char.

  • From ushort to sbyte, byte, short, or char.

  • From int to sbyte, byte, short, ushort, uint, ulong, or char.

  • From uint to sbyte, byte, short, ushort, int, or char.

  • From long to sbyte, byte, short, ushort, int, uint, ulong, or char.

  • From ulong to sbyte, byte, short, ushort, int, uint, long, or char.

  • From char to sbyte, byte, or short.

  • From float to sbyte, byte, short, ushort, int, uint, long, ulong, char, or decimal.

  • From double to sbyte, byte, short, ushort, int, uint, long, ulong, char, float, or decimal.

  • From decimal to sbyte, byte, short, ushort, int, uint, long, ulong, char, float, or double.

Because the explicit conversions include all implicit and explicit numeric conversions, it is always possible to convert from any numeric-type to any other numeric-type using a cast expression .

The explicit numeric conversions possibly lose information or possibly cause exceptions to be thrown. An explicit numeric conversion is processed as follows:

  • For a conversion from an integral type to another integral type, the processing depends on the overflow checking context in which the conversion takes place:

  • In a checked context, the conversion succeeds if the value of the source operand is within the range of the destination type, but throws a System.OverflowException if the value of the source operand is outside the range of the destination type.

  • In an unchecked context, the conversion always succeeds, and proceeds as follows.

  • If the source type is larger than the destination type, then the source value is truncated by discarding its “extra” most significant bits. The result is then treated as a value of the destination type.

  • If the source type is smaller than the destination type, then the source value is either sign-extended or zero-extended so that it is the same size as the destination type. Sign-extension is used if the source type is signed; zero-extension is used if the source type is unsigned. The result is then treated as a value of the destination type.

  • If the source type is the same size as the destination type, then the source value is treated as a value of the destination type.

  • For a conversion from decimal to an integral type, the source value is rounded towards zero to the nearest integral value, and this integral value becomes the result of the conversion. If the resulting integral value is outside the range of the destination type, a System.OverflowException is thrown.

  • For a conversion from float or double to an integral type, the processing depends on the overflow checking context in which the conversion takes place:

  • In a checked context, the conversion proceeds as follows:

  • If the value of the operand is NaN or infinite, a System.OverflowException is thrown.

  • Otherwise, the source operand is rounded towards zero to the nearest integral value. If this integral value is within the range of the destination type then this value is the result of the conversion.

  • Otherwise, a System.OverflowException is thrown.

  • In an unchecked context, the conversion always succeeds, and proceeds as follows.

  • If the value of the operand is NaN or infinite, the result of the conversion is an unspecified value of the destination type.

  • Otherwise, the source operand is rounded towards zero to the nearest integral value. If this integral value is within the range of the destination type then this value is the result of the conversion.

  • Otherwise, the result of the conversion is an unspecified value of the destination type.

  • For a conversion from double to float, the double value is rounded to the nearest float value. If the double value is too small to represent as a float, the result becomes positive zero or negative zero. If the double value is too large to represent as a float, the result becomes positive infinity or negative infinity. If the double value is NaN, the result is also NaN.

  • For a conversion from float or double to decimal, the source value is converted to decimal representation and rounded to the nearest number after the 28th decimal place if required . If the source value is too small to represent as a decimal, the result becomes zero. If the source value is NaN, infinity, or too large to represent as a decimal, a System.OverflowException is thrown.

  • For a conversion from decimal to float or double, the decimal value is rounded to the nearest double or float value. While this conversion may lose precision, it never causes an exception to be thrown.

      1. Explicit enumeration conversions

The explicit enumeration conversions are:

  • From sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, or decimal to any enum-type.

  • From any enum-type to sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, or decimal.

  • From any enum-type to any other enum-type.

An explicit enumeration conversion between two types is processed by treating any participating enum-type as the underlying type of that enum-type, and then performing an implicit or explicit numeric conversion between the resulting types. For example, given an enum-type E with and underlying type of int, a conversion from E to byte is processed as an explicit numeric conversion from int to byte, and a conversion from byte to E is processed as an implicit numeric conversion from byte to int.

      1. Explicit nullable conversions

Explicit nullable conversions permit predefined explicit conversions that operate on non-nullable value types to also be used with nullable forms of those types. For each of the predefined explicit conversions that convert from a non-nullable value type S to a non-nullable value type T , the following nullable conversions exist:

  • An explicit conversion from S? to T?.

  • An explicit conversion from S to T?.

  • An explicit conversion from S? to T.

Evaluation of a nullable conversion based on an underlying conversion from S to T proceeds as follows:

  • If the nullable conversion is from S? to T?:

  • If the source value is null (HasValue property is false), the result is the null value of type T?.

  • Otherwise, the conversion is evaluated as an unwrapping from S? to S, followed by the underlying conversion from S to T, followed by a wrapping from T to T?.

  • If the nullable conversion is from S to T?, the conversion is evaluated as the underlying conversion from S to T followed by a wrapping from T to T?.

  • If the nullable conversion is from S? to T, the conversion is evaluated as an unwrapping from S? to S followed by the underlying conversion from S to T.

Note that an attempt to unwrap a nullable value will throw an exception if the value is null.

      1. Explicit reference conversions

The explicit reference conversions are:

  • From object to any other reference-type.

  • From any class-type S to any class-type T, provided S is a base class of T.

  • From any class-type S to any interface-type T, provided S is not sealed and provided S does not implement T.

  • From any interface-type S to any class-type T, provided T is not sealed or provided T implements S.

  • From any interface-type S to any interface-type T, provided S is not derived from T.

  • From an array-type S with an element type SE to an array-type T with an element type TE, provided all of the following are true:

  • S and T differ only in element type. In other words, S and T have the same number of dimensions.

  • Both SE and TE are reference-types.

  • An explicit reference conversion exists from SE to TE.

  • From System.Array and the interfaces it implements to any array-type.

  • From a single-dimensional array type S[] to System.Collections.Generic.IList<T> and its base interfaces, provided that there is an explicit reference conversion from S to T.

  • From System.Collections.Generic.IList<S> and its base interfaces to a single-dimensional array type T[], provided that there is an explicit identity or reference conversion from S to T.

  • From System.Delegate and the interfaces it implements to any delegate-type.

  • Explicit conversions involving type parameters that are known to be reference types. For more details on explicit conversions involving type parameters, see §6.2.6.

The explicit reference conversions are those conversions between reference-types that require run-time checks to ensure they are correct.

For an explicit reference conversion to succeed at run-time, the value of the source operand must be null, or the actual type of the object referenced by the source operand must be a type that can be converted to the destination type by an implicit reference conversion . If an explicit reference conversion fails, a System.InvalidCastException is thrown.

Reference conversions, implicit or explicit, never change the referential identity of the object being converted. In other words, while a reference conversion may change the type of the reference, it never changes the type or value of the object being referred to.

      1. Unboxing conversions

An unboxing conversion permits a reference type to be explicitly converted to a value-type. An unboxing conversion exists from the types object and System.ValueType to any non-nullable-value-type, and from any interface-type to any non-nullable-value-type that implements the interface-type. Furthermore type System.Enum can be unboxed to any enum-type.

An unboxing conversion exists from a reference type to a nullable-type if an unboxing conversion exists from the reference type to the underlying non-nullable-value-type of the nullable-type.

An unboxing operation consists of first checking that the object instance is a boxed value of the given value-type, and then copying the value out of the instance. Unboxing a null reference to a nullable-type produces the null value of the nullable-type. A struct can be unboxed from the type System.ValueType, since that is a base class for all structs .

Unboxing conversions are described further in §4.3.2.

      1. Explicit conversions involving type parameters

The following explicit conversions exist for a given type parameter T:

  • From the effective base class C of T to T and from any base class of C to T. At run-time, if T is a value type, the conversion is executed as an unboxing conversion. Otherwise, the conversion is executed as an explicit reference conversion or identity conversion.

  • From any interface type to T. At run-time, if T is a value type, the conversion is executed as an unboxing conversion. Otherwise, the conversion is executed as an explicit reference conversion or identity conversion.

  • From T to any interface-type I provided there is not already an implicit conversion from T to I. At run-time, if T is a value type, the conversion is executed as a boxing conversion followed by an explicit reference conversion. Otherwise, the conversion is executed as an explicit reference conversion or identity conversion.

  • From a type parameter U to T, provided T depends on U. At run-time, if T is a value type and U is a reference type, the conversion is executed as an unboxing conversion. Otherwise, if both T and U are value types, then T and U are necessarily the same type and no conversion is performed. Otherwise, if T is a reference type, then U is necessarily also a reference type and the conversion is executed as an explicit reference conversion or identity conversion.

If T is known to be a reference type, the conversions above are all classified as explicit reference conversions . If T is not known to be a reference type, the conversions described in the first two bullets above are classified as unboxing conversions .

The above rules do not permit a direct explicit conversion from an unconstrained type parameter to a non-interface type, which might be surprising. The reason for this rule is to prevent confusion and make the semantics of such conversions clear. For example, consider the following declaration:

class X<T>
{
public static long F(T t) {
return (long)t; // Error
}
}

If the direct explicit conversion of t to int were permitted, one might easily expect that X<int>.F(7) would return 7L. However, it would not, because the standard numeric conversions are only considered when the types are known to be numeric at compile time. In order to make the semantics clear, the above example must instead be written:

class X<T>
{
public static long F(T t) {
return (long)(object)t; // Ok, but will only work when T is long
}
}

This code will now compile but executing X<int>.F(7) would then throw an exception at runtime, since a boxed int cannot be converted directly to a long.

      1. User-defined explicit conversions

A user-defined explicit conversion consists of an optional standard explicit conversion, followed by execution of a user-defined implicit or explicit conversion operator, followed by another optional standard explicit conversion. The exact rules for evaluating user-defined explicit conversions are described in §6.4.5.



Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 1046 / . Delta: 0.03124 с