Tag: AL

Dynamics 365 Business Central: ทำความเข้าใจ Procedure Overload ใน AL วิธีลดความซ้ำซ้อนและเพิ่มประสิทธิภาพ

~ A.Thanapope ~ Leave a comment

การพัฒนาโปรแกรมใน AL (Application Language) สำหรับ Dynamics 365 Business Central มีฟังก์ชันและเครื่องมือที่ช่วยให้โค้ดมีความยืดหยุ่นและสามารถจัดการกับข้อมูลหลายประเภทได้ หนึ่งในเทคนิคที่ช่วยให้การเขียนโปรแกรมใน AL มีความยืดหยุ่นมากขึ้นคือ Procedure Overload ซึ่งช่วยให้คุณสามารถสร้างฟังก์ชันที่มีชื่อเดียวกันแต่รองรับพารามิเตอร์ที่แตกต่างกันได้ ในบทความนี้ เราจะอธิบายถึง Procedure Overload แบบละเอียด พร้อมตัวอย่างการใช้งาน ทั้งก่อนและหลังการนำไปใช้ รวมถึงรูปแบบการใช้งานต่างๆ

1. What is Procedure Overload? – Procedure Overload คืออะไร?

Procedure Overload คือการสร้างฟังก์ชัน (functions) หลายๆ ฟังก์ชันที่มีชื่อเดียวกัน (same name) แต่มีจำนวนพารามิเตอร์ (number of parameters) หรือประเภทของพารามิเตอร์ (type of parameters) ที่แตกต่างกัน ฟังก์ชันเหล่านี้จะถูก Overload ซึ่งหมายความว่าระบบจะเลือกใช้ฟังก์ชันที่เหมาะสมตามพารามิเตอร์ที่ถูกส่งมา

2. Why Use Procedure Overload? – ทำไมต้องใช้ Procedure Overload?

  • Flexibility: ช่วยให้คุณสามารถใช้ฟังก์ชันเดียวกันในหลายสถานการณ์ โดยไม่ต้องสร้างฟังก์ชันใหม่ที่มีชื่อแตกต่างกันStrong
  • Typing: ทำให้โค้ดใช้ประเภทข้อมูลที่ชัดเจน (strongly-typed) และสามารถตรวจสอบความถูกต้องได้ในขั้นตอนการคอมไพล์ (compile-time)
  • Error Reduction: ลดข้อผิดพลาดที่อาจเกิดขึ้นในขั้นตอนการรัน (runtime errors) ด้วยการตรวจสอบตั้งแต่การคอมไพล์

3. Examples of Procedure Overload – ตัวอย่างการใช้งาน Procedure Overload

3.1. Before Using Procedure Overload – ก่อนการใช้ Procedure Overload

สมมติว่าคุณต้องการสร้างฟังก์ชัน CalculateTotal ที่คำนวณราคาสุทธิหลังหักส่วนลด โดยอาจคำนวณจากเปอร์เซ็นต์ (%) หรือจากจำนวนเงินคงที่ (Fixed Amount) รวมถึงการคำนวณราคาโดยไม่หักส่วนลด คุณอาจต้องสร้างฟังก์ชันแยกตามประเภทการคำนวณ:

codeunit 50100 TotalCalculator
{
    local procedure CalculateTotalWithPercent(Price: Decimal; DiscountPercent: Decimal): Decimal
    begin
        Exit(Price - (Price * DiscountPercent / 100));
    end;

    local procedure CalculateTotalWithAmount(Price: Decimal; DiscountAmount: Decimal): Decimal
    begin
        Exit(Price - DiscountAmount);
    end;

    local procedure CalculateTotalWithoutDiscount(Price: Decimal): Decimal
    begin
        Exit(Price);
    end;
}

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

3.2. After Using Procedure Overload – หลังการใช้ Procedure Overload

เพื่อให้สามารถใช้ Procedure Overload ได้อย่างถูกต้อง เราจะปรับให้ฟังก์ชัน CalculateTotal มีจำนวนพารามิเตอร์ที่แตกต่างกัน:

codeunit 50101 TotalCalculatorWithOverloads
{
    procedure CalculateTotal(Price: Decimal; DiscountPercent: Decimal): Decimal
    begin
        Exit(Price - (Price * DiscountPercent / 100));
    end;

    procedure CalculateTotal(Price: Decimal; DiscountAmount: Decimal; IsAmount: Boolean): Decimal
    begin
        Exit(Price - DiscountAmount);
    end;

    procedure CalculateTotal(Price: Decimal): Decimal
    begin
        Exit(Price);
    end;
}

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

4.Usage Patterns of Procedure Overload – รูปแบบการใช้งาน Procedure Overload

  1. Same Function Name, Different Parameters: ฟังก์ชันที่ถูก Overload ต้องมีชื่อเดียวกัน แต่พารามิเตอร์ต้องมีประเภทหรือจำนวนที่แตกต่างกัน
  2. Compile-time Resolution: การเลือกฟังก์ชันที่ถูกต้องจะเกิดขึ้นในขั้นตอนการคอมไพล์ หากพารามิเตอร์ไม่ตรงกับฟังก์ชันใด ระบบจะตรวจพบข้อผิดพลาดทันที
  3. Avoiding Ambiguity: หลีกเลี่ยงการ Overload ที่มีพารามิเตอร์ใกล้เคียงกันเกินไป เพราะอาจทำให้ระบบไม่สามารถเลือกฟังก์ชันที่ถูกต้องได้
  4. Best Practices: ใช้ Procedure Overload เมื่อจำเป็นต้องรองรับพารามิเตอร์ที่แตกต่างกันจริงๆ และตรวจสอบความถูกต้องด้วยการคอมไพล์

ตัวอย่างการเรียกใช้ฟังก์ชัน Procedure Overload:

procedure TestCalculateTotal()
var
    Total1: Decimal;
    Total2: Decimal;
    Total3: Decimal;
begin
    // เรียกใช้ฟังก์ชัน CalculateTotal ที่ใช้ DiscountPercent
    Total1 := CalculateTotal(1000.00, 10.0); 
    // Total1 จะมีค่าเป็น 900.00 (1000 - 10%)

    // เรียกใช้ฟังก์ชัน CalculateTotal ที่ใช้ DiscountAmount
    Total2 := CalculateTotal(1000.00, 100.00, true); 
    // Total2 จะมีค่าเป็น 900.00 (1000 - 100)

    // เรียกใช้ฟังก์ชัน CalculateTotal ที่ไม่ใช้ส่วนลดใดๆ
    Total3 := CalculateTotal(1000.00); 
    // Total3 จะมีค่าเป็น 1000.00 (ไม่มีส่วนลด)
end;

คำอธิบาย:

Total3: ในการเรียกใช้ครั้งที่สาม เราใช้ฟังก์ชัน CalculateTotal(Price: Decimal) ซึ่งจะคืนค่าราคาสินค้าเต็มจำนวนโดยไม่มีส่วนลดใดๆ

Total1: ในการเรียกใช้ครั้งแรก เราใช้ฟังก์ชัน CalculateTotal(Price: Decimal; DiscountPercent: Decimal) ซึ่งจะคำนวณราคาหลังหักส่วนลดตามเปอร์เซ็นต์ (10%) ของราคา

Total2: ในการเรียกใช้ครั้งที่สอง เราใช้ฟังก์ชัน CalculateTotal(Price: Decimal; DiscountAmount: Decimal; IsAmount: Boolean) ซึ่งจะคำนวณราคาหลังหักจำนวนเงินที่เป็นส่วนลด (100 บาท)

5. Conclusion – สรุป

Procedure Overload เป็นเทคนิคที่ช่วยให้การเขียนโปรแกรมใน AL มีความยืดหยุ่นมากขึ้น คุณสามารถใช้ฟังก์ชันเดียวกันในหลากหลายสถานการณ์ได้โดยไม่ต้องสร้างฟังก์ชันใหม่หลายๆ ตัว นอกจากนี้ยังช่วยให้โค้ดดูเรียบร้อยและจัดการได้ง่ายขึ้น อย่างไรก็ตาม ควรใช้ Procedure Overload อย่างระมัดระวัง เพื่อป้องกันความสับสนที่อาจเกิดขึ้นจากการ Overload ฟังก์ชันหลายตัว

Dynamics 365 Business Central: เจาะลึก Duration Data Type ใน AL เคล็ดลับและตัวอย่างการใช้งาน

~ A.Thanapope ~ Leave a comment

Duration Data Type ในภาษา AL ของ Microsoft Dynamics 365 Business Central เป็นชนิดข้อมูลที่ใช้สำหรับการจัดการและคำนวณระยะเวลา (time duration) โดยระยะเวลานี้สามารถประกอบด้วยหน่วยเวลา เช่น ชั่วโมง (hours), นาที (minutes), วินาที (seconds), และมิลลิวินาที (milliseconds) ชนิดข้อมูล Duration นี้ช่วยให้นักพัฒนาสามารถคำนวณเวลา เปรียบเทียบระยะเวลา หรือแปลงเวลาไปเป็นข้อความที่เข้าใจง่ายในแอปพลิเคชันของพวกเขาได้อย่างมีประสิทธิภาพ

การประกาศตัวแปรชนิด Duration

ในภาษา AL การประกาศตัวแปรชนิด Duration สามารถทำได้ง่ายๆ โดยใช้คำสั่ง Duration ตามด้วยชื่อของตัวแปรที่ต้องการ เช่น:

var
TotalDuration: Duration;

ในตัวอย่างนี้ ตัวแปร TotalDuration จะใช้สำหรับเก็บข้อมูลระยะเวลา

การกำหนดค่าให้กับ Duration

การกำหนดค่าให้กับ Duration สามารถทำได้โดยการคำนวณจำนวนชั่วโมง นาที วินาที หรือมิลลิวินาทีที่คุณต้องการ เช่น:

TotalDuration := 2 * 60 * 60 * 1000; // 2 ชั่วโมง

หรือคุณสามารถรวมหลายหน่วยเวลาเข้าด้วยกัน:

TotalDuration := (2 * 60 * 60 * 1000) + (30 * 60 * 1000); // 2 ชั่วโมง 30 นาที

ในตัวอย่างนี้ เราได้กำหนดค่าระยะเวลาเป็น 2 ชั่วโมงและ 30 นาที โดยใช้การคำนวณในหน่วยมิลลิวินาที

ตัวอย่าง: การคำนวณเวลาทำงานทั้งหมดและเปรียบเทียบกับเวลาทำงานมาตรฐาน

สมมุติว่าคุณต้องการคำนวณเวลาทำงานทั้งหมดของพนักงานในแต่ละวัน และเปรียบเทียบกับเวลาทำงานมาตรฐาน (Standard Working Time) ที่กำหนดไว้คือ 8 ชั่วโมง เพื่อดูว่าพนักงานทำงานเกินเวลาหรือไม่ 

procedure CalculateWorkingTime(StartTime: DateTime; EndTime: DateTime)
    var
        TotalWorkingTime: Duration;
        StandardWorkingTime: Duration;
        Overtime: Duration;
        WorkHours: Integer;
        WorkMinutes: Integer;
        OvertimeHours: Integer;
        OvertimeMinutes: Integer;
        MessageText: Text;
    begin

        // กำหนดเวลาทำงานมาตรฐานเป็น 8 ชั่วโมง
        StandardWorkingTime := 8 * 60 * 60 * 1000;// 8 ชั่วโมง = 8 * 60 นาที * 60 วินาที * 1000 มิลลิวินาที

        // คำนวณเวลาทำงานทั้งหมด
        TotalWorkingTime := EndTime - StartTime;

        // แปลงเวลาทำงานทั้งหมดเป็นชั่วโมงและนาที
        WorkHours := TotalWorkingTime DIV (3600 * 1000); // 1 ชั่วโมง = 3600 วินาที * 1000 มิลลิวินาที
        WorkMinutes := (TotalWorkingTime MOD (3600 * 1000)) DIV (60 * 1000); // 1 นาที = 60 วินาที * 1000 มิลลิวินาที
        if TotalWorkingTime > StandardWorkingTime then begin

            // คำนวณเวลาทำงานโอที
            Overtime := TotalWorkingTime - StandardWorkingTime;

            // แปลงเวลาทำงานโอทีเป็นชั่วโมงและนาที
            OvertimeHours := Overtime DIV (3600 * 1000);
            OvertimeMinutes := (Overtime MOD (3600 * 1000)) DIV (60 * 1000);
            MessageText := StrSubstNo('เวลาทำงานทั้งหมด: %1 ชั่วโมง %2 นาที. เวลาทำงานโอที: %3 ชั่วโมง %4 นาที',WorkHours, WorkMinutes, OvertimeHours, OvertimeMinutes);

        end else begin
            MessageText := StrSubstNo('เวลาทำงานทั้งหมด: %1 ชั่วโมง %2 นาที. ไม่มีเวลาทำงานโอที.', WorkHours, WorkMinutes);
        end;
        Message(MessageText);
    end;

สมมุติเวลาทำงานทั้งหมดเป็น 9 ชั่วโมง

อธิบายโค้ด:

  1. StandardWorkingTime: กำหนดเวลาทำงานมาตรฐานเป็น 8 ชั่วโมง โดยแปลงหน่วยเป็นมิลลิวินาที (8 * 60 * 60 * 1000).
  2. TotalWorkingTime: คำนวณเวลาทำงานทั้งหมดจากการลบ StartTime ออกจาก EndTime.
  3. WorkHours และ WorkMinutes: แปลงเวลาทำงานทั้งหมดที่คำนวณได้เป็นชั่วโมงและนาที เพื่อให้สามารถนำไปแสดงผลได้ง่าย.
  4. Overtime: หาก TotalWorkingTime มากกว่า StandardWorkingTime จะคำนวณเวลาโอทีและแปลงเป็นชั่วโมงและนาที.
  5. MessageText: สร้างข้อความที่จะแสดงผลเวลาทำงานทั้งหมดและเวลาโอทีถ้ามี และแสดงผลข้อความนี้ออกมา.

โค้ดนี้สามารถใช้ในการคำนวณเวลาทำงานจริง และตรวจสอบได้ว่ามีการทำงานเกินเวลา (โอที) หรือไม่ พร้อมกับแสดงผลให้ผู้ใช้งานทราบในรูปแบบที่เข้าใจง่าย

การแปลง Duration เป็นข้อความ

Duration สามารถแปลงเป็นข้อความเพื่อแสดงผลได้โดยใช้ฟังก์ชัน Format เช่น:

var
   DurationText: Text;
begin
   DurationText := Format(TotalDuration); // จะแสดงเป็น '2 hours 30 minutes'
   Message(DurationText);
end;

สรุป

Duration Data Type ใน AL เป็นเครื่องมือที่มีประสิทธิภาพในการจัดการเวลาในแอปพลิเคชัน Dynamics 365 Business Central ไม่ว่าจะเป็นการคำนวณเวลา การเปรียบเทียบระยะเวลา หรือการแปลงเวลาไปเป็นข้อความที่เข้าใจง่าย การเข้าใจและใช้งาน Duration อย่างถูกต้องจะช่วยให้การพัฒนาของคุณมีความแม่นยำและเป็นระเบียบมากขึ้น

Dynamics 365 Business Central: ทักษะที่จำเป็นสำหรับ Junior ใน AL Programming เพื่อก้าวสู่ระดับ Senior

~ A.Thanapope ~ Leave a comment

การพัฒนาโปรแกรมด้วย AL (Application Language) สำหรับ Dynamics 365 Business Central เป็นงานที่ต้องการทักษะเฉพาะที่หลากหลาย ทั้งในด้านการเขียนโค้ด การดีบัก การออกแบบระบบ และการจัดการโปรเจค โดยทักษะที่จำเป็นจะแตกต่างกันไปตามระดับของโปรแกรมเมอร์ ไม่ว่าจะเป็นระดับ Junior หรือ Senior บทความนี้จะอธิบายถึงทักษะที่จำเป็นสำหรับแต่ละระดับอย่างละเอียด เพื่อให้คุณมีความเข้าใจที่ชัดเจนและสามารถพัฒนาตัวเองได้ในสายงานนี้

ทักษะที่ Junior Programmer ควรมี

1.พื้นฐานการเขียนโปรแกรม (Programming Basics):

  • Variables and Data Types: ควรมีความเข้าใจในการประกาศและใช้งานตัวแปร (Variables) และชนิดข้อมูล (Data Types) ต่าง ๆ เช่น Integer, Decimal, Boolean, และ Text
  • Control Structures: การใช้โครงสร้างควบคุมการไหลของโปรแกรม เช่น If-Else, Case, For และ While loops ซึ่งจะช่วยให้สามารถควบคุมการทำงานของโค้ดได้อย่างมีประสิทธิภาพ
  • Functions and Procedures: ความเข้าใจในการสร้างและใช้งานฟังก์ชัน (Functions) และขั้นตอนการทำงาน (Procedures) รวมถึงการส่งผ่านค่าระหว่างฟังก์ชัน

2.ความเข้าใจใน Syntax ของ AL (Understanding AL Syntax):

  • Object Structure: Junior Programmer ควรเข้าใจโครงสร้างพื้นฐานของ AL เช่น การสร้างและปรับแต่งตาราง (Tables), หน้าจอ (Pages), และรายงาน (Reports)
  • Trigger and Event Handlers: รู้จักกับ Triggers (เช่น OnInsert, OnModify) และการใช้งาน Event Handlers เพื่อเพิ่มความยืดหยุ่นในการพัฒนา

3.การทำงานกับ Business Central Objects:

  • Tables and Fields: ความสามารถในการสร้างและแก้ไขตาราง (Tables) และฟิลด์ (Fields) ใน Business Central
  • Pages: การออกแบบและปรับแต่งหน้าจอ (Pages) เพื่อแสดงข้อมูลที่เหมาะสมและใช้งานได้ง่าย
  • Reports: การสร้างรายงานที่มีประสิทธิภาพ การใช้งาน Layouts และ Data Items เพื่อดึงข้อมูลที่ต้องการ

4.การดีบักเบื้องต้น (Basic Debugging):

  • Breakpoints: การใช้ Breakpoints เพื่อตรวจสอบการทำงานของโค้ดทีละขั้นตอน โดยตั้งค่าให้โปรแกรมหยุดในบรรทัดที่ต้องการตรวจสอบ เพื่อให้สามารถดูค่าของตัวแปรและตรวจสอบการทำงานได้
  • Variable Inspection: การตรวจสอบค่าตัวแปร (Variable Values) ในระหว่างที่โปรแกรมหยุดที่ Breakpoint เพื่อวิเคราะห์ข้อผิดพลาด
  • Step Over, Step Into, Step Out: ความสามารถในการใช้คำสั่งเหล่านี้เพื่อตรวจสอบการทำงานของโค้ดอย่างละเอียด ทั้งการข้าม การเข้าไปในฟังก์ชัน และการออกจากฟังก์ชัน

5.การอ่านและเข้าใจโค้ดของผู้อื่น (Code Reading and Understanding):

  • Code Review: Junior Programmer ควรมีความสามารถในการอ่านและเข้าใจโค้ดของผู้อื่น เพื่อเรียนรู้และพัฒนาความสามารถของตนเอง
  • Documentation: การทำความเข้าใจเอกสารประกอบโค้ด (Code Documentation) เพื่อทำความเข้าใจการทำงานของโปรแกรม

6.การจัดการข้อมูล (Data Management):

  • Data Manipulation: การจัดการและการดึงข้อมูลจากตาราง (Tables) และ Query ด้วยคำสั่งพื้นฐาน เช่น INSERT, MODIFY, DELETE และ SETFILTER
  • Data Validation: การตรวจสอบความถูกต้องของข้อมูล (Data Validation) ก่อนที่จะทำการบันทึกลงในระบบ

7.การใช้งาน Extension (Extension Development):

  • Creating Extensions: ความสามารถในการสร้างและปรับแต่ง Extensions เพื่อต่อยอดความสามารถของ Business Central
  • Publishing and Managing Extensions: การเผยแพร่และจัดการ Extensions บน Business Central, รวมถึงการทำงานกับ Extension Versioning

8.พื้นฐานของ Web Services และ APIs (Basic Web Services and APIs):

  • OData and SOAP: เข้าใจพื้นฐานของการใช้งาน OData และ SOAP ในการติดต่อกับ Business Central ผ่าน Web Services
  • Basic API Integration: การใช้งาน REST API ในการดึงและอัพเดตข้อมูลระหว่างระบบต่าง ๆ กับ Business Central

ทักษะที่ Senior Programmer ควรมี

1.การออกแบบและสถาปัตยกรรมซอฟต์แวร์ (Software Design and Architecture):

  • System Design: Senior Programmer ต้องมีความสามารถในการออกแบบระบบโดยคำนึงถึงความสามารถในการขยาย (Scalability) และความยืดหยุ่น (Flexibility)
  • Modular Design: การออกแบบโมดูลที่แยกส่วน (Modular) และสามารถทำงานร่วมกันได้อย่างราบรื่น การออกแบบในลักษณะนี้ช่วยให้ระบบสามารถขยายตัวและบำรุงรักษาได้ง่าย นอกจากนี้ยังช่วยให้สามารถพัฒนาโมดูลที่นำกลับมาใช้ใหม่ (Reusable) ในโปรเจกต์อื่นได้บ

2.ความเชี่ยวชาญใน AL และ Dynamics 365 Business Central (AL and Dynamics 365 Business Central Expertise):

  • Advanced AL Coding: Senior Programmer ต้องมีความชำนาญในการเขียนโค้ดที่ซับซ้อนใน AL โดยใช้ฟีเจอร์ขั้นสูง เช่น การทำงานกับ Codeunits, การจัดการกับ TryFunctions, และการพัฒนาฟังก์ชันที่ต้องการประสิทธิภาพสูง
  • Performance Optimization: การปรับปรุงประสิทธิภาพ (Performance) ของโค้ด เช่น การลดเวลาการประมวลผล และการเขียนโค้ดที่ลดการใช้ Resources

3.การบริหารจัดการโครงการและทีมงาน (Project and Team Management):

  • Agile Methodology: ความเข้าใจในกระบวนการพัฒนาซอฟต์แวร์แบบ Agile และการประยุกต์ใช้ในโครงการจริง เช่น การทำงานใน Scrum Teams, การจัดการ Sprints และการใช้งาน Jira หรือ Trello ในการติดตามงาน
  • Team Leadership: ทักษะการเป็นผู้นำทีม (Leadership) การมอบหมายงาน (Task Delegation) และการให้คำปรึกษา (Mentorship) เพื่อพัฒนาทักษะของทีม

4.ทักษะการดีบักขั้นสูง (Advanced Debugging Skills):

  • Complex Problem Solving: ความสามารถในการดีบักปัญหาที่ซับซ้อน เช่น การวิเคราะห์ Memory Leaks, การตรวจสอบ Stack Traces และการใช้ Conditional Breakpoints เพื่อวิเคราะห์ปัญหาที่เกิดขึ้นในสถานการณ์เฉพาะ
  • Debugging Logs: การใช้ Debugging Logs ช่วยให้สามารถติดตามการทำงานของโปรแกรมในเชิงลึก โดยบันทึกเหตุการณ์หรือค่าตัวแปรสำคัญที่เกิดขึ้นระหว่างการทำงานของโปรแกรม การตรวจสอบ Logs เหล่านี้จะช่วยให้ระบุปัญหาได้ง่ายขึ้น

5.การให้คำปรึกษาและการสอนงาน (Mentorship and Teaching):

  • Code Review and Guidance: การทำ Code Review อย่างละเอียด เพื่อปรับปรุงคุณภาพของโค้ด และให้คำแนะนำกับโปรแกรมเมอร์รุ่นน้องในการพัฒนาทักษะ
  • Knowledge Sharing: การจัดทำเอกสารประกอบการพัฒนา (Technical Documentation) และการจัดการอบรม (Training) เพื่อแบ่งปันความรู้กับทีมงาน

6.การทดสอบและการประเมินผลโค้ด (Testing and Code Review):

  • Unit and Integration Testing: ความสามารถในการเขียน Unit Tests และ Integration Tests ที่ครอบคลุม เพื่อให้แน่ใจว่าโค้ดทำงานได้ถูกต้อง
  • Automated Testing: การใช้งานเครื่องมือ Automated Testing เพื่อลดความผิดพลาดจากการทดสอบด้วยตนเอง และเพิ่มความเร็วในการพัฒนา

