IT博客-青蛙學堂-随笔分类-c#

Elasticsearch简介

青蛙學堂 — Fri, 26 Aug 2022 06:18:00 GMT

Elasticsearch简介

Elasticsearch （ES）是一个基于Apache Lucene™的开源搜索引擎，无论在开源还是专有领域，Lucene可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。

但是，Lucene只是一个库。想要发挥其强大的作用，你需使用C#将其集成到你的应用中。Lucene非常复杂，你需要深入的了解检索相关知识来理解它是如何工作的。

Elasticsearch是使用Java编写并使用Lucene来建立索引并实现搜索功能，但是它的目的是通过简单连贯的RESTful API让全文搜索变得简单并隐藏Lucene的复杂性。

不过，Elasticsearch不仅仅是Lucene和全文搜索引擎，它还提供：

分布式的实时文件存储，每个字段都被索引并可被搜索

实时分析的分布式搜索引擎

可以扩展到上百台服务器，处理PB级结构化或非结构化数据

而且，所有的这些功能被集成到一台服务器，你的应用可以通过简单的RESTful API、各种语言的客户端甚至命令行与之交互。

上手Elasticsearch非常简单，它提供了许多合理的缺省值，并对初学者隐藏了复杂的搜索引擎理论。它开箱即用（安装即可使用），只需很少的学习既可在生产环境中使用。Elasticsearch在Apache 2 license下许可使用，可以免费下载、使用和修改。

随着知识的积累，你可以根据不同的问题领域定制Elasticsearch的高级特性，这一切都是可配置的，并且配置非常灵活。

使用C#操作ES

NEST是一个高层的客户端，可以映射所有请求和响应对象，拥有一个强类型查询DSL（领域特定语言），并且可以使用.net的特性比如协变、Auto Mapping Of POCOs，NEST内部使用的依然是Elasticsearch.Net客户端。

Elasticsearch.net（NEST）客户端提供了强类型查询DSL，方便用户使用，源码下载。（https://github.com/elastic/elasticsearch-net/releases/tag/2.4.4）

一、如何安装NEST

打开VS的工具菜单，通过NuGet包管理器控制台，输入以下命令安装NEST

Install-Package NEST

安装后引用了以下三个DLL

Elasticsearch.Net.dll（2.4.4）

Nest.dll（2.4.4）

Newtonsoft.Json.dll（9.0版本）

二、链接elasticsearch

你可以通过单个节点或者指定多个节点使用连接池链接到Elasticsearch集群，使用连接池要比单个节点链接到Elasticsearch更有优势，比如支持负载均衡、故障转移等。

通过单点链接：

var node = new Uri(“http://myserver:9200”);

var settings = new ConnectionSettings(node);

var client = new ElasticClient(settings);

通过连接池链接：

var nodes = new Uri[]

{
new Uri("http://myserver1:9200"),

new Uri("http://myserver2:9200"),

new Uri("http://myserver3:9200")
};

var pool = new StaticConnectionPool(nodes);

var settings = new ConnectionSettings(pool);

var client = new ElasticClient(settings);

NEST Index

为了知道请求需要操作哪个索引，Elasticsearch API期望收到一个或多个索引名称作为请求的一部分。

一、指定索引

1、可以通过ConnectionSettings使用.DefaultIndex()，来指定默认索引。当一个请求里没有指定具体索引时，NEST将请求默认索引。

var settings = new ConnectionSettings()

.DefaultIndex("defaultindex");
2、可以通过ConnectionSettings使用.MapDefaultTypeIndices()，来指定被映射为CLR类型的索引。

var settings = new ConnectionSettings()

.MapDefaultTypeIndices(m => m

    .Add(typeof(Project), "projects")

);
注意：通过.MapDefaultTypeIndices()指定索引的优先级要高于通过.DefaultIndex()指定索引，并且更适合简单对象（POCO）

3、另外还可以显示的为请求指定索引名称，例如：

var response = client.Index(student, s=>s.Index(“db_test”));

var result = client.Search(s => s.Index(“db_test”));

var result = client.Delete(null, s => s.Index(“db_test”));

……

注意：当现实的为请求指定索引名称时，这个优先级是最高的，高于以上两种方式指定的索引。

4、一些Elasticsearch API（比如query）可以采用一个、多个索引名称或者使用_all特殊标志发送请求，请求NEST上的多个或者所有节点

//请求单一节点

var singleString = Nest.Indices.Index(“db_studnet”);

var singleTyped = Nest.Indices.Index();

ISearchRequest singleStringRequest = new SearchDescriptor().Index(singleString);

ISearchRequest singleTypedRequest = new SearchDescriptor().Index(singleTyped);

//请求多个节点

var manyStrings = Nest.Indices.Index(“db_studnet”, “db_other_student”);

var manyTypes = Nest.Indices.Index().And();

ISearchRequest manyStringRequest = new SearchDescriptor().Index(manyStrings);

ISearchRequest manyTypedRequest = new SearchDescriptor().Index(manyTypes);

//请求所有节点

var indicesAll = Nest.Indices.All;

var allIndices = Nest.Indices.AllIndices;

ISearchRequest indicesAllRequest = new SearchDescriptor().Index(indicesAll);

ISearchRequest allIndicesRequest = new SearchDescriptor().Index(allIndices);

二、创建索引

Elasticsearch API允许你创建索引的同时对索引进行配置，例如：

var descriptor = new CreateIndexDescriptor(“db_student”)

.Settings(s => s.NumberOfShards(5).NumberOfReplicas(1));
client.CreateIndex(descriptor);

这里指定了该索引的分片数为5、副本数为1。

三、删除索引

Elasticsearch API允许你删除索引，例如：

var descriptor = new DeleteIndexDescriptor(“db_student”).Index(“db_student”);

client.DeleteIndex(descriptor)

这里制定了要删除的索引名称“db_student”，以下为更多删除用例：

//删除指定索引所在节点下的所有索引

var descriptor = new DeleteIndexDescriptor(“db_student”).AllIndices();

NEST Mapping

NEST提供了多种映射方法，这里介绍下通过Attribute自定义映射。

一、简单实现

1、定义业务需要的POCO，并指定需要的Attribute

[ElasticsearchType(Name = “student”)]

public class Student

{
[Nest.String(Index = FieldIndexOption.NotAnalyzed)]

public string Id { get; set; }

[Nest.String(Analyzer = "standard")]

public string Name { get; set; }

[Nest.String(Analyzer = "standard")]

public string Description { get; set; }

public DateTime DateTime { get; set; }
}

2、接着我们通过.AutoMap()来实现映射

var descriptor = new CreateIndexDescriptor(“db_student”)

.Settings(s => s.NumberOfShards(5).NumberOfReplicas(1))

.Mappings(ms => ms

    .Map(m => m.AutoMap())

);
client.CreateIndex(descriptor);

注意：通过.Properties()可以重写通过Attribute定义的映射

二、Attribute介绍

1、StringAttribute

2、NumberAttribute

3、BooleanAttribute

属性名值类型描述
Boost double 加权值，值越大得分越高
NullValue double 插入文档时，如果数据为NULL时的默认值

4、DateAttribute

属性名值类型描述
Boost double 加权值，值越大得分越高
NullValue string 插入文档时，如果数据为NULL时的默认值
Format string

5、ObjectAttribute

属性名值类型描述
type string/Type 构造函数参数，指定当前属性的类型T
Dynamic DynamicMapping

NEST Search

NEST提供了支持Lambda链式query DLS（领域特定语言）方式，以下是简单实现及各个query的简述。

一、简单实现

1、定义SearchDescriptor，方便项目中复杂业务的实现

var query = new Nest.SearchDescriptor();

var result = client.Search(x => query)

2、检索title和content中包含key，并且作者不等于“wenli”的文档

query.Query(q =>

q.Bool(b =>

    b.Must(m =>

        m.MultiMatch(t => t.Fields(f => f.Field(obj => obj.Title).Field(obj => obj.Content)).Query(key))

    )

    .MustNot(m =>

        m.QueryString(t => t.Fields(f => f.Field(obj => obj.Author)).Query("wenli"))

    )

)
);

注意：

如果Elasticsearch使用默认分词，Title和Content的attribute为[Nest.String(Analyzer = “standard”)]

如果Elasticsearch使用的是IK分词，Title和Content的attribute为[Nest.String(Analyzer = “ikmaxword”)]或者[Nest.String(Analyzer = “ik_smart”)]

Author的attribute为[Nest.String(Index = FieldIndexOption.NotAnalyzed)]，禁止使用分析器

3、过滤作者等于“wenli”的文档

query.PostFilter(x => x.Term(t => t.Field(obj => obj.Author).Value(“wenli”)));

4、过滤作者等于“wenli”或者等于“yswenli”的文档，匹配多个作者中间用空格隔开

query.PostFilter(x => x.QueryString(t => t.Fields(f => f.Field(obj => obj.Author)).Query(“wenli yswenli”)));

5、过滤数量在1~100之间的文档

query.PostFilter(x => x.Range(t => t.Field(obj => obj.Number).GreaterThanOrEquals(1).LessThanOrEquals(100)));

6、排序，按照得分倒叙排列

query.Sort(x => x.Field("_score", Nest.SortOrder.Descending));

7、定义高亮样式及字段

query.Highlight(h => h

.PreTags("")

.PostTags("")

.Fields(

    f => f.Field(obj => obj.Title),

    f => f.Field(obj => obj.Content),

    f => f.Field("_all")

)
);

8、拼装查询内容，整理数据，方便前段调用

var list = result.Hits.Select(c => new Models.ESObject()

{
Id = c.Source.Id,

Title = c.Highlights == null ? c.Source.Title : c.Highlights.Keys.Contains("title") ? string.Join("", c.Highlights["title"].Highlights) : c.Source.Title, //高亮显示的内容，一条记录中出现了几次

Content = c.Highlights == null ? c.Source.Content : c.Highlights.Keys.Contains("content") ? string.Join("", c.Highlights["content"].Highlights) : c.Source.Content, //高亮显示的内容，一条记录中出现了几次

Author = c.Source.Author,

Number = c.Source.Number,

IsDisplay = c.Source.IsDisplay,

Tags = c.Source.Tags,

Comments = c.Source.Comments,

DateTime = c.Source.DateTime,
})

二、query DSL介绍

elasticsearch.net Document

文档操作包含添加/更新文档、局部更新文档、删除文档及对应的批量操作文档方法。

一、添加/更新文档及批量操作

添加/更新单一文档

Client.Index(student);

批量添加/更新文档

var list = new List();

client.IndexMany(list);

二、局部更新单一文档及批量操作

局部更新单一文档

client.Updateobject>(“002”, upt => upt.Doc(new { Name = “wenli” }));

局部更新批量文档

var ids = new List() { “002” };

var bulkQuest = new BulkRequest() { Operations = new List() };

foreach (var v in ids)

{
var operation = new BulkUpdateOperationobject>(v);

operation.Doc = new { Name = "wenli" };

bulkQuest.Operations.Add(operation);
}

var result = client.Bulk(bulkQuest);

三、删除文档及批量操作

删除单一文档

client.Delete(“001”);

批量删除文档

var ids = new List() { “001”, “002” };

var bulkQuest = new BulkRequest() { Operations = new List() };

foreach (var v in ids)

{
bulkQuest.Operations.Add(new BulkDeleteOperation(v));
}

var result = client.Bulk(bulkQuest);

青蛙學堂 2022-08-26 14:18 发表评论

ES C# 增删改

青蛙學堂 — Wed, 10 Aug 2022 03:20:00 GMT

索引(添加)
var settings = new ConnectionSettings(new Uri("http://****:9200/")).DefaultFieldNameInferrer(name => name);
    var client = new ElasticClient(settings);

    //index、indexDocument：添加
    {
        var indexResponse1 = client.IndexDocument(new People { Id = 4, Age = 4, Name = new Name { Firstname = "wj", Lastname = "f" } });
        var indexResponse2 = client.Index(new People { Id = 4, Age = 4 }, i => i
            .Index("my_index")
            .Id(1)
            .Routing("1")
            .Refresh(Refresh.True));
        var indexResponse3 = client.IndexDocument(new People { Id = 4, Age = 4, Name = new Name { Firstname = "wj", Lastname = "f" } });
    }
删除
    //delete、deleteByQuery：删除
    {
        //删除指定id文档
        client.Delete(3, d => d.Index("index13"));
        //删除指定条件的文档
        client.DeleteByQuery(d => d.Index("index13").Query(q => q.Term("UserID", 4)));
    }
修改
    //update：修改
    {
        //Update只会修改指定的字段，如下只修改Name，其他字段不变。
        var updateResponse = client.Update<object>(2, u => u
                                    .Index("index13")
                                    .Doc(new
                                    {
                                        Name = "fan22"
                                    })
        );
    }
批量增删改
    //bulk：批量增删改
    {
        var bulkResponse = client.Bulk(b=>b
                                            .Update<object>(u=>u.Index("index13").Id(2).Doc(new { Name="fan222" }))
                                            .Delete(d=>d.Index("index13").Id(1))
                                            .Index(i=>i.Index("index13").Document(new ElasticUserModel {UserID=11,Name="fan11",Age=11,CreateTime=DateTime.Now,Handle="handle11" }))
                                       );
    }
version（乐观锁）
查询时获取文档版本号，修改时传版本号，如果相同就修改

//查询到版本号
var result = _client.Search(
    s =>
        s.Index(indexName)
            .Query(q => q.Term(tm => tm.Field(fd=>fd.State).Value(1))).Size(1)
            .Version()//结果中包含版本号
            );
foreach (var s in result.Hits)
{
    Console.WriteLine(s.Id + "  -  " + s.Version);
}

var path = new DocumentPath(1);
//更新时带上版本号如果服务端版本号与传入的版本好相同才能更新成功
var response = _client.Update(path, (p) => p
    .Index(indexName)
    .Type(typeof(TestModel5))
    .Version(2)//限制es中版本号为2时才能成功
    .Doc(new TestModel5() { Name = "测测测" + DateTime.Now })
    );

青蛙學堂 2022-08-10 11:20 发表评论

ES SEARCH 数据限制

青蛙學堂 — Thu, 14 Jul 2022 03:09:00 GMT

一般我们使用es的可视化工具来操作es

我们进入kibana的页面通过

http://ip:5601/app/kibana

在设置中找到索引管理

找到我们需要修改的索引,选择Edit settings,

添加"index.max_result_window": "1000000",

最后save就可以了

青蛙學堂 2022-07-14 11:09 发表评论

.net core 连sqlserver

青蛙學堂 — Mon, 11 Jul 2022 11:56:00 GMT

.net core使用EF core连接mssqlserver数据库
一，打开控制台
二，输入以下代码
1.Install-Package Microsoft.EntityFrameworkCore

2.Install-Package Microsoft.EntityFrameworkCore.SqlServer

3.Install-Package Microsoft.EntityFrameworkCore.Tools

4.Scaffold-DbContext “Server=.;Database=EFCore;Trusted_Connection=True;User ID=用户名;Password=密码;” Microsoft.EntityFrameworkCore.SqlServer -OutputDir 要存放实体的文件夹名称

using System.Linq;

青蛙學堂 2022-07-11 19:56 发表评论

ES ip访问

青蛙學堂 — Fri, 01 Jul 2022 06:33:00 GMT

在虚拟机安装Elasticsearch后，浏览器可以正常访问9200端口，但是在宿主机上无法通过虚拟机地址加9200端口进入，找了很多资料，说的是修改配置文件elasticsearch.yml，加上network.host: 0.0.0.0，加上这条配置后es无法启动，最后查到需要加上如下四条配置，只加一条无法启动。

network.host: 0.0.0.0 http.port: 9200 transport.host: localhost transport.tcp.port: 9300

青蛙學堂 2022-07-01 14:33 发表评论

c# Encoding.Unicode.GetBytes 转码取字符串

青蛙學堂 — Tue, 07 Jun 2022 08:34:00 GMT

  private string GetUnicodeString(byte[] buffer)
        {
            int size = 0;
            if (buffer != null && (size = buffer.Length) >= 2)
            {
                size -= size % 2; // sizeof(wchar_t)
                char[] value = new char[size / 2];
                for (int i = 0; i < size; i += 2)
                    value[i / 2] = (char)((buffer[i + 1] << 8) + buffer[i]);
                return new string(value);
            }
            return string.Empty;
        }
        public IActionResult Index()
        {



            List<byte> list = new List<byte> { 0, 8, 0, 0, 6, 1, 0, 0, 0, 8 };
            byte[] bytes = Encoding.Unicode.GetBytes("MSDTC");
            list.AddRange(BitConverter.GetBytes(bytes.Length));
            list.AddRange(bytes);

            byte[] rs = list.ToArray();
            //"000800000601000000080A0000004D005300440054004300"

            List<byte> nlist = new List<byte>();
            nlist.AddRange(rs);
            for(int i = 13; i>=0;i--)
            {
                nlist.RemoveAt(i);
            }
            rs = nlist.ToArray();
            var num = rs.Count();

            var hex = Convert.ToHexString(bytes);
            var hex1 = Convert.ToHexString(rs);

            var abc = Encoding.UTF8.GetString(bytes);
            var abc2 = Encoding.UTF8.GetString(rs);
            var ddd = abc;
            //"4D005300440054004300"

            hex = GetUnicodeString(bytes);
          var   hex2= GetUnicodeString(rs);
            string aa = hex;
            string bb = aa;
            return View();
        }

青蛙學堂 2022-06-07 16:34 发表评论

js访问.net 接口frombody form

青蛙學堂 — Mon, 09 May 2022 07:29:00 GMT

一、使用jQuery Ajax访问
（一）、表单传参( [FromForm])
数据类型：Object

ContenyType类型：application/x-www-form-urlencoded

1
var model = { name: "刘大大", age: 23, sex: true };
前台请求

var model = { name: "刘大大", age: 23, sex: true };
$.ajax({
    url: "http://localhost:9001/API/Default/FormCall",
    type: "POST",
    async: true,
    dataType: "json",
    data: model,
    contentType: "application/x-www-form-urlencoded",
    success: function (data) {
        console.log("data:");
        console.log(data);
    }
});
(二）、JSON字符串[FromBdy]
数据类型：Json

ContenyType类型：application/json

1
       var json = '{"name":"刘大大","age":23,"sex":true}';
也可以使用JSON.stringify(Object)将Object转换为JSON字符串

前端请求

var model = { name: "刘大大", age: 23, sex: true };
$.ajax({
    url: "http://localhost:9001/API/Default/BodyCall",
    type: "POST",
    async: true,
    dataType: "json",
    data: JSON.stringify(model),
    contentType: "application/json",
    success: function (data) {
        console.log("data:");
        console.log(data);
    }
});
（三）、文件上传
建立FormData对象

数据类型：FromData

ContenyType类型false, //必须false才会避开jQuery对 formdata 的默认处理 processData类型: false, //必须false才会自动加上正确的Content-Type

html

1

JS获取文件对象

var file = document.getElementById("file");
var files = file.files;
var formData = new FormData();
for (var i = 0; i < files.length; i++) {
     formData.append(files[i].name, files[i]);
}　　　　
formData.append("name", "刘大大");//可追加参数
AJAX请求

$.ajax({
           url: "http://localhost:9001/API/Default/Upload",
           type: "POST",
           async: true,
           dataType: "json",
           data: formData,
           contentType: false,
           processData: false,
           success: function (data) {
               console.log(data);
           }
       });
完整HTML源码

Welcome

Learn about building Web apps with ASP.NET Core.

　　
二、使用C#后台访问
（一）、Get访问

var url = "http://localhost:57954/API/Default/Test";
using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip }))
{
var taskResponse = client.GetAsync(url);
taskResponse.Wait();
if (taskResponse.IsCompletedSuccessfully)
{
var taskStream = taskResponse.Result.Content.ReadAsStreamAsync();
taskStream.Wait();
using (var reader = new StreamReader(taskStream.Result))
{
jsonString = reader.ReadToEnd();
}
}
}
（二）、Post访问

