String.Concat Méthode

Définition

Concatène une ou plusieurs instances de String, ou les représentations String des valeurs d’une ou plusieurs instances de Object.

Surcharges

Concat(String, String, String, String)

Concatène quatre instances spécifiées de String.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène les représentations sous forme de chaîne de quatre étendues de caractères en lecture seule spécifiées.

Concat(Object, Object, Object, Object)

Concatène les représentations sous forme de chaîne de quatre objets spécifiés et de tous les objets spécifiés dans une liste de paramètres de longueur variable facultative.

Concat(String, String, String)

Concatène trois instances spécifiées de String.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène les représentations sous forme de chaîne de trois étendues de caractères en lecture seule spécifiées.

Concat(Object, Object, Object)

Concatène les représentations sous forme de chaîne de trois objets spécifiés.

Concat(String, String)

Concatène deux instances spécifiées de String.

Concat(Object)

Crée la représentation sous forme de chaîne d’un objet spécifié.

Concat(Object, Object)

Concatène les représentations sous forme de chaîne de deux objets spécifiés.

Concat(String[])

Concatène les éléments d’un tableau de String spécifié.

Concat(ReadOnlySpan<String>)

Concatène les éléments d’une étendue spécifiée de String.

Concat(ReadOnlySpan<Object>)

Concatène les représentations sous forme de chaîne des éléments dans une étendue d’objets spécifiée.

Concat(Object[])

Concatène les représentations sous forme de chaîne des éléments d’un tableau de Object spécifié.

Concat(IEnumerable<String>)

Concatène les membres d’une collection IEnumerable<T> construite de type String.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène les représentations sous forme de chaîne de deux étendues de caractères en lecture seule spécifiées.

Concat<T>(IEnumerable<T>)

Concatène les membres d’une implémentation IEnumerable<T>.

Remarques

Note

Vous pouvez également utiliser l’opérateur de concaténation de chaîne de votre langage, tel que + en C# et F#, ou & et + en Visual Basic, pour concaténer des chaînes. Les deux compilateurs traduisent l’opérateur de concaténation en un appel à l’une des surcharges de String.Concat.

Concat(String, String, String, String)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène quatre instances spécifiées de String.

public:
 static System::String ^ Concat(System::String ^ str0, System::String ^ str1, System::String ^ str2, System::String ^ str3);
public static string Concat (string str0, string str1, string str2, string str3);
public static string Concat (string? str0, string? str1, string? str2, string? str3);
static member Concat : string * string * string * string -> string
Public Shared Function Concat (str0 As String, str1 As String, str2 As String, str3 As String) As String

Paramètres

str0
String

Première chaîne à concaténer.

str1
String

Deuxième chaîne à concaténer.

str2
String

Troisième chaîne à concaténer.

str3
String

Quatrième chaîne à concaténer.

Retours

Concaténation de str0, str1, str2et str3.

Exemples

L’exemple suivant définit un tableau de mots à quatre lettres et stocke leurs lettres individuelles dans un tableau de chaînes afin de les brouiller. Il appelle ensuite la méthode Concat(String, String, String, String) pour réassembler les mots brouillés.

using System;
using System.Collections;

public class Example
{
   public static void Main()
   {
      const int WORD_SIZE = 4;
      
      // Define some 4-letter words to be scrambled.
      string[] words = { "home", "food", "game", "rest" };
      // Define two arrays equal to the number of letters in each word.
      double[] keys = new double[WORD_SIZE];
      string[] letters = new string[WORD_SIZE];
      // Initialize the random number generator.
      Random rnd = new Random();
      
      // Scramble each word.
      foreach (string word in words)
      {
         for (int ctr = 0; ctr < word.Length; ctr++)
         {
            // Populate the array of keys with random numbers.
            keys[ctr] = rnd.NextDouble();
            // Assign a letter to the array of letters.
            letters[ctr] = word[ctr].ToString();
         }   
         // Sort the array. 
         Array.Sort(keys, letters, 0, WORD_SIZE, Comparer.Default);      
         // Display the scrambled word.
         string scrambledWord = String.Concat(letters[0], letters[1], 
                                              letters[2], letters[3]);
         Console.WriteLine("{0} --> {1}", word, scrambledWord);
      } 
   }
}
// The example displays output like the following:
//       home --> mheo
//       food --> oodf
//       game --> aemg
//       rest --> trse
open System
open System.Collections

let WORD_SIZE = 4
      
// Define some 4-letter words to be scrambled.
let words = [| "home"; "food"; "game"; "rest" |]
// Define two arrays equal to the number of letters in each word.
let keys = Array.zeroCreate<float> WORD_SIZE
let letters = Array.zeroCreate<string> WORD_SIZE
// Initialize the random number generator.
let rnd = Random()

// Scramble each word.
for word in words do
    for i = 0 to word.Length - 1 do
        // Populate the array of keys with random numbers.
        keys[i] <- rnd.NextDouble()
        // Assign a letter to the array of letters.
        letters[i] <- string word[i]
    // Sort the array. 
    Array.Sort(keys, letters, 0, WORD_SIZE, Comparer.Default)      
    // Display the scrambled word.
    let scrambledWord = String.Concat(letters[0], letters[1], letters[2], letters[3])
    printfn $"{word} --> {scrambledWord}"
// The example displays output like the following:
//       home --> mheo
//       food --> oodf
//       game --> aemg
//       rest --> trse
Imports System.Collections

Module Example
   Public Sub Main()
      Const WORD_SIZE As Integer = 4
      
      ' Define some 4-letter words to be scrambled.
      Dim words() As String = { "home", "food", "game", "rest" }
      ' Define two arrays equal to the number of letters in each word.
      Dim keys(WORD_SIZE) As Double
      Dim letters(WORD_SIZE) As String
      ' Initialize the random number generator.
      Dim rnd As New Random()
      
      ' Scramble each word.
      For Each word As String In words
         For ctr As Integer = 0 To word.Length - 1
            ' Populate the array of keys with random numbers.
            keys(ctr) = rnd.NextDouble()
            ' Assign a letter to the array of letters.
            letters(ctr) = word.Chars(ctr)
         Next   
         ' Sort the array. 
         Array.Sort(keys, letters, 0, WORD_SIZE, Comparer.Default)      
         ' Display the scrambled word.
         Dim scrambledWord As String = String.Concat(letters(0), letters(1), _
                                                     letters(2), letters(3))
         Console.WriteLine("{0} --> {1}", word, scrambledWord)
      Next 
   End Sub
End Module 
' The example displays output like the following:
'       home --> mheo
'       food --> oodf
'       game --> aemg
'       rest --> trse

Remarques

La méthode concatène str0, str1, str2et str3; il n’ajoute aucun délimiteur.

