在好例子网，分享、交流、成长！
<<

C# 入门教程（C#语法- 1.程序结构）

首先编程语言是一门语言，就像汉语、英语一样都有它的基本语法，咱们接下来通过下面最小入门级示例讲下C#的程序结构。

namespace ConsoleApp2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("Hello, World!");
        }
    }
}

graph LR
C[程序结构] --> D[关键词]
C --> E[命名空间]
C --> H[类]
C --> G[方法:入口函数]
C --> F[代码块]
C --> K[修饰符]

关键词

namespace ConsoleApp2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("Hello, World!!");
        }
    }
}

C#有一些关键字用于定义语法结构和控制程序行为。以下是C#中常见的关键字列表：

  1. abstract：声明抽象类或抽象成员。
  2. as：类型转换运算符。
  3. base：表示基类的关键字。
  4. bool：布尔类型关键字。
  5. break：跳出循环或 switch 语句。
  6. byte：8 位无符号整数类型关键字。
  7. case：用于 switch 语句中的分支情况。
  8. catch：捕获异常。
  9. char：16 位 Unicode 字符类型关键字。
  10. checked：启用整数溢出检查。
  11. class：声明类。
  12. const：声明常量。
  13. continue：继续循环的下一次迭代。
  14. decimal：128 位精确浮点数类型关键字。
  15. default：默认值或默认情况。
  16. delegate：声明委托类型。
  17. do：循环语句的起始点。
  18. double：64 位浮点数类型关键字。
  19. else：条件语句的分支。
  20. enum：声明枚举类型。
  21. event：声明事件。
  22. explicit：声明显式转换运算符。
  23. extern：表示外部方法实现。
  24. false：表示布尔类型的假值。
  25. finally：无论是否发生异常都执行的代码块。
  26. fixed：固定指针的关键字。
  27. float：32 位浮点数类型关键字。
  28. for：循环语句。
  29. foreach：迭代集合的每个元素。
  30. goto：无条件跳转到标记的语句。
  31. if：条件语句。
  32. implicit：声明隐式转换运算符。
  33. in：用于传递参数或 foreach 语句中的迭代。
  34. int：32 位整数类型关键字。
  35. interface：声明接口。
  36. internal：在当前程序集内可见的成员。
  37. is：类型检查运算符。
  38. lock：同步访问共享资源。
  39. long：64 位整数类型关键字。
  40. namespace：声明命名空间。
  41. new：创建新对象或隐藏基类成员。
  42. null：表示空引用。
  43. object：所有类型的基类。
  44. operator：声明运算符。
  45. out：输出参数修饰符。
  46. override：重写基类方法。
  47. params：表示参数数组。
  48. private：私有访问级别。
  49. protected：受保护访问级别。
  50. public：公共访问级别。
  51. readonly：只读字段修饰符。
  52. ref：引用参数修饰符。
  53. return：返回方法的值。
  54. sbyte：8 位有符号整数类型关键字。
  55. sealed：阻止派生类的声明。
  56. short：16 位整数类型关键字。
  57. sizeof：获取数据类型的字节大小。
  58. stackalloc：在堆栈上分配内存。
  59. static：静态成员修饰符。
  60. string：字符串类型关键字。
  61. struct：声明值类型。
  62. switch：多路分支语句。
  63. this：当前实例的引用。
  64. throw：抛出异常。
  65. true：表示布尔类型的真值。
  66. try：尝试执行可能会发生异常的代码块。
  67. typeof：获取对象的 Type 对象。
  68. uint：32 位无符号整数类型关键字。
  69. ulong：64 位无符号整数类型关键字。
  70. unchecked：禁用整数溢出检查。
  71. unsafe：启用不安全代码块。
  72. ushort：16 位无符号整数类型关键字。
  73. using：引入命名空间或资源管理器。
  74. var：隐式类型关键字。
  75. virtual：允许派生类重写方法。
  76. void：表示不返回值的方法。
  77. volatile：指示字段可以由多个线程同时访问。

这些关键字都具有特定的语法和用途，可以根据需要在代码中使用它们。

命名空间

命名空间是针对类分组的过程，就像住宅一样，客厅里放茶几，卧室里放个床，主要是为了归类，使用起来更方便。 以下是框架中控制台类的定义，System 是一个命名空间，Console 是该命名空间中的一个类，WriteLine是该类的一个静态方法

namespace System
{
    public class Console
    {
        public static void WriteLine(string line)
        {
            //输出到控制台。。。
        }
    }
}

类的调用方式一：

namespace ConsoleApp2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("Hello, World!");
        }
    }
}

类的调用方式二： 可使用 using 关键字，这样就不必使用完整的名称，如下例所示：

using System;
namespace ConsoleApp2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

类和对象

类是最基本的 C# 类型。 类是一种数据结构，通常由状态（字段）和操作（方法和其他函数成员）组成。 类为类的实例（亦称为“对象”）提供了定义。 以下是一个学生类的定义，并在控制台调用的完整示例：

using System;

public class Student
{
    private string name;
    private bool isPresent;

    public Student(string name)
    {
        this.name = name;
        isPresent = false;
    }

    public void SignIn()
    {
        isPresent = true;
        Console.WriteLine(name + " 签到成功.");
    }
}

class Program
{
    static void Main()
    {
        // 创建学生对象
        Student student1 = new Student("小王");
        Student student2 = new Student("小张");

        // 调用学生的签到方法
        student1.SignIn();
        student2.SignIn();

        // 等待用户按下任意键退出程序
        Console.ReadKey();
    }
}

该代码中，首先定义了一个名为 Student 的学生类，其中包含一个私有字段 name 表示学生姓名，以及一个私有字段 isPresent 表示学生是否已签到。学生类还有一个公共构造函数，用于初始化学生姓名和签到状态，以及一个公共的签到方法 SignIn()，该方法将 isPresent 标记为 true 并输出签到信息。

在 Main 方法中，创建了两个学生对象 student1 和 student2，并通过调用 SignIn() 方法来实现签到操作。最后，使用 Console.ReadKey() 方法等待用户按下任意键退出程序。

方法:入口函数

当我们编写 C# 程序时，每个程序必须有一个特殊的方法叫做 Main 方法。这个方法是程序执行的入口点，在运行程序时会首先执行其中的代码。 更详细的介绍，点这里

代码块

在 C# 中，大括号 {} 起着以下几种作用：

  1. 代码块：大括号被用来创建代码块，也称为语句块。代码块是一组相关的语句，它们在逻辑上被视为一个整体。大括号将这些语句括起来，使它们成为一个封闭的单元。
using System;

class Program
{
    static void Main(string[] args)
    {
        bool condition = true;

        if (condition)
        {
            Console.WriteLine("条件成立");
            Console.WriteLine("这是一个代码块");
            Console.WriteLine("包含多个语句");
        }
    }
}
  1. 作用域：大括号还定义了一个作用域（scope），也称为局部作用域。在 C# 中，变量和对象只在其所属的作用域中可见和有效。通过使用大括号，我们可以创建新的作用域，并在其中声明局部变量。
using System;

class Program
{
    static void Main(string[] args)
    {
        {
            int value = 10; // 在该作用域中声明的变量
            Console.WriteLine(value); // 输出：10
        }
        // value 不在这里可见

        // 在这里访问 value 将会报错
    }
}
  1. 控制结构：大括号常与控制结构（如 if、for、while、switch 等）一起使用，指定这些结构的执行范围。条件语句或循环语句中的大括号包含了要执行的代码。
using System;

class Program
{
    static void Main(string[] args)
    {
        bool condition = true;

        if (condition)
        {
            Console.WriteLine("条件成立，执行这里的代码");
        }
        else
        {
            Console.WriteLine("条件不成立，执行这里的代码");
        }
    }
}
  1. 匿名类型和对象初始化器：在 C# 中，大括号还用于创建匿名类型和对象初始化器。通过在大括号中指定初始值，我们可以为匿名类型的属性或对象的属性赋初值。
using System;

class Program
{
    static void Main(string[] args)
    {
        var person = new { Name = "Alice", Age = 25 }; // 匿名类型
        Console.WriteLine(person.Name); // 输出：Alice
        Console.WriteLine(person.Age); // 输出：25

        MyClass obj = new MyClass { Property1 = 10, Property2 = "Hello" }; // 对象初始化器
        Console.WriteLine(obj.Property1); // 输出：10
        Console.WriteLine(obj.Property2); // 输出：Hello
    }
}

class MyClass
{
    public int Property1 { get; set; }
    public string Property2 { get; set; }
}

总而言之，大括号用于创建代码块、定义作用域、指定控制结构的执行范围，以及在匿名类型和对象初始化器中提供初始值。它们帮助我们组织代码并影响变量的可见性和作用范围。

修饰符

在 C# 中，有以下几种常用的修饰符（modifiers），它们可以应用于类、方法、字段和属性等成员，用于控制其行为和可访问性：

好的，我将为您提供每种修饰符的使用场景和相应的完整可运行示例代码。

  1. public（公共的）：
    • 使用场景：当希望将成员暴露给所有其他代码时使用。
    • 示例代码：
using System;

public class MyClass
{
    public void MyMethod()
    {
        Console.WriteLine("这是一个公共方法");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        MyClass myObject = new MyClass();
        myObject.MyMethod();
    }
}
  1. private（私有的）：
    • 使用场景：当希望将成员限制在类内部使用时使用。
    • 示例代码：
using System;

public class MyClass
{
    private int myField;

    private void MyMethod()
    {
        Console.WriteLine("这是一个私有方法");
    }

    public void AccessPrivateMember()
    {
        myField = 10;
        MyMethod();
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        MyClass myObject = new MyClass();
        myObject.AccessPrivateMember();
    }
}
  1. protected（受保护的）：
    • 使用场景：当希望将成员限制在类及其派生类使用时使用。
    • 示例代码：
using System;

public class MyBaseClass
{
    protected int myField;

    protected void MyMethod()
    {
        Console.WriteLine("这是一个受保护的方法");
    }
}

public class MyDerivedClass : MyBaseClass
{
    public void AccessProtectedMember()
    {
        myField = 10;
        MyMethod();
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        MyDerivedClass myObject = new MyDerivedClass();
        myObject.AccessProtectedMember();
    }
}
  1. internal（内部的）：
    • 使用场景：当希望将成员限制在同一程序集内部使用时使用。
    • 示例代码：
using System;

internal class MyClass
{
    internal void MyMethod()
    {
        Console.WriteLine("这是一个内部方法");
    }
}

internal class Program
{
    private static void Main(string[] args)
    {
        MyClass myObject = new MyClass();
        myObject.MyMethod();
    }
}
  1. static（静态的）：
    • 使用场景：当希望将成员与特定实例解耦，成为类级别的成员，并且不需要创建类的实例即可访问时使用。
    • 示例代码：
using System;

public class MyClass
{
    public static int myVariable;

    public static void MyMethod()
    {
        Console.WriteLine("这是一个静态方法");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        MyClass.myVariable = 10;
        MyClass.MyMethod();
    }
}
  1. readonly（只读的）：
    • 使用场景：当希望将字段标记为只能在声明时或构造函数中初始化，并且在运行时不可更改时使用。
    • 示例代码：
using System;

public class MyClass
{
    private readonly int myField;

    public MyClass(int value)
    {
        myField = value;
        Console.WriteLine("只读字段的值为：" + myField);
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        MyClass myObject = new MyClass(10);
    }
}
  1. const（常量）：
    • 使用场景：当希望声明一个在编译时确定且不可更改的常量值时使用。
    • 示例代码：
using System;

public class MyClass
{
    public const int MY_CONSTANT = 100;
}

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("常量的值为：" + MyClass.MY_CONSTANT);
    }
}
  1. abstract（抽象的）：
    • 使用场景：当希望定义一个没有实际实现的类、方法或属性，需要在派生类中实现时使用。
    • 示例代码：
using System;

public abstract class MyBaseClass
{
    public abstract void MyMethod();
}

public class MyDerivedClass : MyBaseClass
{
    public override void MyMethod()
    {
        Console.WriteLine("在派生类中实现的抽象方法");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        MyDerivedClass myObject = new MyDerivedClass();
        myObject.MyMethod();
    }
}
  1. virtual（虚拟的）：
    • 使用场景：当希望将方法或属性定义为可在派生类中重写的基类成员时使用。
    • 示例代码：
using System;

public class MyBaseClass
{
    public virtual void MyMethod()
    {
        Console.WriteLine("基类中的虚拟方法");
    }

    public virtual int MyProperty { get; set; }
}

public class MyDerivedClass : MyBaseClass
{
    public override void MyMethod()
    {
        Console.WriteLine("在派生类中重写的虚拟方法");
    }

    public override int MyProperty
    {
        get
        {
            return base.MyProperty * 2;
        }
        set
        {
            base.MyProperty = value;
        }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        MyDerivedClass myObject = new MyDerivedClass();
        myObject.MyMethod();
        myObject.MyProperty = 10;
        Console.WriteLine("派生类中的属性值为：" + myObject.MyProperty);
    }
}

这些修饰符用于不同的场景，以控制成员的可见性、访问级别、是否允许派生类进行重写等。对于初学者来说，理解和正确使用这些修饰符对于设计和实现类、方法和其他成员非常重要。

总结

继续引用雷总的语录，不懂的没有关系，先跳过去，后面的学会了,前面的自然就看懂了

跳跃式学习法

标签： 入门教程 语法 入门 教程 C#

关于好例子网

本站旨在为广大IT学习爱好者提供一个非营利性互相学习交流分享平台。本站所有资源都可以被免费获取学习研究。本站资源来自网友分享，对搜索内容的合法性不具有预见性、识别性、控制性，仅供学习研究，请务必在下载后24小时内给予删除，不得用于其他任何用途，否则后果自负。基于互联网的特殊性，平台无法对用户传输的作品、信息、内容的权属或合法性、安全性、合规性、真实性、科学性、完整权、有效性等进行实质审查；无论平台是否已进行审查，用户均应自行承担因其传输的作品、信息、内容而可能或已经产生的侵权或权属纠纷等法律责任。本站所有资源不代表本站的观点或立场，基于网友分享，根据中国法律《信息网络传播权保护条例》第二十二与二十三条之规定，若资源存在侵权或相关问题请联系本站客服人员，点此联系我们。关于更多版权及免责申明参见 版权及免责申明

报警