7.การจัดการกับระบบขนาดใหญ่ (Managing Large Systems):

  • Scalability: ความสามารถในการออกแบบและจัดการระบบที่รองรับการขยาย (Scaling) ของผู้ใช้งาน และปริมาณข้อมูลที่เพิ่มขึ้น
  • Data Migration: การวางแผนและดำเนินการย้ายข้อมูล (Data Migration) จากระบบเก่าไปยังระบบใหม่โดยไม่สูญเสียข้อมูล

8.การพัฒนา API และการรวมระบบ (API Development and Integration):

  • Custom APIs: การออกแบบและพัฒนา Custom APIs เพื่อการรวมระบบ (System Integration) ระหว่าง Business Central กับระบบอื่น ๆ
  • Advanced Web Services: ความเชี่ยวชาญในการใช้งาน OData, SOAP และ RESTful APIs ในการดึงและอัพเดตข้อมูลระหว่างระบบต่าง ๆ

9.การจัดการความปลอดภัย (Security Management):

  • Security Best Practices: การพัฒนาโค้ดให้สอดคล้องกับ Security Best Practices เช่น การป้องกัน SQL Injection, การจัดการกับข้อมูลที่เป็นความลับ (Sensitive Data) และการทำ Encryption
  • User Authentication and Authorization: การตั้งค่าและจัดการกับระบบ Authentication และ Authorization เพื่อให้มั่นใจว่าผู้ใช้งานมีสิทธิ์ในการเข้าถึงข้อมูลตามที่กำหนด

10.การจัดการ Deployment และ Release (Deployment and Release Management):

  • CI/CD Pipelines: การใช้งาน Continuous Integration และ Continuous Deployment (CI/CD) เพื่อลดเวลาการนำโค้ดเข้าสู่ Production และลดความผิดพลาดที่เกิดจากการ Deployment
  • Version Control: ความเชี่ยวชาญในการใช้งาน Git หรือระบบ Version Control อื่น ๆ เพื่อจัดการกับโค้ดในโปรเจคที่มีทีมงานหลายคน

สรุป (Conclusion)

การเป็น Junior และ Senior Programmer ใน AL Programming มีความแตกต่างกันอย่างชัดเจนในด้านทักษะและประสบการณ์ที่จำเป็น ในขณะที่ Junior Programmer ควรมีความเข้าใจในพื้นฐานและการพัฒนาเบื้องต้น Senior Programmer ต้องมีความเชี่ยวชาญในเรื่องการออกแบบระบบ การจัดการทีมงาน การพัฒนา API การทดสอบและประเมินผลโค้ด การจัดการกับระบบขนาดใหญ่ และการรักษาความปลอดภัย การพัฒนาทักษะเหล่านี้จะช่วยให้คุณสามารถก้าวหน้าในสายงานและสร้างผลงานที่มีคุณภาพสูงสุดได้

Dynamics 365 Business Central: Disable Teaching Tips ใน Dynamics 365 BC ง่ายนิดเดียว

~ A.Thanapope ~ Leave a comment

Teaching Tips ใน Dynamics 365 Business Central เป็นเครื่องมือช่วยผู้ใช้งานใหม่เข้าใจฟีเจอร์ต่างๆ อย่างรวดเร็ว อย่างไรก็ตาม ผู้ใช้งานที่มีประสบการณ์อาจต้องการปิดการใช้งานฟีเจอร์นี้เพื่อให้การทำงานเป็นไปอย่างราบรื่น บทความนี้จะอธิบายขั้นตอนการปิด Teaching Tips อย่างละเอียดทั้งในส่วนของผู้ใช้ทั่วไปและผู้ดูแลระบบ เพื่อให้สามารถใช้งานระบบได้อย่างมีประสิทธิภาพมากขึ้น

ขั้นตอนการปิด Teaching Tips

1. ปิดผ่าน My Settings:

เข้าไปที่ My Settings: คลิกที่ไอคอนโปรไฟล์มุมขวาบนของหน้าจอเพื่อเปิดเมนูการตั้งค่าส่วนตัว

เลือก My Settings: หลังจากคลิกจะเปิดหน้าต่างการตั้งค่าส่วนตัว

ปิด Teaching Tips: ในหน้าต่าง My Settings เลื่อนลงหาฟิลด์ที่ชื่อว่า “Teaching Tips” จากนั้นคลิกเพื่อปิด (สวิตช์จาก “Yes” ไปเป็น “No”)

2. ปิด Teaching Tips สำหรับผู้ใช้งานหลายคน (โดยผู้ดูแลระบบ):

เข้าไปที่ User Settings Card: ผู้ดูแลระบบสามารถกำหนดค่า Teaching Tips สำหรับผู้ใช้หลายๆ คนผ่านหน้า User Settings Card

เลือกผู้ใช้ที่ต้องการ: ภายในหน้า User Settings Card ให้ค้นหาและเลือกผู้ใช้ที่ต้องการแก้ไขการตั้งค่า

ปรับค่า Teaching Tips: ในฟิลด์ Teaching Tips ของผู้ใช้ที่เลือก ให้ตั้งค่าจาก “Yes” ไปเป็น “No” เพื่อปิดการแสดงผล Teaching Tips

การปิด Teaching Tips จะช่วยลดความยุ่งยากในการใช้งานและปรับปรุงประสบการณ์ให้ดียิ่งขึ้น เหมาะสำหรับผู้ใช้ที่คุ้นเคยกับระบบแล้ว

สรุป

การปิด Teaching Tips ใน Dynamics 365 Business Central สามารถทำได้ง่ายๆ โดยผ่าน My Settings สำหรับผู้ใช้ทั่วไป และผ่าน User Settings Card สำหรับผู้ดูแลระบบ การปิดคำแนะนำเหล่านี้ช่วยให้การทำงานบนระบบเป็นไปอย่างราบรื่น และลดการรบกวนในระหว่างการทำงาน

Dynamics 365 Business Central: การใช้ Ternary Operator ใน AL แบบมืออาชีพ

~ A.Thanapope ~ Leave a comment

Ternary Operator หรือที่เรียกกันว่า “Conditional Operator” เป็นฟีเจอร์ใหม่ที่ถูกเพิ่มเข้ามาในภาษา AL เพื่อเพิ่มความสามารถในการเขียนโค้ดที่กระชับและอ่านง่ายขึ้น โดยเฉพาะในสถานการณ์ที่ต้องการตรวจสอบเงื่อนไขและคืนค่าต่างๆ ตามเงื่อนไขนั้นๆ

รูปแบบการใช้งาน Ternary Operator

<เงื่อนไข> ? <ผลลัพธ์ถ้าเป็นจริง> : <ผลลัพธ์ถ้าเป็นเท็จ>

ซึ่งสามารถนำมาใช้แทนโครงสร้าง if-then-else แบบพื้นฐานได้ในกรณีที่เงื่อนไขมีความเรียบง่ายและกระชับพอสมควร

เหตุผลที่ควรใช้ Ternary Operator

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

// การใช้ Ternary operator
IsPositive := Number > 0 ? 'Positive' : 'Negative or Zero';

เทียบกับการใช้ if-then-else แบบธรรมดา:

// การใช้ if-then-else
if Number > 0 then
    IsPositive := 'Positive';
else
    IsPositive := 'Negative or Zero';

จากตัวอย่างนี้จะเห็นได้ว่า Ternary operator ช่วยให้โค้ดสั้นลงและอ่านง่ายขึ้น

ข้อควรระวังในการใช้ Ternary Operator

แม้ว่า Ternary operator จะมีประโยชน์ในบางกรณี แต่ก็มีข้อควรระวังในการใช้งานเช่นกัน

1. อย่าใช้ถ้าโค้ดยาวเกินไป: ควรใช้ Ternary operator เฉพาะในกรณีที่เงื่อนไขและผลลัพธ์นั้นสั้นและกระชับพอที่จะอ่านได้ในบรรทัดเดียว เช่น:

// เหมาะสม
Result := Value > 100 ? 'High' : 'Low';

ไม่เหมาะสม:

// ไม่ควรใช้
Result := (Value > 100 ? 'High' : (Value > 50 ? 'Medium' : 'Low'));

2. หลีกเลี่ยงการใช้ในกรณีที่มีเงื่อนไขซ้ำซ้อน: หากเงื่อนไขเดียวกันต้องตรวจสอบหลายครั้ง ควรใช้ if-then-else แทนเพื่อลดความซับซ้อนของโค้ด:

// ไม่ควรใช้
Result := Value > 0 ? (Value > 50 ? 'High' : 'Medium') : 'Low';

3. ไม่ควรใช้ Ternary operator เพื่อคืนค่า Boolean flag: การใช้ Ternary operator ในกรณีนี้ไม่จำเป็นและอาจทำให้โค้ดสับสน:

// ไม่ควรใช้
IsEligible := Age >= 18 ? true : false;

ควรใช้แบบนี้แทน:

IsEligible := Age >= 18;

4. หลีกเลี่ยงการใช้ Ternary operator ที่ซ้อนกันหลายชั้น: การใช้ Ternary operator ที่ซ้อนกันหลายชั้นทำให้โค้ดอ่านยากและตรวจสอบยาก:

// ไม่ควรใช้
DiscountLevel := PurchaseAmount > 1000 ?
                 (CustomerType = 'VIP' ? 'High Discount' : 'Medium Discount') :
                 (CustomerType = 'VIP' ? 'Low Discount' : 'No Discount');

ควรใช้ if-then-else แทน:

var
   DiscountLevel: Text;
begin
   if PurchaseAmount > 1000 then begin
       if CustomerType = 'VIP' then
           DiscountLevel := 'High Discount'
       else
           DiscountLevel := 'Medium Discount';
   end else begin
       if CustomerType = 'VIP' then
           DiscountLevel := 'Low Discount'
       else
           DiscountLevel := 'No Discount';
   end;
end;

บทสรุป

Ternary operator เป็นเครื่องมือที่ทรงพลังและมีประโยชน์ใน AL Programming Language เมื่อใช้งานอย่างเหมาะสม อย่างไรก็ตาม ควรใช้งานด้วยความระมัดระวังและยึดหลักการเขียนโค้ดที่เรียบง่าย เพื่อให้โค้ดอ่านง่ายและตรวจสอบได้สะดวก ผู้พัฒนาที่ดีควรรู้จักเลือกใช้เครื่องมือให้เหมาะสมกับสถานการณ์ เพื่อให้ได้ผลลัพธ์ที่มีประสิทธิภาพและรักษาคุณภาพของโค้ดให้ดีที่สุด

Dynamics 365 Business Central: พื้นฐานการใช้ AL Operators สำหรับมือใหม่

~ A.Thanapope ~ Leave a comment

AL Operators คืออะไร?

AL Operators หรือตัวดำเนินการในภาษา AL เป็นสัญลักษณ์ที่ใช้ในการดำเนินการกับค่าหรือตัวแปรต่างๆ ไม่ว่าจะเป็นการคำนวณทางคณิตศาสตร์ การเปรียบเทียบข้อมูล การรวมข้อความ หรือการดำเนินการเชิงตรรกะ ตัวดำเนินการเหล่านี้เป็นพื้นฐานที่สำคัญในการพัฒนาโค้ดที่มีประสิทธิภาพ

1. Arithmetic Operators (ตัวดำเนินการทางคณิตศาสตร์)

“+" (Addition): ใช้ในการบวกสองค่าเข้าด้วยกันหรือรวมข้อความ

Total := 10 + 20; // ผลลัพธ์คือ 30
FullName := 'Thanapope' + ' ' + 'Arannat'; // ผลลัพธ์คือ "Thanapope Arannat"

“-” (Subtraction): ใช้ในการลบค่าหนึ่งออกจากอีกค่า

Difference := 30 - 10; // ผลลัพธ์คือ 20

"*" (Multiplication): ใช้ในการคูณสองค่า

Product := 10 * 5; // ผลลัพธ์คือ 50

“/" (Division): ใช้ในการหารสองค่า

Quotient := 20 / 4; // ผลลัพธ์คือ 5

“MOD” (Modulus): ใช้ในการหารสองค่าและคืนค่าเศษที่เหลือ

Remainder := 10 MOD 3; // ผลลัพธ์คือ 1

2. Comparison Operators (ตัวดำเนินการเปรียบเทียบ)

ใช้ในการเปรียบเทียบค่าต่างๆ ซึ่งผลลัพธ์จะเป็น TRUE หรือ FALSE

“=" (Equal): ตรวจสอบว่าค่าสองค่ามีค่าเท่ากันหรือไม่

IsEqual := (10 = 10); // ผลลัพธ์คือ TRUE

“<>" (Not Equal): ตรวจสอบว่าค่าสองค่าไม่เท่ากันหรือไม่

IsNotEqual := (10 <> 20); // ผลลัพธ์คือ TRUE

“>" (Greater Than): ตรวจสอบว่าค่าหนึ่งมากกว่าค่าอีกค่าหรือไม่

IsGreater := (20 > 10); // ผลลัพธ์คือ TRUE

“<" (Less Than): ตรวจสอบว่าค่าหนึ่งน้อยกว่าค่าอีกค่าหรือไม่

IsLess := (5 < 10); // ผลลัพธ์คือ TRUE

“>=" (Greater Than or Equal To): ตรวจสอบว่าค่าหนึ่งมากกว่าหรือเท่ากับค่าอีกค่าหรือไม่

IsGreaterOrEqual := (10 >= 10); // ผลลัพธ์คือ TRUE

“<=" (Less Than or Equal To): ตรวจสอบว่าค่าหนึ่งน้อยกว่าหรือเท่ากับค่าอีกค่าหรือไม่

IsLessOrEqual := (5 <= 10); // ผลลัพธ์คือ TRUE

3. Logical Operators (ตัวดำเนินการเชิงตรรกะ)

ใช้ในการดำเนินการเชิงตรรกะ เช่น AND, OR, และ NOT เพื่อสร้างเงื่อนไขที่ซับซ้อนขึ้น

“AND": ตรวจสอบว่าทั้งสองเงื่อนไขเป็นจริงหรือไม

IsTrue := (TRUE AND TRUE); // ผลลัพธ์คือ TRUE

“OR": ตรวจสอบว่าอย่างน้อยหนึ่งเงื่อนไขเป็นจริงหรือไม่

IsTrue := (TRUE OR FALSE); // ผลลัพธ์คือ TRUE

“NOT": เปลี่ยนค่าจาก TRUE เป็น FALSE และจาก FALSE เป็น TRUE

IsFalse := NOT(TRUE); // ผลลัพธ์คือ FALSE

4. Assignment Operators (ตัวดำเนินการกำหนดค่า)

ใช้ในการกำหนดค่าหรือผลลัพธ์จากการคำนวณให้กับตัวแปร

:= (Assignment): กำหนดค่าหรือผลลัพธ์ให้กับตัวแปร

MyVariable := 100;

5. String Operators (ตัวดำเนินการจัดการข้อความ)

ใช้ในการรวมข้อความ

“+" (Concatenation): รวมข้อความสองข้อความเข้าด้วยกัน

FullName := 'Thanapope' + ' ' + 'Arannat'; // ผลลัพธ์คือ "Thanapope Arannat"

6. Unary Operators (ตัวดำเนินการยูนารี)

ใช้ในการดำเนินการกับค่าหนึ่งค่า เช่น การทำให้เป็นค่าบวกหรือลบ

"+" (Unary Plus): ระบุว่าค่าของตัวแปรเป็นบวก (สามารถละได้)

PositiveValue := +10; // ผลลัพธ์คือ 10

“-" (Unary Minus): ทำให้ค่าของตัวแปรเป็นลบ

NegativeValue := -10; // ผลลัพธ์คือ -10

7. Compound Assignment Operators (ตัวดำเนินการกำหนดค่าแบบผสม)

“+=" (Addition Assignment): เพิ่มค่าและกำหนดค่าผลลัพธ์กลับไปยังตัวแปรเดิม

MyValue := 10;
MyValue += 5; // MyValue ตอนนี้มีค่าเป็น 15

“-=” (Subtraction Assignment): ลบค่าจากตัวแปรแล้วกำหนดค่าผลลัพธ์กลับไปยังตัวแปรเดิม

MyValue := 10;
MyValue -= 3; // MyValue ตอนนี้มีค่าเป็น 7

