登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 资源区 › 代码 ›Quick Library 简介

Quick Library 简介

诞楮 2025-6-5 08:28:47
QuickLib 是一个快速开发库

QuickLib是一个快速开发库，它提供了诸如AutoMapper、LinQ、IOC依赖注入、MemoryCache、计划任务、Json和Yml配置、序列化程序等多种功能。这个库特别支持Delphi和Firemonkey的多平台开发，包括Windows、Linux、Android、OSX和IOS。同时，QuickLib也支持freepascal，使得开发人员能够更轻松地构建跨平台应用程序并提高生产力。
功能领域：

  • 映射（Mapping）: 将一个类的字段映射到另一个类，复制对象等。
  • 配置（Config）: 将配置作为对象使用，并从/向文件（Json/Yaml）或Windows注册表加载/保存。
  • 序列化（Serialization）: 将对象序列化到/从json/Yaml。
  • 调度（Scheduling）: 以独立线程启动任务，并具有重试策略。
  • 线程（Threading）: 简化多线程后台任务的运行和控制，线程安全的列表、队列等
  • 数据（Data）: 灵活的数据交换和存储，允许多种输入输出类型。
  • 云（Cloud）: 简化云Azure/Amazon文件管理，发送电子邮件等。
  • 查询（Querying）: 索引列表，可搜索列表和用于通用列表和数组的Linq查询系统。
  • 基准测试（Benchmark）: 经过的时间控制和基准测试功能。
  • 文件系统（Filesystem）: 进程和服务控制，文件修改监视器和助手等...
  • 失败控制（FailControl）: 失败和重试策略。
  • 缓存（Caching）: 缓存字符串或对象，以便稍后快速检索。
  • 模板（Templating）: 使用字典进行简单的字符串模板化。
  • 调试（Debuging）: 用于调试代码的工具。
  • 参数（Parameters）: 使用命令行参数。
主要单元描述：

  • Quick.Commons: 开发人员日常工作中经常需要的功能。
  • Quick.AppService: 允许控制台应用程序以控制台模式或服务模式运行相同的代码，从而简化调试任务。
  • Quick.Azure/Amazon: 简化了与Azure和Amazon云存储的blob交互。
  • Quick.Network: CIDR和IP范围功能。
  • Quick.Chrono: 计时器和基准测试一段代码很简单。
  • Quick.Console: 使用颜色等将日志消息写入控制台...
  • Quick.Log: 以详细级别和每日或最大空间轮换方式记录到磁盘或内存。
  • Quick.Config: 将配置加载/保存为Json或Yaml文件或Windows注册表项，并将其作为对象管理。
  • Quick.FileMonitor: 监视文件的更改并抛出事件。
  • Quick.JsonUtils: 用于处理json对象的工具。
  • Quick.SMTP: 用两行代码发送电子邮件。
  • Quick.Threads: 线程安全类，具有重试策略的调度和后台任务。
  • Quick.Process: 管理Windows进程。
  • Quick.Services: 管理Windows服务。
  • Quick.Format: 字符串格式。
  • Quick.RTTI.Utils: 简化与RTTI的工作。
  • Quick.JsonSerializer: 将对象序列化到/从json文本。您可以定义是否将处理公开或发布的属性（仅Delphi，fpc rtti仅支持已发布的属性）
  • Quick.AutoMapper: 将一个类的字段映射到另一个类。允许自定义映射以匹配不同的字段，以及手动转换/转换字段的自定义映射过程。
  • Quick.JsonRecord: 用作DTO类，包含json序列化和映射功能。
  • Quick.Lists: 具有索引或搜索功能的改进列表。
  • Quick.Value FlexValue存储任何数据类型，并允许使用集成运算符和autofrees将其传递给其他类。
  • Quick.Arrays: 改进的数组。
  • Quick.YAML: Yaml对象结构。
  • Quick.YAML.Serializer: 将对象从/序列化为Yaml。
  • Quick.Expression: 使用表达式评估对象属性。
  • Quick.Linq: 对任何TObjectList，TList，TArray和TXArray进行Linq查询，执行类似SQL语法的复杂Where选择，更新和排序列表。
  • Quick.MemoryCache: 缓存具有过期时间的对象/信息，以避免每次需要时都生成这些信息（数据库查询，难以计算的信息等）。
  • Quick.Collections: 集合改进，如具有Linq继承的IList和IObjectList。
  • Quick.Pooling: 创建对象池以避免外部资源消耗殆尽和开销。
  • Quick.Template: 使用字典或委托替换字符串模板。
  • Quick.Debug.Utils: 简单的调试和代码基准测试工具。
  • Quick.Parameters: 将命令行参数作为一个类来处理。
  • Quick.Url.Utils: 简单的URL操作
  • Quick.RegEx.Utils: 常用的RegEx比较（电子邮件验证，密码复杂性等）
  • Quick.Conditions: 流畅风格的前后条件验证。
Quick.AppService：

允许控制台应用程序以控制台模式或服务模式运行相同的代码，从而简化调试任务。
  1. if not AppService.IsRunningAsService then
  2. begin
  3.     ...你的代码以控制台模式运行
  4. end
  5. else
  6. begin
  7.     AppService.ServiceName := 'MyService';
  8.     AppService.DisplayName := 'MyServicesvc';
  9.     //你可以将匿名方法传递给事件
  10.     AppService.OnStart := procedure
  11.                           begin
  12.                             ...你的启动代码
  13.                           end;
  14.     AppService.OnExecute := YourExecuteFunction;
  15.     AppService.OnStop := YourStopFunction;
  16.     AppService.CheckParams;
  17. end;
复制代码
Quick.Azure/Amazon：

简化了与Azure和Amazon云存储的blob交互。
  1. //连接到Azure blob存储
  2. QuickAzure := TQuickAzure.Create(AzureAccountName, AzureAccountKey);
  4. //将blob文件下载到流中
  5. done := QuickAzure.GetBlob('MyContainer', 'MyFile.jpg', ResponseInfo, MyStream);
  6.   
  7. //检查是否存在文件夹
  8. found := ExistFolder('MyContainer', '/Public/Documents/Personal');
  9.   
  10. //列出以特定模式开头的blobs（递归或非递归）
  11. for azBlob in ListBlobs('MyContainer', '/Public/Documents', Recursive, ResponseInfo) do
  12. begin
  13.     if azBlob.Size > 1000 then Showmessage(azBlob.Name);
  14. end;
复制代码
Quick.Network：

提供CIDR和IP范围功能。
  1. //将IP字符串转换为整数
  2. IPv4ToInt('192.168.1.10');
  4. //获取子网范围的第一个和最后一个IP
  5. GetIpRange('192.168.100.0', '255.255.255.0', LowIp, HighIP);
复制代码
Quick.Commons：

开发人员日常工作中经常需要的函数。
  1. //将UTC时间TDateTime转换为本地日期时间
  2. UTCToLocalTime(MyUTCTime);
  3.   
  4. //生成一个长度为10的随机密码，包含字母数字和符号。
  5. RandomPassword(10, [pfIncludeNumbers, pfIncludeSigns]);
  7. //将短语中的每个单词首字母大写
  8. CapitalizeAll('the grey fox'); //返回 "The Grey Fox"
  10. //简单的TCounter和TTimeCounter用于循环
  11. counter := TCounter;
  12. counter.Init(200);
  13. timecounter : TTimeCounter;
  14. timecounter.Init(10000);
  15. while true do
  16. begin
  17.     Inc(n);
  18.     {你的过程处理代码在这里}
  19.     //每200步写入控制台
  20.     if counter.Check then writeln(Format('Processed %d entries', [n]));
  21.     //每10秒写入控制台
  22.     if timecounter.Check then writeln('Im working...');
  23. end;
复制代码
Quick.Chrono：

计时器和代码基准测试很简单。
  1. //获取代码部分执行所消耗的时间
  2. Chrono := TChronometer.Create(False);
  3. Chrono.Start;
  4. ...你需要基准测试的代码
  5. Chrono.Stop;
  7. //以长时间格式显示经过的时间（例如2小时10分钟）
  8. Showmessage(Chrono.TimeElapsed(True));
  10. //以短时间格式显示经过的时间（例如02:10:00）
  11. Showmessage(Chrono.TimeElapsed(False));
  12. //获取进程的基准测试信息
  13. Chrono := TChronoBenchMark.Create;
  14. Chrono.TotalProcess := 100000;
  15. for i := 1 to 10000 do
  16. begin
  17.     {你的进程代码在这里}
  18.     Chrono.CurrentProcess := i;
  19.     //显示你的进程预计需要的时间，格式为x小时x分钟x秒
  20.     writeln(Chrono.EstimatedTime(True));
  21.     //显示你的进程处理速度：每秒处理的项数
  22.     writeln(Format('Items processed %d/sec', [Chrono.Speed]));
  23. end;
  24. writeln(Chrono.ElapsedTime(False)); //以00:00:00格式显示总经过时间
复制代码
Quick.Console：

将日志消息以不同颜色等写入控制台。
  1. //定义需要的输出级别
  2. Console.Verbose := LOG_DEBUG;
  4. //以红色在控制台上写行
  5. cout('Error x', etError);
  7. //以绿色格式化输出行
  8. coutFmt('Proccess %s finished', [ProccesName], etSuccess);
  10. //写整数
  11. cout(12348);
  13. //连接QuickLog并一行代码同时写入磁盘和屏幕（具有独立的详细级别）
  14. MyQuickLog := TQuickLog.Create;
  15. MyQuickLog.Verbose := LOG_ALL;
  16. Console.Verbose := LOG_ONLYERRORS;
  17. Console.Log := MyQuickLog;
复制代码
Quick.Log:

记录到磁盘或内存，具有详细的日志等级和每日或最大空间轮换功能。
  1. // 在开始时写入包含运行路径、应用程序名称、调试模式、用户等信息的页眉
  2. Log.ShowHeader := True;// 设置20MB时轮换的日志
  3. Log.SetLog('.\mylog.log',False,20);// 写入一条错误信息
  4. Log.Add('Error x',etError);// 写入格式化的错误信息
  5. Log.Add('Error is %s',[ErrorStr],etError);Quick.Config:
  6. 以Json、Yaml文件或Windows注册表项的形式加载/保存配置。从TAppConfigJson、TAppConfigYaml或TAppConfigRegistry创建一个派生类，并添加将加载/保存的已发布的属性。当检测到文件更改时，可以重新加载文件配置。// 创建一个类继承
  7. TMyConfig = class(TAppConfigJson)
  8. private
  9.     fName : string;
  10.     fSurname : string;
  11.     fStatus : Integer;
  12. published
  13.     property Name : string read fName write fName;
  14.     property SurName : string read fSurname write fSurname;
  15.     property Status : Integer read fStatus write fStatus;
  16. end;// 将配置创建为json文件
  17. // 在您的uses中添加Quick.Config.Json
  18. MyConfig := TMyConfig.Create('Config.json');
  19. MyConfig.Provider.CreateIfNotExists := True;
  20. MyConfig.Provider.ReloadIfFileModified := True;
  21. MyConfig.Name := 'John';
  22. MyConfig.Surname := 'Smith';
  23. // 加载
  24. MyConfig.Load;
  25. // 保存
  26. MyConfig.Save;// 将配置创建到Windows注册表中
  27. // 在您的uses中添加Quick.Config.Registry
  28. MyConfig := TMyConfig.Create;
  29. // 将注册表定义为HKEY_CURRENT_USER\Software\MyApp
  30. MyConfig.HRoot := HKEY_CURRENT_USER;
  31. MyConfig.MainKey := 'MyApp';
  32. MyConfig.Name := 'John';
  33. MyConfig.Surname := 'Smith';
  34. // 加载
  35. MyConfig.Load;
  36. // 保存
  37. MyConfig.Save;// 创建一个没有默认提供者的自定义配置
  38. TMyConfig = class(TAppConfig)
  39. ... 您的属性
  40. end;MyConfig := TMyConfig.Create(TAppConfigJsonProvider.Create('.\config.json');
复制代码
Quick.FileMonitor:

监视文件的更改并触发事件。
  1. FileMonitor.Filename := '.\myfile.txt';
  2. // 每2秒检查一次文件更改
  3. FileMonitor.Interval := 2000;
  4. // 监视文件被删除或修改的事件
  5. FileMonitor.Notifies := [mnFileModified, mnFileDeleted)];
  6. FileMonitor.OnFileChange := MyFileChangeFunction;
  7. FileMonitor.Enabled := True;
复制代码
Quick.JsonUtils:

用于处理json对象的工具。
  1. // 当在uses中声明单元时，TObject Helper允许将所有对象从/加载到json字符串
  2. MyObject.FromJson := jsonstring;
  3. MyString := MyObject.ToJson;// 您可以使用clone函数克隆简单对象
  4. MyObject1.Clone(MyObject2);
复制代码
Quick.SMTP:

用两行代码发送电子邮件。
  1. // 发送电子邮件
  2. SMTP := TSMTP.Create('mail.domain.com',25,False);
  3. SMTP.SendMail('my@email.com','to@email.com','Email subject','My message body');// 您可以定义更高级的选项
  4. SMTP.SenderName := 'John';
  5. SMTP.From := 'my@email.com';
  6. SMTP.Recipient := 'one@email.com,two@email.com';
  7. SMTP.Subject := 'Email subject';
  8. SMTP.AddBodyFromFile := '.\body.html';
  9. SMTP.CC := 'other@email.com';
  10. SMTP.BCC := 'more@email.com';
  11. SMTP.Attachments.Add('.\notes.txt');
  12. SMTP.SendMail;
复制代码
Quick.Threads:

线程安全类。
TThreadedQueueCS: 使用临界区的TThreadedQueue版本。
TThreadObjectList: 线程安全的对象列表。
TThreadedQueueList: 线程安全的队列列表。支持自动增长和临界区。
TAnonymousThread: 创建匿名线程，定义非链式的Execute和OnTerminate方法。如果代码需要更新UI，请使用Execute_Sync和OnTerminate_Sync方法。

  • Execute: 指定启动时执行的代码。
  • Execute_Sync: 与Execute类似，但使用同步线程方法运行代码（避免如果代码更新UI时出现问题）。
  • OnTerminate: 指定任务完成时执行的代码。
  • OnTerminate_Sync: 与OnTerminate类似，但使用同步线程方法运行代码（避免如果代码更新UI时出现问题）。
  • Start: 启动线程执行。
  1. // 简单的匿名线程
  2. TAnonymousThread.Execute(
  3.       procedure
  4.       var
  5.         i : Integer;
  6.       begin
  7.         for i := 0 to 10 do cout('Working %d',[i],etTrace);
  8.         cout('executed thread',etSuccess);
  9.       end)
  10.     .OnTerminate(
  11.       procedure
  12.       begin
  13.         cout('terminated thread',etSuccess);
  14.         cout('PRESS <ENTER> TO EXIT',etInfo);
  15.       end)
  16.     .Start;
复制代码
TRunTask: 启动一个自动释放的单任务线程，具有故障和重试控制策略。可以在代码中传递和创建参数。

  • 定义要执行的代码:

    • Execute: 指定任务名称、传递给匿名方法的参数（如果OwnedParams=true，任务将在终止时释放参数）以及将要执行的方法。
    • Execute_Sync: 与Execute类似，但使用同步线程方法运行代码（避免如果代码更新UI时出现问题）。
    • SetParameter: 定义任务所需的值或对象。

  • 定义控制事件:

    • OnInitialize: 在主执行任务之前运行指定的代码（此代码仅运行一次，OnExecute可以重试多次）
    • OnRetry: 当执行失败时指定要运行的代码，并决定是否需要重试或取消后续重试。
    • OnTerminate: 指定任务完成时执行的代码。
    • OnTerminate_Sync: 与OnTerminate类似，但使用同步线程方法运行代码（避免如果代码更新UI时出现问题）。
    • OnException: 当任务引发异常时指定要执行的代码。

  • 定义故障/重试策略:

    • RetryForever: 如果执行失败，代码将无限次重试，直到任务执行成功。
    • Retry: 如果执行失败，代码将重试x次。
    • WaitAndRetry: 如果执行失败，代码将重试x次，并在每次重试之前等待x毫秒。您可以指定重试次数和重试之间的等待时间。
    • Run: 启动任务执行。

  1.   TRunTask.Execute(
  2.       procedure(task : ITask)
  3.       var
  4.         stream : TStringStream;
  5.         response : IHttpRequestResponse;
  6.       begin
  7.         stream := TStringStream.Create;
  8.         try
  9.           response := TJsonHttpClient(task['httpclient'].AsObject).Get(task['url']);
  10.           task.Result := response.StatusCode;
  11.           if response.StatusCode <> 200 then raise Exception.Create(response.StatusText);
  12.         finally
  13.           stream.Free;
  14.         end;
  15.       end)
  16.     .SetParameter('httpclient',(TJsonHttpClient.Create),True)
  17.     .SetParameter('url','https://mydomain.com/testfile')
  18.     .WaitAndRetry(5,250,2)
  19.     .OnRetry(
  20.       procedure(task : ITask; aException : Exception; var vStopRetries : Boolean)
  21.       begin
  22.         //if error 404 don't try to retry request
  23.         if task.Result = 404 then vStopRetries := True;
  24.       end)
  25.     .OnException(
  26.       procedure(task : ITask; aException : Exception)
  27.       begin
  28.         coutFmt('Exception downloading (Error: %s / StatusCode: %d)...',[aException.Message,task.Result.AsInteger],etError);
  29.       end)
  30.     .OnTerminated(
  31.       procedure(task : ITask)
  32.       begin
  33.         if task.Done then coutFmt('Download "%s" finished ok',[task['url'].AsString],etSuccess)
  34.           else coutFmt('Download "%s" failed after %d retries',[task['url'].AsString,task.NumRetries],etError);
  35.       end)
  36.     .Run;
复制代码
TBackgroundsTasks: 在后台启动任务，允许一定数量的并发工作线程，并具有故障和重试控制策略。如果代码需要更新UI，请使用AddTask_Sync和OnTerminate_Sync方法。

  • 添加要执行的任务:

    • AddTask: 指定任务名称、传递给匿名方法的参数（如果OwnedParams=true，任务将在过期时释放参数）以及将要执行的方法。
    • AddTask_Sync: 与AddTask类似，但使用同步线程方法运行代码（避免如果代码更新UI时出现问题）。
    • SetParameter: 定义任务所需的值或对象。每个参数都将在匿名方法中作为task[]或task.[index]访问。

  • 定义控制事件:
    （与TRunTask类似，此处省略）
  • 定义故障/重试策略:
    （与TRunTask类似，此处省略）
  • 开始执行:

    • Start: 开始执行任务。

  1.     backgroundtasks := TBackgroundTasks.Create(10);
  2.     for i := 1 to 100 do
  3.     begin
  4.       mytask := TMyTask.Create;
  5.       mytask.Id := i;
  6.       mytask.Name := 'Task' + i.ToString;
  7.       backgroundtasks.AddTask([mytask],False,
  8.                               procedure(task : ITask)
  9.                               begin
  10.                                 cout('task %d started',[TMyTask(task.Param[0].AsObject).Id],etDebug);
  11.                                 TMyTask(task.Param[0].AsObject).DoJob;
  12.                               end
  13.                                                         ).WaitAndRetry([250,2000,10000])
  14.                             ).OnException(
  15.                               procedure(task : ITask; aException : Exception)
  16.                               begin
  17.                                 cout('task %d failed (%s)',[TMyTask(task.Param[0].AsObject).Id,aException.Message],etError);
  18.                               end
  19.                             ).OnTerminated(
  20.                               procedure(task : ITask)
  21.                               begin
  22.                                 cout('task %d finished',[TMyTask(task.Param[0].AsObject).Id],etDebug);
  23.                                 TMyTask(task.Param[0].AsObject).Free;
  24.                               end
  25.                             ).Run;
  26.     end;
  27.     backgroundtasks.Start;
