博客已更新：C#(Csharp)基础教程(中)(菜鸟教程笔记)
 内容包括：判断、循环、封装、方法、可空类型、数组、字符串、结构体、枚举。
 
 


 
目录
 
1. C# 及其开发环境简介
1.1 C# 概述
1.2 C# 的编程功能
1.3 C# 与.Net的关系
1.3.1 .Net
1.3.2 C#
   
1.4 C# 的集成开发环境（Integrated Development Environment - IDE）
1.4.1 Windows上编写 C# 程序
1.4.2 Linux / Mac OS 上编写 C# 程序
  
  
2. C# 程序结构
2.1 Hello World
  
3. C# 基本语法
3.1 程序实例
3.2 C# 基本语法
3.2.1 using关键字
3.2.2 class关键字
3.2.3 注释
3.2.3 成员变量
3.2.4 实例化一个类
3.2.5 标识符
3.2.6 C# 关键字
3.2.7 C# 占位符{}
  
  
4. C# 数据类型
4.1 值类型（Value types）
4.2 引用类型（Reference types）
4.2.1 对象（Object）类型
4.2.2 动态（Dynamic）类型
4.2.3 字符串（String）类型
   
4.3 指针类型（Pointer types）
  
5. C# 类型转换
5.1 C# 类型转换方法
5.2 Convert.ToInt32()的取整
  
6. C# 变量
6.1 C# 中的变量定义
6.2 C# 中的变量初始化
6.3 接受来自用户的值
6.4 C# 中的 Lvalues 和 Rvalues
  
7. C# 常量
7.1 整数常量
7.2 浮点常量
7.3 字符常量
7.4 字符串常量
7.5 定义常量
7.6 静态常量和动态常量
7.6.1 静态常量（编译时常量）const
7.6.2 动态常量（运行时常量）readonly
7.6.3 静态常量与动态常量的使用场景
  
  
8. C# 运算符
8.1 算术运算符
8.2 关系运算符
8.3 逻辑运算符
8.4 位运算符
8.5 赋值运算符
8.6 其他运算符
8.7 C# 中的运算符优先级
 

 
1. C# 及其开发环境简介
 
1.1 C# 概述
 
C# 是一个现代的、通用的、面向对象的编程语言，它是由微软（Microsoft）开发的，由 Ecma 和 ISO 核准认可的。
 
C# 是由 Anders Hejlsberg 和他的团队在 .Net 框架开发期间开发的。
 
C# 是专为公共语言基础结构（CLI）设计的。CLI 由可执行代码和运行时环境组成，允许在不同的计算机平台和体系结构上使用各种高级语言。
 下面列出了 C# 成为一种广泛应用的专业语言的原因：
 
现代的、通用的编程语言。
面向对象。
面向组件。
容易学习。
结构化语言。
它产生高效率的程序。
它可以在多种计算机平台上编译。
.Net 框架的一部分。
 
1.2 C# 的编程功能
 
虽然 C# 的构想十分接近于传统高级语言 C 和 C++，是一门面向对象的编程语言，但是它与 Java 非常相似，有许多强大的编程功能，因此得到广大程序员的青睐。
 下面列出 C# 一些重要的功能：
 
布尔条件（Boolean Conditions）
自动垃圾回收（Automatic Garbage Collection）
标准库（Standard Library）
组件版本（Assembly Versioning）
属性（Properties）和事件（Events）
委托（Delegates）和事件管理（Events Management）
易于使用的泛型（Generics）
索引器（Indexers）
条件编译（Conditional Compilation）
简单的多线程（Multithreading）
LINQ 和 Lambda 表达式
集成 Windows
 
1.3 C# 与.Net的关系
 
在这里，主要讨论创建 C# 编程所需的工具。前面已经提到 C# 是 .Net 框架的一部分，且用于编写 .Net 应用程序。因此，在讨论运行 C# 程序的可用工具之前，让我们先了解一下 C# 与 .Net 框架之间的关系。
 
1.3.1 .Net
 
.NET是微软公司下的一个开发平台，.NET核心就是.NET Framwork（.NET框架）是.NET程序开发和运行的环境，在这个平台下可以用不同的语言进行开发，因为.NET是跨语言的一个平台。语言可以是C#,f#,j#,vb.net等等。java和.NET不同的一点是，java是跨平台的，不跨语言的。.NET跨平台仅限于安卓系统和 iOS 苹果系统。
 .Net 框架是一个创新的平台，能帮您编写出下面类型的应用程序：
 
Windows 应用程序
Web 应用程序
Web 服务
 
.Net 框架应用程序是多平台的应用程序。框架的设计方式使它适用于下列各种语言：C#、C++、Visual Basic、Jscript、COBOL 等等。所有这些语言可以访问框架，彼此之间也可以互相交互。
 .Net 框架由一个巨大的代码库组成，用于 C# 等客户端语言。下面列出一些 .Net 框架的组件：
 
公共语言运行库（Common Language Runtime - CLR）
.Net 框架类库（.Net Framework Class Library）
公共语言规范（Common Language Specification）
通用类型系统（Common Type System）
元数据（Metadata）和组件（Assemblies）
Windows 窗体（Windows Forms）
ASP.Net 和 ASP.Net AJAX
ADO.Net
Windows 工作流基础（Windows Workflow Foundation - WF）
Windows 显示基础（Windows Presentation Foundation）
Windows 通信基础（Windows Communication Foundation - WCF）
LINQ
 
如需了解每个组件的详细信息，请参阅微软（Microsoft）的文档。
 
1.3.2 C#
 
C#是一个.NET平台下的一个程序设计语言，仅仅是一个语言。是运行在.net CLR上的，用于创建应用程序的高级语言。 程序设计语言是为了方便开发人员和计算机沟通的工具。
 
1.4 C# 的集成开发环境（Integrated Development Environment - IDE）
 
1.4.1 Windows上编写 C# 程序
 
微软（Microsoft）提供了下列用于 C# 编程的开发工具：
 
Visual Studio 2010 (VS)
Visual C# 2010 Express (VCE)
Visual Web Developer
 
后面两个是免费使用的，可从微软官方网址下载。使用这些工具，您可以编写各种 C# 程序，从简单的命令行应用程序到更复杂的应用程序。您也可以使用基本的文本编辑器（比如 Notepad）编写 C# 源代码文件，并使用命令行编译器（.NET 框架的一部分）编译代码为组件。
 Visual C# Express 和 Visual Web Developer Express 版本是 Visual Studio 的定制版本，且具有相同的外观和感观。它们保留 Visual Studio 的大部分功能。
 
1.4.2 Linux / Mac OS 上编写 C# 程序
 
虽然 .NET 框架是运行在 Windows 操作系统上，但是也有一些运行于其它操作系统上的版本可供选择。Mono 是 .NET 框架的一个开源版本，它包含了一个 C# 编译器，且可运行于多种操作系统上，比如各种版本的 Linux 和 Mac OS。如需了解更多详情，请访问 Go Mono。
 Mono 的目的不仅仅是跨平台地运行微软 .NET 应用程序，而且也为 Linux 开发者提供了更好的开发工具。Mono 可运行在多种操作系统上，包括 Android、BSD、iOS、Linux、OS X、Windows、Solaris 和 UNIX。
 
 
 
VS 是 Visual Studio，它是微软提供的一个工具集，由各种各样的工具组成。VS 可以支持 C/C++、VB、JAVA、C# 编程。然了一次只能支持一种编程方式。在 VS 安装完成，第一次运行的时候会让你选择常用语言，如果你选择 C/C++，那么他就成了能够进行 C/C++ 编程的平台也许就是你所说的 VC 了。如果不想用 C/C++ 的话，只需要修改一下他的初始化设置，选择别的编程语言，就成为了另一种的语言的编程环境了。
VC 是 Visual C++，是一个独立的 C/C++ 的开发工具，比较著名的是 VC6.0，现在的 VC2010其实就是 VC10.0。再通俗一点，以 VS2010 和 VC2010 为例，VS2010 相当与 Office2010，包括了 World2010、Excel2010 等，而 VC2010 就相当于是 World2010。
 
 
2. C# 程序结构
 
2.1 Hello World
 
一个 C# 程序主要包括以下部分：
 
命名空间声明（Namespace declaration）
一个 class
Class 方法
Class 属性
一个 Main 方法
语句（Statements）& 表达式（Expressions）
注释
 
using System;
namespace HelloWorldApplication
{
   class HelloWorld
   {
      static void Main(string[] args)
      {
         /* 我的第一个 C# 程序*/
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}
 
Hello World
 
程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
下一行是 namespace 声明。一个 namespace 里包含了一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld。
下一行是 class 声明。类 HelloWorld 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，HelloWorld 类只有一个 Main 方法。
下一行定义了 Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时 类将做什么动作。
下一行/*...*/将会被编译器忽略，且它会在程序中添加额外的注释。
Main 方法通过语句 Console.WriteLine("Hello World"); 指定了它的行为。
 WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 "Hello World"。
最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。
 以下几点值得注意：
 
C# 是大小写敏感的。
 
所有的语句和表达式必须以分号（;）结尾。
程序的执行从 Main 方法开始。
与 Java 不同的是，文件名可以不同于类的名称。
 
3. C# 基本语法
 
3.1 程序实例
 
C# 是一种面向对象的编程语言。在面向对象的程序设计方法中，程序由各种相互交互的对象组成。相同种类的对象通常具有相同的类型，或者说，是在相同的 class 中。
 例如，以 Rectangle（矩形）对象为例。它具有 length 和 width 属性。根据设计，它可能需要接受这些属性值、计算面积和显示细节。
 让我们来看看一个 Rectangle（矩形）类的实现，并借此讨论 C# 的基本语法：
 
using System;
namespace RectangleApplication
{
    class Rectangle
    {
        // 成员变量
        double length;
        double width;
        public void Acceptdetails()
        {
            length = 4.5;    
            width = 3.5;
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("Length: {0}", length);
            Console.WriteLine("Width: {0}", width);
            Console.WriteLine("Area: {0}", GetArea());
        }
    }
   
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}
 
Length: 4.5
Width: 3.5
Area: 15.75
 
3.2 C# 基本语法
 
3.2.1 using关键字
 
在任何 C# 程序中的第一条语句都是：
 
using System;
 
一般在程序开头添加 using System;，这时System.String 就可简写为string 。
 例如：
 
// using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            System.String a = "Hello World!";
            System.Console.WriteLine(a);
            System.Console.ReadKey();
        }
    }
}
 
和
 
using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            string a = "Hello World!";
            Console.WriteLine(a);
            Console.ReadKey();
        }
    }
}
 
是等价的。
 using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。
 
3.2.2 class关键字
 
class关键字用于声明一个类
 
3.2.3 注释
 
注释是用于解释代码。编译器会忽略注释的条目。在 C# 程序中，多行注释以/*开始，并以字符 */ 终止，如下所示：
 
/* This program demonstrates
The basic syntax of C# programming 
Language */
 
单行注释是用 ‘//’ 符号表示。例如：
 
}//end class Rectangle    
 
3.2.3 成员变量
 
变量是类的属性或数据成员，用于存储数据。在上面的程序中，Rectangle 类有两个成员变量，名为 length 和 width。
 
3.2.4 实例化一个类
 
在上面的程序中，类 ExecuteRectangle 是一个包含 Main() 方法和实例化 Rectangle 类的类。
 
Rectangle r = new Rectangle();
 
3.2.5 标识符
 
标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：
 
标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。
标识符中的第一个字符不能是数字。
标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : " ’ / \。
标识符不能是 C# 关键字。除非它们有一个 @ 前缀。 例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
不能与C#的类库名称相同。
 
3.2.6 C# 关键字
 
关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。
 在 C# 中，有些关键字在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。
 下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：
 

 
 
3.2.7 C# 占位符{}
 
当 WriteLine() 函数有多个参数时，输出第一个参数(双引号内的)中的内容，而第二个及后面的参数中的内容替换掉第一个参数中对应位置的占位符一起输出。
 
static void Main(string[] args)
{
    Console.WriteLine("A:{0}，a:{1}",65,97);
    Console.ReadLine();
}
 
A:65，a:97
 
如果第一个参数没有留占位符,那么第二个参数内容不输出。
 
Console.WriteLine("A:,a:",65,97);
 
A:,a:
 
占位符从零开始计数,且占位符中的数字不能大于第二个及后面的参数的总个数减一(要求占位符必须有可替换的值)。
 占位符数字与第二个及后面的参数字符位置一一对应。
 
static void Main(string[] args)
{
    Console.WriteLine("A:{1}，a:{0}",65,97);
    Console.ReadLine();
}
 
A:97,a:65
 
4. C# 数据类型
 
在 C# 中，变量分为以下几种类型：
 
值类型（Value types）
引用类型（Reference types）
指针类型（Pointer types）
 
4.1 值类型（Value types）
 
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。
 值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。
 下表列出了 C# 2010 中可用的值类型：
 
 如需得到一个类型或一个变量在特定平台上的准确尺寸，可以使用 sizeof 方法。表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。下面举例获取任何机器上 int 类型的存储尺寸：
 
using System;

namespace DataTypeApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}
 
Size of int: 4
 
4.2 引用类型（Reference types）
 
引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。
 
换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的引用类型有：object、dynamic 和 string。
 
 
 
就像仓库，仓库里有货架，货架上有编号：A1,A2,A3…, 这些编号就可以看做是引用类型，现在来了一批货，有 “土豆，黄瓜，西红柿”，这些就是值类型，如果你想让 A1=土豆，那么就要把土豆搬到 A1 里面去，这就叫装箱，装箱需要耗费人力和工时（也就是耗费CPU和内存），同理拆箱就要把对应编号的货物搬出来，也是需要耗费人力和工时。
 
 
 
 
从内存上看，值类型是在栈中的操作，而引用类型是在堆中的操作。
 （导致 => 值类型存取速度快，引用类型存取速度慢。）
从本质上看，值类型表示实际数据，引用类型表示指向存储在内存堆中的数据的指针或引用。
 （值类型是具体的那个数值所占用的空间大小，而引用类型是存放那个数值的空间地址。）
从来源上看，值类型继承自System.ValueType，引用类型继承自System.Object。
特别的：结构体是值类型，类和string是引用类型。
 
 
4.2.1 对象（Object）类型
 
对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。
 
当一个值类型转换为对象类型时，则被称为装箱；另一方面，当一个对象类型转换为值类型时，则被称为拆箱。
 
装箱：值类型转换为对象类型, 实例：
 
int val = 8;
object obj = val;//整型数据转换为了对象类型（装箱）
 
拆箱：之前由值类型转换而来的对象类型再转回值类型, 实例：
 
int val = 8;
object obj = val;//先装箱
int nval = （int）obj;//再拆箱
 
只有装过箱的数据才能拆箱。
 
4.2.2 动态（Dynamic）类型
 
您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。
 声明动态类型的语法：
 
dynamic <variable_name> = value;
 
实例为：
 
dynamic d = 20;
 
动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。
 
4.2.3 字符串（String）类型
 
字符串（String）类型 允许您给变量分配任何字符串值。字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。
 例如：
 
string str = "runoob.com";
 
一个 @引号字符串：
 
@"runoob.com";
 
C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，比如：
 
string str = @"C:\Windows";
 
等价于：
 
string str = "C:\\Windows";
 
@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
 
string str = @"<script type=""text/javascript"">
    <!--
    -->
</script>";
 
用户自定义引用类型有：class、interface 或 delegate。我们将在以后的章节中讨论这些类型。
 
4.3 指针类型（Pointer types）
 
指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
 声明指针类型的语法：
 
type* identifier;
 
例如：
 
char* cptr;
int* iptr;
 
5. C# 类型转换
 
类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。在 C# 中，类型铸造有两种形式：
 
隐式类型转换 ：这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换 ：显式类型转换，即强制类型转换。通过用户使用预定义的函数显式完成的，显式转换需要强制转换运算符，而且强制转换会造成数据丢失。转换类型的范围大小和从属关系和隐式转换相反。显式转换可能会导致数据出错，或者转换失败，甚至无法编译成功。
 
下面的实例显示了一个隐式的类型转换：
 
namespace TypeConvertion
{   class Class1
    {

    }

    class Class2 : Class1 //类Class2是类Class1的子类
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
            int inum = 100;
            long lnum = inum; // 进行了隐式转换，将 int 型（数据范围小）数据转换为了 long 型（数据范围大）的数据
            Class1 c1 = new Class2(); // 这里也是隐式转换，将一个新建的 Class2 实例转换为了其基类 Class1 类型的实例 C1
        }
    }
}
 
下面的实例显示了一个显式的类型转换：
 
namespace TypeConversionApplication
{
    class ExplicitConversion
    {
        static void Main(string[] args)
        {
            double d = 5673.74;
            int i;

            // 强制转换 double 为 int
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
           
        }
    }
}
 
5673
 
5.1 C# 类型转换方法
 
C# 提供了下列内置的类型转换方法：
 
 
 下面的实例把不同值的类型转换为字符串类型：
 
namespace TypeConversionApplication
{
    class StringConversion
    {
        static void Main(string[] args)
        {
            int i = 75;
            float f = 53.005f;
            double d = 2345.7652;
            bool b = true;

            Console.WriteLine(i.ToString());
            Console.WriteLine(f.ToString());
            Console.WriteLine(d.ToString());
            Console.WriteLine(b.ToString());
            Console.ReadKey();
           
        }
    }
}
 
75
53.005
2345.7652
True
 
5.2 Convert.ToInt32()的取整
 
C# 中对 double 类型的数据取整，可以使用Convert.ToInt32()方法，也可使用 int 强制转换为整数，使用 int 时并不存在四舍五入的情况，而是直接将后面的小数位数丢掉。比如:
 
class Program
{
    static void Main(string[] args)
    {
        double a = 1.35;
        double b = 1.65;
        int a1 = Convert.ToInt32(a);
        int a2 = (int)(a);
        int b1 = Convert.ToInt32(b);
        int b2 = (int)(b);
        Console.WriteLine("{0}使用convert方法转化的结果为：{1}",a,a1);
        Console.WriteLine("{0}使用int强制转换的结果为：{1}",a,a2);
        Console.WriteLine("{0}使用convert方法转化的结果为：{1}", b, b1);
        Console.WriteLine("{0}使用int强制转换的结果为：{1}", b, b2);
        Console.ReadKey();
    }
}
 
1.35使用convert方法转化的结果为：1
1.35使用int强制转换的结果为：1
1.65使用convert方法转化的结果为：2
1.65使用int强制转换的结果为：1
 
6. C# 变量
 
一个变量只不过是一个供程序操作的存储区的名字。在 C# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。范围内的值可以存储在内存中，可以对变量进行一系列操作。
 我们已经讨论了各种数据类型。C# 中提供的基本的值类型大致可以分为以下几类：
 
 C# 允许定义其他值类型的变量，比如 enum，也允许定义引用类型变量，比如 class。这些我们将在以后的章节中进行讨论。在本章节中，我们只研究基本变量类型。
 
6.1 C# 中的变量定义
 
C# 中变量定义的语法：
 
<data_type> <variable_list>;
 
在这里，data_type 必须是一个有效的 C# 数据类型，可以是 char、int、float、double 或其他用户自定义的数据类型。variable_list 可以由一个或多个用逗号分隔的标识符名称组成。
 一些有效的变量定义如下所示：
 
