

### http请求
```
function sendGetRequest(url, callback) {
  var xhr = new XMLHttpRequest();
  xhr.open("GET", url, true);
  xhr.onreadystatechange = function() {
    if (xhr.readyState === 4 && xhr.status === 200) {
      var response = JSON.parse(xhr.responseText);
      callback(response);
    }
  };
  xhr.send();
}

// 调用示例
sendGetRequest("https://api.example.com/data", function(response) {
  console.log(response);
});
```

😛 返璞归真，原生JS收集

😃封装一些常见的又是自己喜欢的方式，方便日后复制


### 分页封装

> 复杂等高级查询，参照sqlsugar官网的表格查询 ![0478E7B4.png](/static/img/e180f3dfafbc68d45842f9066fee0b95.0478E7B4.webp) [点我访问](https://www.donet5.com/home/doc?masterId=1&typeId=2314)


 - 比简单多一点的条件
 ```
 /// <summary>
    /// 获取分页数据
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <param name="exp"></param>
    /// <param name="lstWhereIF"></param>
    /// <returns></returns>
    public async Task<ResPageModel<TEntity>> GetPageDataAsync<TEntity>(Expression<Func<TEntity, bool>> exp,
        (bool isWhere, Expression<Func<TEntity, bool>> expression)[] lstWhereIF) where TEntity : class, new()
    {
        RefAsync<int> total = 0;
        RefAsync<int> totalPage = 0;
        int page = 1;
        int pageSize = 10;
        ISugarQueryable<TEntity> queryable =
            Db.Queryable<TEntity>().Where(exp);

        foreach (var whereIF in lstWhereIF)
        {
            queryable.WhereIF(whereIF.isWhere,whereIF.expression);
        }

        var pageData = await queryable.ToPageListAsync(page, pageSize, total, totalPage);
        return new ResPageModel<TEntity>
        {
            PageSize = pageSize,
            DataCount = total,
            PageCount = totalPage,
            Data = pageData
        };
    }
 ```

- 就一个简单的条件
```
 public async Task<ResPageDto<List<TData>>> PageDataAsync<TData>(ReqPageDto model, Expression<Func<TData, bool>>? whereExpression = null, Expression<Func<TData, object>>? orderExpression = null, OrderByType type = OrderByType.Asc) where TData : class
        {
            RefAsync<int> total = 0;
            RefAsync<int> totalPage = 0;
            List<TData>? pageInfo = await _db.Queryable<TData>()
                .WhereIF(whereExpression!=null, whereExpression)
                .OrderByIF(orderExpression!=null, orderExpression,type)
                .ToPageListAsync(model.PageNum, model.PageSize, total, totalPage);

            return new ResPageDto<List<TData>>
            {
                Data = pageInfo,
                PageNum = model.PageNum,
                PageSize = model.PageSize,
                Total = total,
                TotalPage = totalPage
            };
        }
```

 相关实体类
 
```
/// <summary>
/// 请求分页数据传输对象
/// </summary>
public class ReqPageDto
{
    /// <summary>
    /// 页码
    /// </summary>
    public int PageNum { get; set; }

    /// <summary>
    /// 每页大小
    /// </summary>
    public int PageSize { get; set; }
}

/// <summary>
/// 响应分页数据传输对象
/// </summary>
/// <typeparam name="TData">数据类型</typeparam>
public class ResPageDto<TData>
{
    /// <summary>
    /// 总页数
    /// </summary>
    public int TotalPage { get; set; }

    /// <summary>
    /// 总记录数
    /// </summary>
    public int Total { get; set; }

    /// <summary>
    /// 页码
    /// </summary>
    public int PageNum { get; set; }

    /// <summary>
    /// 每页大小
    /// </summary>
    public int PageSize { get; set; }

    /// <summary>
    /// 数据
    /// </summary>
    public TData Data { get; set; }
}
```

sqlsugar

furion框架常规可能会使用的操作



### 配置


- #### DynamicApiControllerSettings

```
"DynamicApiControllerSettings": {
    "KeepName": true,
    "KeepVerb": true,
    "LowercaseRoute": false    
    //[FromQuery] 修饰，单个使用[QueryParameters]
    "UrlParameterization": true,
    "Urls": "http://localhost:8081"
  }
```
> Urls 记得localhost最好保持为*，不然docker等场景下会寄

```
DefaultRoutePrefix：默认路由前缀，string，默认 api
DefaultHttpMethod：默认请求谓词，string，默认：POST
DefaultModule：默认模块名称（区域），可用作接口版本，string，默认：v1
LowercaseRoute：小写路由格式，bool，默认：true
AsLowerCamelCase：启用小驼峰命名（首字母小写），默认 false
KeepVerb：是否保留动作谓词，bool，默认：false
KeepName：是否保留默认名称，bool，默认：fasle
CamelCaseSeparator：骆驼(驼峰)/帕斯卡命名分隔符，string，默认：-
VersionSeparator：版本分隔符，string，默认：@
ModelToQuery：GET/HEAD 请求将 类类型参数转查询参数，bool，默认 false
SupportedMvcController：是否支持 Mvc Controller 动态配置，bool，默认 false
UrlParameterization：路由参数采用 [FromQuery] 化，默认 false（[FromRoute] 方式）
DefaultArea：配置默认区域，默认 null

```


### 配置中心

- #### 使用Nacos
```
Serve.Run(RunOptions.Default.WithArgs(args)
    .ConfigureInject((builder, options) =>
    {
        options.ConfigureAppConfiguration((_, cfb) =>
        {
            cfb.AddNacosV2Configuration(cfb.Build().GetSection("Nacos"));

        });

        options.ConfigureWebServices((_, services) =>
        {
            services.AddNacosAspNet(builder.Configuration, "NacosService");
        });
    })
);
```

Furion 常用操作


# 常用方法

## 时间

DateTime.Now.Subtract 计算两个 DateTime 对象之间的时间间隔的方法


### 多个实现，用哪个？

- 使用Autofac 
```
 public class MyController : Controller
{
    //标记
    [Inject(Name = "ImplementationA")]
    private readonly IAService _aService;

    public MyController()
    {
    }

    public IActionResult Index()
    {
        // 使用_aService进行操作
        // ...
        return View();
    }
}
```

Csharp/dotNet 冷门知识

常用地图计算



```

  public static class DistanceHelper
    {
        /// <summary>
        /// 根据一个给定经纬度的点和距离，进行附近地点查询
        /// </summary>
        /// <param name="longitude">经度</param>
        /// <param name="latitude">纬度</param>
        /// <param name="distance">距离（单位：公里或千米）</param>
        /// <returns>返回一个范围的4个点，最小纬度和纬度，最大经度和纬度</returns>
        public static PositionModel FindNeighPosition(double longitude, double latitude, double distance)
        {
            //先计算查询点的经纬度范围  
            double r = 6378.137;//地球半径千米  
            double dis = distance;//千米距离    
            double dlng = 2 * Math.Asin(Math.Sin(dis / (2 * r)) / Math.Cos(latitude * Math.PI / 180));
            dlng = dlng * 180 / Math.PI;//角度转为弧度  
            double dlat = dis / r;
            dlat = dlat * 180 / Math.PI;
            double minlat = latitude - dlat;
            double maxlat = latitude + dlat;
            double minlng = longitude - dlng;
            double maxlng = longitude + dlng;
            return new PositionModel
            {
                MinLat = minlat,
                MaxLat = maxlat,
                MinLng = minlng,
                MaxLng = maxlng
            };
        }

        /// <summary>
        /// 计算两点位置的距离，返回两点的距离，单位：公里或千米
        /// 该公式为GOOGLE提供，误差小于0.2米
        /// </summary>
        /// <param name="lat1">第一点纬度</param>
        /// <param name="lng1">第一点经度</param>
        /// <param name="lat2">第二点纬度</param>
        /// <param name="lng2">第二点经度</param>
        /// <returns>返回两点的距离，单位：公里或千米</returns>
        public static double GetDistance(double lat1, double lng1, double lat2, double lng2)
        {
            //地球半径，单位米
            double EARTH_RADIUS = 6378137;
            double radLat1 = Rad(lat1);
            double radLng1 = Rad(lng1);
            double radLat2 = Rad(lat2);
            double radLng2 = Rad(lng2);
            double a = radLat1 - radLat2;
            double b = radLng1 - radLng2;
            double result = 2 * Math.Asin(Math.Sqrt(Math.Pow(Math.Sin(a / 2), 2) + Math.Cos(radLat1) * Math.Cos(radLat2) * Math.Pow(Math.Sin(b / 2), 2))) * EARTH_RADIUS;
            return result / 1000;
        }

        /// <summary>
        /// 经纬度转化成弧度
        /// </summary>
        /// <param name="d"></param>
        /// <returns></returns>
        private static double Rad(double d)
        {
            return (double)d * Math.PI / 180d;
        }

        public static string GetDistance(double distance)
        {
            if (distance >= 1000)
                return ">1000km";
            else if (distance < 1000 && distance >= 1)
                return $"{System.Math.Ceiling(distance)}km";
            else if(distance < 1 && distance >=0.5)
                return $"{System.Math.Ceiling(distance*1000)}m";
            else if (distance < 0.5 && distance > 0)
                return $"<500m";
            return "未知";
        }
    }

    public class PositionModel
    {
        public double MinLat { get; set; }
        public double MaxLat { get; set; }
        public double MinLng { get; set; }
        public double MaxLng { get; set; } 
    }
```