C# Dénuder/convertir un ou plusieurs caractères

Question

Existe-t-il un moyen rapide (sans avoir à faire explicitement une boucle sur chaque caractère d'une chaîne) et de l'enlever ou de le conserver. Dans Visual FoxPro, il existe une fonction CHRTRAN() qui le fait génial. C'est sur un remplacement de 1: 1 caractères, mais si aucun caractère dans la position de remplacement, son dépouillé de la chaîne finale. Ex

CHRTRAN ("Ce sera un test", "il", "X")

retournera

"Thxs wXll être un es"

avis l'original "i" est converti en "X", et en minuscule "t" est effacé.

J'ai regardé le remplacement pour l'intention semblable, mais n'ai pas vu une option pour remplacer avec rien.

Je cherche à créer des routines génériques pour valider plusieurs origines de données qui ont différents types de restrictions d'entrée. Certaines des données peuvent provenir de sources externes, donc ce n'est pas seulement une validation d'entrée de zone de texte que je dois tester.

Merci

Answer 1

Voici ma dernière fonction et fonctionne parfaitement comme prévu.

public static String ChrTran(String ToBeCleaned, 
          String ChangeThese, 
          String IntoThese) 
{ 
    String CurRepl = String.Empty; 
    for (int lnI = 0; lnI < ChangeThese.Length; lnI++) 
    { 
     if (lnI < IntoThese.Length) 
     CurRepl = IntoThese.Substring(lnI, 1); 
     else 
     CurRepl = String.Empty; 

     ToBeCleaned = ToBeCleaned.Replace(ChangeThese.Substring(lnI, 1), CurRepl); 
    } 
    return ToBeCleaned; 
} 

Answer 2

Tout ce que vous avez besoin est quelques appels à String.Replace().

string s = "This will be a test"; 
s = s.Replace("i", "X"); 
s = s.Replace("t", ""); 

Notez que Remplacer() retours une nouvelle chaîne. Cela ne modifie pas la chaîne elle-même.

Answer 3

Est-ce-que vous voulez?

"This will be a test".Replace("i", "X").Replace("t", String.Empty) 

Voici une implémentation simple de la fonction CHRTRAN - il ne fonctionne pas si la chaîne contient \0 et est tout à fait désordre. Vous pourriez écrire un plus joli en utilisant des boucles, mais je voulais juste l'essayer en utilisant LINQ.

public static String ChrTran(String input, String source, String destination) 
{ 
    return source.Aggregate(
     input, 
     (current, symbol) => current.Replace(
      symbol, 
      destination.ElementAtOrDefault(source.IndexOf(symbol))), 
     preResult => preResult.Replace("\0", String.Empty)); 
} 

Et vous pouvez l'utiliser.

// Returns "ThXs wXll be a es" 
String output = ChrTran("This will be a test", "it", "X"); 

Juste pour avoir une solution propre - même sans LINQ et travailler pour les \0 cas aussi, et il est presque en place à cause de l'utilisation d'un StringBuilder mais ne modifiera pas l'entrée, bien sûr.

public static String ChrTran(String input, String source, String destination) 
{ 
    StringBuilder result = new StringBuilder(input); 

    Int32 minLength = Math.Min(source.Length, destination.Length); 

    for (Int32 i = 0; i < minLength; i++) 
    { 
     result.Replace(source[i], destination[i]); 
    } 

    for (Int32 i = minLength; i < searchPattern.Length; i++) 
    { 
     result.Replace(source[i].ToString(), String.Empty); 
    } 

    return result.ToString(); 
} 

La gestion des références nulles est manquante. Inspiré par la solution de tvanfosson, j'ai donné un second coup à LINQ.

public static String ChrTran(String input, String source, String destination) 
{ 
    return new String(input. 
     Where(symbol => 
      !source.Contains(symbol) || 
      source.IndexOf(symbol) < destination.Length). 
     Select(symbol => 
      source.Contains(symbol) 
       ? destination[source.IndexOf(symbol)] 
       : symbol). 
     ToArray()); 
} 

Answer 4

Pour "remplacer par rien", il suffit de remplacer par une chaîne vide. Cela vous donnera:

String str = "This will be a test"; 
str = str.Replace("i", "X"); 
str = str.Replace("t",""); 

Answer 5

Une version plus générale comme une extension de chaîne. Comme les autres, ceci n'effectue pas de traduction car les chaînes sont immuables en C#, mais renvoie une nouvelle chaîne avec les remplacements spécifiés.

public static class StringExtensions 
{ 
    public static string Translate(this string source, string from, string to) 
    { 
     if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(from)) 
     { 
      return source; 
     } 

     return string.Join("", source.ToCharArray() 
            .Select(c => Translate(c, from, to)) 
            .Where(c => c != null) 
            .ToArray()); 
    } 

    private static string Translate(char c, string from, string to) 
    { 
     int i = from != null ? from.IndexOf(c) : -1; 
     if (i >= 0) 
     { 
      return (to != null && to.Length > i) 
         ? to[i].ToString() 
         : null; 
     } 
     else 
     { 
      return c.ToString(); 
     } 
    } 
} 

Answer 6

Ceci est un cas où je pense que l'utilisation de LINQ complique le sujet. C'est simple et précis:

private static string Translate(string input, string from, string to) 
{ 
    StringBuilder sb = new StringBuilder(); 
    foreach (char ch in input) 
    { 
     int i = from.IndexOf(ch); 
     if (from.IndexOf(ch) < 0) 
     { 
      sb.Append(ch); 
     } 
     else 
     { 
      if (i >= 0 && i < to.Length) 
      { 
       sb.Append(to[i]); 
      } 
     } 
    } 
    return sb.ToString(); 
} 

Answer 7

 public static string ChrTran(string cSearchIn, string cSearchFor, string cReplaceWith) 
     { 
      string result = ""; 
      dynamic inArray = cSearchIn.ToCharArray(); 
      foreach (var caracter in inArray) 
      { 
       int position = cSearchFor.IndexOf(caracter); 
       result = result + cReplaceWith.Substring(position, 1);
 

 } 

     return result; 
    }</pre>