int i, j, k;
char c, ch;
float f, salary;
double d;
 
您可以在变量定义时进行初始化：
 
int i = 100;
 
6.2 C# 中的变量初始化
 
变量通过在等号后跟一个常量表达式进行初始化（赋值）。初始化的一般形式为：
 
variable_name = value;
 
变量可以在声明时被初始化（指定一个初始值）。初始化由一个等号后跟一个常量表达式组成，如下所示：
 
<data_type> <variable_name> = value;
 
一些实例：
 
int d = 3, f = 5;    /* 初始化 d 和 f. */
byte z = 22;         /* 初始化 z. */
double pi = 3.14159; /* 声明 pi 的近似值 */
char x = 'x';        /* 变量 x 的值为 'x' */
 
正确地初始化变量是一个良好的编程习惯，否则有时程序会产生意想不到的结果。
 请看下面的实例，使用了各种类型的变量：
 
namespace VariableDefinition
{
    class Program
    {
        static void Main(string[] args)
        {
            short a;
            int b ;
            double c;

            /* 实际初始化 */
            a = 10;
            b = 20;
            c = a + b;
            Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
            Console.ReadLine();
        }
    }
}
 
a = 10, b = 20, c = 30
 
6.3 接受来自用户的值
 
System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。
 例如：
 
int num;
num = Convert.ToInt32(Console.ReadLine());
 
函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为 Console.ReadLine() 只接受字符串格式的数据。
 
6.4 C# 中的 Lvalues 和 Rvalues
 
C# 中的两种表达式：
 
lvalue(左值)：lvalue 表达式可以出现在赋值语句的左边或右边。
rvalue(右值)：rvalue 表达式可以出现在赋值语句的右边，不能出现在赋值语句的左边。
 
变量是 lvalue 的，所以可以出现在赋值语句的左边。数值是 rvalue 的，因此不能被赋值，不能出现在赋值语句的左边。下面是一个有效的语句：
 
int g = 20;
 
下面是一个无效的语句，会产生编译时错误：
 
10 = 20;
 
7. C# 常量
 
常量是固定值，程序执行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。
 常量可以被当作常规的变量，只是它们的值在定义后不能被修改。
 
7.1 整数常量
 
整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。
 整数常量也可以有后缀，可以是 U 和 L 的组合，其中，U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写，多个后缀以任意顺序进行组合。
 这里有一些整数常量的实例：
 
212         /* 合法 */
215u        /* 合法 */
0xFeeL      /* 合法 */
078         /* 非法：8 不是一个八进制数字 */
032UU       /* 非法：不能重复后缀 */
 
以下是各种类型的整数常量的实例：
 
85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* int */
30u        /* 无符号 int */
30l        /* long */
30ul       /* 无符号 long */
 
7.2 浮点常量
 
一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。
 这里有一些浮点常量的实例：
 
3.14159       /* 合法 */
314159E-5L    /* 合法 */
510E          /* 非法：不完全指数 */
210f          /* 非法：没有小数或指数 */
.e55          /* 非法：缺少整数或小数 */
 
使用小数形式表示时，必须包含小数点、指数或同时包含两者。使用指数形式表示时，必须包含整数部分、小数部分或同时包含两者。有符号的指数是用 e 或 E 表示的。
 
7.3 字符常量
 
字符常量是括在单引号里，例如，‘x’，且可存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符（例如 ‘x’）、一个转义序列（例如 ‘\t’）或者一个通用字符（例如 ‘\u02C0’）。
 在 C# 中有一些特定的字符，当它们的前面带有反斜杠时有特殊的意义，可用于表示换行符（\n）或制表符 tab（\t）。在这里，列出一些转义序列码：
 
 以下是一些转义序列字符的实例：
 
namespace EscapeChar
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello\tWorld\n\n");
            Console.ReadLine();
        }
    }
}
 
Hello   World
 
7.4 字符串常量
 
字符串常量是括在双引号""里，或者是括在@""里。字符串常量包含的字符与字符常量相似，可以是：普通字符、转义序列和通用字符
 使用字符串常量时，可以把一个很长的行拆成多个行，可以使用空格分隔各个部分。
 这里是一些字符串常量的实例。下面所列的各种形式表示相同的字符串。
 
string a = "hello, world";                  // hello, world
string b = @"hello, world";               // hello, world
string c = "hello \t world";               // hello     world
string d = @"hello \t world";               // hello \t world
string e = "Joe said \"Hello\" to me";      // Joe said "Hello" to me
string f = @"Joe said ""Hello"" to me";   // Joe said "Hello" to me
string g = "\\\\server\\share\\file.txt";   // \\server\share\file.txt
string h = @"\\server\share\file.txt";      // \\server\share\file.txt
string i = "one\r\ntwo\r\nthree";
string j = @"one
two
three";
 
7.5 定义常量
 
常量是使用 const 关键字来定义的 。定义一个常量的语法如下：
 
const <data_type> <constant_name> = value;
 
下面的代码演示了如何在程序中定义和使用常量：
 
using System;

public class ConstTest
{
    class SampleClass
    {
        public int x;
        public int y;
        public const int c1 = 5;
        public const int c2 = c1 + 5;

        public SampleClass(int p1, int p2)
        {
            x = p1;
            y = p2;
        }
    }

    static void Main()
    {
        SampleClass mC = new SampleClass(11, 22);
        Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
        Console.WriteLine("c1 = {0}, c2 = {1}",
                          SampleClass.c1, SampleClass.c2);
    }
}
 
x = 11, y = 22
c1 = 5, c2 = 10
 
7.6 静态常量和动态常量
 
7.6.1 静态常量（编译时常量）const
 
在编译时就确定了值，必须在声明时就进行初始化且之后不能进行更改，可在类和方法中定义。定义方法如下：
 
const double a=3.14；// 正确声明常量的方法
const int b;         // 错误，没有初始化
 
7.6.2 动态常量（运行时常量）readonly
 
在运行时确定值，只能在声明时或构造函数中初始化，只能在类中定义。定义方法如下：
 
class Program
{
    readonly int a=1;  // 声明时初始化
    readonly int b;    // 构造函数中初始化
    Program()
    {
        b=2;
    }
    static void Main()
    {
    }
}
 
7.6.3 静态常量与动态常量的使用场景
 
在下面两种情况下，可以使用 const 常量：
 
取值永久不变(比如圆周率、一天包含的小时数、地球的半径等)。
对程序性能要求非常苛刻。
 
除此之外的其他情况都应该优先采用 readonly 常量。
 
