Quick Library 简介

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实例将由代码销毁。
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

复制代码

你想学习Delphi或提高你的技能吗？访问 learndelphi.org

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。