Číst v angličtině

Sdílet prostřednictvím

String.Concat Metoda

  • Reference

Definice

Obor názvů:
System
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

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

Přetížení

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(Object, Object, Object, Object)

Zřetězí řetězcové reprezentace čtyř zadaných objektů a všech objektů zadaných v seznamu volitelných parametrů délky proměnné.
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(Object)

Vytvoří řetězcovou reprezentaci zadaného objektu.
Concat(Object, Object)

Zřetězí řetězcové reprezentace dvou zadaných objektů.
Concat(String[])

Zřetězí prvky zadaného pole String.
Concat(ReadOnlySpan<String>)

Zřetězí prvky zadaného rozsahu String.
Concat(ReadOnlySpan<Object>)

Zřetězí řetězcové reprezentace prvků v zadaném rozsahu objektů.
Concat(Object[])

Zřetězí řetězcové reprezentace prvků v zadaném poli Object.
Concat(IEnumerable<String>)

Zřetězí členy vytvořené kolekce IEnumerable<T> 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ů ve Visual Basicu můžete použít také operátor zřetězení řetězců, například + v jazyce C# a F# nebo & a + 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
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

Zřetězí čtyři zadané instance String.

public static string Concat (string str0, string str1, string str2, string str3);
public static string Concat (string? str0, string? str1, string? str2, string? str3);

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), aby znovu sesestavila 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

Poznámky

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

Viz také

Platí pro

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

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat (ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3);

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, str1, str2 a str3.

Platí pro

Concat(Object, Object, Object, Object)

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Zřetězí řetězcové reprezentace čtyř zadaných objektů a všech objektů zadaných v seznamu volitelných parametrů délky proměnné.

[System.CLSCompliant(false)]
public static string Concat (object arg0, object arg1, object arg2, object arg3);

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

arg3
Object

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

Návraty

String

Zřetězená řetězcová reprezentace každé hodnoty v seznamu parametrů.

Atributy
CLSCompliantAttribute

Příklady

Následující příklad ukazuje použití metody Concat(Object, Object, Object, Object) ke zřetězení seznamu parametrů proměnné. V tomto případě je volána metoda s devíti parametry.

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

Poznámky

Poznámka

Toto rozhraní API nedodržuje předpisy CLS. Alternativou kompatibilní se specifikací CLS je String.Concat(Object[]). Kompilátory jazyka C# a Visual Basic automaticky přeloží volání této metody jako volání String.Concat(Object[]).

Metoda zřetězí každý objekt v seznamu parametrů voláním jeho bezparametrové ToString metoda; nepřidává žádné oddělovače.

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

Poznámka

Poslední parametr metody Concat je volitelný seznam s oddělovači jednoho nebo více dalších objektů ke zřetězení.

Poznámky pro volající

Tato metoda je označena klíčovým slovem vararg, což znamená, že podporuje proměnný počet parametrů. Metodu lze volat z jazyka Visual C++, ale nelze ji volat z kódu jazyka C# nebo Visual Basic. Kompilátory jazyka C# a Visual Basic přeloží volání Concat(Object, Object, Object, Object) jako volání Concat(Object[]).

Platí pro

Concat(String, String, String)

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

Zřetězí tři zadané instance String.

public static string Concat (string str0, string str1, string str2);
public static string Concat (string? str0, string? str1, string? str2);

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í str0, str1a str2.

Příklady

Následující příklad používá metodu Concat ke 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.

Poznámky

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

Viz také

Platí pro

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

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat (ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2);

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 str0, str1 a str2.

Platí pro

Concat(Object, Object, Object)

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat (object arg0, object arg1, object arg2);
public static string Concat (object? arg0, object? arg1, object? arg2);

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

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

Poznámky

Metoda zřetězí arg0, arg1a arg2 voláním bez parametrů ToString metody každého objektu; nepřidává žádné oddělovače.

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

Viz také

Platí pro

Concat(String, String)

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

Zřetězí dvě zadané instance String.

public static string Concat (string str0, string str1);
public static string Concat (string? str0, string? str1);

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