8. C# 运算符
 
8.1 算术运算符
 
下表显示了 C# 支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
 
 请看下面的实例，了解 C# 中所有可用的算术运算符：
 
using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
            int b = 10;
            int c;

            c = a + b;
            Console.WriteLine("Line 1 - c 的值是 {0}", c);
            c = a - b;
            Console.WriteLine("Line 2 - c 的值是 {0}", c);
            c = a * b;
            Console.WriteLine("Line 3 - c 的值是 {0}", c);
            c = a / b;
            Console.WriteLine("Line 4 - c 的值是 {0}", c);
            c = a % b;
            Console.WriteLine("Line 5 - c 的值是 {0}", c);

            // ++a 先进行自增运算再赋值
            c = ++a;
            Console.WriteLine("Line 6 - c 的值是 {0}", c);

            // 此时 a 的值为 22
            // --a 先进行自减运算再赋值
            c = --a;
            Console.WriteLine("Line 7 - c 的值是 {0}", c);
            Console.ReadLine();
        }
    }
}
 
Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 22
Line 7 - c 的值是 21
 
c = a++: 先将 a 赋值给 c，再对 a 进行自增运算。
 c = ++a: 先将 a 进行自增运算，再将 a 赋值给 c 。
 c = a --: 先将 a 赋值给 c，再对 a 进行自减运算。
 c = --a: 先将 a 进行自减运算，再将 a 赋值给 c 。
 
using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 1;
            int b;

            // a++ 先赋值再进行自增运算
            b = a++;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // ++a 先进行自增运算再赋值
            a = 1; // 重新初始化 a
            b = ++a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // a-- 先赋值再进行自减运算
            a = 1;  // 重新初始化 a
            b= a--;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // --a 先进行自减运算再赋值
            a = 1;  // 重新初始化 a
            b= --a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();
        }
    }
}
 
a = 2
b = 1
a = 2
b = 2
a = 0
b = 1
a = 0
b = 0
 
8.2 关系运算符
 
下表显示了 C# 支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
 
 
using System;

class Program
{
  static void Main(string[] args)
  {
      int a = 21;
      int b = 10;
     
      if (a == b)
      {
          Console.WriteLine("Line 1 - a 等于 b");
      }
      else
      {
          Console.WriteLine("Line 1 - a 不等于 b");
      }
      if (a < b)
      {
          Console.WriteLine("Line 2 - a 小于 b");
      }
      else
      {
          Console.WriteLine("Line 2 - a 不小于 b");
      }
      if (a > b)
      {
          Console.WriteLine("Line 3 - a 大于 b");
      }
      else
      {
          Console.WriteLine("Line 3 - a 不大于 b");
      }
      /* 改变 a 和 b 的值 */
      a = 5;
      b = 20;
      if (a <= b)
      {
         Console.WriteLine("Line 4 - a 小于或等于 b");
      }
      if (b >= a)
      {
         Console.WriteLine("Line 5 - b 大于或等于 a");
      }
  }
}
 
Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a
 
8.3 逻辑运算符
 
下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：
 
 
using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
           
            if (a && b)
            {
               Console.WriteLine("Line 1 - 条件为真");
            }
            if (a || b)
            {
                Console.WriteLine("Line 2 - 条件为真");
            }
            /* 改变 a 和 b 的值 */
            a = false;
            b = true;
            if (a && b)
            {
                Console.WriteLine("Line 3 - 条件为真");
            }
            else
            {
                Console.WriteLine("Line 3 - 条件不为真");
            }
            if (!(a && b))
            {
                Console.WriteLine("Line 4 - 条件为真");
            }
            Console.ReadLine();
        }
    }
}
 
Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真
 
8.4 位运算符
 
位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：
 
 A = 0011 1100
 
B = 0000 1101
 -----------------------
 A&B = 0000 1100
 
A|B = 0011 1101
 
A^B = 0011 0001
 
~A = 1100 0011
 
下表列出了 C# 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：
 
 
using System;
namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 60;            /* 60 = 0011 1100 */  
            int b = 13;            /* 13 = 0000 1101 */
            int c = 0;          

             c = a & b;           /* 12 = 0000 1100 */
             Console.WriteLine("Line 1 - c 的值是 {0}", c );

             c = a | b;           /* 61 = 0011 1101 */
             Console.WriteLine("Line 2 - c 的值是 {0}", c);

             c = a ^ b;           /* 49 = 0011 0001 */
             Console.WriteLine("Line 3 - c 的值是 {0}", c);

             c = ~a;               /*-61 = 1100 0011 */
             Console.WriteLine("Line 4 - c 的值是 {0}", c);

             c = a << 2;     /* 240 = 1111 0000 */
             Console.WriteLine("Line 5 - c 的值是 {0}", c);

             c = a >> 2;     /* 15 = 0000 1111 */
             Console.WriteLine("Line 6 - c 的值是 {0}", c);
            Console.ReadLine();
        }
    }
}
 
Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15
 
8.5 赋值运算符
 
 
using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
            int c;

            c = a;
            Console.WriteLine("Line 1 - =  c 的值 = {0}", c);

            c += a;
            Console.WriteLine("Line 2 - += c 的值 = {0}", c);

            c -= a;
            Console.WriteLine("Line 3 - -=  c 的值 = {0}", c);

            c *= a;
            Console.WriteLine("Line 4 - *=  c 的值 = {0}", c);

            c /= a;
            Console.WriteLine("Line 5 - /=  c 的值 = {0}", c);

            c = 200;
            c %= a;
            Console.WriteLine("Line 6 - %=  c 的值 = {0}", c);

            c <<= 2;
            Console.WriteLine("Line 7 - <<=  c 的值 = {0}", c);

            c >>= 2;
            Console.WriteLine("Line 8 - >>=  c 的值 = {0}", c);

            c &= 2;
            Console.WriteLine("Line 9 - &=  c 的值 = {0}", c);

            c ^= 2;
            Console.WriteLine("Line 10 - ^=  c 的值 = {0}", c);

            c |= 2;
            Console.WriteLine("Line 11 - |=  c 的值 = {0}", c);
            Console.ReadLine();
        }
    }
}
 
Line 1 - =     c 的值 = 21
Line 2 - +=    c 的值 = 42
Line 3 - -=    c 的值 = 21
Line 4 - *=    c 的值 = 441
Line 5 - /=    c 的值 = 21
Line 6 - %=    c 的值 = 11
Line 7 - <<=    c 的值 = 44
Line 8 - >>=    c 的值 = 11
Line 9 - &=    c 的值 = 2
Line 10 - ^=    c 的值 = 0
Line 11 - |=    c 的值 = 2
 
8.6 其他运算符
 
下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。
 
 
using System;

namespace OperatorsAppl
{
   
   class Program
   {
      static void Main(string[] args)
      {
         
         /* sizeof 运算符的实例 */
         Console.WriteLine("int 的大小是 {0}", sizeof(int));
         Console.WriteLine("short 的大小是 {0}", sizeof(short));
         Console.WriteLine("double 的大小是 {0}", sizeof(double));
         
         /* 三元运算符的实例 */
         int a, b;
         a = 10;
         b = (a == 1) ? 20 : 30;
         Console.WriteLine("b 的值是 {0}", b);

         b = (a == 10) ? 20 : 30;
         Console.WriteLine("b 的值是 {0}", b);
         Console.ReadLine();
      }
   }
}
 
int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20
 
8.7 C# 中的运算符优先级
 
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。
 例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。
 下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
 

一、C#简介
 
C#是微软公司发布的一种面向对象的、运行于.NET Framework之上的高级程序设计语言。C#看起来与Java有着惊人的相似；它包括了诸如单一继承、接口、与Java几乎同样的语法和编译成中间代码再运行的过程。但是C#与Java有着明显的不同，它借鉴了Delphi的一个特点，与COM（组件对象模型）是直接集成的，而且它是微软公司 .NET windows网络框架的主角。
 　　C#是一种安全的、稳定的、简单的、优雅的，由C和C++衍生出来的面向对象的编程语言。它在继承C和C++强大功能的同时去掉了一些它们的复杂特性（例如没有宏以及不允许多重继承）。C#综合了VB简单的可视化操作和C++的高运行效率，以其强大的操作能力、优雅的语法风格、创新的语言特性和便捷的面向组件编程的支持成为.NET开发的首选语言。
 

 
二、Create a New C# Project
 
环境：Visual Studio (VS)
 编译 & 执行 C# 程序
 如果您使用 Visual Studio.Net 编译和执行 C# 程序，请按下面的步骤进行：
 
 
 
1、启动 Visual Studio，在菜单栏上选择 File -> New -> Project，从模板中选择 Visual C#，然后选择 Windows，选择 Console Application，为您的项目制定一个名称，然后点击 OK 按钮；
 2、新项目会出现在解决方案资源管理器（Solution Explorer）中，在代码编辑器（Code Editor）中编写代码，点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口（Command Prompt window），显示 输出结果。
 
 
或者通过命令符工具
 
 
 
打开一个文本编辑器，添加上面提到的代码，保存文件为 helloworld.cs
 打开命令提示符工具，定位到文件所保存的目录
 键入 csc helloworld.cs 并按下 enter 键来编译代码
 如果代码没有错误，命令提示符会进入下一行，并生成 helloworld.exe 可执行文件
 接下来，键入 helloworld 来执行程序。
 您将看到 “Hello World” 打印在屏幕上。
 
 

 
三、C# 代码
 
using System;
namespace HelloWorldApplication
{
    /* 类名为 HelloWorld */
    class HelloWorld
    {
        /* main函数 */
        static void Main(string[] args)
        {
            /* 我的第一个 C# 程序 */
            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }
    }
}
 
1.using System：using 关键字用于在程序中包含 System 命名空间，一个程序一般有多个using 语句；
 
2.namespace声明：一个 namespace 是一系列的类，HelloWorldApplication 命名空间包含了类 HelloWorld；
 
3.class 声明：类 HelloWorld 包含了程序使用的数据和方法声明，类一般包含多个方法，方法定义了类的行为，在这里HelloWorld 类只有一个 Main 方法；
 
4.Main 方法：是所有 C# 程序的 入口点，Main 方法说明当执行时 类将做什么动作，Main 方法通过语句 Console.WriteLine("Hello World"); 指定了它的行为。
 
5.WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法，该语句会在屏幕上显示消息 “Hello,World!”；
 　　Console.ReadKey(); 是针对 VS.NET 用户，这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。
 

 
四、C# 基本语法
 
1.using 关键字
	在任何 C# 程序中的第一条语句都是：using System
	using 关键字用于在程序中包含命名空间,一个程序可以包含多个 using 语句

2. class 关键字
	class 关键字用于声明一个类

3. C# 注释
	多行注释以 /* 开始，并以字符 */ 终止，如下所示:
		/* This program demonstrates
		The basic syntax of C# programming 
		Language */
	单行注释是用 '//' 符号表示。例如：
		//end class Rectangle    

4.成员变量: 变量是类的属性或数据成员,用于存储数据
  成员函数: 函数是一系列执行指定任务的语句,类的成员函数是在类内声明的
  标识符: 标识符是用来识别类、变量、函数或任何其它用户定义的项目

5.C#关键字
	关键字是 C# 编译器预定义的保留字,这些关键字不能用作标识符
 

 
五、C# 数据类型
 
在 C# 中，变量分为以下几种类型：
 
值类型（Value types） 引用类型（Reference types） 指针类型（Pointer types）
 
1.值类型（Value types）
 
值类型（Value types）:
	bool		布尔值	
	byte		8 位无符号整数	
	char		16 位 Unicode 字符	
	decimal		128 位精确的十进制值
	double		64 位双精度浮点型	
	float		32 位单精度浮点型	
	int			32 位有符号整数类型	
	long		64 位有符号整数类型	
	sbyte		8 位有符号整数类型	
	short		16 位有符号整数类型	
	uint		32 位无符号整数类型	
	ulong		64 位无符号整数类型	
	ushort		16 位无符号整数类型
 

 
2.引用类型（Reference types）
 
 
 
引用类型不包含存储在变量中的实际数据,但它们包含对变量的引用。换句话说，它们指的是一个内存位置。使用多个变量时,引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。
 
 
内置的引用类型有：object、dynamic 和 string
 
-> 对象（Object）类型
	对象（Object）类型 是 C# 中所有数据类型的终极基类Object 是 System.Object 类的别名。所以对象（Object）类型可以
被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是,在分配值之前，需要先进行类型转换。

	装箱操作: 当一个值类型转换为对象类型时
	拆箱操作: 当一个对象类型转换为值类型时

	object obj;
	obj = 100; // 这是装箱
 
-> 动态（Dynamic）类型
可以存储任何类型的值在动态数据类型变量中,这些变量的类型检查是在运行时发生的

声明动态类型的语法：dynamic <variable_name> = value;

例如：dynamic d = 20;
	动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的
类型检查是在运行时发生的
 
->字符串（string）类型
	字符串（string）类型 允许您给变量分配任何字符串值,字符串（string）类型是 System.String 类的别名。它是从
对象（Object）类型派生的,字符串（string）类型的值可以通过两种形式进行分配：引号和 @引号

例如：
string str = "baidu.com";
一个 @引号字符串：@"baidu.com";

	C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待
比如：
	string str = @"C:\Windows";
	等价于：string str = "C:\\Windows";
	
用户自定义引用类型有：class、interface 或 delegate
 

 
六、C# 类型转换方法
 
C# 提供了下列常用的内置类型转换方法
 
序号	 方法     &               描 述

 1	ToChar 		   把类型转换为单个 Unicode 字符类型
 2	ToDateTime     把类型（整数或字符串类型）转换为 日期-时间 结构
 3	ToDecimal      把浮点型或整数类型转换为十进制类型
 4	ToDouble  		把类型转换为双精度浮点型
 5	ToInt16 / ToInt32 / ToInt64  	把类型转换为 16/32/64 位整数类型
 6	ToString  		把类型转换为字符串类型
 7	ToType  		把类型转换为指定类型
 8	ToUInt16  		把类型转换为 16 位无符号整数类型
 

 
七、C# 中
 
-> 运算符（算术、关系、逻辑、位、赋值、其他）
-> 判断、循环、访问修饰符、方法
-> 数组、字符串、枚举、Class
-> 继承、多态、重载
-> 接口 、命名空间、正则表达式、异常处理
和Java类似
 
下面列出 C# 一些重要的功能：
 
布尔条件（Boolean Conditions）
 自动垃圾回收（Automatic Garbage Collection）
 标准库（Standard Library）
 组件版本（Assembly Versioning）
 属性（Properties）和事件（Events）
 委托（Delegates）和事件管理（Events Management）
 易于使用的泛型（Generics）
 索引器（Indexers）
 条件编译（Conditional Compilation）
 简单的多线程（Multithreading）
 LINQ 和 Lambda 表达式
 集成 Windows
 

 
八、Java 和 C# 的相同点和区别
 
相同点：
 　　都是面向对象的语言，也就是说，它们都能实现面向对象的思想(封装,继承,多态)
 
 
区别：
 
1、开发环境
 　　C# 用Visual Studio，而JAVA用idea、Eclipse；跨平台Java用虚拟机，C#用Framework；Java所有平台都支持，而C#只有Windows和Linux支持。
 　　很多网友认为C#语言比Java更先进，如在泛型和linq上，这只能说C#编程体验好。Sun初衷是把Java设计成一个跨平台的Runtime，而Microsoft只是把.Net做成Windows的一个扩展。
 
2、目前市场上Java比C#占优势
 　　很多大公司选用Java，如京东，淘宝和百度，现状是在企业更通用，Java做Web类开发很强大，C#做窗体类开发更好。
 
3、安全性
 　　Java是开源的，因此在安全性能上是有一些欠缺的，C#经常应用于后台内部网络的开发，C#的安全性是很有保障的。
 
语法上区别：
 
  1.C#中的命名空间是namespace,类似于Java中的package（包）,在Java中导入包用import而c#中用using;

  2.c#和Java都是从main函数入口的，但是c#中的main函数的首字母必须大写,而且有4种写法;

  3.数据类型：Java跟c#基本都差不多,但是Java的String类型的首字母必须大写,而c#中可以小写也可以大写;还有布尔型,Java中是boolean,c#中是bool;
  
  4.输出：c#有三种方式输出：Cosole.WriteLine()、Cosole.WriteLine(要输出的值)、 Cosole.WriteLine("格式字符串"，变量列表); 前两种的用法
与Java中的System.out.println()方法的用法相同,第三种方式是根据占位符输出的,比Java更加方便;

  5.控制流语句：c#跟Java类似,还有c#中的switch如果case后面有内容必须要有break;Java可以没有break;

  6.方法中传递的参数：两种语言都使用值传递与引用传递,C#的引用传递的关键字是ref与out;ref侧重于修改,out侧重于输出,而Java中都以传值方式;

  7.访问修饰符：C#中的访问修饰符与Java中的基本对应,但多出了一个internal,简而言之,C#有5种类型的可访问性,如下所示:
	public：成员可以从任何代码访问
	protected：成员只能从派生类访问
	internal：成员只能从同一程序集的内部访问
	protected：成员只能从同一程序集内的派生类访问
	private：成员只能在当前类的内部访问

  8.由于C#中不存在final关键词,如果想要某个类不再被派生,你可以使用sealed关键词密封;

  9.集合：两种语言都有集合ArrayList,还有通过键访问值的 Java 中是HashMap而 c# 中是HashTable;c#比Java多泛型集合List<T>与Dictionary<K,V>
更容易了,无需拆箱装箱了,更安全;

  10.继承：Java中用关键字extends,c#只用"："就行了.调用父类的构造方法Java用super关键字,而c#用base关键字;
  
  11.多态：抽象类和抽象方法两种语言都用abstract关键字,Java中另外一个类如果继承了它,实现直接重写此方法就可以;而c#必须加上关键字override实现,
C#还比Java多一种虚方法来实现多态;

  12.接口：都用关键字interface定义,Java实现用关键字implements;c#用"："实现。在C#中,接口内的所有方法默认都是公用方法。在Java中,方法声明可以
带有public修饰符(即使这并非必要),但在C#中 显式为接口的方法指定public修饰符是非法的;

  13.C# 中的is操作符与Java中的instanceof操作符一样,两者都可以用来测试某个对象的实例是否属于特定的类型。在Java中没有与C#中的as操作符等价的
操作符,as操作符与is操作符非常相似,但它更富有"进取心"：如果类型正确的话,as操作符会尝试把被测试的对象引用转换成目标类型;否则它把变量引用设置成null。

最近自己闲着 自学了C# ，本人不是搞软件的 ，搞嵌入式的 ，经常要用串口调试工具来调试 ，有时候还要处理一些数据但是市面上的不能满足我的要求 ，正好一个项目需要学习C#,借此机会来开发一个串口  ，说不定对我也有用！
 
话不多说先看看成果！
 
 
串口调试工具 功能：
 
   通过串口设置设置相应的参数  ，串口检测  检测插上的串口号 ，发送与接收数据，HEX显示 ，定时发送，文件保存。
 
1.在vs2017 菜单栏点击 文件  -> 新建项目, 创建c#下的 windows窗体应用：
 
 
在窗体上添加四个  “GroupBox”控件 ，分别将窗体分为“串口设置”，“数据接收”，“数据发送”，”文件操作“。
 
添加若干个"Label”和"ComboBOX”   ，添加两个" RodioButton  " 给字符与HEX  选择，添加若干个 “Button” 
 
发送与接收 添加 TextBox 控件。
 
不说了上代码！
 
 
设置一下标志位与 Form1 初始化。
 
 
 
串口检测 界面初始化
 
 

  private void SetPortProperty () //  设置串口名
         {
             sp = new SerialPort();
             sp.PortName = cbxComPort.Text.Trim();                //设置串口名
             sp.BaudRate = Convert.ToInt32(cbxBaudRate.Text.Trim());  //设置串口波特率
             float f = Convert.ToSingle(cbxStopBits.Text.Trim());     //设置停止位
             if(f==0)
             {
                 sp.StopBits = StopBits.None;
             }
             else if(f==1)
             {
                 sp.StopBits = StopBits.One;
             }
             else if(f==1.5)
             {
                 sp.StopBits = StopBits.OnePointFive;
             }
             else if (f == 2)
             {
                 sp.StopBits = StopBits.Two;
             }
             else
             {
                 sp.StopBits = StopBits.One;
             }
 

             sp.DataBits = Convert.ToInt16(cbxDataBits.Text.Trim()); //设置数据位
 
            string s = cbxParity.Text.Trim();                //设置奇偶校验
             if (s.CompareTo("无") == 0)
             {
                 sp.Parity = Parity.None;
             }
             else if (s.CompareTo("奇校验") == 0)
             {
                 sp.Parity = Parity.Odd;
             }
             else if (s.CompareTo("偶校验") == 0)
             {
                 sp.Parity = Parity.Even;
             }
             else
             {
                 sp.Parity = Parity.None;
             }
 
            sp.ReadTimeout = -1;     //  设置超时读取时间
             sp.RtsEnable = true;
 
            // 定义Data Received 事件 ，  当串口收到数据后触发事件
             sp.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);
             if (rbnHex.Checked)
             {
                 isHex = true;
             }
             else
             {
                 isHex = false;
             }
 
           
 
        }
 
 
 
 
 
上面3图  发送 数据      清除数据   打开文件
 
 
发送文件
 
 
 
定时发送
 
需要完整代码  私信  。
 
上面代码都是自己写的如果那里有不足之处还请多多指教   ，如果觉得对你有帮助就关注一下。
 
下载链接 ： https://download.csdn.net/download/misslxy/12608949  解压密码私信

C#学习路线
 
导读
 
有的初学者对于如何开始学习C#感到无从下手，不知看哪些书，或者是看什么视频，没有目的性，这样就会影响学习效率，也会影响学习的热情。最重要的是很多同学学之前问很多和学习无关的问题，比如：C#是不是不如JAVA好？C#有前途吗？等等。博主认为现在观望还不如现在学习。本篇文章介绍了博主自己总结的C#学路线。如果大家有什么更好的想法或者好的建议可以共同探讨。
 　　有的同学对直接看书有比较强的吸收能力，我建议从《C#入门经典》开始学习，过度到《C#高级编程》和《深入理解C#》。学习C#前提是下载好Visual Studio，配合书上的代码进行动手练习，动手非常重要。
 　　Visual Studio 2017下载路径：https://visualstudio.microsoft.com/zh-hans/downloads/
 本篇文章剩余部分主要是介绍利用微软C#官方文档和网上资源学习。
 掌握C#基本语法
 　　1.C# 快速入门：https://docs.microsoft.com/zh-cn/dotnet/csharp/quick-starts/index
 此部分官方文档给初学者一些入门的认知，它可以直接在浏览器敲出代码，并且能够直观的显示出来。这部分包含了第一个"Hello World"程序，数字类型介绍，分支和循环，字符串类型处理，集合类型List的初探。
 　　2.C# 语言介绍(C#的基础知识)：https://docs.microsoft.com/zh-cn/dotnet/csharp/tour-of-csharp/index
 这部分官方文档介绍程序的基本结构，类型和变量，表达式，语句，类和对象，结构，数组，枚举等方面知识。把这一部分看完，大概会对C#有一定的认识，但是可能不明白的地方也有很多，不要急，只需要多看多敲代码，在后续学习的过程中，会一步一步把前面有问题的地方弄明白。
 　　3.C# 教程：https://docs.microsoft.com/zh-cn/dotnet/csharp/tutorials/index
 教程部分介绍了控制台的I/O，异步编程模型的基础知识，Web通信、JSON 序列化和面向对象的 C# 语言功能，以及LINQ查询的知识。
 　　4.C# 编程指南：https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/index
 这一部分是对第二部分的深入介绍，其中有很多相关的示例，也是学习C#基础知识比较重要的一部分。学习这部分前提是前面的内容已经学习完成(具有一定的C#编程知识)。
 学习完上面的部分，且动手敲完里面的例子，相信你对C#已经有一个不错的认识。这时候需要看进阶的知识来巩固学习成果。
 　　5.C# 演练：https://docs.microsoft.com/zh-cn/dotnet/csharp/walkthroughs
 这部分内容包含了C#更强大的功能，异步编程，设计Windows组件，Windows窗体的介绍，数据操作，和LINQ查询，编写可视化工具等。
 　　6.C# 中的新增功能：https://docs.microsoft.com/zh-cn/dotnet/csharp/whats-new/index
 介绍了C#的版本，和每次版本中的新增内容，有助于让我们更了解C#的进化史，从而更好的应用它。
 附带：
 C# 语言参考：https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/index
 C# 语言规范(英文版)：https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/language-specification/index
 C#进阶之路
 1.网上寻找编程练习题来带到练手的目的，并且巩固和学习新的C#知识，在这一过程中，一定要学会调试代码，可以提高学习的效率和查错速度。
 2.学习数据开发技术，与数据库的交互技术ADO.NET
 3.深入学习C#面向对象基础技能：封装，继承，多态的思想
 4.碎片时间可以用来看红 黑 联 盟的C#文章，简短的介绍，可以提高认识：https://www.2cto.com/kf/ware/cs/index.html
 项目实践
 　　自己动手编写一些小而精的项目，达到整体认识的效果，比如经典的"坦克大战"，“图书管理系统”，这些都是很"轻量级"的。当你把"坦克大战"项目编写完毕，就可以进行更大的项目设计，增加权限管理等等。
 .NET Core学习
 　　现在微软在极力推荐跨平台，.NET Core可以实现在多平台运行，是以后微软重要的方向。所以学习上面知识之后一定要了解.NET Core，跟上时代发展的步伐。