Cette page vous a-t-elle été utile ?
Votre avis sur ce contenu est important. N'hésitez pas à nous faire part de vos commentaires.
Vous avez d'autres commentaires ?
1500 caractères restants
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

String, constructeur

Initialise une nouvelle instance de la classe String.

Ce membre est surchargé. Pour obtenir des informations complètes sur ce membre, y compris sa syntaxe, son utilisation et des exemples s'y rapportant, cliquez sur un nom dans la liste de surcharge.

  Nom Description
Méthode publique String(Char*) Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau de caractères Unicode.
Méthode publique String(Char[]) Initialise une nouvelle instance de la classe String à la valeur indiquée par un tableau de caractères Unicode.
Méthode publique String(SByte*) Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur vers un tableau d'entiers signés 8 bits.
Méthode publique String(Char, Int32) Initialise une nouvelle instance de la classe String à la valeur indiquée par un caractère Unicode spécifié et répété un certain nombre de fois.
Méthode publique String(Char*, Int32, Int32) Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau de caractères Unicode, un point de départ pour le caractère dans ce tableau et une longueur.
Méthode publique String(Char[], Int32, Int32) Initialise une nouvelle instance de la classe String à la valeur indiquée par un tableau de caractères Unicode, un point de départ pour le caractère dans ce tableau et une longueur.
Méthode publique String(SByte*, Int32, Int32) Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau d'entiers signés 8 bits, une position de départ dans ce tableau et une longueur.
Méthode publique String(SByte*, Int32, Int32, Encoding) Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau d'entiers signés 8 bits, une position de départ dans ce tableau, une longueur et un objet Encoding.
Début

Dans cette section :

Syntaxe surchargée de constructeur
Paramètres
Exceptions
Quelle méthode dois-je appeler?
Création de chaînes
Gestion des chaînes répétitives
Exemples d'instanciation de chaînes :
       Utilisation de l'assignation de chaîne
       Utilisation d'un tableau de caractères
       Utiliser une partie d'un tableau de caractères et répéter un caractère unique
       Utiliser un pointeur vers un tableau de caractères
       Utiliser un pointeur et une plage d'un tableau
       Utiliser un pointeur vers un tableau d'octets signés
Informations de version

Syntaxe surchargée de constructeur

Les constructeurs de chaînes se scindent en deux catégories : celles sans paramètres de pointeur, et ceux ayant des paramètres de pointeur. Les constructeurs qui utilisent des pointeurs ne sont pas conformes à CLS. En outre, Visual Basic ne prend pas en charge l'utilisation des pointeurs, et C# requiert un code qui utilise des pointeurs pour s'exécuter dans un contexte unsafe. Pour plus d'informations, consultez unsafe keyword dans la documentation de référence Visual C++.

Pour une assistance supplémentaire sur le choix d'une surcharge, consultez Quelle méthode dois-je appeler?

String(Char[] value )

Initialise la nouvelle instance à la valeur indiquée par un tableau de caractères Unicode. Ce constructeur copie des caractères Unicode (exemple).

String(Char[] value , Int32 startIndex , Int32 length )

Initialise la nouvelle instance à la valeur indiquée par un tableau de caractères Unicode, un point de départ pour le caractère dans ce tableau et une longueur (example).

String(Char c , Int32 count )

Initialise la nouvelle instance à la valeur indiquée par un caractère Unicode spécifié et répété un certain nombre de fois (exemple).

String(char* value )

(Not CLS-compliant)Initialise la nouvelle instance à la valeur indiquée par un pointeur spécifié vers un tableau de caractères Unicode (example).

Permission: SecurityCriticalAttribute, exige une confiance totale pour l'appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement de confiance ou transparent.

String(char* value , Int32 startIndex , Int32 length )

(Not CLS-compliant) initialise une nouvelle instance à la valeur indiquée par un pointeur spécifié vers un tableau de caractères Unicode, un point de départ pour le caractère dans ce tableau et une longueur. Le constructeur copie les caractères Unicode depuis value en commençant à l'index startIndex et se terminant à l'index startIndex + length – 1 (exemple).

Permission: SecurityCriticalAttribute, exige une confiance totale pour l'appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement de confiance ou transparent.

String(SByte* value )

(Not CLS-compliant) initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau d'entiers signés 8 bits. Le tableau est supposé représenter une chaîne encodée à la page de codes système actuelle (autrement dit, l'encodage spécifié par Encoding.Default. Le constructeur traite les caractères de value, à partir de l'emplacement spécifié par le pointeur et jusqu'à ce qu'un caractère null (0x0000) soit atteint (example).