var url = "http://localhost:57954/API/Default/BodyCall";
var data = new {name="刘大大",age=23,sex=true };
using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip }))
{
    var jsonToSend = JsonConvert.SerializeObject(data, Formatting.None, new IsoDateTimeConverter());
    var body = new StringContent(jsonToSend, Encoding.UTF8, "application/json");
    var taskResponse = client.PostAsync(url, body);
    taskResponse.Wait();
    if (taskResponse.IsCompletedSuccessfully)
    {
        var taskStream = taskResponse.Result.Content.ReadAsStreamAsync();
        taskStream.Wait();
        using (var reader = new StreamReader(taskStream.Result))
        {
            jsonString = reader.ReadToEnd();
        }
    }
}
　　

（三）、上传文件


///

/// 上传文件
///

    ///
    [RequestSizeLimit(1_073_741_824)]
    public IActionResult Upload()
    {
        var url = "http://localhost:9001/Api/Default/Upload";

        var data = new MultipartFormDataContent();
        if (Request.HasFormContentType)
        {
            var request = Request.Form.Files;
            foreach (var item in request)
            {
                data.Add(new StreamContent(item.OpenReadStream()), item.Name, item.FileName);
            }

            foreach (var item in Request.Form)
            {
                data.Add(new StringContent(item.Value), item.Key);
            }
        }
        string jsonString = string.Empty;
        using (var client = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip }))
        {
            var taskResponse = client.PostAsync(url, data);
            taskResponse.Wait();
            if (taskResponse.IsCompletedSuccessfully)
            {
                var taskStream = taskResponse.Result.Content.ReadAsStreamAsync();
                taskStream.Wait();
                using (var reader = new StreamReader(taskStream.Result))
                {
                    jsonString = reader.ReadToEnd();
                }
            }
        }
        return new JsonResult(jsonString);
    }
　　

WebHelper

青蛙學堂 2022-05-09 15:29 发表评论

C#后台调用web接口方法

青蛙學堂 — Mon, 02 May 2022 06:44:00 GMT

.net core模拟发送post和get请求
1年前 46,320 0

string url = "http://www.xxx.com/api/postmsg";

string jsonContent = JsonConvert.SerializeObject(message);

using (var client = new HttpClient())
{
var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
//上面代码使http Content-Type 为 application/json; charset=utf-8。如果希望Content-Type为application/json，可以使用下面两行代码
//content.Headers.Remove("Content-Type"); // "{application/json; charset=utf-8}"
//content.Headers.Add("Content-Type", "application/json");

client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer");
string result = client.PostAsync(url, content).Result.Content.ReadAsStringAsync().Result;
}

以上为核心代码。

https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/http-requests?view=aspnetcore-2.2

///

/// 公共方法—— 发送http post请求 2020年6月2日11:20:42 Dennyhui
///

        /// 参数
        /// 请求地址
        /// 身份验证秘钥，可为空
        ///
        public async Task<string> Client_Post(MultipartFormDataContent formData, string requestUri, string token)
        {
            //从工厂获取请求对象
            var client = _httpClientFactory.CreateClient();
            //添加请求头
            if (!string.IsNullOrWhiteSpace(token))
            {
                client.DefaultRequestHeaders.Add("Authorization", token);
            }
            HttpResponseMessage response = client.PostAsync(requestUri, formData).Result;
            return response.Content.ReadAsStringAsync().Result;
        }

        ///

        /// 公共方法—— 发送http get 请求  2020年6月2日11:22:11  Dennyhui
        /// 最终以url参数的方式提交
        ///

        /// 参数字典,可为空
        /// 例如/api/Files/UploadFile
        ///
        public async Task<string> Client_Get(Dictionary<string, string> parameters, string requestUri, string token)
        {
            //从工厂获取请求对象
            var client = _httpClientFactory.CreateClient();
            //添加请求头
            if (!string.IsNullOrWhiteSpace(token))
            {
                client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
            }
            //拼接地址
            if (parameters != null)
            {
                var strParam = string.Join("&", parameters.Select(o => o.Key + "=" + o.Value));
                requestUri = string.Concat(requestUri, '?', strParam);
            }
            client.BaseAddress = new Uri(requestUri);
            //client.DefaultRequestHeaders.Add("Content-Type", "application/json; charset=utf-8");
            return client.GetStringAsync(requestUri).Result;
        }

