Prozess-Instanzen abfragen

Der ProcessInstancesClient ermöglicht das Abfragen und Filtern von Prozess-Instanzen mit flexiblen Suchkriterien.

QueryAsync()

Fragt Prozess-Instanzen mit Filtern ab:


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
// Alle laufenden Prozesse abfragen
var instances = await client.QueryAsync(query => {
    query.FilterByState(ProcessState.Running);
});
 
Console.WriteLine($"Gefunden: {instances.Count} laufende Prozesse");
 
foreach (var instance in instances)
{
    Console.WriteLine($"  - {instance.Id} ({instance.ProcessModelId})");
}

Filter-Optionen

Nach ProcessInstanceId


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
var processInstanceId = "abc-123-def-456";
 
var instances = await client.QueryAsync(query => {
    query.FilterByProcessInstanceId(processInstanceId);
});
 
var instance = instances.SingleOrDefault();
 
if (instance != null)
{
    Console.WriteLine($"Prozess gefunden: {instance.Id}");
    Console.WriteLine($"  Status: {instance.State}");
    Console.WriteLine($"  Model: {instance.ProcessModelId}");
}
else
{
    Console.WriteLine("Prozess-Instanz nicht gefunden");
}

Nach ProcessModelId


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
// Alle Instanzen eines bestimmten Prozessmodells
var instances = await client.QueryAsync(query => {
    query.FilterByProcessModelId("OrderProcess");
});
 
Console.WriteLine($"Order-Prozesse: {instances.Count}");
 
// Gruppierung nach Status
var byStatus = instances
    .GroupBy(i => i.State)
    .Select(g => new { State = g.Key, Count = g.Count() });
 
foreach (var group in byStatus)
{
    Console.WriteLine($"  {group.State}: {group.Count}");
}

Nach CorrelationId


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
var correlationId = "ORDER-2025-001";
 
// Alle Prozesse mit derselben Correlation-ID
var instances = await client.QueryAsync(query => {
    query.FilterByCorrelationId(correlationId);
});
 
Console.WriteLine($"Prozesse mit Correlation '{correlationId}': {instances.Count}");
 
foreach (var instance in instances)
{
    Console.WriteLine($"  - {instance.ProcessModelId}: {instance.State}");
}

Correlation-IDs ermöglichen es, mehrere zusammenhängende Prozess-Instanzen zu gruppieren und gemeinsam abzufragen.

Nach Status (State)


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
// Einzelner Status
var runningInstances = await client.QueryAsync(query => {
    query.FilterByState(ProcessState.Running);
});
 
Console.WriteLine($"Laufende Prozesse: {runningInstances.Count}");
 
// Mehrere Status
var endedInstances = await client.QueryAsync(query => {
    query.FilterByStates(
        ProcessState.Finished,
        ProcessState.Error,
        ProcessState.Terminated
    );
});
 
Console.WriteLine($"Beendete Prozesse: {endedInstances.Count}");

Kombinierte Filter


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
// Mehrere Filter kombinieren
var instances = await client.QueryAsync(query => {
    query.FilterByProcessModelId("OrderProcess");
    query.FilterByState(ProcessState.Running);
});
 
Console.WriteLine($"Laufende Order-Prozesse: {instances.Count}");

ProcessInstance Properties

Eine ProcessInstance enthält folgende wichtige Properties:

Property	Typ	Beschreibung
`Id`	`string`	Eindeutige ID der Instanz
`ProcessModelId`	`string`	ID des Prozessmodells
`CorrelationId`	`string`	Correlation-ID
`State`	`ProcessState`	Aktueller Status
`CreatedAt`	`DateTime`	Erstellungszeitpunkt
`FinishedAt`	`DateTime?`	Endzeitpunkt (falls beendet)
`Identity`	`Identity`	Identität des Starters

ProcessState Enum

State	Beschreibung
`Running`	Prozess läuft aktuell
`Suspended`	Prozess wartet (z.B. auf User Task)
`Finished`	Prozess erfolgreich beendet
`Error`	Prozess mit Fehler beendet
`Terminated`	Prozess wurde manuell abgebrochen

Prozess-Details abrufen


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
var processInstanceId = "abc-123";
 
var instances = await client.QueryAsync(query => {
    query.FilterByProcessInstanceId(processInstanceId);
});
 
var instance = instances.SingleOrDefault();
 
