ในบทความนี้ เราจะมาทำความเข้าใจเกี่ยวกับการใช้งาน Progress Windows, Message, Error, และ Confirm Methods ในการเขียนโปรแกรมด้วยภาษา AL ซึ่งเป็นภาษาหลักที่ใช้ใน Dynamics 365 Business Central แต่ละ method มีบทบาทที่แตกต่างกันไปในการโต้ตอบกับผู้ใช้ โดยเฉพาะในสถานการณ์ที่ต้องการแสดงข้อมูล, แจ้งเตือนข้อผิดพลาด, หรือขอการยืนยันจากผู้ใช้ เราจะมาเจาะลึกถึงรายละเอียดพร้อมตัวอย่างการใช้งานแต่ละ method อย่างละเอียด

1. Progress Windows

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

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

ProgressDialog.OPEN(ProgressMsg, Counter);
ProgressDialog.UPDATE();
ProgressDialog.CLOSE();

ตัวอย่างการใช้งาน:

    procedure ImportDataWithProgress()
    var
        Progress: Dialog;
        Counter: Integer;
        ProgressMsg: Label 'Progress from 0 to 9999   #1#####'; 
    begin
        Counter := 0;
        Progress.OPEN(ProgressMsg, Counter);
        repeat
            // Perform processing logic here
            Counter := Counter + 1;
            Progress.UPDATE();
            SLEEP(10);
        until Counter = 9999;
        Progress.CLOSE();
    end;

ในตัวอย่างข้างต้น เราได้สร้างหน้าต่าง Progress ที่จะบอกผู้ใช้ว่าอยู่ที่ขั้นตอนใดของการประมวลผล และใช้ Progress.UPDATE(); เพื่ออัพเดตข้อมูลในหน้าต่าง

2. Message Method

Message Method ใช้ในการแสดงข้อความให้ผู้ใช้ทราบ ซึ่งข้อความนี้จะเป็นเพียงข้อมูล ไม่ใช่การแจ้งเตือนหรือข้อผิดพลาด

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

Message('Your message here: %1', SomeVariable);

ตัวอย่าง:

  procedure ShowMessage()
  begin
      Message('Hello, %1!', 'Thanapope');
  end;

ในตัวอย่างนี้ เมธอด Message จะทำการแสดงกล่องข้อความที่มีข้อความว่า “Hello, Thanapope!”

3. Error Method

Error Method ใช้ในการแจ้งข้อผิดพลาดและหยุดการทำงานของโปรแกรม หากเกิดข้อผิดพลาดขึ้น

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

Error('An error occurred: %1', ErrorMessage);

ตัวอย่าง:

procedure ValidateInput(SomeValue: Integer)
begin
    if SomeValue < 0 then
        Error('The value %1 cannot be negative', SomeValue);
end;

ในตัวอย่างนี้ หากค่า SomeValue เป็นลบ จะมีการแสดงข้อผิดพลาดและหยุดการทำงานด้วยข้อความ “The value cannot be negative

4. Confirm Method

Confirm Method ใช้ในการสอบถามผู้ใช้เพื่อขอการยืนยันก่อนที่จะทำการดำเนินการใด ๆ

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

if Confirm('Are you sure you want to continue?') then begin
       // Code to execute if user confirms
end;

ตัวอย่าง:

    procedure ConfirmAction()
    begin
        if Confirm('Are you sure you want to delete this record?') then begin
            // Code to delete the record
            Message('Record deleted successfully.');
        end else begin
            Message('Operation cancelled.');
        end;
    end;

ตัวอย่างกด Yes

ตัวอย่างกด No

ในตัวอย่างนี้ โปรแกรมจะถามผู้ใช้ว่าต้องการลบข้อมูลหรือไม่ หากผู้ใช้กดยืนยัน โปรแกรมจะลบข้อมูลและแสดงข้อความว่า “Record deleted successfully.”

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

อะไรคือตัวแปร Protected?

ตัวแปร Protected ในภาษา AL คือ ตัวแปรที่สามารถเข้าถึงได้เฉพาะในออบเจ็กต์ที่ประกาศตัวแปรนั้น และในออบเจ็กต์ที่สืบทอดมาจากออบเจ็กต์นั้น ๆ เท่านั้น (Only accessible within the object where it’s declared and in its subclasses) นั่นหมายความว่าโค้ดที่อยู่นอกออบเจ็กต์ที่ไม่ได้สืบทอดจากออบเจ็กต์นั้นจะไม่สามารถเข้าถึงตัวแปรนี้ได้

