Splitting a string into chunks of a certain size

Question

Suppose I had a string   string str    1111222233334444      How can I break this string into chunks of some size   e g    breaking this into sizes of 4 would return strings    1111   2222   3333   4444

User · Answer

Best   Easiest and Generic Answer          string originalString    1111222233334444       List lt string gt  test   new List lt string gt         int chunkSize   4     change 4 with the size of strings you want      for  int i   0  i  lt  originalString Length  i   i   chunkSize                if  originalString Length - i  gt   chunkSize              test Add originalString Substring i  chunkSize            else             test Add originalString Substring i   originalString Length - i

User · Answer

static List lt string gt  GetChunks string value  int chunkLength        var res   new List lt string gt         int count    value Length   chunkLength     value Length   chunkLength  gt  0   1   0       Enumerable Range 0  count  ToList   ForEach f   gt  res Add value Skip f   chunkLength  Take chunkLength  Select z   gt  z ToString    Aggregate  a b    gt  a b         return res      demo

User · Answer

Personally I prefer my solution  -   It handles    String lengths that are a multiple of the chunk size  String lengths that are NOT a multiple of the chunk size  String lengths that are smaller than the chunk size  NULL and empty strings  throws an exception   Chunk sizes smaller than 1  throws an exception     It is implemented as a extension method  and it calculates the number of chunks is going to generate beforehand  It checks the last chunk because in case the text length is not a multiple it needs to be shorter  Clean  short  easy to understand    and works       public static string   Split this string value  int chunkSize                if  string IsNullOrEmpty value   throw new ArgumentException  The string cannot be null             if  chunkSize  lt  1  throw new ArgumentException  The chunk size should be equal or greater than one              int remainder          int divResult   Math DivRem value Length  chunkSize  out remainder            int numberOfChunks   remainder  gt  0   divResult   1   divResult          var result   new string numberOfChunks            int i   0          while  i  lt  numberOfChunks - 1                        result i    value Substring i   chunkSize  chunkSize               i                       int lastChunkSize   remainder  gt  0   remainder   chunkSize          result i    value Substring i   chunkSize  lastChunkSize            return result

User · Answer

An important tip if the string that is being chunked needs to support all Unicode characters   If the string is to support international characters like   then split up the string using the System Globalization StringInfo class  Using StringInfo  you can split up the string based on number of text elements   string internationalString         The above string has a Length of 2  because the String Length property returns the number of Char objects in this instance  not the number of Unicode characters

User · Answer

This is based on  dove solution but implemented as an extension method    Benefits    Extension method Covers corner cases  Splits string with any chars  numbers  letters  other symbols   Code  public static class EnumerableEx           public static IEnumerable lt string gt  SplitBy this string str  int chunkLength                if  String IsNullOrEmpty str   throw new ArgumentException            if  chunkLength  lt  1  throw new ArgumentException             for  int i   0  i  lt  str Length  i    chunkLength                        if  chunkLength   i  gt  str Length                  chunkLength   str Length - i               yield return str Substring i  chunkLength                       Usage  var result    bobjoecat  SplitBy 3      bob  joe  cat   Unit tests removed for brevity  see previous revision

User · Answer

Simple and short      this means match a space or not a space  anything  up to 4 characters var lines   Regex Matches str      s S  0 4    Cast lt Match gt    Select x   gt  x Value

User · Answer

Based around other posters answers  along with some samples of useage   public static string FormatSortCode string sortCode        return ChunkString sortCode  2   -      public static string FormatIBAN string iban        return ChunkString iban  4    amp nbsp  amp nbsp        private static string ChunkString string str  int chunkSize  string separator        var b   new StringBuilder        var stringLength   str Length      for  var i   0  i  lt  stringLength  i    chunkSize                if  i   chunkSize  gt  stringLength  chunkSize   stringLength - i          b Append str Substring i  chunkSize            if  i chunkSize    stringLength              b Append separator             return b ToString

User · Answer

How s this for a one-liner   List lt string gt  result   new List lt string gt  Regex Split target       lt   G  4     RegexOptions Singleline      With this regex it doesn t matter if the last chunk is less than four characters  because it only ever looks at the characters behind it   I m sure this isn t the most efficient solution  but I just had to toss it out there

User · Answer

