כיצד לנטר את התקדמות טעינת הפרויקט ב‑C#

קבצי Microsoft Project גדולים בפורמט MPP ו‑Primavera בפורמט XER יכולים לקחת בין כמה שניות למספר דקות לעיבוד. בזמן זה, יישום פשוט נראה קפוא: אין סרגל התקדמות, אין טקסט מצב, ואין דבר שהמשתמש יכול לפעול עליו. כל מי שטוען לוחות זמנים גדולים צריך דרך להציג כמה התהליך התקדם, ודרך לעצור תהליך שממשך זמן רב מדי.

מדריך זה מכסה את שני המקרים עם Aspose.Tasks for .NET. תבנה קריאת משוב התקדמות המדווחת על השלב הנוכחי והאחוז, תחבר אותה לטעינה, תשמור על ממשק משתמש שולחני רספונסיבי בזמן שהפענוח רץ בחוט רקע, ותבטל טעינה שעולה על תקציב זמן.

נקודות מרכזיות

• IProgressNotificationCallback.Notify(ProgressNotificationArgs) הוא המתודה היחידה שאתה מיישם כדי לקבל התקדמות טעינה מ‑Aspose.Tasks for .NET.
• ProgressNotificationArgs חושפת את CurrentStepName, CurrentStepProgress (0–100) ו‑EstimatedTotalProgress (0–100).
• חבר את הקריאה חזרה עם LoadOptions.ProjectLoadingCallback; היא נתמכת בפורמטים MPP ו‑XER.
• Notify פועלת על חוט הטעינה, ולכן יש להעביר ערכים לחוט ה‑UI לפני עדכון פקד.
• בטל טעינה איטית על‑ידי הגדרת LoadOptions.CancellationToken וקראת Cancel() על ה‑CancellationTokenSource שלו מתוך חוט אחר.
• ממשק ה‑API של ההתקדמות פועל במצב הערכה; רישיון מסיר רק מגבלות של גודל קובץ ופלט.

חדש בספרייה? דף המוצר של Aspose.Tasks for .NET product page וההתיעוד מכסים את ההגדרה והרישוי במלואם.

איך לנטר את התקדמות טעינת הפרויקט ב‑C#?

מממשים את IProgressNotificationCallback, מגדירים אותו ב‑LoadOptions.ProjectLoadingCallback, וטוענים את הקובץ דרך הבנאי של Project שמקבל LoadOptions. הקוד המינימלי הפועל מורכב משלושה חלקים: מחלקת callback, מופע של LoadOptions, והקריאה לטעינה.

• Input: קובץ MPP או XER, לדוגמה BigProject.mpp
• Output: עדכוני התקדמות במהלך הפענוח — CurrentStepName, CurrentStepProgress, EstimatedTotalProgress
• Library: Aspose.Tasks for .NET
• Language: C#

using System;
using Aspose.Tasks;

internal sealed class ConsoleProgressCallback : IProgressNotificationCallback
{
    public void Notify(ProgressNotificationArgs args)
    {
        Console.WriteLine(
            "{0}: step {1}% / total {2}%",
            args.CurrentStepName,
            args.CurrentStepProgress,
            args.EstimatedTotalProgress);
    }
}

internal static class Program
{
    private static void Main()
    {
        // A license is optional here. Uncomment to remove evaluation limits.
        // new License().SetLicense("Aspose.Tasks.lic");

var loadOptions = new LoadOptions
        {
            ProjectLoadingCallback = new ConsoleProgressCallback()
        };

var project = new Project("BigProject.mpp", loadOptions);

Console.WriteLine("Loaded {0} top-level tasks.", project.RootTask.Children.Count);
    }
}

כאשר הקובץ מפוענח, Notify פועל מספר פעמים והקונסול מציג את השלב והאחוזים. לאחר שהקונסטרקטור מחזיר, האובייקט Project נטען במלואו וניתן לשימוש.

למה ניטור התקדמות הטעינה חשוב לקבצים גדולים?

זה מחליף הפסקה שנראית בלתי מגיבה במשוב חזותי, שהיא ההבדל בין יישום שנראה שבור לבין יישום שנראה עסוק. ככל שהקובץ גדול יותר, כך זמן הפענוח ארוך יותר, וככל שהטעינה העיוורת עולה יותר מבחינת האיכות הנתפסת.