การประกาศและใช้งานตัวแปร Protected

ในการประกาศตัวแปร Protected ในภาษา AL คุณสามารถทำได้โดยการเพิ่มคีย์เวิร์ด protected ก่อนการประกาศตัวแปร ตัวอย่างเช่น:

protected var
ShowSensitiveData: Boolean;

ในตัวอย่างนี้ ตัวแปร ShowSensitiveData สามารถถูกเข้าถึงได้เฉพาะในออบเจ็กต์ที่ประกาศตัวแปรนี้ รวมถึงออบเจ็กต์ที่สืบทอดมาจากออบเจ็กต์นี้เท่านั้น

ตัวอย่างการใช้งาน Protected Variables ในภาษา AL

สมมุติว่าเราต้องการสร้างฟีเจอร์ใหม่สำหรับการแสดงข้อมูลที่สำคัญในระบบ ซึ่งข้อมูลนี้จะถูกแสดงเฉพาะในบางสถานการณ์เท่านั้น

สร้าง Table ใหม่

table 50100 "Sensitive Data"
{
    DataClassification = ToBeClassified;
    fields
    {
        field(1; "Entry No."; Integer)
        {
            DataClassification = SystemMetadata;
            AutoIncrement = true;
        }
        field(2; "Customer No."; Code[20])
        {
            DataClassification = CustomerContent;
        }
        field(3; "Sensitive Info"; Text[100])
        {
            DataClassification = ToBeClassified;
        }
    }

    keys
    {
        key(PK; "Entry No.")
        {
            Clustered = true;
        }
    }
}

ในตัวอย่างนี้ เราได้สร้างตารางใหม่ชื่อว่า Sensitive Data เพื่อเก็บข้อมูลที่สำคัญ เช่น Sensitive Info ที่เกี่ยวข้องกับลูกค้า

สร้าง Page ใหม่

page 50101 "Sensitive Data List"
{
    PageType = List;
    SourceTable = "Sensitive Data";
    ApplicationArea = All;

    layout
    {
        area(content)
        {
            repeater(Group)
            {
                field("Entry No."; "Entry No.")
                {
                    ApplicationArea = All;
                }
                field("Customer No."; "Customer No.")
                {
                    ApplicationArea = All;
                }
                field("Sensitive Info"; "Sensitive Info")
                {
                    ApplicationArea = All;
                    Visible = ShowSensitiveData; // ใช้ตัวแปร Protected ควบคุมการแสดงผล
                }
            }
        }
    }

    actions
    {
        area(Processing)
        {
            action("Toggle Sensitive Info")
            {
                Caption = 'Show/Hide Sensitive Info';
                ApplicationArea = All;
                trigger OnAction()
                begin
                    ShowSensitiveData := not ShowSensitiveData;
                    CurrPage.Update(false);
                end;
            }
        }
    }

    trigger OnOpenPage()
    begin
        ShowSensitiveData := false; // ซ่อนข้อมูลที่สำคัญโดยเริ่มต้น
    end;

    protected var        
    ShowSensitiveData: Boolean;
}

ในเพจ Sensitive Data List เราได้ใช้ตัวแปร Protected ชื่อว่า ShowSensitiveData เพื่อควบคุมการแสดงผลของฟิลด์ Sensitive Info ข้อมูลนี้จะถูกซ่อนโดยค่าเริ่มต้น และจะถูกแสดงเมื่อผู้ใช้กดปุ่ม Toggle Sensitive Info

สร้าง Page Extension เพื่อขยายฟังก์ชัน

pageextension 50102 "Sensitive Data List Ext" extends "Sensitive Data List"
{
    actions
    {
        addlast(Processing)
        {
            action("Reset Sensitive Info Visibility")
            {
                Caption = 'Reset Visibility';
                ApplicationArea = All;
                trigger OnAction()
                begin
                    ShowSensitiveData := false;
                    CurrPage.Update(false);
                end;
            }
        }
    }
}

ใน Page Extension นี้ เราได้เพิ่มปุ่ม Reset Sensitive Info Visibility ซึ่งจะทำการซ่อนข้อมูล Sensitive Info ทุกครั้งที่ผู้ใช้กดปุ่มนี้