If necessary to split by few different length  For example you have date and time in specify format stringstrangeStr    07092016090532   07092016090532  Date 07 09 2016 Time  09 05 32   public static IEnumerable lt string gt  SplitBy this string str  int   chunkLength                if  String IsNullOrEmpty str   throw new ArgumentException            int i   0          for  int j   0  j  lt  chunkLength Length  j                          if  chunkLength j   lt  1  throw new ArgumentException                if  chunkLength j    i  gt  str Length                                chunkLength j    str Length - i                            yield return str Substring i  chunkLength j                i    chunkLength j                     using   string   dt   strangeStr SplitBy new int     2  2  4  2  2  2  2    ToArray

User · Answer

Modified  now it accepts any non null string and any positive chunkSize  Konstantin Spirin s solution   public static IEnumerable lt String gt  Split String value  int chunkSize      if  null    value      throw new ArgumentNullException  value      else if  chunkSize  lt   0      throw new ArgumentOutOfRangeException  chunkSize    Chunk size should be positive       return Enumerable      Range 0  value Length   chunkSize     value Length   chunkSize     0   0   1        Select index   gt   index   1    chunkSize  lt  value Length          value Substring index   chunkSize  chunkSize          value Substring index   chunkSize        Tests     String source     ABCDEF          ABCD EF    String test1   String Join      Split source  4          AB CD EF    String test2   String Join      Split source  2          ABCDEF    String test3   String Join      Split source  123

User · Answer

public static List lt string gt  DevideByStringLength string text  int chunkSize                double a    double text Length   chunkSize          var numberOfChunks   Math Ceiling a            Console WriteLine   quot  text Length     numberOfChunks  quot             List lt string gt  chunkList   new List lt string gt             for  int i   0  i  lt  numberOfChunks  i                          string subString   string Empty              if  i     numberOfChunks - 1                                 subString   text Substring chunkSize   i  text Length - chunkSize   i                   chunkList Add subString                   continue                            subString   text Substring chunkSize   i  chunkSize               chunkList Add subString                     return chunkList

User · Answer

This can be done in this way too          string actualString    1111222233334444           var listResult   new List lt string gt             int groupingLength   actualString Length   4          if  groupingLength  gt  0              listResult Add actualString Substring 0  groupingLength            for  int i   groupingLength  i  lt  actualString Length  i    4                        listResult Add actualString Substring i  4                       foreach var res in listResult                        Console WriteLine res                     Console Read

User · Answer

I ve slightly build up on Jo  o s solution  What I ve done differently is in my method you can actually specify whether you want to return the array with remaining characters or whether you want to truncate them if the end characters do not match your required chunk length  I think it s pretty flexible and the code is fairly straight forward   using System  using System Linq  using System Text RegularExpressions   namespace SplitFunction       class Program               static void Main string   args                        string text    hello  how are you doing today                string   chunks   SplitIntoChunks text  3 false               if  chunks    null                                chunks ToList   ForEach e   gt  Console WriteLine e                               Console ReadKey                       private static string   SplitIntoChunks string text  int chunkSize  bool truncateRemaining                        string chunk   chunkSize ToString                 string pattern   truncateRemaining          chunk            1     chunk                     string   chunks   null              if  chunkSize  gt  0  amp  amp   String IsNullOrEmpty text                   chunks    from Match m in Regex Matches text pattern select m Value  ToArray                  return chunks

User · Answer

I took this to another level   Chucking is an easy one liner  but in my case I needed whole words as well   Figured I would post it  just in case someone else needs something similar  static IEnumerable lt string gt  Split string orgString  int chunkSize  bool wholeWords   true        if  wholeWords                List lt string gt  result   new List lt string gt             StringBuilder sb   new StringBuilder             if  orgString Length  gt  chunkSize                        string   newSplit   orgString Split                   foreach  string str in newSplit                                if  sb Length    0                      sb Append  quot   quot                     if  sb Length   str Length  gt  chunkSize                                        result Add sb ToString                         sb Clear                                       sb Append str                              result Add sb ToString                       else             result Add orgString            return result            else         return new List lt string gt  Regex Split orgString    quot    lt   G   quot    chunkSize    quot    quot   RegexOptions Singleline       Results based on below comment  string msg    quot 336699AABBCCDDEEFF quot   foreach  string newMsg in Split msg  2  false         Console WriteLine   quot  gt  gt  newMsg  lt  lt  quot       Console ReadKey     Results   gt  gt 33 lt  lt   gt  gt 66 lt  lt   gt  gt 99 lt  lt   gt  gt AA lt  lt   gt  gt BB lt  lt   gt  gt CC lt  lt   gt  gt DD lt  lt   gt  gt EE lt  lt   gt  gt FF lt  lt   gt  gt  lt  lt   Another way to pull it  List lt string gt  splitData    List lt string gt  Split msg  2  false    for  int i   0  i  lt  splitData Count - 1  i          Console WriteLine   quot  gt  gt  splitData i   lt  lt  quot       Console ReadKey     New Results   gt  gt 33 lt  lt   gt  gt 66 lt  lt   gt  gt 99 lt  lt   gt  gt AA lt  lt   gt  gt BB lt  lt   gt  gt CC lt  lt   gt  gt DD lt  lt   gt  gt EE lt  lt   gt  gt FF lt  lt

