SRO.CLSJVM.JAR

A multi-platform .NET library for reading, writing, and inspecting Java Archive (JAR) files. Built on top of System.IO.Compression, the library provides a JAR-aware API that handles the META-INF/MANIFEST.MF format, directory entry synthesis, and both file-system and in-memory archive construction — all without a JDK dependency.

Supported Frameworks

Installation

dotnet add package SRO.CLSJVM.JAR

Or via the NuGet Package Manager in Visual Studio — search for SRO.CLSJVM.JAR.

Namespace

using SRO.CLSJVM.JAR;

Quick Start

1 — Inspect an Existing JAR

Open a JAR, read its manifest, and iterate over all entries:

using SRO.CLSJVM.JAR;
using System.IO;

using (FileStream fs = File.OpenRead("myapp.jar"))
{
    JARProcessor processor = new JARProcessor();
    JarSummary summary = processor.JARExtractSummary(fs);

    // Read manifest attributes
    Console.WriteLine("Manifest-Version : " + summary.Manifest.ManifestVersion);
    Console.WriteLine("Created-By       : " + summary.Manifest.CreatedBy);
    Console.WriteLine("Main-Class       : " + summary.Manifest.MainClass);

    // Iterate entries
    foreach (JarEntrySummary entry in summary.Entries)
    {
        Console.WriteLine(entry.JarPath + "  (" + entry.Length + " bytes)");
    }
}

2 — Create a JAR from a Directory

Archive the contents of a directory (excluding the root directory name itself from the JAR paths):

using SRO.CLSJVM.JAR;
using System.IO;

Manifest manifest = new Manifest();
manifest.ManifestVersion = "1.0";
manifest.CreatedBy = "MyBuildTool";
manifest.MainClass = "com.example.Main";

JARProcessor processor = new JARProcessor();

using (FileStream jarOut = File.Create("output.jar"))
{
    processor.JARDirectoryContents(jarOut, new DirectoryInfo(@"C:\build\classes"), manifest);
}

3 — Create a JAR from a File List

When you need fine-grained control over which files are included:

using SRO.CLSJVM.JAR;
using System.Collections.Generic;
using System.IO;

DirectoryInfo root = new DirectoryInfo(@"C:\build\classes");
List<FileInfo> files = new List<FileInfo>
{
    new FileInfo(@"C:\build\classes\com\example\Main.class"),
    new FileInfo(@"C:\build\classes\com\example\Helper.class")
};

Manifest manifest = new Manifest();
manifest.ManifestVersion = "1.0";
manifest.MainClass = "com.example.Main";

JARProcessor processor = new JARProcessor();

using (FileStream jarOut = File.Create("filtered.jar"))
{
    processor.JARFileList(jarOut, root, files, manifest);
}

4 — Create a JAR from In-Memory Blobs

Build a JAR entirely from in-memory data without touching the file system:

using SRO.CLSJVM.JAR;
using System.Collections.Generic;
using System.IO;

// Text file blob
SimpleJarDataBlob textBlob = new SimpleJarDataBlob("Hello from SRO.CLSJVM.JAR");
textBlob.Path = "META-INF/notice.txt";

// Binary blob
SimpleJarDataBlob binaryBlob = new SimpleJarDataBlob(string.Empty);
binaryBlob.Data = File.ReadAllBytes("Main.class");
binaryBlob.Path = "com/example/Main.class";

List<IJarDataBlob> blobs = new List<IJarDataBlob> { textBlob, binaryBlob };

Manifest manifest = new Manifest();
manifest.ManifestVersion = "1.0";
manifest.MainClass = "com.example.Main";

JARProcessor processor = new JARProcessor();

using (MemoryStream ms = new MemoryStream())
{
    processor.JARBlobList(ms, blobs, manifest);
    File.WriteAllBytes("inmemory.jar", ms.ToArray());
}

5 — Read and Re-Save a JAR (Modify Manifest)

Load an existing JAR, update its manifest, and save it to a new stream:

using SRO.CLSJVM.JAR;
using System.IO;

using (FileStream inputFs = File.OpenRead("original.jar"))
using (JarFile jarFile = new JarFile(inputFs))
{
    // Modify manifest attributes
    jarFile.Manifest.MainClass = "com.example.NewMain";
    jarFile.Manifest.ImplementationVersion = "2.0";

    using (FileStream outputFs = File.Create("updated.jar"))
    {
        jarFile.Save(outputFs);
    }
}

API Reference

JARProcessor

The primary entry point for creating and reading JAR archives.

JarFile : IDisposable

Low-level wrapper around a ZipArchive opened in read or create mode. Use using to ensure timely disposal.

Manifest

Represents META-INF/MANIFEST.MF. All standard JAR manifest attributes are exposed as typed properties.

Write(ZipArchive) writes the META-INF/ directory entry and META-INF/MANIFEST.MF to an open archive. Call this before writing any other entries.

JarSummary

Returned by JARProcessor.JARExtractSummary. Provides read access to the manifest and all entries.

JarEntrySummary

Wraps a JarEntry and its parent JarFile to provide convenient data-access properties.

JarEntry

Represents a single file or directory entry inside a JAR.

IJarDataBlob / SimpleJarDataBlob

IJarDataBlob is an interface for supplying in-memory content to JARBlobList / JarFile.Save(Stream, List<IJarDataBlob>).

SimpleJarDataBlob is a convenience implementation. Its string constructor converts text to a UTF-8 byte array automatically.

Notes

• JAR files are ZIP archives with a required META-INF/MANIFEST.MF. This library always writes the manifest as the first entry to comply with the JAR specification.
• All JarFile operations that accept a Stream leave the stream open (leaveOpen: true); the caller controls stream lifetime.
• When opening a JAR that contains no explicit directory entries, JarFile.JarFiles automatically synthesizes JarEntry instances for each implied directory.
• Path normalization (JarEntry.CleanName) replaces Windows backslashes with forward slashes to keep archive paths portable.

Copyright

Copyright 2011-2026 Serengeti Research Organization. All rights reserved.