C# 将新值赋给字符串索引

我需要将用户输入字符串中的字符

a

，

e

，

I

，

o

，

u

转换为指定的符号。以下是我到目前为止的情况

学校作业

首先提示用户输入加密的文本字符串。验证此选项是否未保留为空。将此文本字符串发送到您将创建的自定义方法中，该方法将对其进行解密。解密后，将此文本字符串返回到main，在那里您将输出加密和解密的字符串

要破译文本字符串，必须执行以下字符替换：

• @

  =

  a

• #

  =

  e

• ^

  =

  i

• *

  =

  o

• +

  =

  u

我的当前代码

public static string Decipher (string code)
{
    char[] array = code.ToCharArray();

    for (int i = 0; i < code.Length; i++)
    {
        if (code.Contains("@") && code.Contains("#") && code.Contains("^") &&
            code.Contains("*") && code.Contains("+"))
        {

        }
    }

公共静态字符串解密（字符串代码）
{
char[]数组=code.ToCharArray（）；
for（int i=0；i

每次执行此for循环时，如果字符串包含

@

、

#

、

^

、

*

和

+

字符串中的任意位置，它将计算为true。因此，如果字符串缺少这些符号中的任何一个，则

if

语句将计算为

false

，并且不会发生任何情况

幸运的是，您可以非常轻松地简化此操作。一种方法是将

字符串

转换为

char[]

数组，并将逻辑分解为多个

if

-

else

语句或单个语句，例如：

public static string Decipher (string code)
{
    char[] codeArray = code.ToCharArray(); // convert your code string to a char[] array

    for (int i = 0; i < codeArray.Length; i++)
    {
        switch (codeArray[i]) // Get the char at position i in the array
        {
            case '@': // if the character at i is '@'
                codeArray[i] = 'a'; // Change the character at i to 'a'
                break; // break out of the switch statement - we don't need to evaluate anything else
            case '#': // if the character at i is '#'
                codeArray[i] = 'e'; // Change the character at i to 'e'
                break; // break out of the switch statement - we don't need to evaluate anything else
            // repeat for everything else you need to replace!
        }  
    }
    return new String(codeArray); // Once you're all done, create a string from your deciphered array and return it     
}

公共静态字符串解密（字符串代码）
{
char[]codeArray=code.ToCharArray（）；//将代码字符串转换为char[]数组
for（int i=0；i

这样做其实很简单：

public static string Decipher(string code)
{
    var map = new Dictionary<char, char>()
    {
        { '@', 'a' },
        { '#', 'e' },
        { '^', 'i' },
        { '*', 'o' },
        { '+', 'u' },
    };

    char[] array = code.ToCharArray();

    array = array.Select(x => map.ContainsKey(x) ? map[x] : x).ToArray();

    return new string(array);
}

这将产生：

*+tp+t output *+tp+t 输出

---

为了其他选择

以及何时允许您使用现有方法

你可以这样写：

private Dictionary<char, char> mapping = new Dictionary<char, char>()
{
    { '@', 'a' },
    { '#', 'e' },
    { '^', 'i' },
    { '*', 'o' },
    { '+', 'u' },
};

private string Decrypt(string encryptedString) =>
    string.Concat(encryptedString.Select(s => mapping.ContainsKey(s) ? mapping[s] : s));

---

参考资料：

有很多不同的方法。在循环中进行字符串连接（如@Acex所示）通常是不受欢迎的；它会产生大量的“垃圾”，并且会减慢速度。

Stringbuilder

类通常是一个更好的选择。我的代码使用Stringbuilders（好吧，同样的一个一遍又一遍——我在两者之间清除了它）

以下是做同样事情的几种方法：

const string encoded = "H#ll*, H*w @r# y*+?";

//good old fashioned C-style/brute force:
var buf = new StringBuilder();
foreach (var c in encoded){
    switch(c){
        case '@':
            buf.Append('a');
            break;
        case '#':
            buf.Append('e');
            break;
        case '^':
            buf.Append('i');
            break;
        case '*':
            buf.Append('o');
            break;
        case '+':
            buf.Append('u');
            break;
        default:
            buf.Append(c);
            break;
    }
}
var result = buf.ToString();

//using a lookup table (easily extensible)
buf.Clear();

var decodeDict = new Dictionary<char, char>{
    {'@', 'a'},
    {'#', 'e'},
    {'^', 'i'},
    {'*', 'o'},
    {'+', 'u'},
};

foreach (var c in encoded){
    if (decodeDict.Keys.Contains(c)){
        buf.Append(decodeDict[c]);
    } else {
        buf.Append(c);
    }
}
result = buf.ToString();

//something completely different
//instead of iterating through the string, iterate through the decoding dictionary
buf.Clear();
var working = new StringBuilder(encoded.Length);
working.Append(encoded);
foreach (var pair in decodeDict){
    working.Replace(pair.Key, pair.Value);
}
result = working.ToString();

const string encoded=“H#ll*，H*w@r#y*+？”；
//好的老式C风格/蛮力：
var buf=新的StringBuilder（）；
foreach（编码中的var c）{
开关（c）{
案例“@”：
buf.附加（'a'）；
打破
案例“#”：
buf.附加（'e'）；
打破
案例‘^’：
buf.附加（'i'）；
打破
案例“*”：
buf.附加（'o'）；
打破
格“+”：
buf.附加（'u'）；
打破
违约：
buf.附加（c）；
打破
}
}
var result=buf.ToString（）；
//使用查找表（易于扩展）
buf.Clear（）；
var decodeDict=新字典{
{'@'，a'}，
{'#'，'e'}，
{'^'，i'}，
{'*'，'o'}，
{'+'，u'}，
};
foreach（编码中的var c）{
if（解码密钥包含（c））{
追加（decodeDict[c]）；
}否则{
buf.附加（c）；
}
}
结果=buf.ToString（）；
//完全不同的东西
//迭代解码字典，而不是遍历字符串
buf.Clear（）；
var working=新的StringBuilder（编码的.Length）；
工作。追加（编码）；
foreach（decodeDict中的var对）{
工作。更换（pair.Key，pair.Value）；
}
结果=working.ToString（）；

在每种情况下，

result

都会保存结果。在每个结果赋值之后放置一个断点，看看发生了什么

---

我没有提供太多的注释，只需一步一步地浏览代码，查找类并了解我在做什么（毕竟，你是学生）.

您可以只使用字符串。替换-您不需要将其转换为字符数组，除非您非常关心速度。我们不允许使用字符串方法

code

是一个数组。要访问单个元素，请使用

[]

。一旦您访问了元素（即单个字符），您可以将其与其中一个元音进行比较，然后将其设置为其他内容，例如

code[i]=somethingElse；

您的思路是正确的：但您现在要检查索引

i

处的

char

，例如

if（array[i]='@'）array[i]='a'；

。循环结束后，使用修改后的数组创建结果字符串：

string result=new string（array）；

并返回该结果。这将无法编译。您无法使用索引访问权限修改字符串。（即，

code[i]='a'

是错误的）哦，天哪，我的错了。我现在就来解决这个问题。您（和其他答案）不必将代码转换为数组，它会创建unnece

string result = Decrypt(encryptedString);

const string encoded = "H#ll*, H*w @r# y*+?";

//good old fashioned C-style/brute force:
var buf = new StringBuilder();
foreach (var c in encoded){
    switch(c){
        case '@':
            buf.Append('a');
            break;
        case '#':
            buf.Append('e');
            break;
        case '^':
            buf.Append('i');
            break;
        case '*':
            buf.Append('o');
            break;
        case '+':
            buf.Append('u');
            break;
        default:
            buf.Append(c);
            break;
    }
}
var result = buf.ToString();

//using a lookup table (easily extensible)
buf.Clear();

var decodeDict = new Dictionary<char, char>{
    {'@', 'a'},
    {'#', 'e'},
    {'^', 'i'},
    {'*', 'o'},
    {'+', 'u'},
};

foreach (var c in encoded){
    if (decodeDict.Keys.Contains(c)){
        buf.Append(decodeDict[c]);
    } else {
        buf.Append(c);
    }
}
result = buf.ToString();

//something completely different
//instead of iterating through the string, iterate through the decoding dictionary
buf.Clear();
var working = new StringBuilder(encoded.Length);
working.Append(encoded);
foreach (var pair in decodeDict){
    working.Replace(pair.Key, pair.Value);
}
result = working.ToString();