复制代码
TScheduledTasks: 定时器的替代方案。您可以分配具有开始时间、重复选项、到期日期和故障及重试控制策略的任务。如果代码需要更新UI，请使用AddTask_Sync、OnTerminate_Sync和OnExpired_Sync方法。
您可以为执行、异常、终止和到期事件分配匿名方法。

  • 添加要执行的任务:
    （与TRunTask和TBackgroundTasks类似，此处省略）
  • 定义控制事件:
    （与TRunTask类似，但增加了OnExpire和OnExpire_Sync）
  • 定义何时开始任务:

    • StartNow: 立即启动任务。
    • StartAt: 任务启动的日期和时间。
    • ...（其他开始选项，此处省略）

  • 定义是否需要重复或不重复（如果未定义之前的StartAt、StartOn等，任务将立即执行）:

    • RunOnce: 任务仅执行一次。
    • RepeatEvery: 可以指示重复步骤的时间间隔和到期日期。
    • ...（其他重复选项，此处省略）

  • 定义故障/重试策略:
    （与TRunTask类似，此处省略）
  • 启动/停止调度器:

    • Start: 启动调度器。
    • Stop: 停止调度器。

  1. myjob := TMyJob.Create;
  2. myjob.Name := Format('Run at %s and repeat every 1 second until %s',[DateTimeToStr(ScheduledDate),DateTimeToStr(ExpirationDate)]);
  3. scheduledtasks.AddTask('Task1',[myjob],True,
  4.                             procedure(task : ITask)
  5.                             begin
  6.                               cout('task "%s" started',[TMyTask(task.Param[0]).Name],etDebug);
  7.                               TMyJob(task.Param[0]).DoJob;
  8.                             end
  9.                           ).OnException(
  10.                             procedure(task : ITask; aException : Exception)
  11.                             begin
  12.                               cout('task "%s" failed (%s)',[TMyJob(task.Param[0]).Name,aException.Message],etError);
  13.                             end
  14.                           ).OnTerminated(
  15.                             procedure(task : ITask)
  16.                             begin
  17.                               cout('task "%s" finished',[TMyJob(task.Param[0]).Name],etDebug);
  18.                             end
  19.                           ).OnExpired(
  20.                             procedure(task : ITask)
  21.                             begin
  22.                               cout('task "%s" expired',[TMyJob(task.Param[0]).Name],etWarning);
  23.                             end
  24.                           ).StartAt(ScheduledDate
  25.                           ).RepeatEvery(1,TTimeMeasure.tmSeconds,ExpirationDate);
  26. scheduledtasks.Start;
复制代码
ITask: 传递给TRunTask、TBackgroundTasks和TScheduledTasks的每个任务事件的接口。

  • NumWorker: 返回分配给执行任务的工作线程数。
  • Result: 可以存储任何值类型（TFlexValue类似于变体类型）
  • Param[name]: 可以存储传递给任务的参数或在每个传递给事件的匿名方法中动态创建的参数。
  • Param[index]: 可以存储传递给任务的参数或在每个传递给事件的匿名方法中动态创建的参数。
  • Done: 如果任务没有错误地执行，则返回true。
  • Failed: 如果任务失败，则返回true。
  • IdTask: 定义的任务ID。
  • NumRetries: 已完成的重试次数。
  • MaxRetries: 在将任务标记为失败之前允许的最大重试次数。
  • LastException: 返回失败任务的最后一个异常。
  • CircuitBreaked: 如果已达到最大重试次数或在OnRetry事件中用户取消了重试，则返回true。
  • IsEnabled: 返回任务的状态。
Quick.FaultControl:

管理失败和重试策略，定义最大重试次数、重试之间的等待时间和熔断机制。
Quick.Process:

管理Windows进程。
  1. // 终止explorer进程
  2. KillProcess('explorer.exe');
  3. // 判断一个应用程序是否正在运行
  4. if IsProcessRunning('explorer.exe') then Showmessage('Explorer正在运行！');
  5. // 获取运行exe的用户名
  6. writeln('Explorer.exe由以下用户打开：' + GetProcessUser('explorer.exe'));
  7. // 使用20秒的超时获取窗口句柄
  8. if FindWindowTimeout('MainWindow',20) then writeln('检测到窗口');
复制代码
Quick.Services:

管理Windows服务。
  1. // 检测服务是否已安装
  2. if not ServiceIsPresent('localhost','MySvc') then raise Exception.Create('服务未安装！');
  3. // 启动服务
  4. ServiceStart('localhost','MySvc');
  5. // 卸载服务
  6. ServiceUninstall('MySvc');
复制代码
Quick.Format:

字符串格式化。
  1. // 将字节格式化为MB、GB、TB...
  2. FormatBytes(50000) // 显示 50KB
  3. FormatBytes(90000000) // 显示 90MB
复制代码
Quick.JsonSerializer:

将对象序列化为json文本或从json文本反序列化为对象。您可以定义是否处理公开或已发布的属性（仅Delphi，fpc rtti仅支持已发布的属性）。
  1. json := '{"name":"Peter","age":30}';
  2. serializer := TJsonSerializer.Create(TSerializeLevel.slPublishedProperty);
  3. try
  4.    serializer.JsonToObject(user,json);
  5. finally
  6.    serializer.Free;
  7. end;
复制代码
Quick.AutoMapper:

将一个类的字段映射到另一个类。允许自定义映射以匹配不同的字段，并允许自定义映射过程以手动转换字段。
  1. // 将User1的值映射到User2
  2. TMapper<TUser2>.Map(User);
  4. // 自定义映射
  5. AutoMapper := TAutoMapper<TUser,TUser2>.Create;
  7. // 选项1：您可以定义自动映射不同名称的属性
  8. AutoMapper.CustomMapping.AddMap('Cash','Money');
  9. AutoMapper.CustomMapping.AddMap('Id','IdUser');
  11. // 选项2：您可以决定手动修改每个属性或允许自动映射某些属性
  12. AutoMapper.OnDoMapping := procedure(const aSrcObj : TUser; const aTargetName : string; out Value : TFlexValue)
  13.                           begin
  14.                             if aTargetName = 'Money' then Value := aSrcObj.Cash * 2
  15.                               else if aTargetName = 'IdUser' then Value := aSrcObj.Id;
  16.                           end;
  18. // 选项3：您可以在自动映射完成后修改某些属性
  19. AutoMapper.OnAfterMapping := procedure(const aSrcObj : TUser; aTgtObj : TUser2)
  20.                              begin
  21.                                aTgtObj.Money := aSrcObj.Cash * 2;
  22.                                aTgtObj.IdUser := aSrcObj.Id;
  23.                              end;
  25. User2 := AutoMapper.Map(User);
复制代码
Quick.JsonRecord:

用作DTO类，包含json序列化和映射功能。
  1. type
  2.    TUser = class(TJsonRecord)
  3.    private
  4.       fName : string;
  5.       fAge : Integer;
  6.    published
  7.       property Name : string read fName write fName;
  8.       property Age : Integer read fAge write fAge;
  9.    end;
  10. var
  11.    user, user2 : TUser;
  12. begin
  13.    user := TUser.Create;
  14.    // 展示为json字符串
  15.    Writeln(user.ToJson);
  16.    // 映射到其他类
  17.    user.MapTo(user2);
  18.    Writeln(user2.ToJson);
  19.    // 从文件加载
  20.    user.LoadFromFile('.\user.json');
  21.    // 保存到文件
  22.    user2.SaveToFile('.\user2.json');
  23. end;
复制代码
Quick.Lists:

带有索引或搜索功能的改进列表。

  • TIndexedObjectList: 允许通过对象属性或字段进行快速哈希搜索。
  • TSearchObjectList: 允许通过对象属性或字段进行迭代搜索。
  1. var
  2.    users : TIndexedObjectList<TUser>;
  3. begin
  4.    users := TIndexedObjectList<TUser>.Create(True);
  5.    // 根据属性"Name"创建索引
  6.    users.Indexes.Add('Name','Name',TClassField.cfProperty);
  7.    // 根据私有字段"Id"创建索引
  8.    users.Indexes.Add('Id','fId',TClassField.cfField);
  9.    // 通过"Name"索引获取用户
  10.    writeln(users.Get('Name','Peter').SurName);
  11. end;
复制代码
Quick.Value

FlexValue可以存储任何数据类型，并允许使用集成操作符和自动释放功能传递给其他类。
  1. var
  2.   value : TFlexValue;
  3.   str : string;
  4.   num : Integer;
  5. begin
  6.   value := 'hello';
  7.   str := value;
  8.   value := 123;
  9.   num := value;
  10. end;
复制代码
Quick.Arrays:

改进的数组。
TXArray: 带有类似TList方法的数组。
（注意：下面的代码段似乎被错误地复制了 TIndexedObjectList的示例，这里应该展示 TXArray的使用。）
  1. var
  2.    users : TXArray<TUser>;
  3. begin
  4.    users := TXArray<TUser>.Create;
  5.    users.Add(User); // 假设User已经是一个TUser类型的对象
  6.    // ... 其他TXArray的操作
  7. end;
复制代码
TFlexArray: 可以存储不同值类型的数组，类似于TList。
  1. var
  2.   flexarray : TFlexArray;
  3. begin
  4.     flexarray.Add(10);
  5.     flexarray.Add('Hello');
  6.     user := TUser.Create;
  7.     try
  8.       user.Name := 'Joe';
  9.       flexarray.Add(user);
  11.       cout('Integer Item = %d',[flexarray[0].AsInteger],etInfo);
  12.       cout('String Item = %s',[flexarray[1].AsString],etInfo);
  13.       cout('Record Item = %s',[TUser(flexarray[2]).Name],etInfo);
  14.     finally
  15.       user.Free;
  16.     end;
  17. end;
复制代码
TFlexPairArray: 可以存储不同值类型的数组，并可以通过项目名称进行搜索，类似于TList。
  1. var
  2.   flexarray : TFlexPairArray;
  3. begin
  4.     flexarray.Add('onenumber',10);
  5.     flexarray.Add('other','Hello boy!');
  6.     user := TUser.Create;
  7.     try
  8.       user.Name := 'Joe';
  9.       flexarray.Add('myuser',user);
  11.       cout('Integer Item = %d',[flexarray.GetValue('onenumber').AsInteger],etInfo);
  12.       cout('String Item = %s',[flexarray.GetValue('other').AsString],etInfo);
  13.       cout('Record Item = %s',[TUser(flexarray.GetValue('myuser')).Name],etInfo);
  14.     finally
  15.       user.Free;
  16.     end;
  17. end;
复制代码
Quick.YAML:

Yaml对象结构。
TYamlObject: Yaml对象是一个Yaml值对的数组。
  1. // 从yaml文本创建Yaml对象
  2. yamlobj.ParseYamlValue(aYaml);
  3. // 添加一个对
  4. yamlobj.AddPair('Name','Mike');
  5. // 显示为yaml结构
  6. Writeln(yamlobj.ToYaml);
复制代码
TYamlArray: 对象或标量的数组。
  1. yamlarray.AddElement(TYamlPair.Create('Age',30));
  2. yamlobj.AddPair('myarray',yamlarray);
复制代码
TYamlPair: 名称-值对。值可以是对象、数组或标量。
  1. n := yamlobj.GetPair('Name').Value as TYamlInteger;
复制代码
Quick.YAML.Serializer:

将对象序列化/反序列化为Yaml。
  1. // 序列化
  2. text := YamlSerializer.ObjectToYaml(obj);
  3. // 反序列化
  4. YamlSerializer.YamlToObject(obj, yamltext);
复制代码
Quick.Expression:

使用表达式评估对象属性或单个值。
  1. if TExpressionParser.Validate(user, '(Age > 30) AND (Dept.Name = "Financial")') then
  2. begin
  3.   // 执行一些操作
  4. end;
  6. if TExpressionParser.Validate(user, '(20 > 30) OR (5 > 3)') then
  7. begin
  8.   // 执行一些操作
  9. end;
复制代码
Quick.Linq:

对任何 TObjectList、TList、TArray和 TXArray执行Linq查询，通过类似SQL语法的复杂Where子句进行Select、更新和排序列表。Where子句使用命名空间来确定嵌套属性。Linq可以在属性数组中搜索元素。
现在包括一个 TArray助手，用于在数组中添加、删除和通过正则表达式搜索。

  • From: 要使用的数组、XArray或TObjectList。
  • Where: 搜索表达式。可以使用点来定义属性路径。
  • SelectAll: 返回匹配Where子句的对象数组。
  • SelectTop: 返回匹配Where子句的前x个对象。
  • SelectFirst: 返回匹配Where子句的第一个对象。
  • SelectLast: 返回匹配Where子句的最后一个对象。
  • OrderBy: 定义返回列表的顺序。
  • Update: 更新匹配Where子句的字段。
  • Delete: 删除匹配Where子句的对象。
  • Count: 返回匹配Where子句的元素数量。
  1. // 多条件选择
  2. for user in TLinq<TUser>.From(userslist).Where('(Name = ?) OR (SurName = ?) OR (SurName = ?)', ['Peter', 'Smith', 'Huan']).Select do
  3. begin
  4.   // 执行一些操作
  5. end;
  7. // 选择并更新字段
  8. TLinq<TUser>.From(userlist).Where('SurName Like ?', ['%son']).SelectFirst.Name := 'Robert';
  10. // 选择顶部并按字段排序
  11. for user in TLinq<TUser>.From(userlist).Where('Age > ?', [18]).SelectTop(10).OrderBy('Name') do
  12. begin
  13.   // 执行一些操作
  14. end;
  16. // 按条件更新字段
  17. TLinq<TUser>.From(userlist).Where('Name = ?', ['Peter']).Update(['Name'], ['Joe']);
  19. // 计数结果
  20. numusers := TLinq<TUser>.From(userlist).Where('(Age > ?) AND (Age < ?)', [30, 40]).Count;
复制代码
Quick.HTTPServer:

TCustomHttpServer是一个简单的接口HttpServer，具有自己的HttpRequest和HttpResponse实现，允许轻松更改HttpServer引擎。
您可以启用自定义错误页面以返回自定义页面和动态错误页面。
THttpServer是IndyHttpServer的实现，但您可以定义自己的实现。
  1. TMyHttpServer = class(THttpServer)
  2. public
  3.   procedure ProcessRequest(aRequest: IHttpRequest; aResponse: IHttpResponse); override;
  4. end;
  6. procedure TMyHttpServer.ProcessRequest(aRequest: IHttpRequest; aResponse: IHttpResponse);
  7. begin
  8.   aResponse.ContentText := 'Hello world!';
  9. end;
复制代码
Quick.MemoryCache:

使用过期时间缓存对象或字符串，以避免每次需要时都生成这些信息（数据库查询、难以计算的信息等）。TMemoryCache允许缓存对象和字符串。泛型版本TMemoryCache 仅允许缓存定义的类型。

  • 创建：可以定义清除间隔、序列化和压缩引擎。默认情况下，它使用Json进行序列化并使用gzip进行压缩。
  1. // 创建具有10秒清除间隔的MemoryCache
  2. cache := TMemoryCache.Create(10);
  4. // 为特定类型创建MemoryCache
  5. cache := TMemoryCache<TMyObj>.Create;
复制代码

  • 压缩：启用/禁用缓存数据压缩。
  • CachedObjects：返回当前缓存中的对象数量。
  • CacheSize：返回当前缓存中所有对象的字节大小。实际使用的内存取决于内存管理器或架构。此值是数据字节的实际大小。
  • PurgeInterval：清除作业尝试查找已过期对象以从缓存中删除的时间间隔（默认值为20秒）。
  • OnCacheFlushed：当缓存被刷新时。
  • OnBeginPurgerJob：当清除作业开始时。
  • OnEndPurgerJob：当清除作业结束时。
  • Flush：删除所有缓存对象。
  • SetValue：将对象添加到缓存。可以指示过期日期或毫秒数来过期。如果没有定义，缓存将是无限的。MemoryCache可以存储对象或字符串。
  1. // 将字符串设置到缓存中，没有过期时间
  2. cache.SetValue('mystring', 'hello world');
  4. // 将字符串设置到缓存中，10秒后过期
  5. cache.SetValue('mystring', '这个缓存将在10秒后过期');
  7. // 将对象设置到缓存中
  8. cache.SetValue('Obj1', valueobj);
复制代码

  • TryGetValue：尝试从缓存中获取对象。如果对象不存在或已过期，则返回false。
  1. // 获取字符串查询结果
  2. cache.GetValue('Query12');
  4. // 获取整数
  5. cache.TryGetValue<Integer>('number', valueint);
  7. // 获取对象
  8. cache.TryGetValue('Obj1', valueobj);
复制代码

  • RemoveValue：从缓存中删除对象。
  • 缓存引擎提供程序：
  • TCacheSerializerJSON：使用JSON序列化缓存数据。
  • TCacheCompressorGzip：使用Gzip压缩缓存数据。
  • TCacheCompressorLZO：使用LZO压缩缓存数据。
  1. // 创建具有20秒清除间隔并使用LZO引擎压缩的MemoryCache
  2. cache := TMemoryCache.Create(10, nil, TCacheCompressorLZO.Create);
复制代码
Quick.IOC:

控制反转管理器允许自动创建接口或实例化对象，或在构造函数类中自动注入它们，以避免依赖关系。
创建一个容器来管理依赖注入。
  1. iocContainer := TIocContainer.Create;
复制代码
注册类型：
在注入之前，您需要注册类型。类型可以作为Singleton或Transient注册。
Singleton：生命周期将是所有注入的一个单一实例，类似于全局变量。
Transient：生命周期将是每次注入的一个新实例。
将接口类型作为Transient注册到容器中：
  1. iocContainer.RegisterType<IMultService, TMultService>.AsTransient;
复制代码
将接口类型作为Singleton注册，并委托构造：
  1. iocContainer.RegisterType<ISumService, TSumService>.AsSingleTon.DelegateTo(
  2.   function : TSumService
  3.   begin
  4.     Result := TSumService.Create;
  5.   end
  6. );
复制代码
注册实例：
将命名实例对象作为Transient注册，并委托构造：
  1. iocContainer.RegisterInstance<TDivideService>('one').AsTransient.DelegateTo(
  2.   function : TDivideService
  3.   begin
  4.     Result := TDivideService.Create(True);
  5.   end
  6. );
复制代码
注册选项：
注册IOptions（仅适用于Singleton）：
  1. iocContainer.RegisterOptions<TMyOptions>(MyOptions);
复制代码
解析类型：
AbstractFactory：
尝试使用依赖注入解析所有创建方法参数来创建类。
  1. MyClass := iocContainer.AbstractFactory<TMyBaseClass>(TMyClass);
复制代码
解析接口依赖：
  1. multservice := iocContainer.Resolve<IMultService>;
  2. result := multservice.Mult(2, 4);
复制代码
解析实例：
解析命名实例依赖：
  1. divideservice := iocContainer.Resolve<TDivideService>('other');
  2. result := divideservice.Divide(100, 2);
复制代码
接口实例将自动释放，但实例依赖项仅当定义为Singleton时才会被释放，Transient实例将由代码销毁。#3
Quick.Options:

您可以将部分定义为类，并将其保存为单个文件设置。其工作方式类似于dotnet Options。选项文件可以是JSON或YAML格式。
定义从TOptions继承的选项类，所有已发布的属性都将被加载/保存。
创建选项容器，使用JsonSerializer并在更改时重新加载：
  1. Options := TOptionsContainer.Create('.\options.conf', TJsonOptionsSerializer.Create, True);
复制代码
向容器选项添加一个部分：
  1. Options.AddSection<TLoggingOptions>('Logging');
复制代码
配置选项：
您可以定义要保存到文件中的部分名称，并委托配置默认设置和验证值：
  1. Options.AddSection<TLoggingOptions>('Logging').ConfigureOptions(
  2.   procedure(aOptions: TLoggingOptions)
  3.   begin
  4.     aOptions.Path := 'C:\';
  5.   end
  6. ).ValidateOptions;
复制代码
验证选项：
验证选项允许验证选项设置是否在定义的范围内。此验证需要先在TOptions类中的属性上分配自定义属性。

  • StringLength(max, messagestr): 允许在字符串属性中定义最大长度，如果长度大于最大值，则返回messagestr。
  • Range(min, max, messagestr): 允许定义允许的最小值和最大值范围，如果值超出边界，则返回messagestr。
  1. TLoggingOptions = class(TOptions)
  2.   private
  3.     fPath : string;
  4.   published
  5.     [Required, StringLength(255, 'Path too long')]
  6.     property Path : string read fPath write fPath;
  7.     [Range(0.0, 5.2)]
  8.     property Level : Double read fLevel write fLevel;
  9.   end;
复制代码
使用选项：
检索选项部分：
  1. LoggingOptions := Options.GetSection<TLoggingOptions>;
  2. LoggingOptions.Path := 'C:\Path';
复制代码
使用IOptions:
IOptions是一个可注入依赖的TOptions接口。您可以使用IocContainer.RegisterOptions 注册它以使其可注入到构造函数方法中。
  1. UIOptions := Options.GetSectionInterface<TUIOptions>.Value;
  2. UIOptions.WindowColor := clBlue;
复制代码
加载/保存选项：
从文件设置中加载选项：
  1. options.Load;
复制代码
将选项保存到文件设置：
  1. options.Save;
复制代码
如果您在创建容器时定义了ReloadOnChanged参数为true，则每次文件设置更改时，配置都将重新加载。如果您需要控制何时重新加载，可以监听事件：
  1. Options.OnFileModified := procedure
  2.   begin
  3.     cout('Detected config file modification!', etWarning);
  4.   end;
复制代码
Quick.Pooling:

定义连接池、线程池或您想要控制的任何对象池，以避免资源消耗，如数据库连接、HTTP客户端等。
创建HTTP客户端池：
  1. pool := TObjectPool<THTTPClient>.Create(5, 5000, procedure(var aInstance: THTTPClient)
  2.         begin
  3.           aInstance := THTTPClient.Create;
  4.           aInstance.UserAgent := 'MyAgent';
  5.         end);
复制代码
从池中获取对象：
  1. httpcli := pool.Get.Item;
  2. statuscode := httpcli.Get('https://www.mydomain.com').StatusCode;
复制代码
Quick.Collections:

定义了具有linQ支持的接口List和ObjectList。

  • TXList  / IList ：允许使用LinQ进行正则表达式搜索/删除/更新的接口List。
  1. myarray := ['Joe', 'Mat', 'Lee'];
  2. // 搜索正则表达式匹配项
  3. cout('Search for regex match', ccYellow);
  4. for name in myarray.Where('e$', True).Select do
  5. begin
  6.   cout('User %s ends with "e"', [name], etInfo);
  7. end;
复制代码

  • TXObjectList  / IObjectList ：允许使用LinQ谓词或表达式进行搜索/删除/更新的接口ObjectList。
    表达式搜索：
  1. user := ListObj.Where('Profile.Name = ?', ['Lee']).SelectFirst;
复制代码
对项数组的表达式搜索：
  1. users := ListObj.Where('Roles CONTAINS ?', ['SuperAdmin']).Select;
复制代码
谓词搜索：
  1. user := ListObj.Where(function(aUser: TUser): Boolean
  2.       begin
  3.         Result := aUser.Name.StartsWith('J');
  4.       end).SelectFirst;
  5.     if user <> nil then cout('%s starts with J letter', [user.Name], etInfo);
复制代码
查看Quick.Linq部分以查看更多允许的函数。
Quick.Template:

使用字典或委托函数进行字符串模板替换。您可以指定引号的标记字符。
通过传递字典进行替换：
  1. dict := TDictionary<string, string>.Create;
  2. dict.Add('User', 'John');
  3. dict.Add('Age', '20');
  4. dict.Add('SurName', 'Peterson');
  5. mytemplate := 'User {{User}} {{SurName}} are {{Age}} years old.';
  6. template := TStringTemplate.Create('{{', '}}', dict);
  7. Result := template.Replace(mytemplate);
复制代码
使用委托函数进行替换：
  1. mytemplate := 'User {{User}} {{SurName}} are {{Age}} years old.';
  2. template := TStringTemplate.Create('{{', '}}', function(const aToken: string): string
  3.   begin
  4.     if aToken = 'User' then Result := 'John'
  5.     else if aToken = 'SurName' then Result := 'Peterson'
  6.     else if aToken = 'Age' then Result := '20';
  7.   end);
  8. Result := template.Replace(mytemplate);
复制代码
Quick.Debug.Utils:

调试工具，用于检查性能并获取进入和退出方法的检查点。通过Debug编译器指令定义，仅在应用程序以调试模式编译时激活。
在控制台应用程序中，默认使用控制台输出。您可以传递一个记录器以输出到：
  1. TDebugUtils.SetLogger(ilogger);
复制代码
跟踪代码的一部分：
  1. function TCalculator.Subs(a, b: Int64): Int64;
  2. begin
  3.   {$IFDEF DEBUG}
  4.   TDebugger.Trace(Self, Format('Substract %d - %d', [a, b]));
  5.   {$ENDIF}
  6.   Result := a - b;
  7.   // 模拟工作200毫秒
  8.   Sleep(200);
  9. end;
  10. // 返回：
  11. // 29-06-2020 23:31:41.391  [TRACE] TCalculator -> Substract 30 - 12
复制代码
计算从点到退出函数的处理时间：
  1. function TCalculator.Sum(a, b: Int64): Int64;
  2. begin
  3.   {$IFDEF DEBUG}
  4.   TDebugger.TimeIt(Self, 'Sum', Format('Sum %d + %d', [a, b]));
  5.   {$ENDIF}
  6.   Result := a + b;
  7.   // 模拟工作1秒
  8.   Sleep(1000);
  9. end;
  10. // 返回：
  11. // 29-06-2020 22:58:45.808  [CHRONO] TCalculator.Sum -> Sum 100 + 50 = 1,00s