****************************************************
此处内容传输都是用UTF-8编码

1、不带参数发送Post请求

///

/// 指定Post地址使用Get 方式获取全部字符串
///

        /// 请求后台地址
        ///
        public static string Post(string url)
        {
            string result = "";
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
            req.Method = "POST";
            HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
            Stream stream = resp.GetResponseStream();
            //获取内容
            using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
            {
                result = reader.ReadToEnd();
            }
            return result;
        }

2、带参数Post请求,指定键值对

///

/// 指定Post地址使用Get 方式获取全部字符串
///

    /// 请求后台地址
    ///
    public static string Post(string url,Dictionary<string,string> dic)
    {
        string result = "";
        HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
        req.Method = "POST";
        req.ContentType = "application/x-www-form-urlencoded";
        #region 添加Post 参数
        StringBuilder builder = new StringBuilder();
        int i = 0;
        foreach (var item in dic)
        {
            if (i > 0)
                builder.Append("&");
            builder.AppendFormat("{0}={1}", item.Key, item.Value);
            i++;
        }
        byte[] data = Encoding.UTF8.GetBytes(builder.ToString());
        req.ContentLength = data.Length;
        using (Stream reqStream = req.GetRequestStream())
        {
            reqStream.Write(data, 0, data.Length);
            reqStream.Close();
        }
        #endregion
        HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
        Stream stream = resp.GetResponseStream();
        //获取响应内容
        using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
        {
            result = reader.ReadToEnd();
        }
        return result;
    }

3、带参数的Post请求，指定发送字符串内容

///

/// 指定Post地址使用Get 方式获取全部字符串
///

/// 请求后台地址
/// Post提交数据内容(utf-8编码的)
///
public static string Post(string url, string content)
{
    string result = "";
    HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
    req.Method = "POST";
    req.ContentType = "application/x-www-form-urlencoded";

    #region 添加Post 参数
    byte[] data = Encoding.UTF8.GetBytes(content);
    req.ContentLength = data.Length;
    using (Stream reqStream = req.GetRequestStream())
    {
        reqStream.Write(data, 0, data.Length);
        reqStream.Close();
    }
    #endregion

    HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
    Stream stream = resp.GetResponseStream();
    //获取响应内容
    using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
    {
        result = reader.ReadToEnd();
    }
    return result;
}

转载方法：

HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create("http://fanyi.baidu.com/transcontent");
           Encoding encoding = Encoding.UTF8;
           string param = "ie=utf-8&source=txt&query=hello&t=1327829764203&token=8a7dcbacb3ed72cad9f3fb079809a127&from=auto&to=auto";
           //encoding.GetBytes(postData);
           byte[] bs = Encoding.ASCII.GetBytes(param);
           string responseData = String.Empty;
           req.Method = "POST";
           req.ContentType = "application/x-www-form-urlencoded";
           req.ContentLength = bs.Length;
           using (Stream reqStream = req.GetRequestStream())
           {
               reqStream.Write(bs, 0, bs.Length);
               reqStream.Close();
           }
           using (HttpWebResponse response = (HttpWebResponse)req.GetResponse())
           {
               using (StreamReader reader = new StreamReader(response.GetResponseStream(),encoding))
               {
                   responseData = reader.ReadToEnd().ToString();
               }
               context.Response.Write(responseData);
           }

***************************************************************

调⽤webApi接⼝通过post⽅式传递实体参数时，发现接⼝那⾥接受不到数据，查找资料后顺利解决，顺便做下学习笔记。
⼀、json格式发送
⾸先将实体序列化为json格式的字符串，然后发送，⽰例代码如下：
    Students student =new Students("1001","张三",20,"男");
string json = JsonConvert.SerializeObject(student);
string url ="http://localhost:34626/api/values";
string result = WebHelper.HttpWebRequest(url, json, Encoding.GetEncoding("utf-8"));
其中，HttpWebRequest⽅法⽰例代码如下：
publicstaticstringHttpWebRequest(string url,string parameters, Encoding encoding,int timeout =120000)
{
var request =(HttpWebRequest)WebRequest.Create(url);
        request.Timeout = timeout;
        request.CookieContainer =null;
byte[] postData = encoding.GetBytes(parameters);
        request.Method ="POST";
        request.ContentType ="application/json";
        request.ContentLength = postData.Length;
using(Stream stream = request.GetRequestStream())
{
            stream.Write(postData,0, postData.Length);
}
var response =(HttpWebResponse)request.GetResponse();
string result;
using(Stream stream = response.GetResponseStream())
{
if(stream ==null)
returnstring.Empty;
using(var reader =new StreamReader(stream, encoding))
{
                result = reader.ReadToEnd();
}
}
return result;
}
Post⽅法如下：
//POST api/values
publicstringPost(dynamicvalue)
{
return"value";
}
接收到Json字符串之后再反序列化即可。
结果如下图：
⼆、key/value形式发送
⾸先将实体转换为Dictionary类型，然后构造字符串发送，接⼝⽤实体接收，⽰例代码如下：
将实体转换为
//
Dictionary<string,object>
var dic = JsonConvert.DeserializeObjectstring,object>>(JsonConvert.SerializeObject(student));
    StringBuilder builder =new StringBuilder();
foreach(var item in dic)
{
        builder.AppendFormat("{0}={1}&", item.Key, item.Value);
}
string url ="http://localhost:34626/api/values";
string result = WebHelper.HttpWebRequest(url, builder.ToString(), Encoding.GetEncoding("utf-8"));
采⽤这种⽅式发送需要对HttpWebRequest⽅法修改⼀⾏代码，如下：
修改如下代码
//
    request.ContentType ="application/x-www-form-urlencoded";
Post接⼝⽰例如下：
//POST api/values
publicstringPost(Students value)
{
return"value";
}
结果如下图：
虽然两种⽅式都能传递，但我还是⽐较喜欢序列化为Json格式之后发送，第⼆种⽅式对付简单的实体时⽐较好⽤，但是复杂的就不太好⽤
了。
ok
--------------------------------------------------------

青蛙學堂 2022-05-02 14:44 发表评论

net core 接口参数获取

青蛙學堂 — Mon, 02 May 2022 06:21:00 GMT

一次HTTP请求，就是一次标准IO操作。请求是I，是输入；响应式O，是输出。任何web开发框架，其实都是在干这两件事：

接受请求并进行解析获取参数
根据参数进行渲染并输出响应内容
所以我们学习一个框架，我认为最首要的是知道如何从请求中获取参数。http请求携带参数的地方主要有下面几个地方：

URL
Header
Body
下面看看ASP.NET Core是如何从这几个位置获取参数的。
通过URL获取参数
通过URL传参是HTTP最最常用的办法。这里简单介绍下URL相关的知识。一个URL主要分成4个部分，以http://localhost:5000/fromurl/test?name=mjzhou&age=10为例：

http://    协议
localhost:5000    主机地址
/fromurl/test    PATH
name=mjzhou&age=10    QueryString
我们通常使用PATH跟QueryString来传递参数。新建一个MVC项目，新建一个Controller名为FromUrlController，通过几个Action来演示如何从URL上获取参数。
通过QuerySting获取参数
Request.Query对象
        // /fromurl/test?name=mjzhou
        public IActionResult Test()
        {
            var name = Request.Query["name"];
            return Content(name);
        }
Request.Query对象包含了本次请求的QueryString的键值对列表，所以可以通过它轻松获取QueryString上携带的参数。

自动参数绑定
        // /fromurl/test?name=mjzhou
        public IActionResult Test1(string name)
        {
            return Content(name);
        }
如果Action的型参的名称跟QueryString的Key一致，则MVC框架会自动帮我们绑定参数的值，不用手动获取。

        public IActionResult Test2([FromQuery(Name = "id")]string bh)
        {
            return Content(bh);
        }
如果参数绑定的名称跟QueryString的Key不一致，可以使用FromQueryAttribute强制指定绑定的Key的名称。

通过PATH获取参数
Request.Path对象
//      /fromurl/test3
        public IActionResult Test3()
        {
            var path = Request.Path;
            return Content(path);
        }
Request.Path对象包含了本次http请求的Path的原始信息，一般可以通过/来分隔，手工获取想要的参数。

自动参数绑定
//      /fromurl/Test4/mjzhou/1000
        [Route("FromUrl/test4/{name}/{id}")]
        public IActionResult Test4(string name, int id)
        {
            return Content($"{name}/{id}");
        }
Path的自动参数绑定，需要配合RouteAttribute实现，RouteAttribute主要是指定一个Path的模板，通过这个模板可以告诉路由是否匹配这个Action，另外一个就是可以告诉参数绑定，如何解析这个path实现参数绑定。

        [Route("FromUrl/test6/{name}/{id}")]
        public IActionResult Test6([FromRoute(Name ="name")]string xm, [FromRoute(Name = "id")]int bh)
        {
            return Content($"{xm}/{bh}");
        }
如果Action的型参名称跟RouteAttribute模板的中的名称不一样，那么可以使用FromRoute强制指定解析的名称。

        [HttpGet("FromUrl/test5/{name}/{id}")]
        public IActionResult Test5(string name, int id)
        {
            return Content($"{name}/{id}");
        }
HttpGetAttribute、HttpPostAttribute等attribute同样可以完成RouteAttribute的效果，而且还指定了action接受的HTTP Method的方法，可以说是加强版的RouteAttribute。

从Header上获取参数
添加一个FromHeaderController，通过几个action来演示如果从http headers上获取参数。

Request.Headers对象
        // /FromHeader/test
        public IActionResult Test()
        {
            var myName = Request.Headers["myName"];

            return Content(myName);
        }
Request.Headers是一个字典，包含了本次请求的Headers。所以我们可以通过Request.Headers对象轻松获取某个header的值。

自动参数绑定
        public IActionResult Test1([FromHeader]string myName)
        {
            return Content(myName);
        }
通过在action的型参上打上FromHeaderAttribute，可以告诉框架自动从header获取参数。

        public IActionResult Test2([FromHeader(Name = "myName")]string name)
        {
            return Content(name);
        }
如果action的型参跟header的key值不一致，可以通过FromHeaderAttribute强制指定匹配的header的key值。

从Body获取参数
我们开发的时候经常通过表单提交数据，或者通过AJAX往后台提交一个JavaScript对象，本质上这些数据都是通过HTTP的Bady提交回去的。新建一个FromBodyController控制器，通过几个Action来演示如何获取Body的参数。

Request.Body对象
        public class model1
        {
            public string NAME { get; set; }
        }

        public async Task Test()
        {
            Request.EnableBuffering();

            string body = "";
            var stream = Request.Body;
            if (stream != null)
            {
                stream.Seek(0, SeekOrigin.Begin);
                using (var reader = new StreamReader(stream, Encoding.UTF8, true, 1024, true))
                {
                    body = await reader.ReadToEndAsync();
                }
                stream.Seek(0, SeekOrigin.Begin);
            }

            var model = JsonConvert.DeserializeObject(body);

            return Content(model.NAME);
        }
Request.Body是一个Stream，保存了本次请求的body数据。所以我们只要把这个stream读出来，就能获取提交的数据。有了原始的数据，就可以通过反序列化等操作转换为模型，更简单的获取参数了。注意，ASP.NET Core想要读取这个对象，必须先调用Request.EnableBuffering()这个方法。
使用postman测试一下：
YiygVP.md.png

参数自动绑定
        public IActionResult Test1([FromBody]model1 model)
        {
            return Content(model.NAME);
        }
使用FromBodyAttribute可以把body的数据自动反序列化成型参的模型。但是请注意使用[FromBody]请求的Content-Type必须是application-json。
使用postman测试下：
Yica1e.md.png
Yicch8.md.png

        public IActionResult Test2([FromForm]model1 model)
        {
            return Content(model.NAME);
        }