User · Answer

Using regular expressions and Linq   List lt string gt  groups    from Match m in Regex Matches str     d 4                           select m Value  ToList      I find this to be more readable  but it s just a personal opinion  It can also be a one-liner

User · Answer

Six years later o O   Just because      public static IEnumerable lt string gt  Split this string str  int chunkSize  bool remainingInFront                var count    int  Math Ceiling str Length  double  chunkSize           Func lt int  int gt  start   index   gt  remainingInFront   str Length -  count - index  chunkSize   index chunkSize          Func lt int  int gt  end   index   gt  Math Min str Length - Math Max start index   0   Math Min start index    chunkSize - Math Max start index   0   chunkSize            return Enumerable Range 0  count  Select i   gt  str Substring Math Max start i   0  end i             or      private static Func lt bool  int  int  int  int  int gt  start    remainingInFront  length  count  index  size    gt          remainingInFront   length -  count - index    size   index   size       private static Func lt bool  int  int  int  int  int  int gt  end    remainingInFront  length  count  index  size  start    gt          Math Min length - Math Max start  0   Math Min start   size - Math Max start  0   size         public static IEnumerable lt string gt  Split this string str  int chunkSize  bool remainingInFront                var count    int Math Ceiling str Length    double chunkSize           return Enumerable Range 0  count  Select i   gt  str Substring              Math Max start remainingInFront  str Length  count  i  chunkSize   0               end remainingInFront  str Length  count  i  chunkSize  start remainingInFront  str Length  count  i  chunkSize                       AFAIK all edge cases are handled   Console WriteLine string Join       abc  Split 2  false        ab c Console WriteLine string Join       abc  Split 2  true        a bc Console WriteLine string Join       a  Split 2  true        a Console WriteLine string Join       a  Split 2  false        a

User · Answer

public static List lt string gt  SplitByMaxLength this string str                List lt string gt  splitString   new List lt string gt              for  int index   0  index  lt  str Length  index    MaxLength                        splitString Add str Substring index  Math Min MaxLength  str Length - index                        return splitString

User · Answer

This should be much faster and more efficient than using LINQ or other approaches used here   public static IEnumerable lt string gt  Splice this string s  int spliceLength        if  s    null          throw new ArgumentNullException  s        if  spliceLength  lt  1          throw new ArgumentOutOfRangeException  spliceLength         if  s Length    0          yield break      var start   0      for  var end   spliceLength  end  lt  s Length  end    spliceLength                yield return s Substring start  spliceLength           start   end            yield return s Substring start

User · Answer

In a combination of dove Konstatin s answers     static IEnumerable lt string gt  WholeChunks string str  int chunkSize        for  int i   0  i  lt  str Length  i    chunkSize           yield return str Substring i  chunkSize       This will work for all strings that can be split into a whole number of chunks  and will throw an exception otherwise   If you want to support strings of any length you could use the following code   static IEnumerable lt string gt  ChunksUpto string str  int maxChunkSize        for  int i   0  i  lt  str Length  i    maxChunkSize           yield return str Substring i  Math Min maxChunkSize  str Length-i        However  the the OP explicitly stated he does not need this  it s somewhat longer and harder to read  slightly slower   In the spirit of KISS and YAGNI  I d go with the first option  it s probably the most efficient implementation possible  and it s very short  readable  and  importantly  throws an exception for nonconforming input

User · Answer

It s not pretty and it s not fast  but it works  it s a one-liner and it s LINQy   List lt string gt  a   text Select  c  i    gt  new   Char   c  Index   i    GroupBy o   gt  o Index   4  Select g   gt  new String g Select o   gt  o Char  ToArray     ToList

