Hur man övervakar projektets laddningsframsteg i C#

Stora Microsoft Project MPP och Primavera XER filer kan ta allt från några sekunder till flera minuter att analysera. Medan det pågår ser en enkel applikation ut att vara frusen: ingen förloppsindikator, ingen statustext, inget som användaren kan agera på. Alla som laddar stora scheman behöver ett sätt att visa hur långt en laddning har kommit, samt ett sätt att stoppa en som kör för länge.

Den här guiden täcker båda med Aspose.Tasks for .NET. Du kommer att bygga en progress‑callback som rapporterar den aktuella fasen och en procentsats, ansluta den till inläsningen, hålla ett skrivbords‑UI responsivt medan parsning körs på en bakgrundstråd, och avbryta en inladdning som överskrider en tidsbudget.

Viktiga slutsatser

• IProgressNotificationCallback.Notify(ProgressNotificationArgs) är den enda metod du implementerar för att ta emot laddningsprogress från Aspose.Tasks for .NET.
• ProgressNotificationArgs exponerar CurrentStepName, CurrentStepProgress (0–100) och EstimatedTotalProgress (0–100).
• Anslut återuppringningen med LoadOptions.ProjectLoadingCallback; den stöds för MPP- och XER-formaten.
• Notify körs på laddningstråden, så marshala värden till UI-tråden innan du uppdaterar en kontroll.
• Avbryt en långsam laddning genom att sätta LoadOptions.CancellationToken och anropa Cancel() på dess CancellationTokenSource från en annan tråd.
• Progress‑API:et fungerar i evalueringsläge; en licens tar bara bort begränsningar för filstorlek och utdata.

Ny i biblioteket? Produktsidan för Aspose.Tasks for .NET och dokumentationen täcker installation och licensiering i sin helhet.

Hur man övervakar projektladdningsförlopp i C#?

Implementera IProgressNotificationCallback, sätt den på LoadOptions.ProjectLoadingCallback och ladda filen via Project‑konstruktorn som accepterar LoadOptions. Den minsta fungerande koden består av tre delar: en callback‑klass, en LoadOptions‑instans och laddningsanropet.

• Inmatning: en MPP- eller XER-fil, till exempel BigProject.mpp
• Utdata: framstegsuppdateringar under parsning — CurrentStepName, CurrentStepProgress, EstimatedTotalProgress
• Bibliotek: Aspose.Tasks for .NET
• Språk: 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);
    }
}

När filen analyseras kör Notify flera gånger och konsolen visar fasen och procentsatserna. Efter att konstruktorn returnerar är Project‑objektet helt inläst och kan användas.

Varför är övervakning av laddningsförlopp viktigt för stora filer?

Den ersätter en oresponsiv paus med synlig återkoppling, vilket är skillnaden mellan en applikation som ser trasig ut och en som ser upptagen ut. Ju större filen är, desto längre blir parsningen, och desto mer kostar en blind laddning dig i upplevd kvalitet.

Konkreta användningsområden för framstegsvärdena:

• Styr en bestämd framdriftsindikator från EstimatedTotalProgress istället för att visa en oändlig spinner.
• Logga CurrentStepName‑övergångar för att hitta vilken fas som dominerar laddningstiden när du profilerar en långsam fil.
• Håll UI:t responsivt genom att ladda på en bakgrundstråd och skicka framsteg till UI‑tråden.
• Visa per‑fil‑framsteg i ett batchverktyg som konverterar eller migrerar många projekt i sekvens.

Hur installerar du Aspose.Tasks och ställer in projektet?

Lägg till Aspose.Tasks NuGet‑paketet i ett .NET 6‑ eller senare projekt.

dotnet add package Aspose.Tasks

Eller, från Visual Studio Package Manager Console:

Install-Package Aspose.Tasks

Progress callback fungerar utan licens. Om du behöver ladda filer som överstiger utvärderingsstorleksgränsen eller bearbeta utan utvärderingsrestriktioner, ställ in en licens en gång vid start:

using Aspose.Tasks;

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

Du kan begära en gratis tillfällig licens från Aspose temporära licenssida, och läsa mer om biblioteket på Aspose.Tasks for .NET produktsida.

Vad erbjuder IProgressNotificationCallback API?

