Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Complex, structure

Représente un nombre complexe.

Espace de noms :  System.Numerics
Assembly :  System.Numerics (dans System.Numerics.dll)

[SerializableAttribute]
public struct Complex : IEquatable<Complex>, 
	IFormattable

Le type Complex expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreComplexInitialise une nouvelle instance de la structure Complex à l'aide des valeurs réelles et imaginaires spécifiées.
Début

  NomDescription
Propriété publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImaginaryObtient le composant imaginaire de l'objet Complex actuel.
Propriété publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMagnitudeObtient l'ordre de grandeur (ou valeur absolue) d'un nombre complexe.
Propriété publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePhaseObtient la phase d'un nombre complexe.
Propriété publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRealObtient le composant réel de l'objet Complex actuel.
Début

  NomDescription
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAbsObtient la valeur absolue (ou ordre de grandeur) d'un nombre complexe.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAcosRetourne l'angle qui correspond au cosinus d'arc du nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAddAjoute deux nombres complexes et retourne le résultat.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAsinRetourne l'angle qui correspond au sinus d'arc du nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAtanRetourne l'angle qui correspond à la tangente d'arc du nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConjugateCalcule le conjugué d'un nombre complexe et retourne le résultat.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCosRetourne le cosinus du nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCoshRetourne le cosinus hyperbolique du nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreDivideDivise un nombre complexe par un autre et retourne le résultat.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Complex)Retourne une valeur qui indique si l'instance actuelle et un nombre complexe spécifié ont la même valeur.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur. (Substitue ValueType.Equals(Object).)
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreExpRetourne e élevé à la puissance spécifiée par un nombre complexe.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFromPolarCoordinatesCrée un nombre complexe à partir des coordonnées polaires d'un point.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeRetourne le code de hachage pour l'objet Complex en cours. (Substitue ValueType.GetHashCode().)
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLog(Complex)Retourne le logarithme naturel (base e) d'un nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLog(Complex, Double)Retourne le logarithme d'un nombre complexe spécifié dans une base spécifiée.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLog10Retourne le logarithme de base 10 d'un nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMultiplyRetourne le produit de deux nombres complexes.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreNegateRetourne l'inverse additif d'un nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePow(Complex, Double)Retourne un nombre complexe spécifié élevé à une puissance spécifiée par un nombre à virgule flottante double précision.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePow(Complex, Complex)Retourne un nombre complexe spécifié élevé à une puissance spécifiée par un nombre complexe.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReciprocalRetourne l'inverse multiplicatif d'un nombre complexe.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSinRetourne le sinus du nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSinhRetourne le sinus hyperbolique du nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSqrtRetourne la racine carrée d'un nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSubtractSoustrait un nombre complexe d'un autre et retourne le résultat.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTanRetourne la tangente du nombre complexe spécifié.
Méthode publiqueMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTanhRetourne la tangente hyperbolique du nombre complexe spécifié.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString()Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien. (Substitue ValueType.ToString().)
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(IFormatProvider)Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(String)Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien en utilisant le format spécifié pour ses parties imaginaire et réelle.
Méthode publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString(String, IFormatProvider)Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien en utilisant le format et les informations de mise en forme spécifiques à la culture spécifiés pour ses parties imaginaire et réelle.
Début

  NomDescription
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAdditionAjoute deux nombres complexes.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreDivisionDivise un nombre complexe spécifié par un autre nombre complexe spécifié.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEqualityRetourne une valeur qui indique si deux nombres complexes sont égaux.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreExplicit(BigInteger to Complex)Définit une conversion explicite d'une valeur BigInteger en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreExplicit(Decimal to Complex)Définit une conversion explicite d'une valeur Decimal en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(Byte to Complex)Définit une conversion implicite d'un octet non signé en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(Double to Complex)Définit une conversion implicite d'un nombre à virgule flottante double précision en un nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(Int16 to Complex)Définit une conversion implicite d'un entier 16 bits signé en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(Int32 to Complex)Définit une conversion implicite d'un entier 32 bits signé en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(Int64 to Complex)Définit une conversion implicite d'un entier 64 bits signé en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(SByte to Complex)Définit une conversion implicite d'un octet signé en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(Single to Complex)Définit une conversion implicite d'un nombre à virgule flottante simple précision en un nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(UInt16 to Complex)Définit une conversion implicite d'un entier 16 bits non signé en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(UInt32 to Complex)Définit une conversion implicite d'un entier 32 bits non signé en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImplicit(UInt64 to Complex)Définit une conversion implicite d'un entier 64 bits non signé en nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreInequalityRetourne une valeur qui indique si deux nombres complexes sont différents.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMultiplyMultiplie deux nombres complexes spécifiés.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSubtractionSoustrait un nombre complexe d'un autre nombre complexe.
Opérateur publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreUnaryNegationRetourne l'inverse additif d'un nombre complexe spécifié.
Début

  NomDescription
