string split by index / params?

Just before I write my own function just wanted to check if there exists a function like string.split(string input, params int[] indexes) in the .NET library? This function should split the string on indexes i pass to it.

Edit: I shouldn't have added the string.join sen开发者_如何学Ctence - it was confusing.

You could use the String instance method Substring.

string a = input.Substring(0, 10);
string b = input.Substring(10, 5);
string c = input.Substring(15, 3);

All other answers just seemed too complicated, so I took a stab.

using System.Linq;

public static class StringExtensions
{
    /// <summary>
    ///     Returns a string array that contains the substrings in this instance that are delimited by specified indexes.
    /// </summary>
    /// <param name="source">The original string.</param>
    /// <param name="index">An index that delimits the substrings in this string.</param>
    /// <returns>An array whose elements contain the substrings in this instance that are delimited by one or more indexes.</returns>
    /// <exception cref="ArgumentNullException"><paramref name="index" /> is null.</exception>
    /// <exception cref="ArgumentOutOfRangeException">An <paramref name="index" /> is less than zero or greater than the length of this instance.</exception>
    public static string[] SplitAt(this string source, params int[] index)
    {
        index = index.Distinct().OrderBy(x => x).ToArray();
        string[] output = new string[index.Length + 1];
        int pos = 0;

        for (int i = 0; i < index.Length; pos = index[i++])
            output[i] = source.Substring(pos, index[i] - pos);

        output[index.Length] = source.Substring(pos);
        return output;
    }
}

The Split method divides a string based on a recognition pattern. Perfect for breaking down comma seperated lists etc.

But you are right, there are no built in string methods to achieve what you want.

This doesn't directly answer your generalized question, but in what is most likely the common case (or at least the case for which I was searching for an answer when I came upon this SO question) where indexes is a single int, this extension method is a little cleaner than returning a string[] array, especially in C# 7.

For what it's worth, I benchmarked using string.Substring() against creating two char[] arrays, calling text.CopyTo() and returning two strings by calling new string(charArray). Using string.Substring() was roughly twice as fast.

C# 7 syntax

jdoodle.com example

public static class StringExtensions
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static (string left, string right) SplitAt(this string text, int index) => 
        (text.Substring(0, index), text.Substring(index));
}

public static class Program
{
    public static void Main()
    {
        var (left, right) = "leftright".SplitAt(4);
        Console.WriteLine(left);
        Console.WriteLine(right);
    }
}

C# 6 syntax

jdoodle.com example

Note: Using Tuple<string, string> in versions prior to C# 7 doesn't save much in the way of verbosity and it might actually be cleaner to just return a string[2] array.

public static class StringExtensions
{
    // I'd use one or the other of these methods, and whichever one you choose, 
    // rename it to SplitAt()

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Tuple<string, string> TupleSplitAt(this string text, int index) => 
        Tuple.Create<string, string>(text.Substring(0, index), text.Substring(index));

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static string[] ArraySplitAt(this string text, int index) => 
        new string[] { text.Substring(0, index), text.Substring(index) };
}

public static class Program
{
    public static void Main()
    {
        Tuple<string, string> stringsTuple = "leftright".TupleSplitAt(4);
        Console.WriteLine("Tuple method");
        Console.WriteLine(stringsTuple.Item1);
        Console.WriteLine(stringsTuple.Item2);

        Console.WriteLine();

        Console.WriteLine("Array method");
        string[] stringsArray = "leftright".ArraySplitAt(4);
        Console.WriteLine(stringsArray[0]);
        Console.WriteLine(stringsArray[1]);
    }
}

One possible solution:

public static class StringExtension
{
    public static string[] Split(this string source, params int[] sizes)
    {
        var length = sizes.Sum();
        if (length > source.Length) return null;

        var resultSize = sizes.Length;
        if (length < source.Length) resultSize++;

        var result = new string[resultSize];

        var start = 0;
        for (var i = 0; i < resultSize; i++)
        {
            if (i + 1 == resultSize)
            {
                result[i] = source.Substring(start);
                break;
            }

            result[i] = source.Substring(start, sizes[i]);
            start += sizes[i];
        }

        return result;
    }
}

public static IEnumerable<string> SplitAt(this string source, params int[] index)
{
    var indices = new[] { 0 }.Union(index).Union(new[] { source.Length });

    return indices
                .Zip(indices.Skip(1), (a, b) => (a, b))
                .Select(_ => source.Substring(_.a, _.b - _.a));
}

var s = "abcd";

s.SplitAt(); // "abcd"
s.SplitAt(0); // "abcd"
s.SplitAt(1); // "a", "bcd"
s.SplitAt(2); // "ab", "cd"
s.SplitAt(1, 2) // "a", "b", "cd"
s.SplitAt(3); // "abc", "d"

There is always regular expressions.

Here's an example from which one can expand upon:

 string text = "0123456789ABCDEF";
 Match m = new Regex("(.{7})(.{4})(.{5})").Match(text);
 if (m.Success)
 {
     var result = new string[m.Groups.Count - 1];
     for (var i = 1; i < m.Groups.Count; i++)
         result[i - 1] = m.Groups[i].Value;
 }

