# Expression.Convert Method

## Definition

Creates a UnaryExpression that represents a type conversion operation.

## Overloads

Convert(Expression, Type) |
Creates a UnaryExpression that represents a type conversion operation. |

Convert(Expression, Type, MethodInfo) |
Creates a UnaryExpression that represents a conversion operation for which the implementing method is specified. |

## Convert(Expression, Type)

Creates a UnaryExpression that represents a type conversion operation.

```
public:
static System::Linq::Expressions::UnaryExpression ^ Convert(System::Linq::Expressions::Expression ^ expression, Type ^ type);
```

`public static System.Linq.Expressions.UnaryExpression Convert (System.Linq.Expressions.Expression expression, Type type);`

`static member Convert : System.Linq.Expressions.Expression * Type -> System.Linq.Expressions.UnaryExpression`

`Public Shared Function Convert (expression As Expression, type As Type) As UnaryExpression`

#### Parameters

- expression
- Expression

An Expression to set the Operand property equal to.

#### Returns

A UnaryExpression that has the NodeType property equal to Convert and the Operand and Type properties set to the specified values.

#### Exceptions

`expression`

or `type`

is `null`

.

No conversion operator is defined between `expression`

.Type and `type`

.

### Examples

The following code example shows how to create an expression that represents a type conversion operation.

```
// Add the following directive to your file:
// using System.Linq.Expressions;
// This expression represents a type conversion operation.
Expression convertExpr = Expression.Convert(
Expression.Constant(5.5),
typeof(Int16)
);
// Print out the expression.
Console.WriteLine(convertExpr.ToString());
// The following statement first creates an expression tree,
// then compiles it, and then executes it.
Console.WriteLine(Expression.Lambda<Func<Int16>>(convertExpr).Compile()());
// This code example produces the following output:
//
// Convert(5.5)
// 5
```

```
' Add the following directive to your file:
' Imports System.Linq.Expressions
' This expression represents a type conversion operation.
Dim convertExpr As Expression = Expression.Convert(
Expression.Constant(5.5),
GetType(Int16)
)
' Print the expression.
Console.WriteLine(convertExpr.ToString())
' The following statement first creates an expression tree,
' then compiles it, and then executes it.
Console.WriteLine(Expression.Lambda(Of Func(Of Int16))(convertExpr).Compile()())
' This code example produces the following output:
'
' Convert(5.5)
' 5
```

### Remarks

The Method property of the resulting UnaryExpression is set to the implementing method. The IsLiftedToNull property is `false`

. If the node is lifted, IsLifted is `true`

. Otherwise, it is `false`

.

#### Implementing Method

The following rules determine the implementing method for the operation:

If either

`expression`

.Type or`type`

is a user-defined type that defines an implicit or explicit conversion operator, the MethodInfo that represents that operator is the implementing method.Otherwise:

If both

`expression`

.Type and`type`

represent numeric or Boolean types, or nullable or non-nullable enumeration types, the implementing method is`null`

.If either

`expression`

.Type or`type`

is a reference type and an explicit boxing, unboxing, or reference conversion exists from`expression`

.Type to`type`

, the implementing method is`null`

.

#### Lifted versus Non-Lifted

If the implementing method is not `null`

:

If

`expression`

.Type is assignable to the argument type of the implementing method and the return type of the implementing method is assignable to`type`

, the node is not lifted.If one or both of

`expression`

.Type or`type`

is a nullable value type and the corresponding non-nullable value types are equal to the argument type and the return type of the implementing method respectively, the node is lifted.

If the implementing method is `null`

:

If both

`expression`

.Type and`type`

are non-nullable, the node is not lifted.Otherwise the node is lifted.

## Convert(Expression, Type, MethodInfo)

Creates a UnaryExpression that represents a conversion operation for which the implementing method is specified.

```
public:
static System::Linq::Expressions::UnaryExpression ^ Convert(System::Linq::Expressions::Expression ^ expression, Type ^ type, System::Reflection::MethodInfo ^ method);
```

`public static System.Linq.Expressions.UnaryExpression Convert (System.Linq.Expressions.Expression expression, Type type, System.Reflection.MethodInfo method);`

`static member Convert : System.Linq.Expressions.Expression * Type * System.Reflection.MethodInfo -> System.Linq.Expressions.UnaryExpression`

`Public Shared Function Convert (expression As Expression, type As Type, method As MethodInfo) As UnaryExpression`

#### Parameters

- expression
- Expression

An Expression to set the Operand property equal to.

- method
- MethodInfo

A MethodInfo to set the Method property equal to.

#### Returns

A UnaryExpression that has the NodeType property equal to Convert and the Operand, Type, and Method properties set to the specified values.

#### Exceptions

`expression`

or `type`

is `null`

.

`method`

is not `null`

and the method it represents returns `void`

, is not `static`

(`Shared`

in Visual Basic), or does not take exactly one argument.

No conversion operator is defined between `expression`

.Type and `type`

.

-or-

`expression`

.Type is not assignable to the argument type of the method represented by `method`

.

-or-

The return type of the method represented by `method`

is not assignable to `type`

.

-or-

`expression`

.Type or `type`

is a nullable value type and the corresponding non-nullable value type does not equal the argument type or the return type, respectively, of the method represented by `method`

.

More than one method that matches the `method`

description was found.

### Remarks

The Method property of the resulting UnaryExpression is set to the implementing method. The IsLiftedToNull property is `false`

. If the node is lifted, IsLifted is `true`

. Otherwise, it is `false`

.

#### Implementing Method

The following rules determine the implementing method for the operation:

If method is not

`null`

, it is the implementing method. It must represent a non-void,`static`

(`Shared`

in Visual Basic) method that takes one argument.Otherwise, if either

`expression`

.Type or`type`

is a user-defined type that defines an implicit or explicit conversion operator, the MethodInfo that represents that operator is the implementing method.Otherwise:

If both

`expression`

.Type and`type`

represent numeric or Boolean types, or nullable or non-nullable enumeration types, the implementing method is`null`

.If either

`expression`

.Type or`type`

is a reference type and an explicit boxing, unboxing, or reference conversion exists from`expression`

.Type to`type`

, the implementing method is`null`

.

#### Lifted versus Non-Lifted

If the implementing method is not `null`

:

If

`expression`

.Type is assignable to the argument type of the implementing method and the return type of the implementing method is assignable to`type`

, the node is not lifted.If either or both of

`expression`

.Type or`type`

are a nullable value type and the corresponding non-nullable value types are equal to the argument type and the return type of the implementing method respectively, the node is lifted.

If the implementing method is `null`

:

If both

`expression`

.Type and`type`

are non-nullable, the node is not lifted.Otherwise the node is lifted.