Bestanden inchecken en uitchecken in Vault met C#

Check-in en check-out zijn de kernoperaties van Vault: ze zorgen ervoor dat bestanden gecontroleerd worden gewijzigd en dat versiegeschiedenissen correct worden bijgehouden. Via C# kun je deze operaties volledig automatiseren — ideaal voor geautomatiseerde revisieprocessen, batchupdates en CI/CD-integraties.

Concepten: check-out, check-in en undo

Check-out reserveert een bestand voor jou: anderen kunnen het nog lezen maar niet aanpassen. Het bestand wordt gedownload naar een lokaal pad. Check-in laadt de gewijzigde versie terug naar Vault en maakt een nieuwe versie aan. Undo checkout geeft de reservering vrij zonder een nieuwe versie te maken — handig als je toch geen wijzigingen hebt gedaan.

Verbinding opzetten

using Autodesk.Connectivity.WebServices;
using Autodesk.Connectivity.WebServicesTools;
using VDF = Autodesk.DataManagement.Client.Framework;

var conn = VDF.Vault.Library.ConnectionManager.Connect(
    serverIdentities, credentials,
    VDF.Vault.Currency.Connections.AuthenticationFlags.Standard);

var docSvc    = conn.WebServiceManager.DocumentService;
var fileSvc   = conn.WebServiceManager.DocumentServiceExtensions;

Een bestand uitchecken (check-out)

public string CheckOutBestand(
    VDF.Vault.Currency.Connections.Connection conn,
    File vaultBestand,
    string lokaalPad)
{
    // Zorg dat de lokale map bestaat
    Directory.CreateDirectory(lokaalPad);

    string lokaalBestandPad = Path.Combine(
        lokaalPad, vaultBestand.Name);

    // Check-out aanvragen
    var acqSettings = new AcquireFilesSettings(conn)
    {
        DefaultAcquisitionOption = FileAcquisitionOptions.Checkout
    };
    acqSettings.AddFileToAcquire(vaultBestand, FileAcquisitionOptions.Checkout);

    var resultaat = conn.FileManager.AcquireFiles(acqSettings);

    if (resultaat.FileResults.Any(r => r.Status == FileAcquisitionStatus.Success))
    {
        Console.WriteLine($"✓ Uitgecheckt: {vaultBestand.Name}");
        return resultaat.FileResults.First().LocalPath.FullPath;
    }
    else
    {
        var fout = resultaat.FileResults.First().Exception?.Message ?? "onbekende fout";
        throw new Exception($"Check-out mislukt: {fout}");
    }
}

Controleren of een bestand al is uitgecheckt

public bool IsUitgecheckt(File bestand, out string doorWie)
{
    doorWie = bestand.CheckedOut ? bestand.CheckedOutBy?.DisplayName ?? "onbekend" : "";
    return bestand.CheckedOut;
}

// Gebruik:
if (IsUitgecheckt(vaultBestand, out string gebruiker))
    Console.WriteLine($"Uitgecheckt door: {gebruiker}");
else
    Console.WriteLine("Beschikbaar voor check-out.");

Een bestand inchecken (check-in)

public void CheckInBestand(
    VDF.Vault.Currency.Connections.Connection conn,
    File vaultBestand,
    string lokaalBestandPad,
    string commentaar)
{
    var inSettings = new CheckinFileSettings(conn);

    // Commentaar toevoegen
    inSettings.Comment = commentaar;

    // Bestand registreren voor check-in
    inSettings.AddFileToCheckin(
        vaultBestand,
        new FilePathAbsolute(lokaalBestandPad),
        false // keepCheckedOut = false → geef reservering vrij
    );

    var resultaat = conn.FileManager.CheckinFiles(inSettings);

    foreach (var r in resultaat.FileResults)
    {
        if (r.Status == CheckinStatus.Success)
            Console.WriteLine($"✓ Ingecheckt: {r.File.Name} (v{r.File.VerNum})");
        else
            Console.WriteLine($"✗ Mislukt:    {r.File.Name} — {r.Exception?.Message}");
    }
}

