StringExtensions.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

using System.IO;
using System.Globalization;
using System.Xml.Serialization;
using System.Xml;
//using System.Web;


public static class StringExtensions
{
    public static string RemoveLastChars(this string Input, int NumberOfCharsToRemove)
    {
        if (NumberOfCharsToRemove <= 0) return Input;
        return (Input.Length > NumberOfCharsToRemove ? Input.Substring(0, Input.Length - NumberOfCharsToRemove) : "");
    }


    public static string RemoveSpecifiedEnd(this string Input, string StringEndToRemove, StringComparison ComparisonType = StringComparison.CurrentCulture)
    {
        return Input.EndsWith(StringEndToRemove, ComparisonType) ? Input.RemoveLastChars(StringEndToRemove.Length) : Input;
    }



    public static string RemoveRemoveConsecutiveWhiteSpaces(this string Input)
    {
        return Regex.Replace(Input, @"\s+", " ");
    }

    public static string RemoveWhitespaces(this string input)
    {
        return new string(input.ToCharArray()
            .Where(c => !Char.IsWhiteSpace(c))
            .ToArray());
    }

    public static int HexToInt(this string s)
    {
        return int.Parse(s, System.Globalization.NumberStyles.HexNumber);
    }
    public static int HexToByte(this string s)
    {
        return byte.Parse(s, System.Globalization.NumberStyles.HexNumber);
    }
    public static bool IsHexString(this string s)
    {
        return s.IsHexString(0, s.Length);
    }

    public static bool IsHexString(this string s, int startindex)
    {
        return s.IsHexString(startindex, s.Length - startindex);
    }

    public static bool IsHexString(this string s, int startindex, int length)
    {
        if (string.IsNullOrWhiteSpace(s)) return false;

        if (startindex + length > s.Length) return false;

        return System.Text.RegularExpressions.Regex.IsMatch(s.Substring(startindex, length), @"\A\b[0-9a-fA-F]+\b\Z");
    }




    public static byte[] ToByteArray(this string s)
    {
        System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
        return encoding.GetBytes(s);
    }

    public static StringBuilder ToStringBuilder(this string s)
    {
        if (string.IsNullOrEmpty(s))
        {
            return new StringBuilder("");
        }
        return new StringBuilder(s);
    }

    public static string Left(this string s, int length)
    {
        return s.Substring(0, length);
    }

    public static string Right(this string s, int length)
    {
        return s.Substring(s.Length - length, length);
    }

    public static string Mid(this string s, int startIndex, int length)
    {
        return s.Substring(startIndex, length);
    }

    public static int ToInteger(this string s)
    {
        int integerValue = 0;
        int.TryParse(s, out integerValue);
        return integerValue;
    }

    public static uint ToUInt(this string s)
    {
        uint uintegerValue = 0;
        uint.TryParse(s, out uintegerValue);
        return uintegerValue;
    }

    public static bool IsInteger(this string s)
    {
        int dummy;
        if (s.IsNullOrWhiteSpace()) return false;
        return int.TryParse(s, out dummy);
    }

    public static bool IsUInt(this string s)
    {
        uint dummy;
        if (s.IsNullOrWhiteSpace()) return false;
        return uint.TryParse(s, out dummy);
    }

    public static bool IsNullOrEmpty(this string s)
    {
        return string.IsNullOrEmpty(s);
    }

    public static bool IsNullOrWhiteSpace(this string s)
    {
        return string.IsNullOrWhiteSpace(s);
    }



    public static string Build(this string s, object arg0)
    {
        if (s == null) { return ""; }
        return string.Format(s, arg0);
    }

    public static string Build(this string s, object arg0, object arg1)
    {
        if (s == null) { return ""; }
        return string.Format(s, arg0, arg1);
    }

    public static string Build(this string s, object arg0, object arg1, object arg2)
    {
        if (s == null) { return ""; }
        return string.Format(s, arg0, arg1, arg2);
    }

    //public static string Build(this string s, object[] args)
    //{
    //    if (s == null) { return ""; }
    //    return string.Format(s, args);
    //}

    public static string Build(this string s, params object[] args)
    {
        if (s == null) { return ""; }
        return string.Format(s, args);
    }

    public static string Construct(this string s, Dictionary<string, object> ConstructionValueDictionary, bool ReplaceNullValuesWithEmptyString = true, bool IgnoreMissingConstructionValues = false)
    {
        if (s.IsNullOrWhiteSpace()) return s;

        List<string> L = s.GetConstructionItemsList().Select(S => S.Substring(1, S.Length - 2)).ToList();
        foreach (string N in L)
        {
            string V = "";
            if (ConstructionValueDictionary.ContainsKey(N))
            {
                object O = ConstructionValueDictionary[N];
                if (O == null && ReplaceNullValuesWithEmptyString)
                {
                    V = "";
                }
                else
                {
                    V = O.ToString();
                }
                s = s.Replace("{{{0}}}".Build(N), V);
            }
            else if (!IgnoreMissingConstructionValues)
            {
                throw new ArgumentException("The ConstructionValueDictionary does not contain a value for '{0}'".Build(N), "ConstructionValueDictionary");
            }
        }
        return s;
    }

    public static List<string> GetConstructionItemsList(this string s)
    {
        List<string> L = new List<string>();
        if (!s.IsNullOrWhiteSpace())
        {
            Regex regex = new Regex("{.*?}");
            MatchCollection matches = regex.Matches(s);
            foreach (object match in matches)
            {
                string N = match.ToString();

                if (!L.Contains(N))
                {
                    L.Add(N);
                }

            }
        }
        return L;

    }

    public static Dictionary<string, object> GetConstructionItemsDictionary(this string s)
    {
        Dictionary<string, object> D = new Dictionary<string, object>();
        List<string> L = s.GetConstructionItemsList();
        L.ForEach(N => D.Add(N, null));
        L = null;
        return D;

    }



