Sefrone dotnet api packages

RequiredIfEnumValueAnalyzer Usage Example

This example demonstrates how to use the custom RequiredIfEnumValueAnalyzer in a .NET project to enforce the rule that a nullable property must be set to a non-null value when an enum array contains a specified value.

Setup

First, define the FeatureSet enum and create a class that uses the [RequiredIfEnumValue] attribute.

1. Define the FeatureSet Enum

public enum FeatureSet
{
    Basic,
    Premium,
    Advanced
}

2. Define the RequiredIfEnumValueAttribute

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class RequiredIfEnumValueAttribute : Attribute
{
    public string EnumPropertyName { get; }
    public string DependentPropertyName { get; }
    public int RequiredEnumValue { get; }

    public RequiredIfEnumValueAttribute(string enumPropertyName, string dependentPropertyName, int requiredEnumValue)
    {
        EnumPropertyName = enumPropertyName;
        DependentPropertyName = dependentPropertyName;
        RequiredEnumValue = requiredEnumValue;
    }
}

3. Apply the [RequiredIfEnumValue] Attribute to a Class

[RequiredIfEnumValue("Features", "Data", (int)FeatureSet.Premium)]
public partial class MyFeatureClass
{
    public FeatureSet[] Features { get; set; }
    public string? Data { get; set; }

    public MyFeatureClass(FeatureSet[] features, string? data)
    {
        Features = features;
        Data = data;
    }
}

Behavior of the Analyzer

The analyzer (RequiredIfEnumValueAnalyzer) will check the following:

• The MyFeatureClass has the [RequiredIfEnumValue] attribute applied.
• The Features property is an array of the FeatureSet enum type.
• The Data property is nullable.
• It will report a diagnostic if the Data property is nullable, indicating that it should not be null when the Features array contains the value FeatureSet.Premium.

Example Usage in a Project

Correct Usage (No Diagnostic)

public class Program
{
    public static void Main()
    {
        var validInstance = new MyFeatureClass(new[] { FeatureSet.Basic, FeatureSet.Premium }, "Non-null data");
        // No diagnostic error here because Data is set to a non-null value.
    }
}

Incorrect Usage (Triggers a Diagnostic)

public class Program
{
    public static void Main()
    {
        var invalidInstance = new MyFeatureClass(new[] { FeatureSet.Premium }, null);
        // This will trigger a diagnostic error from the analyzer because the Data property is null
        // and the Features array contains FeatureSet.Premium.
    }
}

Diagnostic Output

When the analyzer detects the issue in the "Incorrect Usage" example, it will produce a compile-time error similar to:

Error REQUIRED_NULL_CHECK: Property 'Data' should not be null when 'Features' contains the specified enum value.

The error message helps the developer understand that the Data property needs to be set to a non-null value when the Features array includes FeatureSet.Premium.

How to Add the Analyzer to the Project

1. Add the Analyzer Project to Your Solution:

   • Create a separate analyzer project for the RequiredIfEnumValueAnalyzer, or use an existing one.
   • Build the analyzer project to produce a .dll file for the analyzer.

2. Reference the Analyzer in the Target Project:

   • Add a reference to the analyzer .dll in the project where you want to apply the rule.
   • You can do this by using NuGet, directly referencing the .dll, or adding the analyzer as a project reference.

3. Enable the Analyzer in the Target Project:

   • When you build your project, the custom analyzer will automatically run and produce diagnostics based on your defined rules.

By following these steps, you can enforce compile-time validation rules based on custom conditions, providing immediate feedback to developers when they violate the rules defined by the [RequiredIfEnumValue] attribute.