feat(mailmark-two-dimensional-barcode): Add 1 Aspose.BarCode .NET C# examples for Mailmark Two Dimensional Barcode — Aspose.BarCode for .NET 26.6.0

Author: agent-aspose-barcode-examples

mailmark-two-dimensional-barcode/cache-generated-barcode-images-in-memory-to-avoid-redundant-regeneration-for-identical-field-sets.cs

@@ -1,92 +1,99 @@
 // Title: In-Memory Barcode Image Caching Example
-// Description: Demonstrates how to cache generated barcode images in memory to avoid regenerating identical barcodes, improving performance.
-// Category-Description: This example belongs to the Aspose.BarCode generation category, illustrating the use of BarcodeGenerator, BaseEncodeType, and image handling classes. Developers often need to generate multiple barcodes with repeated data, and caching reduces redundant processing and resource usage. Ideal for batch processing, reporting, or any scenario where the same barcode may be requested multiple times.
+// Description: Demonstrates caching of generated barcode images in memory to avoid redundant regeneration for identical barcode specifications.
+// Category-Description: This example belongs to the Aspose.BarCode generation and caching category, showcasing how to use BarcodeGenerator, BaseEncodeType, and BarCodeImageFormat to create barcodes, store them in a dictionary, and reuse them. Developers often need to improve performance when generating many barcodes with repeated parameters, and this pattern provides a simple in‑process cache.
 // Prompt: Cache generated barcode images in memory to avoid redundant regeneration for identical field sets.
-// Tags: barcode, caching, memory, code128, qr, datamatrix, aspnet, aspose.barcode, image generation
+// Tags: barcode, caching, memory, code128, qr, datamatrix, generation, aspnet, aspose.barcode
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using Aspose.BarCode;
 using Aspose.BarCode.Generation;
-using Aspose.Drawing;
-using Aspose.Drawing.Imaging;
+using Aspose.BarCode.BarCodeRecognition;
 
 /// <summary>
-/// Demonstrates in‑memory caching of barcode images to prevent duplicate generation.
+/// Provides an in‑memory cache for barcode images generated with Aspose.BarCode.
 /// </summary>
-class Program
+class BarcodeCache
 {
+    // Internal dictionary that maps a unique key (encode type + text) to the generated PNG bytes.
+    private static readonly Dictionary<string, byte[]> _cache = new Dictionary<string, byte[]>();
+
     /// <summary>
-    /// Retrieves a barcode image from the cache or generates a new one if it does not exist.
+    /// Retrieves a cached barcode image or generates a new one if it does not exist.
     /// </summary>
-    /// <param name="encodeType">The barcode symbology to use.</param>
-    /// <param name="codeText">The text or data to encode.</param>
-    /// <param name="cache">Dictionary that stores previously generated images keyed by symbology and text.</param>
-    /// <returns>A <see cref="Bitmap"/> containing the generated barcode.</returns>
-    static Bitmap GetBarcodeImage(BaseEncodeType encodeType, string codeText, Dictionary<string, Bitmap> cache)
+    /// <param name="encodeType">The barcode symbology to use (e.g., Code128, QR).</param>
+    /// <param name="codeText">The text or data to encode in the barcode.</param>
+    /// <returns>A byte array containing the PNG image of the barcode.</returns>
+    public static byte[] GetOrCreate(BaseEncodeType encodeType, string codeText)
     {
-        // Build a unique cache key from the encode type and the text.
-        string key = $"{encodeType}:{codeText}";
+        // Build a unique cache key based on the encode type's full name, its enum value, and the text.
+        string key = $"{encodeType.GetType().FullName}:{encodeType}:{codeText}";
 
         // Return the cached image if it already exists.
-        if (cache.TryGetValue(key, out Bitmap cachedImage))
+        if (_cache.TryGetValue(key, out byte[] cachedData))
         {
-            Console.WriteLine($"Cache hit for key: {key}");
-            return cachedImage;
+            Console.WriteLine($"Cache hit for [{encodeType}] \"{codeText}\"");
+            return cachedData;
         }
 
-        // No cached image – generate a new barcode.
-        Console.WriteLine($"Generating barcode for key: {key}");
+        // Cache miss – generate a new barcode image.
+        Console.WriteLine($"Generating barcode for [{encodeType}] \"{codeText}\"");
         using (var generator = new BarcodeGenerator(encodeType, codeText))
         {
-            Bitmap image = generator.GenerateBarCodeImage();
-            cache[key] = image; // Store the newly generated image for future requests.
-            return image;
+            // Example: set a higher resolution for better image quality.
+            generator.Parameters.Resolution = 300;
+
+            using (var ms = new MemoryStream())
+            {
+                // Save the barcode to the memory stream in PNG format.
+                generator.Save(ms, BarCodeImageFormat.Png);
+                byte[] data = ms.ToArray();
+
+                // Store the generated image in the cache for future requests.
+                _cache[key] = data;
+                return data;
+            }
         }
     }
+}
 
