Welcome to the Lounge

public static string Left(this string theString, int length)
{
    if (length < 0) throw new ArgumentOutOfRangeException(nameof(length));
    if (theString == null || length == 0) return string.Empty;
    if (theString.Length <= length) return theString;
    return theString.Substring(0, length);
}

Dim s As String = "He11o"
Mid$(s, 3, 2) = "ll"

public static string Left(this string target, int length)
{
    if(string.IsNullOrEmpty(target) //could just do == null; condition below caters to empty (which is faster I wonder)
        return target;

    return target.SubString(0, Math.Min(target.Length, length));
}

RyanDev wrote:

I miss VB.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

Quote:

I miss VB.

public static class StringExtensions {
  public static string Left(this string s, int n) {
    if (n >= s.Length)
      return "";
    return s.Substring(s.Length - n);
  }
}

Super Lloyd wrote:

you are the quick to hate type, are you not?

Super Lloyd wrote:

One tiny method missing and boom I hate you MS!

Super Lloyd wrote:

public static class StringExtensions {
public static string Left(this string s, int n) {
if (n >= s.Length)
return "";
return s.Substring(s.Length - n);
}
}

/// <summary>
/// Returns a new string surrounded by single quotes.
/// </summary>
public static string SingleQuote(this String src)
{
    return "'" + src + "'";
}

/// <summary>
/// Returns a new string surrounded by quotes.
/// </summary>
public static string Quote(this String src)
{
    return "\"" + src + "\"";
}

/// <summary>
/// Exchanges ' for " and " for '
/// Javascript JSON support, which must be formatted like '{"foo":"bar"}'
/// </summary>
public static string ExchangeQuoteSingleQuote(this String src)
{
    string ret = src.Replace("'", "\0xFF");
    ret = ret.Replace("\"", "'");
    ret = ret.Replace("\0xFF", "\"");

    return ret;
}

/// <summary>
/// Returns the source string surrounded by a single whitespace.
/// </summary>
public static string Spaced(this String src)
{
    return " " + src + " ";
}

/// <summary>
/// Returns a new string surrounded by brackets.
/// </summary>
public static string Parens(this String src)
{
    return "(" + src + ")";
}

/// <summary>
/// Returns a new string surrounded by brackets.
/// </summary>
public static string Brackets(this String src)
{
    return "[" + src + "]";
}

/// <summary>
/// Returns a new string surrounded by brackets.
/// </summary>
public static string CurlyBraces(this String src)
{
    return "{" + src + "}";
}

/// <summary>
/// Returns everything between the start and end chars, exclusive.
/// </summary>
/// <param name="src">The source string.</param>
/// <param name="start">The first char to find.</param>
/// <param name="end">The end char to find.</param>
/// <returns>The string between the start and stop chars, or an empty string if not found.</returns>
public static string Between(this string src, char start, char end)
{
    string ret = String.Empty;
    int idxStart = src.IndexOf(start);

    if (idxStart != -1)
    {
        ++idxStart;
        int idxEnd = src.IndexOf(end, idxStart);

        if (idxEnd != -1)
        {
            ret = src.Substring(idxStart, idxEnd - idxStart);
        }
    }

    return ret;
}

public static string Between(this string src, string start, string end)
{
    string ret = String.Empty;
    int idxStart = src.IndexOf(start);

    if (idxStart != -1)
    {
        idxStart += start.Length;
        int idxEnd = src.IndexOf(end, idxStart);

        if (idxEnd != -1)
        {
            ret = src.Substring(idxStart, idxEnd - idxStart);
        }
    }

    return ret;
}

public static string BetweenEnds(this string src, char start, char end)
{
    string ret = String.Empty;
    int idxStart = src.IndexOf(start);

    if (idxStart != -1)
    {
        ++idxStart;
        int idxEnd = src.LastIndexOf(end);

        if (idxEnd != -1)
        {
            ret = src.Substring(idxStart, idxEnd - idxStart);
        }
    }

    return ret;
}

/// <summary>
/// Returns the number of occurances of "find".
/// </summary>
/// <param name="src">The source string.</param>
/// <param name="find">The search char.</param>
/// <returns>The # of times the char occurs in the search string.</returns>
public static int Count(this string src, char find)
{
    int ret = 0;

    foreach (char s in src)
    {
        if (s == find)
        {
            ++ret;
        }
    }

    return ret;
}

/// <summary>
/// Return a new string that is "around" (left of and right of) the specified string.
/// Only the first occurance is processed.
/// </summary>
public static string Surrounding(this String src, string s)
{
    return src.LeftOf(s) + src.RightOf(s);
}

public static string RightOf(this String src, char c)
{
    string ret = String.Empty;
    int idx = src.IndexOf(c);

    if (idx != -1)
    {
        ret = src.Substring(idx + 1);
    }

    return ret;
}

public static bool BeginsWith(this String src, string s)
{
    return src.StartsWith(s);
}

public static string RightOf(this String src, string s)
{
    string ret = String.Empty;
    int idx = src.IndexOf(s);

    if (idx != -1)
    {
        ret = src.Substring(idx + s.Length);
    }

    return ret;
}

/// <summary>
/// Returns everything to the right of the rightmost char c.
/// </summary>
/// <param name="src">The source string.</param>
/// <param name="c">The seach char.</param>
/// <returns>Returns everything to the right of the rightmost search char, or an empty string.</returns>
public static string RightOfRightmostOf(this string src, char c)
{
    string ret = String.Empty;
    int idx = src.LastIndexOf(c);

    if (idx != -1)
    {
        ret = src.Substring(idx + 1);
    }

    return ret;
}

/// <summary>
/// Left of the first occurance of c
/// </summary>
/// <param name="src">The source string.</param>
/// <param name="c">Return everything to the left of this character.</param>
/// <returns>String to the left of c, or the entire string.</returns>
public static string LeftOf(this string src, char c)
{
    string ret = src;
    int idx = src.IndexOf(c);

    if (idx != -1)
    {
        ret = src.Substring(0, idx);
    }

    return ret;
}

public static string LeftOf(this String src, string s)
{
    string ret = src;
    int idx = src.IndexOf(s);

    if (idx != -1)
    {
        ret = src.Substring(0, idx);
    }

    return ret;
}

/// <summary>
/// Returns null if the string is empty.
/// </summary>
public static string NullIfEmpty(this String src)
{
    return String.IsNullOrEmpty(src) ? null : src;
}

/// <summary>
/// Safe left of n chars.  If string length is less than n, returns string.
/// </summary>
public static string LeftOf(this String src, int n)
{
    return src.Length < n ? src : src.Substring(n);
}

public static string LeftOfRightmostOf(this String src, char c)
{
    string ret = src;
    int idx = src.LastIndexOf(c);

    if (idx != -1)
    {
        ret = src.Substring(0, idx);
    }

    return ret;
}

public static string LeftOfRightmostOf(this String src, string s)
{
    string ret = src;
    int idx = src.IndexOf(s);
    int idx2 = idx;

    while (idx2 != -1)
    {
        idx2 = src.IndexOf(s, idx + s.Length);

        if (idx2 != -1)
        {
            idx = idx2;
        }
    }

    if (idx != -1)
    {
        ret = src.Substring(0, idx);
    }

    return ret;
}

public static string RightOfRightmostOf(this String src, string s)
{
    string ret = src;
    int idx = src.IndexOf(s);
    int idx2 = idx;

    while (idx2 != -1)
    {
        idx2 = src.IndexOf(s, idx + s.Length);

        if (idx2 != -1)
        {
            idx = idx2;
        }
    }

    if (idx != -1)
    {
        ret = src.Substring(idx + s.Length, src.Length - (idx + s.Length));
    }

    return ret;
}

public static char Rightmost(this String src)
{
    char c = '\0';

    if (src.Length > 0)
    {
        c = src[src.Length - 1];
    }

    return c;
}

public static string TrimLastChar(this String src)
{
    string ret = String.Empty;
    int len = src.Length;

    if (len > 0)
    {
        ret = src.Substring(0, len - 1);
    }

    return ret;
}

public static bool IsBlank(this string src)
{
    return String.IsNullOrEmpty(src) || (src.Trim() == String.Empty);
}

/// <summary>
/// Returns the first occurance of any token given the list of tokens.
/// </summary>
public static string Contains(this String src, string[] tokens)
{
    string ret = String.Empty;
    int firstIndex = 9999;

    // Find the index of the first index encountered.
    foreach (string token in tokens)
    {
        int idx = src.IndexOf(token);

        if ((idx != -1) && (idx < firstIndex))
        {
            ret = token;
            firstIndex = idx;
        }
    }

    return ret;
}

public static string SplitCamelCase(this string input)
{
    // return Regex.Replace(input, "([A-Z])", " $1", System.Text.RegularExpressions.RegexOptions.Compiled).Trim();
    // Replaced, because the version below also handles strings like "IBMMakeStuffAndSellIt", converting it to "IBM Make Stuff And Sell It"
    // See <a href="http://stackoverflow.com/questions/5796383/insert-spaces-between-words-on-a-camel-cased-token">http://stackoverflow.com/questions/5796383/insert-spaces-between-words-on-a-camel-cased-token</a>
    return Regex.Replace(
        Regex.Replace(input, @"(\P{Ll})(\P{Ll}\p{Ll})", "$1 $2"),
            @"(\p{Ll})(\P{Ll})", "$1 $2");
}

public static string CamelCase(this string src)
{
    return src[0].ToString().ToLower() + src.Substring(1).ToLower();

}

public static string PascalCase(this string src)
{
    string ret = String.Empty;

    if (!String.IsNullOrEmpty(src))
    {
        ret = src[0].ToString().ToUpper() + src.Substring(1).ToLower();
    }

    return ret;
}

/// <summary>
/// Returns a Pascal-cased string, given a string with words separated by spaces.
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static string PascalCaseWords(this string src)
{
    StringBuilder sb = new StringBuilder();
    string[] s = src.Split(' ');
    string more = String.Empty;

    foreach (string s1 in s)
    {
        sb.Append(more);
        sb.Append(PascalCase(s1));
        more = " ";
    }

    return sb.ToString();
}

public static string Left(this string inputString, int length) { return  new string((from ch in inputString select ch).Take(length).ToArray()); }

Member 10952144 wrote:

you'll have to spend 2 minutes of your personal precious time to write this code

Member 10952144 wrote:

I understand your frustrations,

StatementTerminator wrote:

This kind of thing annoys me about VB, getting back a string that is shorter than the length you specified is like just having the language ignore an exception and give an arbitrary result.