微软.NET6开发的C#特性——运算符、表达式和命名空间

我是荔园微风，作为一名在IT界整整25年的老兵，看到不少初学者在学习编程语言的过程中如此的痛苦，我决定做点什么，下面我就重点讲讲微软.NET6开发人员需要知道的C#特性，然后比较其他各种语言进行认识。

C#经历了多年发展，进行了多次重大创新，大幅优化了开发者的编码体验。在.NET 平台移交给.NET基金会运营后， C#更新的越来越不像原来的C#了，但总体上来说，所有改进依然以优化开发者的编码体验为最终目的。

首先，要记住一张表，如下：

C#版本发布时间 .NET版本 VS版本 CLR版本

C#1.0 2002-2 .NET Framework 1.0 VS.NET 2002 .NET Framework CLR 1.0

C#2.0 2005-11 .NET Framework 2.0 VS2005 .NET Framework CLR 2.0

C#3.0 2006-11 .NET Framework 3.0 VS2008 .NET Framework CLR 2.0

C#3.0 2007-11 .NET Framework 3.5 VS2008 .NET Framework CLR 2.0

C#4.0 2010-4 .NET Framework 4.0 VS2010 .NET Framework CLR 4.0

C#5.0 2012-2 .NET Framework 4.5 VS2012 .NET Framework CLR 4.0

C#6.0 2015-7 .NET Framework 4.6 VS2015 .NET Framework CLR 4.0

C#7.0 2016-8 .NET Framework 4.6.2 VS2017(v15) .NET Framework CLR 4.0

C#7.1 2017-4 .NET Framework 4.7 VS2017(v15.3) .NET Framework CLR 4.0

C#7.2 2017-10 .NET Framework 4.7.1 VS2017(v15.5) .NET Framework CLR 4.0

C#7.3 2018-4 .NET Framework 4.7.2 VS2017(v15.8) .NET Framework CLR 4.0

C#8.0 2019-4 .NET Framework 4.8 VS2019(v16.3) .NET Framework CLR 4.0

C#8.0 2019-9 .NETCore 3.0 VS2019(v16.4) .NETCore CLR 3.0

C#9.0 2020-11 .NET 5.0 VS2019(v16.8) .NET CLR 5.0

C#10.0 2021-11 .NET 6.0 VS2022(v17) .NET CLR 6.0

看完这张表，我真的是很感慨，从测试版开始，我居然陪伴着.NET和C#走过了二十多年，我不知道有没有微软公司的人在看这篇文章，如果有的话，不知道我这样的二十多年的.NET和C#程序员有没有机会去微软中国和微软亚洲研究院的总部去参观一下，去坐一坐，并作一下技术交流。二十多年了，人生又有几个二十多年啊。

.NET平台是基于IL中间语言的应用运行环境，面向对象语言C#是平台的主要开发语言。除此之外还有同样面向对象的C++/CLI。C++/CLI主要用于和原生C++交互，在.NET平台中仅支持Windows系统。

C#和.NET平台本来是微软为了与Java平台竞争而打造的，C#在设计时充分总结了Java的经验教训，解决了大量Java的基本设计缺陷。本着为一线开发者谋实惠的宗旨，C#设计了大量能减轻开发者的编写负担、容易理解且安全高效的实用功能。为了尽可能降低因安全措施导致性能大幅下降的影响，C#还在有限的情况下保留了C/C++语言的部分语法和功能。到了.NET时代，微软依然在运行时(Runtime)和语言两边同时进行着优化。

随着上世纪九十年代Java的发布，软件公司和开发者开始感受到基于虚拟机的托管语言所带来的好处，微软也不甘示弱，在2001年发布了.NET Framework平台和C#。提供了完整的基础面向对象支持。

运算符和表达式

运算符和表达式可以说是任何编程语言都具备的要素，但不同语言之间还是存在不小的区别。

C#的运算符基本继承了C++的特点，允许重载大部分运算符，C#中隐式或显式类型转换也是一种可以重载的特殊运算符。C#中的运算符本质上就是一种通过特殊语法调用的公共静态方法。

Java删除了重载运算符的功能。这导致Java在编写和使用数学相关的功能时显得非常整脚，甚至还产生了用==运算符和Equals方法对内容完全相同的两个字符串实例进行比较会得出完全相反的结果的迷惑事件。

按编程语言的规则，==运算符执行继承自Object的引用相等性比较，两个实例的引用一定不相等，而Equals方法执行重写后的内容相等性比较，内容肯定是相等的，从而导致了迷惑事件的发生。

C#在这方面则完全没有问题，如果在少数特殊情况下确实想知道两个字符串是不是同一个实例而不管内容是否相同的话，可以使用object.ReferenceEquals方法明确表示要进行引用相等性比较。经过多年的发展之后，C#添加了大量实用的操作符，也增强了许多已有操作符的功能。

C#和C++的运算符重载的示例代码如下所示。

(1)C#

cs 复制代码

namespace Example
{
　　public struct Complex
   {
   　　private double sreal;
　 　　private double simg;

   　　public double Real
　　 　{
　　   　　get { return sreal; }
　　 　}
　　
　　   public double Img
       {
　       　get {return simg;}
       }

    　　public Complex(double real, double img)
       { 
　　    　　sreal= real;
　　     　　simg= img;
        }
  
　    　//重载复数的加运算符
　　　　public static Complex operator +(Complex a, Complex b)
       {
          　return new Complex(a. Real+b. Real, a. Img+b. Img);
　  　　}

   　　//重载实数和复数之间的加运算符
   　　public static Complex operator +(double a, Complex b)
       {
        　　return new Complex (a+ b. Real, b. Img);
　　    }

    　　//重载复数和实数之间的加运算符
   　　public static Complex operator +(Complex a, double b)
       {
       　　return b+a;
    　　}

    　　//重载实数到复数的隐式类型转换运算符，显式和隐式类型转换运算符只能重载其中一个
    　　public static implicit operator Complex(double value)
        {
       　　return new Complex(value, 0);
　　 　　}

    　　//重载实数到复数的显式类型转换运算符，显式和隐式类型转换运算符只能重载其中一个
     　　public static explicit operator Complex(double value)
　      {
        　　return new Complex(value, 0);
　　 　　}
　　}
}

(2) C++

CComplex.h

cpp 复制代码

#pragma once

class CComplex
{

　　private:
    　　double sreal;
　　　　double simg;
　　
　　public:
　　 　CComplex(double real, double img);
　 　　double GetReal();
　 　　double GetImg ()
　 　　CComplex operator+(const CComplex &b) const;
　　 　CComplex operator+(const double b) const;
};

CComplex.cpp

cpp 复制代码

#include "CComplex. h"

CComplex::CComplex (double real, double img){
{
　　sreal= real;
  　simg= img;
}

double CComplex:: GetReal()
{
　　return sreal;
}

double CComplex:: GetImg()
{
　　return simg;
}

CComplex CComplex:: operator+(const CComplex &b)const
{
　　return CComplex(sreal+b.sreal, simg+b.simg);
}

CComplex CComplex:: operator+(const double b)const
{
　　return CComplex(sreal+b, simg);
}

从上面代码中可以看出C++和C#的运算符重载的主要区别是C++的重载体现为实例方法,而C#的重载体现为静态方法。

命名空间

命名空间是从C++开始提供的工程性功能，用于避免大规模软件开发的命名冲突问题，在Java中称为包。Java和C#在命名空间上存在一些比较明显的区别。

C++由于需要兼容C,因此可以直接在命名空间之外定义成员，而C#和Java的成员必定义在命名空间或包中。Java的包路径和类文件在项目中的文件夹路径必须完全一致，一个代码文件只允许有一个包路径，只允许有一个公共类。C#中的命名空间则是完全的虚拟路径，命名空间路径无须和文件夹路径匹配，一个代码文件可以包含任意多个命名空间、子命名空间和公共类，甚至可以直接定义嵌套命名空间。

从这些工程规定和限制可以看出，C#希望尽量为开发者提供更方便自由的环境，Java则在语言规范中包含了大量强制性规定以规范项目结构。C#相信非强制规定能让开发者探索出适合自己的风格，Java则相信强制规定才能解决风格不统一导致的团队问题。

使用C#、C+、Java定义命名空间的示例代码如下所示。

(1) C#

cs 复制代码

//全文件通用的命名空间引用
using System;

//定义普通命名空间
namespace Example
{

　　//内部命名空间引用
　　using System.IO;

　　public class A{}

　　//定义内部命名空间
　　namespace Inner
　　{
   　　//内部命名空间引用
　　　　using System. Net;
　　
　　   public class A{}
　　}
}

//直接定义嵌套命名空间
namespace Example. Inner2
{
　　//内部命名空间引用
　　using System. Text;

　　public class A{}
}

(2)C++

cpp 复制代码

#pragma once

class C {};

namespace example {
　　using namespace std;

　　class C {];

　　namespace inner{
   　　class C {};
   }
}

(3)Java

java 复制代码

package com.example. coredx. practice;　　//定义文件的包

import java.io. File;　　//导入类型

import java. lang. *;　　//批量导入包中的类型

public class C{}   　//代码文件应该叫C.java

class A {}

作者简介：荔园微风，1981年生，高级工程师，浙大工学硕士，软件工程项目主管，做过程序员、软件设计师、系统架构师，早期的Windows程序员，Visual Studio忠实用户，C/C++使用者，是一位在计算机界学习、拼搏、奋斗了25年的老将，经历了UNIX时代、桌面WIN32时代、Web应用时代、云计算时代、手机安卓时代、大数据时代、ICT时代、AI深度学习时代、智能机器时代，我不知道未来还会有什么时代，只记得这一路走来，充满着艰辛与收获，愿同大家一起走下去，充满希望的走下去。