Dividere la stringa in 512 blocchi di carbone

Question

Forse una domanda di base, ma diciamo che ho una stringa lunga 2000 caratteri, ho bisogno di dividere questa stringa in massimo 512 blocchi di caratteri ciascuno.

C'è un modo carino, come un ciclo o così per fare questo?

Answer 1

Qualcosa di simile a questo:

private IList<string> SplitIntoChunks(string text, int chunkSize) 
{ 
    List<string> chunks = new List<string>(); 
    int offset = 0; 
    while (offset < text.Length) 
    { 
     int size = Math.Min(chunkSize, text.Length - offset); 
     chunks.Add(text.Substring(offset, size)); 
     offset += size; 
    } 
    return chunks; 
} 

O semplicemente per iterare su:

private IEnumerable<string> SplitIntoChunks(string text, int chunkSize) 
{ 
    int offset = 0; 
    while (offset < text.Length) 
    { 
     int size = Math.Min(chunkSize, text.Length - offset); 
     yield return text.Substring(offset, size); 
     offset += size; 
    } 
} 

Si noti che questa si divide in pezzi di UTF-16 unità di codice, che non è proprio la stessa divisione in blocchi di punti di codice Unicode, che a loro volta potrebbero non essere la stessa cosa della suddivisione in blocchi di glifi.

Answer 2

static IEnumerable<string> Split(string str, int chunkSize)  
{ 
    int len = str.Length; 
    return Enumerable.Range(0, len/chunkSize).Select(i => str.Substring(i * chunkSize, chunkSize));  
} 

fonte: Splitting a string into chunks of a certain size

Answer 3

Qualcosa di simile?

Calculate eachLength = StringLength/WantedCharLength 
Then for (int i = 0; i < StringLength; i += eachLength) 
SubString (i, eachLength); 

Answer 4

oserò fornire una versione più LINQified della soluzione di Jon, sulla base del fatto che il tipo string implementa IEnumerable<char>:

private IList<string> SplitIntoChunks(string text, int chunkSize) 
{ 
    var chunks = new List<string>(); 
    int offset = 0; 
    while(offset < text.Length) { 
     chunks.Add(new string(text.Skip(offset).Take(chunkSize).ToArray())); 
     offset += chunkSize; 
    } 
    return chunks; 
} 

Answer 5

usando implementazione di Jon e la resa parola chiave.

IEnumerable<string> Chunks(string text, int chunkSize) 
{ 
    for (int offset = 0; offset < text.Length; offset += chunkSize) 
    { 
     int size = Math.Min(chunkSize, text.Length - offset); 
     yield return text.Substring(offset, size); 
    } 
} 

Answer 6

Anche se questa domanda nel frattempo ha una risposta accettata, ecco una versione breve con l'aiuto di espressioni regolari. I puristi potrebbero non piacergli (comprensibilmente) ma quando hai bisogno di una soluzione rapida e sei a portata di mano con le regex, questo può essere. Le prestazioni sono piuttosto buone, sorprendentemente:

string [] split = Regex.Split(yourString, @"(?<=\G.{512})"); 

Che cosa fa? Negativo look-backward e ricordando l'ultima posizione con \G. Otterrà anche l'ultimo bit, anche se non è divisibile per 512.

Answer 7

La maggior parte della risposta potrebbe avere lo stesso difetto. Dato un testo vuoto non daranno nulla. Noi (I) aspettiamo almeno di recuperare quella stringa vuota (lo stesso comportamento di una divisione su un char non nella stringa, che restituirà un elemento: quella stringa)

quindi dovremmo fare un ciclo almeno una volta tutti i tempi (in base al codice di Jon):

IEnumerable<string> SplitIntoChunks (string text, int chunkSize) 
{ 
    int offset = 0; 
    do 
    { 
     int size = Math.Min (chunkSize, text.Length - offset); 
     yield return text.Substring (offset, size); 
     offset += size; 
    } while (offset < text.Length); 
} 

o utilizzando un per (Edited: dopo aver giocato un po 'di più con questo, ho trovato un modo migliore per gestire il caso chunksize maggiore di testo):

IEnumerable<string> SplitIntoChunks (string text, int chunkSize) 
{ 
    if (text.Length <= chunkSize) 
     yield return text; 
    else 
    { 
     var chunkCount = text.Length/chunkSize; 
     var remainingSize = text.Length % chunkSize; 

     for (var offset = 0; offset < chunkCount; ++offset) 
      yield return text.Substring (offset * chunkSize, chunkSize); 

     // yield remaining text if any 
     if (remainingSize != 0) 
      yield return text.Substring (chunkCount * chunkSize, remainingSize); 
    } 
} 

che potrebbe essere utilizzato anche con il fai/while;)

Answer 8

metodo di estensione generico:

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

public static class IEnumerableExtensions 
{ 
    public static IEnumerable<IEnumerable<T>> SplitToChunks<T> (this IEnumerable<T> coll, int chunkSize) 
    { 
    int skipCount = 0; 
    while (coll.Skip (skipCount).Take (chunkSize) is IEnumerable<T> part && part.Any()) 
    { 
     skipCount += chunkSize; 
     yield return part; 
    } 
    } 
} 

class Program 
{ 
    static void Main (string[] args) 
    { 
    var col = Enumerable.Range(1,1<<10); 
    var chunks = col.SplitToChunks(8); 

    foreach (var c in chunks.Take (200)) 
    { 
     Console.WriteLine (string.Join (" ", c.Select (n => n.ToString ("X4")))); 
    } 

    Console.WriteLine(); 
    Console.WriteLine(); 

    "Split this text into parts that are fifteen characters in length, surrounding each part with single quotes and output each into the console on seperate lines." 
     .SplitToChunks (15) 
     .Select(p => $"'{string.Concat(p)}'") 
     .ToList() 
     .ForEach (p => Console.WriteLine (p)); 

    Console.ReadLine(); 
    } 
}