Champ publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreImaginaryOneRetourne une nouvelle instance Complex avec un nombre réel égal à zéro et un nombre imaginaire égal à un.
Champ publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOneRetourne une nouvelle instance Complex avec un nombre réel égal à un et un nombre imaginaire égal à zéro.
Champ publicMembre statiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreZeroRetourne une nouvelle instance Complex avec un nombre réel égal à zéro et un nombre imaginaire égal à zéro.
Début

Un nombre complexe est un nombre qui comprend une partie de nombre réel et une partie de nombre imaginaire. Un nombre complexe z s'écrit habituellement sous la forme suivante : z = x + yi, où x et y sont des nombres réels, et i est l'unité imaginaire qui a la propriété i2 = -1. La partie réelle du nombre complexe est représentée par x, et la partie imaginaire du nombre complexe est représentée par y.

Le type Complex utilise le système de coordonnées cartésien (réel, imaginaire) lors de l'instanciation et de la manipulation des nombres complexes. Un nombre complexe peut être représenté comme un point dans un système de coordonnées à deux dimensions, appelé plan complexe. La partie réelle du nombre complexe est positionnée sur l'axe des abscisses (axe horizontal), et la partie imaginaire est positionnée sur l'axe des ordonnées (axe vertical).

Tout point d'un plan complexe peut également être exprimé selon sa valeur absolue, en utilisant le système de coordonnées polaires. Dans les coordonnées polaires, un point est caractérisé par deux nombres :

  • Sa grandeur, qui est la distance entre le point et l'origine (autrement dit, 0,0, ou le point auquel l'axe des abscisses et les axe des ordonnées se croisent).

  • Sa phase, qui est l'angle entre le véritable axe et la ligne tirée entre l'origine et le point.

Instanciation d'un nombre complexe

Vous pouvez assigner une valeur à un nombre complexe de l'une des manières suivantes :

  • En passant deux valeurs Double à son constructeur. La première valeur représente la partie réelle du nombre complexe, et la seconde valeur représente sa partie imaginaire. Ces valeurs représentent la position du nombre complexe dans le système de coordonnées cartésien à deux dimensions.

  • En appelant la méthode Complex.FromPolarCoordinates statique (Shared en Visual Basic) pour créer un nombre complexe à partir de ses coordonnées polaires.

  • En assignant une valeur Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single ou Double à un objet Complex. La valeur devient la partie réelle du nombre complexe, et sa partie imaginaire est égale à 0.

  • En castant (en C#) ou convertissant (en Visual Basic) une valeur Decimal ou BigInteger en un objet Complex. La valeur devient la partie réelle du nombre complexe, et sa partie imaginaire est égale à 0.

  • En assignant le nombre complexe retourné par une méthode ou un opérateur à un objet Complex. Par exemple, Complex.Add est une méthode statique qui retourne un nombre complexe qui est la somme de deux nombres complexes, et l'opérateur Complex.Addition ajoute deux nombres complexes et retourne le résultat.

L'exemple suivant montre chacune de ces cinq façons d'assigner une valeur à un nombre complexe.


using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      // Create a complex number by calling its class constructor.
      Complex c1 = new Complex(12, 6);
      Console.WriteLine(c1);

      // Assign a Double to a complex number.
      Complex c2 = 3.14;
      Console.WriteLine(c2);

      // Cast a Decimal to a complex number.
      Complex c3 = (Complex) 12.3m;
      Console.WriteLine(c3);

      // Assign the return value of a method to a Complex variable.
      Complex c4 = Complex.Pow(Complex.One, -1);
      Console.WriteLine(c4);

      // Assign the value returned by an operator to a Complex variable.
      Complex c5 = Complex.One + Complex.One;
      Console.WriteLine(c5);

      // Instantiate a complex number from its polar coordinates.
      Complex c6 = Complex.FromPolarCoordinates(10, .524);
      Console.WriteLine(c6);
   }
}
// The example displays the following output:
//       (12, 6)
//       (3.14, 0)
//       (12.3, 0)
//       (1, 0)
//       (2, 0)
//       (8.65824721882145, 5.00347430269914)


