extensions/StringExtensions.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Chrosey.Extensions
{
    public static class StringExtensions
    {
        /// <summary>
        /// Vergleicht 2 Strings Phonetisch und gibt wahr zurück, wenn sich der erste im zweiten befindet
        /// </summary>
        /// <param name="lookFor"></param>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool ComparePhonetic(this string lookFor, string source)
        {
            if (string.IsNullOrEmpty(lookFor))
            {
                return true;
            }
            if (string.IsNullOrEmpty(source))
            {
                return false;
            }
            var a = lookFor.KoelnPhonetic();
            var b = source.KoelnPhonetic();

            return b.IndexOf(a) >= 0;
        }

        /// <summary>
        /// Erstellt aus dem String die Kölner Phonetic Folge
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string KoelnPhonetic(this string input)
        {
            var trimmed = input.Trim();
            var lower = trimmed.ToLower();
            var replacedSpecialChars = lower
                .Replace('ä', 'a')
                .Replace('ö', 'o')
                .Replace('u', 'u')
                .Replace("ß", "ss")
                .Replace('é', 'e')
                .Replace('è', 'e')
                .Replace('à', 'a');

            var withMarkers = "#" + replacedSpecialChars + "#";

            var codeh = new[] { "h" };
            var code0 = new[] { "a", "e", "i", "j", "o", "u", "y" };
            var code1 = new[] { "b", "p" };
            var code2 = new[] { "d", "t" };
            var code3 = new[] { "f", "v", "w" };
            var code4 = new[] { "g", "k", "q" };
            var code5 = new[] { "l" };
            var code6 = new[] { "m", "n" };
            var code7 = new[] { "r" };
            var code8 = new[] { "c", "s", "z" };
            var code48 = new[] { "x" };
            var code4combifirst = new[] { "a", "o", "u", "h", "k", "x", "q", "l", "r" };
            var code4combi = new[] { "a", "o", "u", "h", "k", "x", "q" };
            var code8combi = new[] { "c", "k", "q" };

            var asNumber = string.Empty;
            for (int i = 1; i < withMarkers.Length - 1; i++)
            {
                var prev = withMarkers[i - 1].ToString();
                var curr = withMarkers[i].ToString();
                var next = withMarkers[i + 1].ToString();

                string number;

                if (i == 1)
                {
                    if (code0.Contains(curr)) number = "0";
                    else if (curr == "c" && code4combifirst.Contains(next)) number = "4";
                    else if (code2.Contains(curr) && code8.Contains(next)) number = "8";
                    else if (curr == "x") number = "48";
                    else if (codeh.Contains(curr)) number = "-";
                    else if (code1.Contains(curr)) number = "1";
                    else if (code2.Contains(curr)) number = "2";
                    else if (code3.Contains(curr)) number = "3";
                    else if (code4.Contains(curr)) number = "4";
                    else if (code5.Contains(curr)) number = "5";
                    else if (code6.Contains(curr)) number = "6";
                    else if (code7.Contains(curr)) number = "7";
                    else if (code8.Contains(curr)) number = "8";
                    else number = "?";
                }
                else
                {
                    if (code2.Contains(curr) && code8.Contains(next)) number = "8";
                    else if (code8combi.Contains(prev) && code48.Contains(curr)) number = "8";
                    else if (curr == "x") number = "48";
                    else if (prev == "s" && (curr == "c" || curr == "z")) number = "8";
                    else if (curr == "c" && code4combi.Contains(next)) number = "4";

                    else if (curr == "h") number = "-";
                    else if (code0.Contains(curr)) number = "0";
                    else if (code1.Contains(curr)) number = "1";
                    else if (code2.Contains(curr)) number = "2";
                    else if (code3.Contains(curr)) number = "3";
                    else if (code4.Contains(curr)) number = "4";
                    else if (code5.Contains(curr)) number = "5";
                    else if (code6.Contains(curr)) number = "6";
                    else if (code7.Contains(curr)) number = "7";
                    else if (code8.Contains(curr)) number = "8";
                    else number = "?";
                }

                asNumber += number;
            }

            var withoutH = asNumber.Replace("-", "");
            var zerosRemoved = withoutH[0] + withoutH.Substring(1).Replace("0", "");

            var duplicatesRemoved = zerosRemoved[0].ToString();
            for (int i = 1; i < zerosRemoved.Length; i++)
            {
                var curr = zerosRemoved[i].ToString();
                var prev = zerosRemoved[i - 1].ToString();
                if (curr != prev)
                {
                    duplicatesRemoved += curr;
                }
            }

            return duplicatesRemoved;
        }

        /// <summary>
        /// Formatiert einen Eigenschaftsnamen mit Wert zum passenden Formatierten String
        /// </summary>
        /// <param name="propertyName">der aktuelle String</param>
        /// <param name="value">der Wert der Eigenschaft</param>
        /// <param name="format" default="(propertyName=value)">Das Format in dem die Rückgabe erfolgen soll</param>
        /// <returns>Normales Format "(propertyName=value)</returns>
        public static string PropertyValueFormat(this string propertyName, object value, string format = "({0}={1})")
        {
            return string.Format(format, propertyName, value.ToString());
        }

        public static string FirstUpper(this string me)
        {
            if (string.IsNullOrEmpty(me))
            {
                return string.Empty;
            }
            return char.ToUpper(me[0]) + me.Substring(1);
        }

        public static string AsFormat(this string format, params object[] args)
        {
            return string.Format(format, args);
        }
        public static string ReplaceUmlaute(this string input)
        {
            return input.ToLower().Replace("ä", "ae").Replace("ü", "ue").Replace("ö", "oe").Replace("ß", "ss").Replace("é", "e");
        }

        public static string PlaceUmlaute(this string input)
        {
            return input.Replace("ae", "ä").Replace("oe", "ö").Replace("ue", "ü").Replace("ss", "ß").Replace("aü", "aue").Replace("chäl", "chael").Replace("ßl", "ssl");
        }

        public static string ShuffleTextSecure(this string source)
        {
            return new string(source.ShuffleSecure<char>().ToArray<char>());
        }

        public static bool IsNumeric(this string value)
        {
            return int.TryParse(value, out int _);
        }

        public static bool IsDate(this string value)
        {
            return DateTime.TryParse(value, out DateTime _);
        }

        public static int LevenshteinDistance(this string a, string b)
        {
            int length1 = a.Length;
            int length2 = b.Length;
            if (length1 == 0)
                return length2;
            if (length2 == 0)
                return length1;
            int[,] numArray = new int[length1 + 1, length2 + 1];
            int index1 = 0;
            while (index1 <= length1)
                numArray[index1, 0] = index1++;
            int index2 = 0;
            while (index2 <= length2)
                numArray[0, index2] = index2++;
            for (int index3 = 1; index3 <= length1; ++index3)
            {
                for (int index4 = 1; index4 <= length2; ++index4)
                {
                    int num = (int)b[index4 - 1] == (int)a[index3 - 1] ? 0 : 1;
                    numArray[index3, index4] = Math.Min(Math.Min(numArray[index3 - 1, index4] + 1, numArray[index3, index4 - 1] + 1), numArray[index3 - 1, index4 - 1] + num);
                }
            }
            return numArray[length1, length2];
        }
    }
}