关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。

1. class:

   public class MyClass
   {
       // Class definition
   }
   

2. interface:

   public interface IMyInterface
   {
       void MyMethod();
   }
   

3. public:

   public class MyClass
   {
       public int MyProperty { get; set; }
   }
   

4. private:

   public class MyClass
   {
       private int myPrivateField;
   }
   

5. protected:

   public class MyBaseClass
   {
       protected int MyProtectedField;
   }
   

6. internal:

   internal class MyInternalClass
   {
       // Internal class accessible within the same assembly
   }
   

7. static:

   public static class MyStaticClass
   {
       public static void MyStaticMethod()
       {
           // Static method
       }
   }
   

8. void:

   public class MyClass
   {
       public void MyMethod()
       {
           // Method that returns void
       }
   }
   

9. new:

   public class MyBaseClass
   {
       public virtual void MyMethod()
       {
           // Base method
       }
   }
   
   public class MyDerivedClass : MyBaseClass
   {
       public new void MyMethod()
       {
           // Hides base class method with new implementation
       }
   }
   

10. virtual, override:

    public class MyBaseClass
    {
        public virtual void MyMethod()
        {
            // Virtual method
        }
    }
    
    public class MyDerivedClass : MyBaseClass
    {
        public override void MyMethod()
        {
            // Overrides base class method
        }
    }
    

11. abstract:

    public abstract class MyAbstractClass
    {
        public abstract void MyAbstractMethod();
    }
    

12. this:

    public class MyClass
    {
        private int value;
    
        public void SetValue(int value)
        {
            this.value = value; // 'this' refers to the current instance of MyClass
        }
    }
    

13. base:

    public class MyBaseClass
    {
        protected int baseValue;
    
        public MyBaseClass(int value)
        {
            baseValue = value;
        }
    }
    
    public class MyDerivedClass : MyBaseClass
    {
        public MyDerivedClass(int derivedValue) : base(derivedValue)
        {
            // Calls base class constructor with 'derivedValue'
        }
    }
    

14. readonly, const:

    public class MyClass
    {
        public const int MyConstant = 10;
        public readonly int MyReadOnlyField;
    
        public MyClass(int value)
        {
            MyReadOnlyField = value; // Readonly field can be initialized in constructor
        }
    }
    

15. delegate:

    public delegate void MyDelegate(string message);
    
    public class MyClass
    {
        public void MyMethod(string message)
        {
            Console.WriteLine(message);
        }
    }
    
    // Usage of delegate:
    // MyDelegate handler = new MyDelegate(new MyClass().MyMethod);
    

16. event:

    public class MyClass
    {
        public event EventHandler MyEvent;
    
        public void RaiseEvent()
        {
            MyEvent?.Invoke(this, EventArgs.Empty);
        }
    }
    

17. try, catch, finally:

    try
    {
        // Code that may throw exceptions
    }
    catch (Exception ex)
    {
        // Handle exceptions
    }
    finally
    {
        // Code that always runs, whether an exception occurred or not
    }
    

18. if, else, switch, case:

    int x = 10;
    
    if (x > 5)
    {
        Console.WriteLine("x is greater than 5");
    }
    else
    {
        Console.WriteLine("x is less than or equal to 5");
    }
    
    switch (x)
    {
        case 5:
            Console.WriteLine("x is 5");
            break;
        default:
            Console.WriteLine("x is not 5");
            break;
    }
    

19. for, while, do:

    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine(i);
    }
    
    int j = 0;
    while (j < 5)
    {
        Console.WriteLine(j);
        j++;
    }
    
    int k = 0;
    do
    {
        Console.WriteLine(k);
        k++;
    } while (k < 5);
    

20. foreach:

    int[] numbers = { 1, 2, 3, 4, 5 };
    
    foreach (int num in numbers)
    {
        Console.WriteLine(num);
    }
    

21. lock:

    private object lockObject = new object();
    
    public void AccessSharedResource()
    {
        lock (lockObject)
        {
            // Code inside this block is thread-safe
        }
    }
    

22. using:

    using (var resource = new DisposableResource())
    {
        // Use 'resource' here
    }
    

23. async, await:

    public async Task<int> GetValueAsync()
    {
        await Task.Delay(1000); // Simulates an async operation
        return 10;
    }
    
    // Example of usage:
    // int result = await GetValueAsync();
    

24. get, set:

    public class MyClass
    {
        private int myProperty;
    
        public int MyProperty
        {
            get { return myProperty; }
            set { myProperty = value; }
        }
    }