ExistingFile and ExistingPath attribute

[nolme]

Hello,
I'm looking for a way to change some old code written with Postsharp. I have some contracts to validate inputs :
void MyFunction([ExistingPath] string destinationFolder, [ExistingFile] string fullSourceFileName)
What's the best way in 2026 (in a few hours) ?
Thanks,
Vincent

[gfraiteur]

Implementing [ExistingPath] and [ExistingFile] in Metalama requires understanding how these contracts interact. The key challenge is that [ExistingFile] typically validates a file path relative to a directory marked with [ExistingPath]. But normal contracts in Metalama are self-contained - they cannot reference each other.

This can be implemented using a three-aspect pattern:

1. [ExistingPath] - A marker attribute for directory parameters
2. [ExistingFile] - A marker attribute for file parameters
3. PathValidationAspect - The implementation aspect that performs the actual validation

Here's an implementation (not compiled or tested):

using Metalama.Framework.Aspects;
using Metalama.Framework.Code;
using Metalama.Framework.Eligibility;
using System;
using System.IO;
using System.Linq;

// Marker attribute for directory paths
public class ExistingPathAttribute : Attribute, IAspect<IParameter>
{
    public void BuildAspect(IAspectBuilder<IParameter> builder)
    {
        // Request the implementation aspect on the method
        builder.With(builder.Target.DeclaringMember).RequireAspect<PathValidationAspect>();
    }

    public void BuildEligibility(IEligibilityBuilder<IParameter> builder)
    {
        builder.MustSatisfy(p => p.Type.Is(typeof(string)),
            p => $"Parameter must be of type string");
    }
}

// Marker attribute for file paths
public class ExistingFileAttribute : Attribute, IAspect<IParameter>
{
    public void BuildAspect(IAspectBuilder<IParameter> builder)
    {
        // Request the implementation aspect on the method
        builder.With(builder.Target.DeclaringMember).RequireAspect<PathValidationAspect>();
    }

    public void BuildEligibility(IEligibilityBuilder<IParameter> builder)
    {
        builder.MustSatisfy(p => p.Type.Is(typeof(string)),
            p => $"Parameter must be of type string");
    }
}

// Implementation aspect
[AspectOrder(AspectOrderDirection.CompileTime, typeof(ExistingPathAttribute), typeof(ExistingFileAttribute), typeof(PathValidationAspect))]
public class PathValidationAspect : OverrideMethodAspect
{
    public override dynamic? OverrideMethod()
    {
        // Find the base path parameter (0 or 1 expected) - compile-time
        var basePathParam = meta.Target.Parameters
            .Where(p => p.Enhancements().HasAspect<ExistingPathAttribute>())
            .SingleOrDefault();

        // Get the value at run-time (compile-time if to check existence)
        string? basePath = null;
        if (basePathParam != null)
        {
            basePath = (string?)basePathParam.Value;

            // Validate the base path
            if (basePath != null && !Directory.Exists(basePath))
            {
                throw new DirectoryNotFoundException($"Directory does not exist: {basePath}");
            }
        }

        // Validate file parameters
        foreach (var p in meta.Target.Parameters.Where(p => p.Enhancements().HasAspect<ExistingFileAttribute>()))
        {
            var filePath = (string?)p.Value;
            if (filePath != null)
            {
                var fullPath = basePath != null ? Path.Combine(basePath, filePath) : filePath;
                if (!File.Exists(fullPath))
                {
                    throw new FileNotFoundException($"File does not exist: {fullPath}", fullPath);
                }
            }
        }

        return meta.Proceed();
    }
}

Usage:

public class FileProcessor
{
    public void ProcessFile([ExistingPath] string directory, [ExistingFile] string fileName)
    {
        // directory is validated to exist
        // fileName is validated relative to directory
        var fullPath = Path.Combine(directory, fileName);
        // ...
    }

    public void ProcessAbsoluteFile([ExistingFile] string absolutePath)
    {
        // absolutePath is validated as an absolute path (no ExistingPath present)
        // ...
    }
}

Key points:

• [ExistingPath] and [ExistingFile] are marker attributes that trigger PathValidationAspect via RequireAspect
• The [AspectOrder] attribute with AspectOrderDirection.CompileTime ensures the marker aspects run before the implementation aspect, so HasAspect works correctly
• The compile-time LINQ finds parameters with the marker attributes; the run-time code accesses their values
• File paths are resolved relative to the base path when [ExistingPath] is present
• Uses DirectoryNotFoundException and FileNotFoundException for proper exception semantics

[nolme]

Hello, I made a full project with both Fody (used before and tests OK) and MetaLama :
https://www.swisstransfer.com/d/7a8a3f52-b1c8-4ede-8509-0303e41b4d81

There are 2 types of contracts :

• File & Folders
• IP address, MAC address

The AspectOrder attribute for PathValidationAspect do not compile (CS0592)
I can mark as comment to compile the library but I'm unsure how to adjust the code for unit tests.

Do you have some advices ?
Thanks.

[gfraiteur]

The correct syntax for aspect order is this:

[assembly: AspectOrder(AspectOrderDirection.CompileTime, typeof(ExistingPathAttribute), typeof(ExistingFileAttribute), typeof(PathValidationAspect))]

You're getting the community-level support where answers are AI-generated and verified by the naked eye, but not compiled or tested. Let me know if you are a commercial customer.

[nolme]

I'm the only user in the company (so the only developer).
The correct syntax compile but is ignored because of CS0657