使用FromFormAttribute可以把body的数据自动反序列化成型参的模型。但是请注意使用[FromForm]请求的Content-Type必须是application/x-www-form-urlencoded。
使用postman测试下：
Yigkge.md.png
YigeHI.md.png

总结
ASP.NET Core获取请求参数主要从URL，Headers，Body等位置获取。我们可以通过Request.Query、Request.Headers、Request.Body来手工获取数据。也可以通过[FromQuery]、[FromHeader]、[Frombody]等Attribute来实现参数的自动绑定。

青蛙學堂 2022-05-02 14:21 发表评论

C#后台调用web接口（GET, POST）

青蛙學堂 — Mon, 25 Apr 2022 05:51:00 GMT

测试地址：https://date.nager.at/api/v2/PublicHolidays/2020/US

1.get方法调用接口获取json文件内容
        public void GetFunction()
        {
            string serviceAddress = "http://222.111.999.444:8687/tttr/usercrd/12/b7e50cb45a?userid=9999";
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(serviceAddress);
            request.Method = "GET";
            request.ContentType = "text/html;charset=UTF-8";
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Stream myResponseStream = response.GetResponseStream();
            StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.UTF8);
            string retString = myStreamReader.ReadToEnd();
            myStreamReader.Close();
            myResponseStream.Close();
            Response.Write(retString);
        }

        2.post方法调用接口获取json文件内容
        public void PostFunction()
        {

            string serviceAddress = "http://222.111.999.444:8687/tttr/usercrd/uuu/12/dfd7e4";
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(serviceAddress);

            request.Method = "POST";
            request.ContentType = "application/json";
            string strContent = @"{ ""mmmm"": ""89e"",""nnnnnn"": ""0101943"",""kkkkkkk"": ""e8sodijf9""}";
            using (StreamWriter dataStream = new StreamWriter(request.GetRequestStream()))
            {
                dataStream.Write(strContent);
                dataStream.Close();
            }
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            string encoding = response.ContentEncoding;
            if (encoding == null || encoding.Length < 1)
            {
                encoding = "UTF-8"; //默认编码
            }
            StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(encoding));
            string retString = reader.ReadToEnd();
            //解析josn
            JObject jo = JObject.Parse(retString);
            Response.Write(jo["message"]["mmmm"].ToString());

        }

青蛙學堂 2022-04-25 13:51 发表评论

.net 后端调用接口

青蛙學堂 — Sun, 24 Apr 2022 10:25:00 GMT

public class HttpRequestDemo
{

///

        /// 请求方式 post 提交 json格式
        /// 对应的服务端接口接收 Task Login(model m)
        ///

        public void JsonFormatRequest()
        {
            //参数对象
            var data = new
            {
                platform = 1,
                userName = "xxxxxx",
                password = "xxxxxx"
            };
            //将对象参数序列化成json字符串，也可以自己手动拼接
            var jsonStr = Newtonsoft.Json.JsonConvert.SerializeObject(data);
            byte[] bs = Encoding.Default.GetBytes(jsonStr);

            HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(@"http://xxx.com/Api/User/Login");//接口地址
            req.Method = "POST"; //请求类型
            req.ContentType = "application/json";
            req.ContentLength = bs.Length;

            //获得请求流
            using (Stream reqStream = req.GetRequestStream())
            {
                //参数写入请求流
                reqStream.Write(bs, 0, bs.Length);
                reqStream.Close();
                //从返回结果流中读取返回数据
                StreamReader sr = new StreamReader(req.GetResponse().GetResponseStream(), Encoding.UTF8);
                string result = sr.ReadToEnd();
                Console.WriteLine(result);//打印返回信息结果可用Newtonsoft.Json.JsonConvert.DeserializeObject 序列化成自己想要的对象
            }

        }

        ///

        /// 请求方式 Post 提交 body 如 &name=123&xxx  方式传参
        /// 对应的服务端接收参数 Task Login([FromForm]model m)
        ///

        public void QueryBodyRequest()
        {
            //拼接的即将传入的参数对象
            var queryStr = "&phone=xxxxx&key=xxxxxx&password=xxxx&type=2";
            byte[] bs = Encoding.Default.GetBytes(queryStr);

            HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(@"http://xxx.com/account/login");//接口地址
            req.Method = "POST";
            req.ContentType = "application/x-www-form-urlencoded";
            req.ContentLength = bs.Length;

            //请求数据
            using (Stream reqStream = req.GetRequestStream())
            {
                //写入流数据
                reqStream.Write(bs, 0, bs.Length);
                reqStream.Close();
                //从返回结果流中读取数据
                StreamReader sr = new StreamReader(req.GetResponse().GetResponseStream(), Encoding.UTF8);
                string result = sr.ReadToEnd();
                Console.WriteLine(result);//打印返回信息结果可用Newtonsoft.Json.JsonConvert.DeserializeObject 序列化成自己想要的对象
            }
        }

        ///

        /// 请求方式 Post 提交 Body 方式2 效果同上方法底层也是 &name=123&xxx 方式传参
        /// 对应的服务端接收参数 Task Login([FromBody]model m)
        ///

        public void BodyFormatRequest()
        {
            try
            {
                HttpClient myHttpClient = new HttpClient();
                var url = "http://www.xxxxx.com/account/login";
                var content = new FormUrlEncodedContent(new Dictionary<string, string>() {
                      {"phone","18888888"},
                      {"key","CF6D9D9766665367700F9249AD080E9FF9D9" },
                      {"password","123123" },
                      {"type","2" },
                  });

                HttpResponseMessage response = myHttpClient.PostAsync(url, content).Result;
                var result = response.Content.ReadAsByteArrayAsync().Result;
                Console.WriteLine(Encoding.UTF8.GetString(result));
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }

青蛙學堂 2022-04-24 18:25 发表评论

.net core 使用api client 调用api

青蛙學堂 — Sun, 24 Apr 2022 09:38:00 GMT

Create Some APIs

Here I use ASP.NET Core WebAPI to creat some RESTful APIs.

[Route("api/[controller]")]
public class PersonsController : Controller
{
    // GET: api/persons
    [HttpGet]
    public IEnumerable Get()
    {
        return new List
        {
            new Person{Id = 1 , Name = "catcher wong"},
            new Person{Id = 2 , Name = "james"}
        };
    }

    // GET api/persons/5
    [HttpGet("{id}")]
    public Person Get(int id)
    {
        return new Person { Id = id, Name = "name" };
    }

    // POST api/persons
    [HttpPost]
    public Person Post([FromBody]Person person)
    {
        if (person == null) return new Person();

        return new Person { Id = person.Id, Name = person.Name };
    }

    // PUT api/persons/
    [HttpPut]
    public string Put([FromBody]int id)
    {
        return $"put {id}";
    }

    // DELETE api/persons/5
    [HttpDelete("{id}")]
    public string Delete(int id)
    {
        return $"del {id}";
    }
}
Interface Declaration

Create an interface named IPersonApiClient which inherit from IHttpApiClient.

public interface IPersonApiClient : IHttpApiClient { }
Add some methods that need to call APIs.

Every method must have a HTTP attribute that provides the request method and relative URL. The return type should be ITask.

[HttpGet("/api/persons")]
ITask> GetPersonsAsync();
A request URL can be updated dynamically using replacement blocks and parameters on the method. A replacement block is an alphanumeric string surrounded by { and }.

[HttpGet("/api/persons/{id}")]
ITask GetPersonAsync(int id);
When our requst parameters should in request body, we can use some attributes to specify the content, such as JsonContent, FormContent .etc.

[HttpPost("/api/persons")]
ITask AddPersonAsync([JsonContent]Person person);
The following code demonstrates the basic usage.

public interface IPersonApiClient : IHttpApiClient
{
    [HttpGet("/api/persons")]
    ITask> GetPersonsAsync();

    [HttpGet("/api/persons/{id}")]
    ITask GetPersonAsync(int id);

    [HttpPost("/api/persons")]
    ITask AddPersonAsync([JsonContent]Person person);

    [HttpPut("/api/persons")]
    ITask EditPersonAsync([JsonContent]int id);

    [HttpDelete("/api/persons/{id}")]
    ITask DeletePersonAsync(int id);
}
The next step is how to retrieve the response of the request.

Retrieving Response

We should create a client first. After creating , what we need to do is call the methods we declared in the interface.

//specify the config
var config = new HttpApiConfig
{
    HttpHost = new Uri("http://localhost:9999"),
};

var client = HttpApiClient.Create(config);

var persons = await client.GetPersonsAsync();

Console.WriteLine("GetPersonsAsync result:");
foreach (var item in persons)
{
    Console.WriteLine($"{item.Id}-{item.Name}");
}

var person = await client.GetPersonAsync(1000);
Console.WriteLine("GetPersonAsync result:");
Console.WriteLine($"{person.Id}-{person.Name}");


var newPerson = new Person { Id = 999, Name = "999" };
var postResult = await client.AddPersonAsync(newPerson);
Console.WriteLine("AddPersonAsync result:");
Console.WriteLine($"{postResult.Id}-{postResult.Name}");


var editResult = await client.EditPersonAsync(1);
Console.WriteLine("EditPersonAsync result:");
Console.WriteLine($"{editResult}");

var delResult = await client.DeletePersonAsync(1);
Console.WriteLine("DeletePersonAsync result:");
Console.WriteLine($"{delResult}");

青蛙學堂 2022-04-24 17:38 发表评论

.net core 调用外部api

青蛙學堂 — Sun, 24 Apr 2022 09:29:00 GMT

第三方 API 概览
我们将开发一个允许用户输入国家代码和年份的应用程序，然后我们将调用第三方 API 来获取该特定国家在该特定年份的公共假期列表。我们将使用的第三方 API 称为 Nager.Date，这是一个全球公共假期 API。
在这里插入图片描述
这是一个非常简单的 API，您可以通过输入以下 URL 在 Postman 中轻松测试此 API。
https://date.nager.at/api/v2/PublicHolidays/2020/US

该 API 的响应是 JSON 格式的公共假期列表，如下所示：
在这里插入图片描述

了解 HttpClient 对象
允许我们在 ASP.NET Core 应用程序中使用第三方 API 的最常见和众所周知的类是 HttpClient 类。此类使我们能够向第三方 API 发送 HTTP 请求并接收从这些 API 返回的 HTTP 响应。 HttpClient 的每个实例都维护着自己的连接池，这使得它可以将自己的请求与其他 HttpClient 实例执行的请求隔离开来。此类还充当更特定 HTTP 客户端的基类。例如，您可以创建 FacebookHttpClient 或 TwitterHttpClient 作为基本 HttpClient 的子类，并且可以使用这些特定的 HTTP 客户端与 Facebook 和 Twitter API 进行通信。

建议创建一个 HttpClient 实例并在整个应用程序生命周期中重复使用它。这是因为为每个请求实例化一个新的 HttpClient 实例很容易耗尽重负载下可用的套接字数量。这主要是因为当 HttpClient 对象被释放，底层套接字不会立即释放。您可以阅读这篇精彩的博客文章您使用 HttpClient 错误，这会破坏您的软件的稳定性，以获取有关我刚刚提到的问题的更多信息。

在 ASP.NET Core 中使用 HttpClient
正如我上面提到的，我们将创建一个应用程序，允许用户查看任何国家/地区的公共假期列表。让我们创建一个 ASP.NET Core MVC Web 应用程序并创建以下接口。这个接口只有一个 GetHolidays 方法，它有两个参数 countryCode 和 year，我们很快就会从用户那里收到。

public interface IHolidaysApiService
{
    Task> GetHolidays(string countryCode, int year);
}
上面的 GetHolidays 方法返回一个 HolidayModel 列表，它是一个模型类，具有与 Nager.Date API 的响应映射的属性。

public class HolidayModel
{
    public string Name { get; set; }
    public string LocalName { get; set; }
    public DateTime? Date { get; set; }
    public string CountryCode { get; set; }
    public bool Global { get; set; }
}
接下来，我们需要实现一个 HolidaysApiService 类，该类将实现上面声明的 IHolidaysApiService。请注意我是如何在类中声明私有和静态 HttpClient 变量的，以及它是如何在类的静态构造函数中定义的。这是 Microsoft 官方文档中提到的创建 HttpClient 实例的推荐方法。

public class HolidaysApiService : IHolidaysApiService
{
    private static readonly HttpClient client;

    static HolidaysApiService()
    {
        client = new HttpClient()
        {
            BaseAddress = new Uri("https://date.nager.at")
        };
    }
}
接下来我们需要定义 GetHolidays 方法，如下所示：

public async Task> GetHolidays(string countryCode, int year)
{
    var url = string.Format("/api/v2/PublicHolidays/{0}/{1}", year, countryCode);
    var result = new List();
    var response = await client.GetAsync(url);
    if (response.IsSuccessStatusCode)
    {
        var stringResponse = await response.Content.ReadAsStringAsync();

        result = JsonSerializer.Deserialize>(stringResponse,
            new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
    }
    else
    {
        throw new HttpRequestException(response.ReasonPhrase);
    }

    return result;
}
上面的方法发生了很多事情，所以让我详细解释一下：

第一行是构建 Nager.Date API 的 URL 并使用 year 和 countryCode 参数
var url = string.Format("/api/v2/PublicHolidays/{0}/{1}", year, countryCode);
接下来，我们将使用 GetAsync 方法进行 API 调用，该方法将 GET 请求作为异步操作发送到指定的 Uri。该方法返回 System.Net.Http.HttpResponseMessage 对象，该对象表示包含状态代码和数据的 HTTP 响应消息。
var response = await client.GetAsync(url);
接下来，我们调用 ReadAsStringAsync 方法将 HTTP 内容序列化为字符串
var stringResponse = await response.Content.ReadAsStringAsync();
最后，我们使用 JsonSerializer 将 JSON 响应字符串反序列化为 HolidayModel 对象列表。
result = JsonSerializer.Deserialize>(stringResponse,
    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
这就是我们使用第三方公共假期 API 所需的全部内容。要使用我们的 HolidaysApiService，我们需要首先在 Startup.cs 类中注册我们的服务。

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddSingleton();
}
接下来，我们可以在 HomeController 中注入我们的 HolidaysApiService 并通过传递我们将在 Index action 方法中接收的 countryCode 和 year 参数来调用 GetHolidays 方法。

public class HomeController : Controller
{
    private readonly IHolidaysApiService _holidaysApiService;

    public HomeController(IHolidaysApiService holidaysApiService)
    {
        _holidaysApiService = holidaysApiService;
    }

    public async Task Index(string countryCode, int year)
    {
        List holidays = new List();
        holidays = await _holidaysApiService.GetHolidays(countryCode, year);

        return View(holidays);
    }
}
最后，我们需要一个 Razor 视图来创建一个表单，用户将在其中输入国家代码和年份。表单将提交给上述 Index 操作，然后该操作将调用 GetHolidays 方法。这是 Index.cshtml Razor 视图的代码，显示了一个 HTML 表单和一个用于显示公共假期的表格。

@model List
@{
    ViewData["Title"] = "Home Page";
}

Public Holidays Finder

Country Code:

Year:

    @if (Model != null && Model.Count > 0)
    {

                Date
                Name
                Local Name
                Country Code
                Global



            @foreach (var item in Model)
            {

                    @item.Date.Value.ToShortDateString()
                    @Html.DisplayFor(modelItem => item.Name)
                    @Html.DisplayFor(modelItem => item.LocalName)
                    @Html.DisplayFor(modelItem => item.CountryCode)
                    @Html.DisplayFor(modelItem => item.Global)

            }


    }

现在是时候测试我们的应用程序，看看我们是否能够使用第三方 API。在 Visual Studio 中按 F5，您将看到类似于以下内容的页面。您可以输入国家代码，例如美国、德国等，以及一年，例如2021，然后单击“提交”按钮，如果一切顺利，您将看到我们的代码调用第三方 API，从 API 中获取公共假期列表并将其显示在页面上。
在这里插入图片描述

使用 IHttpClientFactory 管理 HttpClient 对象
为了使 HttpClient 实例易于管理，并避免上述套接字耗尽问题，.NET Core 2.1 引入了 IHttpClientFactory 接口，可用于通过依赖注入 (DI) 在应用程序中配置和创建 HttpClient 实例。为了使用 IHttpClientFactory，我们可以通过调用 AddHttpClient(IServiceCollection) 在 Startup.cs 文件中注册它。

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();

    services.AddSingleton();

    services.AddHttpClient("PublicHolidaysApi", c => c.BaseAddress = new Uri("https://date.nager.at"));
}
可以使用 AddHttpClient 方法注册多个具有不同名称的 HTTP 客户端。 AddHttpClient 方法的第一个参数是客户端的名称，第二个参数是将配置 HttpClient 的 Lamba 表达式。在上面的示例中，我使用要使用此特定 HTTP 客户端调用的第三方 API 的 URL 来设置 BaseAddress 属性。

一旦 HTTP 客户端被注册，我们就可以在我们的控制器和服务中注入 IHttpClientFactory 并调用它的 CreateClient 方法来创建我们想要在我们的代码中使用的特定 HTTP 客户端对象。 CreateClient 方法需要您要创建的 HTTP 客户端的名称，如下所示：

public class HolidaysApiService : IHolidaysApiService
{
    private readonly HttpClient client;

    public HolidaysApiService(IHttpClientFactory clientFactory)
    {
        client = clientFactory.CreateClient("PublicHolidaysApi");
    }

    public async Task> GetHolidays(string countryCode, int year)
    {
        var url = string.Format("/api/v2/PublicHolidays/{0}/{1}", year, countryCode);
        var result = new List();
        var response = await client.GetAsync(url);
        if (response.IsSuccessStatusCode)
        {
            var stringResponse = await response.Content.ReadAsStringAsync();

            result = JsonSerializer.Deserialize>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
        }
        else
        {
            throw new HttpRequestException(response.ReasonPhrase);
        }

        return result;
    }
}
总结概括
在本文中，我向您概述了 HttpClient，并提供了直接或使用 IHttpClientFactory 创建 HttpClient 对象的示例。我还向您展示了一个使用 HttpClient 调用第三方 Web API 的示例。希望您现在熟悉 HttpClient 对象及其用法，并且可以放心地开始在您的项目中使用它。

青蛙學堂 2022-04-24 17:29 发表评论

.net Api 接口调用增删改查

青蛙學堂 — Sun, 24 Apr 2022 09:21:00 GMT

.net Api 接口调用增删改查
.net Api项目搭建内容以前已经说过了，文章链接，这篇文章在已经搭建好项目基础上简单说下如何建立API增删改查接口。

在Models中建立一个实体类：

namespace ApiTest.Models
{
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Category { get; set; }
        public decimal Price { get; set; }
    }
}
处理数据的接口放在Models中：

namespace ApiTest.Models
{
    interface IProductRepository
    {
        IEnumerable GetAll();
        Product Get(int id);
        Product Add(Product item);
        void Remove(int id);
        bool Update(Product item);
    }
}
业务处理的接口实现类也放在Models中：

namespace ApiTest.Models
{
    public class ProductRepository:IProductRepository
    {
        private List products = new List();
        private int _nextId = 1;
        public ProductRepository()
        {
            products.Add(new Product { Id = 0, Name = "Tomato soup", Category = "Groceries", Price = 1.39M });
            products.Add(new Product { Id = 1, Name = "Yo-yo", Category = "Toys", Price = 3.75M });
            products.Add(new Product { Id = 2, Name = "Hammer", Category = "Hardware", Price = 16.99M });
        }

        public IEnumerable GetAll()
        {
            return products;
        }

        public Product Get(int id)
        {
            return products.Find(p=>p.Id==id);
        }

        public Product Add(Product item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            item.Id = _nextId++;
            products.Add(item);
            return item;
        }

        public void Remove(int id)
        {
            products.RemoveAll(p=>p.Id==id);
        }

        public bool Update(Product item)
        {
            if(item==null)
            {
                throw new ArgumentNullException("item");
            }
            int index = products.FindIndex(p=>p.Id==item.Id);
            if (index == -1)
            {
                return false;
            }
            products.RemoveAt(index);
            products.Add(item);
            return true;
        }
    }
在Controllers中新建ProductController：

//这里路由处理根据http协议
namespace ApiTest.Controllers
{
    public class ProductsController : ApiController
    {
        static readonly IProductRepository repository = new ProductRepository();

        //GET:  /api/products
        public IEnumerable GetAllProducts()
        {
            return repository.GetAll();
        }

        //GET: /api/products/id
        public Product GetProduct(int id)
        {
            Product item = repository.Get(id);
            if (item == null)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }
            return item;
        }

        //GET: /api/products?category=Groceries
        public IEnumerable GetProductsByCategory(string category)
        {
            return repository.GetAll().Where(p => string.Equals(p.Category, category, StringComparison.OrdinalIgnoreCase));
        }

        //POST: /api/products
        public HttpResponseMessage PostProduct(Product item)
        {
            item = repository.Add(item);

            var response = Request.CreateResponse(HttpStatusCode.Created, item);
            string uri = Url.Link("DefaultApi", new { id = item.Id });
            response.Headers.Location = new Uri(uri);

            return response;
        }

        //PUT: /api/products/id
        public void PutProduct(int id, Product product)
        {
            product.Id = id;
            if (!repository.Update(product))
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }
        }

        //Delete: /api/products/id
        public void DeleteProduct(int id)
        {
            Product item = repository.Get(id);
            if (item == null)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }
            repository.Remove(id);
        }
    }
在Views中的Home中修改原有的index文件：

添加记录

        Name:
        Category:
        Price:

修改记录

        Id：
        Name:
        Category:
        Price:

启动项目，进入home的index页面，这里会对Api接口进行请求操作。

青蛙學堂 2022-04-24 17:21 发表评论

Net mvc 处理json数据

青蛙學堂 — Mon, 21 Mar 2022 06:53:00 GMT

mvc 处理json数据:

@{
ViewData["Title"] = "Home Page";
}

    获取

    姓名：

    ♠
    密码：


    jieguo：

    33333333333

[HttpPost]
        public IActionResult Login([FromBody] Model7 model)
        {
            if (model != null)
            {
                string Name = model.Name;
                string password = model.Password;
                return Json(new { result = "my:" + Name + "is:" + password });
            }
            else
            {
                return Json(new { result = "it Is Null" });
            }
        }

        public class Model7
        {
            public string Name { get; set; }
            public string Password { get; set; }
        }

青蛙學堂 2022-03-21 14:53 发表评论

net webservice ajax访问

青蛙學堂 — Thu, 17 Dec 2020 08:58:00 GMT

///

///WebService 的摘要说明http://localhost:65497/
///

//[WebService(Namespace = "http://tempuri.org/")]
[WebService(Namespace = "http://localhost:65497/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
//若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消对下行的注释。
[System.Web.Script.Services.ScriptService]
public class WebService : System.Web.Services.WebService {

    public WebService () {

        //如果使用设计的组件，请取消注释以下行
        //InitializeComponent();

    }

    [WebMethod]
    public string HelloWorld() {
        Context.Response.AppendHeader("Access-Control-Allow-Methods", "OPTIONS,POST,GET");
        Context.Response.AppendHeader("Access-Control-Allow-Headers", "x-requested-with");
        Context.Response.AppendHeader("Access-Control-Allow-Origin", "*");
        return "Hello World";
    }
    [WebMethod]
    public string GetAge(string id)
    {
        Context.Response.AppendHeader("Access-Control-Allow-Methods", "OPTIONS,POST,GET");
        Context.Response.AppendHeader("Access-Control-Allow-Headers", "x-requested-with");
        Context.Response.AppendHeader("Access-Control-Allow-Origin", "*");
      Context.Response.AppendHeader("Content-type", "application/json");
        return "ID为:" + id + "的年龄为:" + new Random().Next(10, 41);
    }
}

            $(function () {
                $("#getdata").click(function () {
                    /*
                    $.ajax({
                    type: 'Post',
                    url: 'http://localhost:65497/WebSite1/WebService.asmx/GetAge?id=3344',
                    // data: '{id:"bbut101"}',
                    //  data: 'id=bbut101',
                    // dataType: 'json',
                      dataType: 'xml',
                    contentType: "application/json",
                    success: function (data) {
                    $("#data").append(data.d);
                    }
                    });
                    */
                    // alert("3333333333");

                    //  htmlobj = $.ajax({ url: "http://localhost:65497/WebSite1/WebService.asmx/GetAge", async: false });
                    //  $("#data").html(htmlobj.responseText);
                    /*
                    //  $.post("http://localhost:65497/WebSite1/WebService.asmx/GetAge",
                    {  id: "Duckburg"    },
                    function (data, status) {
                    alert("数据：" + data + "\n状态：" + status);
                    });
                    */
                    /*
                    $.ajax({
                    type: "GET",
                    contentType: "UTF-8",
                    url: "http://localhost:65497/WebSite1/WebService.asmx/GetAge?id=3322",
                    dataType: 'jsonp',
                    // dataType: 'text',
                    success: function (data) {
                    alert(data);
                    }
                    });

                    $.ajax({
                    type: "POST",
                    contentType: "application/json;charset=utf-8",
                    url: "http://localhost:65497/WebSite1/WebService.asmx/GetAge?id=44333",
                    data: "{id:12345 }",
                    dataType: 'jsonp',
                    success: function (response) {
                    alert("成功：" + response.d);
                    },
                    error: function (msg) {
                    alert("错误：" + msg);
                    }
                    })
                     */
                   // jQuery.support.cors = true; //IE10以下
                    $.ajax({
                        type: "post",
                        url: "http://localhost:65497/WebSite1/WebService.asmx/GetAge?id=44333",
                       // dataType: 'xml',
                        dataType: 'text',
                        data: { id: 'eve7777' },
                        success: function (data) {
                            alert(data); //xml对象
                           // document.write(data);
                          //  $("#data").append(data);
                        },
                        error: function (XMLHttpRequest, textStatus, errorThrown) {
                            // console.log(XMLHttpRequest);
                            alert('error:' + errorThrown);
                           // $("#data").append(errorThrown);
                        }
                    });


                });
            });


    获取dddd数据

青蛙學堂 2020-12-17 16:58 发表评论

session过期设置

青蛙學堂 — Thu, 22 Oct 2020 09:00:00 GMT

保持Session的方法：有人说设session.timeout=-1，或小于0的数。这种方法肯定是不行的，session计算时间以分钟为单位，必须是大于等于1的整数。又有人说设session.timeout=99999。这种同样不行，session有最大时间限制。我经过测试发现最大值为24小时，也就是说你最大可以session.timeout=1440，1441都是不可以有，呵呵。本人测试环境：win2003+IIS6.0+ASP3.0。

所以想通过设session.timeout的过期时间让session永不过期是不可能的。写到Cookies里是比较好的方法，网上也有很多这样的教程，这里就不再说了！还有就是用在要保持session的页里设隐藏iframe每隔一段时间（这个时间小于session.timeout的时间）把刷新一次frame里的空页面！实现方法如下：

在要保持session页里加上：

同目录下建一下SessionKeeper.asp的文件。

这种方法还是比较长见的，另外还有一种和上面类似的方法，不过他不是用meta自动刷新嵌套的iframe的方法。他是用javascript:window.setTimeout("functionname()",10000);第隔一段时间时间自动调用一个函数的方法，当然函数里还是要去连接一个空的文件。具体方法如下：

在要保持session面里加上：

function keepsession(){
document.all["Back"].src="/blog/SessionKeeper.asp?RandStr="+Math.random();
//这里的RandStr=Math.random只是为了让每次back.src的值不同，防止同一地址刷新无效的情况
window.setTimeout("keepsession()",900000); //每隔900秒调用一下本身
}
keepsession();

这样同一目录下建一个空内容的sessionKeeper.asp就文件就可以了！

青蛙學堂 2020-10-22 17:00 发表评论

Layui table 示例

青蛙學堂 — Wed, 05 Aug 2020 02:35:00 GMT

Layui table 示例

查看

编辑

删除


  {{#  if(d.auth > 2){ }}

审核
{{# } }}

青蛙學堂 2020-08-05 10:35 发表评论

Lambda表达式

青蛙學堂 — Tue, 28 Jul 2020 00:25:00 GMT

一、简介　　
　　Lambda表达式来源于数学家Alonzo Church等人在1920~1930期间发明的Lambad积分。Lambda积分是用于表示函数的一套系统，它使用希腊字母Lambda（ λ ）来表示无名函数。

　　C# 3.0引入了Lambda表达式，它是一种简化的匿名函数，可用于创建委托或表达式目录树。你也可以将 Lambda 表达式作为参数进行传递，或者将它作用于函数调用值调用后返回的一个函数来使用。

二、基础
　　它的语法形式是：输入参数 => 表达式或语句块　　即运算符的左边是输入参数(如果有)，右边是表达式或语句块。（ “ => ” 读作 “ goes to ” ）

　　

　　2.1 表达式Lambda
　　      表达式位于 => 运算符右侧的 lambda 表达式称为“表达式 lambda”。表达式 Lambda 会返回表达式的结果，并采用以下基本形式：

    (input parameters) => expression

delegate int myDel(int x,int y);    //声明委托

class Program
    {
        static void Main(string[] args)
        {
            myDel del = (x,y) =>  x+y;    //返回x+y的结果
　　　　　　　Console.WriteLine("values {0}",del(5,8)); //输出13  　　　　　 Console.ReadKey(); 　　　　　} 　　}

有关Lambda表达式的参数列表要点如下：

♥　Lambda表达式参数列表中的参数必须在参数数量、类型和位置上与委托相匹配

♥    表达式参数列表中的参数不一定需要包含类型（隐式类型），除非委托有ref或out参数----此时必须注明类型（显式类型）

♥    如果只有一个参数，并且是隐式类型的，周围的圆括号可以被省略，否则必须有括号

♥    如果没有参数，必须使用一组空的圆括号

2.2  语句Lambda
　　　　当lambda表达式中，有多个语句时，写成如下形式：

　　　　(input parameters) => {  statement； }

delegate int myDel(string str);

    class Program
    {
        static void Main(string[] args)
        {
            myDel del = (str) =>
            {
                Console.WriteLine("hello {0}",str);
                return 123;
            };
            Console.WriteLine("values {0}",del("world"));
            Console.ReadKey();
        }
    }

在C#的语法中有一种比较特殊的写法，叫做Lambda表达式，这种表达式的写法在于你查询数据的时候直接是使用以下箭头的形式来表示查询语句的：=>。例如，我们要查找学生的List集合中班级编号为1001的所有学生数据，我们即可用Studentlist.Where(t=>t.ClassCode=‘1001’)语句来直接完成，无需再写繁琐的foreach语句或者for循环。Lambda表达式的运算符即为=>。

一、Lambda表达式定义

Lambda表达式实际上是一种匿名函数，在Lambda表达式中可以包含语句以及运算等操作。并且可用于创建委托或表达式目录树类型，支持带有可绑定到委托或表达式树的输入参数的内联表达式。使用Lambda表达式可大大减少代码量，使得代码更加的优美、简洁，更有可观性。

二、Lambda表达式的表现形式

表达式形式：(Input Param)=>Expression。在表达式左侧的表示输入参数，右侧的为相应的运算语句或者判断语句等，可包含函数调用等复杂方式。运算符=>读作为goes to，例如下面这个表达t=>t.ClassCode='1001'，多做goes to ClassCode equal 1001。

在上述的表达式中，仅仅只有当参数只有一个的时候，括号是可选择的，例如下面这种含有两个参数时候的情况应该是这样子的写法

1	`(a,b)=>a==b`

　　当表达式中的多个参数编译器无法自动判断类型的时候，则需要显式指定类型。

1	`(int` `firstIndex,` `string` `str) => str.IndexOf('Hello') > firstIndex`

(1)查询班级编号为1001的班级下面的所有学生实体并返回到list1001中存储

1	`var` `list1001=Studentlist.Where(t=>t.ClassCode==‘1001’)；`

　(2)查询班级编号为1001的班级下面的所有学生实体并返回到list1001中存储，并按照学生的出生日期从小到大排列。

1	`var` `list1001=Studentlist.Where(t=>t.ClassCode==‘1001’).OrderBy(t=>t.BirthDay)；`

在此说一下，OrderBy是从小到大排序，需要从大到小排列则用OrderByDescending。

　(3)查询班级编号为1001的班级下面的姓氏为【李】的同学的所有集合，并按照学生的出生日期从小到大排列。

1	`var` `list1001=Studentlist.Where(t=>t.ClassCode==‘1001’&&t.StudentName.StartWith（“李”）).OrderBy(t=>t.BirthDay)；`

青蛙學堂 2020-07-28 08:25 发表评论

c# Mvc常用特性2

青蛙學堂 — Mon, 27 Jul 2020 05:49:00 GMT

1.[Required] : 必须输入

[Required(ErrorMessage = "请输入用户名")]

2.[StringLength] : 限制字符串长度

[StringLength(10, ErrorMessage = "长度不能超过10个字符")]

3.[Range] : 限制取值范围

[Range(0, 120, ErrorMessage = "年龄范围在0到120岁之间")]

4.[RegularExpression] : 必须符合某个正则表达式(1)直接使用RegularExpression来写表达式:

01.[RegularExpression(@"^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$", ErrorMessage = "请输入Email格式")]
02.public String RegualarExpressionField { get; set; }

青蛙學堂 2020-07-27 13:49 发表评论

c# Mvc常用特性

青蛙學堂 — Mon, 27 Jul 2020 05:38:00 GMT

介绍一些在开发中非常有用的MVC特性，如下：

BindAttribute
Remote
HandleError
HiddenInput

1.BindAttribute
使用BindAttribute的目的是限制用户在提交form表单时使用合适且正确的值。当我们提交一个表单时，就会检查每一个实体上绑定的特性。

假设我们已经有下面一个Employee实体类：

public class Employee
{
    public string Name { get; set; }
    public string Email { get; set; }
    public string Address { get; set; }
    public string PhoneNo { get; set; }
}

现在如果我们只想提交Email，Name和PhoneNo，而我们不想提交地址，这时我们可以在实体类上添加如下特性：
[Bind(Exclude="Address")]
   public class Employee
   {
       public string Name { get; set; }
       public string Email { get; set; }
       public string Address { get; set; }
       public string PhoneNo { get; set; }
   }

BindAttribute要在System.Web.Mvc命名空间下使用，使用BindAttribute，我们可以在提交表单时对字段进行一些控制。在下面的图中，我们已经在提交的form数据中得不到Address的值了。

我们也可以将BindAttribute直接用在Action的参数中，像下面这样：

public Actionresult emprigister([Bind(Exclude="Address")],Emploree emp)
{
}

2.RemoteAttribute
假设我们有一个注册表单，里面有邮箱文本框，当输入邮箱后，我们想检查输入的邮箱是否在数据库中已经存在，如果存在，则不提交表单，这时我们可以使用RemoteAttribute，通过RemoteAttribute，我们可以在不用提交表单就可以先进行一些服务端验证。

我们可以在下面的例子中使用RemoteAttribute：

public class Employee
{
    public string Name { get; set; }
    [Remote("CheckEmail","Employee",ErrorMessage="Email is already exist")]
    public string Email { get; set; }
    public string Address { get; set; }
    public string PhoneNo { get; set; }
}

RemoteAttribute的第一个参数是一个Action名字，第二个是Controller名字，第三个是如果邮箱已存在后显示给用户看的提示信息。当我们输入完邮箱后，CheckEmail方法将被执行并检查邮箱是否存在。
public JsonResult CheckEmail(string Email)
  {
      //Check here in database if it exist in database return true else false.
      return Json(false, JsonRequestBehavior.AllowGet);
  }

3.HandleError Attribute
我们已经有很多方法在MVC中处理异常，比如用try catch，或者使用Filter，或者通过第三方库比如elmah。但是MVC也提供了一个HandleErrorAttribute去处理异常，如下：

[HandleError()]
public ActionResult CheckError()
  {
     int a = 10;
     int b = 0;
     int k = a / b;
     return View();
  }

在web.config文件中，我们添加如下两行：

在shared文件夹下创建一个视图Error.cshtml，然后运行程序，如果运行上面的CheckError()方法，你刚创建的Error.cshtml将会显示出来。

我们也可以使用HandleErrorAttribute给不同类型的异常显示不同的视图页面。

[HandleError(ExceptionType=typeof(DivideByZeroException),View="DivideByZeroErrorView")]
[HandleError(ExceptionType = typeof(NullReferenceException), View = "NullRefrenceErrorView")]
public ActionResult CheckError()
       {
           int a = 10;
           int b = 0;
           int k = a / b;
           return View();
       }

4.HiddenInput Attribute
如果我们想对用户隐藏一些实体字段，我们可以使用HiddenInput特性。

public class Employee
    {
        [HiddenInput(DisplayValue=false)]
        public string Name { get; set; }
        [Remote("CheckEmail","Employee",ErrorMessage="Email is already exist")]
        public string Email { get; set; }
        public string Address { get; set; }
        public string PhoneNo { get; set; }
    }

在以上的实体中，我用HiddenInput特性去描述Name字段。这样程序运行后在浏览器中Name字段将不在显示。因此HiddenInput给我们d 在实体字段上多了一些额外的控制。

青蛙學堂 2020-07-27 13:38 发表评论

c# 抽象类和接口

青蛙學堂 — Fri, 24 Jul 2020 00:51:00 GMT

抽象类与接口紧密相关。然接口又比抽象类更抽象，这主要体现在它们的差别上：1）类可以实现无限个接口，但仅能从一个抽象（或任何其他类型）类继承，从抽象类派生的类仍可实现接口，从而得出接口是用来解决多重继承问题的。2）抽象类当中可以存在非抽象的方法，可接口不能且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。3）抽象类中的成员变量可以被不同的修饰符来修饰，可接口中的成员变量默认的都是静态常量（static final）。4）这一点也是最重要的一点本质的一点"抽象类是对象的抽象，然接口是一种行为规范"。
  以上是它们本身的异同，下面再来从实际应用讲讲它们的异同！
  不同之处:
  1、定义 
  抽象类表示该类中可能已经有一些方法的具体定义，但是接口就仅仅只能定义各个方法的界面(方法名，参数列表，返回类型)，并不关心具体细节。
  1、用法 
  1）在继承抽象类时，必须覆盖该类中的每一个抽象方法，而每个已实现的方法必须和抽象类中指定的方法一样，接收相同数目和类型的参数，具有同样的返回值，这一点与接口相同。
  2）当父类已有实际功能的方法时，该方法在子类中可以不必实现，直接引用的方法，子类也可以重写该父类的方法（继承的概念）。
  3）而实现 (implement)一个接口（interface)的时候，是一定要实现接口中所定义的所有方法，而不可遗漏任何一个。
  4）另外，抽象类不能产生对象的，但可以由它的实现类来声明对象。
  有鉴于此，在实现接口时，我们也常写一个抽象类，来实现接口中的某些子类所需的通用方法

对于C#初学者来说，abstract抽象类在网上的定义和解释说了一大堆，却往往我们忽视了为何要使用abstract类，使用它的意义在哪里。面试的时候也会有人问起使用它有什么好处，因为不适用它用自己定义的类也可以实现。那么为什么要使用抽象类？

那么我们什么时候应该用抽象类呢？
如果一个类设计的目点是用来被其它类继承的，它代表一类对象的所具有的公共属性或方法，那个这个类就应该设置为抽象类。

抽象类与其它的类有什么区别呢？
抽象类是不能够被实例化的。如果一个类中包含有抽象方法，那么这个类一定要声明为抽象类。同时，抽象方法一定需要在子类中重写，让抽象方法成为一个具体的实实在在的方法。
相信大家在网上一定看过很多这类解释了吧？好吧，不理解的我们一起来看看通俗易理解的说法吧：
比如说：我们需要创建 “狗”、“猫”、“鱼”、“马”这些对象（类），我们可以说他们有一些共同的属性像嘴巴、尾巴、重量、颜色、大小等等一些共同的属性（properties）,但是它们彼此的属性的形状是不同的（如嘴巴），在这种情况下，我们如果一个个去定义各自类似的属性是不是比较繁琐？如果用抽象类是不是很方便的给他们去继承。抽象类也有个更加好的地方，体现在“同质异像”就是实质相同实现形式不同的方法继承上，例如上面的狗、猫、马等的呼吸这个方法或者跑的速度的方法形式不同，我们这个是用定义一个抽象方法，让他们各自的类去实现它是不是很方便。“抽象”的意义正在于此。将共同的东西抽出来封装，但不实现只给继承。

青蛙學堂 2020-07-24 08:51 发表评论

c# 使用接口

青蛙學堂 — Fri, 24 Jul 2020 00:49:00 GMT

c#为什么要使用接口?通俗的讲，就是为了降低耦合度。给大家看一个我见过的很搞笑的例子。看看下面的程序：一个学校里边，有两种人：学生、老师。他们都要吃饭和睡觉。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public interface I人
{
void 吃饭();
void 睡觉();
}
public class 学生:I人
{
public void 吃饭()
      { //去食堂吃饭 }
public void 睡觉()
      { //回寝室睡觉 }
//其他特有方法，比如泡妞、打游戏
}
public class 老师:I人
{
public void 吃饭()
      { //回家吃饭 }
public void 睡觉()
      { //回家睡觉 }
//其它特有方法，比如为生儿育女传宗接代的历史使命努力等“不足为外人道也”的事情
}
public class 学校
{
public void 开饭(I人 ren)
      { ren.吃饭(); }
public void 放学(I人 ren)
      { ren.睡觉(); }
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
这里就用到了里氏代换原则，"开饭()"和"放学()"的参数都是人，那么这个地方如果换成学生和老师肯定也可以。
I人某学生 = new 学生();
某学生.开饭();
某学生.放学();
这样执行的结果就是学生回寝室吃饭。
I人某老师 = new 老师();
某老师.开饭();
某老师.放学();
这样执行的结果就是老师回家吃饭。
为什么要这样写呢？这样写有什么好处呢？我在开饭的时候完全可以直接调用“学生.吃饭();”、“老师.吃饭();”。接着看,有一天，学校里来了第三种人，家长。家长既不是去寝室睡觉也不是回家睡觉，而是旅馆睡觉，既不是去食堂吃饭也不是回家吃饭，而是去下馆子。这个时候学校这个系统该怎么处理呢？如果原来没有定义"I人"这个接口那就麻烦啦，所有用到人的地方代码都要改。现在不一样了，我可以直接定义一个类：家长，这个类实现人这个接口就可以了。好，看代码：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class 家长:I人
{
public void 吃饭()
      { //下馆子 }
public void 睡觉()
      { //去旅馆睡觉 }
//其它特有方法，比如会见老师，晓之以钱，动之以利等等，不一而足
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
在调用的时候不需要修改任何代码，还和原来一样：
I人某家长=new 家长();
某家长.开饭();
某家长.放学();
轻松搞定家长的食宿问题！这样一来学校来再多的客人都没关系啊，绝对可以应付自如，这也就是传说中的可扩展性！不知道大家看到这里是不是能够明白接口的作用。如果你还不明白，那么你把人这个接口去掉，自己写一个学校开饭和放学的类，然后再加一个家长这个新新人类进去，看看你的代码是什么样子的，再想一下在人口这么多的中国，万一哪天你的学校里来了成千上万个新新人类你该怎么办！
先声明一下，这个案例可不是我想出来的～～但是很经典，是不？
    然后我们就很好理解了，为什么用别人的东西要实现接口呢？很直接的一个原因是这样一来，编程的复杂度就可能会大大降低了，不是么？

青蛙學堂 2020-07-24 08:49 发表评论

事件和委托的区别

青蛙學堂 — Wed, 22 Jul 2020 00:40:00 GMT

前言：作为.Net攻城狮，你面试过程中是否遇到过这样的问题呢：什么是事件？事件和委托的区别？既然事件作为一种特殊的委托，那么它的优势如何体现？诸如此类…你是否也曾经被问到过？你又是否都答出来了呢？

关于面试中涉及到的事件的问题，我们只需要抓住几个关键点就好了：

（1）事件是委托的封装，可以理解为一种特殊的委托。

（2）事件里面其实就两个方法(即add_event()和remove_event())和一个私有的委托变量，这两个方法里面分别是对这个私有的委托变量进行的合并和移除，当调用事件的+=时其实是调用的事件里面的add_event()方法，同样-=调用的是remove_event()方法。

（3）事件只能够从对象外部增加新的响应方法和删除已知的响应方法，而不能主动去触发事件和获取其他注册的响应方法等信息。如果使用公有的delegate则不能做这些限制，也就是说事件对委托做了限制，使委托使用起来更加方便。也有人说事件是对委托的阉割，大概也是这个意思。

如果回答的时候抓住了以上的3点，那么我想你的面试应该不会太差。毕竟面试那么短的时间，有一两个亮点就很不错了，你说呢。哪怕你对事件机制完全不懂，为了面试记住其中两点也是很好的，工作经验咱们没有，换工作的经验可不能没有哦~~扯远了，关于面试就到此为止。如果你还想继续将事件了解透彻，别着急，慢慢往下看。

1、事件的定义及由来：

定义事件：

public delegate void MyStudyEvent(object sender, EventArgs e);
public class TestEvent
{
public event MyStudyEvent eMyStudyEvent;
}

将这段代码生成dll后，通过反编译工具reflector我们可以看到：

c# 基础事件

正如上文所说，可以看到当定义一个事件public event MyStudyEvent eMyStudyEvent的时候，编译器会自动给他生成两个方法add和remove，以及一个private的委托变量eMyStudyEvent。我们将反编译代码copy出来看看。

可以看到这两个方法的主要作用就是在向private变量eMyStudyEvent里面添加委托和移除委托。当调用事件的+=和-=时，eMyStudyEvent里面就合并和移除传过来的委托，当事件触发的时候，eMyStudyEvent变量就执行。这样设计也正好符合封装的原则，保证了内部变量的安全性。

//私有委托变量
private MyStudyEvent eMyStudyEvent;
//add方法合并委托到eMyStudyEvent里面
public void add_eMyStudyEvent(MyStudyEvent value)
{
    MyStudyEvent event3;
    MyStudyEvent eMyStudyEvent = this.eMyStudyEvent;
    do
    {
       event3 = eMyStudyEvent;
       MyStudyEvent event4 = (MyStudyEvent)System.Delegate.Combine(event3, value);
       eMyStudyEvent = Interlocked.CompareExchange(ref this.eMyStudyEvent, event4, event3)
    }
    while (eMyStudyEvent != event3);
}

//remove方法移除eMyStudyEvent里面已存在的委托
public void remove_eMyStudyEvent(MyStudyEvent value)
{
    MyStudyEvent event3;
    MyStudyEvent eMyStudyEvent = this.eMyStudyEvent;
    do
    {
        event3 = eMyStudyEvent;
        MyStudyEvent event4 = (MyStudyEvent)System.Delegate.Remove(event3, value);
        eMyStudyEvent = Interlocked.CompareExchange(ref this.eMyStudyEvent, event4, event3);
    }
    while (eMyStudyEvent != event3);
}

青蛙學堂 2020-07-22 08:40 发表评论

c# ?的作用

青蛙學堂 — Tue, 21 Jul 2020 02:26:00 GMT

之前最常用的也就是(?:)，最近遇到(?)和(??)感觉还是挺有意思的。

1、可空类型修饰符（?）
int? a = null;

对比试试
int a = null;

2、空合并运算符(??)
     用于定义可空类型和引用类型的默认值。如果此运算符的左操作数不为null，则此运算符将返回左操作数，否则返回右操作数。
       例如：a ?? b 当a为null时则返回b，a不为null时则返回a本身。

string a = null;
string b = "b";
string c = "c";
var d = a ?? b ?? c;  //"b"
3、三元（运算符）表达式（?:)
   x?y:z 表示如果表达式x为true，则返回y；如果x为false，则返回z，是省略if{}else{}的简单形式。

string a = "a";
var b = a == "a" ? "a" : "b";  //"a"
4、具体使用案例：在不报异常的情况下取为null的lst中集合的个数
            List<string> lst = null;
            var a = lst?.Count ?? 0;  //0
            var b = lst == null ? 0 : lst.Count;  //0
————————————————

青蛙學堂 2020-07-21 10:26 发表评论

c# 泛型类语法

青蛙學堂 — Tue, 21 Jul 2020 02:15:00 GMT

泛型将类型参数的概念引入 .NET，这样就可设计具有以下特征的类和方法：在客户端代码声明并初始化这些类或方法之前，这些类或方法会延迟指定一个或多个类型。例如，通过使用泛型类型参数 T，可以编写其他客户端代码能够使用的单个类，而不会产生运行时转换或装箱操作的成本或风险，如下所示：

//泛型类语法
// Declare the generic class.
public class GenericList
{
   //参数
    public void Add(T input) { }
}
class TestGenericList
{
    private class ExampleClass { }
    static void Main()
    {
        // Declare a list of type int.
        GenericList<int> list1 = new GenericList<int>();
        list1.Add(1);

        // Declare a list of type string.
        GenericList<string> list2 = new GenericList<string>();
        list2.Add("");

        // Declare a list of type ExampleClass.
        GenericList list3 = new GenericList();
        list3.Add(new ExampleClass());
    }
}

泛型类和泛型方法兼具可重用性、类型安全性和效率，这是非泛型类和非泛型方法无法实现的。泛型通常与集合以及作用于集合的方法一起使用。 System.Collections.Generic 命名空间包含几个基于泛型的集合类。非泛型集合（如 ArrayList）不建议使用，并且保留用于兼容性目的。有关详细信息，请参阅 .NET 中的泛型。

青蛙學堂 2020-07-21 10:15 发表评论

c# 泛型方法语法

青蛙學堂 — Tue, 21 Jul 2020 02:07:00 GMT

泛型方法是通过类型参数声明的方法，如下所示：
C#

static void Swap(ref T lhs, ref T rhs)
{
    T temp;
    temp = lhs;
    lhs = rhs;
    rhs = temp;
}
如下示例演示使用类型参数的 int 调用方法的一种方式：
C#

public static void TestSwap()
{
    int a = 1;
    int b = 2;

    Swap<int>(ref a, ref b);
    System.Console.WriteLine(a + " " + b);
}
还可省略类型参数，编译器将推断类型参数。如下 Swap 调用等效于之前的调用：
C#

Swap(ref a, ref b);
类型推理的相同规则适用于静态方法和实例方法。编译器可基于传入的方法参数推断类型参数；而无法仅根据约束或返回值推断类型参数。因此，类型推理不适用于不具有参数的方法。类型推理发生在编译时，之后编译器尝试解析重载的方法签名。编译器将类型推理逻辑应用于共用同一名称的所有泛型方法。在重载解决方案步骤中，编译器仅包含在其上类型推理成功的泛型方法。
在泛型类中，非泛型方法可访问类级别类型参数，如下所示：
C#

class SampleClass
{
    void Swap(ref T lhs, ref T rhs) { }
}

青蛙學堂 2020-07-21 10:07 发表评论

c# 泛型

青蛙學堂 — Tue, 21 Jul 2020 00:40:00 GMT

泛型是.NET  work 2.0 版类库就已经提供的语法，主要用于提高代码的可重用性、类型安全性和效率。

泛型的定义
下面定义了一个普通类和一个泛型类，我们可以明确看到泛型类和普通类最大的区别就是多了一个。

所以，这个就标记了，这个类是泛型类。其中这个T，也可以写成A,B,C,D或其他字符。

public class Generic
{
  public String Name;
}
public class Generic
{
  public T Name;
}
泛型，顾名思义，就是泛指的类型。好比男人，女人，白人，黑人，可以泛称为【人】。

但类型只能是一个类型。那么泛型和类型之间是什么关系呢？

其实很简单，泛型在定义的时候，是泛指类型；在使用的时候，就需要被指定，到底使用哪个类型。

即，使用时，就不在是泛指类型，而是特定类型。

好比，定义时，定义了一个人。但在使用时，必须明确指定，到底是黑人还是白人。

泛型的使用
泛型类跟普通类的使用方式一样，都需要实例化对象，再由对象来调用内部的属性或方法。

下面代码实例化了泛型Generic，实例化时，还指定了该泛型Generic的指定类型为String。

所以要给泛型Generic的属性Name赋值，就需要赋值字符串类型的值。

public static void Excute()
{
  Generic gs = new Generic();
  gs.Name = "Kiba518";
}
下面代码定义了一个Int类型的泛型Generic。

public static void Excute()
{
  Generic<int> gs = new Generic<int>();
  gs.Name = 518;
}
泛型的默认值
泛型的默认值，如下面代码所示。需要使用default(T)来赋值。

不管泛型到底是String,int,bool或者是一个Class类型，都可以被自动赋值。

public static void Excute()
{
  Generic<int> gs = new Generic<int>();
  gs.Name = 518;
  Generic gsTask = new Generic();
  gsTask.Name = new Task(()=> {
    Console.WriteLine("Kiba518");
  });
}

public class Generic
{
  public T Name = default(T);
}
泛型的约束
在泛型类中，有个特别的约束可供我们使用。

当我们不显示的声明时，这个约束不存在。但当我们显示的声明的时候，这个约束就会执行。

下面，我们来看看这个特别的约束。

public static void Excute()
{
  Generic gFanXing = new Generic();
  Generic< > gFanXing = new Generic< >();
  //Generic gs = new Generic(); 这样定义会报错
}
public class Generic where T :
{
  public T Name = default(T);
}
public class
{
  public string Name { get; set; }
}
public class FanXing :
{
  public new string Name { get; set; }
}
如上面代码所示，【where T :  】就是这个特别的约束。

当显示声明这个约束的时候，定义会限制泛型的类型。

什么是限制泛型的类型呢？

很简单，泛型T，是泛指某一个类型。我们在定义泛型类时，还需显示的指定类型，此时我们显示指定的类型，要受这个限制。

这个限制就是指【where T :  】。

它的限制是，要求我们指定的类型T必须是，或者该类型继承自，如FanXing类。

泛型的函数

在C#中，泛型不仅可以用于类，还可以直接用于函数。

具体使用方式如下：

public static void Excute()
{
  GenericFunc gf = new GenericFunc();
  gf.FanXingFunc(new FanXing() { Name="Kiba518"});
}
public class GenericFunc
{
  public void FanXingFunc(T obj)
  {
    Console.WriteLine(obj.GetType());
  }
}

//泛型方法

public T show(T sParameter)

{

return sParameter;

}

很简单，调用泛型函数的时候，指定泛型函数的[指定类型]即可。

但是，这里我们发现一个问题，那就是，在泛型函数里，使用泛型对象的时候，我们发现对象都是类型的。

那我们如果想使用泛型对象里的属性和方法时，要怎么办呢？

也很简单，反射就可以了。

下面我们添加一个反射函数GetPropertyValue，专门用来获取属性。

public class GenericFunc
{
  public void FanXingFunc(T obj)
  {
    var name = GetPropertyValue(obj, "Name");
    Console.WriteLine(name);
  }
  public  GetPropertyValue( obj, string name)
  {
     drv1 = obj.GetType().GetProperty(name).GetValue(obj, null);
    return drv1;
  }
}
输出结果如下：

这样我们就得到了我们想要的结果，如果想使用泛型类里的函数，道理也一样，只需要用反射来调用即可。

结语
看到这里，有些同学可能会觉得泛型很复杂，连使用其对象下的属性，都得反射，太繁琐了，还不如不用呢。

有这样想法的同学，心里想想就好了，如果对老司机这么说，他肯定会内心默默的微笑，然后对你说，你想的没错。

然后，你就没有然后了。

泛型的应用，开篇已经说了，主要用在提高代码的可重用性、类型安全性和效率上。

如果只是定义一个类，调用一个属性，那泛型的存在就是鸡肋。

但事实上，我们的系统永远只有更复杂，更复杂，更复杂。因此泛型才有了用武之地。

青蛙學堂 2020-07-21 08:40 发表评论

c# 字典

青蛙學堂 — Mon, 20 Jul 2020 00:54:00 GMT

1. 使用字典原因

通常情况下，我们可以通过int类型的索引号来从数组或者list集合中查询所需的数据。但是如果情况稍微复杂一点：索引号是非int型数据比如string或其他类型该如何操作呢。这个时候我们就可以使用字典了。

2. 什么是字典

顾名思义，字典是一种让我们可以通过索引号查询到特定数据的数据结构类型。

关键字 DIctionary

3. 用法及注意事项

（1） C#的Dictionary类在内部维护两个数组来实现该功能。一个keys数组容纳要从其映射的键，另一个values容纳映射到的值。在Dictionary集合中插入键/值对时，将自动记录哪

个键和哪个值关联，从而允许开发人员快速和简单地获取具有指定键的值。

（2）C#的Dictionary集合不能包含重复的键。调用Add方法添加键数组中已有的键将抛出异常。但是，如果使用方括号记法（类似给数组元素赋值）来添加键/值对，就不用担心异常——如果键已

经存在，其值就会被新值覆盖。可用ContainKey方法测试Dictionary集合是否已包含特定的键。
（3）Dictionary集合内部采用一种稀疏数据结构，在有大量内存可用时才最高效。随着更多元素的插入，Dictionary集合可能快速消耗大量内存。
（4）用foreach遍历Dictionary集合返回一个KeyValuePair。该结构包含数据项的键和值拷贝，可通过Key和Value属性防蚊每个元素。元素是只读的，不能用它们修改Dictionary集合中的数据。

青蛙學堂 2020-07-20 08:54 发表评论

c# 特性 AttributeUsage

青蛙學堂 — Fri, 17 Jul 2020 06:39:00 GMT

【AttributeUsage】自定义特性时使用

　　System.AttributeUsage声明一个Attribute的使用范围与使用原则。

　　AllowMultiple 和 Inherited 参数是可选的，所以此代码具有相同的效果：

　　AttributeTarget的值可以参考1。部分可取值如下：

　　如果 AllowMultiple 参数设置为 true，则返回特性可对单个实体应用多次。

　　如果 Inherited 设置为 false，则该特性不由从特性化的类派生的类继承。

　　Attribute.GetCustomAttribute可以获取一个类的Attribute。

[AttributeUsage(AttributeTargets.Class)]
    public class VersionAttribute : Attribute
    {
        public string Name { get; set; }
        public string Date { get; set; }
        public string Describtion { get; set; }
    }

[Version(Name = "hyddd", Date = "2009-07-20", Describtion = "hyddd's class")]
    public class MyCode
    {
        //
    }

class Program
    {
        static void Main(string[] args)
        {
            var info = typeof(MyCode);
            var classAttribute = (VersionAttribute)Attribute.GetCustomAttribute(info, typeof(VersionAttribute));
            Console.WriteLine(classAttribute.Name);
            Console.WriteLine(classAttribute.Date);
            Console.WriteLine(classAttribute.Describtion);
        }
    }

青蛙學堂 2020-07-17 14:39 发表评论

IT博客-青蛙學堂-随笔分类-c#

Elasticsearch简介

ES C# 增删改

ES SEARCH 数据限制

.net core 连sqlserver

ES ip访问

c# Encoding.Unicode.GetBytes 转码取字符串

js访问.net 接口frombody form

C#后台调用web接口方法

net core 接口参数获取

C#后台调用web接口（GET, POST）

.net 后端调用接口

.net core 使用api client 调用api

.net core 调用外部api

.net Api 接口调用 增删改查

添加记录

修改记录

Net mvc 处理json数据

net webservice ajax访问

session过期设置

Layui table 示例

Lambda表达式

c# Mvc常用特性2

c# Mvc常用特性

c# 抽象类和接口

c# 使用接口

事件和委托的区别

c# ?的作用

c# 泛型类语法

c# 泛型方法语法

c# 泛型

c# 字典

c# 特性 AttributeUsage

.net Api 接口调用增删改查