C# (.NET) で PDF とドキュメントから注釈を削除する方法

Install-Package GroupDocs.Annotation -Version 25.4.0

dotnet add package GroupDocs.Annotation --version 25.4.0

using System;
using GroupDocs.Annotation;

class Program
{
    static void Main(string[] args)
    {
        // Set up your license (skip this during trial period)
        License lic = new License();
        lic.SetLicense("path-to-your-license.lic");
        
        Console.WriteLine("GroupDocs.Annotation is ready to rock!");
    }
}

string inputFilePath = "YOUR_DOCUMENT_DIRECTORY/ANNOTATED.pdf"; // Replace with your actual path

using (Annotator annotator = new Annotator(inputFilePath))
{
    // All the magic happens inside this using block
    // The using statement ensures proper resource cleanup
}

var annotations = annotator.Get();
Console.WriteLine($"Found {annotations.Count} annotations in the document");

// Let's see what we're working with
foreach (var annotation in annotations)
{
    Console.WriteLine($"Type: {annotation.Type}, Page: {annotation.PageNumber}");
}

// Remove the first annotation (basic example)
if (annotations.Count > 0)
{
    Console.WriteLine($"Removing annotation of type: {annotations[0].Type}");
    annotator.Remove(annotations[0]);
}

string outputDirectory = "YOUR_OUTPUT_DIRECTORY"; // Your output folder
string outputPath = Path.Combine(outputDirectory, "cleaned_" + Path.GetFileName(inputFilePath));

// Save the document with annotations removed
annotator.Save(outputPath);
Console.WriteLine($"Clean document saved to: {outputPath}");

string inputFilePath = "YOUR_DOCUMENT_DIRECTORY/ANNOTATED.pdf";
string outputPath = "YOUR_OUTPUT_DIRECTORY/completely_clean.pdf";

using (Annotator annotator = new Annotator(inputFilePath))
{
    var annotations = annotator.Get();
    
    if (annotations.Count > 0)
    {
        Console.WriteLine($"Removing all {annotations.Count} annotations...");
        
        // Remove all annotations in one go
        foreach (var annotation in annotations)
        {
            annotator.Remove(annotation);
        }
        
        annotator.Save(outputPath);
        Console.WriteLine("All annotations removed successfully!");
    }
    else
    {
        Console.WriteLine("No annotations found in the document.");
    }
}

// DON'T do this
var annotator1 = new Annotator(filePath);
var annotator2 = new Annotator(filePath); // This might fail

// DO this instead
using (var annotator = new Annotator(filePath))
{
    // All your work here
} // Automatically disposed and file is released

var annotations = annotator.Get();
foreach (var annotation in annotations)
{
    Console.WriteLine($"ID: {annotation.Id}, Type: {annotation.Type}");
    Console.WriteLine($"Page: {annotation.PageNumber}, Author: {annotation.User}");
}

// For very large documents, consider processing page by page
using (var annotator = new Annotator(largePdfPath))
{
    var annotations = annotator.Get();
    
    // Process in chunks of 50 annotations
    for (int i = 0; i < annotations.Count; i += 50)
    {
        var batch = annotations.Skip(i).Take(50);
        foreach (var annotation in batch)
        {
            annotator.Remove(annotation);
        }
        
        // Optional: Force garbage collection for very large documents
        GC.Collect();
    }
    
    annotator.Save(outputPath);
}

using (var annotator = new Annotator(inputPath))
{
    var annotations = annotator.Get();
    var toRemove = annotations.Where(a => ShouldRemoveAnnotation(a)).ToList();
    
    Console.WriteLine($"Removing {toRemove.Count} out of {annotations.Count} annotations");
    
    // Remove all at once instead of individual Remove() calls
    foreach (var annotation in toRemove)
    {
        annotator.Remove(annotation);
    }
    
    annotator.Save(outputPath);
}

bool ShouldRemoveAnnotation(AnnotationBase annotation)
{
    // Your custom logic here
    return annotation.Type == AnnotationType.Area || 
           annotation.CreatedOn < DateTime.Now.AddMonths(-6);
}

public class DocumentProcessor
{
    private static readonly License _license = new License();
    
    static DocumentProcessor()
    {
        _license.SetLicense("your-license-path.lic");
    }
    
    public void ProcessDocument(string filePath)
    {
        // License is already set, just use the annotator
        using (var annotator = new Annotator(filePath))
        {
            // Your processing logic
        }
    }
}

public void PrepareClientDocument(string internalContractPath, string clientVersion)
{
    using (var annotator = new Annotator(internalContractPath))
    {
        var annotations = annotator.Get();
        
        // Remove only internal comments, keep client-facing highlights
        var internalComments = annotations.Where(a => 
            a.Type == AnnotationType.TextField && 
            a.User?.Contains("@lawfirm.com") == true);
            
        foreach (var comment in internalComments)
        {
            annotator.Remove(comment);
        }
        
        annotator.Save(clientVersion);
    }
}

public void FinalizeReport(string draftPath, string finalPath)
{
    using (var annotator = new Annotator(draftPath))
    {
        var annotations = annotator.Get();
        
        // Remove all review comments but keep approved highlights
        var reviewComments = annotations.Where(a => 
            a.Type == AnnotationType.TextField ||
            a.Type == AnnotationType.Point);
            
        Console.WriteLine($"Cleaning {reviewComments.Count()} review annotations...");
        
        foreach (var annotation in reviewComments)
        {
            annotator.Remove(annotation);
        }
        
        annotator.Save(finalPath);
        Console.WriteLine($"Final report ready: {finalPath}");
    }
}

public bool RemoveAnnotationsSafely(string inputPath, string outputPath)
{
    try
    {
        using (var annotator = new Annotator(inputPath))
        {
            var annotations = annotator.Get();
            
            if (annotations.Count == 0)
            {
                Console.WriteLine("No annotations to remove.");
                // Still copy the file to output location
                File.Copy(inputPath, outputPath, overwrite: true);
                return true;
            }
            
            foreach (var annotation in annotations)
            {
                try
                {
                    annotator.Remove(annotation);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Failed to remove annotation {annotation.Id}: {ex.Message}");
                    // Continue with other annotations
                }
            }
            
            annotator.Save(outputPath);
            Console.WriteLine($"Successfully processed document: {Path.GetFileName(outputPath)}");
            return true;
        }
    }
    catch (FileNotFoundException)
    {
        Console.WriteLine($"Input file not found: {inputPath}");
        return false;
    }
    catch (UnauthorizedAccessException)
    {
        Console.WriteLine($"Access denied. Check file permissions for: {inputPath}");
        return false;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Unexpected error: {ex.Message}");
        return false;
    }
}

public void TestAnnotationRemoval()
{
    string testFile = "test-document-with-annotations.pdf";
    string outputFile = "test-output.pdf";
    
    // Before removal
    using (var annotator = new Annotator(testFile))
    {
        var beforeCount = annotator.Get().Count;
        Console.WriteLine($"Annotations before removal: {beforeCount}");
    }
    
    // Remove annotations
    bool success = RemoveAnnotationsSafely(testFile, outputFile);
    
    if (success)
    {
        // After removal
        using (var annotator = new Annotator(outputFile))
        {
            var afterCount = annotator.Get().Count;
            Console.WriteLine($"Annotations after removal: {afterCount}");
            Console.WriteLine($"Removed: {beforeCount - afterCount} annotations");
        }
    }
}