/// <summary>
    /// Model base interface that defines a IsDirty property.
    /// </summary>
    public interface IModelBase
    {
        /// <summary>
        /// Gets a value indicating whether the model is dirty or not.
        /// The model is going to be dirty as soon as one of its property is set.
        /// </summary>
        bool IsDirty { get; }
    }

    /// <summary>
    /// A model definition example with two properties MyFirstProperty and MySecondProperty.
    /// </summary>
    /// <remarks>Setting on of the two properties will set the IsDirty flag to true.</remarks>
    public interface IMyModel : IModelBase
    {
        /// <summary>
        /// Gets or sets MyFirstProperty that is the first property of the model example.
        /// </summary>
        /// <remarks>If the property is set, the IsDirty flag will be true.</remarks>
        string MyFirstProperty { get; set; }

        /// <summary>
        /// Gets or sets MySecondProperty that is the second property of the model example.
        /// </summary>
        double MySecondProperty { get; set; }
    }

    /// <summary>
    /// Model pattern interface used by the Model pattern implementation.
    /// </summary>
    public interface IModelPattern : IModelBase
    {
        /// <summary>
        /// Gets or sets property declaration pattern.
        /// </summary>
        object PropertyPattern { get; set; }
    }

    /// <summary>
    /// Model pattern implementation that should be generated for the previous pattern model interface.
    /// </summary>
    public class ModelPattern : IModelPattern
    {
        /// <summary>
        /// The IsDirty implementation.
        /// </summary>
        public bool IsDirty
        { get; private set; }

        /// <summary>
        /// The field used be the property implementation.
        /// </summary>
        private object propertyPattern;

        /// <summary>
        /// The actual property implementation that is updating IsDirty on set.
        /// </summary>
        public object PropertyPattern
        {
            get
            {
                return this.propertyPattern;
            }

            set
            {
                this.propertyPattern = null;
                this.IsDirty = true;
            }
        }
    }

    /// <summary>
    /// Here we need two attributes:
    /// * The Pattern attribute tells the generator how it can find the interfaces from witch it must generate the
    ///  implementation based on the implementation pattern.
    ///  Here we use typeof(InterfaceBasedOnSelector<IModelBase>) to tell the generator to generate code for all
    ///  interfaces extending the IModelBase interface.
    ///  
    /// * The Repeat attribute means that the generator must repeat the pattern model implementation on each
    ///  interfaces targeted by the Pattern attribute.
    ///  The Pattern argument given in the Repeat attribute allows the generator to make the link with the interface
    ///  pattern model.
    ///  The argument Prefix given in the Repeat attribute allows the generator to make text replacement from the
    ///  pattern model implementation to the generated code. Here it will replace all IModelPattern text by the real
    ///  name of the targeted interface.
    ///  
    /// </summary>
    [Pattern<InterfaceBasedOnSelector<IModelBase>>]
    [Repeat(Pattern = nameof(IModelPattern), Prefix = "I")]
    public class ModelPattern : IModelPattern
    {
        /// <summary>
        /// We don't need any attribute since we just want the generator to copy the IsDirty property.
        /// </summary>
        public bool IsDirty
        { get; private set; }

        /// <summary>
        /// Here we need the Repeat attribute to tell the generator that we want to repeat the field for each
        /// Property defined in the targeted interface. The Property are selected matching the one in the pattern
        /// model interface (In this case PropertyPattern in IModelPattern).
        /// </summary>
        [Repeat(Pattern = nameof(IModelPattern.PropertyPattern))]
        private object propertyPattern;

        /// <summary>
        /// Here again we need the Repeat attribute to tell the generator that we want to repeat the Property for each
        /// Property defined in the targeted interface.
        /// </summary>
        [Repeat(Pattern = nameof(IModelPattern.PropertyPattern))]
        public object PropertyPattern
        {
            get
            {
                return this.propertyPattern;
            }

            set
            {
                this.propertyPattern = null;
                this.IsDirty = true;
            }
        }
    }

    /// <summary>
    /// Model implementation.
    /// </summary>
    public class MyModel : IMyModel
    {
        public bool IsDirty
        { get; private set; }

        private string myFirstProperty;
        private double mySecondProperty;

        public string MyFirstProperty
        {
            get
            {
                return this.myFirstProperty;
            }

            set
            {
                this.myFirstProperty = value;
                this.IsDirty = true;
            }
        }

        public double MySecondProperty
        {
            get
            {
                return this.mySecondProperty;
            }

            set
            {
                this.mySecondProperty = value;
                this.IsDirty = true;
            }
        }
    }

using SoloX.GeneratorTools.Core.CSharp;

void Setup(IServiceCollection serviceCollection)
{
    serviceCollection.AddCSharpToolsGenerator();
}

    /// <summary>
    /// The model generator.
    /// </summary>
    public class ModelGenerator
    {
        private ICSharpWorkspaceFactory workspaceFactory;

        /// <summary>
        /// Initializes a new instance of the <see cref="ModelGenerator"/> class.
        /// </summary>
        /// <param name="workspaceFactory">The workspace to use to load the project data.</param>
        public ModelGenerator(ICSharpWorkspaceFactory workspaceFactory)
        {
            this.workspaceFactory = workspaceFactory;
        }
    }

    // Create a Workspace
    var workspace = this.workspaceFactory.CreateWorkspace();

    // First we need to register the project.
    workspace.RegisterProject(projectFile);

    // Register the pattern interface.
    var patternInterfaceDeclaration = this.workspace.RegisterFile("./Patterns/Itf/IModelPattern.cs")
        .Declarations.Single() as IInterfaceDeclaration;

    // Register the pattern implementation.
    var patternImplementationDeclaration = this.workspace.RegisterFile("./Patterns/Impl/ModelPattern.cs")
        .Declarations.Single() as IGenericDeclaration<SyntaxNode>;

    // Load the project and its project dependencies. (Note that we load the sources and the binary assembly
    // dependencies. Both are taken into account)
    var resolver = this.workspace.DeepLoad();

    // Create the `AutomatedGenerator` with a file generator, the locator and the pattern interface/class.
    var generator = new AutomatedGenerator(
        // Tells that we want to write the implementation in a file.
        new FileGenerator(".generated.cs"),
        // Tells that we want the implementation class to be located at the same location than its model interface.
        new RelativeLocator(projectFolder, projectNameSpace),
        // The target project type resolver. (previously created)
        resolver,
        // The pattern type.
        typeof(ModelPattern),
        // A Logger forwarding logs to the given `ILogger`.
        new GeneratorLogger<ModelGeneratorExample>(this.logger));

    // Generate the implementations from the given files.
    generator.Generate(project.Files);