Luego de leer los artículos publicados por Manuel (a.k.a melkorcete), me parece que se olvidó comentar que no siempre es mejor usar Expresiones Regulares.
A continuación, un ejemplo -trivial- que pone en mayúsculas las letras que son precedidas por espacios en blanco. La diferencia en rendimiento, se nota más cuando el texto es más grande.
csharp:
using System;
using System.
Collections.
Generic;
using System.
Text;
using System.
Text.
RegularExpressions;
using System.
Diagnostics;
class Program
{
delegate string DoCapitalize(string str);
static Stopwatch clock = new Stopwatch();
static Dictionary<string, double> stats = new Dictionary<string,double>();
static void Run(string str, DoCapitalize method)
{
clock.Stop();
clock.Reset();
clock.Start();
method(str);
clock.Stop();
if (stats.ContainsKey(method.Method.Name))
stats[method.Method.Name] += clock.ElapsedTicks;
else
stats[method.Method.Name] = clock.ElapsedTicks;
}
static void Main(string[] args)
{
string str = @"Cada año y medio los computadores doblan su velocidad,
entonces sale otra versión de Windows, que los ralentiza a su velocidad original";
DoCapitalize regex = new DoCapitalize(RegexCapitalize);
DoCapitalize normal = new DoCapitalize(Capitalize);
Console.Read();
int n = 1000;
for (int i = 0; i < n; i++)
{
Run(str, regex);
Run(str, normal);
}
Console.WriteLine("\tStats for {0} iterations\n", n);
foreach(KeyValuePair<string, double> item in stats)
{
Console.WriteLine("{0} --> Tiempo: {1:.##}", item.Key, item.Value / n);
}
}
static string RegexCapitalize(string str)
{
return Regex.Replace(str, @"\s[a-z]", new MatchEvaluator(ToUpper)); // @"\s."
}
static string ToUpper(Match m)
{
return m.Value.ToUpper();
}
static string Capitalize(string str)
{
StringBuilder sb=new StringBuilder();
sb.Append(str[0].ToString().ToUpper());
for (int i = 1; i < str.Length; i++)
{
char c = str[i];
if (char.IsWhiteSpace(str[i-1]) && char.IsLower(c))
c = char.ToUpper(c);
sb.Append(c);
}
return sb.ToString();
}
}
Cabe destacar que implementar nuestros propios métodos, puede tener consecuencias no deseadas, como el tiempo necesario para implementar un algoritmo alternativo y más importante, la eficiencia del mismo.