Complex.Implicit Opérateur
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Définit une conversion implicite entre un objet Complex et un autre type.
Surcharges
| Implicit(SByte to Complex) |
Définit une conversion implicite d'un octet signé en nombre complexe. Cette API n'est pas conforme CLS. |
| Implicit(UIntPtr to Complex) |
Convertit implicitement une UIntPtr valeur en nombre complexe à double précision. |
| Implicit(UInt64 to Complex) |
Définit une conversion implicite d'un entier 64 bits non signé en nombre complexe. Cette API n'est pas conforme CLS. |
| Implicit(UInt32 to Complex) |
Définit une conversion implicite d'un entier 32 bits non signé en nombre complexe. Cette API n'est pas conforme CLS. |
| Implicit(UInt16 to Complex) |
Définit une conversion implicite d'un entier 16 bits non signé en nombre complexe. Cette API n'est pas conforme CLS. |
| Implicit(Single to Complex) |
Définit une conversion implicite d'un nombre à virgule flottante simple précision en un nombre complexe. |
| Implicit(IntPtr to Complex) |
Convertit implicitement une IntPtr valeur en nombre complexe à double précision. |
| Implicit(Double to Complex) |
Définit une conversion implicite d'un nombre à virgule flottante double précision en un nombre complexe. |
| Implicit(Int32 to Complex) |
Définit une conversion implicite d'un entier 32 bits signé en nombre complexe. |
| Implicit(Int16 to Complex) |
Définit une conversion implicite d'un entier 16 bits signé en nombre complexe. |
| Implicit(Half to Complex) |
Convertit implicitement une Half valeur en nombre complexe à double précision. |
| Implicit(Int64 to Complex) |
Définit une conversion implicite d'un entier 64 bits signé en nombre complexe. |
| Implicit(Char to Complex) |
Convertit implicitement une Char valeur en nombre complexe à double précision. |
| Implicit(Byte to Complex) |
Définit une conversion implicite d'un octet non signé en nombre complexe. |
Implicit(SByte to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Important
Cette API n’est pas conforme CLS.
Définit une conversion implicite d'un octet signé en nombre complexe.
Cette API n'est pas conforme CLS.
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 ComplexParamètres
- value
- SByte
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
- Attributs
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’un octet signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’octet signé et dont la partie imaginaire est égale à zéro.
sbyte sbyteValue = -12;
System.Numerics.Complex c1 = sbyteValue;
Console.WriteLine(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)
S’applique à
Implicit(UIntPtr to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Important
Cette API n’est pas conforme CLS.
Convertit implicitement une UIntPtr valeur en nombre complexe à double précision.
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 ComplexParamètres
- value
-
UIntPtr
unativeint
La valeur à convertir.
Retours
value converti en nombre complexe double précision.
- Attributs
S’applique à
Implicit(UInt64 to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Important
Cette API n’est pas conforme CLS.
Définit une conversion implicite d'un entier 64 bits non signé en nombre complexe.
Cette API n'est pas conforme CLS.
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 ComplexParamètres
- value
- UInt64
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
- Attributs
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’un entier 64 bits non signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 64 bits non signé et dont la partie imaginaire est égale à zéro.
ulong longValue = 951034217;
System.Numerics.Complex c1 = longValue;
Console.WriteLine(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)
S’applique à
Implicit(UInt32 to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Important
Cette API n’est pas conforme CLS.
Définit une conversion implicite d'un entier 32 bits non signé en nombre complexe.
Cette API n'est pas conforme CLS.
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 ComplexParamètres
- value
- UInt32
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
- Attributs
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’un entier 32 bits non signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 32 bits non signé et dont la partie imaginaire est égale à zéro.
uint value = 197461;
System.Numerics.Complex c1 = value;
Console.WriteLine(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)
S’applique à
Implicit(UInt16 to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Important
Cette API n’est pas conforme CLS.
Définit une conversion implicite d'un entier 16 bits non signé en nombre complexe.
Cette API n'est pas conforme CLS.
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 ComplexParamètres
- value
- UInt16
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
- Attributs
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’un entier 16 bits non signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 16 bits non signé et dont la partie imaginaire est égale à zéro.
ushort shortValue = 421;
System.Numerics.Complex c1 = shortValue;
Console.WriteLine(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)
S’applique à
Implicit(Single to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Définit une conversion implicite d'un nombre à virgule flottante simple précision en un nombre complexe.
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 ComplexParamètres
- value
- Single
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’une Single valeur en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à la valeur et dont la Single partie imaginaire est égale à zéro.
float singleValue = 1.032e-08f;
System.Numerics.Complex c1 = singleValue;
Console.WriteLine(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)
S’applique à
Implicit(IntPtr to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Convertit implicitement une IntPtr valeur en nombre complexe à double précision.
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 ComplexParamètres
- value
-
IntPtr
nativeint
La valeur à convertir.
Retours
value converti en nombre complexe double précision.
S’applique à
Implicit(Double to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Définit une conversion implicite d'un nombre à virgule flottante double précision en un nombre complexe.
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 ComplexParamètres
- value
- Double
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’une Double valeur en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à la valeur et dont la Double partie imaginaire est égale à zéro.
double doubleValue = 1.032e-16;
System.Numerics.Complex c1 = doubleValue;
Console.WriteLine(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)
S’applique à
Implicit(Int32 to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Définit une conversion implicite d'un entier 32 bits signé en nombre complexe.
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 ComplexParamètres
- value
- Int32
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’un entier 32 bits signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 32 bits signé et dont la partie imaginaire est égale à zéro.
int intValue = 1034217;
System.Numerics.Complex c1 = intValue;
Console.WriteLine(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)
S’applique à
Implicit(Int16 to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Définit une conversion implicite d'un entier 16 bits signé en nombre complexe.
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 ComplexParamètres
- value
- Int16
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’un entier 16 bits signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 16 bits signé et dont la partie imaginaire est égale à zéro.
short shortValue = 16024;
System.Numerics.Complex c1 = shortValue;
Console.WriteLine(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)
S’applique à
Implicit(Half to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Convertit implicitement une Half valeur en nombre complexe double précision.
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 ComplexParamètres
- value
- Half
La valeur à convertir.
Retours
value converti en nombre complexe double précision.
S’applique à
Implicit(Int64 to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Définit une conversion implicite d'un entier 64 bits signé en nombre complexe.
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 ComplexParamètres
- value
- Int64
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’un entier 64 bits signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 64 bits signé et dont la partie imaginaire est égale à zéro.
long longValue = 951034217;
System.Numerics.Complex c1 = longValue;
Console.WriteLine(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)
S’applique à
Implicit(Char to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Convertit implicitement une Char valeur en nombre complexe double précision.
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 ComplexParamètres
- value
- Char
La valeur à convertir.
Retours
value converti en nombre complexe double précision.
S’applique à
Implicit(Byte to Complex)
- Source:
- Complex.cs
- Source:
- Complex.cs
- Source:
- Complex.cs
Définit une conversion implicite d'un octet non signé en nombre complexe.
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 ComplexParamètres
- value
- Byte
Valeur à convertir en nombre complexe.
Retours
Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.
Remarques
Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.
Cette surcharge permet au compilateur de gérer les conversions d’une Byte valeur en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à la valeur et dont la Byte partie imaginaire est égale à zéro.
byte byteValue = 122;
System.Numerics.Complex c1 = byteValue;
Console.WriteLine(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)
S’applique à
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour