การเขียนโปรแกรมเดลฟี--สำนวน

Delphi -- การสำรวจทักษะ:

{หมายเลข 1}

ประโยคสำหรับการสร้างรูปแบบกิริยาช่วย:

คลาส PROcedure TMyForm.RunForm (AObj1, AObj2: TObject);

var

vForm: TMyForm;

เริ่ม

vForm := TMyForm.Create(แอปพลิเคชัน);

ด้วย vForm ทำ

พยายาม

เริ่มต้นแบบฟอร์ม(AObj1, AObj2);

แสดงกิริยา;

ในที่สุด

ฟรี;

จบ;

จบ;

//*อธิบาย:

ฟังก์ชันที่ประกาศผ่านคลาสจะคล้ายกับฟังก์ชันคงที่ใน VC คำสั่งใช้: TMyForm.RunForm(vObj1, vObj2);

สำหรับข้อมูลเฉพาะอื่นๆ โปรดดูที่: คำอธิบายคลาสในวิธีใช้ Delphi

จุดประสงค์ของการเน้นสำนวนนี้คือ:

1. หากใช้แบบฟอร์มนี้ในหลายที่ คุณสามารถมั่นใจได้ว่ารหัสนี้จะถูกเรียกเหมือนกัน

2. หากมีการแก้ไขฟังก์ชัน เช่น การประมวลผลตามค่าที่ส่งคืนของ ShowModal ให้แก้ไขเฉพาะฟังก์ชันนี้เท่านั้น

3. โปรแกรมมีการห่อหุ้มที่ดีและง่ายต่อการบำรุงรักษาและส่งมอบงาน -

{หมายเลข 2}//การใช้แท็ก

ตอบสนองต่อเหตุการณ์ปุ่มแถบเครื่องมือของแบบฟอร์ม

ขั้นตอน TMyForm.RunOperate (ATag: Integer);

เริ่ม

กรณี Aแท็กของ

1: MyButton.Color := clRed;

2: MyButton.Color := clGreen;

3: MyButton.Color := clBlack;

จบ;

จบ;

ขั้นตอน TMyForm.ToolBtnClick (ผู้ส่ง: TObject);

เริ่ม

RunOperate(TControl(ผู้ส่ง).แท็ก);

จบ;

หากคุณอยู่ในเมนูแบบเลื่อนลงและจำเป็นต้องทำหน้าที่ที่คล้ายกัน

ขั้นตอน TMyForm.MenuItemClick (ผู้ส่ง: TObject);

เริ่ม

RunOperate(TMenuItem(ผู้ส่ง).แท็ก);

จบ;

//*อธิบาย:

1. โครงสร้างที่ชัดเจน

2. ข้อมูลที่เกี่ยวข้องมีความเข้มข้น ทำให้ง่ายต่อการตรวจสอบ แก้ไข และบำรุงรักษา

3. ปรับปรุงความสามารถในการปรับตัวและความยืดหยุ่นของโปรแกรม เช่น หากไม่ได้ใช้งานข้อกำหนดในปุ่มแถบเครื่องมือ แต่นำไปใช้ในปุ่มต่างๆ ก็จะง่ายต่อการปรับเปลี่ยน

คำแนะนำ: แต่ละหมวดหมู่จะมีโค้ดเพียงบรรทัดเดียวหรือสองสามบรรทัดต่อท้าย หากมีโค้ดจำนวนมาก ให้ใช้ฟังก์ชันกระบวนการแทน

สิ่งที่น่าสนใจกว่าคือฉันมักจะเขียนดังนี้:

กรณี btnMyButton.Visible ของ

{show} จริง: ...

{อย่าแสดง} เท็จ: ...

จบ; *//

{ หมายเลข 3 }//ตัวชี้เหตุการณ์เป็นพารามิเตอร์

//ใช้ตัวชี้เหตุการณ์สำหรับรายการเรื่องรออ่าน ฯลฯ

พิมพ์

TDataSetEvent = ขั้นตอน (ชุดข้อมูล: TDataSet; AIndex, ACount: จำนวนเต็ม) ของวัตถุ;

//คลาสที่ได้มาจาก TADOQuery

