Welcome to the Lounge

using System;
using System.Globalization;

namespace WHATEVER
{
    public static class StringExtensions
    {
        // holds result of last successful conversion to 'double
        private static double dbl;

        // holds result of last successful conversion to 'int
        private static int i;

        public static StringState GetStringState(this string str)
        {
            if (String.IsNullOrEmpty(str))
            {
                return str == "" ? StringState.IsEmpty : StringState.IsNull;
            }
            else
            {
                if (String.IsNullOrWhiteSpace(str)) return StringState.IsWhiteSpace;
            }

            if (Double.TryParse(str, out dbl)) return StringState.IsNumeric;

            return StringState.IsStandard;

        }

        public static NumberState GetStringNumberState(this string str)
        {
            if (str.GetStringState() != StringState.IsNumeric) return NumberState.NotNumber;

            // https://stackoverflow.com/a/2751597/133321
            if (Math.Abs(dbl % 1) < Double.Epsilon)
            {
                return NumberState.IsInt;
            }
            else
            {
                return NumberState.IsDouble;
            }
        }

        public static bool StringIsHex(this string str)
        {
            if (str.StartsWith("0x")) str = str.Remove(0,2);

            return Int32.TryParse(str, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out i);
        }
    }

    public enum StringState
    {
        IsStandard = 0x0 << 0,
        IsNull = 0x1 << 0,
        IsEmpty = 0x1 << 1,
        IsWhiteSpace = 0x1 << 2,
        IsNumeric = 0x1 << 3,
    }

    public enum NumberState
    {
        NotNumber = 0x0 << 0,
        IsInt = 0x1 << 0,
        IsDouble = 0x1 << 1
    }
}

string s1 = null;
string s2 = "";
string s3 = "12";
string s4 = "23.45";
string s5 = "0xFF";
string s6 = "23.45";

var state1 = s1.GetStringState();
var state2 = s2.GetStringState();
var state3 = s3.GetStringState();
var state4 = s4.GetStringState();
var state5 = s5.GetStringState();
var state6 = s6.GetStringState();

var nstate1 = s1.GetStringNumberState();
var nstate2 = s2.GetStringNumberState();
var nstate3 = s3.GetStringNumberState();
var nstate4 = s4.GetStringNumberState();

var ishex1 = s5.StringIsHex();
var ishex2 = "0xddDFf".StringIsHex();
var ishex3 = "0xXdDFf".StringIsHex();

public static class StringExtensions
{
    public static StringState GetStringState(this string str, out double dbl)
    {
        dbl = double.NaN;
        
        if (str is null) return StringState.IsNull;
        if (str.Length == 0) return StringState.IsEmpty;
        if (string.IsNullOrWhiteSpace(str)) return StringState.IsWhiteSpace;
        if (!double.TryParse(str, out var d)) return StringState.IsStandard;
        
        dbl = d;
        return StringState.IsNumeric;
    }
    
    public static StringState GetStringState(this string str) => GetStringState(str, out _);
    
    public static NumberState GetStringNumberState(this string str, out double dbl)
    {
        if (GetStringState(str, out dbl) != StringState.IsNumeric) return NumberState.NotNumber;
        if (Math.Abs(dbl % 1) < double.Epsilon) return NumberState.IsInt;
        return NumberState.IsDouble;
    }
    
    public static NumberState GetStringNumberState(this string str) => GetStringNumberState(str, out _);
    
    public static bool StringIsHex(this string str, out int i)
    {
        if (str.StartsWith("0x")) str = str.Remove(0, 2);
        return int.TryParse(str, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out i);
    }
    
    public static bool StringIsHex(this string str) => StringIsHex(str, out _);
}

public static class StringExtensions
{
    public static (StringState state, double dbl) GetStringState(this string str)
    {
        if (str is null) return (StringState.IsNull, double.NaN);
        if (str.Length == 0) return (StringState.IsEmpty, double.NaN);
        if (string.IsNullOrWhiteSpace(str)) return (StringState.IsWhiteSpace, double.NaN);
        if (!double.TryParse(str, out var d)) return (StringState.IsStandard, double.NaN);
        return (StringState.IsNumeric, d);
    }
    
    public static (NumberState state, double dbl) GetStringNumberState(this string str)
    {
        switch (GetStringState(str))
        {
            case var n when n.state != StringState.IsNumeric:
            {
                return (NumberState.NotNumber, double.NaN);
            }
            case var n when Math.Abs(n.dbl % 1) < double.Epsilon:
            {
                return (NumberState.IsInt, n.dbl);
            }
            case var n:
            {
                return (NumberState.IsDouble, n.dbl);
            }
        }
    }
    
    public static (bool isHex, int value) StringIsHex(this string str)
    {
        if (str.StartsWith("0x")) str = str.Remove(0, 2);
        return (int.TryParse(str, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var i), i);
    }
}

OriginalGriff wrote:

I'll stick with IsNullOrWhitespace myself!

M.D.V.

If something has a solution... Why do we have to worry about?. If it has no solution... For what reason do we have to worry about?
Help me to understand what I'm saying, and I'll explain it better to you
Rating helpful answers is nice, but saying thanks can be even nicer.

if (name?.Length >= 3)

RickZeeland wrote:

if (name?.Length >= 3)

RickZeeland wrote:

Updated the answer