public IWebHost Build()
    {
      if (this._webHostBuilt)
        throw new InvalidOperationException(Resources.WebHostBuilder_SingleInstance);
      this._webHostBuilt = true;
      AggregateException hostingStartupErrors;
      IServiceCollection serviceCollection1 = this.BuildCommonServices(out hostingStartupErrors);
      IServiceCollection serviceCollection2 = serviceCollection1.Clone();
      IServiceProvider providerFromFactory = GetProviderFromFactory(serviceCollection1);
      .....

　　　　WebHost webHost = new WebHost(serviceCollection2, providerFromFactory, this._options, this._config, hostingStartupErrors);
      try
      {
        webHost.Initialize();
        return (IWebHost) webHost;
      }
      catch
      {
        webHost.Dispose();
        throw;
      }

    IServiceProvider GetProviderFromFactory(IServiceCollection collection)
      {
        ServiceProvider serviceProvider = collection.BuildServiceProvider();
        IServiceProviderFactory<IServiceCollection> service = ((IServiceProvider) serviceProvider).GetService<IServiceProviderFactory<IServiceCollection>>();
        if (service == null)
          return (IServiceProvider) serviceProvider;
        using (serviceProvider)
          return service.CreateServiceProvider(service.CreateBuilder(collection));
      }
    }

private IServiceCollection BuildCommonServices(
      out AggregateException hostingStartupErrors)
    {
        .....
　　　　　ServiceCollection services = new ServiceCollection();

        services.AddTransient<IApplicationBuilderFactory, ApplicationBuilderFactory>();
        services.AddTransient<IHttpContextFactory, HttpContextFactory>();
        services.AddScoped<IMiddlewareFactory, MiddlewareFactory>();
        services.AddOptions();
        services.AddLogging();
        services.AddTransient<IStartupFilter, AutoRequestServicesStartupFilter>();
        services.AddTransient<IServiceProviderFactory<IServiceCollection>, DefaultServiceProviderFactory>();

　　　　.....

      foreach (Action<WebHostBuilderContext, IServiceCollection> servicesDelegate in this._configureServicesDelegates)
        servicesDelegate(this._context, (IServiceCollection) services);
      return (IServiceCollection) services;
    }

WebHost webHost = new WebHost(serviceCollection2, providerFromFactory, this._options, this._config, hostingStartupErrors);

webHost.Initialize();　　

　　public void Initialize()
    {
      try
      {
        this.EnsureApplicationServices();
      }
      catch (Exception ex)
      {
        if (this._applicationServices == null)
          this._applicationServices = (IServiceProvider) this._applicationServiceCollection.BuildServiceProvider();
        if (!this._options.CaptureStartupErrors)
          throw;
        else
          this._applicationServicesException = ExceptionDispatchInfo.Capture(ex);
      }
    }

　　private void EnsureApplicationServices()
    {
      if (this._applicationServices != null)
        return;
      this.EnsureStartup();
      this._applicationServices = this._startup.ConfigureServices(this._applicationServiceCollection);
    }

    private void EnsureStartup()
    {
      if (this._startup != null)
        return;
      this._startup = this._hostingServiceProvider.GetService<IStartup>();
      if (this._startup == null)
        throw new InvalidOperationException(string.Format("No startup configured. Please specify startup via WebHostBuilder.UseStartup, WebHostBuilder.Configure, injecting {0} or specifying the startup assembly via {1} in the web host configuration.", (object) "IStartup", (object) "StartupAssemblyKey"));
    }

　　public virtual async Task StartAsync(CancellationToken cancellationToken = default (CancellationToken))
    {
      HostingEventSource.Log.HostStart();
      this._logger = this._applicationServices.GetRequiredService<ILogger<WebHost>>();
      this._logger.Starting();
      RequestDelegate application = this.BuildApplication();
      this._applicationLifetime = this._applicationServices.GetRequiredService<Microsoft.AspNetCore.Hosting.IApplicationLifetime>() as ApplicationLifetime;
      this._hostedServiceExecutor = this._applicationServices.GetRequiredService<HostedServiceExecutor>();
      DiagnosticListener requiredService1 = this._applicationServices.GetRequiredService<DiagnosticListener>();
      IHttpContextFactory requiredService2 = this._applicationServices.GetRequiredService<IHttpContextFactory>();
      ILogger<WebHost> logger = this._logger;
      DiagnosticListener diagnosticSource = requiredService1;
      IHttpContextFactory httpContextFactory = requiredService2;
      await this.Server.StartAsync<HostingApplication.Context>((IHttpApplication<HostingApplication.Context>) new HostingApplication(application, (ILogger) logger, diagnosticSource, httpContextFactory), cancellationToken).ConfigureAwait(false);
      this._applicationLifetime?.NotifyStarted();
      await this._hostedServiceExecutor.StartAsync(cancellationToken).ConfigureAwait(false);
     .....
    }

　　private RequestDelegate BuildApplication()
    {
        this._applicationServicesException?.Throw();
        this.EnsureServer();
        IApplicationBuilder builder = this._applicationServices.GetRequiredService<IApplicationBuilderFactory>().CreateBuilder(this.Server.Features);
        builder.ApplicationServices = this._applicationServices;
        IEnumerable<IStartupFilter> service = this._applicationServices.GetService<IEnumerable<IStartupFilter>>();
        Action<IApplicationBuilder> next = new Action<IApplicationBuilder>(this._startup.Configure);
        foreach (IStartupFilter startupFilter in service.Reverse<IStartupFilter>())
          next = startupFilter.Configure(next);
        next(builder);
        return builder.Build();
      }

　　private void EnsureServer()
    {
      if (this.Server != null)
        return;
      this.Server = this._applicationServices.GetRequiredService<IServer>();
      IServerAddressesFeature addressesFeature = this.Server.Features?.Get<IServerAddressesFeature>();
      ICollection<string> addresses = addressesFeature?.Addresses;
      if (addresses == null || addresses.IsReadOnly || addresses.Count != 0)
        return;
      string str1 = this._config[WebHostDefaults.ServerUrlsKey] ?? this._config[WebHost.DeprecatedServerUrlsKey];
      if (string.IsNullOrEmpty(str1))
        return;
      addressesFeature.PreferHostingUrls = WebHostUtilities.ParseBool(this._config, WebHostDefaults.PreferHostingUrlsKey);
      string str2 = str1;
      char[] separator = new char[1]{ '';'' };
      foreach (string str3 in str2.Split(separator, StringSplitOptions.RemoveEmptyEntries))
        addresses.Add(str3);
    }

public interface IServer : IDisposable
{
    IFeatureCollection Features { get; }

    Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken);

    Task StopAsync(CancellationToken cancellationToken);
}

public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder)
{
    hostBuilder.UseLibuv();

    return hostBuilder.ConfigureServices(services =>
    {
        services.AddTransient<IConfigureOptions<KestrelServerOptions>, KestrelServerOptionsSetup>();
        services.AddSingleton<IServer, KestrelServer>();
    });
}

public RequestDelegate Build()
    {
      RequestDelegate requestDelegate = (RequestDelegate) (context =>
      {
        context.Response.StatusCode = 404;
        return Task.CompletedTask;
      });
      foreach (Func<RequestDelegate, RequestDelegate> func in this._components.Reverse<Func<RequestDelegate, RequestDelegate>>())
        requestDelegate = func(requestDelegate);
      return requestDelegate;
    }

public interface IHttpApplication<TContext>
{
    TContext CreateContext(IFeatureCollection contextFeatures);

    Task ProcessRequestAsync(TContext context);

    void DisposeContext(TContext context, Exception exception);
}

public class HostingApplication : IHttpApplication<HostingApplication.Context>
  {
    private readonly RequestDelegate _application;
    private readonly IHttpContextFactory _httpContextFactory;public Task ProcessRequestAsync(HostingApplication.Context context)
    {
      return this._application(context.HttpContext);
    }
　　......
}

public async Task StartAsync<TContext>(
      IHttpApplication<TContext> application,
      CancellationToken cancellationToken)
    {
      try
      {
        if (!BitConverter.IsLittleEndian)
          throw new PlatformNotSupportedException(CoreStrings.BigEndianNotSupported);
        this.ValidateOptions();
        if (this._hasStarted)
          throw new InvalidOperationException(CoreStrings.ServerAlreadyStarted);
        this._hasStarted = true;
        this._heartbeat.Start();
        await AddressBinder.BindAsync(this._serverAddresses, this.Options, (ILogger) this.Trace, new Func<ListenOptions, Task>(OnBind)).ConfigureAwait(false);
      }
      catch (Exception ex)
      {
        this.Trace.LogCritical((EventId) 0, ex, "Unable to start Kestrel.");
        this.Dispose();
        throw;
      }

      async Task OnBind(ListenOptions endpoint)
      {
        endpoint.UseHttpServer<TContext>((IList<IConnectionAdapter>) endpoint.ConnectionAdapters, this.ServiceContext, application, endpoint.Protocols);
        ConnectionDelegate connectionDelegate = endpoint.Build();
        if (this.Options.Limits.MaxConcurrentConnections.HasValue)
          connectionDelegate = new ConnectionDelegate(new ConnectionLimitMiddleware(connectionDelegate, this.Options.Limits.MaxConcurrentConnections.Value, this.Trace).OnConnectionAsync);
        ConnectionDispatcher connectionDispatcher = new ConnectionDispatcher(this.ServiceContext, connectionDelegate);
        ITransport transport = this._transportFactory.Create((IEndPointInformation) endpoint, (IConnectionDispatcher) connectionDispatcher);
        this._transports.Add(transport);
        await transport.BindAsync().ConfigureAwait(false);
      }
    }

public class HostedServiceExecutor
  {
    private readonly IEnumerable<IHostedService> _services;public async Task StartAsync(CancellationToken token)
    {
　　　　await this.ExecuteAsync((Func<IHostedService, Task>) (service => service.StartAsync(token)));      
    }

    public async Task StopAsync(CancellationToken token)
    {
　　　　await this.ExecuteAsync((Func<IHostedService, Task>) (service => service.StopAsync(token)));      
    }

    private async Task ExecuteAsync(Func<IHostedService, Task> callback)
    {
      List<Exception> exceptions = (List<Exception>) null;
      foreach (IHostedService service in this._services)
      {
        try
        {
          await callback(service);
        }
        catch (Exception ex)
        {
          if (exceptions == null)
            exceptions = new List<Exception>();
          exceptions.Add(ex);
        }
      }
      if (exceptions != null)
        throw new AggregateException((IEnumerable<Exception>) exceptions);
    }
  }

int i=3;
obect obj=i;//装箱
int k=(int)obj;//拆箱

public class MyTest
{
    private int x;
    public MyTest(int n)
    {
        this.x=n;
    }
}

MyTest t=new MyTest(3);//引用类型

public struct ValuePoint// : System.ValueType  结构不能有父类，因为隐式继承了ValueType
 {
     public int x;
     public ValuePoint(int x)
     {
         this.x = x;
         this.Text = "1234";
     }

     public string Text;//堆还是栈？
 }

string student = "bingle1";
string student2 = student;

Console.WriteLine(student);//bingle1
Console.WriteLine(student2);//bingle1

student2 = "bingle2";//=new string(APP);
Console.WriteLine(student);//bingle1
Console.WriteLine(student2);//bingle2
Console.ReadLine();

string student = "bingle1";
string student2 = "bingle2";//共享
student2 = "bingle1";

Console.WriteLine(object.ReferenceEquals(student, student2));//true

student2 = "binglebingle";//等于重新开辟一块内存叫“binglebingle”  new String("binglebingle")
Console.WriteLine(student);//bingle1

string student3 = string.Format("bing{0}", "le");
Console.WriteLine(object.ReferenceEquals(student, student3));//false

string student4 = "bing" + "le";
 Console.WriteLine(object.ReferenceEquals(student, student4));//true
 //true  编译器优化了，直接就是bingle

string halfStudent = "le";
string student5= "bing" + halfStudent;
Console.WriteLine(object.ReferenceEquals(student, student5));
//false 也是先内存，再计算

public class StandardDispose : IDisposable
 {
     //演示创建一个非托管资源
     private string _UnmanageResource = "未被托管的资源";
     //演示创建一个托管资源
     private string _ManageResource = "托管的资源";


     private bool _disposed = false;

     /// <summary>
     /// 实现IDisposable中的Dispose方法
     /// </summary>
     public void Dispose()
     {
         this.Dispose(true); //必须为true
         GC.SuppressFinalize(this);//通知垃圾回收机制不再调用终结器（析构器）
     }

     /// <summary>
     /// 不是必要的，提供一个Close方法仅仅是为了更符合其他语言（如C++）的规范
     /// </summary>
     public void Close()
     {
         this.Dispose();
     }

     /// <summary>
     /// 必须，以备程序员忘记了显式调用Dispose方法
     /// </summary>
     ~StandardDispose()
     {
         //必须为false
         this.Dispose(false);
     }

     /// <summary>
     /// 非密封类修饰用protected virtual
     /// 密封类修饰用private
     /// </summary>
     /// <param name="disposing"></param>
     protected virtual void Dispose(bool disposing)
     {
         if (this._disposed)//已经被释放的还可以不异常
         {
             return;
         }
         if (disposing)
         {
             // 清理托管资源
             if (this._ManageResource != null)
             {
                 //Dispose
                 this._ManageResource = null;
             }
         }
         // 清理非托管资源
         if (this._UnmanageResource != null)
         {
             //Dispose  conn.Dispose()
             this._UnmanageResource = null;
         }
         //让类型知道自己已经被释放
         this._disposed = true;
     }

     public void PublicMethod()
     {
         if (this._disposed)
         {
             throw new ObjectDisposedException("StandardDispose", "StandardDispose is disposed");
         }
         //
     }