שימושים קונקרטיים לערכי ההתקדמות:

• הפעל סרגל התקדמות קבוע מ-EstimatedTotalProgress במקום להציג סמן אינסופי.
• רשום שינויי CurrentStepName כדי למצוא איזו שלב שולט בזמן הטעינה כאשר אתה מבצע פרופיל לקובץ איטי.
• שמור על תגובתיות הממשק על ידי טעינה בחוט רקע ושליחת ההתקדמות לחוט הממשק.
• הצג התקדמות לכל קובץ בכלי אצווה שממיר או מעביר פרויקטים רבים ברצף.

איך מתקינים את Aspose.Tasks ומגדירים את הפרויקט?

הוסף את חבילת NuGet של Aspose.Tasks לפרויקט .NET 6 או מאוחר יותר.

dotnet add package Aspose.Tasks

או, מ-Visual Studio Package Manager Console:

Install-Package Aspose.Tasks

הקריאה חזרה של ההתקדמות עובדת ללא רישיון. אם אתה צריך לטעון קבצים שמעבר למגבלת הגודל של ההערכה או לעבד ללא מגבלות הערכה, הגדר רישיון פעם אחת בעת ההפעלה:

using Aspose.Tasks;

var license = new License();
license.SetLicense("Aspose.Tasks.lic");

אתה יכול לבקש רישיון זמני חינמי מדף הרישיון הזמני של Aspose, ולקרוא עוד על הספרייה בדף המוצר של Aspose.Tasks for .NET.

מה מספקת ה-API IProgressNotificationCallback?

ה‑API הוא ממשק אחד, שיטה אחת, וסוג ארגומנט אחד, כולם במרחב השמות Aspose.Tasks.

ProgressNotificationArgs הוא sealed ונגזר מ-EventArgs. שלושת המאפיינים שלו הם read-only.

איך מיישמים קריאת חזרה של הודעת התקדמות?

צור מחלקה שמממשת IProgressNotificationCallback ועשה משהו שימושי עם ProgressNotificationArgs בתוך Notify. שמור על מהירות השיטה, מכיוון שהיא רצה על חוט הטעינה.

using System;
using Aspose.Tasks;

internal sealed class ConsoleProgressCallback : IProgressNotificationCallback
{
    private int lastTotal = -1;

public void Notify(ProgressNotificationArgs args)
    {
        // Only redraw when the total percentage actually changes.
        if (args.EstimatedTotalProgress == lastTotal)
        {
            return;
        }

lastTotal = args.EstimatedTotalProgress;
        Console.WriteLine("[{0,3}%] {1}", args.EstimatedTotalProgress, args.CurrentStepName);
    }
}

המאבטח על lastTotal מונע הצפה של הקונסול עם שורות משוכפלות כאשר כמה קריאות Notify מדווחות על אותו סך כולל.

איך לטעון פרויקט עם מעקב התקדמות?

הגדר ProjectLoadingCallback על אובייקט LoadOptions, ואז העבר אותו לבנאי Project. הטעינה מתבצעת באופן סינכרוני; כאשר הבנאי מחזיר, ניתוח הקובץ הושלם.

using System;
using Aspose.Tasks;

internal static class Loader
{
    public static Project Load(string path)
    {
        var loadOptions = new LoadOptions
        {
            ProjectLoadingCallback = new ConsoleProgressCallback()
        };

// Same call for MPP and XER; only the file path changes.
        var project = new Project(path, loadOptions);

Console.WriteLine("Done. Root task children: {0}", project.RootTask.Children.Count);
        return project;
    }
}

מנסים זאת בלוחות הזמנים שלכם? הורידו רישיון זמני חינמי כדי להריץ עומסים ללא מגבלת ההערכה על גודל הקובץ.

איך לשמור על ממשק משתמש תגובתי בזמן טעינה?

טען בחוט רקע והעבר את ערכי ההתקדמות לחוט ממשק המשתמש בתוך הפונקציה הקולבק, מכיוון ש‑Notify פועל על כל חוט שקרא לבונה Project.

using System.Windows.Forms;
using Aspose.Tasks;

internal sealed class ProgressBarCallback : IProgressNotificationCallback
{
    private readonly ProgressBar bar;

public ProgressBarCallback(ProgressBar bar) => this.bar = bar;

public void Notify(ProgressNotificationArgs args)
    {
        if (bar.InvokeRequired)
        {
            bar.BeginInvoke(() => bar.Value = args.EstimatedTotalProgress);
        }
        else
        {
            bar.Value = args.EstimatedTotalProgress;
        }
    }
}