Poznámky

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

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

Viz také

Platí pro

Concat(Object)

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat (object arg0);
public static string Concat (object? arg0);

Parametry

arg0
Object

Objekt představující nebo null.

Návraty

String

Řetězcové vyjádření hodnoty arg0nebo Empty, pokud je arg0null.

Příklady

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

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

Poznámky

Metoda Concat(Object) představuje arg0 jako řetězec zavoláním metody bez parametrů ToString.

Viz také

Platí pro

Concat(Object, Object)

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat (object arg0, object arg1);
public static string Concat (object? arg0, object? arg1);

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

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

Poznámky

Metoda zřetězí arg0 a arg1 voláním metody ToStringarg0 a arg1bez parametrů; nepřidává žá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é

Platí pro

Concat(String[])

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

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

public static string Concat (params string[] values);
public static string Concat (params string?[] values);
[System.CLSCompliant(false)]
public static string Concat (params string[] values);

Parametry

values
String[]

Pole instancí řetězců.

Návraty

String

Zřetězené prvky values.

Atributy
CLSCompliantAttribute

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

Poznámky

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

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

Viz také

Platí pro

Concat(ReadOnlySpan<String>)

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

public static string Concat (scoped ReadOnlySpan<string?> values);

Parametry

values
ReadOnlySpan<String>

Rozsah String instancí.

Návraty

String

Zřetězené prvky values.

Platí pro

Concat(ReadOnlySpan<Object>)

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

public static string Concat (scoped ReadOnlySpan<object?> args);

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.

Platí pro

Concat(Object[])

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat (params object[] args);
public static string Concat (params object?[] args);

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 metoda s Object pole.

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

Poznámky

Metoda zřetězí každý objekt v args voláním bez parametrů ToString metody tohoto objektu; nepřidává žá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í Concat, které mají čtyři nebo více parametrů objektu jako volání Concat(Object, Object, Object, Object).

Viz také

Platí pro

Concat(IEnumerable<String>)

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat (System.Collections.Generic.IEnumerable<string> values);
public static string Concat (System.Collections.Generic.IEnumerable<string?> values);
[System.Runtime.InteropServices.ComVisible(false)]
public static string Concat (System.Collections.Generic.IEnumerable<string> values);

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 valuesnebo Empty, pokud je values prázdným IEnumerable(Of String).

Atributy
ComVisibleAttribute

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 List<T> objektu typu String, který pak předá Concat(IEnumerable<String>) metodě.

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

Poznámky

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

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

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

Concat(IEnumerable<String>) je pohodlná metoda, která umožňuje zřetězení jednotlivých prvků v kolekci IEnumerable(Of String), 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á objekt List(Of String), který obsahuje velká nebo malá písmena abecedy výrazu 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 se předá metodě Concat(IEnumerable<String>), aby se výsledek zobrazil jako jediný ř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

Platí pro

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

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat (ReadOnlySpan<char> str0, ReadOnlySpan<char> str1);

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.

Platí pro

Concat<T>(IEnumerable<T>)

Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs
Zdroj:
String.Manipulation.cs

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

public static string Concat<T> (System.Collections.Generic.IEnumerable<T> values);
[System.Runtime.InteropServices.ComVisible(false)]
public static string Concat<T> (System.Collections.Generic.IEnumerable<T> values);

Parametry typu

T

Typ členů values.

Parametry

values
IEnumerable<T>

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

Návraty

String

Zřetězené členy v values.

Atributy
ComVisibleAttribute

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 řadu Animal objektů. Metoda rozšíření Enumerable.Where je volána k extrakci Animal objektů, jejichž Order vlastnost se rovná "Hlásek". Výsledek se předá metodě Concat<T>(IEnumerable<T>) 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

Poznámky

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

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

Concat<T>(IEnumerable<T>) je pohodlná metoda, která umožňuje zřetězení jednotlivých prvků v kolekci IEnumerable<T> bez prvního převodu prvků 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 ToString metody tohoto objektu.

Platí pro