C#,CLR，IL，JIT概念 以及 .NET 家族
Monitor 类通过向单个线程授予对象锁来控制对对象的访问。对象锁提供限制访问代码块（通常称为临界区）的能⼒。当 ⼀个线程拥有对象的锁时，其他任何线程都不能获取该锁。还可以使⽤ Monitor 来确保不会允许其他任何线程访问正在由 锁的所有者执⾏的应⽤程序代码节，除⾮另⼀个线程正在使⽤其他的锁定对象执⾏该代码。
例：
Queue myQueue = new Queue();
Monitor.Enter(myQueue);
//可以在当前线程下对myQueue做任何操作。
Monitor.Exit(myQueue)//释放锁
为了保证在异常情况下仍可释放锁，Monitor.Exit()⽅法可以放在finally块⾥。调⽤Monitor.Pulse()⽅法会通知预备队列中的 线程可以⽴即使⽤释放的对象。
Mutex类是同步基元。当两个或更多线程需要同时访问⼀个共享资源时，系统需要使⽤同步机制来确保⼀次只有⼀个线程 使⽤该资源。
Mutex只向⼀个线程授予对共享资源的独占访问权。如果⼀个线程获取了互斥体，则要获取该互斥体的第⼆个线程将被挂 起，直到第⼀个线程释放该互斥体。已命名的系统互斥体（Mutex）在整个操作系统中都可见，可⽤于同步进程活动。
与Monitor类不同，Mutex可与WaitHandle⼀起构成“等待机制”，Mutex还可以穿越应⽤程序域。
例：
class Test
{
// Create a new Mutex. The creating thread does not own the
// Mutex.
private static Mutex mut = new Mutex();
private const int numIterations = 1;
private const int numThreads = 3;
static void Main()
{
// Create the threads that will use the protected resource.
for(int i = 0; i < numThreads; i++)
{
Thread myThread = new Thread(new ThreadStart(MyThreadProc));
myThread.Name = String.Format("Thread{0}", i + 1);
myThread.Start();
}
// The main thread exits, but the application continues to
// run until all foreground threads have exited.
}
private static void MyThreadProc()
{
for(int i = 0; i < numIterations; i++)
{
UseResource();
}
}
// This method represents a resource that must be synchronized
// so that only one thread at a time can enter.
private static void UseResource()
{
// Wait until it is safe to enter.
mut.WaitOne();
Console.WriteLine("{0} has entered the protected area",
Thread.CurrentThread.Name);
// Place code to access non-reentrant resources here.
// Simulate some work.
Thread.Sleep(500);
Console.WriteLine("{0} is leaving the protected area\r\n",
Thread.CurrentThread.Name);
// Release the Mutex.
mut.ReleaseMutex();
}
}
（八） C# 面向对象编程、继承、多态、接口、委托、事件
基本概念
⾯向对象编程（Object –Oriented Programming,OOP），抽象、继承和多态是OOP编程语⾔的三⼤要素。
继承：类继承的重要特性是，在希望出现基类型实例的任何地⽅，都可以替换成派⽣类型的实例。类似地，接口继承允许在希望出现已命名接口类型的实例的任何地⽅，都可以替换成实现接口的⼀个类型的实现。
多态：指的是多个类型的对象对同⼀消息做出各⾃的处理。多态是⼦类对⽗类的⽅法进⾏重写或替换⽽实现的。
接口：接口是⼀组已命名的⽅法签名，在接口内还可以定义事件和属性，它们在本质上也是⽅法。C# 要求接口⽅法标记为 Public。接口的关键价值在于隐藏类型的设计细节，即外部对象不依赖当前对象的内部细节。
接口特性
接口⽅法的隐式实现：当⽅法签名与继承的接口中的签名⼀致，并且是public或者是viture修饰的⽅法都视为隐式实现了接口⽅法。
例：
Internal sealed class SimpleType:IDisposable
{
Public void Dispose(){Console.WriteLine(“Dispose”);}
}
接口⽅法的显式实现：以接口类型名称作为⽅法前缀时，创建的是⼀个显式接口⽅法实现（explicit interface method implementation,EIMI）。⼀个EIMI⽅法不允许标记访问性（⽐如公共或私有），也不能被标记为virture，因⽽也不能被重 写。显⽰接口⽅法会损害性能，应当谨慎使⽤。
例：
Internal sealed class SimpleType:IDisposable
{
Public void Dispose(){….}
Void IDisposable.Dispose(){….}//显式
}
对显式接口的调⽤，需要通过⼀个接口类型的变量来进⾏。
例：
SimpleType st = new SimpleType();
IDisposable d = st;
d.Dispose();
泛型接口有如下优点：
1、使用接口方法变为强类型。
2、泛型接口在操作值类型时，会减少装箱操作。
3、类可以实现同一个接口若干次，只要使用不同的类型参数。
例：
Public sealed class Number:IComparable<Int32>,IComparable<String>
{
Private int32 m_val =5;
//实现IComparable<Int32>
Public Int32 CompareTo(Int32 n){return m_val.CompareTo(n);}
//实现IComparable<String>
Public Int32 CompareTo(String s){return m_val.CompareTo(Int32.Parse(s));}
}
委托
委托是.NET中的回调机制。将一个方法绑定到一个委托时，C#和CLR允许引用类型的协变（covariance）和反协变（contra-variance）。协变是指一个方法能返回一个从委托的返回类型派生出来的类型。反协变是指一个方法的参数类型可以是委托的参数类型的基类。但协变对于返回值类型或void的方法不适用。
例：
//MyCallback委托
Delegate object MyCallback(FileStream s);
//SomeMethod⽅法
String SomeMethod(Stream s);
上例中，SomeMethod的返回类型(String)继承⾃委托返回类型(Object)，这种协变是允许的。SomeMethod的参数类型
(Stream)是委托的参数类型(FileStream)的基类。这种反协变是允许的。
链式委托指的是⽤⼀个委托回调多个⽅法，即⼀系列委托对象组成的集合。Delegate的公共静态⽅法Combine⽤于添加⼀ 个委托到委托链，Remove⽅法⽤于从链中删除⼀个委托对象。在C#中内置的+=与-=操作符简化了这些操作。
例：
Internal delegate void Feedback(int32 value);
Feedback fb1 = new Feedback(….);
Feedback fb2 = new Feedback(….);
fbChain =(Feedback)Delegate.Combine(fbChain,fb1);
fbChain =(Feedback)Delegate.Combine(fbChain,fb2);
⼀组委托是按顺序执⾏的，如果他们带有返回值，只能得到最后⼀个委托的返回值，如果其间有委托⽅法出现致命错误，其它委托就⽆法执⾏。为了克服这些问题，产⽣了MulticastDelegate类，它的GetInvocationList⽅法⽤于显式调⽤链中的每 ⼀个委托，并使⽤符合⾃⼰需求的任何算法。MulticastDelegate类是特殊的类型，只能由系统派⽣，Delegate类已经具备了 MulticastDelegate的能⼒。
委托的便捷实现：
1. 不构造委托对象
例：
internal sealed class AClass
{
public static void CallbackWithoutNewingADelegateObject()
{
ThreadPool.QueueUserWorkItem(SomeAsyncTask,5);
}
private static void SomeAsyncTask(Object o)
{
Console.WriteLine(o);
}
}
上例中ThreadPool类的静态⽅法QueueUserWorkItem期望接收⼀个WaitCallback委托对象引⽤，该对象又包含⼀个 SomeAsyncTask⽅法引⽤。因为C#编译器能够⾃⼰进⾏推断，所以我们可以省略构造WaitCallback对象的代码。
2. 不定义回调⽅法
例：
internal sealed class AClass
{
public static void CallbackWithoutNewingADelegateObject()
{
ThreadPool.QueueUserWorkItem(delegate(Object obj){Console.WriteLine(obj);},5)
}
}
上例中⽤了⼀段代码块替代了回调⽅法名，编译器会⾃动在类中增加⼀个经过命名的基于此代码块的回调⽅法。
3. 不指定回调⽅法的参数
例：
button1.Click += delegate(Object sender,EventArgs e){MessageBox.Show(“The Button was clicked”);}
//由于上述⽅法中没有⽤到sender与e两个参数，可简写为：
button1.Click+=delegate{MessageBox.Show(“ The Button was clicked”);}
4. 不需要将局部变量⼈⼯封装到类中，即可传给⼀个回调⽅法
事件
事件：在.NET中事件（event）是类的成员，与成员属性和⽅法⼀样。类型的事件，是对外提供的⾃⾝状态的通知。外部类 型通过订阅的形式与事件的发布类型进⾏协作。将事件与处理⽅法关联起来的是委托。.NET中⽤event关键指定特定的委托 来为事件做出响应，这样做可以限制其它⽅法对委托的调⽤(在内部定义委托为私有的，通过event公开，因此外部⽆法访 问委托中的⽅法)。
设计线程安全的事件，必须显⽰地控制事件的订阅与注销。
例：
internal class MailManager
{
//创建⼀个作为线程同步锁的私有实例字段
private readonly Object m_eventLock = new Object();
//增加⼀个引⽤ 委托链表头部的私有字段
private EventHadler<NewMailEventArgs> m_NewMail;
//增加⼀个事件成员
public event EventHandler<NewMailEventArgs> NewMail
{
//显式实现add
add
{
//加私有锁，并向委托链表增加⼀个处理程序以‘value’为参数
lock(m_eventLock){m_NewMail+=value;}
}
//显式实现remove
remove
{
//加私有锁，并向委托链表移除⼀个处理程序以‘value’为参数
lock(m_eventLock){m_NewMail -= value;}
}
}
//定义⼀个负责引发事件的⽅法，来通知已订阅事件的对象事件已经发⽣，如果类是封装的
//则需要将⽅法声明为private和non-virtual
proteted virtual void OnNewMail(NewMailEventArgs e)
{
//出于线程安全考虑，将委托字段保存到⼀个临时字段中
EventHadler<NewMailEventArgs> temp = m_NewMail;
if(temp!=null){temp(this,e);}
}
//将输⼊转化为希望的事件
public void SimulateNewMail(String from,String to,String subject)
{
//构建⼀个对象存放给事件接收者的信息
NewMailEventArgs e = new NewMailEventArgs(from,to,subject);
//引发
OnNewMail(e);
}
}
委托与事件
关键字“event”是个修饰词，在绝⼤多数的情形中，被指定为委托（delegate）的对象和被指定为事件（event）的对象是可以互换的。然⽽，事件还有特殊之处：
● 事件就像⼀个委托类型的字段。该字段引⽤了⼀个代表事件处理器的委托，这些处理器是被添加到事件上的；
● 事件只能在声明它的类中被调⽤，⽽所有能见到委托的地⽅都可以使⽤委托；
● 事件可以被包含在接口中⽽委托不可以；
● 事件有可被重写的Add和Remove存取(acccessor)⽅法；
（九）、Linq表达式、异步处理
LINQ
语言集成查询 (LINQ) 是一系列直接将查询功能集成到 C# 语言的技术统称，比如涵盖：SQL 数据库查询、XML 文档查询、List对象查询、Array对象查询、String对象查询……。 借助 LINQ，查询成为了最高级的语言构造，就像类、方法和事件一样。
示例：
class LINQQueryExpressions
{
static void Main()
{
// Specify the data source.
int[] scores = new int[] { 97, 92, 81, 60 };
// Define the query expression.
IEnumerable<int> scoreQuery =
from score in scores
where score > 80
select score;
// Execute the query.
foreach (int i in scoreQuery)
{
Console.Write(i + " ");
}
}
}
// Output: 97 92 81
更详细的Linq用法请参考:
异步处理
异步是 .NET 中充分使用处理器核心资源的机制，异步机制直接处理多个核心上的阻塞 I/O 和并发操作以提高系统执行效率。
.NET 异步的特点：
1、等待 I/O 请求返回的同时，可通过生成处理更多请求的线程，处理更多的服务器请求。
2、等待 I/O 请求的同时生成 UI 交互线程，并通过将长时间运行的工作转换到其他 CPU 核心，让 UI 的响应速度更快。
使用基于 .NET 任务的异步模型可直接编写绑定 I/O 和 CPU 的异步代码。 该模型由 Task 和 Task<T> 类型以及 C# 和 Visual Basic 中的 async 和 await 关键字公开。 （有关特定语言的资源，请参见另请参阅部分。）
Task是用于实现称之为并发 Promise 模型的构造。 简单地说，它们“承诺”，会在稍后完成工作。
Task 表示不返回值的单个操作。
Task<T> 表示返回 T 类型的值的单个操作。
Task在当前线程上执行，且在适当时会将工作委托给操作系统。 可选择性地通过 Task.Run API 显式请求任务在独立线程上运行。
示例：
//定义一个基于Task的异步方法
public Task<string> GetHtmlAsync()
{
// Execution is synchronous here
var client = new HttpClient();
return client.GetStringAsync("
https://www.dotnetfoundation.org");
}
//第二个异步方法
public async Task<string> GetFirstCharactersCountAsync(string url, int count)
{
// Execution is synchronous here
var client = new HttpClient();
// Execution of GetFirstCharactersCountAsync() is yielded to the caller here
// GetStringAsync returns a Task<string>, which is *awaited*
var page = await client.GetStringAsync(url);
// Execution resumes when the client.GetStringAsync task completes,
// becoming synchronous again.
if (count > page.Length)
{
return page;
}
else
{
return page.Substring(0, count);
}
}
//调用示例
var str = await GetHtmlAsync();
var str2 = await GetFirstCharactersCountAsync("https://www.dotnetfoundation.org",100);
更深入地了解 .NET 上的异步编程
三、.NET 上的 Web 开发: ASP.NET Core
.NET上的Web解决方案由ASP.NET Core 框架实现，某种程度上你可以将之理解为Java界的Spring MVC。ASP.NET 是经典.NET上的Web解决方案，我们建议新的Web应用应该选择ASP.NET Core。
当前Web开发存在两种主要的风格：MVC，Web API。MVC指的是模型--视图--控制器的Web程序设计模式，而Web API指的是面向RESTful API场景的Web程序设计模式，它仅提供API调用的响应而不关心视图。
ASP.NET Core
ASP.NET Core MVC 框架由如下基本组件构成：
路由
模型绑定
模型验证
依赖关系注入
筛选器
区域
Web API
Razor 视图引擎
强类型视图
标记帮助程序
视图组件
控制器：ASP.NET Core MVC 的Web请求入口是由Controller类型或其子类型的公共方法实现的，一般情况下每个请求入口都是一部分业务逻辑代码的聚合。
例：
public class DefaultController : ControllerBase
{
public ActionResult<string> Index()
{
return "hello,world";
}
}
路由：ASP.NET Core MVC 建立在 ASP.NET CORE 的路由之上，是一个功能强大的 URL 映射组件，可用于生成具有易于理解和可搜索 URL 的应用程序。 它可让你定义适用于搜索引擎优化 (SEO) 和链接生成的应用程序 URL 命名模式，而不考虑如何组织 Web 服务器上的文件。 可以使用支持路由值约束、默认值和可选值的方便路由模板语法来定义路由。
例：
routes.MapRoute(name: "Default", template: "{controller=Home}/{action=Index}/{id?}");
模型：ASP.NET Core MVC 模型绑定将客户端请求数据（窗体值、路由数据、查询字符串参数、HTTP 头）转换到控制器可以处理的对象中。 因此，控制器逻辑不必找出传入的请求数据；它只需具备作为其操作方法的参数的数据。
例：
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null) { ... }
模型验证：ASP.NET Core MVC 通过使用数据注释验证属性修饰模型对象来支持验证。 验证属性在值发布到服务器前在客户端上进行检查，并在调用控制器操作前在服务器上进行检查。
例：
using System.ComponentModel.DataAnnotations;
public class LoginViewModel
{
[Required]
[EmailAddress]
public string Email { get; set; }
[Required]
[DataType(DataType.Password)]
public string Password { get; set; }
[Display(Name = "Remember me?")]
public bool RememberMe { get; set; }
}
Razor视图引擎: Razor 是一种紧凑、富有表现力且流畅的模板标记语言，用于使用嵌入式 C# 代码定义视图。 Razor 用于在服务器上动态生成 Web 内容。 可以完全混合服务器代码与客户端内容和代码。我们可以在MVC工程中，往Controller添加请求入口的View文件，这些View文件代表视图文件(.cshtml)，这些文件默认使用Razor视图引擎来实现服务端渲染视图。
例：
Index.cshtml:
<!-- 单行代码块 -->
@{ var myMessage = "Hello World"; }
<!-- 行内表达式或变量 -->
<p>The value of myMessage is: @myMessage</p>
<!-- 多行代码块 -->
@{
var greeting = "Welcome to our site!";
var weekDay = DateTime.Now.DayOfWeek;
var greetingMessage = greeting + " Today is: " + weekDay;
}
<p>The greeting is: @greetingMessage</p>
更深入的 Razor 介绍
http://www.w3school.com.cn/aspnet/razor_intro.asp
Web API: ASP.NET Core 支持使用 C# 创建 RESTful 服务，也称为 Web API。 Web API 使用控制器响应这些请求，Web API 中的控制器是派生自 ControllerBase 的类。
例：
[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
public ActionResult<Pet> Create(Pet pet)
{
pet.Id = _petsInMemoryStore.Any() ? _petsInMemoryStore.Max(p => p.Id) + 1 : 1;
_petsInMemoryStore.Add(pet);
return CreatedAtAction(nameof(GetById),
new { id = pet.Id }, pet);
}
}
SignalR: ASP.NET Core SignalR 是一个开源代码库，它简化了向应用添加实时 Web 功能的过程。 实时 Web 功能使服务器端代码能够即时将内容推送到客户端。
SignalR 的适用对象：需要来自服务器的高频率更新的应用。
例如：
游戏、社交网络、投票、拍卖、地图和 GPS 应用；
仪表板和监视应用；
协作应用，例如白板应用和团队会议软件；
需要通知的应用， 社交网络、电子邮件、聊天、游戏、行程警示以及许多其他应用都使用通知；
SignalR 提供了一个用于创建服务器到客户端远程过程调用（RPC）的 API。 RPC 通过服务器端 .NET Core 代码调用客户端上的 JavaScript 函数。
以下是 ASP.NET Core SignalR 的一些功能：
1、自动管理连接。
2、向所有连接的客户端广播消息。 例如，聊天室。
3、将消息发送到特定的客户端或客户端组。
4、扩展以处理增加的流量。
更深入的了解.NET上的Web开发：
https://docs.microsoft.com/zh-cn/aspnet/core/?view=aspnetcore-2.2
四、.NET 上的ORM
EF6 & EF Core
EntityFramework 6.x (EF6) 是经典 .NET上的 ORM 框架，它功能全面在Windows上运行稳定。
EntityFramework Core (EF Core) 是 EntityFramework 的跨平台移植版本，目前功能上与 EF6 仍有差距，可以满足绝大部分 CRUD 操作。
下图是 EF6 与 EF Core 在数据库支持上的对比：
其它ORM
dapper 是Stack Overflow贡献的轻量级 ORM 框架，兼容.NET Core 和 .NET 4.5x，它直接扩展了.NET Connection 对象。
SmartSql 是一个包括ORM及延伸功能的数据、缓存读写与配置框架。
以上介绍的主要的ORM工具都可以在Github上找到其官方主页。
五、.NET 微服务和容器化
.NET Core 是最早响应微服务与容器化部署的技术平台。.NET 团队在Docker Hub 官网上维护着所有主要的 .NET Core 版本的 Docker 镜像。
你可以在这个链接上找到这些镜像： https://hub.docker.com/_/microsoft-dotnet-core
值得一提的是，.NET Core 在 Docker 上的性能表现超过了大部分其他同类技术平台。例如使用 Raygun 工具测试相同 Linux 环境的上运行的 Node.js 与 .NET Core 的性能对比，.NET Core 的性能是 Node.js 的2000%。
.NET Core 是天生为云计算优化的技术平台，有着优良的可伸缩性，并兼容主流的云计算平台，比如 Azure、AWS、阿里云。
上图是 .NET Core 上实现的微服务与 docker 容器部署的典型架构示例
关于如何设计、发布 .NET Core 的微服务到 Docker 镜像，可以下载这个官方中文说明书：
https://dotnet.microsoft.com/download/thank-you/microservices-architecture-ebook-zh-cn
六、.NET平台与Java平台的互换性
| .NET | Java | |
| 包管理 |
nuget | Maven |
| Web场景开发 |
ASP.NET
ASP.NET Core
|
Spring Boot |
| ORM |
EntityFramework 6.x
EntityFramework Core
dapper
NHibernate
SmartSql
|
Hibernate
Mybatis
|
| 单元测试 |
MSUnit
XUnit.net
|
JUnit |
| Android/ios 开发 | Xamarin |
Android SDK
RoboVM
|
| Windows 开发 |
.NET Framework 4.x
.NET Core 3.0+
Mono |
Oracle JDK
Open JDK (free)
|
| Mac OS 开发 |
Mono
Xamarin/.NET Core
|
Oracle JDK
Open JDK(free)
|
| linux开发 |
Mono
.NET Core
|
Oracle JDK
Open JDK(free)
|
| docker支持 |
.NET Core
ASP.NET Core
Mono
|
Oracle JDK
Open JDK(free)
|
| AI/数据分析 |
ML.net
ONNX Runtime Microsoft Cognitive Toolkit(CNTK)
tensorflow.net
.NET for Apache Spark
|
Eclipse Deeplearning4j
Apache OpenNLP
Java-ML
Spark
Flink
Kafka
Storm
|
| 游戏开发 |
Unity (C#语言)
MonoGame
CRYENGINE
|
|
| IoT | .NET Core | Open IoT Stack for Java |
以上关于 .NET 平台及 Java 平台的比较信息来源于一小部分有代表性的技术栈，仅供参考。
关于 .NET 平台更多的生态内容可以参考这个链接：
https://github.com/thangchung/awesome-dotnet-core
感谢 .NET 社群中的朋友帮忙审校。
参考链接：