“*=" (Multiplication Assignment): คูณค่ากับตัวแปรแล้วกำหนดค่าผลลัพธ์กลับไปยังตัวแปรเดิม

MyValue := 10;
MyValue *= 2; // MyValue ตอนนี้มีค่าเป็น 20

"/=” (Division Assignment): หารค่าจากตัวแปรแล้วกำหนดค่าผลลัพธ์กลับไปยังตัวแปรเดิม

MyValue := 20;
MyValue /= 4; // MyValue ตอนนี้มีค่าเป็น 5

สรุป

การใช้ AL Operators ในการเขียนโปรแกรมใน Dynamics 365 Business Central เป็นเรื่องสำคัญที่ช่วยให้คุณสามารถคำนวณ เปรียบเทียบ และจัดการข้อมูลได้อย่างมีประสิทธิภาพ เมื่อคุณเข้าใจวิธีการใช้ตัวดำเนินการเหล่านี้ การเขียนโค้ดของคุณจะง่ายขึ้น และคุณจะสามารถสร้างโซลูชันที่ตรงตามความต้องการได้อย่างรวดเร็วและถูกต้อง

การเรียนรู้ AL Operators ไม่ได้ยาก แค่เข้าใจพื้นฐานแล้วฝึกใช้งานบ่อยๆ คุณก็จะเชี่ยวชาญได้อย่างรวดเร็วครับ!

Dynamics 365 Business Central: เริ่มต้นสร้าง AL Project ง่ายๆ ใน D365BC สำหรับมือใหม่

~ A.Thanapope ~ Leave a comment 

การพัฒนา AL Project ใน Microsoft Dynamics 365 Business Central อาจดูท้าทายสำหรับผู้เริ่มต้น แต่ด้วยคำแนะนำที่ถูกต้องและขั้นตอนที่ชัดเจน คุณจะพบว่ามันไม่ยากอย่างที่คิด บทความนี้จะแนะนำคุณตลอดกระบวนการสร้าง AL Project ตั้งแต่การติดตั้งเครื่องมือที่จำเป็นไปจนถึงการพัฒนาและทดสอบฟังก์ชันต่างๆ ที่คุณสร้างขึ้นได้ด้วยตัวเอง

1. การเตรียมความพร้อม ติดตั้งเครื่องมือที่จำเป็น

ก่อนที่จะเริ่มต้นสร้าง AL Project คุณจำเป็นต้องเตรียมเครื่องมือที่ใช้ในการพัฒนา ดังนี้:

1.1 การติดตั้ง Visual Studio Code (VS Code)

Visual Studio Code (VS Code) เป็นเครื่องมือที่นักพัฒนานิยมใช้สำหรับการเขียนโปรแกรม AL เนื่องจากมีความยืดหยุ่นและใช้งานง่าย คุณสามารถติดตั้งได้ดังนี้:

  1. เข้าไปที่เว็บไซต์ Visual Studio Code
  2. ดาวน์โหลดเวอร์ชันที่เหมาะกับระบบปฏิบัติการของคุณ (Windows, macOS, หรือ Linux)
  3. ติดตั้งโปรแกรมตามขั้นตอนที่แนะนำ

1.2 การติดตั้ง AL Language Extension

หลังจากติดตั้ง VS Code แล้ว คุณต้องติดตั้งส่วนขยายที่ทำให้ VS Code รองรับการเขียนโค้ด AL:

1. เปิด Visual Studio Code

2. ไปที่ Extensions โดยคลิกที่ไอคอนทางซ้ายหรือกด Ctrl + Shift + X

3. พิมพ์ “AL Language” ในช่องค้นหาและคลิกที่ปุ่ม Install

2. เริ่มต้นสร้าง AL Project ของคุณ

2.1 การสร้างโปรเจกต์ใหม่

เมื่อคุณติดตั้งเครื่องมือที่จำเป็นเสร็จแล้ว ก็สามารถเริ่มสร้าง AL Project ได้ โดยทำตามขั้นตอนดังนี้:

  • เปิด Visual Studio Code
  • ไปที่ View > Command Palette หรือกด Ctrl + Shift + P

  • พิมพ์ “AL: Go!” ในช่องค้นหาและกด Enter

  • ระบุชื่อของโปรเจกต์และตำแหน่งที่ต้องการบันทึก

  • เลือกเวอร์ชันของ Business Central ที่ต้องการใช้ (แนะนำให้เลือกเวอร์ชัน Sandbox)

  • ระบบจะสร้างโครงสร้างโปรเจกต์พื้นฐานที่ประกอบด้วยไฟล์สำคัญ เช่น app.json, HelloWorld.al, และ launch.json

2.1.1 อธิบายไฟล์สำคัญในโปรเจกต์

เมื่อคุณสร้าง AL Project ใหม่ใน Microsoft Dynamics 365 Business Central คุณจะพบกับไฟล์สำคัญสามไฟล์หลัก:

1. app.json:

เป็นไฟล์กำหนดค่าพื้นฐานของแอปพลิเคชัน AL ที่คุณพัฒนา ประกอบด้วยข้อมูลเช่น ชื่อแอป, ผู้พัฒนา, เวอร์ชัน, และช่วง ID ของ Object ที่ใช้งานในโปรเจกต์

ตัวอย่าง:

รายละเอียดของแต่ละฟิลด์:

  1. id:
    • รหัส UUID ที่ไม่ซ้ำกันสำหรับแอปพลิเคชันนี้ ใช้ในการระบุแอปพลิเคชันในระบบอย่างเฉพาะเจาะจง
  2. name:
    • ชื่อของแอปพลิเคชัน เช่น “My AL Project”
  3. publisher:
    • ชื่อผู้พัฒนาแอปพลิเคชันหรือบริษัทที่พัฒนา เช่น “Default Publisher”
  4. version:
    • หมายเลขเวอร์ชันของแอปพลิเคชันในรูปแบบ major.minor.build.revision เช่น “1.0.0.0”
  5. brief, description, privacyStatement, EULA, help, url, logo:
    • ฟิลด์เหล่านี้ใช้สำหรับการให้ข้อมูลเพิ่มเติมเกี่ยวกับแอปพลิเคชัน เช่น คำอธิบายสั้นๆ (brief), คำอธิบายแบบละเอียด (description), ลิงก์ไปยังนโยบายความเป็นส่วนตัว (privacyStatement), ข้อตกลงการใช้งาน (EULA), ลิงก์ไปยังหน้าเว็บช่วยเหลือ (help), URL ของเว็บไซต์ (url), และโลโก้ของแอปพลิเคชัน (logo) ฟิลด์เหล่านี้จะถูกแสดงให้ผู้ใช้เห็นเมื่อพวกเขาดาวน์โหลดหรือใช้งานแอปพลิเคชัน
  6. dependencies:
    • ระบุแอปพลิเคชันหรือแพคเกจที่โปรเจกต์นี้พึ่งพา เช่น “System Application” และ “Base Application” ที่มาจาก Microsoft พร้อมกับระบุเวอร์ชันที่ต้องการ
  7. screenshots:
    • เป็นอาร์เรย์ที่ใช้ระบุภาพหน้าจอ (screenshots) ของแอปพลิเคชัน ซึ่งสามารถแสดงใน AppSource หรือ Business Central แต่ในที่นี้ยังไม่ได้กำหนดค่า
  8. platform:
    • เวอร์ชันของแพลตฟอร์ม Business Central ที่แอปพลิเคชันนี้รองรับ
  9. application:
    • เวอร์ชันของแอปพลิเคชัน Business Central ที่ AL Project นี้ทำงานร่วมกับ
  10. idRanges:
    • ช่วงของ ID ที่กำหนดให้ Object ต่างๆ ในโปรเจกต์นี้ใช้ เช่น ตั้งแต่ 50100 ถึง 50149
  11. resourceExposurePolicy:
    • นโยบายการเปิดเผยทรัพยากร เช่น การอนุญาตให้ดีบัก (allowDebugging), การดาวน์โหลดซอร์สโค้ด (allowDownloadingSource), และการรวมซอร์สโค้ดในไฟล์สัญลักษณ์ (includeSourceInSymbolFile)
  12. runtime:
    • เวอร์ชันของ AL runtime ที่โปรเจกต์นี้ใช้ เช่น “13.1”
  13. features:
    • ฟีเจอร์พิเศษที่เปิดใช้งานในโปรเจกต์ เช่น "NoImplicitWith" ซึ่งเป็นฟีเจอร์ที่ช่วยป้องกันการใช้งาน WITH โดยไม่เจตนาในโค้ด AL

