String.Concat Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zřetězí jednu nebo více instancí Stringnebo String reprezentaci hodnot jedné nebo více instancí Object.

Přetížení

Name	Description
Concat(String, String, String, String)	Zřetězí čtyři zadané instance String.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Zřetězí řetězcové reprezentace čtyř zadaných znaků jen pro čtení.
Concat(String, String, String)	Zřetězí tři zadané instance String.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Zřetězí řetězcové reprezentace tří zadaných znaků jen pro čtení.
Concat(Object, Object, Object)	Zřetězí řetězcové reprezentace tří zadaných objektů.
Concat(String, String)	Zřetězí dvě zadané instance String.
Concat(ReadOnlySpan<Object>)	Zřetězí řetězcové reprezentace prvků v zadaném rozsahu objektů.
Concat(Object, Object)	Zřetězí řetězcové reprezentace dvou zadaných objektů.
Concat(String[])	Zřetězí prvky zadaného String pole.
Concat(ReadOnlySpan<String>)	Zřetězí prvky zadaného rozsahu String.
Concat(Object[])	Zřetězí řetězcové reprezentace prvků v zadaném Object poli.
Concat(Object)	Vytvoří řetězcovou reprezentaci zadaného objektu.
Concat(IEnumerable<String>)	Zřetězí členy vytvořené IEnumerable<T> kolekce typu String.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Zřetězí řetězcové reprezentace dvou zadaných znaků jen pro čtení.
Concat<T>(IEnumerable<T>)	Zřetězí členy IEnumerable<T> implementace.

Poznámky

Poznámka

Ke zřetězení řetězců můžete použít také operátor zřetězení řetězců jazyka, například + v jazyce C# a F# nebo & v + jazyce Visual Basic. Oba kompilátory překládají operátor zřetězení do volání jednoho z přetížení String.Concat.

Concat(String, String, String, String)

Zdroj:

String.Manipulation.cs

Zřetězí čtyři zadané instance 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

Parametry

str0

String

První řetězec ke zřetězení.

str1

String

Druhý řetězec ke zřetězení.

str2

String

Třetí řetězec ke zřetězení.

str3

String

Čtvrtý řetězec ke zřetězení.

Návraty

String

Zřetězení str0, str1, str2a str3.

Příklady

Následující příklad definuje pole čtyřmísmenných slov a ukládá jejich jednotlivá písmena do pole řetězců, aby je bylo možné zakódovat. Potom volá metodu Concat(String, String, String, String) , která znovu sestaví zakódovaná slova.

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

Poznámky

Metoda zřetězí , str1, str2a str3; nepřidá str0žádné oddělovače.

Viz také

• Join(String, String[])

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

Zdroj:

String.Manipulation.cs

Zřetězí řetězcové reprezentace čtyř zadaných znaků jen pro čtení.

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

Parametry

str0

ReadOnlySpan<Char>

První rozsah znaků jen pro čtení, který se zřetědí.

str1

ReadOnlySpan<Char>

Druhý rozsah znaků jen pro čtení ke zřetězení.

str2

ReadOnlySpan<Char>

Třetí znak jen pro čtení, který se zřetědí.

str3

ReadOnlySpan<Char>

Čtvrtý rozsah znaků jen pro čtení ke zřetězení.

Návraty

String

Zřetězené řetězcové reprezentace hodnot str0, str1str2 a str3.

Concat(String, String, String)

Zdroj:

String.Manipulation.cs

Zřetězí tři zadané instance 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

Parametry

str0

String

První řetězec ke zřetězení.

str1

String

Druhý řetězec ke zřetězení.

str2

String

Třetí řetězec ke zřetězení.

Návraty

String

Zřetězení zřetězení str0, str1a str2.

Příklady

Následující příklad používá metodu Concat zřetězení tří řetězců a zobrazí výsledek.

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.

Poznámky

Metoda zřetězí , str1a str2; nepřidá str0žádné oddělovače.

Viz také

• Join(String, String[])

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

Zdroj:

String.Manipulation.cs

Zřetězí řetězcové reprezentace tří zadaných znaků jen pro čtení.

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

Parametry

str0

ReadOnlySpan<Char>

První rozsah znaků jen pro čtení, který se zřetědí.

str1

ReadOnlySpan<Char>

Druhý rozsah znaků jen pro čtení ke zřetězení.

str2

ReadOnlySpan<Char>

Třetí znak jen pro čtení, který se zřetědí.

Návraty

String

Zřetězené řetězcové reprezentace hodnot str0str1 a str2.

Concat(Object, Object, Object)

Zdroj:

String.Manipulation.cs

Zřetězí řetězcové reprezentace tří zadaných objektů.

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

Parametry

arg0

Object

První objekt, který se má zřetězení.

arg1

Object

Druhý objekt ke zřetězení.

arg2

Object

Třetí objekt ke zřetězení.

Návraty

String

Zřetězené řetězcové reprezentace hodnot arg0, arg1a arg2.

Příklady

Následující příklad ukazuje metodu Concat .

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

Poznámky

Metoda zřetězí arg0a arg1arg2 zavolá metodu bez ToString parametrů každého objektu; nepřidá žádné oddělovače.

String.Empty se používá místo jakéhokoli argumentu null.

Viz také

• Object
• Join(String, String[])

Concat(String, String)

Zdroj:

String.Manipulation.cs

Zřetězí dvě zadané instance 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

Parametry

str0

String

První řetězec ke zřetězení.

str1

String

Druhý řetězec ke zřetězení.

Návraty

String

Zřetězení str0 a str1.

Příklady

Následující příklad zřetězí jméno, prostřední jméno a příjmení osoby.

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

Poznámky

Metoda zřetězí a str1; nepřidá str0 žádné oddělovače.

Řetězec Empty se používá místo jakéhokoli argumentu null.

Viz také

• Join(String, String[])

Concat(ReadOnlySpan<Object>)

Zdroj:

String.Manipulation.cs

Zřetězí řetězcové reprezentace prvků v zadaném rozsahu objektů.

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

Parametry

args

ReadOnlySpan<Object>

Rozsah objektů, které obsahují prvky ke zřetězení.

Návraty

String

Zřetězené řetězcové reprezentace hodnot prvků v args.

Concat(Object, Object)

Zdroj:

String.Manipulation.cs

Zřetězí řetězcové reprezentace dvou zadaných objektů.

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

Parametry

arg0

Object

První objekt, který se má zřetězení.

arg1

Object

Druhý objekt ke zřetězení.

Návraty

String

Zřetězené řetězcové reprezentace hodnot arg0 a arg1.

Příklady

Následující příklad ukazuje metodu Concat .

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

Poznámky

Metoda zřetězí arg0 a arg1 zavolá metodu arg0 bez ToString parametrů a arg1nepřidá žádné oddělovače.

String.Empty se používá místo jakéhokoli argumentu null.

Pokud je některý z argumentů odkazem na pole, metoda zřetězí řetězec představující toto pole místo jeho členů (například "System.String[]").

Viz také

• Object
• Join(String, String[])

Concat(String[])

Zdroj:

String.Manipulation.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Zřetězí prvky zadaného String pole.

public:
 static System::String ^ Concat(... cli::array <System::String ^> ^ values);

public static string Concat(params string?[] values);

static member Concat : string[] -> string

Public Shared Function Concat (ParamArray values As String()) As String

Parametry

values

String[]

Pole instancí řetězců.

Návraty

String

Zřetězené prvky .values

Výjimky

ArgumentNullException

values je null.

OutOfMemoryException

Nedostatek paměti.

Příklady

Následující příklad ukazuje použití Concat metody s polem String .

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

Poznámky

Metoda zřetězí každý objekt v values; nepřidá žádné oddělovače.

Řetězec Empty se používá místo jakéhokoli objektu null v poli.

Viz také

• Join(String, String[])

Concat(ReadOnlySpan<String>)

Zdroj:

String.Manipulation.cs

Zřetězí prvky zadaného rozsahu 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

Parametry

values

ReadOnlySpan<String>

Rozsah String instancí.

Návraty

String

Zřetězené prvky .values

Concat(Object[])

Zdroj:

String.Manipulation.cs

Zřetězí řetězcové reprezentace prvků v zadaném Object poli.

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

Parametry

args

Object[]

Pole objektů, které obsahuje prvky ke zřetězení.

Návraty

String

Zřetězené řetězcové reprezentace hodnot prvků v args.

Výjimky

ArgumentNullException

args je null.

OutOfMemoryException

Nedostatek paměti.

Příklady

Následující příklad ukazuje použití Concat metody s polem 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

Poznámky

Metoda zřetězí každý objekt args voláním metody bez ToString parametrů tohoto objektu; nepřidá žádné oddělovače.

String.Empty se používá místo jakéhokoli objektu null v poli.

Poznámky pro volající

Tato metoda není volána kódem jazyka C++. Kompilátor jazyka C++ překládá volání, která Concat mají čtyři nebo více parametrů objektu jako volání Concat(Object, Object, Object, Object).

Viz také

• Object
• Join(String, String[])

Concat(Object)

Zdroj:

String.Manipulation.cs

Vytvoří řetězcovou reprezentaci zadaného objektu.

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

Parametry

arg0

Object

Objekt, který má představovat, nebo null.

Návraty

String

Řetězcová reprezentace hodnoty , nebo Empty je-li arg0null.arg0

Příklady

Následující příklad ukazuje metodu Concat .

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

Poznámky

Metoda Concat(Object) představuje arg0 jako řetězec voláním jeho bezparametrové ToString metody.

Viz také

• Object
• Join(String, String[])

Concat(IEnumerable<String>)

Zdroj:

String.Manipulation.cs

Zřetězí členy vytvořené IEnumerable<T> kolekce typu String.

public:
 static System::String ^ Concat(System::Collections::Generic::IEnumerable<System::String ^> ^ values);

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

Parametry

values

IEnumerable<String>

Objekt kolekce, který implementuje IEnumerable<T> a jehož obecný typ argument je String.

Návraty

String

Zřetězené řetězce v values, nebo Empty je-li values prázdný IEnumerable(Of String).

Výjimky

ArgumentNullException

values je null.

Příklady

Následující příklad používá algoritmus Sieve of Eratosthenes k výpočtu prvočísla, která jsou menší nebo rovna 100. Přiřadí výsledek objektu List<T> typu String, který pak předá metodě 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

Poznámky

Metoda zřetězí každý objekt v values; nepřidá žádné oddělovače. Chcete-li zadat oddělovač mezi jednotlivými členy values, zavolejte metodu Join(String, IEnumerable<String>) .

Řetězec Empty se používá místo jakéhokoli prvku null v values.

Pokud values je prázdná IEnumerable(Of String), metoda vrátí String.Empty. Pokud values je null, metoda vyvolá ArgumentNullException výjimku.

Concat(IEnumerable<String>) je metoda usnadnění, která umožňuje zřetězení každého prvku v IEnumerable(Of String) kolekci, aniž byste nejprve převáděli prvky na pole řetězců. Je zvlášť užitečné s výrazy dotazu Language-Integrated Query (LINQ). Následující příklad předá List(Of String) objekt, který obsahuje buď velká nebo malá písmena abecedy výraz lambda, který vybere písmena, která jsou rovna nebo větší než konkrétní písmeno (což je v příkladu "M"). Kolekce IEnumerable(Of String) vrácená metodou Enumerable.Where je předána Concat(IEnumerable<String>) metodě k zobrazení výsledku jako jeden řetězec.

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

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

Zdroj:

String.Manipulation.cs

Zřetězí řetězcové reprezentace dvou zadaných znaků jen pro čtení.

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

Parametry

str0

ReadOnlySpan<Char>

První rozsah znaků jen pro čtení, který se zřetědí.

str1

ReadOnlySpan<Char>

Druhý rozsah znaků jen pro čtení ke zřetězení.

Návraty

String

Zřetězené řetězcové reprezentace hodnot str0 a str1.

Concat<T>(IEnumerable<T>)

Zdroj:

String.Manipulation.cs

Zřetězí členy IEnumerable<T> implementace.

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

static member Concat : seq<'T> -> string

Public Shared Function Concat(Of T) (values As IEnumerable(Of T)) As String

Parametry typu

T

Typ členů .values

Parametry

values

IEnumerable<T>

Objekt kolekce, který implementuje IEnumerable<T> rozhraní.

Návraty

String

Zřetězené členy v values.

Výjimky

ArgumentNullException

values je null.

Příklady

Následující příklad definuje velmi jednoduchou Animal třídu, která obsahuje název zvířete a pořadí, do kterého patří. Potom definuje List<T> objekt, který bude obsahovat určitý počet Animal objektů. Rozšiřující Enumerable.Where metoda je volána k extrakci Animal objektů, jejichž Order vlastnost se rovná "Hlásek". Výsledek se předá Concat<T>(IEnumerable<T>) metodě a zobrazí se konzole.

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

Poznámky

Metoda zřetězí každý objekt v values; nepřidá žádné oddělovače.

Řetězec Empty se používá místo jakéhokoli argumentu null.

Concat<T>(IEnumerable<T>) je metoda usnadnění, která umožňuje zřetězení jednotlivých prvků v IEnumerable<T> kolekci, aniž byste nejprve převáděli prvky na řetězce. Je zvlášť užitečná s výrazy dotazu Language-Integrated Query (LINQ), jak je znázorněno v příkladu. Řetězcová reprezentace každého objektu v kolekci IEnumerable<T> je odvozena voláním této metody objektu ToString .