Here's a function that encapsulates the above logic:

    public static string[] SplitAt(this string text, params int[] indexes)
    {
        var pattern = new StringBuilder();
        var lastIndex = 0;
        foreach (var index in indexes)
        {
            pattern.AppendFormat("(.{{{0}}})", index - lastIndex);
            lastIndex = index;
        }
        pattern.Append("(.+)");

        var match = new Regex(pattern.ToString()).Match(text);
        if (! match.Success)
        {
            throw new ArgumentException("text cannot be split by given indexes");
        }

        var result = new string[match.Groups.Count - 1];
        for (var i = 1; i < match.Groups.Count; i++)
            result[i - 1] = match.Groups[i].Value;
        return result;            
    }

This was written rather quickly but I believe it illustrates my points and emphasizes my points to author of comment, Michael.

Version with "List< string >" as return.

Caller

string iTextLine = "02121AAAARobert Louis StevensonXXXX"
int[] tempListIndex = new int[] {
    // 0 -  // 0number  (exclude first)
    5,      // 1user
    9,      // 2name
    31      // role
};  

// GET - words from indexes
List<string> tempWords = getListWordsFromLine(iTextLine, tempListIndex);

method

/// <summary>
/// GET - split line in parts using index cuts
/// </summary>
/// <param name="iListIndex">Input List of indexes</param>
/// <param name="iTextLine">Input line to split</param>
public static List<string> getListWordsFromLine(string iTextLine, int[] iListIndex)
{
    // INIT
    List<string> retObj = new List<string>(); 
    int currStartPos = 0;
    // GET - clear index list from dupl. and sort it
    int[] tempListIndex = iListIndex.Distinct()
                                    .OrderBy(o => o)
                                    .ToArray();
    // CTRL
    if (tempListIndex.Length != iListIndex.Length)
    {
        // ERR
        throw new Exception("Input  iListIndex contains duplicate indexes");
    }


    for (int jj = 0; jj < tempListIndex.Length; ++jj)
    {
        try
        {
            // SET - line chunk
            retObj.Add(iTextLine.Substring(currStartPos,
                                           tempListIndex[jj] - currStartPos));
        }
        catch (Exception)
        {
            // SET - line is shorter than expected
            retObj.Add(string.Empty);                    
        }                
        // GET - update start position
        currStartPos = tempListIndex[jj];
    }
    // SET
    retObj.Add(iTextLine.Substring(currStartPos));  
    // RET
    return retObj;
}

I wanted to use the Range class to implement a solution.

My use case was to convert standard property names - e.g. CustomerName, WindowSize, etc. - into a JSON property name that would still be easy to read - as in customer_name, window_size.

Creating a JsonNamingPolicy descendent, I overrode the ConvertName method with the following implementation:

        /// <summary>
        /// Converts a property name like "CustomerName" and converts to "customer_name"
        /// </summary>
        /// <param name="name">the propery name</param>
        /// <returns>property conversion</returns>
        public override string ConvertName(string name) {
            //  using Regex to look for caps: "([A-Z]+)"
            Match[] matches = regex.Matches(name)
                .ToArray();

            if (!matches.Any()) {
                //  no capitals to match
                return name;
            }

            if (matches.Length == 1) {
                //  one match
                return name.ToLower();
            }

            //  multiple matches - we could use StringBuilder
            string[] parts = new string[matches.Length];

            int index = 0;

            //  this is somewhat verbose for debugging purposes
            while (index < matches.Length) {
                //  get our match
                Match m = matches[index];
                //  calculate range length
                int length = index + 1 < matches.Length ?
                    //  return the start of the next match
                    (matches[index + 1]).Index : 
                    //  return the end of the string
                    name.Length;

                //  create the range
                Range range = (m.Index..length);
                //  insert the part
                parts[index] = (name[range]).ToLower();
                //  increment the indexer
                ++index;
            }

            //  construct property name
            return string.Join("_", parts);
        }
    }

Note: I could use StringBuilder as some people will likely prefer. I don't anticipate performance problems as this is a one and done scenario.

That being said, if I needed to serialize tons of data to go across the wire, I would likely forego this process altogether and design my properties with the desired naming convention.

For completeness, here is the source class:

    // trimmed to the necessary bits for brevity
    public class LaunchParameters : ILoadable {
        #region     properties
        [JsonIgnore]
        string ILoadable.Directory { get; } = CONFIG_DIR;
        [JsonIgnore]
        string ILoadable.FileName { get; } = CONFIG_FILE;
        public Size WindowSize { get; set; } = new(1024, 768);
        public string Title { get; init; } = "GLX Game";
        [JsonIgnore]
        public string Application => Title.Replace(" ", "_");
        public string Label { get; init; }
        public Version Version { get; init; }
        [JsonIgnore]
        public string WindowTitle => $"{Title} Window";
        public string LogPath { get; init; } = @".\.logs";
        public string CrashLogPath { get; init; } = @".\.crash_logs";
        #endregion  properties
    }

... and the resulting JSON:

{
  "window_size": {
    "is_empty": false,
    "width": 1024,
    "height": 768
  },
  "title": "GLX Game",
  "label": null,
  "version": null,
  "log_path": ".\\.logs",
  "crash_log_path": ".\\.crash_logs"
}