ขั้นตอน TMyADOQuery.EnumRecord (AWhereStr: String; APro: TDataSetEvent);

เริ่ม

ปิด;

SQL.เคลียร์;

SQL.Add('เลือก * จาก Table1');

ถ้า AWhereStr <> '' แล้ว

SQL.Add('Where' + AWhereStr);

เปิด;

ในขณะที่ไม่ใช่อีฟโด

เริ่ม

ถ้าได้รับมอบหมาย (APro) แล้ว APro (Self, RecNo, RecordCount);

ต่อไป;

จบ;

ปิด;

จบ;

//*อธิบาย:

วิธีนี้มาจากฟังก์ชัน API ใน Window เพื่อระบุหน้าต่างลูกปัจจุบันทั้งหมด EnumChildWindow

หลักการ: พยายามแยกการอ่านข้อมูลจากการแสดงข้อมูล การประมวลผลข้อมูล ฯลฯ เช่น MVC ฯลฯ ล้วนมีไว้เพื่อจุดประสงค์นี้

2. ความสามารถในการปรับขนาดของโปรแกรมได้รับการปรับปรุงแล้ว หากคุณเดิมต้องการแสดงหรือประมวลผลคอลัมน์ข้อมูลบางคอลัมน์ในรายการ แต่ต่อมาได้เปลี่ยนเป็นการใช้ ComboBox เมื่อแก้ไขโปรแกรม คุณไม่จำเป็นต้องอ่านส่วนการอ่านข้อมูล คุณเพียงแค่ต้องแก้ไขการแสดงข้อมูล ฯลฯ อีกตัวอย่างหนึ่ง ตอนนี้คุณจะต้องใช้แถบความคืบหน้าเพื่อแสดงความคืบหน้าในการอ่านเมื่ออ่านบันทึก

-

{ หมายเลข 4 }//อาร์เรย์คงที่

{ในข้อ 2 มีการนำเนื้อหาต่อไปนี้ไปใช้

ขั้นตอน TMyForm.RunOperate (ATag: Integer);

เริ่ม

กรณี Aแท็กของ

1: MyButton.Color := clRed;

2: MyButton.Color := clGreen;

3: MyButton.Color := clBlack;

จบ;

จบ;

-

// ถ้าอย่างนั้น มันจะเหมาะกว่าถ้าจะนำไปใช้โดยใช้อาร์เรย์

ขั้นตอน TMyForm.RunOperate (ATag: Integer);

ค่าคงที่

MyButtonColorMax := 3;

MyButtonColor: อาร์เรย์ [1..MyButtonColorMax] ของ TColor = (clRed, clGreen, clBlack);

เริ่ม

กรณี Aแท็กของ

1..MyButtonColorMax: MyButton.Color := MyButtonColor[ATag];

101:....

จบ;

จบ;

//*อธิบาย:

สำหรับการใช้งานในโหมดอาร์เรย์ โปรดทราบว่าขีดจำกัดบนหรือล่างของอาร์เรย์ถูกนำมาใช้โดยใช้ค่าคงที่ จากนั้นลองใช้ค่าคงที่นี้สำหรับการอ่านลูปอาร์เรย์ในอนาคต

-

{หมายเลข 5}กลไกข้อความลดฟังก์ชันสาธารณะของคลาส

//วิธีย่อคำจำกัดความของฟังก์ชันสาธารณะให้เหลือน้อยที่สุดในรูปแบบ

{ตัวอย่าง: หากคุณต้องการใช้แบบฟอร์มรายการคุณสมบัติของตัวควบคุมแบบฟอร์มปัจจุบัน เมื่อคุณต้องการรีเฟรชแบบฟอร์มคุณสมบัติ เปลี่ยนค่าของคุณสมบัติบางอย่าง เพิ่มคุณสมบัติใหม่ ฯลฯ จะมีข้อมูลจำนวนมาก ที่ต้องมีการโต้ตอบด้วย หากเราใช้คลาส public function เราจำเป็นต้องกำหนดฟังก์ชันสาธารณะจำนวนมาก ในเวลาเดียวกัน หากจำเป็นต้องมีการแปลงประเภทแบบฟอร์ม ฟังก์ชันสาธารณะจะสามารถใช้ได้หลังจากแปลงเป็นประเภทแบบฟอร์มเป้าหมายแล้วเท่านั้น ดังนั้นจะมีสถานการณ์ที่ทั้งสองหน่วยจำเป็นต้องรวมเข้าด้วยกัน}

//สารละลาย:

TfrmMyForm = คลาส (TForm)

FfrmProperty: TForm;

จบ;

-

FfrmProperty := TfrmProperty.MyCreate (แอปพลิเคชัน ตนเอง);

-

//เมื่อจำเป็นต้องรีเฟรชหน้าต่างคุณสมบัติ

FfrmProperty.ดำเนินการ (WD_REFRESHPROPERTYLIST, 0, 0);

TfrmProperty = คลาส (TForm)

ส่วนตัว

FMyForm: TForm;

ขั้นตอน WDREFRESHPROPERTYLIST (ข้อความ var: TMessage);

สาธารณะ

ตัวสร้าง MyCreate (เจ้าของ: TComponent; AForm: TForm);

จบ;

ตัวสร้าง TfrmProperty.MyCreate (เจ้าของ: TComponent; AForm: TForm);

เริ่ม

สืบทอดสร้าง (เจ้าของ);

FMyForm := แบบฟอร์ม;

จบ;

//* สำหรับวิธีการใช้ข้อความ คำจำกัดความของฟังก์ชันสาธารณะของแบบฟอร์มสามารถลดลงได้ ในขณะเดียวกันก็ช่วยเพิ่มความสามารถในการขยายขนาดของโปรแกรม หากคุณใช้แบบฟอร์มของเขาแทน คุณสามารถแปลงได้อย่างง่ายดาย เพราะส่วนใหญ่เป็นแบบฟอร์มของคุณซึ่งไม่ได้ประมวลผลข้อความปัจจุบัน*)//

{หมายเลข 6}ใช้รายการลงทะเบียนเพื่อจัดการโมดูลส่วนขยายที่เป็นไปได้

//โครงการ: คุณจะต้องสนับสนุนวิธีการแสดงผลลัพธ์หลายวิธีสำหรับชุดข้อมูล

...ตัวอย่างจะแจ้งให้ทราบภายหลัง

//* แสดงให้เห็น:

1. "วิธีเอาต์พุตหลายวิธี" บ่งชี้ว่าวิธีเอาต์พุตอาจถูกขยายบ่อยครั้งในการใช้งานในอนาคต ดังนั้นจึงต้องคำนึงถึงความสามารถในการปรับขนาดได้ง่ายของวิธีเอาต์พุตในระหว่างการออกแบบโปรแกรม

2. อ้างถึงกลไกการลงทะเบียนการควบคุม (RegisterComponents) ใน VCL คุณจะพบว่ามีการใช้กลไกการลงทะเบียนจำนวนมากใน VCL สิ่งที่คลาสสิกมากกว่าคือการลงทะเบียนของตัวแก้ไขคุณสมบัติการควบคุม

-

{No.7}ใช้เวอร์ชันโปรแกรมควบคุมที่กำหนดไว้ล่วงหน้า

//หากคุณกำลังทำโปรแกรมแพลตฟอร์มการพัฒนารอง คุณต้องเกี่ยวข้องกับปัญหาการควบคุมเวอร์ชันผลิตภัณฑ์และการควบคุมเวอร์ชันของโครงการ

//โดยปกติจะควบคุมโดยใช้วิธีการที่กำหนดไว้ล่วงหน้า

//คำสั่งนั้นค่อนข้างง่าย:

{$กำหนด JOYYUAN97}

{$IFDEF JOYYUAN97} {ELSE} {ENDIF}

{$ยกเลิก JOYYUAN97}

*อธิบาย:

1. แบ่งคำนิยามออกเป็นไฟล์หลายๆ ไฟล์แยกกัน

2. ที่จุดเริ่มต้นของแต่ละหน่วย แต่หลังจากหน่วย ให้ใช้ {$I ...} เพื่อรวมไฟล์ลงในหน่วยปัจจุบัน

3. ควบคุมไฟล์หน่วยที่หน่วยปัจจุบันสามารถมีได้ตามเงื่อนไขที่กำหนดไว้ล่วงหน้า

4. ลองแยกไฟล์ที่กำหนดไว้ล่วงหน้าสำหรับโปรเจ็กต์ หลังจากรวมไฟล์ที่กำหนดไว้ล่วงหน้าทั้งหมดแล้ว ให้รวมไฟล์นี้ไว้ในไฟล์นี้ ไฟล์ที่กำหนดไว้ล่วงหน้าบางไฟล์สามารถยกเลิกได้ตามความต้องการของโปรเจ็กต์

-

{หมายเลข 8}ใช้พอยน์เตอร์ฟังก์ชันเพื่อลดการรวมโปรเจ็กต์ของหน่วย

//ฉันมักจะคิดว่าการลดการรวมยูนิตเป็นก้าวแรกในการสร้างยูนิตสาธารณะ ดังนั้นจะลดการรวมยูนิตให้มากที่สุดได้อย่างไร

//นั่นคือ ควรมีความพยายามมากขึ้นในการลดการเชื่อมต่อของหน่วยโปรแกรม

{คำอธิบายสถานการณ์:

TMyFormManager: คลาสการจัดการแบบฟอร์ม

TMyForm: คลาสฐานแบบฟอร์มข้อมูล

TMyFormaccess: การบันทึกข้อมูลแบบฟอร์มและคลาสการอ่าน บันทึกข้อมูลแบบฟอร์มลงในฐานข้อมูลหรือโครงสร้างประเภทอื่น

วิเคราะห์:

1. ต้องใช้คลาสฐานแบบฟอร์ม (TMyForm) และคลาสการจัดการแบบฟอร์ม (TMyFormManager) ในหน่วย uManagers

2. หน่วยคลาสการใช้งานเฉพาะแบบฟอร์ม (TMyImageForm) fMyImange จำเป็นต้องรวมหน่วย uManagers สำหรับการสืบทอดแบบฟอร์มและการจัดการแบบฟอร์ม

3. หน่วยคลาสการอ่านข้อมูลแบบฟอร์ม (TMyFormAccess) uMyAccess จำเป็นต้องรวมหน่วย uManagers และหน่วย fMyImange

คำถาม:

หากฉันต้องการบันทึกแบบฟอร์มควรทำในเหตุการณ์ปุ่มของแบบฟอร์ม เมื่อพูดถึงหน่วยฟอร์ม จำเป็นต้องมีหน่วยคลาสการเข้าถึงข้อมูลแบบฟอร์ม และหากวางไว้ในคลาสฐานของฟอร์ม หน่วย uManager จะต้องมีหน่วย uMyAccess

การรวมเซลล์ถือเป็นอันตรายเมื่อการเข้าถึงข้อมูล เช่น รูปแบบการจัดเก็บข้อมูล เปลี่ยนแปลงตามความต้องการและจำเป็นต้องมีความสามารถในการขยายขนาด

วิธีแก้ไข: ใช้ตัวแปรตัวชี้ฟังก์ชัน

1. กำหนดตัวแปรตัวชี้ฟังก์ชันในหน่วย uManagers เพื่อบันทึกข้อมูล

2. กำหนดค่าให้กับตัวแปรตัวชี้ฟังก์ชันนี้เมื่อเตรียมใช้งานแอปพลิเคชัน

3. เมื่อจำเป็นต้องบันทึกข้อมูลแบบฟอร์ม ให้พิจารณาว่าตัวชี้ไม่ว่างเปล่า จากนั้นดำเนินการฟังก์ชันเพื่อบันทึกข้อมูลแบบฟอร์ม

{หมายเลข 9}ค่าคงที่ ทำความเข้าใจค่าคงที่ ใช้ค่าคงที่

มีหนังสือหลายเล่มที่แนะนำความสำคัญของคำจำกัดความคงที่ และฉันมักจะคิดถึงเรื่องนี้ แต่เมื่อฉันดูซอร์สโค้ด VCL ฉันรู้ว่าฉันเพิกเฉยต่อการใช้ค่าคงที่ของผู้อื่น

1. คำจำกัดความของข้อความที่เรามักใช้คือ ประกาศค่าคงที่ แล้วใช้ในเวลาที่เหมาะสม

กำหนดและใช้โดยทั่วไป:

ค่าคงที่

WD_MyMessage = WM_ผู้ใช้ + 101;

พิมพ์

TMyForm = คลาส (TForm)

-

ขั้นตอน WDMyMessage (ข้อความ var: TMessage);

จบ;

อย่างไรก็ตาม หากคุณเขียนคำสั่ง {response message position} ใหม่เป็น:

ขั้นตอน WDMyMessage (ข้อความ var: TMessage);

ในทำนองเดียวกัน การรวบรวมก็สามารถทำได้สำเร็จและการใช้งานก็เป็นเรื่องปกติ ดังนั้นคำจำกัดความคงที่จึงมักใช้ในการประมวลผลและอินเทอร์เฟซของระบบ Window

2. ใน Delphi เราได้กำหนดตัวแปรสี clRed, clGreen ฯลฯ ซึ่งเป็นค่าคงที่ที่กำหนดค่าไว้เพื่ออำนวยความสะดวกในการใช้งานในอนาคต จากการสังเกตนี้ ฉันพบว่าคำจำกัดความของค่าคงที่ควรสามารถนำมาใช้ซ้ำได้บางส่วนในโครงการ ดังนั้นจึงสามารถกำหนดหน่วยค่าคงที่มาตรฐานเพื่อให้สามารถนำค่าคงที่ที่กำหนดกลับมาใช้ใหม่ในแต่ละโครงการได้

{หมายเลข 10}อาร์เรย์ที่ใช้กันทั่วไปใน Delphi

มีการใช้งานที่ค่อนข้างสมบูรณ์ใน Delphi สำหรับคำจำกัดความและการใช้อาร์เรย์ประเภท TIdentMapEntryd

TIdentMapEntry = บันทึก

ค่า: จำนวนเต็ม;

ชื่อ: สตริง;

จบ;

1. คำจำกัดความของอาร์เรย์: array[0..ArrMax] ของ TIdentMapEntry

โปรดดูที่: หน่วยควบคุม:

เคอร์เซอร์: array[0..21] ของ TIdentMapEntry = (

-

-

2. สองฟังก์ชันที่ประเมินซึ่งกันและกัน: IntToIdent (ค้นหาชื่อจากค่า) และ IdentToInt (ค้นหาค่าจากชื่อ)

สำหรับแอปพลิเคชันเฉพาะ โปรดดูที่: IdentToCursor และ CursorToIdent

3. การใช้งาน: ก. ใช้วิธีการกำหนดกลุ่มต้นไม้และฟังก์ชันการจัดการอาร์เรย์โดยตรง ข. เรียนรู้วิธีการเข้าถึงและจัดการอาร์เรย์ในฟังก์ชัน c. เรียนรู้คำจำกัดความของฟังก์ชันการเข้าถึงข้อมูลมาตรฐาน: function IntToIdent(Int: Longint; var Ident: string; const Map: array of TIdentMapEntry): Boolean; ข้อมูลที่ส่งคืนโดยเฉพาะจะถูกส่งกลับโดยพารามิเตอร์ ถูกส่งผ่านฟังก์ชัน ค่าส่งคืนบูลีนจะถูกตัดสิน

{หมายเลข 11}จากกรณีพิเศษไปจนถึงการค้นพบทั่วไป

ฉันค้นพบโดยการติดตามคำจำกัดความและฟังก์ชันการทำงานของเคอร์เซอร์:

1. ตามที่แนะนำใน {No. 10} ให้สรุปคำจำกัดความและการดำเนินการทั่วไปของเคอร์เซอร์

2. จัดเตรียมฟังก์ชันสำหรับการแปลงระหว่าง Int และ Ident

3. จัดให้มีฟังก์ชันสำหรับการอ่านข้อมูลรายการอาร์เรย์แบบวนรอบ: GetCursorValues; ในหมู่พวกเขา วิธีการของ "ตัวชี้เหตุการณ์เป็นพารามิเตอร์" นำมาใช้ใน {No. 3} เพื่ออ่านข้อมูลรายการ

ภาคผนวกของ {หมายเลข 6}:

ตัวอย่าง:

ขั้นตอน RegisterComponents (หน้า const: string;

ComponentClasses: อาร์เรย์ของ TComponentClass);

เริ่ม

ถ้าได้รับมอบหมาย (RegisterComponentsProc) แล้ว

RegisterComponentsProc (เพจ, ComponentClasses)

อื่น

เพิ่ม EComponentError.CreateRes(@SRegisterError);

จบ;

การตีความ:

1. ใช้วิธีการลงทะเบียนเพื่อบันทึกประเภทของการควบคุมที่สามารถใช้ได้ ฯลฯ

3. สำหรับ RegisterComponentsProc วิธีการ "ใช้ตัวชี้ฟังก์ชันเพื่อลดการรวมโปรเจ็กต์ของหน่วย" ใน {No. 8} ใช้เพื่ออำนวยความสะดวกในการขยายโปรแกรมในอนาคต อัปเกรดเวอร์ชัน ฯลฯ

{หมายเลข 11}กำหนดฟังก์ชันสาธารณะเพียงรายการเดียวเท่านั้น

//คำอธิบายโครงการ: ตอนนี้เราจำเป็นต้องใช้แบบร่าง CAD หรือระบบ Visio ซึ่งต้องการความสามารถในการขยายขนาดที่ดีและการบำรุงรักษาที่ง่ายดาย

//และต้องใช้การเชื่อมต่อต่ำ เพื่อให้สามารถบรรจุชิ้นส่วนของระบบหรือระบบขยายได้โดยตรงในโครงการในอนาคต

ออกแบบ:

1. ออกแบบคลาสนามธรรมของวัตถุกราฟิก ในคลาสนี้ ให้กำหนดฟังก์ชันนามธรรม CadPerform พารามิเตอร์ของฟังก์ชันอ้างอิงถึงฟังก์ชัน TControl.Perform(Msg: Cardinal; WParam, LParam: Longint): Longint;

2. ในคลาสการจัดการกราฟิก ใช้การจัดการรายการออบเจ็กต์กราฟิก สิ่งที่เก็บไว้ในรายการคือตัวชี้ของออบเจ็กต์นามธรรม

3. เมื่อคุณต้องการควบคุมออบเจ็กต์คลาสเฉพาะ คุณจำเป็นต้องใช้ฟังก์ชัน CanPerform เท่านั้น จากนั้นส่ง Msg ตามหมวดหมู่ของการดำเนินการปัจจุบัน และส่งผ่านข้อมูลพารามิเตอร์ที่เกี่ยวข้อง

การนำไปปฏิบัติ: TCad เป็นคลาสควบคุมระดับแรกที่สืบทอดมาจากคลาสนามธรรม

ฟังก์ชั่น TCad.CadPerform (ข่าวสารเกี่ยวกับ: พระคาร์ดินัล; WParam, LParam: Longint): Longint;

เริ่ม

กรณีข่าวสารของ

My_Message1: ผลลัพธ์ := MyMessage1(WParam, LParam);

My_Message2: ผลลัพธ์ := MyMessage2(WParam, LParam);

จบ;

จบ;

สำหรับ TPoint ที่สืบทอดมาจาก TCad ฟังก์ชัน CadPerform จะถูกใช้งานดังนี้

ฟังก์ชัน TPoint.CadPerform (ข่าวสารเกี่ยวกับ: พระคาร์ดินัล; WParam, LParam: Longint): Longint;

เริ่ม

กรณีข่าวสารของ

My_Message1: ผลลัพธ์ := MyMessage1(WParam, LParam); // การประมวลผลประเภทการดำเนินการนี้ใน TCad ถูกบล็อก

My_Message3: ผลลัพธ์ := MyMessage3(WParam, LParam);

ผลลัพธ์อื่น := CadPerform ที่สืบทอดมา (ข่าวสารเกี่ยวกับ WParam, LParam);

จบ;

จบ;

*อธิบาย:

เนื่องจากเราใช้งานออบเจ็กต์กราฟิกบ่อยมาก เราจึงกำหนดฟังก์ชันอินเทอร์เฟซสาธารณะและแบบเปิดเพื่อให้บรรลุการห่อหุ้มคลาสที่สูง และการบำรุงรักษาและการขยายโปรแกรมที่ง่ายดาย

-

{หมายเลข 12}

ต่อไปนี้เป็นข้อกำหนดในการเขียนโปรแกรมของฉัน: (ข้อมูลบางอย่างไม่มีข้อจำกัดด้านภาษา)

//วิธีแก้ปัญหาต่อไปนี้เกือบทั้งหมดสามารถพบได้ในวิธีการข้างต้น

1. ลดความซับซ้อนของโปรแกรม ก. ลดจำนวนฟังก์ชัน ใช้วิธี Case และ Tag และเรียนรู้วิธีกำหนดการดำเนินการ ข. ลดความสัมพันธ์การซ้อนหน่วย ใช้วิธีการส่งข้อความ และลดการรวมหน่วยแบบฟอร์มเข้าด้วยกัน

2. ลด

{หมายเลข 13} ใช้การออกอากาศเพื่อใช้การแจ้งเตือนจากคลาสการจัดการไปยังออบเจ็กต์รายการการจัดการ

//สำหรับคำอธิบายโปรเจ็กต์ {หมายเลข 12} เมื่อคุณสมบัติหรือสถานะของการควบคุมแบบฟอร์มการวาดเปลี่ยนแปลง มักจะจำเป็นต้องแจ้งออบเจ็กต์กราฟิกทั้งหมดและทำการเปลี่ยนแปลงที่เกี่ยวข้อง

//หากมีการกำหนดฟังก์ชันการออกอากาศเพียงฟังก์ชันเดียว การแจ้งเตือนหลักและรองสามารถรับรู้ได้ ซึ่งจะปรับปรุงการนำกลับมาใช้ใหม่ ความสามารถในการปรับขนาด ความง่ายในการบำรุงรักษา ฯลฯ ของโปรแกรม และทำให้โครงสร้างคลาสชัดเจน

//ตัวอย่าง: 1. ใน Visio และ MapInfo หากขนาด (อัตราส่วนการซูม) ของรูปแบบปัจจุบันเปลี่ยนแปลงไป ออบเจ็กต์กราฟิกที่แสดงอยู่ทั้งหมดจะต้องถูกวาดใหม่ด้วยขนาดใหม่ 2. เมื่อมีการเปลี่ยนแปลงแบบอักษรของแบบฟอร์มเริ่มต้นของแบบฟอร์มปัจจุบัน ควรเปลี่ยนแบบอักษรข้อความของออบเจ็กต์กราฟิกที่ใช้แบบอักษรของแบบฟอร์มตามค่าเริ่มต้นในการแสดงข้อมูลข้อความตามนั้น

//วิธีแก้ปัญหา อ้างถึงกลไกการประมวลผลใน TWinControl ที่แจ้งเตือนการควบคุมย่อยทั้งหมดเมื่อแอตทริบิวต์หรือสถานะเปลี่ยนแปลง:

ขั้นตอน TWinControl.NotifyControls (ข่าวสารเกี่ยวกับ: Word);

var

ข้อความ: TMessage;

เริ่ม

ข้อความข่าวสาร := ข่าวสาร;

ข้อความ WParam := 0;

ข้อความ LParam := 0;

ข้อความผลลัพธ์ := 0;

ออกอากาศ(ข้อความ);//ออกอากาศข้อความการเปลี่ยนแปลงปัจจุบัน

จบ;

ใน:

ขั้นตอน TWinControl.Broadcast (ข้อความ var);

var

ฉัน: จำนวนเต็ม;

เริ่ม

สำหรับฉัน := 0 ถึง ControlCount - 1 ทำ

เริ่ม

การควบคุม [I] .WindowProc (TMessage (ข้อความ));

//เปลี่ยนเป็น: ด้วย TMessage(ข้อความ) ทำ Cads[I].CadPerform(msg, WParam, LParam);

ถ้า TMessage (ข้อความ) ผลลัพธ์ <> 0 แล้วออก;

จบ;

จบ;

อย่างไรก็ตาม เมื่อเราจัดการกับวัตถุกราฟิก เราอาจเรียกฟังก์ชันสาธารณะ CanPerform ของ Cads โดยตรง

{หมายเลข 14}สร้างวัตถุของคุณแบบไดนามิกเมื่อจำเป็น

ตัวอย่างเช่น: http://www.delphibbs.com/keylife/iblog_show.asp?xid=824

//************ ตัวเลือก 2: สร้างแบบฟอร์มทรัพย์สินเมื่อจำเป็น

การใช้งาน

-

ฉทรัพย์สิน;

พิมพ์

TfrmMyMap = คลาส

-

ขั้นตอน OnfrmMyMapDestroy (ผู้ส่ง: TObject);

ขั้นตอน OnMapGeoSelected (AGEo: TGeometry);

ส่วนตัว

FfrmProperty: TfrmProperty;

ขั้นตอน ShowPropertyForm (aVisible: Boolean);

สาธารณะ

จบ;

ขั้นตอน TfrmMyMap.ShowPropertyForm (aVisible: Boolean);

เริ่ม

หากไม่ได้รับมอบหมาย (FfrmProperty) ดังนั้น FfrmProperty := TfrmProperty.Create (Application);

FfrmProperty.Visible := aVisible;

จบ;

ขั้นตอน TfrmMyMap.OnfrmMyMapDestroy (ผู้ส่ง: TObject);

เริ่ม

ถ้าได้รับมอบหมาย (FfrmProperty) แล้ว FfrmProperty.Free;

จบ;

ขั้นตอน TfrmMyMap.OnMapGeoSelected (AGEo: TGeometry);

เริ่ม

ถ้าได้รับมอบหมาย (FfrmProperty) แล้ว FfrmProperty.MyRefresh (AGEo);

จบ;

มีระบุไว้ดังนี้:

1. สร้างออบเจ็กต์ FfrmProperty ของคุณแบบไดนามิกเมื่อจำเป็น

2. เมื่อวัตถุปัจจุบันถูกปล่อยออกมา ให้ตรวจสอบความถูกต้องตามกฎหมายของวัตถุของคุณ จากนั้นจึงปล่อยวัตถุที่สร้างขึ้นแบบไดนามิก

{หมายเลข 15}สร้างอินเทอร์เฟซหรือสร้างโครงสร้าง

//คำอธิบายโครงการ: เมื่อฉันพัฒนาตัวควบคุมตาราง ถ้าฉันตั้งค่าเซลล์เป็น Com หากมีข้อมูลมากเกินไปในตาราง ก็ไม่สามารถรับประกันความเร็วในการโหลดได้ และอาจถึงขั้นอาจเกิดข้อผิดพลาดได้ เหตุผลที่ฉันใช้ Com ก็เพื่อให้ในอนาคตการประมวลผลและข้อมูลของแต่ละเซลล์สามารถขยายออกไปนอกการควบคุมได้

วิธีแก้ปัญหาของฉันคือ: สร้างอินสแตนซ์สำหรับการควบคุมแต่ละรายการที่ได้รับจากเซลล์ และสร้างวัตถุโครงสร้างหลายรายการแบบไดนามิกเพื่อบันทึกข้อมูลของแต่ละเซลล์ หากคุณต้องการใช้งานเซลล์ ให้กำหนดตัวชี้วัตถุโครงสร้างให้กับส่วนประกอบเซลล์ ผลลัพธ์การทดสอบคือ น่าพอใจมาก

ดังนั้น หากคุณต้องการใช้อินสแตนซ์ของ Com จำนวนมาก ให้พยายามจัดการและบำรุงรักษาอินสแตนซ์เดียว และข้อมูลในนั้นสามารถสร้างและจัดการแบบไดนามิกได้ ซึ่งจะมีผลดีในแง่ของความเร็ว

นอกจากนี้ ให้ลองประกาศ pMyInterface = ^IMyInterface ตัวชี้อินเทอร์เฟซ เมื่อส่งหรือใช้พารามิเตอร์ ให้ใช้ตัวชี้อินเทอร์เฟซโดยตรง ซึ่งจะช่วยลดจำนวนการเรียกใช้ฟังก์ชันการนับ _AddInft เป็นต้น และยังสามารถเพิ่มความเร็วได้หาก การดำเนินการเป็นเรื่องปกติ