Permission: SecurityCriticalAttribute, exige une confiance totale pour l'appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement de confiance ou transparent.

String(SByte* value , Int32 startIndex , Int32 length )

(Not CLS-compliant) initialise la nouvelle instance à la valeur indiquée par un pointeur spécifié vers un tableau d'entiers signés 8 bits, une position de départ dans ce tableau et une longueur. Le constructeur traite les caractères de valeur en commençant par startIndex et en terminant à startIndex + length – 1 (exemple).

Permission: SecurityCriticalAttribute, exige une confiance totale pour l'appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement de confiance ou transparent.

String(SByte* value , Int32 startIndex , Int32 length , Encoding enc )

(Not CLS-compliant) initialise une nouvelle instance à la valeur indiquée par un pointeur spécifié vers un tableau d'entiers signés 8 bits, une position de départ dans ce tableau, une longueur et un objet Encoding.

Permission: SecurityCriticalAttribute, exige une confiance totale pour l'appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement de confiance ou transparent.

Paramètres

Voici une liste complète des paramètres utilisés par les constructeurs String qui n'incluent pas de paramètre pointeur. Pour les paramètres utilisés par chaque surcharge, consultez la syntaxe de surcharge ci-dessus.

Paramètre

Type

Description

value

Char []

Tableau de caractères Unicode.

c

Char

Caractère Unicode.

startIndex

Int32

La position de départ dans value du premier caractère de la nouvelle chaîne.

Valeur par défaut: 0.

length

Int32

Nombre de caractères dans value à inclure dans la sous-chaîne retournée.

Valeur par défaut: Array.Length

count

Int32

Le nombre de fois où le caractère c est répété dans la nouvelle chaîne. Si count est zéro, la valeur du nouvel objet est String.Empty.

Voici une liste complète des paramètres utilisés par les constructeurs String qui incluent un paramètre pointeur. Pour les paramètres utilisés par chaque surcharge, consultez la syntaxe de surcharge ci-dessus.

Paramètre

Type

Description

value

Char *

ou

SByte *

Un pointeur vers un tableau de caractères Unicode se terminant par null ou un tableau d'entier signé 8 bits. Si value est null ou un tableau vide, la nouvelle chaîne est String.Empty.

startIndex

Int32

Index de l'élément du tableau qui définit le premier caractère dans la nouvelle chaîne.

Valeur par défaut: 0.

length

Int32

Le nombre d'éléments de tableau à utiliser pour créer la nouvelle chaîne. Si la longueur est zéro, le constructeur crée une chaîne dont la valeur est String.Empty.

Valeur par défaut: Array.Length

enc

Encoding

Un objet qui spécifie la façon le tableau value est encodé.

Valeur par défaut : Encoding.Default, ou la page de codes ANSI actuelle du système

Exceptions

Voici une liste d'exceptions levées par les constructeurs qui ne concernent pas les paramètres du pointeur.

Exception

Condition

Levée par

ArgumentNullException

value a la valeur null.

String(Char[], Int32, Int32)

ArgumentOutOfRangeException

startIndex, length ou count est inférieur à zéro.

ou

La somme de startIndex et length est supérieure au nombre d'éléments figurant dans value.

ou

count est inférieur à zéro.

String(Char, Int32)

String(Char[], Int32, Int32)

Voici une liste d'exceptions levées par les constructeurs qui comprennent les paramètres de pointeur.

Exception

Condition

Levée par

ArgumentException

value spécifie un tableau contenant un caractère Unicode valide.

ou

value ou value + startIndex spécifie une adresse inférieure à 64K.

ou

Une nouvelle instance String ne peut pas être initialisée du tableau d'octets value car value n'utilise pas l'encodage par défaut de page de codes.

Tous les constructeurs avec des pointeurs.

ArgumentNullException

value a la valeur null.

String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

ArgumentOutOfRangeException

Le processus actuel n'a pas l'accès en lecture à tous les caractères identifiés par l'adresse.

ou

startIndex ou length est inférieur à zéro, value + startIndex entraînent un dépassement de capacité de pointeur ou le processus actuel n'a pas l'accès en lecture à tous les caractères identifiés par l'adresse.

ou

La longueur de la nouvelle chaîne est trop grande pour être allouée.

Tous les constructeurs avec des pointeurs.

AccessViolationException

value ou value + startIndex + length – 1, spécifie une adresse non valide.

String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Quelle méthode dois-je appeler?

Vers

Appeler ou utiliser

Créer une chaîne.

Assignation d'un littéral de chaîne ou d'une chaîne existante (exemple)

Créer une chaîne à partir d'un tableau de caractères entier.