ב‑WPF, השתמש ב‑Dispatcher.Invoke או ב‑Dispatcher.BeginInvoke במקום Control.BeginInvoke.

איך לבטל טעינה ארוכת‑זמן?

הגדר LoadOptions.CancellationToken לטוקן מ-CancellationTokenSource, ואז קרא Cancel() על המקור הזה מתוך ת׳ אחרת. Aspose.Tasks מפסיק לנתח והקונסטרקטור של Project זורק, ולכן יש לעטוף זאת ב-try/catch.

using System;
using System.Threading;
using Aspose.Tasks;

var cts = new CancellationTokenSource();

var loadOptions = new LoadOptions
{
    ProjectLoadingCallback = new ConsoleProgressCallback(),
    CancellationToken = cts.Token
};

// Wire a Cancel button or a timeout to this:
// cts.CancelAfter(TimeSpan.FromSeconds(30));

try
{
    var project = new Project("BigProject.xer", loadOptions);
    Console.WriteLine("Loaded {0} tasks.", project.RootTask.Children.Count);
}
catch (Exception ex)
{
    Console.WriteLine("Load stopped: {0}", ex.Message);
}

סיכום

הוספת התקדמות טעינה ליישום Aspose.Tasks for .NET היא שינוי קטן עם השפעה גדולה על תחושת המהירות הנתפסת. מממשים IProgressNotificationCallback, משייכים אותו ל‑LoadOptions.ProjectLoadingCallback, וקוראים ל‑CurrentStepName, CurrentStepProgress ו‑EstimatedTotalProgress בתוך Notify. מוסיפים CancellationToken כאשר טעינות יכולות לרוץ זמן רב עד שמשתמש עשוי לרצות לעצור אותן.

Explore the Aspose.Tasks for .NET תיעוד ו‑הפניות API כדי להמשיך, והורד רישיון זמני חינמי כדי להערכה ללא מגבלות.

שאלות נפוצות

האם אני צריך רישיון בתשלום כדי להשתמש ב‑API של התראות התקדמות?
לא. IProgressNotificationCallback פועל במצב הערכה. רישיון זמני או בתשלום מסיר רק את מגבלות ההערכה על גודל הקובץ והפלט; הוא אינו משחרר את ה‑progress API.

האם אותו callback עובד גם עבור קבצי XER וגם עבור MPP?
כן. LoadOptions.ProjectLoadingCallback נתמך כיום עבור פורמטים MPP ו‑XER. יישום IProgressNotificationCallback זהה מטפל בשניהם.

האם ה‑callback של ההתקדמות בטוח מבחינת תחרויות?
Notify מתבצע על החוט שמריץ את הטעינה, ולא על חוט רקע. באפליקציית שולחן עבודה, יש להעביר את הערכים לחוט ה‑UI באמצעות Control.Invoke או Dispatcher.Invoke לפני שמעדכנים סרגל התקדמות.

מה ההבדל בין CurrentStepProgress ל-EstimatedTotalProgress?
CurrentStepProgress הוא אחוז ההשלמה לשלב הנוכחי של הטעינה, כגון קריאת משימות או קריאת משאבים. EstimatedTotalProgress הוא אחוז ההשלמה המשוער לכל הפעולה. שניהם מספרים שלמים מ‑0 עד 100.

האם אני יכול לבטל טעינה מתוך הקריאה חזרה? לא מתוך Notify ישירות. במקום זאת, הגדר את LoadOptions.CancellationToken לטוקן מ-CancellationTokenSource וקרא ל-Cancel() על המקור משורת אחרת. הקונסטרוקטור של Project לאחר מכן נעצרת וזורקת, ולכן יש לעטוף זאת ב-try/catch.

האם הוספת callback מאטה את הטעינה?
העומס של ה‑callback זניח מכיוון ש‑Notify נקרא במספר מצומצם של נקודות ביקורת, ולא עבור כל רשומה. עם זאת, שמרו על השיטה קלה, מכיוון שכל עבודה שתבצעו בתוכה רצה על חוט הטעינה.

קרא עוד

• המרת MS Project מ-XML ל-HTML ב-C#