Opérations avec des nombres complexes

La structure Complex dans le .NET Framework inclut des membres qui fournissent les fonctionnalités suivantes :

  • Méthodes pour comparer deux nombres complexes et déterminer s'ils sont égaux.

  • Opérateurs pour exécuter des opérations arithmétiques sur les nombres complexes. Les opérateurs Complex vous permettent d'effectuer des additions, soustractions, multiplications, divisions et opérations NON unaires avec des nombres complexes.

  • Méthodes pour exécuter d'autres opérations numériques sur les nombres complexes. En plus de quatre opérations arithmétiques fondamentales, vous pouvez élever un nombre complexe à une puissance spécifiée, rechercher la racine carrée d'un nombre complexe et obtenir la valeur absolue d'un nombre complexe.

  • Méthodes pour exécuter des opérations trigonométriques sur les nombres complexes. Par exemple, vous pouvez calculer la tangente d'un angle représentée par un nombre complexe.

Précision et nombres complexes

Les parties imaginaire et réelle d'un nombre complexe sont représentées par deux valeurs à virgule flottante double précision. Cela signifie que les valeurs Complex, comme les valeurs à virgule flottante double précision, peuvent perdre la précision à la suite d'opérations numériques. Cela signifie que les comparaisons strictes pour l'égalité de deux valeurs Complex peuvent échouer, même si la différence entre les deux valeurs est due à une perte de précision. Pour plus d'informations, consultez Double.

Par exemple, l'exécution de l'élévation à la puissance du logarithme d'un nombre doit retourner le nombre d'origine. Toutefois, la perte de précision de valeurs à virgule flottante peut provoquer dans certains cas de légères différences entre les deux valeurs, comme le montre l'exemple suivant.


Complex value = new Complex(Double.MinValue/2, Double.MinValue/2);
Complex value2 = Complex.Exp(Complex.Log(value));
Console.WriteLine("{0} \n{1} \nEqual: {2}", value, value2, 
                                            value == value2);
// The example displays the following output:
//    (-8.98846567431158E+307, -8.98846567431158E+307)
//    (-8.98846567431161E+307, -8.98846567431161E+307)
//    Equal: False


De la même façon, l'exemple suivant, qui calcule la racine carrée d'un nombre Complex, produit des résultats légèrement différents sur les versions 32 bits et IA64 du .NET Framework.


Complex minusOne = new Complex(-1, 0);
Console.WriteLine(Complex.Sqrt(minusOne));
// The example displays the following output:
//    (6.12303176911189E-17, 1) on 32-bit systems.
//    (6.12323399573677E-17,1) on IA64 systems.


Les nombres complexes, Infinity et NaN

Les parties imaginaire et réelle d'un nombre complexe sont représentées par les valeurs Double. En plus de s'étendre de Double.MinValue à Double.MaxValue, la partie réelle ou imaginaire d'un nombre complexe peut avoir la valeur Double.PositiveInfinity, Double.NegativeInfinity ou Double.NaN. Double.PositiveInfinity , Double.NegativeInfinity et Double.NaN propagent tous dans toutes les opérations arithmétiques ou trigonométriques.

Dans l'exemple suivant, la division par Zero produit un nombre complexe dont les parties réelles et imaginaires sont toutes deux Double.NaN. Par conséquent, l'exécution de la multiplication avec cette valeur produit également un nombre complexe dont les parties réelles et imaginaires sont Double.NaN. De la même façon, l'exécution d'une multiplication qui dépasse la plage du type Double produit un nombre complexe dont la partie réelle est Double.NaN et la partie imaginaire Double.PositiveInfinity. Par la suite, le fait d'effectuer une division avec ce nombre complexe retourne un nombre complexe dont la partie réelle est Double.NaN et dont la partie imaginaire est Double.PositiveInfinity.


using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      Complex c1 = new Complex(Double.MaxValue / 2, Double.MaxValue /2);

      Complex c2 = c1 / Complex.Zero;
      Console.WriteLine(c2.ToString());
      c2 = c2 * new Complex(1.5, 1.5);
      Console.WriteLine(c2.ToString());
      Console.WriteLine();

      Complex c3 = c1 * new Complex(2.5, 3.5);
      Console.WriteLine(c3.ToString());
      c3 = c3 + new Complex(Double.MinValue / 2, Double.MaxValue / 2); 
      Console.WriteLine(c3);
   }
}
// The example displays the following output:
//       (NaN, NaN)
//       (NaN, NaN)
//       (NaN, Infinity)
//       (NaN, Infinity)


