Complex.Implicit Operator
Definitie
Belangrijk
Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.
Hiermee definieert u een impliciete conversie tussen een Complex object en een ander type.
Overloads
| Name | Description |
|---|---|
| Implicit(SByte to Complex) |
Hiermee definieert u een impliciete conversie van een ondertekende byte naar een complex getal. Deze API is niet CLS-conform. |
| Implicit(UIntPtr to Complex) |
Converteert impliciet een UIntPtr waarde naar een complex getal met dubbele precisie. |
| Implicit(UInt64 to Complex) |
Definieert een impliciete conversie van een 64-bits geheel getal zonder teken naar een complex getal. Deze API is niet CLS-conform. |
| Implicit(UInt32 to Complex) |
Hiermee definieert u een impliciete conversie van een 32-bits geheel getal zonder teken naar een complex getal. Deze API is niet CLS-conform. |
| Implicit(UInt16 to Complex) |
Definieert een impliciete conversie van een 16-bits geheel getal zonder teken naar een complex getal. Deze API is niet CLS-conform. |
| Implicit(Single to Complex) |
Definieert een impliciete conversie van een drijvendekommagetal met één precisie naar een complex getal. |
| Implicit(BFloat16 to Complex) | |
| Implicit(Int32 to Complex) |
Hiermee definieert u een impliciete conversie van een 32-bits geheel getal met teken naar een complex getal. |
| Implicit(Int64 to Complex) |
Hiermee definieert u een impliciete conversie van een 64-bits geheel getal met teken naar een complex getal. |
| Implicit(IntPtr to Complex) |
Converteert impliciet een IntPtr waarde naar een complex getal met dubbele precisie. |
| Implicit(Int16 to Complex) |
Definieert een impliciete conversie van een 16-bits geheel getal met teken naar een complex getal. |
| Implicit(Half to Complex) |
Converteert impliciet een Half waarde naar een complex getal met dubbele precisie. |
| Implicit(Double to Complex) |
Definieert een impliciete conversie van een drijvendekommagetal met dubbele precisie naar een complex getal. |
| Implicit(Char to Complex) |
Converteert impliciet een Char waarde naar een complex getal met dubbele precisie. |
| Implicit(Byte to Complex) |
Hiermee definieert u een impliciete conversie van een niet-ondertekende byte naar een complex getal. |
Implicit(SByte to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Belangrijk
Deze API is niet CLS-conform.
Hiermee definieert u een impliciete conversie van een ondertekende byte naar een complex getal.
Deze API is niet CLS-conform.
public:
static operator System::Numerics::Complex(System::SByte value);[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex(sbyte value);[<System.CLSCompliant(false)>]
static member op_Implicit : sbyte -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As SByte) As ComplexParameters
- value
- SByte
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
- Kenmerken
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies van een ondertekende byte naar een complex getal verwerken, zoals in het volgende voorbeeld wordt weergegeven. Het resultaat van de conversie is een complex getal waarvan het werkelijke deel gelijk is aan de ondertekende byte en waarvan het imaginaire deel gelijk is aan nul.
sbyte sbyteValue = -12;
System.Numerics.Complex c1 = sbyteValue;
Console.WriteLine(c1);
// The example displays the following output:
// (-12, 0)
let sbyteValue = -12
let c1: System.Numerics.Complex = sbyteValue
printfn $"{c1}"
// The example displays the following output:
// (-12, 0)
Dim sbyteValue As SByte = -12
Dim c1 As System.Numerics.Complex = sbyteValue
Console.WriteLine(c1)
' The example displays the following output:
' (-12, 0)
Van toepassing op
Implicit(UIntPtr to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Belangrijk
Deze API is niet CLS-conform.
Converteert impliciet een UIntPtr waarde naar een complex getal met dubbele precisie.
public:
static operator System::Numerics::Complex(UIntPtr value);[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex(UIntPtr value);[<System.CLSCompliant(false)>]
static member op_Implicit : unativeint -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As UIntPtr) As ComplexParameters
- value
-
UIntPtr
unativeint
De waarde die moet worden geconverteerd.
Retouren
value geconverteerd naar een complex getal met dubbele precisie.
- Kenmerken
Van toepassing op
Implicit(UInt64 to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Belangrijk
Deze API is niet CLS-conform.
Definieert een impliciete conversie van een 64-bits geheel getal zonder teken naar een complex getal.
Deze API is niet CLS-conform.
public:
static operator System::Numerics::Complex(System::UInt64 value);[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex(ulong value);[<System.CLSCompliant(false)>]
static member op_Implicit : uint64 -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As ULong) As ComplexParameters
- value
- UInt64
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
- Kenmerken
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies verwerken van een niet-ondertekend 64-bits geheel getal naar een complex getal, zoals in het volgende voorbeeld wordt weergegeven. Het resultaat van de conversie is een complex getal waarvan het werkelijke deel gelijk is aan het niet-ondertekende 64-bits gehele getal en waarvan het imaginaire deel gelijk is aan nul.
ulong longValue = 951034217;
System.Numerics.Complex c1 = longValue;
Console.WriteLine(c1);
// The example displays the following output:
// (951034217, 0)
let longValue = 951034217
let c1: System.Numerics.Complex = longValue
printfn $"{c1}"
// The example displays the following output:
// (951034217, 0)
Dim longValue As ULong = 951034217
Dim c1 As System.Numerics.Complex = longValue
Console.WriteLine(c1)
' The example displays the following output:
' (951034217, 0)
Van toepassing op
Implicit(UInt32 to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Belangrijk
Deze API is niet CLS-conform.
Hiermee definieert u een impliciete conversie van een 32-bits geheel getal zonder teken naar een complex getal.
Deze API is niet CLS-conform.
public:
static operator System::Numerics::Complex(System::UInt32 value);[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex(uint value);[<System.CLSCompliant(false)>]
static member op_Implicit : uint32 -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As UInteger) As ComplexParameters
- value
- UInt32
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
- Kenmerken
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies verwerken van een niet-ondertekend 32-bits geheel getal naar een complex getal, zoals in het volgende voorbeeld wordt weergegeven. Houd er rekening mee dat het resultaat van de conversie een complex getal is waarvan het werkelijke deel gelijk is aan het niet-ondertekende 32-bits gehele getal en waarvan het imaginaire deel gelijk is aan nul.
uint value = 197461;
System.Numerics.Complex c1 = value;
Console.WriteLine(c1);
// The example displays the following output:
// (197461, 0)
let value = 197461
let c1: System.Numerics.Complex = value
printfn $"{c1}"
// The example displays the following output:
// (197461, 0)
Dim intValue As UInteger = 197461
Dim c1 As System.Numerics.Complex = intValue
Console.WriteLine(c1)
' The example displays the following output:
' (197461, 0)
Van toepassing op
Implicit(UInt16 to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Belangrijk
Deze API is niet CLS-conform.
Definieert een impliciete conversie van een 16-bits geheel getal zonder teken naar een complex getal.
Deze API is niet CLS-conform.
public:
static operator System::Numerics::Complex(System::UInt16 value);[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex(ushort value);[<System.CLSCompliant(false)>]
static member op_Implicit : uint16 -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As UShort) As ComplexParameters
- value
- UInt16
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
- Kenmerken
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies verwerken van een niet-ondertekend 16-bits geheel getal naar een complex getal, zoals in het volgende voorbeeld wordt weergegeven. Het resultaat van de conversie is een complex getal waarvan het werkelijke deel gelijk is aan het niet-ondertekende 16-bits gehele getal en waarvan het imaginaire deel gelijk is aan nul.
ushort shortValue = 421;
System.Numerics.Complex c1 = shortValue;
Console.WriteLine(c1);
// The example displays the following output:
// (421, 0)
let shortValue = 421
let c1: System.Numerics.Complex = shortValue
printfn $"{c1}"
// The example displays the following output:
// (421, 0)
Dim shortValue As UShort = 421
Dim c1 As System.Numerics.Complex = shortValue
Console.WriteLine(c1)
' The example displays the following output:
' (421, 0)
Van toepassing op
Implicit(Single to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Definieert een impliciete conversie van een drijvendekommagetal met één precisie naar een complex getal.
public:
static operator System::Numerics::Complex(float value);public static implicit operator System.Numerics.Complex(float value);static member op_Implicit : single -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As Single) As ComplexParameters
- value
- Single
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies van een Single waarde naar een complex getal verwerken, zoals in het volgende voorbeeld wordt weergegeven. Het resultaat van de conversie is een complex getal waarvan het werkelijke deel gelijk is aan de Single waarde en waarvan het imaginaire deel gelijk is aan nul.
float singleValue = 1.032e-08f;
System.Numerics.Complex c1 = singleValue;
Console.WriteLine(c1);
// The example displays the following output:
// (1.03199999657022E-08, 0)
let singleValue = 1.032e-08f
let c1: System.Numerics.Complex = singleValue
printfn $"{c1}"
// The example displays the following output:
// (1.03199999657022E-08, 0)
Dim singleValue As Single = 1.032e-08
Dim c1 As System.Numerics.Complex = singleValue
Console.WriteLine(c1)
' The example displays the following output:
' (1.03199999657022E-08, 0)
Van toepassing op
Implicit(BFloat16 to Complex)
- Bron:
- Complex.cs
public:
static operator System::Numerics::Complex(System::Numerics::BFloat16 value);public static implicit operator System.Numerics.Complex(System.Numerics.BFloat16 value);static member op_Implicit : System.Numerics.BFloat16 -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As BFloat16) As ComplexParameters
- value
- BFloat16
Retouren
Van toepassing op
Implicit(Int32 to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Hiermee definieert u een impliciete conversie van een 32-bits geheel getal met teken naar een complex getal.
public:
static operator System::Numerics::Complex(int value);public static implicit operator System.Numerics.Complex(int value);static member op_Implicit : int -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As Integer) As ComplexParameters
- value
- Int32
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies verwerken van een ondertekend 32-bits geheel getal naar een complex getal, zoals in het volgende voorbeeld wordt weergegeven. Houd er rekening mee dat het resultaat van de conversie een complex getal is waarvan het werkelijke deel gelijk is aan het ondertekende 32-bits gehele getal en waarvan het imaginaire deel gelijk is aan nul.
int intValue = 1034217;
System.Numerics.Complex c1 = intValue;
Console.WriteLine(c1);
// The example displays the following output:
// (1034217, 0)
let intValue = 1034217
let c1: System.Numerics.Complex = intValue
printfn $"{c1}"
// The example displays the following output:
// (1034217, 0)
Dim intValue As Integer = 1034217
Dim c1 As System.Numerics.Complex = intValue
Console.WriteLine(c1)
' The example displays the following output:
' (1034217, 0)
Van toepassing op
Implicit(Int64 to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Hiermee definieert u een impliciete conversie van een 64-bits geheel getal met teken naar een complex getal.
public:
static operator System::Numerics::Complex(long value);public static implicit operator System.Numerics.Complex(long value);static member op_Implicit : int64 -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As Long) As ComplexParameters
- value
- Int64
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies verwerken van een ondertekend 64-bits geheel getal naar een complex getal, zoals in het volgende voorbeeld wordt weergegeven. Houd er rekening mee dat het resultaat van de conversie een complex getal is waarvan het werkelijke deel gelijk is aan het ondertekende 64-bits gehele getal en waarvan het imaginaire deel gelijk is aan nul.
long longValue = 951034217;
System.Numerics.Complex c1 = longValue;
Console.WriteLine(c1);
// The example displays the following output:
// (951034217, 0)
let longValue = 951034217
let c1: System.Numerics.Complex = longValue
printfn $"{c1}"
// The example displays the following output:
// (951034217, 0)
Dim longValue As Long = 951034217
Dim c1 As System.Numerics.Complex = longValue
Console.WriteLine(c1)
' The example displays the following output:
' (951034217, 0)
Van toepassing op
Implicit(IntPtr to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Converteert impliciet een IntPtr waarde naar een complex getal met dubbele precisie.
public:
static operator System::Numerics::Complex(IntPtr value);public static implicit operator System.Numerics.Complex(IntPtr value);static member op_Implicit : nativeint -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As IntPtr) As ComplexParameters
- value
-
IntPtr
nativeint
De waarde die moet worden geconverteerd.
Retouren
value geconverteerd naar een complex getal met dubbele precisie.
Van toepassing op
Implicit(Int16 to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Definieert een impliciete conversie van een 16-bits geheel getal met teken naar een complex getal.
public:
static operator System::Numerics::Complex(short value);public static implicit operator System.Numerics.Complex(short value);static member op_Implicit : int16 -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As Short) As ComplexParameters
- value
- Int16
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies verwerken van een ondertekend 16-bits geheel getal naar een complex getal, zoals in het volgende voorbeeld wordt weergegeven. Het resultaat van de conversie is een complex getal waarvan het werkelijke deel gelijk is aan het ondertekende 16-bits gehele getal en waarvan het imaginaire deel gelijk is aan nul.
short shortValue = 16024;
System.Numerics.Complex c1 = shortValue;
Console.WriteLine(c1);
// The example displays the following output:
// (16024, 0)
let shortValue = 16024
let c1: System.Numerics.Complex = shortValue
printfn $"{c1}"
// The example displays the following output:
// (16024, 0)
Dim shortValue As Short = 16024
Dim c1 As System.Numerics.Complex = shortValue
Console.WriteLine(c1)
' The example displays the following output:
' (16024, 0)
Van toepassing op
Implicit(Half to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Converteert impliciet een Half waarde naar een complex getal met dubbele precisie.
public:
static operator System::Numerics::Complex(Half value);public static implicit operator System.Numerics.Complex(Half value);static member op_Implicit : Half -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As Half) As ComplexParameters
- value
- Half
De waarde die moet worden geconverteerd.
Retouren
value geconverteerd naar een complex getal met dubbele precisie.
Van toepassing op
Implicit(Double to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Definieert een impliciete conversie van een drijvendekommagetal met dubbele precisie naar een complex getal.
public:
static operator System::Numerics::Complex(double value);public static implicit operator System.Numerics.Complex(double value);static member op_Implicit : double -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As Double) As ComplexParameters
- value
- Double
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies van een Double waarde naar een complex getal verwerken, zoals in het volgende voorbeeld wordt weergegeven. Het resultaat van de conversie is een complex getal waarvan het werkelijke deel gelijk is aan de Double waarde en waarvan het imaginaire deel gelijk is aan nul.
double doubleValue = 1.032e-16;
System.Numerics.Complex c1 = doubleValue;
Console.WriteLine(c1);
// The example displays the following output:
// (1.032E-16, 0)
let doubleValue = 1.032e-16
let c1: System.Numerics.Complex = doubleValue
printfn $"{c1}"
// The example displays the following output:
// (1.032E-16, 0)
Dim doubleValue As Double = 1.032e-16
Dim c1 As System.Numerics.Complex = doubleValue
Console.WriteLine(c1)
' The example displays the following output:
' (1.032E-16, 0)
Van toepassing op
Implicit(Char to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Converteert impliciet een Char waarde naar een complex getal met dubbele precisie.
public:
static operator System::Numerics::Complex(char value);public static implicit operator System.Numerics.Complex(char value);static member op_Implicit : char -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As Char) As ComplexParameters
- value
- Char
De waarde die moet worden geconverteerd.
Retouren
value geconverteerd naar een complex getal met dubbele precisie.
Van toepassing op
Implicit(Byte to Complex)
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
- Bron:
- Complex.cs
Hiermee definieert u een impliciete conversie van een niet-ondertekende byte naar een complex getal.
public:
static operator System::Numerics::Complex(System::Byte value);public static implicit operator System.Numerics.Complex(byte value);static member op_Implicit : byte -> System.Numerics.ComplexPublic Shared Widening Operator CType (value As Byte) As ComplexParameters
- value
- Byte
De waarde die moet worden geconverteerd naar een complex getal.
Retouren
Een object dat de waarde van de value parameter bevat als het werkelijke deel en nul als het imaginaire deel.
Opmerkingen
De overbelastingen van de operator Implicit definiëren de typen waaruit een compiler automatisch een Complex-object kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen .
Met deze overbelasting kan de compiler conversies van een Byte waarde naar een complex getal verwerken, zoals in het volgende voorbeeld wordt weergegeven. Het resultaat van de conversie is een complex getal waarvan het werkelijke deel gelijk is aan de Byte waarde en waarvan het imaginaire deel gelijk is aan nul.
byte byteValue = 122;
System.Numerics.Complex c1 = byteValue;
Console.WriteLine(c1);
// The example displays the following output:
// (122, 0)
let byteValue = 122
let c1: System.Numerics.Complex = byteValue
printfn $"{c1}"
// The example displays the following output:
// (122, 0)
Dim byteValue As Byte = 122
Dim c1 As System.Numerics.Complex = byteValue
Console.WriteLine(c1)
' The example displays the following output:
' (122, 0)