Voir aussi

S’applique à

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène les représentations sous forme de chaîne de quatre étendues de caractères en lecture seule spécifiées.

public:
 static System::String ^ Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3);
public static string Concat (ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3);
static member Concat : ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Concat (str0 As ReadOnlySpan(Of Char), str1 As ReadOnlySpan(Of Char), str2 As ReadOnlySpan(Of Char), str3 As ReadOnlySpan(Of Char)) As String

Paramètres

str0
ReadOnlySpan<Char>

Première étendue de caractères en lecture seule à concaténer.

str1
ReadOnlySpan<Char>

Deuxième étendue de caractères en lecture seule à concaténer.

str2
ReadOnlySpan<Char>

Troisième étendue de caractères en lecture seule à concaténer.

str3
ReadOnlySpan<Char>

Quatrième étendue de caractères en lecture seule à concaténer.

Retours

Représentations sous forme de chaîne concaténées des valeurs de str0, str1, str2 et str3.

S’applique à

Concat(Object, Object, Object, Object)

Important

Cette API n’est pas conforme CLS.

Concatène les représentations sous forme de chaîne de quatre objets spécifiés et de tous les objets spécifiés dans une liste de paramètres de longueur variable facultative.

public:
 static System::String ^ Concat(System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2, System::Object ^ arg3);
[System.CLSCompliant(false)]
public static string Concat (object arg0, object arg1, object arg2, object arg3);
[<System.CLSCompliant(false)>]
static member Concat : obj * obj * obj * obj -> string
Public Shared Function Concat (arg0 As Object, arg1 As Object, arg2 As Object, arg3 As Object) As String

Paramètres

arg0
Object

Premier objet à concaténer.

arg1
Object

Deuxième objet à concaténer.

arg2
Object

Troisième objet à concaténer.

arg3
Object

Quatrième objet à concaténer.

Retours

Représentation sous forme de chaîne concaténée de chaque valeur dans la liste des paramètres.

Attributs

Exemples

L’exemple suivant illustre l’utilisation de la méthode Concat(Object, Object, Object, Object) pour concaténer une liste de paramètres de variable. Dans ce cas, la méthode est appelée avec neuf paramètres.

using System;
using System.Collections;

public class Example
{
   public static void Main()
   {
      const int WORD_SIZE = 4;
      
      // Define some 4-letter words to be scrambled.
      string[] words = { "home", "food", "game", "rest" };
      // Define two arrays equal to the number of letters in each word.
      double[] keys = new double[WORD_SIZE];
      string[] letters = new string[WORD_SIZE];
      // Initialize the random number generator.
      Random rnd = new Random();
      
      // Scramble each word.
      foreach (string word in words)
      {
         for (int ctr = 0; ctr < word.Length; ctr++)
         {
            // Populate the array of keys with random numbers.
            keys[ctr] = rnd.NextDouble();
            // Assign a letter to the array of letters.
            letters[ctr] = word[ctr].ToString();
         }   
         // Sort the array. 
         Array.Sort(keys, letters, 0, WORD_SIZE, Comparer.Default);      
         // Display the scrambled word.
         string scrambledWord = String.Concat(letters[0], letters[1], 
                                              letters[2], letters[3]);
         Console.WriteLine("{0} --> {1}", word, scrambledWord);
      } 
   }
}
// The example displays output like the following:
//       home --> mheo
//       food --> oodf
//       game --> aemg
//       rest --> trse
open System
open System.Collections

let WORD_SIZE = 4
      
// Define some 4-letter words to be scrambled.
let words = [| "home"; "food"; "game"; "rest" |]
// Define two arrays equal to the number of letters in each word.
let keys = Array.zeroCreate<float> WORD_SIZE
let letters = Array.zeroCreate<string> WORD_SIZE
// Initialize the random number generator.
let rnd = Random()

// Scramble each word.
for word in words do
    for i = 0 to word.Length - 1 do
        // Populate the array of keys with random numbers.
        keys[i] <- rnd.NextDouble()
        // Assign a letter to the array of letters.
        letters[i] <- string word[i]
    // Sort the array. 
    Array.Sort(keys, letters, 0, WORD_SIZE, Comparer.Default)      
    // Display the scrambled word.
    let scrambledWord = String.Concat(letters[0], letters[1], letters[2], letters[3])
    printfn $"{word} --> {scrambledWord}"
// The example displays output like the following:
//       home --> mheo
//       food --> oodf
//       game --> aemg
//       rest --> trse
Imports System.Collections

Module Example
   Public Sub Main()
      Const WORD_SIZE As Integer = 4
      
      ' Define some 4-letter words to be scrambled.
      Dim words() As String = { "home", "food", "game", "rest" }
      ' Define two arrays equal to the number of letters in each word.
      Dim keys(WORD_SIZE) As Double
      Dim letters(WORD_SIZE) As String
      ' Initialize the random number generator.
      Dim rnd As New Random()
      
      ' Scramble each word.
      For Each word As String In words
         For ctr As Integer = 0 To word.Length - 1
            ' Populate the array of keys with random numbers.
            keys(ctr) = rnd.NextDouble()
            ' Assign a letter to the array of letters.
            letters(ctr) = word.Chars(ctr)
         Next   
         ' Sort the array. 
         Array.Sort(keys, letters, 0, WORD_SIZE, Comparer.Default)      
         ' Display the scrambled word.
         Dim scrambledWord As String = String.Concat(letters(0), letters(1), _
                                                     letters(2), letters(3))
         Console.WriteLine("{0} --> {1}", word, scrambledWord)
      Next 
   End Sub
End Module 
' The example displays output like the following:
'       home --> mheo
'       food --> oodf
'       game --> aemg
'       rest --> trse

Remarques

Note

Cette API n’est pas conforme CLS. L’alternative conforme CLS est String.Concat(Object[]). Les compilateurs C# et Visual Basic résolvent automatiquement un appel à cette méthode en tant qu’appel à String.Concat(Object[]).

La méthode concatène chaque objet dans la liste de paramètres en appelant sa méthode ToString sans paramètre ; il n’ajoute aucun délimiteur.

String.Empty est utilisé à la place d’un argument Null.

Note

Le dernier paramètre de la méthode Concat est une liste facultative délimitée par des virgules d’un ou plusieurs objets supplémentaires à concaténer.

Notes pour les appelants

Cette méthode est marquée avec le mot clé vararg, ce qui signifie qu’elle prend en charge un nombre variable de paramètres. La méthode peut être appelée à partir de Visual C++, mais elle ne peut pas être appelée à partir de C# ou de code Visual Basic. Les compilateurs C# et Visual Basic résolvent les appels à Concat(Object, Object, Object, Object) en tant qu’appels à Concat(Object[]).

S’applique à

Concat(String, String, String)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène trois instances spécifiées de String.

public:
 static System::String ^ Concat(System::String ^ str0, System::String ^ str1, System::String ^ str2);
public static string Concat (string str0, string str1, string str2);
public static string Concat (string? str0, string? str1, string? str2);
static member Concat : string * string * string -> string
Public Shared Function Concat (str0 As String, str1 As String, str2 As String) As String

Paramètres

str0
String

Première chaîne à concaténer.

str1
String

Deuxième chaîne à concaténer.

str2
String

Troisième chaîne à concaténer.

Retours

Concaténation de str0, str1et str2.

Exemples

L’exemple suivant utilise la méthode Concat pour concaténer trois chaînes et afficher le résultat.

using namespace System;

void main()
{
   String^ s1 = "We went to a bookstore, ";
   String^ s2 = "a movie, ";
   String^ s3 = "and a restaurant.";

   String^ s = String::Concat(s1, s2, s3);
   Console::WriteLine(s);
}
// The example displays the following output:
//      We went to a bookstore, a movie, and a restaurant.
using System;

public class Example
{
   public static void Main()
   {
      String s1 = "We went to a bookstore, ";
      String s2 = "a movie, ";
      String s3 = "and a restaurant.";

      var s = String.Concat(s1, s2, s3);
      Console.WriteLine(s);
   }
}
// The example displays the following output:
//      We went to a bookstore, a movie, and a restaurant.
open System

let s1 = "We went to a bookstore, "
let s2 = "a movie, "
let s3 = "and a restaurant."

String.Concat(s1, s2, s3)
|> printfn "%s"
// The example displays the following output:
//      We went to a bookstore, a movie, and a restaurant.
Public Module Example
   Public Sub Main()
      Dim s1 As String = "We went to a bookstore, "
      Dim s2 As String = "a movie, "
      Dim s3 As String = "and a restaurant."

      Dim s = String.Concat(s1, s2, s3)
      Console.WriteLine(s)
   End Sub
End Module
' The example displays the following output:
'      We went to a bookstore, a movie, and a restaurant.

Remarques

La méthode concatène str0, str1et str2; il n’ajoute aucun délimiteur.

Voir aussi

S’applique à

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène les représentations sous forme de chaîne de trois étendues de caractères en lecture seule spécifiées.

public:
 static System::String ^ Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2);
public static string Concat (ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2);
static member Concat : ReadOnlySpan<char> * ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Concat (str0 As ReadOnlySpan(Of Char), str1 As ReadOnlySpan(Of Char), str2 As ReadOnlySpan(Of Char)) As String

Paramètres

str0
ReadOnlySpan<Char>

Première étendue de caractères en lecture seule à concaténer.

str1
ReadOnlySpan<Char>

Deuxième étendue de caractères en lecture seule à concaténer.

str2
ReadOnlySpan<Char>

Troisième étendue de caractères en lecture seule à concaténer.

Retours

Représentations sous forme de chaîne concaténées des valeurs de str0, str1 et str2.

S’applique à

Concat(Object, Object, Object)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène les représentations sous forme de chaîne de trois objets spécifiés.