User · Answer

List lt string gt  SplitString int chunk  string input        List lt string gt  list   new List lt string gt         int cycles   input Length   chunk       if  input Length   chunk    0          cycles         for  int i   0  i  lt  cycles  i                  try                       list Add input Substring i   chunk  chunk                      catch                       list Add input Substring i   chunk                        return list

User · Answer

You can use morelinq by Jon Skeet  Use Batch like   string str    1111222233334444   int chunkSize   4  var chunks   str Batch chunkSize  Select r   gt  new String r ToArray        This will return 4 chunks for the string  1111222233334444   If the string length is less than or equal to the chunk size Batch will return the string as the only element of IEnumerable lt string gt   For output   foreach  var chunk in chunks        Console WriteLine chunk       and it will give   1111 2222 3333 4444

User · Answer

I know question is years old  but here is a Rx implementation  It handles the length   chunkSize    0 problem out of the box      public static IEnumerable lt string gt  Chunkify this string input  int size                        if size  lt  1                  throw new ArgumentException  size must be greater than 0                 return input ToCharArray                    ToObservable                    Buffer size                               Select x   gt  new string x ToArray                      ToEnumerable

User · Answer

I can t remember who gave me this  but it works great   I speed tested a number of ways to break Enumerable types into groups   The usage would just be like this     List lt string gt  Divided   Source3 Chunk 24  Select Piece   gt  string Concat lt char gt  Piece   ToList      The extention code would look like this      region Chunk Logic private class ChunkedEnumerable lt T gt    IEnumerable lt T gt        class ChildEnumerator   IEnumerator lt T gt                ChunkedEnumerable lt T gt  parent          int position          bool done   false          T current            public ChildEnumerator ChunkedEnumerable lt T gt  parent                        this parent   parent              position   -1              parent wrapper AddRef                       public T Current                       get                               if  position    -1    done                                        throw new InvalidOperationException                                      return current                                    public void Dispose                         if   done                                done   true                  parent wrapper RemoveRef                                     object System Collections IEnumerator Current                       get   return Current                       public bool MoveNext                         position                 if  position   1  gt  parent chunkSize                                done   true                             if   done                                done    parent wrapper Get position   parent start  out current                              return  done                      public void Reset                            per http   msdn microsoft com en-us library system collections ienumerator reset aspx             throw new NotSupportedException                         EnumeratorWrapper lt T gt  wrapper      int chunkSize      int start       public ChunkedEnumerable EnumeratorWrapper lt T gt  wrapper  int chunkSize  int start                this wrapper   wrapper          this chunkSize   chunkSize          this start   start             public IEnumerator lt T gt  GetEnumerator                 return new ChildEnumerator this              System Collections IEnumerator System Collections IEnumerable GetEnumerator                 return GetEnumerator             private class EnumeratorWrapper lt T gt        public EnumeratorWrapper IEnumerable lt T gt  source                SourceEumerable   source            IEnumerable lt T gt  SourceEumerable   get  set         Enumeration currentEnumeration       class Enumeration               public IEnumerator lt T gt  Source   get  set            public int Position   get  set            public bool AtEnd   get  set               public bool Get int pos  out T item                 if  currentEnumeration    null  amp  amp  currentEnumeration Position  gt  pos                        currentEnumeration Source Dispose                currentEnumeration   null                     if  currentEnumeration    null                        currentEnumeration   new Enumeration   Position   -1  Source   SourceEumerable GetEnumerator    AtEnd   false                       item   default T           if  currentEnumeration AtEnd                        return false                     while  currentEnumeration Position  lt  pos                        currentEnumeration AtEnd    currentEnumeration Source MoveNext                currentEnumeration Position                 if  currentEnumeration AtEnd                                return false                                    item   currentEnumeration Source Current           return true             int refs   0          needed for dispose semantics      public void AddRef                 refs               public void RemoveRef                 refs--          if  refs    0  amp  amp  currentEnumeration    null                        var copy   currentEnumeration              currentEnumeration   null              copy Source Dispose                           lt summary gt Speed Checked   Works Great  lt  summary gt  public static IEnumerable lt IEnumerable lt T gt  gt  Chunk lt T gt  this IEnumerable lt T gt  source  int chunksize        if  chunksize  lt  1  throw new InvalidOperationException         var wrapper   new EnumeratorWrapper lt T gt  source        int currentPos   0      T ignore      try               wrapper AddRef            while  wrapper Get currentPos  out ignore                         yield return new ChunkedEnumerable lt T gt  wrapper  chunksize  currentPos               currentPos    chunksize                      finally               wrapper RemoveRef             endregion