ตัวอย่างผลลัพธ์

ข้อดีของการใช้ Protected Variables ในภาษา AL

1. การควบคุมการเข้าถึง (Access Control):
   • ตัวแปร Protected ช่วยให้คุณสามารถกำหนดได้ว่าตัวแปรจะถูกเข้าถึงได้จากที่ไหนบ้าง เฉพาะภายในตัวโค้ดหรือจากออบเจ็กต์ที่สืบทอด (Inheritance) มาเท่านั้น ข้อมูลสำคัญจึงไม่ถูกแก้ไขโดยไม่จำเป็น
2. การสืบทอด (Inheritance):
   • ออบเจ็กต์ย่อยสามารถใช้ตัวแปร Protected จากออบเจ็กต์หลักได้อย่างอิสระ ช่วยให้สามารถเพิ่มฟังก์ชันการทำงานใหม่ ๆ โดยใช้ข้อมูลที่ถูกปกป้องในออบเจ็กต์หลักได้อย่างมีประสิทธิภาพ
3. การออกแบบโค้ดที่ยืดหยุ่น (Flexible Code Design):
   • ตัวแปร Protected ทำให้คุณสามารถสร้างโค้ดที่ยืดหยุ่น โดยการเก็บข้อมูลและฟังก์ชันการทำงานในออบเจ็กต์หลัก แล้วสืบทอดและใช้งานในออบเจ็กต์ย่อย ซึ่งช่วยลดการทำซ้ำโค้ด (Code Duplication)
4. ลดข้อผิดพลาด (Reduced Errors):
   • เนื่องจากตัวแปร Protected จะไม่สามารถเข้าถึงได้จากภายนอกออบเจ็กต์หรือออบเจ็กต์ที่ไม่ได้สืบทอด การลดการเข้าถึงตัวแปรที่ไม่จำเป็นจะช่วยลดโอกาสในการเกิดข้อผิดพลาดในโค้ด

ข้อเสียของการใช้ Protected Variables ในภาษา AL

1. ความซับซ้อนในการจัดการ (Complex Management):
   • การใช้ตัวแปร Protected อาจทำให้โค้ดซับซ้อนขึ้น โดยเฉพาะเมื่อมีออบเจ็กต์ย่อยหลายออบเจ็กต์สืบทอดจากออบเจ็กต์หลัก ผู้พัฒนาต้องเข้าใจโครงสร้างการเข้าถึงข้อมูลทั้งหมด ทำให้การบำรุงรักษาโค้ดยากขึ้น
2. การพึ่งพาคลาสหลัก (Base Class Dependency):
   • เมื่อออบเจ็กต์ย่อยพึ่งพาตัวแปร Protected จากออบเจ็กต์หลัก หากออบเจ็กต์หลักมีการเปลี่ยนแปลง จะต้องมีการปรับปรุงโค้ดในออบเจ็กต์ย่อยให้สอดคล้องกัน ซึ่งอาจเพิ่มงานในการบำรุงรักษา
3. การใช้ที่ไม่จำเป็น (Unnecessary Usage):
   • หากมีการใช้ Protected โดยไม่จำเป็น เช่น ประกาศตัวแปร Protected ที่ไม่ต้องการความปกป้อง อาจทำให้โค้ดยุ่งยากโดยไม่จำเป็น ซึ่งควรใช้ Protected เฉพาะในกรณีที่จำเป็นจริง ๆ เท่านั้น
4. ความยุ่งยากในการขยาย (Complicated Extensions):
   • เมื่อมีการสืบทอดตัวแปร Protected หลายชั้น อาจทำให้โค้ดยุ่งยากในการเข้าใจและขยายฟังก์ชันใหม่ ๆ เนื่องจากต้องติดตามว่าแต่ละออบเจ็กต์ใช้ตัวแปรเหล่านี้อย่างไร

การพัฒนาโปรแกรมใน 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

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 บาท)

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;

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

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

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

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

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 ช่วยให้โค้ดสั้นลงและอ่านง่ายขึ้น

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

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;

AL Operators คืออะไร?

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

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

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

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

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

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

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

1. app.json:

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

ตัวอย่าง:

ตัวอย่าง:

ตัวอย่าง:

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

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.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