public:
 static System::String ^ Concat(System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Concat (object arg0, object arg1, object arg2);
public static string Concat (object? arg0, object? arg1, object? arg2);
static member Concat : obj * obj * obj -> string
Public Shared Function Concat (arg0 As Object, arg1 As Object, arg2 As Object) As String

Paramètres

arg0
Object

Premier objet à concaténer.

arg1
Object

Deuxième objet à concaténer.

arg2
Object

Troisième objet à concaténer.

Retours

Représentations sous forme de chaîne concaténées des valeurs de arg0, arg1et arg2.

Exemples

L’exemple suivant illustre la méthode Concat.

using namespace System;

int main()
{
   int i = -123;
   Object^ o = i;
   array<Object^>^objs = { -123, -456, -789};
   Console::WriteLine("Concatenate 1, 2, and 3 objects:");
   Console::WriteLine("1) {0}", String::Concat(o));
   Console::WriteLine("2) {0}", String::Concat(o, o));
   Console::WriteLine("3) {0}", String::Concat(o, o, o));
   
   Console::WriteLine("\nConcatenate 4 objects and a variable length parameter list:" );
   Console::WriteLine("4) {0}", String::Concat(o, o, o, o));
   Console::WriteLine("5) {0}", String::Concat( o, o, o, o, o));
   Console::WriteLine("\nConcatenate a 3-element object array:");
   Console::WriteLine("6) {0}", String::Concat(objs));
}
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//    
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//    
//    Concatenate a 3-element object array:
//    6) -123-456-789
using System;

class stringConcat5 {
    public static void Main() {
    int i = -123;
    Object o = i;
    Object[] objs = new Object[] {-123, -456, -789};

    Console.WriteLine("Concatenate 1, 2, and 3 objects:");
    Console.WriteLine("1) {0}", String.Concat(o));
    Console.WriteLine("2) {0}", String.Concat(o, o));
    Console.WriteLine("3) {0}", String.Concat(o, o, o));

    Console.WriteLine("\nConcatenate 4 objects and a variable length parameter list:");
    Console.WriteLine("4) {0}", String.Concat(o, o, o, o));
    Console.WriteLine("5) {0}", String.Concat(o, o, o, o, o));

    Console.WriteLine("\nConcatenate a 3-element object array:");
    Console.WriteLine("6) {0}", String.Concat(objs));
    }
}
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//
//    Concatenate a 3-element object array:
//    6) -123-456-789
open System

let i = -123
let o: obj = i
let objs: obj[] = [| -123; -456; -789 |]

printfn "Concatenate 1, 2, and 3 objects:"
printfn $"1) {String.Concat o}"
printfn $"2) {String.Concat(o, o)}"
printfn $"3) {String.Concat(o, o, o)}"

printfn "\nConcatenate 4 objects and a variable length parameter list:"
printfn $"4) {String.Concat(o, o, o, o)}"
printfn $"5) {String.Concat(o, o, o, o, o)}"

printfn "\nConcatenate a 3-element object array:"
printfn $"6) {String.Concat objs}" 
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//
//    Concatenate a 3-element object array:
//    6) -123-456-789
Class stringConcat5
   Public Shared Sub Main()
      Dim i As Integer = - 123
      Dim o As [Object] = i
      Dim objs() As [Object] = {-123, -456, -789}
      
      Console.WriteLine("Concatenate 1, 2, and 3 objects:")
      Console.WriteLine("1) {0}", [String].Concat(o))
      Console.WriteLine("2) {0}", [String].Concat(o, o))
      Console.WriteLine("3) {0}", [String].Concat(o, o, o))
      
      Console.WriteLine(vbCrLf & "Concatenate 4 objects and a variable length parameter list:")
      Console.WriteLine("4) {0}", String.Concat(o, o, o, o))
      Console.WriteLine("5) {0}", String.Concat(o, o, o, o, o))
      
      Console.WriteLine(vbCrLf & "Concatenate a 3-element object array:")
      Console.WriteLine("6) {0}", [String].Concat(objs))
   End Sub
End Class
'The example displays the following output:
'    Concatenate 1, 2, and 3 objects:
'    1) -123
'    2) -123-123
'    3) -123-123-123
'    
'    Concatenate 4 objects and a variable length parameter list:
'    4) -123-123-123-123
'    5) -123-123-123-123-123
'         
'    Concatenate a 3-element object array:
'    6) -123-456-789

Remarques

La méthode concatène arg0, arg1et arg2 en appelant la méthode ToString sans paramètre de chaque objet ; il n’ajoute aucun délimiteur.

String.Empty est utilisé à la place d’un argument Null.

Voir aussi

S’applique à

Concat(String, String)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène deux instances spécifiées de String.

public:
 static System::String ^ Concat(System::String ^ str0, System::String ^ str1);
public static string Concat (string str0, string str1);
public static string Concat (string? str0, string? str1);
static member Concat : string * string -> string
Public Shared Function Concat (str0 As String, str1 As String) As String

Paramètres

str0
String

Première chaîne à concaténer.

str1
String

Deuxième chaîne à concaténer.

Retours

Concaténation de str0 et de str1.

Exemples

L’exemple suivant concatène le prénom, le milieu et le nom d’une personne.

using namespace System;
int main()
{
   
   // we want to simply quickly add this person's name together
   String^ fName = "Simon";
   String^ mName = "Jake";
   String^ lName = "Harrows";
   
   // because we want a name to appear with a space in between each name, 
   // put a space on the front of the middle, and last name, allowing for
   // the fact that a space may already be there
   mName = String::Concat(  " ", mName->Trim() );
   lName = String::Concat(  " ", lName->Trim() );
   
   // this line simply concatenates the two strings
   Console::WriteLine( "Welcome to this page, '{0}'!", String::Concat( String::Concat( fName, mName ), lName ) );
}
// The example displays the following output:
//        Welcome to this page, 'Simon Jake Harrows'!
using System;

public class ConcatTest {
    public static void Main() {

        // we want to simply quickly add this person's name together
        string fName = "Simon";
        string mName = "Jake";
        string lName = "Harrows";

        // because we want a name to appear with a space in between each name,
        // put a space on the front of the middle, and last name, allowing for
        // the fact that a space may already be there
        mName = " " + mName.Trim();
        lName = " " + lName.Trim();

        // this line simply concatenates the two strings
        Console.WriteLine("Welcome to this page, '{0}'!", string.Concat( string.Concat(fName, mName), lName ) );
    }
}
// The example displays the following output:
//        Welcome to this page, 'Simon Jake Harrows'!
open System

[<EntryPoint>]
let main _ =
    // we want to simply quickly add this person's name together
    let fName = "Simon"
    let mName = "Jake"
    let lName = "Harrows"

    // because we want a name to appear with a space in between each name,
    // put a space on the front of the middle, and last name, allowing for
    // the fact that a space may already be there
    let mName = " " + mName.Trim()
    let lName = " " + lName.Trim()

    // this line simply concatenates the two strings
    printfn $"Welcome to this page, '{String.Concat(String.Concat(fName, mName), lName)}'!"
    0
// The example displays the following output:
//        Welcome to this page, 'Simon Jake Harrows'!
Public Class ConcatTest
    Public Shared Sub Main()
        Dim fName As String = "Simon"
        Dim mName As String = "Jake"
        Dim lName As String = "Harrows"
        
        ' We want to simply quickly add this person's name together.
        ' Because we want a name to appear with a space in between each name, 
        ' we put a space on the front of the middle, and last name, allowing for
        ' the fact that a space may already be there.
        mName = " " + mName.Trim()
        lName = " " + lName.Trim()
        
        ' This line simply concatenates the two strings.
        Console.WriteLine("Welcome to this page, '{0}'!", _
                          String.Concat(String.Concat(fName, mName), lName))
    End Sub
End Class
' The example displays the following output:
'       Welcome to this page, 'Simon Jake Harrows'!

Remarques

La méthode concatène str0 et str1; il n’ajoute aucun délimiteur.

Une chaîne Empty est utilisée à la place d’un argument Null.

Voir aussi

S’applique à

Concat(Object)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Crée la représentation sous forme de chaîne d’un objet spécifié.

public:
 static System::String ^ Concat(System::Object ^ arg0);
public static string Concat (object arg0);
public static string Concat (object? arg0);
static member Concat : obj -> string
Public Shared Function Concat (arg0 As Object) As String

Paramètres

arg0
Object

Objet à représenter, ou null.

Retours

Représentation sous forme de chaîne de la valeur de arg0, ou Empty si arg0 est null.

Exemples

L’exemple suivant illustre la méthode Concat.

using namespace System;

int main()
{
   int i = -123;
   Object^ o = i;
   array<Object^>^objs = { -123, -456, -789};
   Console::WriteLine("Concatenate 1, 2, and 3 objects:");
   Console::WriteLine("1) {0}", String::Concat(o));
   Console::WriteLine("2) {0}", String::Concat(o, o));
   Console::WriteLine("3) {0}", String::Concat(o, o, o));
   
   Console::WriteLine("\nConcatenate 4 objects and a variable length parameter list:" );
   Console::WriteLine("4) {0}", String::Concat(o, o, o, o));
   Console::WriteLine("5) {0}", String::Concat( o, o, o, o, o));
   Console::WriteLine("\nConcatenate a 3-element object array:");
   Console::WriteLine("6) {0}", String::Concat(objs));
}
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//    
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//    
//    Concatenate a 3-element object array:
//    6) -123-456-789
using System;

class stringConcat5 {
    public static void Main() {
    int i = -123;
    Object o = i;
    Object[] objs = new Object[] {-123, -456, -789};

    Console.WriteLine("Concatenate 1, 2, and 3 objects:");
    Console.WriteLine("1) {0}", String.Concat(o));
    Console.WriteLine("2) {0}", String.Concat(o, o));
    Console.WriteLine("3) {0}", String.Concat(o, o, o));

    Console.WriteLine("\nConcatenate 4 objects and a variable length parameter list:");
    Console.WriteLine("4) {0}", String.Concat(o, o, o, o));
    Console.WriteLine("5) {0}", String.Concat(o, o, o, o, o));

    Console.WriteLine("\nConcatenate a 3-element object array:");
    Console.WriteLine("6) {0}", String.Concat(objs));
    }
}
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//
//    Concatenate a 3-element object array:
//    6) -123-456-789
open System

let i = -123
let o: obj = i
let objs: obj[] = [| -123; -456; -789 |]

printfn "Concatenate 1, 2, and 3 objects:"
printfn $"1) {String.Concat o}"
printfn $"2) {String.Concat(o, o)}"
printfn $"3) {String.Concat(o, o, o)}"

printfn "\nConcatenate 4 objects and a variable length parameter list:"
printfn $"4) {String.Concat(o, o, o, o)}"
printfn $"5) {String.Concat(o, o, o, o, o)}"

printfn "\nConcatenate a 3-element object array:"
printfn $"6) {String.Concat objs}" 
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//
//    Concatenate a 3-element object array:
//    6) -123-456-789
Class stringConcat5
   Public Shared Sub Main()
      Dim i As Integer = - 123
      Dim o As [Object] = i
      Dim objs() As [Object] = {-123, -456, -789}
      
      Console.WriteLine("Concatenate 1, 2, and 3 objects:")
      Console.WriteLine("1) {0}", [String].Concat(o))
      Console.WriteLine("2) {0}", [String].Concat(o, o))
      Console.WriteLine("3) {0}", [String].Concat(o, o, o))
      
      Console.WriteLine(vbCrLf & "Concatenate 4 objects and a variable length parameter list:")
      Console.WriteLine("4) {0}", String.Concat(o, o, o, o))
      Console.WriteLine("5) {0}", String.Concat(o, o, o, o, o))
      
      Console.WriteLine(vbCrLf & "Concatenate a 3-element object array:")
      Console.WriteLine("6) {0}", [String].Concat(objs))
   End Sub
End Class
'The example displays the following output:
'    Concatenate 1, 2, and 3 objects:
'    1) -123
'    2) -123-123
'    3) -123-123-123
'    
'    Concatenate 4 objects and a variable length parameter list:
'    4) -123-123-123-123
'    5) -123-123-123-123-123
'         
'    Concatenate a 3-element object array:
'    6) -123-456-789

Remarques

La méthode Concat(Object) représente arg0 sous forme de chaîne en appelant sa méthode ToString sans paramètre.

Voir aussi

S’applique à

Concat(Object, Object)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène les représentations sous forme de chaîne de deux objets spécifiés.

public:
 static System::String ^ Concat(System::Object ^ arg0, System::Object ^ arg1);
public static string Concat (object arg0, object arg1);
public static string Concat (object? arg0, object? arg1);
static member Concat : obj * obj -> string
Public Shared Function Concat (arg0 As Object, arg1 As Object) As String

Paramètres

arg0
Object

Premier objet à concaténer.

arg1
Object

Deuxième objet à concaténer.

Retours

Représentations sous forme de chaîne concaténées des valeurs de arg0 et de arg1.

Exemples

L’exemple suivant illustre la méthode Concat.

using namespace System;

int main()
{
   int i = -123;
   Object^ o = i;
   array<Object^>^objs = { -123, -456, -789};
   Console::WriteLine("Concatenate 1, 2, and 3 objects:");
   Console::WriteLine("1) {0}", String::Concat(o));
   Console::WriteLine("2) {0}", String::Concat(o, o));
   Console::WriteLine("3) {0}", String::Concat(o, o, o));
   
   Console::WriteLine("\nConcatenate 4 objects and a variable length parameter list:" );
   Console::WriteLine("4) {0}", String::Concat(o, o, o, o));
   Console::WriteLine("5) {0}", String::Concat( o, o, o, o, o));
   Console::WriteLine("\nConcatenate a 3-element object array:");
   Console::WriteLine("6) {0}", String::Concat(objs));
}
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//    
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//    
//    Concatenate a 3-element object array:
//    6) -123-456-789
using System;

class stringConcat5 {
    public static void Main() {
    int i = -123;
    Object o = i;
    Object[] objs = new Object[] {-123, -456, -789};

    Console.WriteLine("Concatenate 1, 2, and 3 objects:");
    Console.WriteLine("1) {0}", String.Concat(o));
    Console.WriteLine("2) {0}", String.Concat(o, o));
    Console.WriteLine("3) {0}", String.Concat(o, o, o));

    Console.WriteLine("\nConcatenate 4 objects and a variable length parameter list:");
    Console.WriteLine("4) {0}", String.Concat(o, o, o, o));
    Console.WriteLine("5) {0}", String.Concat(o, o, o, o, o));

    Console.WriteLine("\nConcatenate a 3-element object array:");
    Console.WriteLine("6) {0}", String.Concat(objs));
    }
}
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//
//    Concatenate a 3-element object array:
//    6) -123-456-789
open System

let i = -123
let o: obj = i
let objs: obj[] = [| -123; -456; -789 |]

printfn "Concatenate 1, 2, and 3 objects:"
printfn $"1) {String.Concat o}"
printfn $"2) {String.Concat(o, o)}"
printfn $"3) {String.Concat(o, o, o)}"

printfn "\nConcatenate 4 objects and a variable length parameter list:"
printfn $"4) {String.Concat(o, o, o, o)}"
printfn $"5) {String.Concat(o, o, o, o, o)}"

printfn "\nConcatenate a 3-element object array:"
printfn $"6) {String.Concat objs}" 
// The example displays the following output:
//    Concatenate 1, 2, and 3 objects:
//    1) -123
//    2) -123-123
//    3) -123-123-123
//
//    Concatenate 4 objects and a variable length parameter list:
//    4) -123-123-123-123
//    5) -123-123-123-123-123
//
//    Concatenate a 3-element object array:
//    6) -123-456-789
Class stringConcat5
   Public Shared Sub Main()
      Dim i As Integer = - 123
      Dim o As [Object] = i
      Dim objs() As [Object] = {-123, -456, -789}
      
      Console.WriteLine("Concatenate 1, 2, and 3 objects:")
      Console.WriteLine("1) {0}", [String].Concat(o))
      Console.WriteLine("2) {0}", [String].Concat(o, o))
      Console.WriteLine("3) {0}", [String].Concat(o, o, o))
      
      Console.WriteLine(vbCrLf & "Concatenate 4 objects and a variable length parameter list:")
      Console.WriteLine("4) {0}", String.Concat(o, o, o, o))
      Console.WriteLine("5) {0}", String.Concat(o, o, o, o, o))
      
      Console.WriteLine(vbCrLf & "Concatenate a 3-element object array:")
      Console.WriteLine("6) {0}", [String].Concat(objs))
   End Sub
End Class
'The example displays the following output:
'    Concatenate 1, 2, and 3 objects:
'    1) -123
'    2) -123-123
'    3) -123-123-123
'    
'    Concatenate 4 objects and a variable length parameter list:
'    4) -123-123-123-123
'    5) -123-123-123-123-123
'         
'    Concatenate a 3-element object array:
'    6) -123-456-789

Remarques

La méthode concatène arg0 et arg1 en appelant la méthode de ToString sans paramètre de arg0 et de arg1; il n’ajoute aucun délimiteur.

String.Empty est utilisé à la place d’un argument Null.

Si l’un des arguments est une référence de tableau, la méthode concatène une chaîne représentant ce tableau, au lieu de ses membres (par exemple, « System.String[] »).

Voir aussi

S’applique à

Concat(String[])

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Important

Cette API n’est pas conforme CLS.

Concatène les éléments d’un tableau de String spécifié.

public:
 static System::String ^ Concat(... cli::array <System::String ^> ^ values);
public static string Concat (params string[] values);
public static string Concat (params string?[] values);
[System.CLSCompliant(false)]
public static string Concat (params string[] values);
static member Concat : string[] -> string
[<System.CLSCompliant(false)>]
static member Concat : string[] -> string
Public Shared Function Concat (ParamArray values As String()) As String

Paramètres

values
String[]

Tableau d’instances de chaîne.

Retours

Éléments concaténés de values.

Attributs

Exceptions

values est null.

Mémoire insuffisante.

Exemples

L’exemple suivant illustre l’utilisation de la méthode Concat avec un tableau String.

using namespace System;

int main()
{
   
   // Make an array of strings. Note that we have included spaces.
   array<String^>^s = { "hello ", "and ", "welcome ", "to ",
                        "this ", "demo! "};
   
   // Put all the strings together.
   Console::WriteLine( String::Concat(s) );
   
   // Sort the strings, and put them together.
   Array::Sort( s );
   Console::WriteLine( String::Concat(s));
}
// The example displays the following output:
//       hello and welcome to this demo!
//       and demo! hello this to welcome
using System;

public class Example
{
    public static void Main()
    {
        // Make an array of strings. Note that we have included spaces.
        string [] s = { "hello ", "and ", "welcome ", "to ",
                        "this ", "demo! " };

        // Put all the strings together.
        Console.WriteLine(string.Concat(s));

        // Sort the strings, and put them together.
        Array.Sort(s);
        Console.WriteLine(string.Concat(s));
    }
}
// The example displays the following output:
//       hello and welcome to this demo!
//       and demo! hello this to welcome
open System

// Make an array of strings. Note that we have included spaces.
let s = 
    [| "hello "; "and "; "welcome "; "to "
       "this "; "demo! " |]

// Put all the strings together.
printfn $"{String.Concat s}"

// Sort the strings, and put them together.
Array.Sort s
printfn $"{String.Concat s}"
// The example displays the following output:
//       hello and welcome to this demo!
//       and demo! hello this to welcome
Public Class Example
    Public Shared Sub Main()
        ' Make an array of strings. Note that we have included spaces.
        Dim s As String() = { "hello ", "and ", "welcome ", "to ",
                              "this ", "demo! "}

        ' Put all the strings together.
        Console.WriteLine(String.Concat(s))
        
        ' Sort the strings, and put them together.
        Array.Sort(s)
        Console.WriteLine(String.Concat(s))
    End Sub
End Class
' The example displays the following output:
'       hello and welcome to this demo!
'       and demo! hello this to welcome

Remarques

La méthode concatène chaque objet dans values; il n’ajoute aucun délimiteur.

Une chaîne Empty est utilisée à la place d’un objet Null dans le tableau.

Voir aussi

S’applique à

Concat(ReadOnlySpan<String>)

Concatène les éléments d’une étendue spécifiée de String.

public:
 static System::String ^ Concat(ReadOnlySpan<System::String ^> values);
public static string Concat (scoped ReadOnlySpan<string?> values);
static member Concat : ReadOnlySpan<string> -> string
Public Shared Function Concat (values As ReadOnlySpan(Of String)) As String

Paramètres

values
ReadOnlySpan<String>

Étendue d’instances String.

Retours

Éléments concaténés de values.

S’applique à

Concat(ReadOnlySpan<Object>)

Concatène les représentations sous forme de chaîne des éléments dans une étendue d’objets spécifiée.

public:
 static System::String ^ Concat(ReadOnlySpan<System::Object ^> args);
public static string Concat (scoped ReadOnlySpan<object?> args);
static member Concat : ReadOnlySpan<obj> -> string
Public Shared Function Concat (args As ReadOnlySpan(Of Object)) As String

Paramètres

args
ReadOnlySpan<Object>

Étendue d’objets qui contient les éléments à concaténer.

Retours

Représentations sous forme de chaîne concaténées des valeurs des éléments dans args.

S’applique à

Concat(Object[])

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène les représentations sous forme de chaîne des éléments d’un tableau de Object spécifié.

public:
 static System::String ^ Concat(... cli::array <System::Object ^> ^ args);
public static string Concat (params object[] args);
public static string Concat (params object?[] args);
static member Concat : obj[] -> string
Public Shared Function Concat (ParamArray args As Object()) As String

Paramètres

args
Object[]

Tableau d’objets qui contient les éléments à concaténer.

Retours

Représentations sous forme de chaîne concaténées des valeurs des éléments dans args.

Exceptions

args est null.

Mémoire insuffisante.

Exemples

L’exemple suivant illustre l’utilisation de la méthode Concat avec un tableau Object.

using System;

public class ConcatTest {
    public static void Main() {
        // Create a group of objects.
        Test1 t1 = new Test1();
        Test2 t2 = new Test2();
        int i = 16;
        string s = "Demonstration";

        // Place the objects in an array.
        object [] o = { t1, i, t2, s };

        // Concatenate the objects together as a string. To do this,
        // the ToString method of each of the objects is called.
        Console.WriteLine(string.Concat(o));
    }
}

// Create two empty test classes.
class Test1 {
}

class Test2 {
}
// The example displays the following output:
//       Test116Test2Demonstration
open System

// Create two empty test classes.
type Test1() = class end

type Test2() = class end

// Create a group of objects.
let t1 = new Test1()
let t2 = new Test2()
let i = 16
let s = "Demonstration"

// Place the objects in an array.
let o: obj[] = [| t1; i; t2; s |]

// Concatenate the objects together as a string. To do this,
// the ToString method of each of the objects is called.
printfn $"{String.Concat o}"

// The example displays the following output:
//       Test116Test2Demonstration
Public Class ConcatTest
    
    Public Shared Sub Main()
        Dim t1 As New Test1()
        Dim t2 As New Test2()
        Dim i As Integer = 16
        Dim s As String = "Demonstration"
        Dim o As Object() = {t1, i, t2, s}
        
        ' create a group of objects
        
        ' place the objects in an array
        
        ' concatenate the objects together as a string. To do this,
        ' the ToString method in the objects is called
        Console.WriteLine(String.Concat(o))
    End Sub
End Class


' imagine these test classes are full-fledged objects...
Class Test1
End Class

Class Test2
End Class

Remarques

La méthode concatène chaque objet dans args en appelant la méthode ToString sans paramètre de cet objet ; il n’ajoute aucun délimiteur.

String.Empty est utilisé à la place d’un objet Null dans le tableau.

Notes pour les appelants

Cette méthode n’est pas appelée par le code C++. Le compilateur C++ résout les appels à Concat qui ont quatre paramètres d’objet ou plus comme appel à Concat(Object, Object, Object, Object).

Voir aussi

S’applique à

Concat(IEnumerable<String>)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène les membres d’une collection IEnumerable<T> construite de type String.

public:
 static System::String ^ Concat(System::Collections::Generic::IEnumerable<System::String ^> ^ values);
public static string Concat (System.Collections.Generic.IEnumerable<string> values);
public static string Concat (System.Collections.Generic.IEnumerable<string?> values);
[System.Runtime.InteropServices.ComVisible(false)]
public static string Concat (System.Collections.Generic.IEnumerable<string> values);
static member Concat : seq<string> -> string
[<System.Runtime.InteropServices.ComVisible(false)>]
static member Concat : seq<string> -> string
Public Shared Function Concat (values As IEnumerable(Of String)) As String

Paramètres

values
IEnumerable<String>

Objet de collection qui implémente IEnumerable<T> et dont l’argument de type générique est String.

Retours

Chaînes concaténées dans valuesou Empty si values est une IEnumerable(Of String)vide.

Attributs

Exceptions

values est null.

Exemples

L’exemple suivant utilise l’algorithme Sieve of Eratosthenes pour calculer les nombres premiers inférieurs ou égaux à 100. Il affecte le résultat à un objet List<T> de type String, qu’il passe ensuite à la méthode Concat(IEnumerable<String>).

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      int maxPrime = 100;
      IEnumerable<String> primeList = GetPrimes(maxPrime);
      Console.WriteLine("Primes less than {0}:", maxPrime);
      Console.WriteLine("   {0}", String.Concat(primeList));
   }

   private static IEnumerable<String> GetPrimes(int maxPrime)
   {
      Array values = Array.CreateInstance(typeof(int), 
                              new int[] { maxPrime - 1}, new int[] { 2 }); 
      // Use Sieve of Erathsthenes to determine prime numbers.
      for (int ctr = values.GetLowerBound(0); ctr <= (int) Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))); ctr++)
      {
                           
         if ((int) values.GetValue(ctr) == 1) continue;
         
         for (int multiplier = ctr; multiplier <=  maxPrime / 2; multiplier++)
            if (ctr * multiplier <= maxPrime)
               values.SetValue(1, ctr * multiplier);
      }      
      
      List<String> primes = new List<String>();
      for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++)
         if ((int) values.GetValue(ctr) == 0) 
            primes.Add(ctr.ToString() + " ");
      return primes;
   }   
}
// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
open System

let getPrimes maxPrime =
    let values = Array.CreateInstance(typeof<int>, [| maxPrime - 1|], [| 2 |]) 
    // Use Sieve of Erathsthenes to determine prime numbers.
    for i = values.GetLowerBound 0 to values.GetUpperBound 0 |> float |> sqrt |> ceil |> int do
        if values.GetValue i :?> int <> 1 then
            for multiplier = i to maxPrime / 2 do
                if i * multiplier <= maxPrime then
                    values.SetValue(1, i * multiplier)
    seq {
        for i = values.GetLowerBound 0 to values.GetUpperBound 0 do
            if values.GetValue i :?> int = 0 then
                string i + " "
    }    

let maxPrime = 100
let primeList = getPrimes maxPrime
printfn $"Primes less than {maxPrime}:"
printfn $"   {String.Concat primeList}"

// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim maxPrime As Integer = 100
      Dim primeList As IEnumerable(Of String) = GetPrimes(maxPrime)
      Console.WriteLine("Primes less than {0}:", maxPrime)
      Console.WriteLine("   {0}", String.Concat(primeList))
   End Sub
   
   Private Function GetPrimes(maxPrime As Integer) As IEnumerable(Of String)
      Dim values As Array = Array.CreateInstance(GetType(Integer), _
                              New Integer() { maxPrime - 1}, New Integer(){ 2 }) 
      ' Use Sieve of Erathsthenes to determine prime numbers.
      For ctr As Integer = values.GetLowerBound(0) To _
                           CInt(Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))))
         If CInt(values.GetValue(ctr)) = 1 Then Continue For
         
         For multiplier As Integer = ctr To maxPrime \ 2
            If ctr * multiplier <= maxPrime Then values.SetValue(1, ctr * multiplier)
         Next   
      Next      
      
      Dim primes As New List(Of String)
      For ctr As Integer = values.GetLowerBound(0) To values.GetUpperBound(0)
         If CInt(values.GetValue(ctr)) = 0 Then primes.Add(ctr.ToString() + " ")
      Next            
      Return primes
   End Function   
