The Lounge - CodeProject

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Super Lloyd16-Jun-16 23:31

16-Jun-16 23:31

I am still wondering if you are really throwing a tantrum for a "missing 2 lines function" or it is in fact a joke!?
Haha! Laugh | :laugh:

Your seemingly deep anger make it all the more laughable! haha! WTF | :WTF:

All in one Menu-Ribbon Bar
DirectX for WinRT/C# since 2013!
Taking over the world since 1371!

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

den2k8816-Jun-16 23:34

den2k88

16-Jun-16 23:34

My tantrum is directeed to the pile of sunshine that is the .NET framework, in fact I usually make my own libraries anyway. Still for a "framework" so bloated not having a simple and fundamental function is basically an indication of utter failure.

GCS d--- s-/++ a- C++++ U+++ P- L- E-- W++ N++ o+ K- w+++ O? M-- V? PS+ PE- Y+ PGP t++ 5? X R++ tv-- b+ DI+++ D++ G e++>+++ h--- ++>+++ y+++* Weapons extension: ma- k++ F+2 X

If you think 'goto' is evil, try writing an Assembly program without JMP. -- TNCaver

When I was six, there were no ones and zeroes - only zeroes. And not all of them worked. -- Ravi Bhavnani

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Super Lloyd17-Jun-16 6:39

Super Lloyd

17-Jun-16 6:39

Yes, just like you, I wouldn't use the .NET Framework for anything, obviously!
It doesn't even have a .Left() method on string, for god's sake man! Who make that sh*t?! OMG | :OMG:

All in one Menu-Ribbon Bar
DirectX for WinRT/C# since 2013!
Taking over the world since 1371!

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

ZurdoDev17-Jun-16 1:18

ZurdoDev

17-Jun-16 1:18

Super Lloyd wrote:
you are the quick to hate type, are you not?

No.

Super Lloyd wrote:
One tiny method missing and boom I hate you MS!

I'm trying to fit in with the Lounge crowd.

$Shucks | :-\$

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);
}
}

You tried to sneak that one there. return "". How dare you. Mad | :mad:

There are only 10 types of people in the world, those who understand binary and those who don't.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

BillWoodruff16-Jun-16 14:41

BillWoodruff

16-Jun-16 14:41

While I cherish the myriad weirdnesses I am aware of in my long-term relationship with C#, the absence of 'Left would not qualify. Welcome to Linq: [^].

Unless there's something you just can't stand about the word: "Take" ?

Smile | :)

cheers, Bill

«There is a spectrum, from "clearly desirable behaviour," to "possibly dodgy behavior that still makes some sense," to "clearly undesirable behavior." We try to make the latter into warnings or, better, errors. But stuff that is in the middle category you don’t want to restrict unless there is a clear way to work around it.» Eric Lippert, May 14, 2008

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Marc Clifton16-Jun-16 15:20

Marc Clifton

16-Jun-16 15:20

These are the string extension methods I wrote ages ago (well, since extension methods have been around):

(Note that some of this isn't very elegant, could be LINQ'ified, could be optimized, etc.)

/// <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();
}

Imperative to Functional Programming Succinctly

Contributors Wanted for Higher Order Programming Project!

Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Sander Rossel16-Jun-16 21:10

Sander Rossel

16-Jun-16 21:10

Yesterday I noticed one of our projects has a reference to Microsoft.VisualBasic. What the...?
Upon closer inspection I found it was needed for new My.Computer.Devices.ComputerInfo().TotalPhysicalMemory().
Looked around on the web, and there really isn't an easy C# variant Sigh | :sigh:

Read my (free) ebook Object-Oriented Programming in C# Succinctly.
Visit my blog at Sander's bits - Writing the code you need.
Or read my articles here on CodeProject.

Simplicity is prerequisite for reliability.
— Edsger W. Dijkstra

Regards,
Sander

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Member 1095214417-Jun-16 2:54

Member 10952144

17-Jun-16 2:54

While MS gave you the power of Linq in C#....this gives you an infinite amount of possibilities.
That combined with extensions, and you are so much better off than with VB! It's true, you'll have to spend 2 minutes of your personal precious time to write this code once, and to remember to add this extension 'lib' to all your projects where you might need them....boohoo.
Sth like this... one line of code...

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

Now you can just Left a string by doing string.Left(5)....so easy but 1000 times more powerful (and prob as many times more performant) than VB....

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

ZurdoDev17-Jun-16 2:57

ZurdoDev

17-Jun-16 2:57

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

Exactly!

There are only 10 types of people in the world, those who understand binary and those who don't.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Member 1095214417-Jun-16 3:18

Member 10952144

17-Jun-16 3:18

Well it'll be less now if you just copy/paste the code....I think 30 secs will do now. Is prob just about as much as VB would need to show you its 'intellisense' info on the Left function Wink | ;-)

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

ZurdoDev17-Jun-16 3:21

ZurdoDev

17-Jun-16 3:21

My point is, why after all these years have the C# builders not added it in. It would only take a few minutes of their time.