String(Char[]) (exemple)

Créer une chaîne à partir d'une partie d'une chaîne dans un tableau de caractères.

String(Char[], Int32, Int32) (exemple)

Créer une chaîne qui répète le même caractère plusieurs fois.

String(Char, Int32) (exemple)

Créer une chaîne à partir d'un pointeur vers un Unicode ou un ensemble de caractères larges.

String(Char*)

Créer une chaîne d'une partie d'Unicode ou d'un jeu de caractères larges à l'aide du pointeur.

String(Char*, Int32, Int32)

Créer une chaîne de tableau C++ char.

String(SByte*) , String(SByte*, Int32, Int32)

ou

String(SByte*, Int32, Int32, Encoding)

Créer une chaîne de caractères ASCII.

ASCIIEncoding.GetString

Création de chaînes

La technique la plus souvent utilisée pour créer des chaînes par programme est une simple assignation, comme illustré dans cet exemple. La classe String inclut également quatre types de surcharges de constructeur qui vous permettent de créer des chaînes à partir des valeurs suivantes :

  • A partir d'un tableau de caractères (un tableau de caractères d'UTF-16-encoded). Vous pouvez créer un objet String à partir des caractères dans le tableau entier ou d'une partie. Le constructeur String(Char[]) copie tous les caractères dans le tableau à la nouvelle chaîne. Le constructeur String(Char[], Int32, Int32) copie les caractères à partir de l'index startIndex jusqu'à l'index startIndex + length – 1 à la nouvelle chaîne. Si length est zéro, la nouvelle chaîne est String.Empty.

    Si votre code instancie de façon récurrente les chaînes qui ont la même valeur, vous pouvez améliorer les performances de l'application en employant d'autres façons de créer des chaînes. Pour plus d'informations, consultez Gestion des chaînes répétitives.

  • D'un caractère unique qui est dupliqué zéro, une, ou plusieurs fois, en utilisant le constructeur String(Char, Int32). Si count est zéro, la valeur de la nouvelle chaîne est String.Empty.

  • D'un pointeur vers un tableau de caractères se terminant par null, en utilisant String(Char*) ou le constructeur String(Char*, Int32, Int32). Le tableau entier ou une plage spécifiée peuvent être utilisés pour initialiser la chaîne. Le constructeur copie une séquence de caractères Unicode en commençant par le pointeur spécifié ou par le pointeur spécifié plus startIndex et en continuant à la fin du tableau ou des caractères length. Si value est un pointeur Null ou length vaut zéro, le constructeur crée une chaîne dont la valeur est String.Empty. Si l'opération de copie continue jusqu'à la fin du tableau et s'il ne se termine pas par null, le comportement du constructeur dépend du système. Cette condition peut provoquer une violation d'accès.

    Si le tableau contient des caractères Null incorporés (U+0000 ou « \ 0 ") et la surcharge String(Char*, Int32, Int32) est appelée, l'instance de chaîne contient des caractères length notamment les caractères nulls. L'exemple suivant illustre ce qui se produit lorsqu'un pointeur vers un tableau de 10 éléments qui inclut deux caractères Null est passé à la méthode String(Char*, Int32, Int32). Parce que l'adresse est le début du tableau et que tous les éléments du tableau doivent être ajoutés à la chaîne, le constructeur instancie une chaîne avec dix caractères, y compris deux caractères nulls. En revanche, si le même tableau est passé au constructeur String(Char*), le résultat est une chaîne de quatre caractères qui n'inclut pas le premier caractère null.

    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          char[] chars = { 'a', 'b', 'c', 'd', '\0', 'A', 'B', 'C', 'D', '\0' };
          string s = null;
    
          fixed(char* chPtr = chars) {
             s = new string(chPtr, 0, chars.Length);            
          } 
    
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();
    
          fixed(char* chPtr = chars) {
             s = new string(chPtr);         
          }
    
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    
    
    

    Le tableau doit contenir des caractères de contrôle Unicode. En C++, cela signifie que le tableau de caractères doit être défini comme un type managé Char[] ou le type non managé wchar_t[].

    Si la surcharge String(Char*) est appelée et le tableau ne se termine pas par null, ou si la surcharge String(Char*, Int32, Int32) est appelée et startIndex + length -1 inclut une plage en dehors de la mémoire allouée pour la séquence de caractères, le comportement du constructeur est dépendant du système, et une violation d'accès peut se produire. En outre, sur le processeur Intel Itanium, les appels au constructeur String(Char*, Int32, Int32) peuvent lever une exception DataMisalignedException. Si cela se produit, appelez String(Char[], Int32, Int32).

  • A partir d'un pointeur vers un tableau d'octets signés. Le tableau entier ou une plage spécifiée peuvent être utilisés pour initialiser la chaîne. La séquence d'octets peut être interprétée en utilisant l'encodage par défaut de page de codes, ou un encodage peut être spécifié dans l'appel de constructeur. Si le constructeur essaie d'instancier une chaîne d'un tableau entier qui ne se termine pas par null, ou si la plage du tableau qui commence à value + startIndex et qui se termine à value + startIndex + length -1 est en dehors de la mémoire allouée au tableau, le comportement de ce constructeur est dépendant du système, et une violation d'accès peut se produire.

    Les trois constructeurs qui incluent un tableau d'octets signés comme paramètre sont conçus principalement pour convertir le tableau C++ char en une chaîne, comme illustré dans cet exemple :

    
    using namespace System;
    
    void main()
    {
          char chars[] = { 'a', 'b', 'c', 'd', '\x00' };
    
          char* charPtr = chars;
          String^ value = gcnew String(charPtr);
    
          Console::WriteLine(value);
    }
    // The example displays the following output:
    //      abcd
    
    
    

    Si le tableau contient un caractère Null ('\0') ou des octets dont la valeur est 0 et si la surcharge String(SByte*, Int32, Int32) est appelée, l'instance de chaîne contient des caractères length notamment les caractères nulls. L'exemple suivant illustre ce qui se produit lorsqu'un pointeur vers un tableau de 10 éléments qui inclut deux caractères Null est passé à la méthode String(SByte*, Int32, Int32). Parce que l'adresse est le début du tableau et que tous les éléments du tableau doivent être ajoutés à la chaîne, le constructeur instancie une chaîne avec dix caractères, y compris deux caractères nulls. En revanche, si le même tableau est passé au constructeur String(SByte*), le résultat est une chaîne de quatre caractères qui n'inclut pas le premier caractère null.

    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          sbyte[] bytes = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 0x44, 0x00 };
    
          string s = null;
          fixed (sbyte* bytePtr = bytes) {
             s = new string(bytePtr, 0, bytes.Length);
          }
    
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
    
          Console.WriteLine();    
    
          fixed(sbyte* bytePtr = bytes) {
             s = new string(bytePtr);         
          }
    
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();    
    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    
    
    

    Parce que les constructeurs String(SByte*) et String(SByte*, Int32, Int32) interprètent value via la page de codes ANSI par défaut, appeler ces constructeurs avec les tableaux d'octets identiques peut créer des chaînes qui ont différentes valeurs sur les différents systèmes.

