Question

在C ++中，＆＃39;＆gt;＆gt;＆＃39;和＆＃39;＆lt;＆lt;＆＃在执行输入/输出操作期间用于级联有没有什么方法可以在C＃中完成这些事情？直到现在，我知道我可以一次输入一个输入并将其分配给变量，例如，在以下代码片段中：

int a,b;
Console.Write("Enter the value of first number: ");
a=Convert.ToInt32(Console.ReadLine());
Console.Write("Enter the value of second number: ");
b=Convert.ToInt32(Console.ReadLine());

而在C ++中，同样的事情可以做到：

int a,b;
cout<<"Enter the values of the two numbers: ";
cin>>a>>b;

Answer 1

正如@fredrik和@Henk Holterman所说，这个功能并没有内置在语言中。但是......（很大但是在这里）我们是程序员！我们自己无法实现！

在解释之前让我们看看代码，代码可以解释多次：

public class Reader
{
    public Reader Read<T>(out T t) where T : struct
    {
        var line = Console.ReadLine();
        t = GetValueFromStringRepresentation<T>(line);
        return this;
    }

    public Reader Read(out string str)
    {
        str = Console.ReadLine();
        return this;
    }

    //GetValueFromStringRepresentation stuff
}

我们在此处实现方法链模式以根据需要多次读取，并使用 out 参数初始化变量。此实现仅适用于结构（但不是全部...）和字符串，这是重载方法采用字符串的原因... C＃不允许在类型参数约束中指定AND ... =（< / p>

接下来就是解析一个字符串值，这就是我做的...好吧..它只是民主代码：

private static T GetValueFromStringRepresentation<T>(string str)
{
    var type = typeof(T);
    var value = type == typeof(string)
        ? str
        : type == typeof(bool)
            ? bool.Parse(str)
            : type == typeof(sbyte)
                ? sbyte.Parse(str, CultureInfo.InvariantCulture)
                : type == typeof(byte)
                    ? byte.Parse(str, CultureInfo.InvariantCulture)
                    : type == typeof(short)
                        ? short.Parse(str, CultureInfo.InvariantCulture)
                        : type == typeof(ushort)
                            ? ushort.Parse(str, CultureInfo.InvariantCulture)
                            : type == typeof(int)
                                ? int.Parse(str, CultureInfo.InvariantCulture)
                                : type == typeof(uint)
                                    ? uint.Parse(str, CultureInfo.InvariantCulture)
                                    : type == typeof(long)
                                        ? long.Parse(str, CultureInfo.InvariantCulture)
                                        : type == typeof(char)
                                            ? char.Parse(str)
                                            : type == typeof(float)
                                                ? float.Parse(str, CultureInfo.InvariantCulture)
                                                : type == typeof(double)
                                                    ? double.Parse(str, CultureInfo.InvariantCulture)
                                                    : type == typeof(ulong)
                                                        ? ulong.Parse(str, CultureInfo.InvariantCulture)
                                                        : type == typeof(decimal)
                                                            ? decimal
                                                                .Parse(str, CultureInfo.InvariantCulture)
                                                            : type == typeof(Guid)
                                                                ? Guid.Parse(str)
                                                                : (object)null;
    return (T)value;
}

正如我之前所说，对于每个可能的结构都不会开箱即用，但是你可以轻松添加一个封装解析的可选参数，例如： Func＆lt; string，T＆gt;解析器即可。

并测试：

    int a, b;
    string c;
    char d;

    var reader = new Reader();
    reader.Read(out a)
        .Read(out b)
        .Read(out c)
        .Read(out d);

    Console.WriteLine(a);
    Console.WriteLine(b);
    Console.WriteLine(c);
    Console.WriteLine(d);
    Console.ReadLine();

修改

如果您使用的是C＃7+，则可以利用内联可变声明：

var reader = new Reader(); reader.Read(out int a) .Read(out int b) .Read(out string c) .Read(out char d);

I / O级联c＃

1 个答案: