可以用C#编写没有变量的程序吗？

因此，我和我的朋友收到了实现此功能的编程任务：

所以你必须输入x，输出y。 事实上，这很容易，但问题是：我们可以不用变量，只使用Console.ReadLine（）的一个实例（并将其解析为double），然后将结果传递给多个“if”检查吗？使用新的类和方法也是一种欺骗：我们必须在main（）中执行所有操作

下面是一个带有一个变量的程序示例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication4 {
    class Program {
        static void Main(string[] args) {
            double x;
            x = double.Parse(Console.ReadLine());
            if (x < -2.0) { Console.Write(2.0); }
            if ((x < -1.0)&&(x>=-2.0)) { Console.Write(1.0); }
            if ((x < 0.0)&&(x>=-1)) { Console.Write(0.0); }
            if ((x>=0.0)&&(x<1.0)) { Console.Write(x); }
            if (x >= 1.0) { Console.Write(1.0); }
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
命名空间控制台应用程序4{
班级计划{
静态void Main（字符串[]参数）{
双x；
x=double.Parse（Console.ReadLine（））；
如果（x<-2.0）{Console.Write（2.0）；}
if（（x<-1.0）&（x>=-2.0））{Console.Write（1.0）；}
if（（x<0.0）&&（x>=-1））{Console.Write（0.0）；}
如果（（x>=0.0）&&（x=1.0）{Console.Write（1.0）；}
}
}
}

回答问题。是的。简单地用

double.Parse（Console.ReadLine（））

替换

x

的每个实例。首先，您当前的程序正在定义变量

args

。您不需要这样做，因为您不能声明变量。将

Main

的声明更改为：

static void Main()
{
     //...
} 

您可以使用某种形式的外部状态来存储通常存储在变量中的任何值，例如，始终将值读取/写入文件：

File.WriteAllText("line.txt", Console.ReadLine());

if (double.Parse(File.ReadAllText("line.txt")) < -2.0)
    Console.Write(2.0);
if ((double.Parse(File.ReadAllText("line.txt")) < -1.0)
    && (double.Parse(File.ReadAllText("line.txt")) >= -2.0))
    Console.Write(1.0);
if ((double.Parse(File.ReadAllText("line.txt")) < 0.0)
    && (double.Parse(File.ReadAllText("line.txt")) >= -1))
    Console.Write(0.0);
if ((double.Parse(File.ReadAllText("line.txt")) >= 0.0)
    && (double.Parse(File.ReadAllText("line.txt")) < 1.0))
    Console.Write(double.Parse(File.ReadAllText("line.txt")));
if (double.Parse(File.ReadAllText("line.txt")) >= 1.0)
    Console.Write(1.0);
File.Delete("line.txt");

File.writealText（“line.txt”，Console.ReadLine（））；
if（double.Parse（File.ReadAllText（“line.txt”））<-2.0）
控制台写入（2.0）；
if（（double.Parse（File.ReadAllText（“line.txt”））<-1.0）
&&（double.Parse（File.ReadAllText（“line.txt”）>=-2.0））
控制台写入（1.0）；
if（（double.Parse（File.ReadAllText（“line.txt”））<0.0）
&&（double.Parse（File.ReadAllText（“line.txt”）>=-1））
控制台写入（0.0）；
if（（double.Parse（File.ReadAllText（“line.txt”））>=0.0）
&&（double.Parse（File.ReadAllText（“line.txt”））<1.0）
Write（double.Parse（File.ReadAllText（“line.txt”））；
if（double.Parse（File.ReadAllText（“line.txt”））>=1.0）
控制台写入（1.0）；
删除（“line.txt”）；

您可以对注册表值执行同样的操作，获取/发布值到web服务，等等。当然，这些都是非常低效的，但这只是一个玩具示例

当然，除了效率极低之外，这看起来也很混乱。我们实际上可以通过使用方法使其看起来更好。我们的方法不能有任何参数，因为参数都是变量，但是返回解析行的无参数方法在这里的可读性非常好：

public static void Main()
{
    File.WriteAllText("line.txt", Console.ReadLine());

    if (GetValue() < -2.0)
        Console.Write(2.0);
    if (GetValue() < -1.0 && GetValue() >= -2.0)
        Console.Write(1.0);
    if (GetValue() < 0.0 && GetValue() >= -1)
        Console.Write(0.0);
    if (GetValue() >= 0.0 && GetValue() < 1.0)
        Console.Write(GetValue());
    if (GetValue() >= 1.0)
        Console.Write(1.0);
    File.Delete("line.txt");
}
public static double GetValue()
{
    return double.Parse(File.ReadAllText("line.txt"));
}

publicstaticvoidmain（）
{
File.writealText（“line.txt”，Console.ReadLine（））；
如果（GetValue（）<-2.0）
控制台写入（2.0）；
如果（GetValue（）<-1.0&&GetValue（）>=-2.0）
控制台写入（1.0）；
如果（GetValue（）<0.0&&GetValue（）>=-1）
控制台写入（0.0）；
如果（GetValue（）>=0.0&&GetValue（）<1.0）
Write（GetValue（））；
如果（GetValue（）>=1.0）
控制台写入（1.0）；
删除（“line.txt”）；
}
公共静态双GetValue（）
{
返回double.Parse（File.ReadAllText（“line.txt”）；
}

这是可行的，没有声明变量：

static void Main()
{
    (new Action<double>(x =>
    {
        if (x < -2.0) { Console.Write(2.0); }
        if ((x < -1.0) && (x >= -2.0)) { Console.Write(1.0); }
        if ((x < 0.0) && (x >= -1)) { Console.Write(0.0); }
        if ((x >= 0.0) && (x < 1.0)) { Console.Write(x); }
        if (x >= 1.0) { Console.Write(1.0); }
    }))(double.Parse(Console.ReadLine()));

    Console.ReadKey();
}

static void Main（）
{
（新动作（x=>
{
如果（x<-2.0）{Console.Write（2.0）；}
if（（x<-1.0）&（x>=-2.0））{Console.Write（1.0）；}
if（（x<0.0）&&（x>=-1））{Console.Write（0.0）；}
如果（（x>=0.0）&（x<1.0））{Console.Write（x）；}
如果（x>=1.0）{Console.Write（1.0）；}
}))（double.Parse（Console.ReadLine（））；
Console.ReadKey（）；
}

取决于您如何定义“变量”☺

---

没有使用局部变量、参数、字段或属性。

这不会使您得到0个变量，但实际上只有1个

编辑

至于@Servy在评论中提出的问题，下面的初始答案仍然使用了一个变量（args），但这并没有计入OP中，所以我觉得这是一个合理的答案

如果您想要一个包含0个变量的解决方案，该解决方案不依赖可能失败的存储（例如，无文件系统访问、无注册表访问等），则可以这样做

using System;

class Program {
    static void Main()
    {
        Console.Title = Console.ReadLine();
        if (double.Parse(Console.Title) < -2.0) { Console.Write(2.0); }
        if ((double.Parse(Console.Title) < -1.0) && (double.Parse(Console.Title) >= -2.0)) { Console.Write(1.0); }
        if ((double.Parse(Console.Title) < 0.0) && (double.Parse(Console.Title) >= -1)) { Console.Write(0.0); }
        if ((double.Parse(Console.Title) >= 0.0) && (double.Parse(Console.Title) < 1.0)) { Console.Write(double.Parse(Console.Title)); }
        if (double.Parse(Console.Title) >= 1.0) { Console.Write(1.0); }
    }
}

使用系统；
班级计划{
静态void Main（）
{
Console.Title=Console.ReadLine（）；
if（double.Parse（Console.Title）<-2.0）{Console.Write（2.0）；}
if（（double.Parse（Console.Title）<-1.0）&（double.Parse（Console.Title）>=-2.0））{Console.Write（1.0）；}
if（（double.Parse（Console.Title）<0.0）&（double.Parse（Console.Title）>=-1））{Console.Write（0.0）；}
if（（double.Parse（Console.Title）>=0.0）&（double.Parse（Console.Title）<1.0））{Console.Write（double.Parse（Console.Title））；}
if（double.Parse（Console.Title）>=1.0{Console.Write（1.0）；}
}
}

下面的原始答案

using System;

class Program {
    static void Main(string[] args)
    {
        if (args.Length == 0)
        {
            Main(new string[] { Console.ReadLine() });
        }
        else
        {
            if (double.Parse(args[0]) < -2.0) { Console.Write(2.0); }
            if ((double.Parse(args[0]) < -1.0) && (double.Parse(args[0]) >= -2.0)) { Console.Write(1.0); }
            if ((double.Parse(args[0]) < 0.0) && (double.Parse(args[0]) >= -1)) { Console.Write(0.0); }
            if ((double.Parse(args[0]) >= 0.0) && (double.Parse(args[0]) < 1.0)) { Console.Write(double.Parse(args[0])); }
            if (double.Parse(args[0]) >= 1.0) { Console.Write(1.0); }
        }
    }
}

使用系统；
班级计划{
静态void Main（字符串[]参数）
{
如果（args.Length==0）
{
Main（新字符串[]{Console.ReadLine（）}）；
}
其他的
{
if（double.Parse（args[0]）<-2.0）{Console.Write（2.0）；}
如果（（double.Parse（args[0]）<-1.0）和（&（double.Parse（args[0]）>=-2.0））{Console.Write（1.0）；}
if（（double.Parse（args[0]）<0.0）&（double.Parse（args[0]）>=-1））{Console.Write（0.0）；}
if（（double.Parse（args[0]）>=0.0）和&（double.Parse（args[0]）<1.0））{Console.Write（double.Parse（args[0]）；}
if（double.Parse（args[0]）>=1.0）{Console.Write（1.0）；}
}
}
}

这可以用正则表达式来完成，但它相当难看。值-1和-2必须单独处理，数字表示中的E存在巨大问题。我将解决方案包装到测试循环中

//test loop
for (double x = -4; x < 4; x += 0.2d)
{
    Console.Write(x.ToString().PadRight(20, ' ') + " => ");
    string readLine = x.ToString();

    //original main
    Console.WriteLine(Math.Abs(Math.Max(-2, Math.Min(1, double.Parse(
        Regex.Replace(Regex.Replace(Regex.Replace(Regex.Replace(
            Math.Max(-3, double.Parse(readLine)).ToString()//format normalization
            , "-1$", "0") // -1 -> 0
            , "-2$", "-1") // -2 -> -1
            , @"^-.*E-.*", @"0") // -5E-5 -> 0
            , @"^(-\d+)\D.*", @"$1")))))); // -2.22 -> -2
    //end of main
}

任意函数映射R->R

//test loop
for (double x = -4; x < 4; x += 0.2d)
{
    Console.Write(x.ToString().PadRight(20, ' ') + " => ");
    string readLine = x.ToString();

    //original main
    Console.WriteLine(Math.Abs(Math.Max(-2, Math.Min(1, double.Parse(
        Regex.Replace(Regex.Replace(Regex.Replace(Regex.Replace(
            Math.Max(-3, double.Parse(readLine)).ToString()//format normalization
            , "-1$", "0") // -1 -> 0
            , "-2$", "-1") // -2 -> -1
            , @"^-.*E-.*", @"0") // -5E-5 -> 0
            , @"^(-\d+)\D.*", @"$1")))))); // -2.22 -> -2
    //end of main
}

-4                   => 2
-3,8                 => 2
-3,6                 => 2
-3,4                 => 2
-3,2                 => 2
-3                   => 2
-2,8                 => 2
-2,6                 => 2
-2,4                 => 2
-2,2                 => 2
-2                   => 1
-1,8                 => 1
-1,6                 => 1
-1,4                 => 1
-1,2                 => 1
-0,999999999999999   => 0
-0,799999999999999   => 0
-0,599999999999999   => 0
-0,399999999999999   => 0
-0,199999999999999   => 0
1,27675647831893E-15 => 1,27675647831893E-15
0,200000000000001    => 0,200000000000001
0,400000000000001    => 0,400000000000001
0,600000000000001    => 0,600000000000001
0,800000000000001    => 0,800000000000001
1                    => 1
1,2                  => 1
1,4                  => 1
1,6                  => 1
1,8                  => 1
2                    => 1
2,2                  => 1
2,4                  => 1
2,6                  => 1
2,8                  => 1
3                    => 1
3,2                  => 1
3,4                  => 1
3,6                  => 1
3,8                  => 1