String.Concat String.Concat String.Concat String.Concat Method

Definition

Verkettet eine oder mehrere Instanzen von String oder die String-Darstellungen der Werte einer oder mehrerer Instanzen von Object.Concatenates one or more instances of String, or the String representations of the values of one or more instances of Object.

Überlädt

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

Verkettet die Zeichenfolgendarstellung von drei angegebenen schreibgeschützten Zeichenspannen.Concatenates the string representations of three specified read-only character spans.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

Verkettet zwei angegebene Instanzen von String.Concatenates four specified instances of String.

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

Verkettet die Zeichenfolgendarstellung von vier angegebenen schreibgeschützten Zeichenspannen.Concatenates the string representations of four specified read-only character spans.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object)

Verkettet die Zeichenfolgenentsprechungen von vier angegebenen Objekten sowie aller in einer optionalen Parameterliste variabler Länger angegebenen Objekte.Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

Verkettet zwei angegebene Instanzen von String.Concatenates three specified instances of String.

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

Verkettet zwei angegebene Instanzen von String.Concatenates two specified instances of String.

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

Verkettet die Zeichenfolgendarstellungen von drei angegebenen Objekten.Concatenates the string representations of three specified objects.

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

Verkettet die Zeichenfolgendarstellungen zweier angegebener Objekte.Concatenates the string representations of two specified objects.

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

Verkettet die Elemente eines angegebenen String-Arrays.Concatenates the elements of a specified String array.

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

Verkettet die Zeichenfolgendarstellungen der Elemente in einem angegebenen Object-Array.Concatenates the string representations of the elements in a specified Object array.

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

Erstellt die Zeichenfolgendarstellung eines angegebenen Objekts.Creates the string representation of a specified object.

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String.Concatenates the members of a constructed IEnumerable<T> collection of type String.

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

Verkettet die Zeichenfolgendarstellung von zwei angegebenen schreibgeschützten Zeichenspannen.Concatenates the string representations of two specified read-only character spans.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

Verkettet die Member einer IEnumerable<T>-Implementierung.Concatenates the members of an IEnumerable<T> implementation.

Hinweise

Hinweis

Sie können auch den Zeichen folgen Verkettungs Operator ihrer Sprache verwenden, z + . C#b. & in + , oder und in Visual Basic, um Zeichen folgen zu verketten.You can also use your language's string concatenation operator, such as + in C#, or & and + in Visual Basic, to concatenate strings. Beide Compiler übersetzen den Verkettungs Operator in einen-aufruber einer der über Ladungen String.Concatvon.Both compilers translate the concatenation operator into a call to one of the overloads of String.Concat.

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

Verkettet die Zeichenfolgendarstellung von drei angegebenen schreibgeschützten Zeichenspannen.Concatenates the string representations of three specified read-only character spans.

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

Parameter

str0
ReadOnlySpan<Char>

Die erste zu verkettende schreibgeschützte Zeichenspanne.The first read-only character span to concatenate.

str1
ReadOnlySpan<Char>

Die zweite zu verkettende schreibgeschützte Zeichenspanne.The second read-only character span to concatenate.

str2
ReadOnlySpan<Char>

Die dritte zu verkettende schreibgeschützte Zeichenspanne.The third read-only character span to concatenate.

Gibt zurück

Die verketteten Zeichenfolgendarstellungen der Werte von str0, str1 und str2.The concatenated string representations of the values of str0, str1 and str2.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

Verkettet zwei angegebene Instanzen von String.Concatenates four specified instances of 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);
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

Parameter

str0
String String String String

Die erste zu verkettende Zeichenfolge.The first string to concatenate.

str1
String String String String

Die zweite zu verkettende Zeichenfolge.The second string to concatenate.

str2
String String String String

Die dritte zu verkettende Zeichenfolge.The third string to concatenate.

str3
String String String String

Die vierte zu verkettende Zeichenfolge.The fourth string to concatenate.

Gibt zurück