if (instance != null)
{
    Console.WriteLine($"Prozess-Instanz: {instance.Id}");
    Console.WriteLine($"  Model: {instance.ProcessModelId}");
    Console.WriteLine($"  Status: {instance.State}");
    Console.WriteLine($"  Correlation: {instance.CorrelationId}");
    Console.WriteLine($"  Erstellt: {instance.CreatedAt:yyyy-MM-dd HH:mm:ss}");
 
    if (instance.FinishedAt.HasValue)
    {
        var duration = instance.FinishedAt.Value - instance.CreatedAt;
        Console.WriteLine($"  Beendet: {instance.FinishedAt:yyyy-MM-dd HH:mm:ss}");
        Console.WriteLine($"  Dauer: {duration.TotalSeconds:F2} Sekunden");
    }
    else
    {
        var runningTime = DateTime.UtcNow - instance.CreatedAt;
        Console.WriteLine($"  Laufzeit: {runningTime.TotalMinutes:F1} Minuten");
    }
 
    if (instance.Identity != null)
    {
        Console.WriteLine($"  Gestartet von: {instance.Identity.UserId}");
    }
}

Status überwachen (Polling)


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var definitionsClient = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
var instancesClient = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
// Prozess starten
var response = await definitionsClient.StartProcessInstanceAsync(
    processModelId: "DataProcessing",
    startEventId: "StartEvent_1",
    initialToken: new { dataId = "DATA-789" }
);
 
var processInstanceId = response.ProcessInstanceId;
Console.WriteLine($"Prozess gestartet: {processInstanceId}");
 
// Status überwachen bis Prozess beendet ist
var isRunning = true;
 
while (isRunning)
{
    await Task.Delay(2000); // 2 Sekunden warten
 
    var instances = await instancesClient.QueryAsync(query => {
        query.FilterByProcessInstanceId(processInstanceId);
    });
 
    var instance = instances.SingleOrDefault();
 
    if (instance == null)
    {
        Console.WriteLine("Prozess nicht gefunden");
        break;
    }
 
    Console.WriteLine($"Status: {instance.State}");
 
    // Prüfen ob beendet
    switch (instance.State)
    {
        case ProcessState.Finished:
            Console.WriteLine("✓ Prozess erfolgreich abgeschlossen");
            isRunning = false;
            break;
 
        case ProcessState.Error:
            Console.WriteLine("✗ Prozess mit Fehler beendet");
            isRunning = false;
            break;
 
        case ProcessState.Terminated:
            Console.WriteLine("⊘ Prozess wurde abgebrochen");
            isRunning = false;
            break;
 
        case ProcessState.Running:
            Console.WriteLine("⟳ Prozess läuft...");
            break;
 
        case ProcessState.Suspended:
            Console.WriteLine("⏸ Prozess wartet...");
            break;
    }
}

Polling sollte mit Bedacht eingesetzt werden. Für Echtzeit-Updates sollten Sie stattdessen Event-basierte Mechanismen oder SignalR verwenden.

Statistiken erstellen


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
// Alle Instanzen eines Prozessmodells abrufen
var instances = await client.QueryAsync(query => {
    query.FilterByProcessModelId("OrderProcess");
});
 
Console.WriteLine("Order-Prozess Statistiken:");
Console.WriteLine($"  Gesamt: {instances.Count}");
 
// Nach Status gruppieren
var stats = instances
    .GroupBy(i => i.State)
    .Select(g => new
    {
        State = g.Key,
        Count = g.Count(),
        Percentage = (g.Count() * 100.0) / instances.Count
    })
    .OrderByDescending(s => s.Count);
 
foreach (var stat in stats)
{
    Console.WriteLine($"  {stat.State}: {stat.Count} ({stat.Percentage:F1}%)");
}
 
// Durchschnittliche Laufzeit berechnen (nur beendete Prozesse)
var finishedInstances = instances
    .Where(i => i.FinishedAt.HasValue)
    .ToList();
 
if (finishedInstances.Any())
{
    var avgDuration = finishedInstances
        .Average(i => (i.FinishedAt!.Value - i.CreatedAt).TotalSeconds);
 
    Console.WriteLine($"\nDurchschnittliche Laufzeit: {avgDuration:F2} Sekunden");
}

Zeitbasierte Filter


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
// Alle Instanzen abrufen
var allInstances = await client.QueryAsync(query => {
    query.FilterByProcessModelId("OrderProcess");
});
 
// Im Code filtern nach Zeitstempel
var now = DateTime.UtcNow;
var last24Hours = now.AddHours(-24);
var lastWeek = now.AddDays(-7);
 
