C#语法相比其它语言比较独特的地方（二）

下面我将详细讲解“C#语法相比其它语言比较独特的地方（二）”的攻略：

1. 运算符重载

在C#中，我们可以重载运算符来自定义类型之间的运算操作。这就是C#语法相比其它语言比较独特的地方之一。

例如，我们可以定义一个Rational类（代表有理数），并重载运算符以便让我们像操作整数一样操作有理数。

class Rational
{
    public int Numerator { get; private set; }
    public int Denominator { get; private set; }

    public Rational(int numerator, int denominator)
    {
        Numerator = numerator;
        Denominator = denominator;
    }

    public static Rational operator +(Rational r1, Rational r2)
    {
        int newDenominator = r1.Denominator * r2.Denominator;
        int newNumerator = r1.Numerator * r2.Denominator + r2.Numerator * r1.Denominator;
        return new Rational(newNumerator, newDenominator);
    }
}

在上面的代码中，我们定义了一个Rational类，它有一个Numerator属性和一个Denominator属性，代表有理数的分子和分母。

然后，我们定义了一个加法运算符+的重载函数，它接受两个Rational参数，并返回一个新的Rational对象。

这样，我们就可以使用+运算符来对两个Rational对象进行加法操作了。

例如：

Rational r1 = new Rational(1, 2);
Rational r2 = new Rational(3, 4);
Rational r3 = r1 + r2; // r3的值为5/4

2. 嵌套类型

在C#中，我们可以在一个类中定义另一个类，这就是嵌套类型。嵌套类型的作用范围只限于外层类，外部无法直接创建嵌套类型的实例。

例如，我们可以定义一个ArrayStack类，它使用数组来实现一个栈（先进后出）。

public class ArrayStack<T>
{
    private T[] _elements;
    private int _count;

    public ArrayStack(int capacity)
    {
        _elements = new T[capacity];
        _count = 0;
    }

    public void Push(T value)
    {
        if (_count == _elements.Length)
            throw new InvalidOperationException("Stack is full.");

        _elements[_count] = value;
        _count++;
    }

    public T Pop()
    {
        if (_count == 0)
            throw new InvalidOperationException("Stack is empty.");

        _count--;
        return _elements[_count];
    }

    public class Enumerator
    {
        private ArrayStack<T> _stack;
        private int _index;

        public Enumerator(ArrayStack<T> stack)
        {
            _stack = stack;
            _index = -1;
        }

        public T Current
        {
            get
            {
                if (_index == -1 || _index == _stack._count)
                    throw new InvalidOperationException();

                return _stack._elements[_index];
            }
        }

        public bool MoveNext()
        {
            _index++;

            if (_index >= _stack._count)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public void Reset()
        {
            _index = -1;
        }
    }

    public Enumerator GetEnumerator()
    {
        return new Enumerator(this);
    }
}

在上面的代码中，我们定义了一个ArrayStack类，它有一个嵌套类型Enumerator。Enumerator类用于遍历栈中的元素。

然后，我们定义了一个GetEnumerator方法，它返回一个Enumerator对象，这个对象可以用于遍历栈中的元素。

例如：

ArrayStack<int> stack = new ArrayStack<int>(10);
stack.Push(1);
stack.Push(2);
stack.Push(3);

foreach (int i in stack)
{
    Console.WriteLine(i); // 输出3, 2, 1
}

在上面的代码中，我们创建了一个ArrayStack对象，并将3, 2, 1压入栈中。然后，我们使用foreach循环遍历栈中的元素，并依次输出它们的值。