    public static bool IsEmail(this string s)
    {
        Regex MailCheck = new Regex(@"\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
        return MailCheck.IsMatch(s);
    }

    public static void WriteToFile(this string s, string FileName)
    {
        s.WriteToFile(FileName, false);
    }

    public static void WriteToFile(this string s, string FileName, bool Append)
    {
        TextWriter tw = null;
        try
        {
            tw = new StreamWriter(FileName, Append);
            tw.Write(s);
        }
        catch (Exception e)
        {

            if (tw != null)
            {
                tw.Close();
            }
            throw e;
        }

        tw.Close();

        tw.Dispose();


    }

    public static void WriteToFile(this string s, FileInfo File)
    {
        s.WriteToFile(File.FullName, false);
    }

    public static void WriteToFile(this string s, FileInfo File, bool Append)
    {
        s.WriteToFile(File.FullName, Append);
    }


    static public string Replace(this string originalString, string oldValue, string newValue, StringComparison comparisonType)
    {
        StringBuilder sb = new StringBuilder();

        int previousIndex = 0;
        int index = originalString.IndexOf(oldValue, comparisonType);
        while (index != -1)
        {
            sb.Append(originalString.Substring(previousIndex, index - previousIndex));
            sb.Append(newValue);
            index += oldValue.Length;

            previousIndex = index;
            index = originalString.IndexOf(oldValue, index, comparisonType);
        }
        sb.Append(originalString.Substring(previousIndex));

        return sb.ToString();

    }


    public static bool IsAlphaNumeric(this string str)
    {
        if (string.IsNullOrEmpty(str))
            return false;

        return !str.Any(C => !char.IsLetterOrDigit(C));

    }

    public static string RemoveDiacritics(this string text)
    {
        string normalizedString = text.Normalize(NormalizationForm.FormD);
        StringBuilder stringBuilder = new StringBuilder();

        foreach (var c in normalizedString)
        {
            UnicodeCategory unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(c);
            if (unicodeCategory != UnicodeCategory.NonSpacingMark)
            {
                stringBuilder.Append(c);
            }
        }

        return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
    }

    public static string AlternativeWhenNullOrWhiteSpace(this string text, string Alternative)
    {
        if (text.IsNullOrWhiteSpace()) return Alternative;
        return text;
    }


    public static T XMLDeserialize<T>(this string Xml)
    {
        byte[] xmlBytes = Encoding.Default.GetBytes(Xml);
        using (MemoryStream ms = new MemoryStream(xmlBytes))
        {
            try
            {
                return (T)new XmlSerializer(typeof(T)).Deserialize(ms);
            }
            catch (Exception E)
            {

                Exception Ex = new Exception("Could not deserialize {0} from XML data.".Build(typeof(T).Name), E);
                Ex.Data.Add("XML Data", Xml);
                throw Ex;
            }
        }



    }


    public static object XMLDeserialize(this string Xml, Type Type)
    {
        byte[] xmlBytes = Encoding.Default.GetBytes(Xml);
        using (MemoryStream ms = new MemoryStream(xmlBytes))
        {
            try
            {
                return new XmlSerializer(Type).Deserialize(ms);
            }
            catch (Exception E)
            {

                Exception Ex = new Exception("Could not deserialize {0} from XML data.".Build(Type.Name), E);
                Ex.Data.Add("XML Data", Xml);
                throw Ex;
            }
        }



    }

    public static T XMLDeserializeInterface<T>(this string Xml)
    {
        byte[] xmlBytes = Encoding.Default.GetBytes(Xml);
        using (MemoryStream ms = new MemoryStream(xmlBytes))
        {
            using (XmlReader r = XmlReader.Create(ms))
            {
                List<Type> Types = new List<Type>(AppDomain.CurrentDomain.GetAssemblies().ToList().SelectMany(s => s.GetTypes()).Where(p => typeof(T).IsAssignableFrom(p) && !p.IsAbstract));

                if (Types.Any(Ty => Ty.FullName == r.LocalName))
                {
                    throw new Exception("The type {0} specified in the xml cant be assigned to {1}".Build(r.LocalName, typeof(T).FullName));
                }
                Type TargetType = Types.First(Ty => Ty.FullName == r.LocalName);
                try
                {
                    return (T)new XmlSerializer(TargetType).Deserialize(r);
                }
                catch (Exception E)
                {

                    Exception Ex = new Exception("Could not deserialize {0} from XML data.".Build(typeof(T).Name), E);
                    Ex.Data.Add("XML Data", Xml);
                    throw Ex;
                }
            }
        }


    }





    public static bool IsValidPath(this string PathToCheck)
    {
        try
        {
            Path.GetFullPath(PathToCheck);
        }
        catch
        {
            return false;
        }
        return true;
    }

    public static bool IsRelativePath(this string PathToCheck)
    {
        if (IsValidPath(PathToCheck))
        {
            if (!Path.IsPathRooted(PathToCheck))
            {
                return true;
            }
        }
        return false;
    }


    public static DateTime ToDateTime(this string DateString, string DateFormat)
    {
        return DateTime.ParseExact(DateString, DateFormat, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.NoCurrentDateDefault);
    }


    public static DateTime ToDateTime(this string DateString, string[] DateFormats)
    {
        return DateTime.ParseExact(DateString, DateFormats, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.NoCurrentDateDefault);
    }

    public static bool IsDateTime(this string DateString, string[] DateFormats)
    {
        if (DateString == null) return false;
        DateTime Dummy;
        return (DateTime.TryParseExact(DateString, DateFormats, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.NoCurrentDateDefault, out Dummy));
    }

    public static bool IsDateTime(this string DateString, string DateFormat)
    {
        if (DateString == null) return false;
        DateTime Dummy;
        return (DateTime.TryParseExact(DateString, DateFormat, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.NoCurrentDateDefault, out Dummy));
    }


    public static string IndentString(this string StringToIndent, string IndentionString)
    {
        if (StringToIndent == null) { return null; }
        string[] Parts = StringToIndent.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.None);
        return IndentionString + string.Join(Environment.NewLine + IndentionString, Parts);
    }

    static public byte[] GetBytes(this string str)
    {
        byte[] bytes = new byte[str.Length * sizeof(char)];
        System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
        return bytes;
    }
}