Gestion des chaînes répétitives

Les applications qui analysent ou décodent des flux de texte utilisent souvent le constructeur String(Char[], Int32, Int32) ou la méthode StringBuilder.Append(Char[], Int32, Int32) pour convertir les séquences de caractères en une chaîne. Créer de façon récurrente de nouvelles chaînes avec la même valeur au lieu de créer et de réutiliser une chaîne gaspille la mémoire. Si vous êtes susceptible de créer la même valeur de chaîne à plusieurs reprises en appelant le constructeur String(Char[], Int32, Int32), même si vous ne connaissez pas à l'avance ces valeurs de chaîne identiques, vous pouvez utiliser une table de correspondance à la place.

Par exemple, supposez que vous lisez et analysez le flux de caractères d'un fichier contenant des attributs et des balises XML. Lorsque vous analysez le flux, vous rencontrez à plusieurs reprises certains jetons (c'est-à-dire des séquences de caractères qui ont une signification symbolique). Les jetons égaux aux chaînes "0", "1", "true" et "false" sont susceptibles d'être fréquemment présents dans un flux XML.

Au lieu de convertir chaque jeton dans une nouvelle chaîne, vous pouvez créer un objet System.Xml.NameTable pour contenir les chaînes courantes. L'objet NameTable améliore les performances car il récupère les chaînes stockées sans allouer de mémoire temporaire. Lorsque vous rencontrez un jeton, utilisez la méthode NameTable.Get(Char[], Int32, Int32) pour récupérer le jeton de la table. Si le jeton existe, la méthode retourne la chaîne correspondante. Si le jeton n'existe pas, utilisez la méthode NameTable.Add(Char[], Int32, Int32) pour insérer le jeton dans la table et pour obtenir la chaîne correspondante.

Exemple 1 : Utilisation de l'assignation de chaîne

L'exemple suivant crée une nouvelle chaîne en lui assignant un littéral de chaîne. Il crée une deuxième chaîne en lui assignant la valeur de la première chaîne. Ce sont les deux méthodes les plus courantes pour instancier un nouvel objet String.