2. launch.json:

ใช้สำหรับตั้งค่าการดีบักใน Visual Studio Code กำหนด environment, URL เซิร์ฟเวอร์, tenant, และการตั้งค่าต่างๆ เพื่อเชื่อมต่อกับ Business Central

ตัวอย่าง:

รายละเอียดแต่ละฟิลด์:

  1. name:
    • ชื่อของการตั้งค่าการ Publish ซึ่งสามารถปรับเปลี่ยนได้ตามต้องการ (เช่น “sandbox”)
  2. request:
    • ประเภทของคำสั่ง deploy ใช้ "launch" ซึ่งหมายถึงการเริ่มต้นการ deploy
  3. type:
    • ประเภทของการ deploy ใช้ "al" ซึ่งหมายถึงการ deploy โค้ด AL (Application Language) ใน Business Central
  4. server:
    • URL ของเซิร์ฟเวอร์ Business Central ในที่นี้เป็น "https://businesscentral.dynamics.com/" ซึ่งเป็น URL หลักของ Business Central บนคลาวด์
  5. tenant:
    • ชื่อ Tenant ที่คุณกำลังเชื่อมต่อ คุณต้องใส่ชื่อ Tenant ของคุณแทน "your tenant"
  6. environmentType:
    • ประเภทของ Environment ในที่นี้คือ "Sandbox" หมายถึง Environment ที่ใช้สำหรับการทดสอบ ไม่ใช่ production
  7. breakOnError:
    • ตั้งค่าเป็น true หมายถึงการดีบักจะหยุดเมื่อมีข้อผิดพลาดเกิดขึ้นในโค้ด
  8. launchBrowser:
    • ตั้งค่าเป็น true หมายความว่าเบราว์เซอร์จะเปิดขึ้นโดยอัตโนมัติเมื่อเริ่มการดีบัก
  9. schemaUpdateMode:
    • ตั้งค่าเป็น "Synchronize" หมายถึงการอัปเดต schema ของฐานข้อมูลให้ตรงกับการเปลี่ยนแปลงในโค้ด AL โดยอัตโนมัติ

3. ไฟล์ .al (เช่น HelloWorld.al):

เป็นไฟล์ที่ใช้ในการเขียนโค้ด AL ของคุณ ทุกครั้งที่คุณสร้าง Object ใหม่ใน Business Central เช่น Table, Page, Codeunit จะถูกกำหนดในไฟล์ .al เหล่านี้

ตัวอย่าง:

ไฟล์เหล่านี้ทำหน้าที่เป็นพื้นฐานในการกำหนดค่าและพัฒนา AL Project ของคุณใน Microsoft Dynamics 365 Business Central ช่วยให้คุณสามารถจัดการแอปพลิเคชันได้อย่างเป็นระบบและมีประสิทธิภาพ.

3. ทำความเข้าใจ Object ใน AL

ในการพัฒนา AL Project คุณจะต้องทำงานกับ Object หลายประเภท ซึ่งแต่ละประเภทมีหน้าที่และฟังก์ชันเฉพาะ ดังนี้

3.1 Table

Table ใช้สำหรับการเก็บข้อมูลในระบบ Business Central ตัวอย่างโค้ดสำหรับการสร้าง Table คือ:

  • DataClassification: กำหนดระดับการปกป้องข้อมูล
  • field: ใช้กำหนดฟิลด์ต่างๆ ในตาราง
  • key: ใช้กำหนดคีย์สำหรับตาราง เช่น Primary Key

3.2 Page

Page ใช้ในการสร้างหน้าจออินเทอร์เฟซที่ผู้ใช้สามารถโต้ตอบได้ ตัวอย่างโค้ดสำหรับการสร้าง Page คือ:

3.3 Codeunit

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

  • trigger OnRun: เป็นตัวที่เรียกใช้เมื่อ Codeunit ถูกเรียกใช้งาน

4. การ Deploy Project

หลังจากที่คุณพัฒนา AL Project เสร็จสิ้นแล้ว ขั้นตอนต่อไปคือการ Deploy Project เพื่อให้แอปพลิเคชันพร้อมใช้งานใน environment ต่างๆ ของ Microsoft Dynamics 365 Business Central โดยมีขั้นตอนดังนี้:

4.1 การ Build และ Publish โปรเจกต์

1. Build Project: ก่อนที่จะทำการ Deploy คุณต้อง Build โปรเจกต์ใน Visual Studio Code เพื่อให้แน่ใจว่าไม่มีข้อผิดพลาดใดๆ ในโค้ด:

– เปิดโปรเจกต์ใน Visual Studio Code

– กด Ctrl + Shift + B หรือไปที่เมนู Terminal > Run Build Task แล้วเลือก Build

– ตรวจสอบว่าไม่มีข้อผิดพลาดปรากฏขึ้นในหน้าต่าง Output ของ Visual Studio Code

2. Publish ไปยัง Sandbox Environment:

– การ Publish ไปยัง Sandbox Environment ใช้สำหรับการทดสอบแอปพลิเคชันใน environment ที่ปลอดภัยก่อนที่จะทำการเผยแพร่ไปยัง Production

– กด F5 หรือไปที่เมนู Run > Start Debugging ระบบจะทำการ Build และ Publish แอปพลิเคชันไปยัง Sandbox Environment ที่คุณตั้งค่าไว้ในไฟล์ launch.json

– เมื่อกระบวนการเสร็จสิ้น Visual Studio Code จะเปิดเบราว์เซอร์และนำคุณไปยังหน้าแอปพลิเคชันที่ถูก Deploy ใน Business Central

4.2 การตรวจสอบผลลัพธ์หลังการ Deploy

1. หลังจาก Publish เสร็จสิ้นแล้ว ให้ตรวจสอบว่าแอปพลิเคชันทำงานตามที่คาดหวังหรือไม่

– ทดสอบฟังก์ชันต่างๆ ของแอปพลิเคชันภายใน Sandbox Environment เพื่อให้แน่ใจว่าทุกอย่างทำงานถูกต้อง

– หากพบข้อผิดพลาด ให้ทำการแก้ไขใน Visual Studio Code แล้วทำการ Build และ Publish ใหม่

5. สรุป

การสร้าง AL Project ใน Microsoft Dynamics 365 Business Central อาจดูซับซ้อนในตอนแรก แต่เมื่อคุณทำตามขั้นตอนที่ได้แนะนำในบทความนี้ คุณจะพบว่ามันไม่ยากเลย บทความนี้ครอบคลุมตั้งแต่การติดตั้งเครื่องมือ, การสร้างโปรเจกต์, การเข้าใจ Object ต่างๆ, ไปจนถึงการดีบักและทดสอบ หวังว่าบทความนี้จะช่วยให้คุณสามารถเริ่มต้นพัฒนา AL Project ได้อย่างมั่นใจ

AL Programming Language: ก้าวสำคัญสู่การพัฒนาบน MS D365BC

~ A.Thanapope ~ Leave a comment

AL Programming Language คืออะไร?

AL คือภาษาการเขียนโปรแกรมที่ออกแบบมาเพื่อใช้ในการพัฒนาและปรับแต่งโซลูชันบน Microsoft Dynamics 365 Business Central โดยมีความสามารถในการสร้างและจัดการ Object Types ต่าง ๆ ที่เกี่ยวข้องกับการดำเนินการทางธุรกิจ ภาษานี้มีความเชี่ยวชาญเฉพาะด้านและถูกออกแบบมาให้ใช้งานง่ายแม้สำหรับผู้พัฒนาที่คุ้นเคยกับภาษาโปรแกรมทั่วไป เช่น C# หรือ JavaScript

ความสำคัญของ AL ในการพัฒนา Business Central

AL มีบทบาทสำคัญในการช่วยให้ธุรกิจสามารถปรับแต่งและขยายความสามารถของ Business Central ได้ตามความต้องการ ไม่ว่าจะเป็นการสร้างตารางข้อมูลใหม่ การออกแบบหน้าจอผู้ใช้ หรือการพัฒนารายงานที่สอดคล้องกับการวิเคราะห์ทางธุรกิจ AL ทำให้การปรับแต่งเหล่านี้เป็นไปอย่างราบรื่นและมีประสิทธิภาพ โดยไม่กระทบต่อโครงสร้างพื้นฐานหลักของระบบ