End Module
' The example displays the following output:
'    Primes less than 100:
'       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Remarques

La méthode concatène chaque objet dans values; il n’ajoute aucun délimiteur. Pour spécifier un délimiteur entre chaque membre de values, appelez la méthode Join(String, IEnumerable<String>).

Une chaîne Empty est utilisée à la place d’un élément Null dans values.

Si values est une IEnumerable(Of String)vide, la méthode retourne String.Empty. Si values est null, la méthode lève une exception ArgumentNullException.

Concat(IEnumerable<String>) est une méthode pratique qui vous permet de concaténer chaque élément d’une collection IEnumerable(Of String) sans convertir d’abord les éléments en tableau de chaînes. Il est particulièrement utile avec les expressions de requête LINQ (Language-Integrated Query). L’exemple suivant transmet un objet List(Of String) qui contient les lettres majuscules ou minuscules de l’alphabet à une expression lambda qui sélectionne des lettres égales ou supérieures à une lettre particulière (qui, dans l’exemple, est « M »). La collection IEnumerable(Of String) retournée par la méthode Enumerable.Where est passée à la méthode Concat(IEnumerable<String>) pour afficher le résultat sous forme de chaîne unique.

using System;
using System.Collections.Generic;
using System.Linq;

public class Example
{
   public static void Main()
   {
      string output = String.Concat( GetAlphabet(true).Where( letter => 
                      letter.CompareTo("M") >= 0));
      Console.WriteLine(output);  
   }