API:et är ett gränssnitt, en metod och en argumenttyp, alla i Aspose.Tasks‑namnutrymmet.

ProgressNotificationArgs är förseglad och ärver från EventArgs. Alla tre av dess egenskaper är endast läsbara.

Hur implementerar du en återuppringning för förloppsavisering?

Skapa en klass som implementerar IProgressNotificationCallback och gör något användbart med ProgressNotificationArgs inuti Notify. Håll metoden snabb, eftersom den körs på laddningstråden.

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);
    }
}

Vakten på lastTotal förhindrar att konsolen översvämmas med dubblettlinjer när flera Notify‑anrop rapporterar samma total.

Hur laddar du ett projekt med förloppsspårning?

Ställ in ProjectLoadingCallback på ett LoadOptions‑objekt och skicka sedan det till Project‑konstruktorn. Inläsningen körs synkront; när konstruktorn returnerar är parsningen klar.

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;
    }
}

Försöker du göra detta på dina egna scheman? Ladda ner en gratis tillfällig licens för att köra belastningar utan utvärderingsgränsen för filstorlek.

Hur håller du ett UI responsivt medan det laddas?

Läs in på en bakgrundstråd och vidarebefordra värdena för framsteg till UI‑tråden i återanropet, eftersom Notify körs på den tråd som anropade Project‑konstruktorn.

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;
        }
    }
}

I WPF, använd Dispatcher.Invoke eller Dispatcher.BeginInvoke i stället för Control.BeginInvoke.

Hur avbryter du en långvarig laddning?

Ställ in LoadOptions.CancellationToken till en token från en CancellationTokenSource, anropa sedan Cancel() på den källan från en annan tråd. Aspose.Tasks stoppar parsning och Project‑konstruktorn kastar ett undantag, så omslut den med 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);
}

Slutsats

Att lägga till laddningsprogress i en Aspose.Tasks for .NET‑applikation är en liten förändring med stor effekt på den upplevda responsen. Implementera IProgressNotificationCallback, tilldela den till LoadOptions.ProjectLoadingCallback och läs CurrentStepName, CurrentStepProgress och EstimatedTotalProgress i Notify. Lägg till en CancellationToken när laddningar kan pågå så länge att en användare kan vilja stoppa dem.

Utforska Aspose.Tasks for .NET documentation och API-referensen för att gå vidare, samt ladda ner en gratis tillfällig licens för att utvärdera utan begränsningar.

Vanliga frågor

Behöver jag en betald licens för att använda progress‑notifierings‑API:t?
Nej. IProgressNotificationCallback fungerar i utvärderingsläge. En tillfällig eller betald licens tar bara bort utvärderingsgränserna för filstorlek och utdata; den låser inte upp progress‑API:t.

Fungerar samma återuppringning för XER-filer lika bra som för MPP?
Ja. LoadOptions.ProjectLoadingCallback stöds för närvarande för MPP- och XER-formaten. Samma IProgressNotificationCallback‑implementation hanterar båda.

Är återuppringningsmetoden för framsteg trådsäker?
Notify anropas på den tråd som kör laddningen, inte på en bakgrundstråd. I en skrivbordsapp, marshala värdena till UI‑tråden med Control.Invoke eller Dispatcher.Invoke innan du rör en förloppsindikator.

Vad är skillnaden mellan CurrentStepProgress och EstimatedTotalProgress?
CurrentStepProgress är den procentuella färdigheten för det aktuella steget i laddningen, till exempel läsning av uppgifter eller läsning av resurser. EstimatedTotalProgress är den uppskattade procentuella färdigheten för hela operationen. Båda är heltal från 0 till 100.

Kan jag avbryta en laddning från inne i callbacken?
Inte från inne i Notify direkt. Istället, sätt LoadOptions.CancellationToken till en token från en CancellationTokenSource och anropa Cancel() på den källan från en annan tråd. Project‑konstruktorn stoppar då och kastar ett undantag, så omslut den i try/catch.

Påverkar ett callback laddningshastigheten? Callback-överheaden är försumbar eftersom Notify anropas vid ett litet antal kontrollpunkter, inte per post. Håll metoden lättviktig, dock, eftersom allt arbete du utför i den körs på laddningstråden.

Läs mer

• Konvertera MS Project från XML till HTML i C#