+/// <summary>
+/// Demonstrates the use of <see cref="BarcodeCache"/> to generate and cache barcode images.
+/// </summary>
+class Program
+{
     /// <summary>
-    /// Entry point of the example. Generates several barcodes, some of which are duplicates,
-    /// to demonstrate caching. Saves each image to disk and disposes resources afterwards.
+    /// Entry point of the example. Generates a series of barcodes, some of which are duplicates,
+    /// to illustrate caching behavior, and writes the images to disk.
     /// </summary>
     static void Main()
     {
-        // In‑memory cache: maps a unique key to a barcode bitmap.
-        var barcodeCache = new Dictionary<string, Bitmap>();
-
-        // Define a set of barcode requests; duplicates are intentional to test caching.
-        var requests = new (BaseEncodeType type, string text)[]
+        // Define a list of barcode generation requests; duplicates test the cache.
+        var requests = new List<(BaseEncodeType type, string text)>
         {
-            (EncodeTypes.Code128, "123ABC"),
+            (EncodeTypes.Code128, "ABC123"),
             (EncodeTypes.QR, "https://example.com"),
-            (EncodeTypes.Code128, "123ABC"), // duplicate
+            (EncodeTypes.Code128, "ABC123"), // duplicate
             (EncodeTypes.DataMatrix, "DataMatrixSample"),
             (EncodeTypes.QR, "https://example.com") // duplicate
         };
 
-        // Process each request, retrieving from cache or generating as needed.
-        for (int i = 0; i < requests.Length; i++)
+        int index = 1;
+        foreach (var (type, text) in requests)
         {
-            var (type, text) = requests[i];
-            Bitmap barcodeImage = GetBarcodeImage(type, text, barcodeCache);
+            // Retrieve the barcode image, using the cache when possible.
+            byte[] imageData = BarcodeCache.GetOrCreate(type, text);
 
-            // Save each image with a unique filename for verification.
-            string fileName = $"barcode_{i + 1}.png";
-            using (var fileStream = System.IO.File.OpenWrite(fileName))
-            {
-                barcodeImage.Save(fileStream, ImageFormat.Png);
-            }
+            // Construct a file name that includes the request order and barcode type.
+            string fileName = $"barcode_{index}_{type}.png";
 
+            // Write the PNG bytes to disk.
+            File.WriteAllBytes(fileName, imageData);
             Console.WriteLine($"Saved barcode to {fileName}");
+            index++;
         }
 
-        // Dispose all cached bitmaps before exiting to free unmanaged resources.
-        foreach (var kvp in barcodeCache)
-        {
-            kvp.Value.Dispose();
-        }
-
-        Console.WriteLine("All barcodes processed. Press any key to exit.");
-        Console.ReadKey();
+        Console.WriteLine("Processing completed.");
     }
 }