   private static List<string> GetAlphabet(bool upper)
   {
      List<string> alphabet = new List<string>();
      int charValue = upper ? 65 : 97;
      for (int ctr = 0; ctr <= 25; ctr++)
         alphabet.Add(((char)(charValue + ctr)).ToString());
      return alphabet; 
   }
}
// The example displays the following output:
//      MNOPQRSTUVWXYZ
// This example uses the F# Seq.filter function instead of Linq.
open System

let getAlphabet upper =
    let charValue = if upper then 65 else 97
    seq {
        for i = 0 to 25 do
            charValue + i |> char |> string
    }

getAlphabet true
|> Seq.filter (fun letter -> letter.CompareTo "M" >= 0)
|> String.Concat
|> printfn "%s"
// The example displays the following output:
//      MNOPQRSTUVWXYZ
Imports System.Collections.Generic
Imports System.Linq

Module modMain
   Public Sub Main()
      Dim output As String = String.Concat(GetAlphabet(true).Where(Function(letter) _
                                                         letter >= "M"))
        
      Console.WriteLine(output)                                     
   End Sub
   
   Private Function GetAlphabet(upper As Boolean) As List(Of String)
      Dim alphabet As New List(Of String)
      Dim charValue As Integer = CInt(IIf(upper, 65, 97))
      For ctr As Integer = 0 To 25
         alphabet.Add(ChrW(charValue + ctr).ToString())
      Next
      Return alphabet 
   End Function
End Module
' The example displays the following output:
'       MNOPQRSTUVWXYZ

S’applique à

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène les représentations sous forme de chaîne de deux étendues de caractères en lecture seule spécifiées.

public:
 static System::String ^ Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1);
public static string Concat (ReadOnlySpan<char> str0, ReadOnlySpan<char> str1);
static member Concat : ReadOnlySpan<char> * ReadOnlySpan<char> -> string
Public Shared Function Concat (str0 As ReadOnlySpan(Of Char), str1 As ReadOnlySpan(Of Char)) As String

Paramètres

str0
ReadOnlySpan<Char>

Première étendue de caractères en lecture seule à concaténer.

str1
ReadOnlySpan<Char>

Deuxième étendue de caractères en lecture seule à concaténer.

Retours

Représentations sous forme de chaîne concaténées des valeurs de str0 et de str1.

S’applique à

Concat<T>(IEnumerable<T>)

Source:
String.Manipulation.cs
Source:
String.Manipulation.cs
Source:
String.Manipulation.cs

Concatène les membres d’une implémentation IEnumerable<T>.

public:
generic <typename T>
 static System::String ^ Concat(System::Collections::Generic::IEnumerable<T> ^ values);
public static string Concat<T> (System.Collections.Generic.IEnumerable<T> values);
[System.Runtime.InteropServices.ComVisible(false)]
public static string Concat<T> (System.Collections.Generic.IEnumerable<T> values);
static member Concat : seq<'T> -> string
[<System.Runtime.InteropServices.ComVisible(false)>]
static member Concat : seq<'T> -> string
Public Shared Function Concat(Of T) (values As IEnumerable(Of T)) As String

Paramètres de type

T

Type des membres de values.

Paramètres

values
IEnumerable<T>

Objet de collection qui implémente l’interface IEnumerable<T>.

Retours

Membres concaténés dans values.

Attributs

Exceptions

values est null.

Exemples

L’exemple suivant définit une classe de Animal très simple qui contient le nom d’un animal et l’ordre auquel il appartient. Il définit ensuite un objet List<T> pour contenir un certain nombre d’objets Animal. La méthode d’extension Enumerable.Where est appelée pour extraire les objets Animal dont la propriété Order est égale à « Rongeur ». Le résultat est passé à la méthode Concat<T>(IEnumerable<T>) et affiché à la console.

using System;
using System.Collections.Generic;
using System.Linq;

public class Animal
{
   public string Kind;
   public string Order;
   
   public Animal(string kind, string order)
   {
      this.Kind = kind;
      this.Order = order;
   }
   
   public override string ToString()
   {
      return this.Kind;
   }
}

public class Example
{
   public static void Main()
   {
      List<Animal> animals = new List<Animal>();
      animals.Add(new Animal("Squirrel", "Rodent"));
      animals.Add(new Animal("Gray Wolf", "Carnivora"));
      animals.Add(new Animal("Capybara", "Rodent"));
      string output = String.Concat(animals.Where( animal => 
                      (animal.Order == "Rodent")));
      Console.WriteLine(output);  
   }
}
// The example displays the following output:
//      SquirrelCapybara
// This example uses the F# Seq.filter function instead of Linq.
open System

type Animal =
  { Kind: string
    Order: string }
    override this.ToString() =
       this.Kind

let animals = ResizeArray()
animals.Add { Kind = "Squirrel"; Order = "Rodent" }
animals.Add { Kind = "Gray Wolf"; Order = "Carnivora" }
animals.Add { Kind = "Capybara"; Order = "Rodent" }

Seq.filter (fun animal -> animal.Order = "Rodent")
|> String.Concat
|> printfn "%s"
// The example displays the following output:
//      SquirrelCapybara
Imports System.Collections.Generic

Public Class Animal
   Public Kind As String
   Public Order As String
   
   Public Sub New(kind As String, order As String)
      Me.Kind = kind
      Me.Order = order
   End Sub
   
   Public Overrides Function ToString() As String
      Return Me.Kind
   End Function
End Class

Module Example
   Public Sub Main()
      Dim animals As New List(Of Animal)
      animals.Add(New Animal("Squirrel", "Rodent"))
      animals.Add(New Animal("Gray Wolf", "Carnivora"))
      animals.Add(New Animal("Capybara", "Rodent")) 
      Dim output As String = String.Concat(animals.Where(Function(animal) _
                                           animal.Order = "Rodent"))
      Console.WriteLine(output)                                           
   End Sub
End Module
' The example displays the following output:
'      SquirrelCapybara

Remarques

La méthode concatène chaque objet dans values; il n’ajoute aucun délimiteur.

Une chaîne Empty est utilisée à la place d’un argument Null.

Concat<T>(IEnumerable<T>) est une méthode pratique qui vous permet de concaténer chaque élément d’une collection IEnumerable<T> sans convertir d’abord les éléments en chaînes. Il est particulièrement utile avec les expressions de requête Language-Integrated Query (LINQ), comme l’illustre l’exemple. La représentation sous forme de chaîne de chaque objet de la collection IEnumerable<T> est dérivée en appelant la méthode ToString de cet objet.

S’applique à