接口通信组件

前言

框架中HTTP网络请求使用了微软公司开发的 System.Net.Http.HttpClient 组件。

System.Net.Http.HttpClient 是微软推出的最新的 HTTP 应用程序的编程接口，微软称之为“现代化的 HTTP 编程接口”，命名空间 System.Net.Http 以及 System.Net.Http.Headers 提供了如下内容：

1. HttpClient 发送和接收 HTTP 请求与响应;
2. HttpRequestMessage 和 HttpResponseMessage 封装了 RFC 2616 定义的 HTTP 消息；
3. HttpHeaders 封装了 RFC 2616 定义的 HTTP 标头；
4. HttpClientHandler 负责生成HTTP响应消息的HTTP处理程序。

组件介绍

框架中的 XCI.Core.WebApi 组件对 HttpClient 组件进行了适当的封装，以方便接口调用以及数据提交。

WebApi 组件功能上对文件的上传和下载进行了单独的封装，用起来更加简便。从请求方法上分为：GET 和 POST，每种请求方法从返回值又分为：返回字符串、返回通用消息对象、返回泛型消息对象。而POST方法从提交数据上分为：提交键值对数据、提交JSON字符串数据。

最佳实践：推荐的使用方**式是WebApi组**件针对一个服务器只需要创建一个实例，即单例模式，每个方法都是线程安全的，并不需要创建多个WebApi实例。

预定义规则

组件中的每个方法都有两个共同的参数：接口请求地址(url)、提交的数据(data)。针对这两个参数有预定义规则。

接口请求地址

接口请求地址由两部分组成：基地址和接口地址两部分组成。例如：http://localhost:6070/api/sys/system/ping，其中基地址是http://localhost:6070，接口地址是`/api/sys/system/ping`。而通常情况下，我们调用的绝大多数接口的基地址是一样的，所以我们调用的时候只需要传递接口地址，而基地址在组件初始化的时候通过构造函数传入即可。如果部分接口的基地址不一致，我们可以传入完整的接口请求地址，比如：`http://www.icoc.group/api/sys/system/name`，由于传入的地址是一个完整的http地址，所以此时会忽略构造函数中传递的基地址。

//构建通讯对象
WebApi api = new WebApi("http://localhost:6070", TimeSpan.FromSeconds(10), false);
api.Get("/api/sys/system/ping");//正确
api.Get("api/sys/system/ping");//正确
api.Get("http://localhost:6070/api/sys/system/ping");//正确
api.Get("http://www.icoc.group/api/sys/system/name");//正确

最佳实践：推荐的使用方式是在构造函数中传递服务基地址，在接口调用时只写接口地址，并且接口地址以 **/** 开头。

提交的数据

在每个函数中都有一个data参数，所有的data参数都是可选项，data参数是object，目前支持的类型：

1. 实现了接口 IDictionary<string,object> 的集合对象。
2. 普通C#类，通过反射机制，读取实例的属性和属性值放入一个字典集合中，其中属性名称作为字典键，属性值作为字典值。
3. 如果以JSON方式提交的话会把data参数序列化为字符串提交。

构造函数

构造函数中主要有三个参数：

1. baseUrl 字符串类型，指定服务基地址，例如：http://localhost:6070
2. timeout 时间间隔类型，指定请求超时间隔，例如：TimeSpan.FromSeconds(10) 10秒
3. bool useProxy 布尔类型，指定是否使用代理，如果要使用调试工具，必须设置为true，发布时设置为false，可以加快接口调用。

也有其他重载的构造函数，也可以在对象创建完成后，通过实例方法单独设置参数

• SetBaseUrl 设置服务基地址
• SetTimeout 设置请求超时间隔

GET方法

//从返回值分为：返回字符串、返回通用消息对象、返回泛型消息对象
public string Get(string url, object data = null) //Get请求返回字符串
public BoolMessage<T> Get<T>(string url, object data = null)  //Get请求返回泛型消息对象
public BoolMessage GetAsMessage(string url, object data = null) //Get请求返回通用消息对象

POST方法

从提交数据上分为：提交键值对数据、提交JSON字符串数据

1. 提交键值对数据

//从返回值分为：返回字符串、返回通用消息对象、返回泛型消息对象
public string Post(string url, object data = null) //Post请求返回字符串
public BoolMessage<T> Post<T>(string url, object data = null) //Post请求返回泛型消息对象
public BoolMessage PostAsMessage(string url, object data = null) //Post请求返回通用消息对象

2. 提交JSON字符串数据

//从返回值分为：返回字符串、返回通用消息对象、返回泛型消息对象
public string PostJson(string url, object data = null) //Json方式Post请求返回字符串
public BoolMessage<T> PostJson<T>(string url, object data = null) //Json方式Post请求返回泛型消息对象  
public BoolMessage PostJsonAsMessage(string url, object data = null) //Json方式Post请求返回通用消息对象

文件上传

文件上传全部使用POST方法。

//从返回值分为：返回字符串、返回泛型消息对象泛型对象类型：FileModel
//从上传的内容上分为：本地文件、字节数组
//参数说明：
/// <param name="url">接口路径</param>
/// <param name="displayName">文件显示名称</param>
/// <param name="filePath">待上传的本地文件路径</param>
/// <param name="fileData">待上传的字节数组</param>
/// <param name="data">请求数据</param>
//上传文件返回响应字符串
public string UploadFile(string url, string displayName, string filePath, object data = null)
//上传文件返回泛型消息对象
public BoolMessage<T> UploadFile<T>(string url, string displayName, string filePath, object data = null)
//上传字节数组
public string UploadByte(string url, string displayName, byte[] fileData, object data = null)
//上传字节数组
public BoolMessage<T> UploadByte<T>(string url, string displayName, byte[] fileData, object data = null)

文件下载

//从返回值分为：返回通用消息对象、返回泛型消息对象
//从下载的方法上分为：GET、POST，默认使用GET方法
//参数说明：
/// <param name="url">接口路径</param>
/// <param name="data">请求数据</param>
/// <param name="savePath">文件本地保存路径</param>
//用Get方法下载文件到本地
public BoolMessage Download(string url, object data, string savePath)
//用Get方法下载文件到字节数组
public BoolMessage<byte[]> Download(string url, object data = null)
//用Post方法下载文件到本地
public BoolMessage DownloadPost(string url, object data, string savePath)
//用Post方法下载文件到字节数组
public BoolMessage<byte[]> DownloadPost(string url, object data = null)

事件

子类可以重写这两个方法

/// <summary>
/// 在请求发送前触发
/// </summary>
/// <param name="request">请求对象</param>
/// <returns>如果返回false,则终止请求</returns>
protected virtual bool OnBeforeRequest(HttpRequestMessage request)
{
    return true;
}
/// <summary>
/// 在请求成功后触发
/// </summary>
/// <param name="response">响应对象</param>
protected virtual void OnAfterRequest(HttpResponseMessage response)
{
}

权限子系统通信类

权限通讯类继承自WebApi类，在构造函数中传入appId参数，同时重写了OnBeforeRequest方法，实现了在请求发送之前添加Header参数，符合了服务端接口请求规范。

using System;
using System.Globalization;
using System.Net.Http;
using XCI.Core;
using XCI.Helper;
namespace XCI.Sys
{
    /// <summary>
    /// 系统Api接口
    /// </summary>
    public class SysWebApi : WebApi
    {
        private string _appId;
        /// <summary>
        /// 初始化系统Api接口
        /// </summary>
        /// <param name="appId">应用Id</param>
        /// <param name="baseUrl">服务器基地址</param>
        /// <param name="timeout">超时间隔</param>
        /// <param name="useProxy">是否使用代理</param>
        public SysWebApi(string appId, string baseUrl, TimeSpan timeout, bool useProxy) : base(baseUrl, timeout, useProxy)
        {
            _appId = appId;
        }
        /// <summary>
        /// 在请求前触发
        /// </summary>
        /// <param name="request">请求对象</param>
        /// <returns>如果返回false,则终止请求</returns>
        protected override bool OnBeforeRequest(HttpRequestMessage request)
        {
            request.Headers.Add("appId", _appId);//app
            request.Headers.Add("timestamp", DateTimeHelper.GetTimeStamp().ToString(CultureInfo.InvariantCulture));//时间戳
            request.Headers.Add("token", SysRuntime.CurrentUser?.Token);//token
            return true;
        }
    }
}

文件上传下载服务

上面介绍的通讯类类似于工具类，而文件上传和下载需要编写服务端，框架已经默认实现了的上传和下载功能，客户端使用FileUploadService类来完成调用。

namespace XCI.Sys.Service
{
    public class FileUploadService
    {
        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="folder">服务端文件夹(可为空,默认为当前日期)</param>
        /// <param name="fileName">文件保存名称(可为空,默认为自动生成)</param>
        /// <param name="displayName">文件显示名称</param>
        /// <param name="localPath">待上传的本地文件路径</param>
        public FileModel UploadFile(string folder, string fileName, 
                string displayName, string localPath);
        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="folder">服务端文件夹(可为空,默认为当前日期)</param>
        /// <param name="fileName">文件保存名称(可为空,默认为自动生成)</param>
        /// <param name="displayName">文件显示名称</param>
        /// <param name="fileData">待上传的二进制</param>
        public FileModel UploadByte(string folder, string fileName, 
            string displayName, byte[] fileData);
        /// <summary>
        /// 下载文件
        /// </summary>
        /// <param name="serverPath">服务端文件路径</param>
        /// <param name="md5">文件md5</param>
        public byte[] Download(string serverPath, string md5);
        /// <summary>
        /// 下载文件
        /// </summary>
        /// <param name="serverPath">服务端文件路径</param>
        /// <param name="localPath">本地存储文件路径</param>
        /// <param name="md5">文件md5</param>
        public void Download(string serverPath, string localPath,string md5);
        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="serverPath">服务端文件路径</param>
        /// <returns>成功返回true</returns>
        public bool Delete(string serverPath);
    }
}

示例

1. 用GET方法请求公司网站

WebApi api = new WebApi();
var result = api.Get("http://www.xci96716.com/");
MessageBoxHelper.ShowMessage(result);

1. 用POST方法请求服务器时间

SysWebApi api = new SysWebApi("1117664844619845632", "http://localhost:8765", TimeSpan.FromSeconds(10), false);
//请求服务,显示服务响应字符串
var result = api.Post("/api/sys/system/datetime");
MessageBoxHelper.ShowMessage(result);
//请求服务,将服务响应字符串转为泛型消息对象,并显示泛型对象值
var resultMessage = api.Post<string>("/api/sys/system/datetime");
MessageBoxHelper.ShowMessage(resultMessage.Data);

1. 上传文件

//自动生成文件夹和文件名
var fileInfo1 = FileUploadService.Instance.UploadFile(null, null, "风景.jpg", "R:\\5.jpg");
MessageBoxHelper.ShowMessage(JsonHelper.Serialize(fileInfo1, Formatting.Indented));
//设置目录名称,并且按年 - 月自动创建文件夹,设置文件保存名称
var fileInfo2 = FileUploadService.Instance.UploadFile($"/customer/{DateTime.Now:yyyy-MM}", "abc.jpg", "风景.jpg", "R:\\5.jpg");
MessageBoxHelper.ShowMessage(JsonHelper.Serialize(fileInfo2, Formatting.Indented));
//使用二进制数组上传
using (var stream = File.OpenRead("R:\\35.jpg"))
{
    byte[] bytes = new byte[stream.Length];
    stream.Read(bytes, 0, bytes.Length);
    var fileInfo3 = FileUploadService.Instance.UploadByte(null, null, "风光.jpg", bytes);
    MessageBoxHelper.ShowMessage(JsonHelper.Serialize(fileInfo3, Formatting.Indented));
}

1. 下载文件

//下载文件到本地文件
var serverUrl = "/res/upload/1117664844619845632/20190711/5390705aa4d74b7cb7c9efdefa83280d.jpg";
var localUrl = $"R:/风景{ Path.GetExtension(serverUrl)}";
FileUploadService.Instance.Download(serverUrl, localUrl, null);
MessageBoxHelper.ShowMessage($"文件下载成功,保存到 {localUrl}");
//下载文件到二进制数组
var serverUrl = "/res/upload/1117664844619845632/20190711/abc.jpg";
byte[] fileBytes = FileUploadService.Instance.Download(serverUrl, null);
Image img = ImageHelper.FromArray(fileBytes);
pictureEdit1.Image = img;
//下载文件时传递md5
var serverUrl = "/res/upload/1117664844619845632/20190711/5390705aa4d74b7cb7c9efdefa83280d.jpg";
var localUrl = $"R:/风景{ Path.GetExtension(serverUrl)}";
var md5 = string.Empty;
if (File.Exists(localUrl))
{
    md5 = IOHelper.GetFileMd5(localUrl);
}
FileUploadService.Instance.Download(serverUrl, localUrl, md5);
MessageBoxHelper.ShowMessage($"文件下载成功,保存到 {localUrl}");

1. 删除服务端文件

//删除服务器文件
var result = FileUploadService.Instance.Delete("/res/upload/1117664844619845632/20190711/82609296ce6c4cd1ac8e958c96da1a90.jpg");
if (result)
{
    MessageBoxHelper.ShowMessage("删除成功");
}

服务基类

客户端所有的业务处理都是通过调用服务端的接口来完成的，按照要求每个业务要有一个独立的Service来完成对服务端接口的封装。为了调用服务端接口更方便，每个业务服务需要继承泛型服务基类BaseService。

使用服务基类有以下几个关键点：

1. 单例对象

服务类并没有状态字段，所以只需要使用单例模式即可，每次都新创建服务示例没有任何意义。

使用方法：

public class ParamService : BaseService<SysParam>
{
    public static readonly ParamService Instance = new ParamService();
}

2. 设置接口根地址

由于每个接口服务的前缀几乎是一样的，可以设置接口根地址，并通过GetUrl方法，快捷的生成一个接口地址。

使用方法：

public class ParamService : BaseService<SysParam>
{
    //设置服务根地址
    protected override string RootUrl => "/api/sys/param/";
}
//构建地址
var url = GetUrl("insert");//获取新增地址 /api/sys/param/insert
var url = GetUrl("update");//获取修改地址 /api/sys/param/update
var url = GetUrl("delete");//获取删除地址 /api/sys/param/delete
var url = GetUrl("selectById",1);//获取指定主键的地址 /api/sys/param/selectById/1
var url = GetUrl("selectByCode","user",2);//获取指定主键的地址 /api/sys/param/selectByCode/user/2
var url = GetUrl("selectList");//获取列表地址 /api/sys/param/selectList
var url = GetUrl("selectPageList");//获取分页列表地址 /api/sys/param/selectPageList

3. 获取主键

框架中使用了整数作为主键，每个整数使用了雪花ID算法由服务端生成，所以在使用前要调用服务端方法来生成。

调用方法：

/// <summary>
/// 新建参数模型
/// </summary>
public SysParam New()
{
    return new SysParam
    {
        //调用服务基类中的NewId方法
        Id = NewId()
    };
}

4. 分页参数转换

分页参数封装在类PageParam中，有以下字段：

• PageIndex //页码索引,从1开始
• PageSize //每页记录数
• SortName //排序字段名称
• SortDir //排序方式(asc/desc)

调用服务基类中的方法ToPageMap把分页参数对象转为Map对象，转换过程中进行数据验证，保障发送给服务端参数的正确性。

5. Map集合对象

Map对象继承自Dictionary，表示一个键值对集合，扩展了一些链式方法，方便操作。

using System.Collections.Generic;
using XCI.Helper;
namespace XCI.Core
{
    /// <summary>
    /// 字符字典
    /// </summary>
    public class Map : Dictionary<string, object>
    {
        public static Map New => new Map();
        /// <summary>
        /// 添加键值对
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        public new Map Add(string key, object value)
        {
            this[key] = value;
            return this;
        }
        /// <summary>
        /// 添加对象(属性名为键,属性值为值)
        /// </summary>
        /// <param name="obj">对象</param>
        public Map AddObject(object obj)
        {
            var data = ObjectHelper.GetPropertyKeyValuePair(obj);
            foreach (KeyValuePair<string, object> item in data)
            {
                this[item.Key] = item.Value;
            }
            return this;
        }
        /// <summary>
        /// 如果值不为空字符串,则添加键值对
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        public Map IsNotEmpty(string key, object value)
        {
            if (value != null && !string.IsNullOrEmpty(value.ToString()))
            {
                this[key] = value.ToString();
            }
            return this;
        }
        /// <summary>
        /// 如果值不为空对象,则添加键值对
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        public Map IfNotNull(string key, object value)
        {
            if (value != null)
            {
                this[key] = value.ToString();
            }
            return this;
        }
        /// <summary>
        /// 如果条件为真,则添加键值对
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        public Map If(bool condition, string key, object value)
        {
            if (condition)
            {
                this[key] = value;
            }
            return this;
        }
        /// <summary>
        /// 合并两个Map集合
        /// </summary>
        /// <param name="map">待合并的Map集合</param>
        public Map Merge(Map map)
        {
            foreach (KeyValuePair<string,object> item in map)
            {
                this[item.Key] = item.Value;
            }
            return this;
        }
    }
}

使用方法：

//添加键值对
Map.New.Add("key", key).Add("deptId", deptId).Add("status", status);
//添加对象
HistoryFilter filter = new HistoryFilter();
Map.New.AddObject(filter)

6. 公共方法

基类包装了常用的接口方法

ExistByIdCore             // 检查主键是否存在
ExistByCodeCore         // 检查编码是否存在
ExistByNameCore         // 检查名称是否存在
InsertCore                //新建数据
UpdateCore                 //修改数据
DeleteByIdCore             //根据主键删除数据
DeleteByIdsCore         //根据主键字符串删除数据
UpdateStatusByIdCore     //根据主键修改状态
UpdateStatusByIdsCore     //根据主键字符串删除数据
BatchUpdateValuesCore     //批量修改字段值
SelectByIdCore             //根据主键获取数据
SelectByCodeCore         //根据编码获取数据
SelectPageListCore         //查询分页列表数据
SelectListCore             //查询列表数据
ExportCore                 //导出数据
bool RefreshCacheCore     //刷新服务端缓存

服务基类源码

using System.Collections.Generic;
using XCI.Core;
using XCI.Windows.Extensions;
namespace XCI.Sys.Service
{
    /// <summary>
    /// 服务基类
    /// </summary>
    public class BaseService<T> where T : class
    {
        /// <summary>
        /// 根地址
        /// </summary>
        protected virtual string RootUrl { get; }
        /// <summary>
        /// 获取接口地址
        /// </summary>
        /// <param name="name">接口名称</param>
        /// <param name="paths">路径参数</param>
        protected string GetUrl(string name, params string[] paths)
        {
            var url = string.Concat(RootUrl, name);
            if (paths != null && paths.Length > 0)
            {
                foreach (var path in paths)
                {
                    url = string.Concat(url, "/", path);
                }
            }
            return url;
        }
        /// <summary>
        /// 转为分页Map
        /// </summary>
        /// <param name="pageParam">分页参数</param>
        protected Map ToPageMap(PageParam pageParam)
        {
            Map map = new Map();
            if (pageParam.PageIndex.HasValue)
            {
                map.Add("pageIndex", pageParam.PageIndex.Value.ToString());
            }
            if (pageParam.PageSize.HasValue)
            {
                map.Add("pageSize", pageParam.PageSize.Value.ToString());
            }
            if (!string.IsNullOrEmpty(pageParam.SortName) && !string.IsNullOrEmpty(pageParam.SortDir))
            {
                map.Add("sortName", pageParam.SortName);
                map.Add("sortDir", pageParam.SortDir);
            }
            return map;
        }
        /// <summary>
        /// 创建新Id
        /// </summary>
        protected string NewId()
        {
            return SysService.Instance.GetId();
        }
        /// <summary>
        /// 检查主键是否存在
        /// </summary>
        /// <param name="id">主键</param>
        protected bool ExistByIdCore(string id)
        {
            var url = GetUrl(SysConst.ApiExistByIdName, id);
            return SysRuntime.Api.Post<bool>(url).EnsureSuccess().Data;
        }
        /// <summary>
        /// 检查编码是否存在
        /// </summary>
        /// <param name="code">编码</param>
        protected bool ExistByCodeCore(string code)
        {
            var url = GetUrl(SysConst.ApiExistByCodeName, code);
            return SysRuntime.Api.Post<bool>(url).EnsureSuccess().Data;
        }
        /// <summary>
        /// 检查名称是否存在
        /// </summary>
        /// <param name="name">名称</param>
        protected bool ExistByNameCore(string name)
        {
            var url = GetUrl(SysConst.ApiExistByNameName, name);
            return SysRuntime.Api.Post<bool>(url).EnsureSuccess().Data;
        }
        /// <summary>
        /// 新建数据
        /// </summary>
        /// <param name="model">数据模型</param>
        protected bool InsertCore(T model)
        {
            var url = GetUrl(SysConst.ApiInsertName);
            return SysRuntime.Api.PostJsonAsMessage(url, model).EnsureSuccess().Success;
        }
        /// <summary>
        /// 修改数据
        /// </summary>
        /// <param name="model">数据模型</param>
        protected bool UpdateCore(T model)
        {
            var url = GetUrl(SysConst.ApiUpdateName);
            return SysRuntime.Api.PostJsonAsMessage(url, model).EnsureSuccess().Success;
        }
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="id">主键</param>
        protected bool DeleteByIdCore(string id)
        {
            var url = GetUrl(SysConst.ApiDeleteName);
            var map = new Map
            {
                { SysConst.FIdName, id }
            };
            return SysRuntime.Api.PostAsMessage(url, map).EnsureSuccess().Success;
        }
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="ids">主键字符串</param>
        protected bool DeleteByIdsCore(string ids)
        {
            var url = GetUrl(SysConst.ApiDeleteName);
            var map = new Map
            {
                { SysConst.FIdsName, ids }
            };
            return SysRuntime.Api.PostAsMessage(url, map).EnsureSuccess().Success;
        }
        /// <summary>
        /// 修改状态
        /// </summary>
        /// <param name="id">主键</param>
        /// <param name="status">状态 true:启用 false:禁用</param>
        /// <returns>成功返回true</returns>
        protected bool UpdateStatusByIdCore(string id, bool status)
        {
            var url = GetUrl(SysConst.ApiUpdateStatusName);
            var map = new Map
            {
                { SysConst.FIdName, id },
                { SysConst.FStatusName, status.ToString() }
            };
            return SysRuntime.Api.PostAsMessage(url, map).EnsureSuccess().Success;
        }
        /// <summary>
        /// 修改状态
        /// </summary>
        /// <param name="ids">主键字符串</param>
        /// <param name="status">状态 true:启用 false:禁用</param>
        /// <returns>成功返回true</returns>
        protected bool UpdateStatusByIdsCore(string ids, bool status)
        {
            var url = GetUrl(SysConst.ApiUpdateStatusName);
            var map = new Map
            {
                { SysConst.FIdsName, ids },
                { SysConst.FStatusName, status.ToString() }
            };
            return SysRuntime.Api.PostAsMessage(url, map).EnsureSuccess().Success;
        }
        /// <summary>
        /// 批量修改字段值
        /// </summary>
        /// <param name="keyValues">修改的数据集合</param>
        /// <returns>成功返回true</returns>
        protected bool BatchUpdateValuesCore(List<PrimaryKeyValue> keyValues)
        {
            var url = GetUrl(SysConst.ApiBatchUpdateValuesName);
            return SysRuntime.Api.PostJsonAsMessage(url, keyValues).EnsureSuccess().Success;
        }
        /// <summary>
        /// 根据主键获取数据
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>成功返回模型对象</returns>
        protected T SelectByIdCore(string id)
        {
            var url = GetUrl(SysConst.ApiSelectByIdName, id);
            return SysRuntime.Api.Post<T>(url).EnsureSuccess().Data;
        }
        /// <summary>
        /// 根据编码获取数据
        /// </summary>
        /// <param name="code">编码</param>
        /// <returns>成功返回模型对象</returns>
        protected T SelectByCodeCore(string code)
        {
            var url = GetUrl(SysConst.ApiSelectByCodeName, code);
            return SysRuntime.Api.Post<T>(url).EnsureSuccess().Data;
        }
        /// <summary>
        /// 刷新服务端缓存
        /// </summary>
        protected bool RefreshCacheCore()
        {
            var url = GetUrl(SysConst.ApiRefreshCacheName);
            return SysRuntime.Api.PostAsMessage(url).EnsureSuccess().Success;
        }
        /// <summary>
        /// 查询分页数据
        /// </summary>
        protected PageList<T> SelectPageListCore(Map map = null)
        {
            var url = GetUrl(SysConst.ApiSelectPageListName);
            return SysRuntime.Api.Post<PageList<T>>(url, map).EnsureSuccess().Data;
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        protected List<T> SelectListCore(Map map = null)
        {
            var url = GetUrl(SysConst.ApiSelectListName);
            return SysRuntime.Api.Post<List<T>>(url, map).EnsureSuccess().Data;
        }
        /// <summary>
        /// 导出数据
        /// </summary>
        protected byte[] ExportCore(Map map = null)
        {
            var url = GetUrl(SysConst.ApiExportName);
            return SysRuntime.Api.DownloadPost(url, map).EnsureSuccess().Data;
        }
    }
}

系统参数服务示例

using System;
using System.Collections.Generic;
using XCI.Sys.Model;
using XCI.Core;
using XCI.Windows.Extensions;
namespace XCI.Sys.Service
{
    /// <summary>
    /// 系统参数服务
    /// </summary>
    public class ParamService : BaseService<SysParam>
    {
        public static readonly ParamService Instance = new ParamService();
        protected override string RootUrl => "/api/sys/param/";
        /// <summary>
        /// 新建参数模型
        /// </summary>
        public SysParam New()
        {
            return new SysParam
            {
                Id = NewId()
            };
        }
        /// <summary>
        /// 复制参数模型
        /// </summary>
        /// <param name="original">原模型</param>
        public SysParam Copy(SysParam original)
        {
            if (original == null) throw new ArgumentNullException(nameof(original));
            var model = original?.Clone();
            model.Id = NewId();
            return model;
        }
        /// <summary>
        /// 检查参数编码是否存在
        /// </summary>
        /// <param name="code">参数编码</param>
        public bool ExistByCode(string code)
        {
            return ExistByCodeCore(code);
        }
        /// <summary>
        /// 新建参数
        /// </summary>
        /// <param name="model">参数模型对象</param>
        /// <returns>成功返回true</returns>
        public bool Insert(SysParam model)
        {
            return InsertCore(model);
        }
        /// <summary>
        /// 修改参数
        /// </summary>
        /// <param name="model">参数模型对象</param>
        /// <returns>成功返回true</returns>
        public bool Update(SysParam model)
        {
            return UpdateCore(model);
        }
        /// <summary>
        /// 删除参数
        /// </summary>
        /// <param name="ids">主键字符串</param>
        /// <returns>成功返回true</returns>
        public bool Delete(string ids)
        {
            return DeleteByIdsCore(ids);
        }
        /// <summary>
        /// 根据主键获取参数对象
        /// </summary>
        /// <param name="id">参数主键</param>
        public SysParam SelectById(string id)
        {
            return SelectByIdCore(id);
        }
        /// <summary>
        /// 根据参数编码获取参数对象
        /// </summary>
        /// <param name="code">参数编码</param>
        /// <returns>成功返回模型对象</returns>
        public SysParam SelectByCode(string code)
        {
            return SelectByCodeCore(code);
        }
        /// <summary>
        /// 根据编码查询单个参数值
        /// </summary>
        /// <param name="code">参数编码</param>
        /// <param name="defaultValue">如果没有找到指定编码的参数,则返回此默认值</param>
        /// <returns>返回指定编码的参数值</returns>
        public string SelectValueByCode(string code, string defaultValue)
        {
            var url = GetUrl("selectValueByCode");
            var map = Map.New.Add("code", code).Add("defaultValue", defaultValue);
            return SysRuntime.Api.Post<string>(url, map).EnsureSuccess().Data;
        }
        /// <summary>
        /// 查询参数分页列表
        /// </summary>
        /// <param name="paged">分页参数</param>
        /// <param name="key">编码/名称关键字</param>
        public PageList<SysParam> SelectPageList(PageParam paged, string key)
        {
            var map = ToPageMap(paged).Add(SysConst.FKeyName, key);
            return SelectPageListCore(map);
        }
        /// <summary>
        /// 查询参数列表
        /// </summary>
        /// <param name="key">编码/名称关键字</param>
        public List<SysParam> SelectList(string key)
        {
            var map = Map.New.Add(SysConst.FKeyName, key);
            return SelectListCore(map);
        }
        /// <summary>
        /// 导出参数列表
        /// </summary>
        /// <param name="key">编码/名称关键字</param>
        public byte[] Export(string key)
        {
            var map = Map.New.Add(SysConst.FKeyName, key);
            return ExportCore(map);
        }
        /// <summary>
        /// 刷新服务端参数缓存
        /// </summary>
        public bool RefreshCache()
        {
            return RefreshCacheCore();
        }
    }
}