Les opérations mathématiques avec des nombres complexes qui ne sont pas valides ou qui dépassent la plage du type de données Double ne lèvent pas d'exception. À la place, elles retournent un Double.PositiveInfinity, Double.NegativeInfinity ou Double.NaN sous les conditions suivantes :

Notez que cela s'applique à tous les calculs intermédiaires exécutés par une méthode. Par exemple, la multiplication de new Complex(9e308, 9e308) and new Complex(2.5, 3.5) utilise la formule (ac - bd) + (ad + bc)i. Le calcul du vrai composant qui résulte de la multiplication évalue l'expression 9e308 * 2.5 - 9e308 * 3.5. Chaque multiplication intermédiaire dans cette expression retourne Double.PositiveInfinity, et la tentative de soustraction Double.PositiveInfinity de Double.PositiveInfinity retourne Double.NaN.

Mise en forme d'un nombre complexe

Par défaut, la représentation sous forme de chaîne d'un nombre complexe prend la forme (réel, imaginaire), où réel et imaginaire sont les représentations sous forme de chaînes des valeurs Double qui forment les composants réels et imaginaires du nombre complexe. Certaines surcharges de la méthode ToString permettent à la personnalisation des représentations sous forme de chaîne de ces valeurs Double de refléter les conventions de mise en forme d'une culture particulière ou de s'afficher dans un format particulier défini par une chaîne de format numérique standard ou personnalisée. (Pour plus d'informations, consultez Chaînes de format numériques standard et Chaînes de format numériques personnalisées).

L'une des façons les plus courantes d'exprimer la représentation sous forme de chaîne d'un nombre complexe prend la forme a + bi, où a est le composant réel du nombre complexe et b le composant imaginaire du nombre complexe. En génie électrique, un nombre complexe est le plus souvent exprimé sous la forme a + bj. Vous pouvez retourner la représentation sous forme de chaîne d'un nombre complexe dans l'une ou l'autre de ces formes. Pour cela, définissez un fournisseur de format personnalisé en implémentant les interfaces ICustomFormatter et IFormatProvider, puis appelez la méthode String.Format(IFormatProvider, String, Object[]).

L'exemple suivant définit une classe ComplexFormatter qui représente un nombre complexe comme une chaîne sous la forme a + bi ou a + bj.


using System;
using System.Numerics;

public class ComplexFormatter :IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType) 
   {   
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }

   public string Format(string format, object arg, 
                        IFormatProvider provider)
   {
      if (arg is Complex)
      {
         Complex c1 = (Complex) arg; 
         // Check if the format string has a precision specifier.
         int precision;
         string fmtString = String.Empty;
         if (format.Length > 1) {
            try {
               precision = Int32.Parse(format.Substring(1));
            }
            catch (FormatException) {
               precision = 0;
            }
            fmtString = "N" + precision.ToString();
         }
         if (format.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase))
            return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "i";
         else if (format.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase))
            return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "j";
         else
            return c1.ToString(format, provider);
      }
      else
      {
         if (arg is IFormattable)
            return ((IFormattable) arg).ToString(format, provider);
         else if (arg != null) 
            return arg.ToString();
         else
            return String.Empty;
      }                        
   }
}


L'exemple suivant utilise ensuite ce formateur personnalisé pour afficher la représentation sous forme de chaîne d'un nombre complexe.


public class Example
{
   public static void Main()
   {
      Complex c1 = new Complex(12.1, 15.4);
      Console.WriteLine("Formatting with ToString():       " + 
                        c1.ToString());
      Console.WriteLine("Formatting with ToString(format): " + 
                        c1.ToString("N2"));
      Console.WriteLine("Custom formatting with I0:        " + 
                        String.Format(new ComplexFormatter(), "{0:I0}", c1));
      Console.WriteLine("Custom formatting with J3:        " + 
                        String.Format(new ComplexFormatter(), "{0:J3}", c1));
   }
}
// The example displays the following output:
//    Formatting with ToString():       (12.1, 15.4)
//    Formatting with ToString(format): (12.10, 15.40)
//    Custom formatting with I0:        12 + 15i
//    Custom formatting with J3:        12.100 + 15.400j


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4

.NET Framework Client Profile

Pris en charge dans : 4

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft