一切福田，不離方寸，從心而覓，感無不通。

Category Archives: Asp.Net Core

基于IdentityServer4 实现.NET Core的认证授权

目录 IdentityServer4是什么？ OpenID Connect 和 OAuth2.0是什么 Authentication 和 Authorization的区别 OAuth2.0的原理 IdentityServer4能做什么 IdentityServer4定义的基本术语 IdentityServer4的简单示例 IdentityServer4是什么？ IdentityServer4是基于ASP.NET Core实现的认证和授权框架，是对OpenID Connect和OAuth 2.0协议的实现。 OpenID Connect 和 OAuth2.0是什么 OpenID Connect: OpenID Connect由OpenID基金会于2014年发布的一个开放标准, 是建立在OAuth 2.0协议上的一个简单的身份标识层, OpenID Connect 兼容 OAuth 2.0. 实现身份认证（Authentication） 参考资料：https://openid.net/connect/ OpenID Connect文档：https://openid.net/specs/openid-connect-discovery-1_0.html OAuth2.0: OAuth2.0是一个开放的工业标准的授权协议（Authorization），它允许用户授权让第三方应用直接访问用户在某一个服务中的特定资源，但不提供给第三方账号及密码信息 参考资料：https://www.cnblogs.com/xiandnc/p/9763121.html OAuth2.0 文档：https://tools.ietf.org/html/rfc6749#page-73 Authentication 和 Authorization的区别 1 2 authentication: n. 证明；鉴定；证实 authorization: n. 授权，认可；批准，委任 前者是身份识别，鉴别你是谁；后者是授权许可，告诉你可以做什么。 举个例子：你吭哧吭哧写了一天的代码，急于回家吃上一口媳妇做的热饭。当你走到小区门口的时候你需要刷小区的门禁卡才能进入到小区里面，然后再找到你家在哪一栋楼，几单元几号，然后掏出钥匙开门才能回到家。在这个过程中刷小区的门禁就是认证你是这个小区的人，拿你家的钥匙开门就是授权的过程，如果你的认证不通过，那就不存在授权。 OAuth2.0的原理 我们先来了解一下OAuth2.0中的几个关键概念： 资源所有者（Resource Owner）： 一个能够访问受保护资源的实体。当资源所有者是一个人时，它被称为终端用户 资源服务器（Resource Server）： 托管受保护资源的服务器，能够使用访问令牌接受和响应受保护的资源请求 客户端（Client）： 代表资源所有者和其授权的应用程序来保护资源请求。术语客户端并不意味着任何特定的实现特征（例如，应用程序是否在服务器、桌面或其他设备上执行） 授权服务器（Authorization Server）： 在成功验证资源所有者并获得授权之后，服务器向客户端发出访问令牌。（授权服务器是用来管理Resource Owner，Resource Server，Client的中间人） 场景：小李想要打印（美图快印）自己三年来发布在新浪微博相册中和女朋友的照片，有没有什么方法他既不告诉工作人员自己的新浪微博用账号和密码又能够方便快捷的把照片给到美图快印呢？（排除存U盘这种手工操作）   Authorization Server和Resource Server可以使独立的服务提供商，也可以是在一起的，比如例子中新浪微博既作授权服务器也用来存储用户的图片资源。我们可以看到OAuth2解决的问题是：通过Authorization Server可以提供一个访问的凭据（token）给client（美图快印的工作人员），使得client可以在不知道Resource Owner以及Resource Server的用户名和密码的情况下访问到Resource Owner受保护的资源，它是一个完美的中间人。 OAuth2.0详细内容请参考：https://www.cnblogs.com/xiandnc/p/9763121.html IdentityServer4能做什么 用户认证服务 基于OpenID Connect实现的独立的认证服务实现对多平台（web, native, mobile, services）的集中认证 API访问授权 […]

龙生   07 Nov 2019
View Details

在ASP.NET Core中使用百度在线编辑器UEditor

0x00 起因 最近需要一个在线编辑器，之前听人说过百度的UEditor不错，去官网下了一个。不过服务端只有ASP.NET版的，如果是为了能尽快使用，只要把ASP.NET版的服务端作为应用部署在IIS上就可以立即使用了。不过我的需求并不急，所以把ASP.NET移植到了ASP.NET Core上。整个过程很简单，只是重新引用了一些包，修改了几处代码，另外就是把Controller中比较长的一个switch语句块重构为了字典，根据url中的action参数从字典中找出并调用相应的Action处理，这样的好处就是如果要扩展action支持的操作无需修改源代码，只要扩展字典就可以，对扩展开放，对修改关闭。最后把服务端功能打成了nuget包UEditorNetCore，方便使用。这篇博客主要就介绍下如何使用UEditorNetCore快速实现UEditor服务端，也可以直接使用源代码中的示例，希望对有这方面需求的园友有所帮助。 0x01 总体设计   当接收到action后，UEditorService会从UEditorActionCollection中找到这个action对应的方法并调用，同时传入HttpContext参数。这些方法调用基层的服务XxxxHandler完成功能，并把返回内容通过HttpContext.Response.WriteAsync()方法写入。如果要扩展对action的支持，可以扩展UEditorActionCollection，具体方法后面有介绍。 0x02 如何使用UEditorNetCore 1.安装UEditorNetCore

1
Install-Package UEditorNetCore

2.在Startup.cs的ConfigureServices方法中添加UEditorNetCore服务

1
2
3
4
5
6
7
public void ConfigureServices(IServiceCollection services)
{
　　//第一个参数为配置文件路径，默认为项目目录下config.json
　　//第二个参数为是否缓存配置文件，默认false
　　services.AddUEditorService()
　　services.AddMvc();
}

3.添加Controller用于处理来自UEditor的请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[Route("api/[controller]")] //配置路由
public class UEditorController : Controller
{
    private UEditorService ue;
    public UEditorController(UEditorService ue)
    {
        this.ue = ue;
    }
 
    public void Do()
    {
        ue.DoAction(HttpContext);
    }
}

4.修改前端配置文件ueditor.config.js serverUrl需要参照第3步Controller中配置的路由，按照上面步骤3中的配置，需要以下配置：

1
serverUrl:"/api/UEditor"

这样配置后当前端要获取服务端UEditor配置时就会访问/api/UEditor?action=config。 5.修改服务端配置config.json 上传类的操作需要配置相应的PathFormat和Prefix。示例部署在web根目录，因此Prefix都设置为"/"。使用时要根据具体情况配置。 例如示例中图片上传的配置如下：

1
2
"imageUrlPrefix": "/", /* 图片访问路径前缀 */
"imagePathFormat": "upload/image/{yyyy}{mm}{dd}/{time}{rand:6}",

关于PathFormat的详细配置可参照官方文档。 6.添加javascript引用

1
2
3
<script type="text/javascript" charset="utf-8" src="~/lib/ueditor/ueditor.config.js"></script>
<script type="text/javascript" charset="utf-8" src="~/lib/ueditor/ueditor.all.min.js"> </script>
<script type="text/javascript" charset="utf-8" src="~/lib/ueditor/lang/zh-cn/zh-cn.js"></script>

0x03 扩展action UEditor前端和后端交互主要通过在url中给出不同的action参数实现的，例如/api/UEditor?action=config会从服务端获取UEditor配置信息。UEditorNetCore目前支持的有8种action： config 获取服务端配置信息 uploadimage 上传图片 uploadscrawl 上传涂鸦 uploadvideo 上传视频 uploadfile 上传文件 listimage 多图片上传 listfile 多文件上传 catchimage 抓取图片 如果以上action无法满足需求，可以方便的增加、覆盖、移除action。 增加action

1
2
3
4
5
6
7
8
9
10
11
12
13
public void ConfigureServices(IServiceCollection services)
{
    services.AddUEditorService()
        .Add("test", context =>
        {
            context.Response.WriteAsync("from test action");
        })
        .Add("test2", context =>
        {
            context.Response.WriteAsync("from test2 action");
        });
    services.AddMvc();
}

以上代码增加了名字为test和test2两个action，作为示例仅仅返回了字符串。当访问/api/UEditor?action=test时会返回"from test action"。在扩展action时可以使用Config获取服务端配置，也可以使用已有的Handlers，具体可以参考源代码。 覆盖现有action 上面的Add方法除了添加新action外还可以覆盖现有action。当现有的action可能不符合你的要求，可以Add一个同名的action覆盖现有的。 移除action 如果要移除某个action，可以使用Remove方法。

1
2
3
4
5
6
public void ConfigureServices(IServiceCollection services)
{
    services.AddUEditorService()
        .Remove("uploadvideo");
    services.AddMvc();
}

以上代码中的Remove("uploadvideo")方法移除了名为uploadvideo的action。 0x04 相关资源 UEditorNetCore代码和示例：https://github.com/durow/UEditorNetCore UEditor代码：https://github.com/fex-team/ueditor UEditor官网：http://ueditor.baidu.com/website/index.html   from:https://www.cnblogs.com/durow/p/6116393.html

龙生   14 Oct 2019
View Details

将视图添加到 ASP.NET Core MVC 应用

在本部分中，将修改 HelloWorldController 类，进而使用 Razor 视图文件来顺利封装为客户端生成 HTML 响应的过程。 使用 Razor 创建视图模板文件。 当前，Index 方法返回带有在控制器类中硬编码的消息的字符串。 C#

1
2
3
4
public IActionResult Index()
{
    return View();
}

  上面的代码调用控制器的 View 方法。 添加视图 Visual Studio Visual Studio Code Visual Studio for Mac 右键单击“视图”文件夹，然后单击“添加”>“新文件夹”，并将文件夹命名为“HelloWorld”。 右键单击“Views/HelloWorld”文件夹，然后单击“添加”>“新项”。 在“添加新项 – MvcMovie”对话框中 在右上角的搜索框中，输入“视图” 选择“Razor 视图” 保持“名称”框的值：Index.cshtml 。 选择“添加” 为 HelloWorldController 添加 Index 视图。 添加一个名为“Views/HelloWorld”的新文件夹。 向 Views/HelloWorld 文件夹添加名为“Index.cshtml”的新文件。 右键单击“视图”文件夹，然后单击“添加”>“新文件夹”，并将文件夹命名为“HelloWorld”。 右键单击“Views/HelloWorld”文件夹，然后单击“添加”>“新文件” 。 在“新建文件”对话框中 ： 在左窗格中，选择“Web” 。 在中间窗格中，选择“空 HTML 文件” 。 在“名称”框中键入“Index.cshtml” 。 选择“新建” 。 使用以下内容替换 Razor 视图文件 Views/HelloWorld/Index.cshtml 的内容 ： HTML

1
@{ ViewData["Title"] = "Index"; } <h2>Index</h2> <p>Hello from our View Template!</p>

  导航到 https://localhost:{PORT}/HelloWorld。 更改视图和布局页面 选择菜单链接（“MvcMovie”、“首页”和“隐私”） 。 布局模板使你能够在一个位置指定网站的 HTML 容器布局，然后将它应用到网站中的多个页面。 更改布局文件中的标题、页脚和菜单链接 在标题和页脚元素中，将 MvcMovie 更改为 Movie App。 将定位点元素 <a […]

龙生   20 Sep 2019
View Details

TagHelper是怎么实现的

众所周知，在asp.net core中编写Razor视图的时候，用了一种新的写法--TagHelper 那这个TagHelper是怎么回事呢?   首先来看看TagHelper的项目位置，它是位于Microsoft.AspNetCore.Mvc.TagHelpers。 如果看到project.json，可以发现，它还依赖一个比较重要的东西Microsoft.AspNetCore.Mvc.Razor 为什么这么说呢，其实很简单，看了里面诸多TagHelper，就会发现，里面都是继承了 Microsoft.AspNetCore.Razor.TagHelpers下面的TagHelper这个抽象类。 下面就以我们天天用到的表单--FormTagHelper为例来说一下，他是怎么实现的。 首先要看看TagHelper这个抽象类：

1
2
3
4
5
6
7
8
public abstract class TagHelper : ITagHelper
{
protected TagHelper();
public virtual int Order { get; }
public virtual void Init(TagHelperContext context);
public virtual void Process(TagHelperContext context, TagHelperOutput output);
public virtual Task ProcessAsync(TagHelperContext context, TagHelperOutput output);
}

里面包含两比较重要的方法：Process和ProcessAsync 其实看方法名就应该知道一个是同步的方法一个是异步的方法 因为这个是输出html的方法，你说，这能不重要吗？下面来看看FormTagHelper的具体实现吧！

1
[HtmlTargetElement("form", Attributes = ActionAttributeName)]

先来看看HtmlTargetElement这个Attribute是用来干嘛的 简单来说，它指定了我们html标签(<form></form>)以及一些相关的元素。 可以看到，诸多Attributes = XXXAttributeName，其中的XXXAttributeName是在类里面定义的变量。

1
2
3
4
5
6
7
8
private const string ActionAttributeName = "asp-action";
private const string AntiforgeryAttributeName = "asp-antiforgery";
private const string AreaAttributeName = "asp-area";
private const string ControllerAttributeName = "asp-controller";
private const string RouteAttributeName = "asp-route";
private const string RouteValuesDictionaryName = "asp-all-route-data";
private const string RouteValuesPrefix = "asp-route-";
private const string HtmlActionAttributeName = "action";

  再来看看下面的图，相对比一看，是不是就很清晰了呢？ 我们可以看到下面的好几个属性，如Controller，它的上面是有 HtmlAttributeName来标注的 而且这个指向的名字还是ControllerAttributeName(也就是asp-controller)。这个就是用来接收asp-controller的值。

1
2
[HtmlAttributeName(ControllerAttributeName)]
public string Controller { get; set; }

相对来说，这样做只是起了个别名。

1
2
3
4
5
6
7
8
    [HtmlTargetElement("form", Attributes = ActionAttributeName)]
    [HtmlTargetElement("form", Attributes = AntiforgeryAttributeName)]
    [HtmlTargetElement("form", Attributes = AreaAttributeName)]
    [HtmlTargetElement("form", Attributes = ControllerAttributeName)]
    [HtmlTargetElement("form", Attributes = RouteAttributeName)]
    [HtmlTargetElement("form", Attributes = RouteValuesDictionaryName)]
    [HtmlTargetElement("form", Attributes = RouteValuesPrefix + "*")]
    public class FormTagHelper : TagHelper

  当然，我们也是可以不指定别名的，也可以不用在HtmlTargetElement指明Attributes 好比如下的代码，就可以直接用Controller

1
2
3
4
5
[HtmlTargetElement("form")]
public class FormTagHelper : TagHelper
{
　　public string Controller { get; set; }
}

  还有一个RouteValues的属性，它是一个键值对，用来存放参数的，具体可以怎么用呢？ 总的来说有两种用法。可以看到它指向asp-all-route-data和asp-route-

1
[HtmlAttributeName(RouteValuesDictionaryName, DictionaryAttributePrefix = RouteValuesPrefix)]

用法如下：一种是用asp-all-route-data来接收一个IDictionary类型的变量，一种是通过asp-route-*的方式来接收参数*的值。 这两种写法是等价的。 下面就是FormTagHelper的构造函数和一个Generator属性

1
2
3
4
5
public FormTagHelper(IHtmlGenerator generator)
{
    Generator = generator;
}
protected IHtmlGenerator Generator { get; }

  由于在Core中，依赖注入随处可见，看到这个写法马上就是想到了这个 果不其然，发现其对应了一个实现类：DefaultHtmlGenerator。

1
2
3
4
5
6
7
8
9
10
11
12
13
    public class DefaultHtmlGenerator : IHtmlGenerator
    {      
        public DefaultHtmlGenerator(IAntiforgery antiforgery, IOptions<MvcViewOptions> optionsAccessor, IModelMetadataProvider metadataProvider, IUrlHelperFactory urlHelperFactory, HtmlEncoder htmlEncoder, ClientValidatorCache clientValidatorCache);    
        public virtual TagBuilder GenerateActionLink(ViewContext viewContext, string linkText, string actionName, string controllerName, string protocol, string hostname, string fragment, object routeValues, object htmlAttributes);
        public virtual IHtmlContent GenerateAntiforgery(ViewContext viewContext);    
        public virtual TagBuilder GenerateForm(ViewContext viewContext, string actionName, string controllerName, object routeValues, string method, object htmlAttributes);  
        public virtual TagBuilder GenerateLabel(ViewContext viewContext, ModelExplorer modelExplorer, string expression, string labelText, object htmlAttributes);  
        public virtual TagBuilder GenerateTextArea(ViewContext viewContext, ModelExplorer modelExplorer, string expression, int rows, int columns, object htmlAttributes);
        public virtual TagBuilder GenerateTextBox(ViewContext viewContext, ModelExplorer modelExplorer, string expression, object value, string format, object htmlAttributes);      
        protected virtual TagBuilder GenerateInput(ViewContext viewContext, InputType inputType, ModelExplorer modelExplorer, string expression, object value, bool useViewData, bool isChecked, bool setId, bool isExplicitValue, string format, IDictionary<string, object> htmlAttributes);
        protected virtual TagBuilder GenerateLink(string linkText, string url, object htmlAttributes);
　　　　 ....省略部分
    }

  这个类里面，我们看到了熟悉的TagBuilder，就算不去看它里面的实现都能知道它是用来干嘛的 它就是用来创建我们的Html标签，相信用过MVC的，多多少少都扩展过HtmlHelper，这是类似的。 最后，也是最最重要的重写的Process方法。 可以看到开始就判断了表单<form>中是否包含了action这个属性output.Attributes.ContainsName(HtmlActionAttributeName) 如果包含，就是正常的html标签。换句话说，正常的html写法和我们的TagHelper方法会有冲突，只能用其中一种。 当我们这样写的时候，编译能通过。 但是，运行的时候就会出错。 再下面的处理就是用了TagBuilder去处理了。 收集路由的数据放到一个字典中->区域是否存在->用Generator去创建form表单，返回TagBuilder对象->TagHelperOutput对象把tagbuilder的innerhtml等信息输出。 如下面的写法：

1
2
3
<form method="post" asp-action="Get" asp-controller="Product" asp-antiforgery="false" asp-route-id="2">
  <button type="submit">submit</button>
</form>

生成对应的html如下：

1
2
3
<form method="post" action="/Product/Get/2">
  <button type="submit">submit</button>
</form>

到这里，FormTagHelper的讲解就算是OK，至于其他的，原理都是差不多，就不再累赘了。 来看看，到底有多少种TagHelper(还没有部分没有列出来)，以及它们包含的属性。 下面是我们自己写一个TagHelper——CatcherATagHelper，这个TagHelper是干什么的呢？它只是一个精简版的A标签。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.AspNetCore.Mvc.Routing;
using Microsoft.AspNetCore.Mvc.TagHelpers;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
using Microsoft.AspNetCore.Razor.TagHelpers;
 
namespace Catcher.EasyDemo.Controllers.TagHelpers
{
    [HtmlTargetElement("catcher-a")]
    public class CatcherATagHelper:TagHelper
    {      
        public CatcherATagHelper(IHtmlGenerator generator, IUrlHelperFactory urlHelperFactory)
        {
            this.Generator = generator;
            UrlHelperFactory = urlHelperFactory;
        }
 
        [HtmlAttributeNotBound]
        public IUrlHelperFactory UrlHelperFactory { get; }
 
        protected IHtmlGenerator Generator { get; }
        
        public override int Order
        {
            get
            {
                return -1000;
            }
        }
                
        public string Action { get; set; }
        
        public string Controller { get; set; }
 
        public string LinkText { get; set; }
 
        [ViewContext]
        [HtmlAttributeNotBound]
        public ViewContext ViewContext { get; set; }
 
        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            //method 1
            if (Action != null || Controller != null)
            {
                output.Attributes.Clear();
 
                var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
 
                output.TagName = "a";
 
                output.Attributes.SetAttribute("href", urlHelper.Action(Action, Controller));
                //whether the inner html is null
                if (output.Content.IsEmptyOrWhiteSpace)
                {
                    output.PreContent.SetContent(LinkText);
                }
            }
            //method 2
            //TagBuilder tagBuilder;
            //if (Action != null || Controller != null)
            //{
            //    tagBuilder = Generator.GenerateActionLink(
            //            ViewContext,
            //            linkText: string.Empty,
            //            actionName: Action,
            //            controllerName: Controller,
            //            protocol: string.Empty,
            //            hostname: string.Empty,
            //            fragment: string.Empty,
            //            routeValues: null,
            //            htmlAttributes: null);
 
            //    output.TagName = "a";
            //    //whether the inner html is null
            //    if (output.Content.IsEmptyOrWhiteSpace)
            //    {
            //        output.PreContent.SetContent(LinkText);
            //    }
            //    output.MergeAttributes(tagBuilder);
            //}
        }
    }
}

   这里提供了两种写法供大家参考 一种是借助IUrlHelperFactory去生成链接 一种是借助IHtmlGenerator去生成链接 写好了之后要怎么用呢？ 不知道大家有没有留意_ViewImports.cshtml这个文件

1
2
3
@using Catcher.EasyDemo.Website
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@inject Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration TelemetryConfiguration

这个是默认情况下帮我们添加的TagHelper 我们可以在要用到那个TagHelper的地方添加就好  Index.cshtml   addTagHelper的用法如下： @addTagHelper 你的TagHelper , 你的TagHelper所在的命名空间 或者更直接 @addTagHelper * , 你的TagHelper所在的命名空间   可以添加，当然也可以删除，删除是@removeTagHelper 当我们在自己的框架中完全重写了一套自己的TagHelper，那么这个时候，微软自己的TagHelper我们就可以通过下面的方法来移除了。 @removeTagHelper […]

龙生   19 Sep 2019
View Details

.NET Core开源API网关 – Ocelot中文文档

Ocelot是一个用.NET Core实现并且开源的API网关，它功能强大，包括了：路由、请求聚合、服务发现、认证、鉴权、限流熔断、并内置了负载均衡器与Service Fabric、Butterfly Tracing集成。这些功能只都只需要简单的配置即可完成，下面我们会对这些功能的配置一一进行说明。 介绍 简单的来说Ocelot是一堆的asp.net core middleware组成的一个管道。当它拿到请求之后会用一个request builder来构造一个HttpRequestMessage发到下游的真实服务器，等下游的服务返回response之后再由一个middleware将它返回的HttpResponseMessage映射到HttpResponse上。 API网关—— 它是系统的暴露在外部的一个访问入口。这个有点像代理访问的家伙，就像一个公司的门卫承担着寻址、限制进入、安全检查、位置引导、等等功能。 Ocelot的基本使用 用一台web service来host Ocelot，在这里有一个json配置文件，里面设置了所有对当前这个网关的配置。它会接收所有的客户端请求，并路由到对应的下游服务器进行处理，再将请求结果返回。而这个上下游请求的对应关系也被称之为路由。 集成Identity Server 当我们涉及到认证和鉴权的时候，我们可以跟Identity Server进行结合。当网关需要请求认证信息的时候会与Identity Server服务器进行交互来完成。 网关集群 只有一个网关是很危险的，也就是我们通常所讲的单点，只要它挂了，所有的服务全挂。这显然无法达到高可用，所以我们也可以部署多台网关。当然这个时候在多台网关前，你还需要一台负载均衡器。 Consul 服务发现 在Ocelot已经支持简单的负载功能，也就是当下游服务存在多个结点的时候，Ocelot能够承担起负载均衡的作用。但是它不提供健康检查，服务的注册也只能通过手动在配置文件里面添加完成。这不够灵活并且在一定程度下会有风险。这个时候我们就可以用Consul来做服务发现，它能与Ocelot完美结合。 集成网关 在asp.net core 2.0里通过nuget即可完成集成，或者命令行dotnet add package Ocelot以及通过vs2017 UI添加Ocelot nuget引用都可以。

1
Install-Package Ocelot

  配置 我们需要添加一个.json的文件用来添加Ocelot的配置，以下是最基本的配置信息。

1
2
3
4
5
6
{
    "ReRoutes": [],
    "GlobalConfiguration": {
        "BaseUrl": "https://api.mybusiness.com"
    }
}

  要特别注意一下BaseUrl是我们外部暴露的Url，比如我们的Ocelot运行在http://123.111.1.1的一个地址上，但是前面有一个 nginx绑定了域名http://api.jessetalk.cn，那这里我们的BaseUrl就是 http://api.jessetalk.cn。 将配置文件加入ASP.NET Core Configuration 我们需要通过WebHostBuilder将我们添加的json文件添加进asp.net core的配置

1
2
3
4
5
6
7
8
9
public static IWebHost BuildWebHost(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .ConfigureAppConfiguration( (hostingContext,builder) => {
            builder
            .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
            .AddJsonFile("Ocelot.json");
        })
        .UseStartup<Startup>()
        .Build();

    配置依赖注入与中间件 在startup.cs中我们首先需要引用两个命名空间

1
2
using Ocelot.DependencyInjection;
using Ocelot.Middleware;

  接下来就是添加依赖注入和中间件

1
2
3
4
public void ConfigureServices(IServiceCollection services)
{
    services.AddOcelot();
}

 

1
2
3
4
5
6
7
8
9
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
 
    app.UseOcelot().Wait();
}

  Ocelot功能介绍 通过配置文件可以完成对Ocelot的功能配置：路由、服务聚合、服务发现、认证、鉴权、限流、熔断、缓存、Header头传递等。在配置文件中包含两个根节点：ReRoutes和GlobalConfiguration。ReRoutes是一个数组，其中的每一个元素代表了一个路由，我们可以针对每一个路由进行以上功能配置。下面是一个完整的路由配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
{
          "DownstreamPathTemplate": "/",
          "UpstreamPathTemplate": "/",
          "UpstreamHttpMethod": [
              "Get"
          ],
          "AddHeadersToRequest": {},
          "AddClaimsToRequest": {},
          "RouteClaimsRequirement": {},
          "AddQueriesToRequest": {},
          "RequestIdKey": "",
          "FileCacheOptions": {
              "TtlSeconds": 0,
              "Region": ""
          },
          "ReRouteIsCaseSensitive": false,
          "ServiceName": "",
          "DownstreamScheme": "http",
          "DownstreamHostAndPorts": [
              {
                  "Host": "localhost",
                  "Port": 51876,
              }
          ],
          "QoSOptions": {
              "ExceptionsAllowedBeforeBreaking": 0,
              "DurationOfBreak": 0,
              "TimeoutValue": 0
          },
          "LoadBalancer": "",
          "RateLimitOptions": {
              "ClientWhitelist": [],
              "EnableRateLimiting": false,
              "Period": "",
              "PeriodTimespan": 0,
              "Limit": 0
          },
          "AuthenticationOptions": {
              "AuthenticationProviderKey": "",
              "AllowedScopes": []
          },
          "HttpHandlerOptions": {
              "AllowAutoRedirect": true,
              "UseCookieContainer": true,
              "UseTracing": true
          },
          "UseServiceDiscovery": false
      }

  Downstream是下游服务配置 UpStream是上游服务配置 Aggregates 服务聚合配置 ServiceName, LoadBalancer, UseServiceDiscovery 配置服务发现 AuthenticationOptions 配置服务认证 RouteClaimsRequirement 配置Claims鉴权 RateLimitOptions为限流配置 FileCacheOptions 缓存配置 QosOptions 服务质量与熔断 DownstreamHeaderTransform头信息转发 我们接下来将对这些功能一一进行介绍和配置 路由 路由是API网关最基本也是最核心的功能、ReRoutes下就是由多个路由节点组成。

1
2
3
4
{
    "ReRoutes": [
    ]
}

  而每一个路由由以下几个基本信息组成： 下面这个配置信息就是将用户的请求 /post/1 转发到 localhost/api/post/1

1
2
3
4
5
6
7
8
9
10
11
12
{
    "DownstreamPathTemplate": "/api/post/{postId}",
    "DownstreamScheme": "https",
    "DownstreamHostAndPorts": [
            {
                "Host": "localhost",
                "Port": 80,
            }
        ],
    "UpstreamPathTemplate": "/post/{postId}",
    "UpstreamHttpMethod": [ "Get"]
}

  DownstreamPathTemplate：下游戏 DownstreamScheme：下游服务http schema DownstreamHostAndPorts：下游服务的地址，如果使用LoadBalancer的话这里可以填多项 UpstreamPathTemplate: 上游也就是用户输入的请求Url模板 […]

龙生   05 Sep 2019
View Details

Dapper ORM VS SqlSugar ORM的 8场对决

比赛规则
1.统一使用Realse版本的最新 DLL,Realse模式启用程序

2.为了平衡CPU和数据库空闲情况，使用车轮战，每场比赛连续10回合比试

3.多次重启电脑取平均成绩上图

比赛成员
1.SqlSugar 3.1.01

2.Dapper 1.5.0.2 Dapper.Contrib 1.5 官方DLL

龙生   05 Sep 2019
View Details

Asp .Net Core 2.0 登录授权以及多用户登录

用户登录是一个非常常见的应用场景 .net core 2.0 的登录方式发生了点变化，应该是属于是良性的变化，变得更方便，更容易扩展。 配置 打开项目中的Startup.cs文件，找到ConfigureServices方法，我们通常在这个方法里面做依赖注入的相关配置。添加如下代码：

1
2
3
4
5
6
7
8
9
public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
        .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, o =>
            {
                o.LoginPath = new PathString("/Account/Login");
                o.AccessDeniedPath = new PathString("/Error/Forbidden");
            });
}

这段代码的大概意思就是，添加授权支持，并添加使用Cookie的方式，配置登录页面和没有权限时的跳转页面。 再找到Configure方法，添加 app.UseAuthentication()，使用授权：

1
2
3
4
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    app.UseAuthentication();
}

这样基本的配置就完成了。 登录 添加一个Controller，如AccountController，再添加一个Action，如 Login，所配置的路由，要与上面的配置对应，不然跳转登录时会跳错页面。 用户提交用户名和密码，登录代码大致如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[HttpPost]
public async Task <IActionResult> Login(string userName, string password, string ReturnUrl)
{
    var user = _userService.Login(userName, password);
    if (user != null)
    {
 
        user.AuthenticationType = CookieAuthenticationDefaults.AuthenticationScheme;
        var identity = new ClaimsIdentity(user);
        identity.AddClaim(new Claim(ClaimTypes.Name, user.UserID));
        await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(identity));
 
        if (ReturnUrl.IsNullOrEmpty())
        {
            return RedirectToAction("Index", "Dashboard");
        }
        return Redirect(ReturnUrl);
    }
    ViewBag.Errormessage = "登录失败，用户名密码不正确";
    return View();
}

这里要注意的是 AuthenticationType 所设置的Scheme一定要与前面的配置一样，这样对应的登录授权才会生效。 使用登录身份 登录的目录，就是希望有些页面或者资源只有登录以后才可访问。使用AuthorizeAttribute来做限制。在需要做限制的Controller上加上[Authorize]特性来做限制。

1
2
3
4
[Authorize]
public class ThemeController
{
}

这样这个Controller下的所有的Action都必需要登录后才可访问。如果希望其中某些Action可以不用登录也可访问，可以添加例外：

1
2
3
4
5
[AllowAnonymous]
public ActionResult Index()
{
    return View();
}

到这里一个最基础的登录就完成了。 在Web项目中，通常会遇到一个问题，后端管理员和前台用户。这两个用户都是可登录的，在 .net core 2.0，这个将很容易实现。 多用户登录 添加一个登录方案（Scheme） CookieAuthenticationDefaults.AuthenticationScheme，这是系统已经定义好的一个默认的登录方案，添加一个新的来实现一个不同的身份登录。代码如下：

1
2
3
4
5
6
7
8
public class CustomerAuthorizeAttribute : AuthorizeAttribute
{
    public const string CustomerAuthenticationScheme = "CustomerAuthenticationScheme";
    public CustomerAuthorizeAttribute()
    {
        this.AuthenticationSchemes = CustomerAuthenticationScheme;
    }
}

添加使用这个新的方案，在Startup.cs文件下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
        .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, o =>
            {
                o.LoginPath = new PathString("/Account/Login");
                o.AccessDeniedPath = new PathString("/Error/Forbidden");
            })
            .AddCookie(CustomerAuthorizeAttribute.CustomerAuthenticationScheme, option =>
            {
                option.LoginPath = new PathString("/Account/Signin");
                option.AccessDeniedPath = new PathString("/Error/Forbidden");
            });
}

添加新的登录方案，并配置一个新的登录页面，登录的方法和刚才是一样，只是AuthenticationType使用了新的方案。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[HttpPost]
public async Task <IActionResult> Login(string userName, string password, string ReturnUrl)
{
    var user = _userService.Login(userName, password);
    if (user != null)
    {
 
        user.AuthenticationType = <strong>CustomerAuthorizeAttribute.CustomerAuthenticationScheme</strong>;
        var identity = new ClaimsIdentity(user);
        identity.AddClaim(new Claim(ClaimTypes.Name, user.UserID));
        await HttpContext.SignInAsync(<strong>CustomerAuthorizeAttribute.CustomerAuthenticationScheme</strong>, new ClaimsPrincipal(identity));
 
        if (ReturnUrl.IsNullOrEmpty())
        {
            return RedirectToAction("Index", "Dashboard");
        }
        return Redirect(ReturnUrl);
    }
    ViewBag.Errormessage = "登录失败，用户名密码不正确";
    return View();
}

验证登录状态 使用方法和之前的差不多，换成新的CustomerAuthorizeAttribute就行了：

1
2
3
4
[CustomerAuthorize]
public class CustomerController
{
}

CustomerAuthorizeAttribute这个类，不是必需的，只是为了方便使用而写，其实完全可以只定义一个新的方案(Scheme)就行了。 谁才是HttpContext.User？ 登录了多个用户，那么谁才是HttpContext.User呢？如果你的Controller或者Action上有使用AuthorizeAttribute，那这个Attribute使用的登录方案是哪个，则这个HttpContext.User对应的就是那个方案的登录用户。如果没有使用，则AddAuthentication()方法默认指它的方案（Scheme）所登录的用户，就是这个HttpContext.User了。 如何获取对应方案的登录用户呢？使用HttpContext.AuthenticateAsync

1
2
3
4
5
var auth = await HttpContext.AuthenticateAsync(CustomerAuthorizeAttribute.CustomerAuthenticationScheme);
if (auth.Succeeded)
{
    auth.Principal.Identity...
}

退出登录 这个就简单了，指定方案退出就可以了。

1
2
3
4
5
public async Task Logout(string returnurl)
{
    await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
    return Redirect(returnurl ?? "~/");
}

from:http://www.zkea.net/codesnippet/detail/asp-net-core-multi-login-user.html

龙生   02 Sep 2019
View Details

ASP.NET CORE中使用Cookie身份认证

大家在使用ASP.NET的时候一定都用过FormsAuthentication做登录用户的身份认证，FormsAuthentication的核心就是Cookie，ASP.NET会将用户名存储在Cookie中。 现在到了ASP.NET CORE的时代，但是ASP.NET CORE中没有FormsAuthentication这个东西，那么怎么做身份认证呢？答案是ASP.NET CORE已经为我们内置了Cookie身份认证的功能，而且使用起来非常方便，注意本文是基于ASP.NET CORE 2.0版本来阐述Cookie认证方式的。   1.从ASP.NET CORE OWIN框架中启用Cookie身份认证功能 要在ASP.NET CORE中使用Cookie身份认证，第一步就是在项目中的OWIN框架文件Startup.cs中启用Cookie身份认证中间件。 首先我们在Startup中的ConfigureServices方法中使用services.AddAuthentication注册Cookie认证服务，如下代码所示：

1
2
3
4
5
6
7
public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
 
    //注册Cookie认证服务
    services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme).AddCookie();
}

然后在Startup中的Configure方法中使用app.UseAuthentication启用Cookie认证中间件（注意其中app.UseAuthentication和app.UseMvc的调用顺序不能反），如下代码所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseBrowserLink();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }
 
    app.UseStaticFiles();
 
    //注意app.UseAuthentication方法一定要放在下面的app.UseMvc方法前面，否者后面就算调用HttpContext.SignInAsync进行用户登录后，使用
    //HttpContext.User还是会显示用户没有登录，并且HttpContext.User.Claims读取不到登录用户的任何信息。
    //这说明Asp.Net OWIN框架中MiddleWare的调用顺序会对系统功能产生很大的影响，各个MiddleWare的调用顺序一定不能反
    app.UseAuthentication();
 
    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    });
 
            
}

这里顺便说一下app.UseAuthentication是用来干什么的，app.UseAuthentication会启用Authentication中间件，该中间件会根据当前Http请求中的Cookie信息来设置HttpContext.User属性（后面会用到），所以只有在app.UseAuthentication方法之后注册的中间件才能够从HttpContext.User中读取到值，这也是为什么上面强调app.UseAuthentication方法一定要放在下面的app.UseMvc方法前面，因为只有这样ASP.NET Core的MVC中间件中才能读取到HttpContext.User的值。     2.登录用户 在ASP.NET CORE中使用Cookie认证登录用户的方法和传统的FormsAuthentication不太一样，大致步骤如下： 创建Claim类型的数组，将登录用户的所有信息（比如用户名）存储在Claim类型的字符串键值对中 将上面创建的Claim类型的数组传入ClaimsIdentity中，用来构造一个ClaimsIdentity对象 将上面创建的ClaimsIdentity对象传入ClaimsPrincipal中，用来构造一个ClaimsPrincipal对象 调用HttpContext.SignInAsync方法，传入上面创建的ClaimsPrincipal对象，完成用户登录 所以我们可以看到整个ASP.NET CORE的Cookie认证登录流程比以前ASP.NET的FormsAuthentication还是要复杂许多，毕竟以前一个FormsAuthentication.SetAuthCookie方法就搞定了。   在本文的例子中我们在项目中默认的HomeController中创建了一个Acion方法Login，来实现用户登录的代码。当然这里我们实现的是最简的Cookie登录，下面代码中实际上还可以设置Cookie是否持久化、Cookie多久过期、存储登录用户信息的Cookie的名字是什么等，我们就不做过多介绍了，大家可以阅读本文最后推荐的两份官方文档了解更多。 Login方法的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/// <summary>
/// 该Action登录用户Wangdacui到Asp.Net Core
/// </summary>
public IActionResult Login()
{
    //下面的变量claims是Claim类型的数组，Claim是string类型的键值对，所以claims数组中可以存储任意个和用户有关的信息，
    //不过要注意这些信息都是加密后存储在客户端浏览器cookie中的，所以最好不要存储太多特别敏感的信息，这里我们只存储了用户名到claims数组,
    //表示当前登录的用户是谁
    var claims = new[] { new Claim("UserName", "Wangdacui") };
 
    var claimsIdentity = new ClaimsIdentity(
    claims,
    CookieAuthenticationDefaults.AuthenticationScheme);
 
    ClaimsPrincipal user = new ClaimsPrincipal(claimsIdentity);
 
    Task.Run(async () =>
    {
        //登录用户，相当于ASP.NET中的FormsAuthentication.SetAuthCookie
        await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, user);
 
        //可以使用HttpContext.SignInAsync方法的重载来定义持久化cookie存储用户认证信息，例如下面的代码就定义了用户登录后60分钟内cookie都会保留在客户端计算机硬盘上，
        //即便用户关闭了浏览器，60分钟内再次访问站点仍然是处于登录状态，除非调用Logout方法注销登录。
        //注意其中的AllowRefresh属性，如果AllowRefresh为true，表示如果用户登录后在超过50%的ExpiresUtc时间间隔内又访问了站点，就延长用户的登录时间（其实就是延长cookie在客户端计算机硬盘上的保留时间），
        //例如本例中我们下面设置了ExpiresUtc属性为60分钟后，那么当用户登录后在大于30分钟且小于60分钟内访问了站点，那么就将用户登录状态再延长到当前时间后的60分钟。但是用户在登录后的30分钟内访问站点是不会延长登录时间的，
        //因为ASP.NET Core有个硬性要求，是用户在超过50%的ExpiresUtc时间间隔内又访问了站点，才延长用户的登录时间。
        //如果AllowRefresh为false，表示用户登录后60分钟内不管有没有访问站点，只要60分钟到了，立马就处于非登录状态（不延长cookie在客户端计算机硬盘上的保留时间，60分钟到了客户端计算机就自动删除cookie）
        /*
        await HttpContext.SignInAsync(
        CookieAuthenticationDefaults.AuthenticationScheme,
        user, new AuthenticationProperties()
        {
            IsPersistent = true,
            ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(60),
            AllowRefresh = true
        });
        */
 
    }).Wait();
 
    return View();
}

  如果当前Http请求本来登录了用户A，现在调用HttpContext.SignInAsync方法登录用户B，那么相当于注销用户A，登录用户B     3.读取登录用户信息 那么用户登录后怎么将登录用户的信息（比如用户名）读取出来呢？我们在HomeController的Index方法中演示了如何判断当前用户是否已经登录，并且读出登录用户的用户名，Index方法的代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/// <summary>
/// 该Action判断用户是否已经登录，如果已经登录，那么读取登录用户的用户名
/// </summary>
public IActionResult Index()
{
    //如果HttpContext.User.Identity.IsAuthenticated为true，
    //或者HttpContext.User.Claims.Count()大于0表示用户已经登录
    if (HttpContext.User.Identity.IsAuthenticated)
    {
        //这里通过 HttpContext.User.Claims 可以将我们在Login这个Action中存储到cookie中的所有
        //claims键值对都读出来，比如我们刚才定义的UserName的值Wangdacui就在这里读取出来了
        var userName = HttpContext.User.Claims.First().Value;
    }
 
    return View();
}

注意，最好还是用HttpContext.User.Identity.IsAuthenticated来判断用户是否已经登录     4.注销用户 那么登录用户后怎么注销登录呢？我们在HomeController的Logout方法中演示了如何注销登录的用户，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
/// <summary>
/// 该Action从Asp.Net Core中注销登录的用户
/// </summary>
public IActionResult Logout()
{
    Task.Run(async () =>
    {
        //注销登录的用户，相当于ASP.NET中的FormsAuthentication.SignOut  
        await HttpContext.SignOutAsync();
    }).Wait();
 
    return View();
}

如果当前Http请求本来就没有登录用户，那么调用HttpContext.SignOutAsync方法时也不会报错     5.负载均衡   警告： ASP.NET Core使用 ASP.NET Core data protection stack 来实现Cookie身份认证。如果在服务器集群中必须配置 ASP.NET Core Data Protection，有关详细信息，请参阅 Configuring data protection。如果你的ASP.NET Core站点使用了负载均衡部署了多个实例，就要做ASP.NET Core Data Protection的配置，否则ASP.NET CORE跨多个实例进行Cookie身份认证会失败。 还可以参考：Host ASP.NET Core in a web farm 以及 Share authentication cookies among ASP.NET apps 如何管理ASP.NET Core Data Protection的过期key，可以查看：Data Protection – […]

龙生   02 Sep 2019
View Details

ASP.NET Core WebApi使用Swagger生成api说明文档看这篇就够了

引言 在使用asp.net core 进行api开发完成后，书写api说明文档对于程序员来说想必是件很痛苦的事情吧，但文档又必须写，而且文档的格式如果没有具体要求的话，最终完成的文档则完全取决于开发者的心情。或者详细点，或者简单点。那么有没有一种快速有效的方法来构建api说明文档呢？答案是肯定的， Swagger就是最受欢迎的REST APIs文档生成工具之一！ 为什么使用Swagger作为REST APIs文档生成工具 Swagger 可以生成一个具有互动性的API控制台，开发者可以用来快速学习和尝试API。 Swagger 可以生成客户端SDK代码用于各种不同的平台上的实现。 Swagger 文件可以在许多不同的平台上从代码注释中自动生成。 Swagger 有一个强大的社区，里面有许多强悍的贡献者。 asp.net core中如何使用Swagger生成api说明文档呢 Swashbuckle.AspNetCore 是一个开源项目，用于生成 ASP.NET Core Web API 的 Swagger 文档。 NSwag 是另一个用于将 Swagger UI 或 ReDoc 集成到 ASP.NET Core Web API 中的开源项目。 它提供了为 API 生成 C# 和 TypeScript 客户端代码的方法。 下面以Swashbuckle.AspNetCore为例为大家进行展示 Swashbuckle由哪些组成部分呢？ Swashbuckle.AspNetCore.Swagger：将 SwaggerDocument 对象公开为 JSON 终结点的 Swagger 对象模型和中间件。 Swashbuckle.AspNetCore.SwaggerGen：从路由、控制器和模型直接生成 SwaggerDocument 对象的 Swagger 生成器。 它通常与 Swagger 终结点中间件结合，以自动公开 Swagger JSON。 Swashbuckle.AspNetCore.SwaggerUI：Swagger UI 工具的嵌入式版本。 它解释 Swagger JSON 以构建描述 Web API 功能的可自定义的丰富体验。 它包括针对公共方法的内置测试工具。 如何使用vs2017安装Swashbuckle呢？ 从“程序包管理器控制台”窗口进行安装 转到“视图” > “其他窗口” > “程序包管理器控制台” 导航到包含 TodoApi.csproj 文件的目录 请执行以下命令 ·Install-Package […]

龙生   15 Jul 2019
View Details

Asp.Net Core连接多个数据库

1.首先要有对应的context实体类, 多个实体类的构造函数的参数都应该是集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class firstContext : DbContext
    {
        //多个数据库应该使用这个构造函数，参数是上下文的集合
        public GalpOnlineContext(DbContextOptions<firstContext> options) : base(options)
        {
 
        }
 
        //自定义DbContext实体属性名与数据库表对应名称（默认 表名与属性名对应是 User与Users）
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<User>().ToTable("user");
            modelBuilder.Entity<Project>().ToTable("project");
            //相关表名称的和类的对应
            base.OnModelCreating(modelBuilder);
        }
 
 
        public DbSet<User> User { get; set; }
      //....
 
        //第二种方法，重载父级的构造函数，和配置，这个只能是一个数据库时候的构造函数
        /*
        public firstContext(DbContextOptions options) : base(options)
        {
            // Using the default constructor
        }*/
 
    }
}

  2.在appsettings.json中进行配置数据库连接的信息

1
2
3
4
5
6
7
8
9
10
{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "ConnectionStrings": {
    "firstContext": "Server=localhost;database=test;uid=root;pwd=123456;sslmode=none",
    "secondContext": "Server=localhost;database=test2;uid=root;pwd=123456;sslmode=none"
  },

  3.在startup.cs文件中注册数据库上下文的信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void ConfigureServices(IServiceCollection services)
      {
          services.Configure<CookiePolicyOptions>(options =>
          {
              //  options.CheckConsentNeeded = context => false;实现session,默认是true
              options.CheckConsentNeeded = context => false; 
              options.MinimumSameSitePolicy = SameSiteMode.None;
          });
 
          //注册数据库的服务
          string connectionString = Configuration.GetConnectionString("firstContext");
          string connectionString2 = Configuration.GetConnectionString("secondContext");
 
          services.AddDbContext<firstContext>(options => options.UseMySql(connectionString));
          services.AddDbContext<secondContext>(options => options.UseMySql(connectionString2));
 
 
          //注册session
          services.AddDistributedMemoryCache();
          services.AddSession(Options =>
        {
            Options.IdleTimeout = TimeSpan.FromSeconds(1000);
            Options.Cookie.HttpOnly = true;
        });
          //services.AddMemoryCache();//使用本地缓存必须添加
 
          //注册mvc服务
          services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
 
      }

  然后就可以了，在使用的地方引入上下文就可以了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TestController : Controller
    {
        public readonly firstContext _context;
        //构造函数，依赖注入数据库上下文就可以了
        public TestController(firstContext context)
        {
            _context = context;
        }
        public ActionResult Index(string page)
        {
            List&lt;Project&gt; projects = _context.Project.ToList();
            ViewBag.projects = projects;
            return View();
        }
    }

  from:https://www.cnblogs.com/xuqp/p/9707469.html

龙生   29 Jun 2019
View Details
1 … 9 10 11 … 17

Copyright © 2025 Longsheng All rights reserved