Die Verkettung von str0, str1, str2 und str3.The concatenation of str0, str1, str2, and str3.

Beispiele

Im folgenden Beispiel wird ein Array aus aus vier Buchstaben bestehenden Wörtern definiert und die einzelnen Buchstaben in einem Zeichen folgen Array gespeichert, um Sie zu verscheinigen.The following example defines an array of four-letter words and stores their individual letters to a string array in order to scramble them. Anschließend wird die Concat(String, String, String, String) -Methode aufgerufen, um die verwornielten Wörter erneut zuzuweisen.It then calls the Concat(String, String, String, String) method to reassemble the scrambled words.

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
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

Hinweise

Die-Methode verkettet str0 str2, str1, und str3. Sie fügt keine Trennzeichen hinzu.The method concatenates str0, str1, str2, and str3; it does not add any delimiters.

Siehe auch

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

Verkettet die Zeichenfolgendarstellung von vier angegebenen schreibgeschützten Zeichenspannen.Concatenates the string representations of four specified read-only character spans.

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

Parameter

str0
ReadOnlySpan<Char>

Die erste zu verkettende schreibgeschützte Zeichenspanne.The first read-only character span to concatenate.

str1
ReadOnlySpan<Char>

Die zweite zu verkettende schreibgeschützte Zeichenspanne.The second read-only character span to concatenate.

str2
ReadOnlySpan<Char>

Die dritte zu verkettende schreibgeschützte Zeichenspanne.The third read-only character span to concatenate.

str3
ReadOnlySpan<Char>

Die vierte zu verkettende schreibgeschützte Zeichenspanne.The fourth read-only character span to concatenate.

Gibt zurück

Die verketteten Zeichenfolgendarstellungen der Werte von str0, str1, str2 und str3.The concatenated string representations of the values of str0, str1, str2 and str3.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object)

Wichtig

Diese API ist nicht CLS-kompatibel.

Verkettet die Zeichenfolgenentsprechungen von vier angegebenen Objekten sowie aller in einer optionalen Parameterliste variabler Länger angegebenen Objekte.Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

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);
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

Parameter

arg0
Object Object Object Object

Das erste zu verkettende Objekt.The first object to concatenate.

arg1
Object Object Object Object

Das zweite zu verkettende Objekt.The second object to concatenate.

arg2
Object Object Object Object

Das dritte zu verkettende Objekt.The third object to concatenate.

arg3
Object Object Object Object

Das vierte zu verkettende Objekt.The fourth object to concatenate.

Gibt zurück

Die verkettete Zeichenfolgendarstellung aller Werte in der Parameterliste.The concatenated string representation of each value in the parameter list.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie die Concat(Object, Object, Object, Object) -Methode verwendet wird, um eine Liste von Variablen Parametern zu verketten.The following example illustrates the use of the Concat(Object, Object, Object, Object) method to concatenate a list of variable parameters. In diesem Fall wird die-Methode mit neun Parametern aufgerufen.In this case, the method is called with nine parameters.

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
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

Hinweise

Hinweis

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant. Die CLS-kompatible Alternative ist String.Concat(Object[]).The CLS-compliant alternative is String.Concat(Object[]). Der C# -und der-Visual Basic Compiler lösen einen aufzurufenden Rückruf dieser Methode String.Concat(Object[])automatisch als-Aufrufe von auf.The C# and Visual Basic compilers automatically resolve a call to this method as a call to String.Concat(Object[]).

Die-Methode verkettet jedes Objekt in der Parameterliste, indem es die Parameter lose ToString -Methode aufruft. es fügt keine Trennzeichen hinzu.The method concatenates each object in the parameter list by calling its parameterless ToString method; it does not add any delimiters.

String.Emptywird anstelle von NULL-Argumenten verwendet.String.Empty is used in place of any null argument.

Hinweis

Der letzte Parameter der Concat -Methode ist eine optionale durch Trennzeichen getrennte Liste mit einem oder mehreren zusätzlichen Objekten, die verkettet werden sollen.The last parameter of the Concat method is an optional comma-delimited list of one or more additional objects to concatenate.

Hinweise für Aufrufer

Diese Methode ist mit dem vararg -Schlüsselwort gekennzeichnet, was bedeutet, dass Sie eine Variable Anzahl von Parametern unterstützt.This method is marked with the vararg keyword, which means that it supports a variable number of parameters. Die-Methode kann aus Visual C++aufgerufen werden, Sie kann jedoch nicht von C# oder Visual Basic Code aufgerufen werden.The method can be called from Visual C++, but it cannot be called from C# or Visual Basic code. Der C# -und der-Visual Basic Compiler lösen Concat(Object, Object, Object, Object) Aufrufe von als Concat(Object[])Aufrufe von auf.The C# and Visual Basic compilers resolve calls to Concat(Object, Object, Object, Object) as calls to Concat(Object[]).

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

Verkettet zwei angegebene Instanzen von String.Concatenates three specified instances of 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);
static member Concat : string * string * string -> string
Public Shared Function Concat (str0 As String, str1 As String, str2 As String) As String

Parameter

str0
String String String String

Die erste zu verkettende Zeichenfolge.The first string to concatenate.

str1
String String String String

Die zweite zu verkettende Zeichenfolge.The second string to concatenate.

str2
String String String String

Die dritte zu verkettende Zeichenfolge.The third string to concatenate.

Gibt zurück

Die Verkettung von str0, str1 und str2.The concatenation of str0, str1, and str2.

Beispiele

Im folgenden Beispiel wird die Concat -Methode verwendet, um drei Zeichen folgen zu verketten, und das Ergebnis wird angezeigt.The following example uses the Concat method to concatenate three strings and displays the result.

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. 
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. 

Hinweise

Die-Methode verkettet str0, str1und und str2fügt keine Trennzeichen hinzu.The method concatenates str0, str1, and str2; it does not add any delimiters.

Siehe auch

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

Verkettet zwei angegebene Instanzen von String.Concatenates two specified instances of String.

public:
 static System::String ^ Concat(System::String ^ str0, System::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

Parameter

str0
String String String String

Die erste zu verkettende Zeichenfolge.The first string to concatenate.

str1
String String String String

Die zweite zu verkettende Zeichenfolge.The second string to concatenate.

Gibt zurück

Die Verkettung von str0 und str1.The concatenation of str0 and str1.

Beispiele

Im folgenden Beispiel werden die ersten, mittleren und Nachnamen einer Person verkettet.The following example concatenates a person's first, middle, and last name.

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'!
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'!

Hinweise

Die str0 -Methode verkettet und str1und fügt keine Trennzeichen hinzu.The method concatenates str0 and str1; it does not add any delimiters.

Anstelle Empty eines NULL-Arguments wird eine Zeichenfolge verwendet.An Empty string is used in place of any null argument.

Siehe auch

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

Verkettet die Zeichenfolgendarstellungen von drei angegebenen Objekten.Concatenates the string representations of three specified objects.

public:
 static System::String ^ Concat(System::Object ^ arg0, System::Object ^ arg1, System::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

Parameter

arg0
Object Object Object Object

Das erste zu verkettende Objekt.The first object to concatenate.

arg1
Object Object Object Object

Das zweite zu verkettende Objekt.The second object to concatenate.

arg2
Object Object Object Object

Das dritte zu verkettende Objekt.The third object to concatenate.

Gibt zurück

Die verketteten Zeichenfolgendarstellungen der Werte von arg0, arg1 und arg2.The concatenated string representations of the values of arg0, arg1, and arg2.

Beispiele

Das folgende Beispiel veranschaulicht die Concat Methode.The following example demonstrates the Concat method.

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
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

Hinweise

Die-Methode verkettet arg0, arg1und, arg2 indem die Parameter lose ToString -Methode der einzelnen-Objekte aufgerufen wird. Sie fügt keine Trennzeichen hinzu.The method concatenates arg0, arg1, and arg2 by calling the parameterless ToString method of each object; it does not add any delimiters.

String.Emptywird anstelle von NULL-Argumenten verwendet.String.Empty is used in place of any null argument.

Siehe auch

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

Verkettet die Zeichenfolgendarstellungen zweier angegebener Objekte.Concatenates the string representations of two specified objects.

public:
 static System::String ^ Concat(System::Object ^ arg0, System::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

Parameter

arg0
Object Object Object Object

Das erste zu verkettende Objekt.The first object to concatenate.

arg1
Object Object Object Object

Das zweite zu verkettende Objekt.The second object to concatenate.

Gibt zurück

Die verketteten Zeichenfolgendarstellungen der Werte von arg0 und arg1.The concatenated string representations of the values of arg0 and arg1.

Beispiele

Das folgende Beispiel veranschaulicht die Concat Methode.The following example demonstrates the Concat method.

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
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

Hinweise

Die arg0 -Methode verkettet und arg1 durch Aufrufen der Parameter losen ToString -Methode von arg0 und arg1. Sie fügt keine Trennzeichen hinzu.The method concatenates arg0 and arg1 by calling the parameterless ToString method of arg0 and arg1; it does not add any delimiters.

String.Emptywird anstelle von NULL-Argumenten verwendet.String.Empty is used in place of any null argument.

Wenn eines der Argumente ein Array Verweis ist, verkettet die Methode eine Zeichenfolge, die dieses Array anstelle der zugehörigen Member (z. b. "System. String []") darstellt.If either of the arguments is an array reference, the method concatenates a string representing that array, instead of its members (for example, "System.String[]").

Siehe auch

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

Wichtig

Diese API ist nicht CLS-kompatibel.

Verkettet die Elemente eines angegebenen String-Arrays.Concatenates the elements of a specified String array.

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

Parameter

values
String[]

Ein Array von Zeichenfolgeninstanzen.An array of string instances.

Gibt zurück

Die verketteten Elemente von values.The concatenated elements of values.

Ausnahmen

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung Concat der-Methode mit einem String -Array.The following example demonstrates the use of the Concat method with a String array.

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
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

Hinweise

Die-Methode verkettet jedes Objekt in values. es fügt keine Trennzeichen hinzu.The method concatenates each object in values; it does not add any delimiters.

Anstelle Empty von Null-Objekten im Array wird eine Zeichenfolge verwendet.An Empty string is used in place of any null object in the array.

Siehe auch

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

Verkettet die Zeichenfolgendarstellungen der Elemente in einem angegebenen Object-Array.Concatenates the string representations of the elements in a specified Object array.

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

Parameter

args
Object[]

Ein Objektarray, das die zu verkettenden Elemente enthält.An object array that contains the elements to concatenate.

Gibt zurück

Die verketteten Zeichenfolgendarstellungen der Werte der Elemente in args.The concatenated string representations of the values of the elements in args.

Ausnahmen

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung Concat der-Methode mit einem Object -Array.The following example demonstrates the use of the Concat method with an Object array.

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
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 'Main
End Class 'ConcatTest


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

Class Test2
End Class 'Test2

Hinweise

Die-Methode verkettet jedes Objekt in args , indem die Parameter lose ToString -Methode dieses Objekts aufgerufen wird. es fügt keine Trennzeichen hinzu.The method concatenates each object in args by calling the parameterless ToString method of that object; it does not add any delimiters.

String.Emptywird anstelle eines NULL-Objekts im-Array verwendet.String.Empty is used in place of any null object in the array.

Hinweise für Aufrufer

Diese Methode wird nicht von C++ Code aufgerufen.This method is not called by C++ code. Der C++ Compiler löst Aufrufe von Concat auf, die vier oder mehr Objekt Parameter als Aufruf von Concat(Object, Object, Object, Object)haben.The C++ compiler resolves calls to Concat that have four or more object parameters as a call to Concat(Object, Object, Object, Object).

Siehe auch

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

Erstellt die Zeichenfolgendarstellung eines angegebenen Objekts.Creates the string representation of a specified object.

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

Parameter

arg0
Object Object Object Object

Das darzustellende Objekt oder null.The object to represent, or null.

Gibt zurück

Die Zeichenfolgendarstellung des Werts von arg0 oder Empty, wenn arg0 null ist.The string representation of the value of arg0, or Empty if arg0 is null.

Beispiele

Das folgende Beispiel veranschaulicht die Concat Methode.The following example demonstrates the Concat method.

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
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

Hinweise

Die Concat(Object) -Methode arg0 stellt eine Zeichenfolge dar, indem Sie die ToString Parameter lose-Methode aufrufen.The Concat(Object) method represents arg0 as a string by calling its parameterless ToString method.

Siehe auch

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String.Concatenates the members of a constructed IEnumerable<T> collection of type String.

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

Parameter

values
IEnumerable<String>

Ein Auflistungsobjekt, das IEnumerable<T> implementiert und dessen generisches Typargument String ist.A collection object that implements IEnumerable<T> and whose generic type argument is String.

Gibt zurück

Die verketteten Zeichenfolgen in values oder Empty, wenn values ein leeres IEnumerable(Of String) ist.The concatenated strings in values, or Empty if values is an empty IEnumerable(Of String).

Ausnahmen

Beispiele

Im folgenden Beispiel wird das Sieb des Eratosthenes-Algorithmus zum Berechnen der Primzahlen, die kleiner oder gleich 100 sind, verwendet.The following example uses the Sieve of Eratosthenes algorithm to calculate the prime numbers that are less than or equal to 100. Das Ergebnis wird einem List<T> -Objekt vom Typ Stringzugewiesen, das dann an die Concat(IEnumerable<String>) -Methode weitergeleitet wird.It assigns the result to a List<T> object of type String, which it then passes to the Concat(IEnumerable<String>) method.

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
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

Hinweise

Die-Methode verkettet jedes Objekt in values. es fügt keine Trennzeichen hinzu.The method concatenates each object in values; it does not add any delimiters. Um ein Trennzeichen zwischen den einzelnen Membern von valuesanzugeben, wird Join(String, IEnumerable<String>) die-Methode aufgerufen.To specify a delimiter between each member of values, call the Join(String, IEnumerable<String>) method.

Eine Empty Zeichenfolge wird anstelle eines beliebigen null-Elements in valuesverwendet.An Empty string is used in place of any null element in values.

Wenn values ein leeres IEnumerable(Of String)ist, gibt die Methode String.Emptyzurückgegeben.If values is an empty IEnumerable(Of String), the method returns String.Empty. Wenn values ArgumentNullException ist null, löst die Methode eine Ausnahme aus.If values is null, the method throws an ArgumentNullException exception.

Concat(IEnumerable<String>)ist eine Hilfsmethode, mit der Sie jedes Element in einer IEnumerable(Of String) Auflistung verketten können, ohne zuvor die Elemente in ein Zeichen folgen Array umzuwandeln.Concat(IEnumerable<String>) is a convenience method that lets you concatenate each element in an IEnumerable(Of String) collection without first converting the elements to a string array. Dies ist besonders nützlich bei LINQ-Abfrage Ausdrücken (Language-Integrated Query).It is particularly useful with Language-Integrated Query (LINQ) query expressions. Im folgenden Beispiel wird ein List(Of String) -Objekt, das entweder die Groß-oder Kleinbuchstaben des Alphabets enthält, an einen Lambda-Ausdruck weitergeleitet, der Buchstaben auswählt, die gleich oder größer als ein bestimmter Buchstabe (im Beispiel "M") sind.The following example passes a List(Of String) object that contains either the uppercase or lowercase letters of the alphabet to a lambda expression that selects letters that are equal to or greater than a particular letter (which, in the example, is "M"). Die IEnumerable(Of String) Auflistung, die von der Enumerable.Where -Methode zurückgegeben wird, Concat(IEnumerable<String>) wird an die-Methode übermittelt, um das Ergebnis als eine einzelne Zeichenfolge anzuzeigen.The IEnumerable(Of String) collection that is returned by the Enumerable.Where method is passed to the Concat(IEnumerable<String>) method to display the result as a single string.

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(Convert.ToChar(charValue + ctr).ToString());
      return alphabet; 
   }
}
// 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

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

Verkettet die Zeichenfolgendarstellung von zwei angegebenen schreibgeschützten Zeichenspannen.Concatenates the string representations of two specified read-only character spans.

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

Parameter

str0
ReadOnlySpan<Char>

Die erste zu verkettende schreibgeschützte Zeichenspanne.The first read-only character span to concatenate.

str1
ReadOnlySpan<Char>

Die zweite zu verkettende schreibgeschützte Zeichenspanne.The second read-only character span to concatenate.

Gibt zurück

Die verketteten Zeichenfolgendarstellungen der Werte von str0 und str1.The concatenated string representations of the values of str0 and str1.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

Verkettet die Member einer IEnumerable<T>-Implementierung.Concatenates the members of an IEnumerable<T> implementation.

public:
generic <typename T>
 static System::String ^ Concat(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
Public Shared Function Concat(Of T) (values As IEnumerable(Of T)) As String

Typparameter

T

Der Typ der Member von values.The type of the members of values.

Parameter

values
IEnumerable<T> IEnumerable<T> IEnumerable<T> IEnumerable<T>

Ein Auflistungsobjekt, das die IEnumerable<T>-Schnittstelle implementiert.A collection object that implements the IEnumerable<T> interface.

Gibt zurück

Die verketteten Zeichenfolgen in values.The concatenated members in values.

Ausnahmen

Beispiele

Im folgenden Beispiel wird eine sehr einfache Animal Klasse definiert, die den Namen eines Tieres und die Reihenfolge enthält, zu der er gehört.The following example defines a very simple Animal class that contains the name of an animal and the order to which it belongs. Anschließend wird ein List<T> -Objekt definiert, das eine Reihe Animal von-Objekten enthalten soll.It then defines a List<T> object to contain a number of Animal objects. Die Enumerable.Where -Erweiterungsmethode wird aufgerufen, um Animal die Objekte Order zu extrahieren, deren-Eigenschaft "Rodent" entspricht.The Enumerable.Where extension method is called to extract the Animal objects whose Order property equals "Rodent". Das Ergebnis wird an die Concat<T>(IEnumerable<T>) -Methode übermittelt und in der Konsole angezeigt.The result is passed to the Concat<T>(IEnumerable<T>) method and displayed to the 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
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

Hinweise

Die-Methode verkettet jedes Objekt in values. es fügt keine Trennzeichen hinzu.The method concatenates each object in values; it does not add any delimiters.

Anstelle Empty eines NULL-Arguments wird eine Zeichenfolge verwendet.An Empty string is used in place of any null argument.

Concat<T>(IEnumerable<T>)ist eine Hilfsmethode, mit der Sie jedes Element in einer IEnumerable<T> Auflistung verketten können, ohne dass die Elemente zuvor in Zeichen folgen umgerechnet werden.Concat<T>(IEnumerable<T>) is a convenience method that lets you concatenate each element in an IEnumerable<T> collection without first converting the elements to strings. Dies ist besonders nützlich mit LINQ-Abfrage Ausdrücken (Language-Integrated Query), wie im Beispiel veranschaulicht.It is particularly useful with Language-Integrated Query (LINQ) query expressions, as the example illustrates. Die Zeichen folgen Darstellung der einzelnen Objekte in IEnumerable<T> der Auflistung wird durch Aufrufen der- ToString Methode dieses Objekts abgeleitet.The string representation of each object in the IEnumerable<T> collection is derived by calling that object's ToString method.

Gilt für: