C # Regex: Comment puis-je remplacer Tokens avec des chaînes à Generated d'exécution?

Question

Compte tenu des chaînes d'entrée et regex suivantes:

const string inputString = "${Principal}*${Rate}*${Years}";
const string tokenMatchRegexString = @"\${([^}]+)}";

Comment puis-je remplacer chaque jeton (à savoir $ {} principal, $ {} Taux, et $ {} ans) avec la valeur de retour de ma fonction 'ReplaceToken'?

private static string ReplaceToken(string tokenString)
{
    switch (tokenString)
    {
        case "Principal":
            return GetPrincipal();
        case "Rate":
            return GetRate();
        case "Years":
            return GetYears();
        default:
            throw new NotImplementedException(String.Format("A replacment for the token '{0}' has not been implemented.", tokenString));
    }
}

private static string GetPrincipal()
{
    throw new NotImplementedException();
}

private static string GetRate()
{
    throw new NotImplementedException();
}

private static string GetYears()
{
    throw new NotImplementedException();
}

Answer 1

Regex a une surcharge qui prend une MatchEvaluator. L'entrée est un match, et il renvoie une chaîne. La valeur du match dans ce cas serait tout le jeton, vous pouvez créer une cale qui extrait la valeur (vous capturez déjà au sein de votre Regex) et adapte à la méthode que vous avez publié.

Regex.Replace(inputString,
              tokenMatchRegexString,
              match => TokenReplacement(match.Groups[1].Value));

Answer 2

Si vous avez vraiment juste un petit nombre de jetons pour remplacer ce que vous savez à l'avance, vous pouvez utiliser string.Replace() simplement remplacer les jetons un par un. Cette technique simple peut fonctionner, mais il présente des inconvénients. Il est pas particulièrement extensible, elle peut entraîner des chaînes intermédiaires (jetables), et il peut également rendre le code source de confusion.

Si vous attendez d'avoir beaucoup de jetons différents et ils ont des règles de correspondance cohérentes, vous pouvez utiliser Regex.Replace() qui prend un délégué MatchEvaluator - essentiellement fonction qui accepte une correspondance d'une expression régulière et retourne une chaîne pour remplacer le match avec. L'avantage d'utiliser la surcharge de Replace() qui prend MatchEvaluator est qu'il permet d'éviter la création de chaînes intermédiaires qui sont ensuite utilisés pour remplacer tout le match suivant. Il est également agréable de réutiliser des classes intégrées .NET, plutôt que vos propres modèles.

Enfin, si vous avez vraiment complexes correspondance / exigences de substitution, vous pouvez utiliser les bibliothèques comme StringTemplate faire plus complexes extensions de modèles et substitution de correspondance.

Voici un exemple d'utilisation de l'appel Regex.Replace():

const string inputString = "${Principal}*${Rate}*${Years}";
const string tokenMatchRegexString = @"\${([^}]+)}";

var rex = new Regex( tokenMatchRegexString );
MatchEvaluator matchEval = match => TokenReplacement( match.Groups[1].Value );

rex.Replace( inputString, matchEval );

Answer 3

Ne pas réinventer la roue. J'utilise StringTemplate (la version C #) lorsque vous faites des choses comme ça.