There are only 10 types of people in the world, those who understand binary and those who don't.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Member 1095214417-Jun-16 3:41

Member 10952144

17-Jun-16 3:41

I understand your frustrations, but to be honest, I didn't ever miss that function. I did VB6 for years, I did Java for years, even did some Delphi, but now C# for quite some years, and every language has its benefits and its downsides, but C# really is the nicest language I've used, Delphi comes in second Smile | :)

The reasoning behind not providing a Left function I think is since it's not a core function, but more of a "convenience function", one that would give discussions among developers, since they would make their own 'more performing' version of that function.
VB6 provided more convenience functions out of the box, since it was mainly meant to make software development 'as easy as possible'.
And to be honest, I like the fact that C# provided us with Extensions, Linq, Entity Framework,... more than the couple of arguable functions they might have 'forgotten'.
Here they were really one of the first to incorporate these new ideas, where Java now tries to catch up...

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

ZurdoDev17-Jun-16 3:49

ZurdoDev

17-Jun-16 3:49

Member 10952144 wrote:
I understand your frustrations,

Actually, I don't think you do, but that is my fault. I think a lot of other people thought I was seriously "hating" on Microsoft. My original post was done tongue-in-cheek. I do find it weird that they don't have the LEFT method on a string but it doesn't actually bother me at all. I just wanted to get in on all the hating going on with something silly. $Shucks | :-\$

But, you do make good points.

There are only 10 types of people in the world, those who understand binary and those who don't.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

PSU Steve17-Jun-16 3:45

PSU Steve

17-Jun-16 3:45

Left isn't a method of the String class in VB.NET either. It's hidden in the Microsoft.VisualBasic.Strings class. I work in VB.NET all the time and just created my own Left extension method, just like you would in C#.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

jtmueller17-Jun-16 4:26

jtmueller

17-Jun-16 4:26

C# doesn't have ANY methods on string. The methods on string are part of the .NET framework, and are the same for any .NET language - C#, VB, F#, you name it.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

StatementTerminator17-Jun-16 5:58

StatementTerminator

17-Jun-16 5:58

Wow, go do some string manipulations in ANSI C, that'll give you something to complain about Smile | :)

As a general rule, the more powerful the language the more responsibility the programmer has for implementing algorithms correctly. Checking bounds before taking a bite out of an array is basic stuff, why should the language hold your hand for that?

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. It's not what you asked for, and you shouldn't get it. What if code down the line is expecting the string to be that exact length?

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

ZurdoDev17-Jun-16 6:19

ZurdoDev

17-Jun-16 6:19

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.

Not even close. It's like being a human.

If you asked someone, "hey, give me the first 100 characters of the phrase 'i love VB'", would you expect them to yell at you with an exception or to just return your string? Maybe you think too much like a computer instead of a human. $Shucks | :-\$

There are only 10 types of people in the world, those who understand binary and those who don't.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

StatementTerminator17-Jun-16 6:31

StatementTerminator

17-Jun-16 6:31

RyanDev wrote:
If you asked someone, "hey, give me the first 100 characters of the phrase 'i love VB'", would you expect them to yell at you with an exception or to just return your string?

I would expect different answers from different people, which is exactly the point. And yes, I would be the elephanting Vulcan who says that the question is unanswerable, because what is being asked for can't be given.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

ZurdoDev17-Jun-16 7:14

ZurdoDev

17-Jun-16 7:14

Give me the first 100 digits of 10. Laugh | :laugh:

There are only 10 types of people in the world, those who understand binary and those who don't.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

StatementTerminator17-Jun-16 15:32

StatementTerminator

17-Jun-16 15:32

10.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

ZurdoDev18-Jun-16 2:38

ZurdoDev

18-Jun-16 2:38

Exactly.

There are only 10 types of people in the world, those who understand binary and those who don't.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Member 772330917-Jun-16 7:27

Member 7723309

17-Jun-16 7:27

Add a reference to Visual Basic and just use the left function from VB

string test = "Hello World";
string shortTest = Microsoft.VisualBasic.Strings.Left(test, 5);
Console.WriteLine(shortTest);

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

ZurdoDev17-Jun-16 7:28

ZurdoDev

17-Jun-16 7:28

I know.

There are only 10 types of people in the world, those who understand binary and those who don't.

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Gerry Schmitz17-Jun-16 9:41

Gerry Schmitz

17-Jun-16 9:41

Func<string, int, string> Left = ( s, n ) => s.PadRight( n + 1 ).Remove( n );

Console.WriteLine( Left( "FooBar", 3 ) );
Console.WriteLine( Left( "", 6 ) + "*" );

Console.ReadKey();

Re: Fine, I'll jump on the "I hate Microsoft" bandwagon

Herbie Mountjoy17-Jun-16 13:52

Herbie Mountjoy

17-Jun-16 13:52

I miss VB too. Somehow it's very good at dodging bullets.

We're philosophical about power outages here. A.C. come, A.C. go.

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Welcome to the Lounge