#ssl.conf文件内容



server { 

    listen8080 ssl http2;server_name localhost;ssl_certificate C:/WebRoot/nginx/conf/ssl/www.iqidi.com_bundle.crt;ssl_certificate_key C:/WebRoot/nginx/conf/ssl/www.iqidi.com.key;
    #先配置签名证书，再配置加密证书，签名加密证书私钥 key 为同一个！

    ssl_session_timeout 5m;ssl_protocols TLSv1.2;ssl_ciphers SM2-WITH-SMS4-SM3:ECDH:AESGCM:HIGH:MEDIUM:!RC4:!DH:!MD5:!aNULL:!eNULL;ssl_prefer_server_cipherson;location/{ 

            root   html/CollectDataApp;index index.html index.htm;} 

}

server {

        listen8080 ssl;server_name  localhost;

        #charset koi8-r;
        #access_log  logs/host.access.log  main;location/{

            root   html/CollectDataApp;index  index.html index.htm;try_files$uri $uri/ /index.html =404;}}

server {

        listen9002 ssl;server_name  localhost;ssl_certificate C:/WebRoot/nginx/conf/ssl/www.iqidi.com_bundle.crt; 

        ssl_certificate_key C:/WebRoot/nginx/conf/ssl/www.iqidi.com.key;

        ssl_session_cache    shared:SSL:1m;

        ssl_session_timeout  5m;

        ssl_ciphers  HIGH:!aNULL:!MD5;

        ssl_prefer_server_ciphers  on;

        #charset koi8-r;
        #access_log  logs/host.access.log  main;location/{

            root   html/AssetCheckApp;index  index.html index.htm;try_files$uri $uri/ /index.html =404;}}

/// <summary>
///数据显示的函数/// </summary>
public async override voidDisplayData()

{if (!string.IsNullOrEmpty(ID))

    {#region 显示信息
        var info = await BLLFactory<ICustomerService>.Instance.GetAsync(ID);if (info != null)

        {

            tempInfo= info;//重新给临时对象赋值，使之指向存在的记录对象txtName.Text=info.Name;

            txtAge.Value=info.Age;

        }#endregion
        //this.btnOK.Enabled = HasFunction("Customer/Edit");
}else{//this.btnOK.Enabled = HasFunction("Customer/Add");
}              

}

