【前端】HighCharts柱形范围图

发表于 2018-06-22 分类于前端知识
本文字数： 4.8k 阅读时长 ≈ 4 分钟

效果图：

代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <div id="container" style="width: 930px; height: 400px; margin: 0 auto"></div>
</body>
<script src="http://cdn.hcharts.cn/highcharts/highcharts.js"></script>
<script src="http://cdn.hcharts.cn/highcharts/highcharts-more.js"></script>
<script src="http://cdn.hcharts.cn/highcharts/modules/exporting.js"></script>
<script src="http://cdn.hcharts.cn/highcharts-plugins/highcharts-zh_CN.js"></script>
<script>
    var MyData = [
        [9.10, 18.40],
        [9.01, 16.5],
        [9.5, 17.4],
        [9.4, 18.9],
        [10.0, 17.6],
        [9.9, 18.5],
        [9.2, 17.7],
        [8.3, 18.5],
        [9.4, 18.0],
        [9.1, 17.4],
        [9.2, 18.4],
        [11.5, 18.8]
    ];
    function GetDate(value) {
        var h = parseInt(value);
        var m = parseInt((value - parseInt(value)) * 60);
        return (h < 10 ? '0' + h : h) + "：" + (m < 10 ? '0' + m : m);
    };

    //柱状图颜色定义
    var colors=[];
    for(var i=0;i<MyData.length;i++){
        var workTime =MyData[i][1]-MyData[i][0];
        if(workTime>9){
            colors.push("#83F5C4");
        }else{
            colors.push("#F08664");
        }
    }
    Highcharts.setOptions({
        colors:colors
    });
    var chart = Highcharts.chart('container', {
        chart: {
            type: 'columnrange',
            zoomType: 'xy'
        },
        title: {
            text: '数据记录'
        },
        subtitle: {
            text: '2018/06'
        },
        xAxis: {
            crosshair: true,
            categories: ['06/01', '06/02', '06/03', '06/04', '06/05', '06/06', '06/07', '06/08', '06/09', '06/10', '06/11', '06/12']
        },
        yAxis: [{
            title: {
                text: '打卡时间 ( H )'
            },
            plotLines: [{
                color: 'red',
                dashStyle: 'longdashdot',
                value: 9,
                width: 2,
                label: {
                    text: '上班时间',
                    align: 'left',
                    x: -60,
                    y: 5
                }
            }, {
                color: 'red',
                dashStyle: 'longdashdot',
                value: 18,
                width: 2,
                label: {
                    text: '下班时间',
                    align: 'left',
                    x: -60,
                }
            }],
        }],
        tooltip: {
            formatter: function () {
                return '<b>日期：' + this.x + '</b><br/>' +
                    '上班时间' + ': ' + GetDate(this.point.low) + '<br/>' +
                    '下班时间' + ': ' + GetDate(this.point.high) + '<br/>' +
                    '工作时长: ' + (this.point.high - this.point.low).toFixed(2)+'H';
            }
        },
        plotOptions: {
            column: {
                colorByPoint: true
            },
            columnrange: {
                dataLabels: {
                    enabled: true,
                    formatter: function () {
                        return GetDate(this.y);
                    }
                }
            }
        },
        legend: {
            enabled: false
        },
        series: [{
            colorByPoint: true, 
            name: '打卡时间',
            yAxis: 0,
            data: MyData
        }]
    });
</script>
</html>

效果图：

代码：

var chart = Highcharts.chart('container', {
	chart: {
		type: 'columnrange', // columnrange 依赖 highcharts-more.js
		zoomType: 'xy',
	},
	title: {
		text: '每月温度变化范围'
	},
	subtitle: {
		text: '2009 挪威某地'
	},
	xAxis: {
		categories: ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月']
	},
	yAxis: {
		title: {
			text: '温度 ( °C )'
		}
	},
	plotOptions: {
		columnrange: {
			stacking: 'normal'
		},
	},
	tooltip: {
		formatter: function () {
			return '<b>Date：' + this.x + '</b><br/>' +
				'On work time' + ': ' + (this.point.low) + '<br/>' +
				'Off work time' + ': ' + (this.point.high) + '<br/>' +
				'Length of work: ' + ((this.point.high - this.point.low).toFixed(2));
		}
	},
	series: [{
		name: '温度',
		data: [{
			low: 2,
			high: 9.4,
			color: "#83F5C4"
		}, {
			low: 5,
			high: 6.6,
			color: "#83F5C4"
		}, {
			low: 7.8,
			high: 9.5,
			color: "#83F5C4"
		}, {
			low: 6,
			high: 20.0,
			color: "#83F5C4"
		}],
		stack: 'male',
	},{
		name: 'XXX',
		data: [
			[9.4,12],
			[ 6.6,12],
			[ 9.5,12],
			[20.0,22]
		],
		stack: 'male',
		color: '#FF0000'
	}]
});

