Mmzkworks.StorageSharp 0.1.2

StorageSharp

StorageSharp is a flexible storage system for handling single binary files and folder file collections. By combining them, you can flexibly handle file systems, caching, and folder file collections (called Packs).

Read first

• overview

Features

Storage Features (IStorage)

• FileStorage: File system-based storage
• MemoryStorage: Memory-based storage
• CachedStorage: Storage with caching functionality
• StorageRouter: Routes operations to different storages based on key patterns

Archive Features (IPacks)

• ZippedPacks: Archive implementation that manages packages in ZIP format

Basic Usage

Using Storage

// File storage
var fileStorage = new FileStorage("StorageDirectory");

// Writing data
await fileStorage.WriteAsync("key.txt", data);

// Reading data
var data = await fileStorage.ReadAsync("key.txt");

Using Cached Storage

var storage = new CachedStorage(
    cache: new MemoryStorage(), // Cache storage
    origin: new FileStorage("OriginStorage") // Origin storage
);

Using ZIP Packages

var packages = new ZippedPacks(
    new ZippedPacks.Settings("Tmp/Packs/"),
    storage
);

// Add directory to archive
var archiveScheme = await packages.Add(directoryPath);

// Load archive
var loadedPath = await packages.Load(archiveScheme);

// Use files
// ...

// Unload archive
await packages.Unload(archiveScheme);

// Delete archive
await packages.Delete(archiveScheme);

// List all archives
var list = await packages.ListAll();

Setup

Using as a Library

# Add reference to project
dotnet add reference path/to/StorageSharp.csproj

Using as NuGet Package (in the future)

dotnet add package StorageSharp

Development Environment Setup

# Clone repository
git clone <repository-url>
cd storageSharp

# Restore dependencies
dotnet restore

# Build
dotnet build

# Run tests
dotnet test

Running Sample Programs

# Run sample project
cd StorageSharp.Samples
dotnet run

Project Structure

storageSharp/
├── StorageSharp/                    # Main library
│   ├── Storages/
│   │   ├── IStorage.cs              # Storage interface
│   │   ├── FileStorage.cs           # File storage implementation
│   │   ├── MemoryStorage.cs         # Memory storage implementation
│   │   ├── CachedStorage.cs         # Cached storage implementation
│   │   └── StorageRouter.cs         # Storage routing implementation
│   ├── Packs/
│   │   ├── IPacks.cs                # Archive interface
│   │   └── ZippedPacks.cs           # ZIP package implementation
│   └── StorageSharp.csproj          # Library project
├── StorageSharp.Samples/            # Sample project
│   ├── Program.cs                   # Sample program
│   ├── StorageSharp.Samples.csproj  # Sample project
│   └── README.md                    # Sample README
├── StorageSharp.Tests/              # Test project
│   ├── UnitTests/                   # Unit tests
│   └── IntegrationTests/            # Integration tests
├── storageSharp.sln                 # Solution file
└── README.md                        # This file

Usage Examples

Basic Storage Operations

// Using file storage
var fileStorage = new FileStorage("ExampleStorage");
var testData = System.Text.Encoding.UTF8.GetBytes("Hello, StorageSharp!");
await fileStorage.WriteAsync("test.txt", testData);

// Using memory storage
var memoryStorage = new MemoryStorage();
await memoryStorage.WriteAsync("memory-test.txt", testData);

Using Cached Storage

var cache = new MemoryStorage();
var origin = new FileStorage("OriginStorage");
var cachedStorage = new CachedStorage(cache, origin);

// Writing data
var data = System.Text.Encoding.UTF8.GetBytes("Cached data example");
await cachedStorage.WriteAsync("cached-file.txt", data);

// Reading data (cache hit/miss is automatically managed)
var readData = await cachedStorage.ReadAsync("cached-file.txt");

Using ZIP Packages

var storage = new FileStorage("ZippedPacks");
var packages = new ZippedPacks(
    new ZippedPacks.Settings("Tmp/Packs/"),
    storage
);

// Add directory to archive
var archiveScheme = await packages.Add("MyDirectory");

// Load and use archive
var loadedPath = await packages.Load(archiveScheme);
// Use files...
await packages.Unload(archiveScheme);

// Delete archive
await packages.Delete(archiveScheme);

Using Storage Router

var storageRouter = new StorageRouter(new[]
{
    // Route HTTP/HTTPS keys to specific storage
    new StorageRouter.Branch(
        key => key.StartsWith("http://") || key.StartsWith("https://"),
        new FileStorage("HttpStorage")),
    
    // Route file:// keys with prefix removal
    new StorageRouter.Branch(
        key => key.StartsWith("file://"),
        key => key.Substring("file://".Length), // Key formatter
        new FileStorage("LocalStorage"))
},
new FileStorage("DefaultStorage")); // Default storage

// Write to appropriate storage based on key
await storageRouter.WriteAsync("http://example.com/data.txt", data);
await storageRouter.WriteAsync("file://local/data.txt", data); // Routed to LocalStorage with key "local/data.txt"
await storageRouter.WriteAsync("regular-file.txt", data); // Routed to DefaultStorage

Notes

• Temporary files are automatically managed, but please consider appropriate cleanup when handling large amounts of data
• Use the caching functionality with attention to memory usage
• The ZIP package functionality uses the SharpZipLib library

About AI Generation

• This document has been machine translated.
• This repo contains generated code by ChatGPT and Cursor.

License

This project is published under the MIT License.