// Prozesse der letzten 24 Stunden
var recent = allInstances
    .Where(i => i.CreatedAt >= last24Hours)
    .ToList();
 
Console.WriteLine($"Letzte 24 Stunden: {recent.Count}");
 
// Prozesse der letzten Woche
var thisWeek = allInstances
    .Where(i => i.CreatedAt >= lastWeek)
    .ToList();
 
Console.WriteLine($"Letzte 7 Tage: {thisWeek.Count}");
 
// Laufen länger als 1 Stunde
var longRunning = allInstances
    .Where(i => i.State == ProcessState.Running)
    .Where(i => (DateTime.UtcNow - i.CreatedAt).TotalHours > 1)
    .ToList();
 
Console.WriteLine($"Laufen länger als 1h: {longRunning.Count}");

Mit Authentifizierung


using ProcessCube.Engine;
using ProcessCube.Engine.Client.Identity;
 
// Identity Provider erstellen
var identityProvider = new ClientCredentialsIdentityProvider(
    authorityAddress: "http://localhost:11235",
    clientId: "monitoring-service",
    clientSecret: "secret-key",
    scope: "engine_read"
);
 
// Token abrufen
var identity = await identityProvider.GetIdentityAsync();
 
// Client mit Identity erstellen
var client = ClientFactory.CreateProcessInstancesClient(
    engineAddress: "http://localhost:8000",
    identity: identity
);
 
// Prozesse abfragen (authentifiziert)
var instances = await client.QueryAsync(query => {
    query.FilterByState(ProcessState.Running);
});
 
Console.WriteLine($"Laufende Prozesse: {instances.Count}");

Dashboard-Daten sammeln


using ProcessCube.Engine;
 
public class ProcessDashboard
{
    private readonly IProcessInstancesClient _client;
 
    public ProcessDashboard(IProcessInstancesClient client)
    {
        _client = client;
    }
 
    public async Task<DashboardData> GetDashboardDataAsync(string processModelId)
    {
        var instances = await _client.QueryAsync(query => {
            query.FilterByProcessModelId(processModelId);
        });
 
        var dashboard = new DashboardData
        {
            ProcessModelId = processModelId,
            TotalInstances = instances.Count,
            Running = instances.Count(i => i.State == ProcessState.Running),
            Suspended = instances.Count(i => i.State == ProcessState.Suspended),
            Finished = instances.Count(i => i.State == ProcessState.Finished),
            Error = instances.Count(i => i.State == ProcessState.Error),
            Terminated = instances.Count(i => i.State == ProcessState.Terminated)
        };
 
        // Durchschnittliche Laufzeit
        var finishedInstances = instances
            .Where(i => i.FinishedAt.HasValue)
            .ToList();
 
        if (finishedInstances.Any())
        {
            dashboard.AverageDurationSeconds = finishedInstances
                .Average(i => (i.FinishedAt!.Value - i.CreatedAt).TotalSeconds);
        }
 
        return dashboard;
    }
}
 
public class DashboardData
{
    public string ProcessModelId { get; set; }
    public int TotalInstances { get; set; }
    public int Running { get; set; }
    public int Suspended { get; set; }
    public int Finished { get; set; }
    public int Error { get; set; }
    public int Terminated { get; set; }
    public double AverageDurationSeconds { get; set; }
}

Fehlerbehandlung


using ProcessCube.Engine;
using ProcessCube.Engine.Client.Exceptions;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
try
{
    var instances = await client.QueryAsync(query => {
        query.FilterByProcessModelId("OrderProcess");
    });
 
    Console.WriteLine($"Gefunden: {instances.Count} Instanzen");
}
catch (EngineClientException ex) when (ex.StatusCode == 401)
{
    Console.WriteLine("Nicht authentifiziert");
}
catch (EngineClientException ex) when (ex.StatusCode == 403)
{
    Console.WriteLine("Fehlende Berechtigung");
}
catch (HttpRequestException ex)
{
    Console.WriteLine($"Verbindungsfehler: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Unerwarteter Fehler: {ex.Message}");
}

Performance-Tipp: Wenn Sie nur den Status eines einzelnen Prozesses prüfen müssen, verwenden Sie FilterByProcessInstanceId() statt alle Instanzen abzufragen.

Nächste Schritte

Prozess beenden - Instanzen abbrechen
Prozess neu starten - Fehlerhafte Prozesse wiederholen
FlowNode Instances - Ausführungshistorie abfragen