【.Net】几种常用的加密方式

发表于 2018-06-11 分类于编程路上
本文字数： 8.5k 阅读时长 ≈ 8 分钟

一、AES加密算法

AES算法基于排列和置换运算。排列是对数据重新进行安排，置换是将一个数据单元替换为另一个。AES 使用几种不同的方法来执行排列和置换运算。
AES是一个迭代的、对称密钥分组的密码，它可以使用128、192 和 256 位密钥，并且用 128 位（16字节）分组加密和解密数据。与公共密钥密码使用密钥对不同，对称密钥密码使用相同的密钥加密和解密数据。通过分组密码返回的加密数据的位数与输入数据相同。迭代加密使用一个循环结构，在该循环中重复置换和替换输入数据。摘自：互动百科

几种模式的优缺点对比：

C#代码：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace PwdDemo
{
    public class AESHelper
    {
        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public string AesEncrypt(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

            ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
            return Convert.ToBase64String(resultArray);
        }

        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="str">明文（待解密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public string AesDecrypt(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Convert.FromBase64String(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

            ICryptoTransform cTransform = rm.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Encoding.UTF8.GetString(resultArray);
        }
    }
}

二、DES加密算法

DES设计中使用了分组密码设计的两个原则：混淆（confusion）和扩散(diffusion)，其目的是抗击敌手对密码系统的统计分析。混淆是使密文的统计特性与密钥的取值之间的关系尽可能复杂化，以使密钥和明文以及密文之间的依赖性对密码分析者来说是无法利用的。扩散的作用就是将每一位明文的影响尽可能迅速地作用到较多的输出密文位中，以便在大量的密文中消除明文的统计结构，并且使每一位密钥的影响尽可能迅速地扩展到较多的密文位中，以防对密钥进行逐段破译。

C#代码：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace PwdDemo
{
    public class DESHelper
    {
        //密钥
        public static byte[] _KEY  = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        //向量
        public static byte[] _IV = new byte[] { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 };   

        /// <summary>
        /// DES加密操作
        /// </summary>
        /// <param name="normalTxt"></param>
        /// <returns></returns>
        public string DesEncrypt(string normalTxt)
        {
            //byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(_KEY);
            //byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(_IV);
            
            DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
            int i = cryptoProvider.KeySize;
            MemoryStream ms = new MemoryStream();
            CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(_KEY, _IV), CryptoStreamMode.Write);

            StreamWriter sw = new StreamWriter(cst);
            sw.Write(normalTxt);
            sw.Flush();
            cst.FlushFinalBlock();
            sw.Flush();

            string strRet = Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
            return strRet;
        }

        /// <summary>
        /// DES解密操作
        /// </summary>
        /// <param name="securityTxt">加密字符串</param>
        /// <returns></returns>
        public string DesDecrypt(string securityTxt)//解密  
        {
            //byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(_KEY);
            //byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(_IV);
            byte[] byEnc;
            try
            {
                securityTxt.Replace("_%_", "/");
                securityTxt.Replace("-%-", "#");
                byEnc = Convert.FromBase64String(securityTxt);
            }
            catch
            {
                return null;
            }
            DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
            MemoryStream ms = new MemoryStream(byEnc);
            CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(_KEY, _IV), CryptoStreamMode.Read);
            StreamReader sr = new StreamReader(cst);
            return sr.ReadToEnd();
        }
    }
}

三、RSA加密算法

RSA是第一个能同时用于加密和数字签名的算法，也易于理解和操作。RSA是被研究得最广泛的公钥算法，从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。