复制代码
计算从点到点以及退出函数的处理时间：
  1. function TCalculator.Divide(a, b: Int64): Double;
  2. begin
  3.   {$IFDEF DEBUG}
  4.   var crono := TDebugger.TimeIt(Self, 'Divide', Format('Divide %d / %d', [a, b]));
  5.   {$ENDIF}
  6.   Result := a / b;
  7.   // 模拟工作500毫秒
  8.   Sleep(500);
  9.   {$IFDEF DEBUG}
  10.   crono.BreakPoint('Only divide');
  11.   {$ENDIF}
  12.   // 模拟工作1秒
  13.   Sleep(1000);
  14.   {$IFDEF DEBUG}
  15.   crono.BreakPoint('Only Sleep');
  16.   {$ENDIF}
  17. end;
  18. // 返回：
  19. // 29-06-2020 23:25:46.223  [CHRONO] TCalculator.Divide -> First point = 500,18ms
  20. // 29-06-2020 23:25:47.224  [CHRONO] TCalculator.Divide -> Second point = 1,00s
  21. // 29-06-2020 23:25:47.225  [CHRONO] TCalculator.Divide -> Divide 10 / 2 = 1,50s
复制代码
当进入和退出函数时获取通知，并计算时间：
  1. function TCalculator.Mult(a, b: Int64): Int64;
  2. begin
  3.   {$IFDEF DEBUG}
  4.   TDebugger.Enter(Self, 'Mult').TimeIt;
  5.   {$ENDIF}
  6.   Result := a * b;
  7.   // 模拟工作2秒
  8.   Sleep(2000);
  9. end;
  10. // 返回：
  11. // 29-06-2020 22:58:45.808  [ENTER] >> TCalculator.Mult
  12. // 29-06-2020 22:58:47.810  [EXIT] >> TCalculator.Mult in 2,00s
复制代码
Quick.Parameters:

使用命令行扩展，可以轻松处理命令行参数。
定义一个从TParameters或TServiceParameters（如果使用QuickAppServices）继承的类，将可能的参数作为已发布的属性：
  1. uses
  2.   Quick.Parameters;
  3. type
  4.   TCommand = (Copy, Move, Remove);
  5.   TMyMode = (mdAdd, mdSelect, mdRemove);
  7.   [CommandDescription('使用Quick.Parameters的简单控制台应用程序示例')]
  8.   TMyParameter = class(TParameters)
  9.   private
  10.     // ... [私有成员]
  11.   published
  12.     // ... [已发布的属性]
  13.   end;
复制代码
使用参数：
  1. params := TMyParameter.Create;
复制代码
当您使用--help调用exe时，将获得文档。如果需要检查开关或值，可以这样做：
  1. if params.Port = 0 then ...
  2. if params.Silent then ...
复制代码
QuickParameters使用自定义属性来定义特殊的参数条件：

  • CommandDescription: 定义在帮助文档中描述您的应用程序的文本。
  • ParamCommand(number): 为单个参数定义命令行中的静态位置。
  • ParamName(name,alias): 为参数定义不同的名称。允许使用类属性中不允许的特殊字符（如文件名或config.file）。可选的Alias参数定义了替代（通常是短名称）参数名称。
  • ParamHelp(helptext,valuename): 在用法部分定义命令行帮助文本和值名称。
  • ParamSwitchChar(sign): 定义指示开关或参数的字符串或字符。如果没有定义，将默认使用双破折号（--）。
  • ParamValueSeparator(sign): 定义从值（filename=config.json）中分离参数名称的字符串或字符。如果没有定义，将默认使用等号（=）。
  • ParamValueIsNextParam: 定义没有值分隔符的参数值（filename c:\config.ini）。
  • ParamRequired: 定义参数为必需。如果未找到参数，将引发异常。
QuickParameter会自动检查值类型。如果将参数值定义为Integer，并传递了字母数字值，将引发异常。
帮助定制：
您可以使用ColorizeHelp定义自己的颜色定制。如果Enabled属性为True，则使用自定义颜色，否则使用黑白颜色。
  1. Parameters.ColorizeHelp.Enabled := True;
  2. Parameters.ColorizeHelp.CommandName := ccCyan;
  3. Parameters.ColorizeHelp.CommandUsage := ccBlue;
复制代码
当参数检测到帮助参数时，将显示帮助文档。
Parameters.ShowHelp: 显示自动生成的帮助文档。
Quick.Url.Utils:


  • GetProtocol: 从URL中获取协议。
  • GetHost: 从URL中获取主机名。
  • GetPath: 从URL中获取路径。
  • GetQuery: 从URL中获取查询部分。
  • RemoveProtocol: 从URL中移除协议。
  • RemoveQuery: 从URL中移除查询部分。
  • EncodeUrl: 对URL中的路径和查询部分进行编码。
Quick.RegEx.Utils:

常用验证工具。
（此部分未给出具体示例代码）
Quick.Conditions:

以流畅风格进行前置条件和后置条件的验证。
Condition.Requires在执行某些操作之前评估变量的条件。
Condition.Ensures在执行某些操作之后评估变量结果的条件。
  1. Condition.Requires(num, "num")
  2.     .IsInRange(1, 10, 'value for num is out of range');   // 如果不在范围内，则抛出自定义错误
  3.     .IsNotGreater(50);   // 如果不等于50，则抛出ArgumentException
  5. Condition.Requires(myobj, "myobj")
  6.     .WithExceptionOnFailure(EMyException) // 如果失败，则抛出特定异常
  7.     .IsNotNull();          // 如果为null，则抛出ArgumentNullException
  8.     .Evaluate(myobj.id > 10); // myobj.id必须大于10
  10. Condition.Requires(text, "text")
  11.     .IsNotEmpty();          // 如果为空，则抛出ArgumentNullException
  12.     .StartsWith("<html>") // 如果不以<html>开头，则抛出ArgumentException
  13.     .EndsWith("</html>") // 如果不以</html>结尾，则抛出ArgumentException
  14.     .IsNotLowerCase; // 如果不是小写，则抛出ArgumentException
  15.     .Evaluate(text.Contains("sometxt") or text.Contains('othertxt')); // 如果不满足条件，则抛出ArgumentException
复制代码
hieroly 翻译整理于 2024年5月12日
你想学习Delphi或提高你的技能吗？访问 learndelphi.org

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
诞楮
2025-6-5 08:28:47

0

粉丝关注

9

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