¿Cómo contaría las ocurrencias de una cadena (en realidad un char) dentro de una cadena?

Estoy haciendo algo en el que me di cuenta de que quería contar cuántos /s podía encontrar en una cadena, y luego me di cuenta de que había varias formas de hacerlo, pero no podía decidir cuál era la mejor (o la más fácil). .

Por el momento voy con algo como:

string source = "/once/upon/a/time/";
int count = source.Length - source.Replace("/", "").Length;

Pero no me gusta en absoluto, ¿algún tomador?

Realmente no quiero cavar RegExpara esto, ¿verdad?

Sé que mi cadena tendrá el término que estoy buscando, por lo que puede suponer que ...

Por supuesto para cadenas donde longitud> 1 ,

string haystack = "/once/upon/a/time";
string needle = "/";
int needleCount = ( haystack.Length - haystack.Replace(needle,"").Length ) / needle.Length;

Si está utilizando .NET 3.5, puede hacerlo en una sola línea con LINQ:

int count = source.Count(f => f == '/');

Si no desea usar LINQ, puede hacerlo con:

int count = source.Split('/').Length - 1;

¡Te sorprenderá saber que tu técnica original parece ser aproximadamente un 30% más rápida que cualquiera de estas! Acabo de hacer un punto de referencia rápido con "/ once / upon / a / time /" y los resultados son los siguientes:

Su
fuente original = 12s. Cantidad = fuente 19s.
Split = 17s
foreach ( de la respuesta de bobwienholt ) = 10s

(Los tiempos son para 50,000,000 de iteraciones, por lo que es poco probable que note mucha diferencia en el mundo real).

string source = "/once/upon/a/time/";
int count = 0;
foreach (char c in source) 
  if (c == '/') count++;

Tiene que ser más rápido que el source.Replace()solo.

int count = new Regex(Regex.Escape(needle)).Matches(haystack).Count;

Si desea poder buscar cadenas enteras, y no solo caracteres:

src.Select((c, i) => src.Substring(i))
    .Count(sub => sub.StartsWith(target))

Lea como "para cada carácter de la cadena, tome el resto de la cadena a partir de ese carácter como una subcadena; cuéntelo si comienza con la cadena de destino".

Investigué un poco y descubrí que la solución de Richard Watson es la más rápida en la mayoría de los casos. Esa es la tabla con los resultados de cada solución en la publicación (excepto aquellos que usan Regex porque arroja excepciones al analizar cadenas como "test {test")

    Name      | Short/char |  Long/char | Short/short| Long/short |  Long/long |
    Inspite   |         134|        1853|          95|        1146|         671|
    LukeH_1   |         346|        4490|         N/A|         N/A|         N/A|
    LukeH_2   |         152|        1569|         197|        2425|        2171|
Bobwienholt   |         230|        3269|         N/A|         N/A|         N/A|
Richard Watson|          33|         298|         146|         737|         543|
StefanosKargas|         N/A|         N/A|         681|       11884|       12486|

Puede ver que en caso de encontrar el número de ocurrencias de subcadenas cortas (1-5 caracteres) en una cadena corta (10-50 caracteres), se prefiere el algoritmo original.

Además, para la subcadena de varios caracteres, debe usar el siguiente código (basado en la solución de Richard Watson )

int count = 0, n = 0;

if(substring != "")
{
    while ((n = source.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
    {
        n += substring.Length;
        ++count;
    }
}

LINQ funciona en todas las colecciones, y dado que las cadenas son solo una colección de personajes, ¿qué tal este simpático y sencillo:

var count = source.Count(c => c == '/');

Asegúrese de tener using System.Linq;en la parte superior de su archivo de código, ya que .Countes un método de extensión de ese espacio de nombres.

string source = "/once/upon/a/time/";
int count = 0;
int n = 0;

while ((n = source.IndexOf('/', n)) != -1)
{
   n++;
   count++;
}

En mi computadora es aproximadamente 2 segundos más rápido que la solución para cada personaje para 50 millones de iteraciones.

Revisión 2013:

Cambia la cadena a char [] e itera a través de eso. ¡Corta uno o dos segundos más del tiempo total para iteraciones de 50 m!

char[] testchars = source.ToCharArray();
foreach (char c in testchars)
{
     if (c == '/')
         count++;
}

Esto es más rápido aún:

char[] testchars = source.ToCharArray();
int length = testchars.Length;
for (int n = 0; n < length; n++)
{
    if (testchars[n] == '/')
        count++;
}

En buena medida, iterar desde el final de la matriz hasta 0 parece ser el más rápido, en aproximadamente un 5%.

int length = testchars.Length;
for (int n = length-1; n >= 0; n--)
{
    if (testchars[n] == '/')
        count++;
}

Me preguntaba por qué esto podría ser y estaba buscando en Google (recuerdo algo acerca de que la iteración inversa es más rápida), y me encontré con esta pregunta SO que molestamente usa la técnica string a char []. Sin embargo, creo que el truco de la inversión es nuevo en este contexto.

¿Cuál es la forma más rápida de iterar a través de caracteres individuales en una cadena en C #?

Ambos solo funcionan para términos de búsqueda de un solo carácter ...

countOccurences("the", "the answer is the answer");

int countOccurences(string needle, string haystack)
{
    return (haystack.Length - haystack.Replace(needle,"").Length) / needle.Length;
}

puede resultar mejor para agujas más largas ...

Pero tiene que haber una forma más elegante. :)

Editar:

source.Split('/').Length-1

En C #, un buen contador de String SubString es este tipo inesperadamente complicado:

public static int CCount(String haystack, String needle)
{
    return haystack.Split(new[] { needle }, StringSplitOptions.None).Length - 1;
}

Regex.Matches(input,  Regex.Escape("stringToMatch")).Count

private int CountWords(string text, string word) {
    int count = (text.Length - text.Replace(word, "").Length) / word.Length;
    return count;
}

Debido a que la solución original era la más rápida para los caracteres, supongo que también será para las cadenas. Así que aquí está mi contribución.

Para el contexto: estaba buscando palabras como 'fallido' y 'exitoso' en un archivo de registro.

Gr, Ben

string s = "65 fght 6565 4665 hjk";
int count = 0;
foreach (Match m in Regex.Matches(s, "65"))
  count++;

Para cualquiera que quiera un método de extensión String listo para usar,

Esto es lo que uso, que se basó en la mejor de las respuestas publicadas:

public static class StringExtension
{    
    /// <summary> Returns the number of occurences of a string within a string, optional comparison allows case and culture control. </summary>
    public static int Occurrences(this System.String input, string value, StringComparison stringComparisonType = StringComparison.Ordinal)
    {
        if (String.IsNullOrEmpty(value)) return 0;

        int count    = 0;
        int position = 0;

        while ((position = input.IndexOf(value, position, stringComparisonType)) != -1)
        {
            position += value.Length;
            count    += 1;
        }

        return count;
    }

    /// <summary> Returns the number of occurences of a single character within a string. </summary>
    public static int Occurrences(this System.String input, char value)
    {
        int count = 0;
        foreach (char c in input) if (c == value) count += 1;
        return count;
    }
}

public static int GetNumSubstringOccurrences(string text, string search)
{
    int num = 0;
    int pos = 0;

    if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(search))
    {
        while ((pos = text.IndexOf(search, pos)) > -1)
        {
            num ++;
            pos += search.Length;
        }
    }
    return num;
}

Creo que la forma más fácil de hacer esto es usar las expresiones regulares. De esta forma, puede obtener el mismo recuento dividido que podría usar myVar.Split ('x') pero en una configuración de múltiples caracteres.

string myVar = "do this to count the number of words in my wording so that I can word it up!";
int count = Regex.Split(myVar, "word").Length;

string search = "/string";
var occurrences = (regex.Match(search, @"\/")).Count;

Esto contará cada vez que el programa encuentre "/ s" exactamente (distingue entre mayúsculas y minúsculas) y el número de ocurrencias de esto se almacenará en la variable "ocurrencias"

Sentí que nos faltaban ciertos tipos de recuento de subcadenas, como comparaciones inseguras byte por byte. Reuní el método del póster original y cualquier método que se me ocurriera.

Estas son las extensiones de cadena que hice.

namespace Example
{
    using System;
    using System.Text;

    public static class StringExtensions
    {
        public static int CountSubstr(this string str, string substr)
        {
            return (str.Length - str.Replace(substr, "").Length) / substr.Length;
        }

        public static int CountSubstr(this string str, char substr)
        {
            return (str.Length - str.Replace(substr.ToString(), "").Length);
        }

        public static int CountSubstr2(this string str, string substr)
        {
            int substrlen = substr.Length;
            int lastIndex = str.IndexOf(substr, 0, StringComparison.Ordinal);
            int count = 0;
            while (lastIndex != -1)
            {
                ++count;
                lastIndex = str.IndexOf(substr, lastIndex + substrlen, StringComparison.Ordinal);
            }

            return count;
        }

        public static int CountSubstr2(this string str, char substr)
        {
            int lastIndex = str.IndexOf(substr, 0);
            int count = 0;
            while (lastIndex != -1)
            {
                ++count;
                lastIndex = str.IndexOf(substr, lastIndex + 1);
            }

            return count;
        }

        public static int CountChar(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            for (int i = 0; i < length; ++i)
                if (str[i] == substr)
                    ++count;

            return count;
        }

        public static int CountChar2(this string str, char substr)
        {
            int count = 0;
            foreach (var c in str)
                if (c == substr)
                    ++count;

            return count;
        }

        public static unsafe int CountChar3(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            fixed (char* chars = str)
            {
                for (int i = 0; i < length; ++i)
                    if (*(chars + i) == substr)
                        ++count;
            }

            return count;
        }

        public static unsafe int CountChar4(this string str, char substr)
        {
            int length = str.Length;
            int count = 0;
            fixed (char* chars = str)
            {
                for (int i = length - 1; i >= 0; --i)
                    if (*(chars + i) == substr)
                        ++count;
            }

            return count;
        }

        public static unsafe int CountSubstr3(this string str, string substr)
        {
            int length = str.Length;
            int substrlen = substr.Length;
            int count = 0;
            fixed (char* strc = str)
            {
                fixed (char* substrc = substr)
                {
                    int n = 0;

                    for (int i = 0; i < length; ++i)
                    {
                        if (*(strc + i) == *(substrc + n))
                        {
                            ++n;
                            if (n == substrlen)
                            {
                                ++count;
                                n = 0;
                            }
                        }
                        else
                            n = 0;
                    }
                }
            }

            return count;
        }

        public static int CountSubstr3(this string str, char substr)
        {
            return CountSubstr3(str, substr.ToString());
        }

        public static unsafe int CountSubstr4(this string str, string substr)
        {
            int length = str.Length;
            int substrLastIndex = substr.Length - 1;
            int count = 0;
            fixed (char* strc = str)
            {
                fixed (char* substrc = substr)
                {
                    int n = substrLastIndex;

                    for (int i = length - 1; i >= 0; --i)
                    {
                        if (*(strc + i) == *(substrc + n))
                        {
                            if (--n == -1)
                            {
                                ++count;
                                n = substrLastIndex;
                            }
                        }
                        else
                            n = substrLastIndex;
                    }
                }
            }

            return count;
        }

        public static int CountSubstr4(this string str, char substr)
        {
            return CountSubstr4(str, substr.ToString());
        }
    }
}

Seguido por el código de prueba ...

static void Main()
{
    const char matchA = '_';
    const string matchB = "and";
    const string matchC = "muchlongerword";
    const string testStrA = "_and_d_e_banna_i_o___pfasd__and_d_e_banna_i_o___pfasd_";
    const string testStrB = "and sdf and ans andeians andano ip and and sdf and ans andeians andano ip and";
    const string testStrC =
        "muchlongerword amuchlongerworsdfmuchlongerwordsdf jmuchlongerworijv muchlongerword sdmuchlongerword dsmuchlongerword";
    const int testSize = 1000000;
    Console.WriteLine(testStrA.CountSubstr('_'));
    Console.WriteLine(testStrA.CountSubstr2('_'));
    Console.WriteLine(testStrA.CountSubstr3('_'));
    Console.WriteLine(testStrA.CountSubstr4('_'));
    Console.WriteLine(testStrA.CountChar('_'));
    Console.WriteLine(testStrA.CountChar2('_'));
    Console.WriteLine(testStrA.CountChar3('_'));
    Console.WriteLine(testStrA.CountChar4('_'));
    Console.WriteLine(testStrB.CountSubstr("and"));
    Console.WriteLine(testStrB.CountSubstr2("and"));
    Console.WriteLine(testStrB.CountSubstr3("and"));
    Console.WriteLine(testStrB.CountSubstr4("and"));
    Console.WriteLine(testStrC.CountSubstr("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr2("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr3("muchlongerword"));
    Console.WriteLine(testStrC.CountSubstr4("muchlongerword"));
    var timer = new Stopwatch();
    timer.Start();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr(matchA);
    timer.Stop();
    Console.WriteLine("CS1 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr(matchB);
    timer.Stop();
    Console.WriteLine("CS1 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr(matchC);
    timer.Stop();
    Console.WriteLine("CS1 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr2(matchA);
    timer.Stop();
    Console.WriteLine("CS2 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr2(matchB);
    timer.Stop();
    Console.WriteLine("CS2 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr2(matchC);
    timer.Stop();
    Console.WriteLine("CS2 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr3(matchA);
    timer.Stop();
    Console.WriteLine("CS3 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr3(matchB);
    timer.Stop();
    Console.WriteLine("CS3 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr3(matchC);
    timer.Stop();
    Console.WriteLine("CS3 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountSubstr4(matchA);
    timer.Stop();
    Console.WriteLine("CS4 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrB.CountSubstr4(matchB);
    timer.Stop();
    Console.WriteLine("CS4 and: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrC.CountSubstr4(matchC);
    timer.Stop();
    Console.WriteLine("CS4 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar(matchA);
    timer.Stop();
    Console.WriteLine("CC1 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar2(matchA);
    timer.Stop();
    Console.WriteLine("CC2 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar3(matchA);
    timer.Stop();
    Console.WriteLine("CC3 chr: " + timer.Elapsed.TotalMilliseconds + "ms");

    timer.Restart();
    for (int i = 0; i < testSize; ++i)
        testStrA.CountChar4(matchA);
    timer.Stop();
    Console.WriteLine("CC4 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
}

Resultados: CSX se corresponde con CountSubstrX y CCX se corresponde con CountCharX. "chr" busca una cadena para '_', "y" busca una cadena para "y", y "mlw" busca una cadena para "muchlongerword"

CS1 chr: 824.123ms
CS1 and: 586.1893ms
CS1 mlw: 486.5414ms
CS2 chr: 127.8941ms
CS2 and: 806.3918ms
CS2 mlw: 497.318ms
CS3 chr: 201.8896ms
CS3 and: 124.0675ms
CS3 mlw: 212.8341ms
CS4 chr: 81.5183ms
CS4 and: 92.0615ms
CS4 mlw: 116.2197ms
CC1 chr: 66.4078ms
CC2 chr: 64.0161ms
CC3 chr: 65.9013ms
CC4 chr: 65.8206ms

Y finalmente, tenía un archivo con 3.6 millones de caracteres. Fue "derp adfderdserp dfaerpderp deasderp" repetido 100.000 veces. Busqué "derp" dentro del archivo con los métodos anteriores 100 veces estos resultados.

CS1Derp: 1501.3444ms
CS2Derp: 1585.797ms
CS3Derp: 376.0937ms
CS4Derp: 271.1663ms

Entonces, mi cuarto método es definitivamente el ganador, pero, de manera realista, si un archivo de 3.6 millones de caracteres 100 veces solo tomaba 1586ms como el peor de los casos, entonces todo esto es bastante insignificante.

Por cierto, también escaneé el 'd' char en el archivo de 3,6 millones de caracteres con 100 veces los métodos CountSubstr y CountChar. Resultados ...

CS1  d : 2606.9513ms
CS2  d : 339.7942ms
CS3  d : 960.281ms
CS4  d : 233.3442ms
CC1  d : 302.4122ms
CC2  d : 280.7719ms
CC3  d : 299.1125ms
CC4  d : 292.9365ms

El método original de carteles es muy malo para agujas de un solo personaje en un gran pajar de acuerdo con esto.

Nota: Todos los valores se actualizaron a la versión de lanzamiento. Accidentalmente olvidé construir en modo Release la primera vez que publiqué esto. Algunas de mis declaraciones han sido enmendadas.

Una función genérica para ocurrencias de cadenas:

public int getNumberOfOccurencies(String inputString, String checkString)
{
    if (checkString.Length > inputString.Length || checkString.Equals("")) { return 0; }
    int lengthDifference = inputString.Length - checkString.Length;
    int occurencies = 0;
    for (int i = 0; i < lengthDifference; i++) {
        if (inputString.Substring(i, checkString.Length).Equals(checkString)) { occurencies++; i += checkString.Length - 1; } }
    return occurencies;
}

string source = "/once/upon/a/time/";
int count = 0, n = 0;
while ((n = source.IndexOf('/', n) + 1) != 0) count++;

Una variación en la respuesta de Richard Watson, un poco más rápido con la mejora de la eficiencia, ¡cuantas más veces se produce el char en la cadena y menos código!

Aunque debo decir que, sin probar exhaustivamente cada escenario, vi una mejora de velocidad muy significativa al usar:

int count = 0;
for (int n = 0; n < source.Length; n++) if (source[n] == '/') count++;

            var conditionalStatement = conditionSetting.Value;

            //order of replace matters, remove == before =, incase of ===
            conditionalStatement = conditionalStatement.Replace("==", "~").Replace("!=", "~").Replace('=', '~').Replace('!', '~').Replace('>', '~').Replace('<', '~').Replace(">=", "~").Replace("<=", "~");

            var listOfValidConditions = new List<string>() { "!=", "==", ">", "<", ">=", "<=" };

            if (conditionalStatement.Count(x => x == '~') != 1)
            {
                result.InvalidFieldList.Add(new KeyFieldData(batch.DECurrentField, "The IsDoubleKeyCondition does not contain a supported conditional statement. Contact System Administrator."));
                result.Status = ValidatorStatus.Fail;
                return result;
            }

Necesitaba hacer algo similar para probar las declaraciones condicionales de una cadena.

Reemplacé lo que estaba buscando con un solo personaje y conté las instancias del único personaje.

Obviamente, el carácter único que está utilizando deberá verificarse para que no exista en la cadena antes de que esto ocurra para evitar conteos incorrectos.

Cadena en cadena:

Encuentra "etc" en ".. JD JD JD JD etc. y etc. JDJDJDJDJDJDJDJD y etc."

var strOrigin = " .. JD JD JD JD etc. and etc. JDJDJDJDJDJDJDJD and etc.";
var searchStr = "etc";
int count = (strOrigin.Length - strOrigin.Replace(searchStr, "").Length)/searchStr.Length.

Verifique el rendimiento antes de descartar este como poco sólido / torpe ...

Mi primera toma me dio algo como:

public static int CountOccurrences(string original, string substring)
{
    if (string.IsNullOrEmpty(substring))
        return 0;
    if (substring.Length == 1)
        return CountOccurrences(original, substring[0]);
    if (string.IsNullOrEmpty(original) ||
        substring.Length > original.Length)
        return 0;
    int substringCount = 0;
    for (int charIndex = 0; charIndex < original.Length; charIndex++)
    {
        for (int subCharIndex = 0, secondaryCharIndex = charIndex; subCharIndex < substring.Length && secondaryCharIndex < original.Length; subCharIndex++, secondaryCharIndex++)
        {
            if (substring[subCharIndex] != original[secondaryCharIndex])
                goto continueOuter;
        }
        if (charIndex + substring.Length > original.Length)
            break;
        charIndex += substring.Length - 1;
        substringCount++;
    continueOuter:
        ;
    }
    return substringCount;
}

public static int CountOccurrences(string original, char @char)
{
    if (string.IsNullOrEmpty(original))
        return 0;
    int substringCount = 0;
    for (int charIndex = 0; charIndex < original.Length; charIndex++)
        if (@char == original[charIndex])
            substringCount++;
    return substringCount;
}

La aguja en un enfoque de pajar que usa reemplazo y división rinde más de 21 segundos, mientras que esto toma aproximadamente 15.2.

Edite después de agregar un bit que agregaría substring.Length - 1al charIndex (como debería), es de 11.6 segundos.

Edición 2: utilicé una cadena que tenía 26 cadenas de dos caracteres, aquí están los tiempos actualizados a los mismos textos de muestra:

Aguja en un pajar (versión de OP): 7.8 segundos

Mecanismo sugerido: 4.6 segundos.

Edición 3: agregando el caso de esquina de un solo carácter, pasó a 1.2 segundos.

Edición 4: Para el contexto: se usaron 50 millones de iteraciones.

Pensé que lanzaría mi método de extensión al ring (ver comentarios para más información). No he hecho ninguna marca formal de banco, pero creo que tiene que ser muy rápido para la mayoría de los escenarios.

EDITAR: OK, así que esta pregunta SO me hizo preguntarme cómo se compararía el rendimiento de nuestra implementación actual con algunas de las soluciones presentadas aquí. Decidí hacer una pequeña marca de banco y descubrí que nuestra solución estaba muy en línea con el rendimiento de la solución proporcionada por Richard Watson hasta que realiza una búsqueda agresiva con cadenas grandes (100 Kb +), subcadenas grandes (32 Kb + ) y muchas repeticiones integradas (10K +). En ese momento, nuestra solución fue alrededor de 2X a 4X más lenta. Dado esto y el hecho de que realmente nos gusta la solución presentada por Richard Watson, hemos refactorizado nuestra solución en consecuencia. Solo quería que esto estuviera disponible para cualquiera que pudiera beneficiarse de él.

Nuestra solución original:

    /// <summary>
    /// Counts the number of occurrences of the specified substring within
    /// the current string.
    /// </summary>
    /// <param name="s">The current string.</param>
    /// <param name="substring">The substring we are searching for.</param>
    /// <param name="aggressiveSearch">Indicates whether or not the algorithm 
    /// should be aggressive in its search behavior (see Remarks). Default 
    /// behavior is non-aggressive.</param>
    /// <remarks>This algorithm has two search modes - aggressive and 
    /// non-aggressive. When in aggressive search mode (aggressiveSearch = 
    /// true), the algorithm will try to match at every possible starting 
    /// character index within the string. When false, all subsequent 
    /// character indexes within a substring match will not be evaluated. 
    /// For example, if the string was 'abbbc' and we were searching for 
    /// the substring 'bb', then aggressive search would find 2 matches 
    /// with starting indexes of 1 and 2. Non aggressive search would find 
    /// just 1 match with starting index at 1. After the match was made, 
    /// the non aggressive search would attempt to make it's next match 
    /// starting at index 3 instead of 2.</remarks>
    /// <returns>The count of occurrences of the substring within the string.</returns>
    public static int CountOccurrences(this string s, string substring, 
        bool aggressiveSearch = false)
    {
        // if s or substring is null or empty, substring cannot be found in s
        if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(substring))
            return 0;

        // if the length of substring is greater than the length of s,
        // substring cannot be found in s
        if (substring.Length > s.Length)
            return 0;

        var sChars = s.ToCharArray();
        var substringChars = substring.ToCharArray();
        var count = 0;
        var sCharsIndex = 0;

        // substring cannot start in s beyond following index
        var lastStartIndex = sChars.Length - substringChars.Length;

        while (sCharsIndex <= lastStartIndex)
        {
            if (sChars[sCharsIndex] == substringChars[0])
            {
                // potential match checking
                var match = true;
                var offset = 1;
                while (offset < substringChars.Length)
                {
                    if (sChars[sCharsIndex + offset] != substringChars[offset])
                    {
                        match = false;
                        break;
                    }
                    offset++;
                }
                if (match)
                {
                    count++;
                    // if aggressive, just advance to next char in s, otherwise, 
                    // skip past the match just found in s
                    sCharsIndex += aggressiveSearch ? 1 : substringChars.Length;
                }
                else
                {
                    // no match found, just move to next char in s
                    sCharsIndex++;
                }
            }
            else
            {
                // no match at current index, move along
                sCharsIndex++;
            }
        }

        return count;
    }

Y aquí está nuestra solución revisada:

    /// <summary>
    /// Counts the number of occurrences of the specified substring within
    /// the current string.
    /// </summary>
    /// <param name="s">The current string.</param>
    /// <param name="substring">The substring we are searching for.</param>
    /// <param name="aggressiveSearch">Indicates whether or not the algorithm 
    /// should be aggressive in its search behavior (see Remarks). Default 
    /// behavior is non-aggressive.</param>
    /// <remarks>This algorithm has two search modes - aggressive and 
    /// non-aggressive. When in aggressive search mode (aggressiveSearch = 
    /// true), the algorithm will try to match at every possible starting 
    /// character index within the string. When false, all subsequent 
    /// character indexes within a substring match will not be evaluated. 
    /// For example, if the string was 'abbbc' and we were searching for 
    /// the substring 'bb', then aggressive search would find 2 matches 
    /// with starting indexes of 1 and 2. Non aggressive search would find 
    /// just 1 match with starting index at 1. After the match was made, 
    /// the non aggressive search would attempt to make it's next match 
    /// starting at index 3 instead of 2.</remarks>
    /// <returns>The count of occurrences of the substring within the string.</returns>
    public static int CountOccurrences(this string s, string substring, 
        bool aggressiveSearch = false)
    {
        // if s or substring is null or empty, substring cannot be found in s
        if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(substring))
            return 0;

        // if the length of substring is greater than the length of s,
        // substring cannot be found in s
        if (substring.Length > s.Length)
            return 0;

        int count = 0, n = 0;
        while ((n = s.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
        {
            if (aggressiveSearch)
                n++;
            else
                n += substring.Length;
            count++;
        }

        return count;
    }

string Name = "Very good nice one is very good but is very good nice one this is called the term";
bool valid=true;
int count = 0;
int k=0;
int m = 0;
while (valid)
{
    k = Name.Substring(m,Name.Length-m).IndexOf("good");
    if (k != -1)
    {
        count++;
        m = m + k + 4;
    }
    else
        valid = false;
}
Console.WriteLine(count + " Times accures");

string s = "HOWLYH THIS ACTUALLY WORKSH WOWH";
int count = 0;
for (int i = 0; i < s.Length; i++)
   if (s[i] == 'H') count++;

Simplemente verifica cada carácter en la cadena, si el carácter es el carácter que está buscando, agregue uno para contar.

Si visita esta página web , se comparan 15 formas diferentes de hacerlo, incluido el uso de bucles paralelos.

Parece que la forma más rápida es usar un solo bucle for roscado (si tiene una versión .Net <4.0) o un bucle paralelo .for (si usa .Net> 4.0 con miles de comprobaciones).

Suponiendo que "ss" es su Cadena de búsqueda, "ch" es su matriz de caracteres (si tiene más de un carácter que está buscando), aquí está la esencia básica del código que tuvo el tiempo de ejecución más rápido de un solo subproceso:

for (int x = 0; x < ss.Length; x++)
{
    for (int y = 0; y < ch.Length; y++)
    {
        for (int a = 0; a < ss[x].Length; a++ )
        {
        if (ss[x][a] == ch[y])
            //it's found. DO what you need to here.
        }
    }
}

También se proporciona el código fuente de referencia para que pueda ejecutar sus propias pruebas.

str="aaabbbbjjja";
int count = 0;
int size = str.Length;

string[] strarray = new string[size];
for (int i = 0; i < str.Length; i++)
{
    strarray[i] = str.Substring(i, 1);
}
Array.Sort(strarray);
str = "";
for (int i = 0; i < strarray.Length - 1; i++)
{

    if (strarray[i] == strarray[i + 1])
    {

        count++;
    }
    else
    {
        count++;
        str = str + strarray[i] + count;
        count = 0;
    }

}
count++;
str = str + strarray[strarray.Length - 1] + count;

Esto es para contar la ocurrencia del personaje. Para este ejemplo, la salida será "a4b4j3"

Para el caso de un delimitador de cadena (no para el caso de char, como dice el sujeto):
string source = "@@@ once @@@ upon @@@ a @@@ time @@@";
int count = source.Split (new [] {"@@@"}, StringSplitOptions.RemoveEmptyEntries) .Length - 1;

El delimitador natural del valor fuente original del póster ("/ once / upon / a / time /") es un char '/' y las respuestas explican la opción source.Split (char []) aunque ...

usando System.Linq;

int CountOf => "A :: BC :: D" .Split ("::"). Longitud - 1;