การทำงานของ AL ใน Microsoft Dynamics 365 Business Central

ใน AL โค้ดจะถูกจัดระเบียบในรูปแบบของ Object Types ซึ่งแต่ละประเภทมีบทบาทเฉพาะในระบบ:

  • Tables: ตารางใน AL ถูกใช้เพื่อเก็บข้อมูลในรูปแบบของแถวและคอลัมน์ ผู้พัฒนาสามารถกำหนดฟิลด์ต่าง ๆ และคุณสมบัติพิเศษได้ เช่น Primary Key และ DataClassification ตารางเหล่านี้เป็นรากฐานในการจัดการข้อมูลใน Business Central
  • Pages: Pages เป็นอินเทอร์เฟซผู้ใช้ที่แสดงผลและให้ผู้ใช้ทำงานกับข้อมูล เช่น การแสดงรายการลูกค้า การป้อนข้อมูล หรือการตรวจสอบรายละเอียดต่าง ๆ ผู้พัฒนาสามารถปรับแต่งหน้าจอเหล่านี้ให้ตรงกับความต้องการของผู้ใช้ได้
  • Codeunits: Codeunits เป็นกลุ่มของฟังก์ชันที่สามารถนำกลับมาใช้ซ้ำได้ ฟังก์ชันเหล่านี้อาจเป็นการดำเนินการต่าง ๆ เช่น การคำนวณทางธุรกิจ หรือการตรวจสอบข้อมูล Codeunits ช่วยในการจัดการโค้ดให้อยู่ในรูปแบบที่เป็นระบบและง่ายต่อการจัดการ
  • Reports: Reports ใช้ในการสร้างรายงานที่ประกอบด้วยข้อมูลตามรูปแบบที่กำหนด รายงานเหล่านี้สามารถถูกออกแบบให้แสดงผลในรูปแบบต่าง ๆ เช่น รายงานยอดขาย รายงานสต็อกสินค้า หรือรายงานการเงินประจำเดือน
  • Queries: Queries เป็นคำสั่งที่ใช้ในการดึงข้อมูลจากหลายตารางในฐานข้อมูล ผู้พัฒนาสามารถกำหนดเงื่อนไขการกรองข้อมูล การจัดเรียง และการรวมข้อมูลได้ Queries เป็นเครื่องมือสำคัญในการสร้างรายงานที่ซับซ้อนและมีความยืดหยุ่น

ตัวอย่างโค๊ด

โค้ดตัวอย่างนี้แสดงการสร้างตาราง CustomerList ที่มีฟิลด์ Customer ID, Customer Name และ Balance ซึ่งใช้ในการจัดเก็บข้อมูลลูกค้า

การเขียนโปรแกรมแบบ Event-Driven ใน AL

หนึ่งในจุดเด่นของ AL คือการรองรับการเขียนโปรแกรมแบบ Event-Driven ซึ่งช่วยให้ผู้พัฒนาสามารถสร้างเหตุการณ์ (Events) ที่กระตุ้นการทำงานของโค้ดได้อย่างมีประสิทธิภาพ เช่น เมื่อมีการเพิ่มข้อมูลใหม่ในตารางลูกค้า ระบบสามารถเรียกใช้ฟังก์ชันเพื่อตรวจสอบข้อมูล หรือติดตามการเปลี่ยนแปลงได้โดยอัตโนมัติ

ตัวอย่างเช่น

ในตัวอย่างนี้ MyProcedure จะถูกเรียกใช้ทุกครั้งที่มีการแทรกข้อมูลลูกค้าใหม่ในตาราง Customer

การพัฒนาใน Visual Studio Code

AL ทำงานได้อย่างราบรื่นใน Visual Studio Code ซึ่งเป็นเครื่องมือพัฒนาที่ได้รับความนิยมสูง Visual Studio Code มีส่วนขยายที่สนับสนุนการพัฒนา AL โดยเฉพาะ ฟีเจอร์ที่สำคัญของ Visual Studio Code ในการพัฒนา AL ได้แก่:

  • IntelliSense: ระบบช่วยเติมคำสั่งอัตโนมัติ ช่วยเพิ่มความสะดวกและความเร็วในการเขียนโค้ด
  • Debugging: ความสามารถในการตรวจสอบและแก้ไขข้อผิดพลาดในโค้ดได้อย่างมีประสิทธิภาพ
  • Source Control: การควบคุมเวอร์ชันของโค้ดผ่าน Git ช่วยให้การจัดการโครงการเป็นไปอย่างราบรื่น

การพัฒนาภายใน Visual Studio Code ยังรวมถึงการสร้างโปรเจกต์ AL และการจัดการไฟล์ต่าง ๆ ที่เกี่ยวข้องกับโซลูชันใน Business Central

การสร้างและการจัดการ Extension

หนึ่งในคุณสมบัติที่สำคัญของ AL คือการสร้าง Extension ซึ่งเป็นโมดูลที่สามารถเพิ่มฟังก์ชันการทำงานใหม่ ๆ ให้กับ Business Central โดยไม่กระทบกับโค้ดหลักของระบบ Extension เหล่านี้สามารถถูกติดตั้งหรือแจกจ่ายให้กับผู้ใช้งานได้อย่างง่ายดาย

ขั้นตอนการสร้าง Extension:

  1. สร้างโปรเจกต์ใหม่ใน Visual Studio Code: เริ่มต้นด้วยการสร้างโปรเจกต์ AL ใหม่ จากนั้นกำหนดโครงสร้างของโซลูชันที่ต้องการพัฒนา
  2. เขียนโค้ด AL: พัฒนาโค้ดตามความต้องการ เช่น การสร้างตารางใหม่ หรือการปรับแต่งอินเทอร์เฟซผู้ใช้
  3. ทดสอบและ Debug: ใช้ฟีเจอร์ Debugging ใน Visual Studio Code เพื่อตรวจสอบและแก้ไขข้อผิดพลาดในโค้ด
  4. สร้างไฟล์ .app: เมื่อโค้ดเสร็จสมบูรณ์ ให้สร้างไฟล์ .app ซึ่งเป็นแพ็กเกจ Extension สำหรับติดตั้งใน Business Central
  5. ติดตั้ง Extension: นำไฟล์ .app ไปติดตั้งในระบบ Business Central ผ่านการจัดการ Extension

Integration กับ Web Services และระบบภายนอก

AL ยังมีความสามารถในการทำงานร่วมกับ Web Services และระบบภายนอกอื่น ๆ ทำให้สามารถเชื่อมต่อและแลกเปลี่ยนข้อมูลกับระบบภายนอกได้อย่างมีประสิทธิภาพ เช่น การดึงข้อมูลจาก API ภายนอก หรือการส่งข้อมูลไปยังระบบอื่น ๆ เพื่อการประมวลผลต่อไป

ตัวอย่างโค้ดที่เชื่อมต่อกับ Web Service

การรักษาความปลอดภัยและการกำหนดสิทธิ์การเข้าถึง (Security and Permissions)

Dynamic 365 Business Central มีฟีเจอร์ในการจัดการความปลอดภัยของข้อมูลและการกำหนดสิทธิ์การเข้าถึงของผู้ใช้งานตามบทบาท (Role) ที่กำหนด ผู้พัฒนาสามารถสร้างและจัดการ Permission Sets เพื่อกำหนดสิทธิ์การเข้าถึงข้อมูลต่าง ๆ ในระบบ เช่น ผู้จัดการสามารถเข้าถึงข้อมูลทั้งหมด แต่พนักงานอาจมีการจำกัดการเข้าถึง

สรุป

AL Programming Language เป็นเครื่องมือที่ทรงพลังและมีความสำคัญสำหรับการพัฒนาโซลูชันใน Microsoft Dynamics 365 Business Central ด้วยคุณสมบัติที่ครบครันในการจัดการข้อมูล การปรับแต่งอินเทอร์เฟซ และการเชื่อมต่อกับบริการภายนอก AL ช่วยให้ธุรกิจสามารถปรับตัวและเติบโตได้อย่างรวดเร็วในยุคดิจิทัล