C#代码：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace PwdDemo
{
   public class RSAHelper
    {
        private const int RsaKeySize = 2048;
        private const string publicKeyFileName = "RSA.Pub";
        private const string privateKeyFileName = "RSA.Private";

        /// <summary>
        ///在给定路径中生成XML格式的私钥和公钥。
        /// </summary>
        public void GenerateKeys(string path)
        {
            using (var rsa = new RSACryptoServiceProvider(RsaKeySize))
            {
                try
                {
                    // 获取私钥和公钥。
                    var publicKey = rsa.ToXmlString(false);
                    var privateKey = rsa.ToXmlString(true);

                    // 保存到磁盘
                    File.WriteAllText(Path.Combine(path, publicKeyFileName), publicKey);
                    File.WriteAllText(Path.Combine(path, privateKeyFileName), privateKey);

                    //Console.WriteLine(string.Format("生成的RSA密钥的路径: {0}\\ [{1}, {2}]", path, publicKeyFileName, privateKeyFileName));
                }
                finally
                {
                    rsa.PersistKeyInCsp = false;
                }
            }
        }

        /// <summary>
        /// 用给定路径的RSA公钥文件加密纯文本。
        /// </summary>
        /// <param name="plainText">要加密的文本</param>
        /// <param name="pathToPublicKey">用于加密的公钥路径.</param>
        /// <returns>表示加密数据的64位编码字符串.</returns>
        public string Encrypt(string plainText, string pathToPublicKey)
        {
            using (var rsa = new RSACryptoServiceProvider(RsaKeySize))
            {
                try
                {
                    //加载公钥
                    var publicXmlKey = File.ReadAllText(pathToPublicKey);
                    rsa.FromXmlString(publicXmlKey);

                    var bytesToEncrypt = System.Text.Encoding.Unicode.GetBytes(plainText);

                    var bytesEncrypted = rsa.Encrypt(bytesToEncrypt, false);

                    return Convert.ToBase64String(bytesEncrypted);
                }
                finally
                {
                    rsa.PersistKeyInCsp = false;
                }
            }
        }

        /// <summary>
        /// Decrypts encrypted text given a RSA private key file path.给定路径的RSA私钥文件解密 加密文本
        /// </summary>
        /// <param name="encryptedText">加密的密文</param>
        /// <param name="pathToPrivateKey">用于加密的私钥路径.</param>
        /// <returns>未加密数据的字符串</returns>
        public string Decrypt(string encryptedText, string pathToPrivateKey)
        {
            using (var rsa = new RSACryptoServiceProvider(RsaKeySize))
            {
                try
                {
                    var privateXmlKey = File.ReadAllText(pathToPrivateKey);
                    rsa.FromXmlString(privateXmlKey);

                    var bytesEncrypted = Convert.FromBase64String(encryptedText);

                    var bytesPlainText = rsa.Decrypt(bytesEncrypted, false);

                    return System.Text.Encoding.Unicode.GetString(bytesPlainText);
                }
                finally
                {
                    rsa.PersistKeyInCsp = false;
                }
            }
        }
    }
}

四、SHA加密算法

SHA，全称SecureHashAlgorithm，是一种数据加密算法，该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。

C#代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace PwdDemo
{
    public class SHAHelper
    {
        public string SHAmd5Encrypt(string normalTxt)
        {
            var bytes = Encoding.Default.GetBytes(normalTxt);//求Byte[]数组  
            var Md5 = new MD5CryptoServiceProvider();
            var encryptbytes = Md5.ComputeHash(bytes);//求哈希值  
            return Base64To16(encryptbytes);//将Byte[]数组转为净荷明文(其实就是字符串)  
        }

        public string SHA1Encrypt(string normalTxt)
        {
            var bytes = Encoding.Default.GetBytes(normalTxt);
            var SHA = new SHA1CryptoServiceProvider();
            var encryptbytes = SHA.ComputeHash(bytes);
            return Base64To16(encryptbytes);
        }
        public string SHA256Encrypt(string normalTxt)
        {
            var bytes = Encoding.Default.GetBytes(normalTxt);
            var SHA256 = new SHA256CryptoServiceProvider();
            var encryptbytes = SHA256.ComputeHash(bytes);
            return Base64To16(encryptbytes);
        }
        public string SHA384Encrypt(string normalTxt)
        {
            var bytes = Encoding.Default.GetBytes(normalTxt);
            var SHA384 = new SHA384CryptoServiceProvider();
            var encryptbytes = SHA384.ComputeHash(bytes);
            return Base64To16(encryptbytes);
        }
        public string SHA512Encrypt(string normalTxt)
        {
            var bytes = Encoding.Default.GetBytes(normalTxt);
            var SHA512 = new SHA512CryptoServiceProvider();
            var encryptbytes = SHA512.ComputeHash(bytes);
            return Base64To16(encryptbytes);
        }


        private string Base64To16(byte[] buffer)
        {
            string md_str = string.Empty;
            for (int i = 0; i < buffer.Length; i++)
            {
                md_str += buffer[i].ToString("x2");
            }
            return md_str;
        }
    }
}

以上内容大部分摘自网络，代码根据网上的改的，简单测试过。

【Asp.Net】WebApi接口返回值返回值类型详解

发表于 2018-06-10 分类于编程路上
本文字数： 8.9k 阅读时长 ≈ 8 分钟

最开头，说明下文章转自：

http://www.cnblogs.com/landeanfen/p/5501487.html 点击打开链接

欢迎直接去看原创文章，原创比较精彩，这里只做个搬运工作！

使用过Webapi的园友应该都知道，Webapi的接口返回值主要有四种类型

void无返回值
IHttpActionResult
HttpResponseMessage
自定义类型此篇就围绕这四块分别来看看它们的使用。

回到顶部

一、void无返回值

void关键字我们都不陌生，它申明方法没有返回值。它的使用也很简单，我们来看一个示例就能明白。

public class ORDER
{
    public string ID { get; set; }

    public string NO { get; set; }

    public string NAME { get; set; }

    public string DESC { get; set; }
}

public class OrderController : ApiController
{
    [HttpPost]
    public void SaveOrder(ORDER name)
    { 
        //处理业务逻辑

    }
}

在Web里面调用

$(function () {
    $.ajax({
        type: 'post',
        url: 'http://localhost:21528/api/Order/SaveOrder',
        data: { ID: "aaa", NAME: "test" },
        success: function (data, status) {
            alert(data);
        }
    });
});

得到结果

可以看到，使用void申明的方法，在success方法里面得不到返回值，并且会返回http状态码204，告诉客户端此请求没有返回值。

二、IHttpActionResult

IHttpActionResult类型是WebApi里面非常重要的一种返回值类型。下面博主就根据平时在项目里面使用最多的几种方式来讲解下这种类型的返回值的一些用法。

1、Json(T content)

使用MVC开发过的朋友一定记得，在MVC里面，请求数据的接口的返回值类型大部分使用的是JsonResult，在MVC里面你一定也写过类似这样的接口：

public JsonResult GetResult()
{
    return Json(new { }, JsonRequestBehavior.AllowGet);
}

那么，在WebAPI里面是否也存在类似的用法呢。呵呵，在这点上面，微软总是贴心的。在WebApi的ApiController这个抽象类里面，为我们封装了Json(T content)这个方法，它的用法和MVC里面的JsonResult基本类似。我们通过一个例子来说明它的用法：

[HttpGet]
public IHttpActionResult GetOrder()
{
    var lstRes = new List<ORDER>(); 

    //实际项目中，通过后台取到集合赋值给lstRes变量。这里只是测试。
    lstRes.Add(new ORDER() { ID = "aaaa", NO = "111", NAME = "111", DESC = "1111" });
    lstRes.Add(new ORDER() { ID = "bbbb", NO = "222", NAME = "222", DESC = "2222" });

    return Json<List<ORDER>>(lstRes);
}

看到这个代码，有人就疑惑了，我们定义的返回值类型是IHttpActionResult类型，直接返回Json(T content)这样可行么？我们将Json转到定义看看：

1	protected internal JsonResult<T> Json<T>(T content);

我们继续将JsonResult转到定义

原来JsonResult是实现了IHttpActionResult接口的，难怪可以直接返回呢。

知道了这个，我们直接在Web里面通过ajax请求来调用：

$(function () {
    $.ajax({
        type: 'get',
        url: 'http://localhost:21528/api/Order/GetOrder',
        data: {},
        success: function (data, status) {
            alert(data);
        }
    });
});

来看结果：

既然实体类可以直接这样传递，那么如果我们想要传递一些匿名类型呢，因为很多情况下，我们需要返回到前端的对象都没有对应的实体来对应，如果我们想要返回匿名对象怎么办呢？我们知道，这里的Json(T content)必须要传一个对应的泛型类型，如果是匿名类型这里肯定不好传。还好有我们的object类型，当然你可以使用dynamic，我们来试一把。

[HttpGet]
public IHttpActionResult GetOrder()
{
    
    return Json<dynamic>(new { AA = "", BB = "cc" });
}

同样的来看测试结果：

2、Ok()、 Ok(T content)

除了Json(T content)，在ApiController里面还有另外一个比较常用的方法：Ok()。同样，我们将Ok()转到定义

1	protected internal virtual OkResult Ok();

OkResult转到定义

有了这个作为基础，我们就可以放心大胆的使用了。

[HttpGet]
public IHttpActionResult GetOKResult()
{
    return Ok();
}

得到结果

如果返回Ok()，就表示不向客户端返回任何信息，只告诉客户端请求成功。

除了Ok()之外，还有另外一个重载Ok(T content)。

[HttpGet]
public IHttpActionResult GetOKResult(string name)
{
    return Ok<string>(name);
}

这种用法和Json(T content)比较类似，如果你非要问这两者有什么区别，或者说怎么选择两者。那么我的理解是如果是返回实体或者实体集合，建议使用Json(T content)，如果是返回基础类型（如int、string等），使用Ok(T content)。

3、NotFound()

当需要向客户端返回找不到记录时，有时需要用到NotFound()方法。

1	protected internal virtual NotFoundResult NotFound();

来看看它的使用场景

[HttpGet]
public IHttpActionResult GetNotFoundResult(string id)
{
    var lstRes = new List<ORDER>();

    //实际项目中，通过后台取到集合赋值给lstRes变量。这里只是测试。
    lstRes.Add(new ORDER() { ID = "aaaa", NO = "111", NAME = "111", DESC = "1111" });
    lstRes.Add(new ORDER() { ID = "bbbb", NO = "222", NAME = "222", DESC = "2222" });
    var oFind = lstRes.FirstOrDefault(x => x.ID == id) ;
    if (oFind == null)
    {
        return NotFound();
    }
    else
    {
        return Json<ORDER>(oFind);
    }
}

$(function () {
    $.ajax({
        type: 'get',
        url: 'http://localhost:21528/api/Order/GetNotFoundResult',
        data: { id :"cccc" },
        success: function (data, status) {
            alert(data);
        }
    });
});

得到结果

NotFound()方法会返回一个404的错误到客户端。

4、其他

其他还有一些方法，都有它特定的用途。在此贴出来。

4.1、Content(HttpStatusCode statusCode, T value)

[HttpGet]
public IHttpActionResult GetContentResult()
{
    return Content<string>(HttpStatusCode.OK, "OK");
}

向客户端返回值和http状态码。

4.2、BadRequest()

[HttpGet]
public IHttpActionResult GetBadRequest(ORDER order)
{
    if (string.IsNullOrEmpty(order.ID))
        return BadRequest();
    return Ok();
}

向客户端返回400的http错误。

4.3、Redirect(string location)

[HttpGet]
public IHttpActionResult RedirectResult()
{
    return Redirect("http://localhost:21528/api/Order/GetContentResult");
}

将请求重定向到其他地方。

5、自定义IHttpActionResult接口的实现

上面介绍了一些系统内置的常用的实现IHttpActionResult接口的方法。如果我们需要自定义IHttpActionResult的返回呢？

在介绍之前，我们有必要先来看看IHttpActionResult类型的定义，将IHttpActionResult转到定义可以看到：

namespace System.Web.Http
{
    // 摘要: 
    //     Defines a command that asynchronously creates an System.Net.Http.HttpResponseMessage.
    public interface IHttpActionResult
    {
        // 摘要: 
        //     Creates an System.Net.Http.HttpResponseMessage asynchronously.
        //
        // 参数: 
        //   cancellationToken:
        //     The token to monitor for cancellation requests.
        //
        // 返回结果: 
        //     A task that, when completed, contains the System.Net.Http.HttpResponseMessage.
        Task<System.Net.Http.HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken);
    }
}

这个接口包含唯一的一个方法ExecuteAsync()，此方法将以异步方式创建一个HttpResponseMessage实例返回给客户端。

有了这个作为基础，下面，我们自定义一个bootstrapTable服务端分页的子类去展示自定义IHttpActionResult的用法。

首先，自定义一个实现类

public class PageResult : IHttpActionResult
{
    object _value;
    HttpRequestMessage _request;

    public PageResult(object value, HttpRequestMessage request)
    {
        _value = value;
        _request = request;
    }

    public Task<HttpResponseMessage> ExecuteAsync(System.Threading.CancellationToken cancellationToken)
    {
        var response = new HttpResponseMessage()
        {
            Content = new ObjectContent(typeof(object), _value, new JsonMediaTypeFormatter()),
            RequestMessage = _request
        };
        return Task.FromResult(response);
    }
}

然后，在API接口里面返回PageResult对象

[HttpGet]
public IHttpActionResult GetPageRow(int limit, int offset)
{
    var lstRes = new List<ORDER>();

    //实际项目中，通过后台取到集合赋值给lstRes变量。这里只是测试。
    lstRes.Add(new ORDER() { ID = "aaaa", NO = "111", NAME = "111", DESC = "1111" });
    lstRes.Add(new ORDER() { ID = "bbbb", NO = "222", NAME = "222", DESC = "2222" });

    var oData = new { total = lstRes.Count, rows = lstRes.Skip(offset).Take(limit).ToList() };
    return new PageResult(oData, Request);
}

最好，ajax调用

$(function () {
    $.ajax({
        type: 'get',
        url: 'http://localhost:21528/api/Order/GetPageRow',
        data: { limit:1,offset:1},
        success: function (data, status) {
            alert(data);
        }
    });
});

得到结果

三、HttpResponseMessage

在上文自定义IHttpActionResult返回类型的时候，提到过HttpResponseMessage这个对象。它表示向客户端返回一个http响应的消息对象（包含http状态码和需要返回客户端的消息）。这个对象也有它独特的使用场景：需要向客户端返回HttpResponse时就要用到这个对象。以导出为例，由于需要将导出的Excel文件输出到客户端浏览器，Webapi的服务端需要向Web的客户端输出文件流，这个时候一般的IHttpActionResult对象不方便解决这个问题，于是HttpReponseMessage派上了用场。我们来看看它的使用示例。

　　　　public HttpResponseMessage Export()
{
    //取数据
    var lstRes = OrderBLL.Export();

    //向Excel里面填充数据
    HSSFWorkbook workbook = new HSSFWorkbook();
    CreateAndFillSheet(workbook, lstRes);
    
    //保存到服务
    var fileName = "Excel" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".xls";
    var strPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Data\" + fileName);
    using (FileStream fs = new FileStream(strPath, FileMode.Create))
    {
        workbook.Write(fs);
        using (MemoryStream ms = new MemoryStream())
        {
            workbook.Write(ms);
        }
    }

    //输出到浏览器
    try
    {
        var stream = new FileStream(strPath, FileMode.Open);
        HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
        response.Content = new StreamContent(stream);
        response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
        response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
        {
            FileName = fileName
        };

        return response;
    }
    catch
    {
        return new HttpResponseMessage(HttpStatusCode.NoContent);
    }
}

将文件流保存在StreamContent对象里面，然后输出到浏览器。在浏览器端即可将Excel输出。

四、自定义类型

以上几种返回值类型能解决我们大部分返回值的问题，当然，你也可以将webapi的接口和普通方法一样，返回任意的类型，WebApi会自动序列化你自定义任何返回类型，然后将序列化的值写到响应正文里，状态码统一返回200。比如：

[HttpGet]
public object GetOther()
{
    var lstRes = new List<ORDER>();

    //实际项目中，通过后台取到集合赋值给lstRes变量。这里只是测试。
    lstRes.Add(new ORDER() { ID = "aaaa", NO = "111", NAME = "111", DESC = "1111" });
    lstRes.Add(new ORDER() { ID = "bbbb", NO = "222", NAME = "222", DESC = "2222" });

    return lstRes;
}

得到结果

和上面的Json、Ok等用法在效果上面没有太大区别。

五、总结

以上通过四个方面详细分享了下WebApi里面返回值的常见用法，不能说哪种方式最好，因为每种方式都有其特定的使用场景。博主觉得为了规范WebApi接口，对于一般接口的返回值，尽量使用IHttpActionResult类型作为返回值，毕竟是微软内置的东西，可能为我们考虑了很多我们考虑不到的东西。当然，你可能会觉得麻烦，你可能会说直接和普通方法一样来使用不是更爽，博主当初也有这种想法，可是学习微软的东西多了之后发现很多东西还是遵守一定的标准比较好，至少维护起来方便。这就像博主最近正在努力学习的WebApi+oData一样，为什么要搞这么一套标准性的东西，还不是为了更加方便地规范Restful风格。如果本文能帮到你，不妨推荐下，您的推荐是博主继续总结的动力！