1、services.AddTransient<IDictDataService, DictDataService>();  // 瞬时生命周期
2、services.AddScoped<IDictDataService, DictDataService>();     // 域生命周期
3、services.AddSingleton<IDictDataService, DictDataService>();  // 全局单例生命周期

        /// <summary>
        ///配置依赖注入对象/// </summary>
        /// <param name="services"></param>
        public static voidConfigureRepository(IServiceCollection services)

        {#region 自动注入对应的服务接口
            var path = AppDomain.CurrentDomain.RelativeSearchPath ??AppDomain.CurrentDomain.BaseDirectory;var getFiles = Directory.GetFiles(path, "*.dll").Where(Match);  //.Where(o=>o.Match())
            var referencedAssemblies = getFiles.Select(Assembly.LoadFrom).ToList();  //.Select(o=> Assembly.LoadFrom(o))
            
            var baseType = typeof(IDependency);var types =referencedAssemblies

                .SelectMany(a=>a.DefinedTypes)

                .Select(type=>type.AsType())

                .Where(x=> x != baseType &&baseType.IsAssignableFrom(x)).ToList();var implementTypes = types.Where(x =>x.IsClass).ToList();var interfaceTypes = types.Where(x =>x.IsInterface).ToList();



            RegisterService(services, implementTypes, interfaceTypes);#endregion}

/// <summary>
///根据配置文件，决定采用直连的DLL，还是代理API的DLL，构建接口进行注入/// </summary>
/// <param name="services"></param>
public static voidConfigureRepositoryAuto(IServiceCollection services)

{var config = newAppConfig();string callerType = config.AppConfigGet("CallerType");if (!string.IsNullOrWhiteSpace(callerType) && callerType.Equals("api", StringComparison.OrdinalIgnoreCase))

    {//如果配置为API模式
ConfigureRepositoryApi(services);

    }else{//如果配置为普通模式
ConfigureRepository(services);

    }

}

    /// <summary>
    ///客户信息应用层服务接口实现/// </summary>
    public class CustomerService : MyCrudService<CustomerInfo, string, CustomerPagedDto>, ICustomerService

    {

       ...............

    }

/// <summary>
///客户信息的Web API调用处理/// </summary>
public class CustomerApiCaller : AsyncCrudApiCaller<CustomerInfo, string, CustomerPagedDto>, ICustomerService

{

}

/// <summary>
///对用户身份进行认证/// </summary>
/// <param name="username">用户名</param>
/// <param name="password">用户密码</param>
/// <returns></returns>
public async virtual Task<AuthenticateResultDto> Authenticate(string username, stringpassword)

{var url = string.Format("{0}/api/Login/Authenticate", ServerRootAddress);var input = new{

        UsernameOrEmailAddress=username,

        Password=password

    };
    var result = await apiClient.PostAsync<AuthenticateResultDto>(url, input);returnresult;

}

/// <summary>
///重新增加相应的请求头，如认证的信息/// </summary>
protected virtual voidAddRequestHeaders()

{//读取需要设置的请求头
apiClient.RequestHeaders.Clear();foreach (var item inRequestHeaders)

    {

        apiClient.RequestHeaders.Add(item);

    }//从缓存里面读取令牌信息，并在请求的时候自动加入（如果没有加的话）
    var accessToken = Cache.Instance["AccessToken"] as string;if (!string.IsNullOrWhiteSpace(accessToken))

    {var bearer = new NameValue("Authorization", "Bearer " +accessToken);if (apiClient.RequestHeaders != null && !apiClient.RequestHeaders.Contains(bearer))

        {

            apiClient.RequestHeaders.Add(bearer);

        }

    }

}

/// <summary>
///获取所有对象列表/// </summary>
/// <returns></returns>
public async virtual Task<ListResultDto<TEntity>>GetAllAsync()

{return await DoActionAsync<PagedResultDto<TEntity>>("all");

}/// <summary>
///获取所有对象列表/// </summary>
/// <param name="input">获取所有条件</param>
/// <returns></returns>
public async virtual Task<ListResultDto<TEntity>> GetAllByIdsAsync(IEnumerable<TPrimaryKey>input)

{return await DoActionAsync<PagedResultDto<TEntity>>("all-byids", input);

}

public async Task<bool> SetDeletedFlag(int id, bool deleted = true)

{var action = $"set-deleted";var input = new{

        id,

        deleted

    };return await DoActionAsync<bool>(action, input, HttpVerb.Post);

}public async Task<OuInfo> FindByName(stringname)

{var action = $"byname/{name}";var dict = new Dictionary<string, string> { { "name", name } };return await DoActionAsync<OuInfo>(action, dict, HttpVerb.Get);

}

/// <summary>
///新增状态下的数据保存/// </summary>
/// <returns></returns>
public async override Task<bool>SaveAddNew()

{

    CustomerInfo info= tempInfo;//必须使用存在的局部变量，因为部分信息可能被附件使用
SetInfo(info);
    try{#region 新增数据
        //检查是否还有其他相同关键字的记录
        bool isExist = await BLLFactory<ICustomerService>.Instance.IsExistAsync(s=>s.Name.Equals(info.Name));if(isExist)

        {

            MessageDxUtil.ShowTips("指定的【姓名】已经存在，不能重复添加，请修改");return false;

        }var success = await BLLFactory<ICustomerService>.Instance.InsertAsync(info);if(success)

        {//可添加其他关联操作
            return true;

        }#endregion}catch(Exception ex)

    {

        LogTextHelper.Error(ex);

        MessageDxUtil.ShowError(ex.Message);

    }return false;

}

/// <summary>
///判断是否存在指定条件的记录/// </summary>
/// <param name="input">表达式条件</param>
/// <returns></returns>
Task<bool> IsExistAsync(Expression<Func<TEntity, bool>> input);

/// <summary>
///获取某字段数据字典列表/// </summary>
Task<List<string>> GetFieldList(Expression<Func<TEntity, object>> selector, Expression<Func<TEntity, bool>> where = null);

/// <summary>
///初始化数据字典/// </summary>
private async voidInitDictItem()

{//初始化代码
    var list = await BLLFactory<IFormService>.Instance.GetFieldList(s=>s.Category);this.txtCategory.BindDictItems(list, "");

}

    /// <summary>
    ///对Lambda表达式的序列号和反序列化处理/// </summary>
    public static classSerializeExtension

    {/// <summary>
        ///序列化 LINQ Expression 表达式为JSON文本/// </summary>
        /// <typeparam name="TEntity">处理对象类型</typeparam>
        /// <typeparam name="TResult">返回结果类型</typeparam>
        /// <param name="express"></param>
        /// <returns></returns>
        public static string SerializeText<TEntity, TResult>(this Expression<Func<TEntity, TResult>>express)

        {//使用Serialize.Linq组件序列化表达式，传递给API端，API端需要对应反序列化的处理操作进行转换Expression
            var serializer = new ExpressionSerializer(newJsonSerializer());var expressJson =serializer.SerializeText(express);//接收端的反序列化处理//var express = (Expression<Func<TEntity, TResult>>)serializer.DeserializeText(expressJson);

            returnexpressJson;

        }/// <summary>
        ///反序列化JSON文本为LINQ Expression 表达式/// </summary>
        /// <typeparam name="TEntity">处理对象类型</typeparam>
        /// <typeparam name="TResult">返回结果类型</typeparam>
        /// <param name="text"></param>
        /// <returns></returns>
        public static Expression<Func<TEntity, TResult>> DeserializeText<TEntity, TResult>(this stringjson)

        {

            Expression<Func<TEntity, TResult>> express = null;if (!string.IsNullOrWhiteSpace(json))

            {var serializer = new ExpressionSerializer(newJsonSerializer());

                express= (Expression<Func<TEntity, TResult>>)serializer.DeserializeText(json);

            }returnexpress;

        }

    }

        /// <summary>
        ///根据条件，获取所有记录/// </summary>
        public virtual async Task<ListResultDto<TEntity>> GetAllAsync(Expression<Func<TEntity, bool>> input, string orderBy = null)

        {var express = input.SerializeText(); //使用扩展函数处理生成JSON
            var postData = new{

                express,

                orderBy

            };return await DoActionAsync<ListResultDto<TEntity>>("all-expression", postData, HttpVerb.Post);

        }/// <summary>
        ///根据条件计算记录数量/// </summary>
        /// <returns></returns>
        public virtual async Task<long> CountAsync(Expression<Func<TEntity, bool>>input)

        {var expressJson = input.SerializeText(); //使用扩展函数处理生成JSON
            return await DoActionAsync<long>("count-expression", expressJson, HttpVerb.Post);

        }

        /// <summary>
        ///根据条件，获取所有记录/// </summary>
[HttpPost]

        [Route("all-expression")]public async Task<ListResultDto<TEntity>>GetAllAsync(ExpressionOrderDtoinput)

        {

            ListResultDto<TEntity>? result = null;string json =input.expression;var express = json.DeserializeText<TEntity, bool>();if (express != null)

            {

                result= await _service.GetAllAsync(express!);

            }returnresult;

        }



        [HttpPost]

        [Route("count-expression")]public virtual async Task<long> CountAsync(dynamicexpressJson)

        {long result = 0;string json =expressJson;var express = json.DeserializeText<TEntity, bool>();if (express != null)

            {

                result= await _service.CountAsync(express!);

            }returnresult;

        }

        private void btnLoadImage_Click(objectsender, EventArgs e)

        {var imageFile = FileDialogHelper.OpenImage(false, "");if(imageFile != null)

            {var str =BaiduOcr(imageFile);//var str = TesseractOcr(imageFile);
                this.txtResuilt.Text =str;

            }

        }private static string BaiduOcr(stringimageFile)

        {var APIKey = "**********";var SecretKey = "********";var ocr = newBaidu.Aip.Ocr.Ocr(APIKey, SecretKey);var currentImage =FileUtil.FileToBytes(imageFile);var result =ocr.Accurate(currentImage);string str = string.Empty;var txts = (from obj in (JArray)result.Root["words_result"]select (string)obj["words"]).ToList();string startString = "手术助手";int startIndex = 0;for (int i = 0; i < txts.Count(); i++)

            {if (txts[i] ==startString)

                {

                    startIndex= i; //记录二维表的开始位置
}

            }var newList = txts.Skip(startIndex + 1).ToList();



            str= string.Join("\r\n", newList);returnstr;

        }

usingRestSharp;usingSystem;namespaceGpt3APIExample

{classProgram

    {static void Main(string[] args)

        {//OpenAI API地址
            string apiUrl = "https://api.openai.com/v1/engines/gpt-3/jobs";//OpenAI API密钥
            string apiKey = "YOUR_API_KEY";//创建一个RestClient对象
            var client = newRestClient(apiUrl);//创建一个RestRequest对象
            var request = newRestRequest(Method.POST);//在请求头中添加API密钥
            request.AddHeader("Authorization", "Bearer" +apiKey);//添加请求内容
            request.AddJsonBody(new{

                model= "text-davinci-002",

                prompt= "What is the capital of France?",

                max_tokens= 100,

                n= 1,

                stop= null,

                temperature= 0.5,

            });//发送请求并获取响应
            IRestResponse response =client.Execute(request);//显示响应内容
Console.WriteLine(response.Content);

            Console.ReadLine();

        }

    }

}

    /// <summary>
    ///基于OpenAI-DotNet的使用/// </summary>
    public classTest2

    {public static asyncTask ExcuteCode()

        {var api = new OpenAIClient(newOpenAIAuthentication(Constants.ApiKey));var result = await api.CompletionsEndpoint.CreateCompletionAsync("读取图片文件的展示到窗体的C#代码", null, null, 1000, 0.1);

            Log.Information(result.ToJson());

        }

            var results = await api.ImagesEndPoint.GenerateImageAsync("中国布达拉宫的全景图片", 1, ImageSize.Large);foreach (var item inresults)

            {

                Log.Information(item);

            }

            var imageAssetPath = "images/休息区.png";var maskAssetPath = "images/休息区2.png";var imageResults = await api.ImagesEndPoint.CreateImageEditAsync(Path.GetFullPath(imageAssetPath), Path.GetFullPath(maskAssetPath), "阳光明媚的室内休息区，有一个鸭子在池塘中", 1, ImageSize.Small);foreach (var item inimageResults)

            {

                Log.Information(item);

            }