Check-out ongedaan maken (undo checkout)

public void OngedaanMakenCheckout(
    VDF.Vault.Currency.Connections.Connection conn,
    File vaultBestand)
{
    // UndoCheckout gooit de lokale wijzigingen weg en bevrijdt de reservering
    conn.WebServiceManager.DocumentService
        .UndoCheckoutFile(vaultBestand.MasterId, out _);

    Console.WriteLine($"Check-out ongedaan gemaakt: {vaultBestand.Name}");
}

Volledig workflow: check-out → wijzig → check-in

public void VoerWorkflowUit(
    VDF.Vault.Currency.Connections.Connection conn,
    string vaultPad,
    string lokaalWerkmap,
    string commentaar)
{
    var docSvc  = conn.WebServiceManager.DocumentService;

    // 1. Bestand zoeken in Vault
    var map     = docSvc.GetFolderByPath(Path.GetDirectoryName(vaultPad).Replace('\', '/'));
    var bestanden = docSvc.GetLatestFilesByFolderId(map.Id, false);
    var bestand = bestanden.FirstOrDefault(f => f.Name == Path.GetFileName(vaultPad));

    if (bestand == null)
        throw new Exception($"Bestand niet gevonden: {vaultPad}");

    // 2. Controleer of al uitgecheckt
    if (bestand.CheckedOut)
        throw new Exception($"Al uitgecheckt door {bestand.CheckedOutBy?.DisplayName}");

    // 3. Uitchecken
    string lokaalPad = CheckOutBestand(conn, bestand, lokaalWerkmap);

    // 4. Bestand aanpassen (hier jouw logica)
    File.AppendAllText(lokaalPad, $"
// Bijgewerkt op {DateTime.Now}");

    // 5. Inchecken
    // Herlaad bestand om actuele versieinfo te hebben
    bestanden = docSvc.GetLatestFilesByFolderId(map.Id, false);
    bestand   = bestanden.First(f => f.Name == Path.GetFileName(vaultPad));

    CheckInBestand(conn, bestand, lokaalPad, commentaar);
}

Meerdere bestanden tegelijk uitchecken

public void BatchCheckOut(
    VDF.Vault.Currency.Connections.Connection conn,
    IEnumerable bestanden,
    string lokaalMap)
{
    var settings = new AcquireFilesSettings(conn)
    {
        DefaultAcquisitionOption = FileAcquisitionOptions.Checkout
    };

    foreach (var b in bestanden)
        settings.AddFileToAcquire(b, FileAcquisitionOptions.Checkout);

    var resultaat = conn.FileManager.AcquireFiles(settings);

    foreach (var r in resultaat.FileResults)
    {
        if (r.Status == FileAcquisitionStatus.Success)
            Console.WriteLine($"✓ {r.File.Name}");
        else
            Console.WriteLine($"✗ {r.File.Name}: {r.Exception?.Message}");
    }
}

Meerdere bestanden tegelijk inchecken

public void BatchCheckIn(
    VDF.Vault.Currency.Connections.Connection conn,
    Dictionary bestandenEnPaden, // Vault-bestand → lokaal pad
    string commentaar)
{
    var settings = new CheckinFileSettings(conn) { Comment = commentaar };

    foreach (var kv in bestandenEnPaden)
        settings.AddFileToCheckin(kv.Key, new FilePathAbsolute(kv.Value), false);

    conn.FileManager.CheckinFiles(settings);
}

Veelgemaakte fouten

Bestand is al uitgecheckt — controleer altijd bestand.CheckedOut voor je een check-out probeert. Gooit anders een fout op de server.

Lokaal bestand bestaat niet meer bij check-in — als het lokale bestand verwijderd of hernoemd is, mislukt de check-in. Gebruik altijd het originele pad dat je bij check-out hebt gekregen.

keepCheckedOut = true vergeten — als je na de check-in de reservering wil behouden (om meteen door te werken), zet keepCheckedOut = true. Standaard wordt de reservering vrijgegeven.

Vault-bestandsobject verouderd — na een check-in verandert het versienummer. Herlaad het bestandsobject via GetLatestFilesByFolderId voor je het opnieuw gebruikt.

Samenvatting

Check-in/check-out automatiseren met de Vault .NET API draait om AcquireFilesSettings voor uitchecken en CheckinFileSettings voor inchecken. Voeg bestanden toe via AddFileToAcquire / AddFileToCheckin, verwerk de resultaten per bestand en behandel fouten per item in de batch. Zo bouw je robuuste, geautomatiseerde Vault-workflows.

Check-in and check-out are the core operations of Vault: they ensure files are modified in a controlled way and that version histories are maintained correctly. Via C# you can fully automate these operations — ideal for automated revision processes, batch updates and CI/CD integrations.

Concepts: Check-out, Check-in and Undo

Check-out reserves a file for you: others can still read it but cannot modify it. The file is downloaded to a local path. Check-in uploads the modified version back to Vault and creates a new version. Undo checkout releases the reservation without creating a new version.

Checking Out a File

var acqSettings = new AcquireFilesSettings(conn)
{
    DefaultAcquisitionOption = FileAcquisitionOptions.Checkout
};
acqSettings.AddFileToAcquire(vaultFile, FileAcquisitionOptions.Checkout);
var result = conn.FileManager.AcquireFiles(acqSettings);

foreach (var r in result.FileResults)
    Console.WriteLine(r.Status == FileAcquisitionStatus.Success
        ? $"✓ Checked out: {r.File.Name} → {r.LocalPath.FullPath}"
        : $"✗ Failed: {r.Exception?.Message}");

Checking Whether a File is Already Checked Out

if (vaultFile.CheckedOut)
    Console.WriteLine($"Checked out by: {vaultFile.CheckedOutBy?.DisplayName}");
else
    Console.WriteLine("Available for check-out.");

Checking In a File

var inSettings = new CheckinFileSettings(conn) { Comment = "Automated update rev B" };
inSettings.AddFileToCheckin(vaultFile, new FilePathAbsolute(localPath), false);
var result = conn.FileManager.CheckinFiles(inSettings);

foreach (var r in result.FileResults)
    Console.WriteLine(r.Status == CheckinStatus.Success
        ? $"✓ Checked in: {r.File.Name} (v{r.File.VerNum})"
        : $"✗ Failed: {r.Exception?.Message}");

Undo Checkout

conn.WebServiceManager.DocumentService.UndoCheckoutFile(vaultFile.MasterId, out _);

Batch Check-out / Check-in

// Batch check-out
var settings = new AcquireFilesSettings(conn) { DefaultAcquisitionOption = FileAcquisitionOptions.Checkout };
foreach (var f in files) settings.AddFileToAcquire(f, FileAcquisitionOptions.Checkout);
conn.FileManager.AcquireFiles(settings);

// Batch check-in
var ciSettings = new CheckinFileSettings(conn) { Comment = comment };
foreach (var kv in filesAndPaths) ciSettings.AddFileToCheckin(kv.Key, new FilePathAbsolute(kv.Value), false);
conn.FileManager.CheckinFiles(ciSettings);

Common Pitfalls

File already checked out — always check file.CheckedOut before attempting a check-out. Otherwise the server throws an error.

Local file missing at check-in — if the local file was deleted or renamed, check-in will fail. Always use the exact path returned by check-out.

Stale file object — after a check-in the version number changes. Reload the file object via GetLatestFilesByFolderId before reusing it.

Summary

Automating check-in/check-out with the Vault .NET API revolves around AcquireFilesSettings for checking out and CheckinFileSettings for checking in. Add files via the respective AddFile* methods, process results per file and handle errors per item in the batch.