// Generically represents an indexed character array with length, 
// and does so without causing later garbage collection
struct TextBlock
{
    // internally can be either a string, a StringBuilder, 
    // a character array, or a reference to a custom buffer 
    // implementation via a particular interface */
    public TextBlock(string s);
    public TextBlock(string s, int startIndex, int length);
    public TextBlock(StringBuilder sb);
    public TextBlock(StringBuilder sb, int startIndex, int length);    
    public TextBlock(...);  // (other constructors here)

    // get the length of the substring, or the whole string if 
    // there's no substring
    public int Length { get; }

    // get the character at a given index in the substring, 
    // or in the whole string if there's no substring
    public char this[int index] { get; }
}

string s = "Hello, world...";
DrawString(new TextBlock(s),...); // print "Hello, world..."
DrawString(new TextBlock(s,0,5),...); // print "Hello"

  public class WrappedText
  {
    /// <summary>
    /// A WordType is assigned to each processed word for efficiently determining what action to take in the wrapping routine.
    /// </summary>
    private enum WordType
    {
      Normal    = 0,  //add word width to current line, test new line width; success, move to next word; failure, start new line
      WhiteSpace  = 1,  //add width of space/tab to current line, move to next word (no tests necessary, as white space characters are allowed to overhang lines)
      LineBreak  = 2,  //start new line immediately
    }

    /// <summary>
    /// Stores information about processed words.
    /// For the purpose of line breaking, a 'Word' is clearly defined as any group of characters which must remain together on the same line.
    /// </summary>
    private struct Word
    {
      public WordType    word_type;    //See the WordType enum for more information.
      public float    width;      //width of the word, according to SpriteFont.MeasureString( text ).X
      public string    text;      //text of the word

      public Word( WordType word_type, float width, string text )
      {
        this.word_type    = word_type;
        this.width      = width;
        this.text      = text;
      }
    }

    private SpriteFontDescription  font_description;
    private string          original_text;
    private string[]        wrapped_text;
    private float          desired_wrap_width;
    private float          max_actual_wrap_width;

    /// <summary>
    /// Wraps text and returns an array of strings representing the lines of text.
    /// </summary>
    /// <param name="font">The SpriteFont used for string measurements.  Cannot be null.</param>
    /// <param name="text">The text to wrap.  Cannot be null.</param>
    /// <param name="wrap_width">The maximum allowed line width.  If the width is less than the width of the first word of any line, that word will not be wrapped, and some overhang must occur.</param>
    /// <param name="min_required_display_width">This is the actual calculated width of the longest line.  This value may exceed wrap_width if wrap_width is so small that the first word of a line overhangs wrap_width.</param>
    /// <returns>An array of strings, where each element is a line of text.</returns>
    public static string[] WrapText( SpriteFont font, string text, float wrap_width, out float max_actual_line_width )
    {
      max_actual_line_width = 0;

      //font is required for measuring strings; it is impossible to proceed if it is null
      if (font == null)
        throw new Exception( "The 'font' parameter must not be null." );

      //if text is null, we can return a single blank line; max_actual_line_width will remain zero.
      if (text == null)
        return new string[] {String.Empty};

      //Initialize local variables
      int        text_length      = text.Length; //number of characters in the text string
      float      line_width      = 0f; //display width of the current line (presumably in pixels; whatever units SpriteFont.MeasureString returns)
      List<Word>    processed_words    = new List<Word>(); //words are further processed, broken up, and classified to account for extra white space, line breaks, and hyphenations
      StringBuilder  string_builder    = new StringBuilder();
      List<string>  lines        = new List<string>();

      //Deduce the width of a space/tab character since we may not be able to directly measure it; I've tested that is possible to directly measure it, but who knows what changes wil be made in the future.  This way has to work.
      float      underscore_width      = font.MeasureString( "_" ).X;
      float      space_width      = font.MeasureString( "_ _" ).X - (2 * underscore_width);
      float      tab_width      = font.MeasureString( "_\t_" ).X - (2 * underscore_width);

      //Construct words one character at a time.
      //Turns out, you have to do it this way to properly handle new-lines, extra white space, and hyphenated words.
      //Simply splitting the string would eradicate certain characters, and if you chose to split on just white space, you'd still have to do a character-by-character search for new lines and hyphens in each word anyway!
      //It's more efficient to just construct and classify words as we go, one character at a time, than it would be to first create an array of might-be-words and then further analyze them for line breaks and hyphens.
      for (int i = 0; i < text_length; i++) //I understand that the compiler optimizes loops on fixed-length arrays, so no need for a temporary length variable here
      {
        char c = text[ i];
        
        if (c == ' ')
        {
          FinalizeWord( string_builder, processed_words, font );
          processed_words.Add( new Word( WordType.WhiteSpace, space_width, " " ) );
        }
        else if (c == '\t')
        {
          FinalizeWord( string_builder, processed_words, font );
          processed_words.Add( new Word( WordType.WhiteSpace, tab_width, "\t" ) );
        }
        else if (c == '\r')
        {
          if (i < text_length - 1) //i+1 < text_length
            if (text[i+1] == '\n') //treat "\r\n" sequences as a single line break (MS Windows tradition)
              i++; //skip over the '\n'

          FinalizeWord( string_builder, processed_words, font );
          processed_words.Add( new Word( WordType.LineBreak, 0f, null ) );
          continue;
        }
        else if (c == '\n')
        {
          FinalizeWord( string_builder, processed_words, font );
          processed_words.Add( new Word( WordType.LineBreak, 0f, null ) );
        }
        else if (c == '-')
        {
          string_builder.Append( c ); //add the hyphen before finalizing the word
          FinalizeWord( string_builder, processed_words, font );
        }
        else
        {
          string_builder.Append( c );
        }
      }
      FinalizeWord( string_builder, processed_words, font ); //end of string reached, dump any word remaining in the buffer
      
      //Iterative over all processed words and perform line-breaking
      int processed_word_count = processed_words.Count;
      for (int i = 0; i < processed_word_count; i++)
      {
        Word current_word  = processed_words[ i];
        line_width      += current_word.width;
        bool fits      = (line_width <= wrap_width) || (line_width == current_word.width && current_word.width > wrap_width); //if line exceeds wrap width, it doesn't fit, unless the first word of the line is greater than the allowed line width

        switch (current_word.word_type)
        {
          case WordType.Normal:  //add word width to current line, test new line width; success, add a space and move to next word; failure, start new line
            if (fits)
              string_builder.Append( current_word.text );
            else
            {
              FinalizeLine( string_builder, lines, font, ref line_width, ref max_actual_line_width );
              i--; //retest the current word
            }
            break;
          case WordType.WhiteSpace:  //add width of space to current line, move to next word (no tests necessary, as spaces are allowed to overhang)
            string_builder.Append( current_word.text ); //append the space or tab character to the line (trailing white space will ultimately be trimmed from the line)
            break;
          case WordType.LineBreak:  //start new line immediately
            FinalizeLine( string_builder, lines, font, ref line_width, ref max_actual_line_width );
            break;
        }
      }
      FinalizeLine( string_builder, lines, font, ref line_width, ref max_actual_line_width );

      return lines.ToArray();
    }