User · Answer

List lt string gt  chunks   new List lt string gt             var longString   new string  s   3000           var chunkLength   1273          var ratio    double longString Length   chunkLength          var countOfChunks   Convert ToByte Math Round ratio  MidpointRounding ToPositiveInfinity             for  byte i   0  i  lt  countOfChunks  i                          var remainingLength   longString Length - chunkLength   i              if  chunkLength  gt  remainingLength                  chunks Add longString Substring i   chunkLength  remainingLength                else                 chunks Add longString Substring i   chunkLength  chunkLength

User · Answer

Changed slightly to return parts whose size  not equal to chunkSize  public static IEnumerable lt string gt  Split this string str  int chunkSize                var splits   new List lt string gt             if  str Length  lt  chunkSize    chunkSize   str Length            splits AddRange Enumerable Range 0  str Length   chunkSize  Select i   gt  str Substring i   chunkSize  chunkSize             splits Add str Length   chunkSize  gt  0   str Substring  str Length   chunkSize    chunkSize  str Length -   str Length   chunkSize    chunkSize     string Empty           return  IEnumerable lt string gt  splits

User · Answer

Why not loops   Here s something that would do it quite well           string str    111122223333444455           int chunkSize   4          int stringLength   str Length          for  int i   0  i  lt  stringLength   i    chunkSize                        if  i   chunkSize  gt  stringLength  chunkSize   stringLength  - i              Console WriteLine str Substring i  chunkSize                       Console ReadLine      I don t know how you d deal with case where the string is not factor of 4  but not saying you re idea is not possible  just wondering the motivation for it if a simple for loop does it very well   Obviously the above could be cleaned and even put in as an extension method   Or as mentioned in comments  you know it s  4 then  str    1111222233334444   for  int i   0  i  lt  stringLength  i    chunkSize      Console WriteLine str Substring i  chunkSize

User · Answer

static IEnumerable lt string gt  Split string str  double chunkSize        return Enumerable Range 0   int  Math Ceiling str Length chunkSize           Select i   gt  new string str             Skip i    int chunkSize              Take  int chunkSize              ToArray          and another approach   using System  using System Collections Generic  using System Linq   public class Program       public static void Main                  var x    Hello World           foreach var i in x ChunkString 2   Console WriteLine i            public static class Ext      public static IEnumerable lt string gt  ChunkString this string val  int chunkSize           return val Select  x i    gt  new  Index   i  Value   x                      GroupBy x   gt  x Index chunkSize  x   gt  x Value                     Select x   gt  string Join    x

User · Answer

I think this is an straight forward answer   public static IEnumerable lt string gt  Split this string str  int chunkSize                if string IsNullOrEmpty str     chunkSize lt 1              throw new ArgumentException  String can not be null or empty and chunk size should be greater than zero             var chunkCount   str Length   chunkSize    str Length   chunkSize    0   1   0           for  var i   0  i  lt  chunkCount  i                          var startIndex   i   chunkSize              if  startIndex   chunkSize  gt   str Length                  yield return str Substring startIndex               else                 yield return str Substring startIndex  chunkSize                     And it covers edge cases

User · Answer

class StringHelper       static void Main string   args                string str    Hi my name is vikas bansal and my email id is bansal vks gmail com           int offSet   10           List lt string gt  chunks   chunkMyStr str  offSet            Console Read               static List lt string gt  chunkMyStr string str  int offSet                  List lt string gt  resultChunks   new List lt string gt              for  int i   0  i  lt  str Length  i    offSet                        string temp   str Substring i   str Length - i   gt  offSet   offSet    str Length - i                Console WriteLine temp               resultChunks Add temp                        return resultChunks

User · Answer

static IEnumerable lt string gt  Split string str  int chunkSize       IEnumerable lt string gt  retVal   Enumerable Range 0  str Length   chunkSize           Select i   gt  str Substring i   chunkSize  chunkSize       if  str Length   chunkSize  gt  0          retVal   retVal Append str Substring str Length   chunkSize   chunkSize  str Length   chunkSize        return retVal      It correctly handles input string length not divisible by chunkSize   Please note that additional code might be required to gracefully handle edge cases  null or empty input string  chunkSize    0

User · Answer

Using the Buffer extensions from the IX library       static IEnumerable lt string gt  Split  this string str  int chunkSize                 return str Buffer chunkSize  Select l   gt  String Concat l

User · Answer

public static IEnumerable lt IEnumerable lt T gt  gt  SplitEvery lt T gt  this IEnumerable lt T gt  values  int n        var ls   values Take n       var rs   values Skip n       return ls Any             Cons ls  SplitEvery rs  n              Enumerable Empty lt IEnumerable lt T gt  gt        public static IEnumerable lt T gt  Cons lt T gt  T x  IEnumerable lt T gt  xs        yield return x      foreach  var xi in xs          yield return xi

User · Answer

Here s my 2 cents    IEnumerable lt string gt  Split string str  int chunkSize           while   string IsNullOrWhiteSpace str                  var chunk   str Take chunkSize  ToArray            str   str Substring chunk Length           yield return new string chunk                 Split

User · Answer

static IEnumerable lt string gt  Split string str  int chunkSize        return Enumerable Range 0  str Length   chunkSize           Select i   gt  str Substring i   chunkSize  chunkSize        Please note that additional code might be required to gracefully handle edge cases  null or empty input string  chunkSize    0  input string length not divisible by chunkSize  etc    The original question doesn t specify any requirements for these edge cases and in real life the requirements might vary so they are out of scope of this answer

User · Answer

I recently had to write something that accomplishes this at work  so I thought I would post my solution to this problem  As an added bonus  the functionality of this solution provides a way to split the string in the opposite direction and it does correctly handle unicode characters as previously mentioned by Marvin Pinto above  So  here it is   using System  using Extensions   namespace TestCSharp       class Program               static void Main string   args                            string asciiStr    This is a string                string unicodeStr                             string   array1   asciiStr Split 4               string   array2   asciiStr Split -4                string   array3   asciiStr Split 7               string   array4   asciiStr Split -7                string   array5   unicodeStr Split 5               string   array6   unicodeStr Split -5                      namespace Extensions       public static class StringExtensions                    lt summary gt Returns a string array that contains the substrings in this string that are seperated a given fixed length  lt  summary gt               lt param name  s  gt This string object  lt  param gt               lt param name  length  gt Size of each substring                   lt para gt CASE  length  amp gt  0   RESULT  String is split from left to right  lt  para gt                   lt para gt CASE  length    0   RESULT  String is returned as the only entry in the array  lt  para gt                   lt para gt CASE  length  amp lt  0   RESULT  String is split from right to left  lt  para gt               lt  param gt               lt returns gt String array that has been split into substrings of equal length  lt  returns gt               lt example gt                   lt code gt                      string s    1234567890                       string   a   s Split 4      a       1234    5678    90                     lt  code gt               lt  example gt                      public static string   Split this string s  int length                        System Globalization StringInfo str   new System Globalization StringInfo s                int lengthAbs   Math Abs length                if  str    null    str LengthInTextElements    0    lengthAbs    0    str LengthInTextElements  lt   lengthAbs                  return new string     str ToString                   string   array   new string  str LengthInTextElements   lengthAbs    0   str LengthInTextElements   lengthAbs   str LengthInTextElements   lengthAbs    1                 if  length  gt  0                  for  int iStr   0  iArray   0  iStr  lt  str LengthInTextElements  amp  amp  iArray  lt  array Length  iStr    lengthAbs  iArray                        array iArray    str SubstringByTextElements iStr   str LengthInTextElements - iStr  lt  lengthAbs   str LengthInTextElements - iStr   lengthAbs                else    if  length  lt  0                  for  int iStr   str LengthInTextElements - 1  iArray   array Length - 1  iStr  gt   0  amp  amp  iArray  gt   0  iStr -  lengthAbs  iArray--                      array iArray    str SubstringByTextElements  iStr - lengthAbs  lt  0   0   iStr - lengthAbs   1    iStr - lengthAbs  lt  0   iStr   1   lengthAbs                 return array                      Also  here is an image link to the results of running this code  http   i imgur com 16Iih png

[c#] Splitting a string into chunks of a certain size

Examples related to c#

Examples related to string