using System;

public class Example
{
   public static void Main()
   {
      String value1 = "This is a string.";
      String value2 = value1;
      Console.WriteLine(value1);
      Console.WriteLine(value2);
   }
}
// The example displays the following output:
//    This is a string.
//    This is a string.


Exemple 2 : Utilisation d'un tableau de caractères

L'exemple suivant montre comment créer un nouveau objet String à partir d'un tableau de caractères.


// Unicode Mathematical operators
char [] charArr1 = {'\u2200','\u2202','\u200F','\u2205'};
String szMathSymbols = new String(charArr1);

// Unicode Letterlike Symbols
char [] charArr2 = {'\u2111','\u2118','\u2122','\u2126'};
String szLetterLike = new String (charArr2);

// Compare Strings - the result is false
Console.WriteLine("The Strings are equal? " +
    (String.Compare(szMathSymbols, szLetterLike)==0?"true":"false") );


Exemple 3 : Utiliser une partie d'un tableau de caractères et répéter un caractère unique

L'exemple suivant montre comment créer un objet String à partir d'une partie d'un tableau de caractères, et comment créer un objet String qui contient plusieurs occurrences d'un caractère unique.


// Create a Unicode String with 5 Greek Alpha characters
String szGreekAlpha = new String('\u0391',5);
// Create a Unicode String with a Greek Omega character
String szGreekOmega = new String(new char [] {'\u03A9','\u03A9','\u03A9'},2,1);

String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone());

// Examine the result
Console.WriteLine(szGreekLetters);

// The first index of Alpha
int ialpha = szGreekLetters.IndexOf('\u0391');
// The last index of Omega
int iomega = szGreekLetters.LastIndexOf('\u03A9');

Console.WriteLine("The Greek letter Alpha first appears at index " + ialpha +
    " and Omega last appears at index " + iomega + " in this String.");


Exemple 4 : Utilisation d'un pointeur vers un tableau de caractères

L'exemple suivant montre comment créer un nouvel objet String à partir d'un pointeur vers un tableau de caractères. L'exemple C# doit être compilé en utilisant le commutateur de compilation en /unsafe.


using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      string value;

      fixed (char* charPtr = characters) {
         value = new String(charPtr);
      }                            
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//        Hello world!


Exemple 5 : Instanciation d'une chaîne à partir d'un pointeur et d'une plage d'un tableau

L'exemple suivant décrit les éléments d'un tableau de caractères pour un point ou un point d'exclamation. Si l'un deux est trouvé, il instancie une chaîne de caractères du tableau qui précèdent le symbole de ponctuation. Sinon, il instancie une chaîne avec le contenu entier du tableau. L'exemple C# doit être compilé en utilisant le commutateur de compilation en /unsafe.


using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      String value;

      fixed (char* charPtr = characters) {
         int length = 0;
         Char* iterator = charPtr;

         while (*iterator != '\x0000')
         {
            if (*iterator == '!' || *iterator == '.')
               break;
            iterator++;
            length++;
         }
         value = new String(charPtr, 0, length);
      }
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//      Hello World


Exemple 6 : Instanciation d'une chaîne d'un pointeur vers un tableau d'octets signés

L'exemple simple suivant montre comment vous pouvez créer une instance de la classe String avec le constructeur String(SByte*).


unsafe
{
    // Null terminated ASCII characters in an sbyte array
    String szAsciiUpper = null;
    sbyte[] sbArr1 = new sbyte[] { 0x41, 0x42, 0x43, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiUpper = sbArr1)
    {
        szAsciiUpper = new String(pAsciiUpper);
    }
    String szAsciiLower = null;
    sbyte[] sbArr2 = { 0x61, 0x62, 0x63, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiLower = sbArr2)
    {
        szAsciiLower = new String(pAsciiLower, 0, sbArr2.Length);
    }
    // Prints "ABC abc"
    Console.WriteLine(szAsciiUpper + " " + szAsciiLower);

    // Compare Strings - the result is true
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper())==0?"true":"false") );

    // This is the effective equivalent of another Compare method, which ignores case
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper, szAsciiLower, true)==0?"true":"false") );
}


Informations de version

.NET Framework

Toutes les surcharges sont prises en charge dans: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Toutes les surcharges sont prises en charge dans: 4, 3.5 SP1

Bibliothèque de classes portable

Toutes les surcharges sans paramètre SByte* sont prises en charge

.NET pour les applications du Windows Store

Toutes les surcharges sans paramètre SByte* sont prises en charge dans : Windows 8

Ajouts de la communauté

AJOUTER
Afficher:
© 2015 Microsoft