Каскадирование ввода / вывода в c #

Question

В C ++ «>>» и «<<» используются для каскадирования при выполнении операций ввода / вывода. <br>Есть ли способ, с помощью которого такие вещи можно сделать в 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 в ограничениях параметров типа ... = (

Следующее, что нужно сделать - это проанализировать строковое значение, вот как я это сделал ... хорошо ... это просто демокод:

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 parser .

И тестирование:

    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);