Introducing members

In previous articles, you learned how to override the implementation of existing type members. This article will teach you how to add new members to an existing type.

Currently, you can add the following types of members:

• Methods
• Fields
• Properties
• Events
• Operators
• Conversions

However, the following types of members are not yet supported:

• Constructors

Introducing members declaratively

The simplest way to introduce a member from an aspect is to implement this member in the aspect and annotate it with the [Introduce] custom attribute. This custom attribute has the following notable properties:

Example: ToString

The following example demonstrates an aspect that implements the ToString method. It will return a string that includes the object type and a reasonably unique identifier for that object.

Please note that this aspect will replace any hand-written implementation of ToString, which is not desirable. Currently, this can only be avoided by introducing the method programmatically and conditionally.

1using Metalama.Framework.Aspects;
2
3namespace Doc.IntroduceMethod
4{
5    internal class ToStringAttribute : TypeAspect
6    {
7        [Introduce]
8        private int _id = IdGenerator.GetId();
9
10        [Introduce( WhenExists = OverrideStrategy.Override )]
11        public override string ToString() => $"{this.GetType().Name} Id={this._id}";
12    }
13}

1using System;
2using System.Threading;
3
4namespace Doc.IntroduceMethod
5{
6    [ToString]
7    internal class MyClass { }
8
9    internal static class IdGenerator








10    {
11        private static int _nextId;
12
13        public static int GetId() => Interlocked.Increment( ref _nextId );
14    }
15
16    internal class Program
17    {
18        private static void Main()
19        {
20            Console.WriteLine( new MyClass().ToString() );
21            Console.WriteLine( new MyClass().ToString() );
22            Console.WriteLine( new MyClass().ToString() );
23        }
24    }
25}

1using System;
2using System.Threading;
3
4namespace Doc.IntroduceMethod
5{
6    [ToString]
7    internal class MyClass
8    {
9        private int _id = IdGenerator.GetId();
10
11        public override string ToString()
12        {
13            return $"{GetType().Name} Id={_id}";
14        }
15    }
16
17    internal static class IdGenerator
18    {
19        private static int _nextId;
20
21        public static int GetId() => Interlocked.Increment(ref _nextId);
22    }
23
24    internal class Program
25    {
26        private static void Main()
27        {
28            Console.WriteLine(new MyClass().ToString());
29            Console.WriteLine(new MyClass().ToString());
30            Console.WriteLine(new MyClass().ToString());
31        }
32    }
33}

MyClass Id=1
MyClass Id=2
MyClass Id=3

Introducing members programmatically

The main limitation of declarative introductions is that the name, type, and signature of the introduced member must be known upfront. They cannot depend on the aspect target. The programmatic approach allows your aspect to fully customize the declaration based on the target code.

There are two steps to introduce a member programmatically:

Step 1. Implement the template

Implement the template in your aspect class and annotate it with the [Template] custom attribute. The template does not need to have the final signature.

Step 2. Invoke IAdviceFactory.Introduce*

In your implementation of the BuildAspect method, call one of the following methods and store the return value in a variable:

• IntroduceMethod returning an IMethodBuilder
• IntroduceProperty returning an IPropertyBuilder
• IntroduceEvent returning an IEventBuilder
• IntroduceField returning an IFieldBuilder

A call to one of these methods creates a member by default that has the same characteristics as the template (name, signature, etc.), taking into account the properties of the [Template] custom attribute.

To modify the name and signature of the introduced declaration, use the buildMethod, buildProperty, buildEvent, or buildField parameter of the Introduce* method.

Example: Update method

The following aspect introduces an Update method that assigns all writable fields in the target type. The method signature is dynamic: there is one parameter per writable field or property.

1using Metalama.Framework.Aspects;
2using Metalama.Framework.Code;
3using System.Linq;
4
5namespace Doc.UpdateMethod
6{
7    internal class UpdateMethodAttribute : TypeAspect
8    {
9        public override void BuildAspect( IAspectBuilder<INamedType> builder )
10        {
11            builder.Advice.IntroduceMethod(
12                builder.Target,
13                nameof(this.Update),
14                buildMethod:
15                m =>
16                {
17                    var fieldsAndProperties =
18                        builder.Target.FieldsAndProperties
19                            .Where( f => !f.IsImplicitlyDeclared && f.Writeability == Writeability.All );
20
21                    foreach ( var field in fieldsAndProperties )
22                    {
23                        m.AddParameter( field.Name, field.Type );
24                    }
25                } );
26        }
27
28        [Template]
29        public void Update()
30        {
31            var index = meta.CompileTime( 0 );
32
33            foreach ( var parameter in meta.Target.Parameters )
34            {
35                var field = meta.Target.Type.FieldsAndProperties.OfName( parameter.Name ).Single();
36
37                field.Value = meta.Target.Parameters[index].Value;
38                index++;
39            }
40        }
41    }
42}

1using System;
2
3namespace Doc.UpdateMethod
4{
5    [UpdateMethod]
6    internal class CityHunter
7    {
8        private int _x;
9
10        public string? Y { get; private set; }
11
12        public DateTime Z { get; }
13    }
14






15    internal class Program
16    {
17        private static void Main()
18        {
19            CityHunter ch = new();
            Error CS1061: 'CityHunter' does not contain a definition for 'Update' and no accessible extension method 'Update' accepting a first argument of type 'CityHunter' could be found (are you missing a using directive or an assembly reference?)

20            ch.Update(0, "1");
21        }
22    }
23}

1using System;
2
3namespace Doc.UpdateMethod
4{
5    [UpdateMethod]
6    internal class CityHunter
7    {
8        private int _x;
9
10        public string? Y { get; private set; }
11
12        public DateTime Z { get; }
13
14        public void Update(int _x, string? Y)
15        {
16            this._x = _x;
17            this.Y = Y;
18        }
19    }
20
21    internal class Program
22    {
23        private static void Main()
24        {
25            CityHunter ch = new();
26            ch.Update(0, "1");
27        }
28    }
29}

Overriding existing implementations

Specifying the override strategy

When you want to introduce a member to a type, it may happen that the same member is already defined in this type or in a parent type. The default strategy of the aspect framework in this case is simply to report an error and fail the build. You can change this behavior by setting the OverrideStrategy for this advice:

• For declarative advice, set the WhenExists property of the custom attribute
• For programmatic advice, set the whenExists optional parameter of the advice factory method

Accessing the overridden declaration

Most of the time, when you override a method, you will want to invoke the base implementation. The same applies to properties and events. In plain C#, when you override a base-class member in a derived class, you call the member with the base prefix. A similar approach exists in Metalama.

• To invoke the base method or accessor with exactly the same arguments, call meta.Proceed
• To invoke the base method with different arguments, use meta.Target.Method.Invoke
• To call the base property getter or setter, use meta.Property.Value
• To access the base event, use meta.Event.Add, meta.Event.Remove or meta.Event.Raise

Referencing introduced members in a template

When you introduce a member to a type, you will often want to access it from templates. There are three ways to do it:

Option 1. Access the aspect template member

1using Metalama.Framework.Aspects;
2using System.ComponentModel;
3
4namespace Doc.IntroducePropertyChanged1
5{
6    internal class IntroducePropertyChangedAspect : TypeAspect
7    {
8        [Introduce]
9        public event PropertyChangedEventHandler? PropertyChanged;
10
11        [Introduce]
12        protected virtual void OnPropertyChanged( string propertyName )
13        {
14            this.PropertyChanged?.Invoke( meta.This, new PropertyChangedEventArgs( propertyName ) );
15        }
16    }
17}

1namespace Doc.IntroducePropertyChanged1
2{


3    [IntroducePropertyChangedAspect]
4    internal class Foo { }
5}

1using System.ComponentModel;
2
3namespace Doc.IntroducePropertyChanged1
4{
5    [IntroducePropertyChangedAspect]
6    internal class Foo
7    {
8        protected virtual void OnPropertyChanged(string propertyName)
9        {
10            this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
11        }
12
13        public event PropertyChangedEventHandler? PropertyChanged;
14    }
15}

Option 2. Use meta.This and write dynamic code

1using Metalama.Framework.Aspects;
2using System.ComponentModel;
3
4namespace Doc.IntroducePropertyChanged3
5{
6    internal class IntroducePropertyChangedAspect : TypeAspect
7    {
8        [Introduce]
9        public event PropertyChangedEventHandler? PropertyChanged;
10
11        [Introduce]
12        protected virtual void OnPropertyChanged( string propertyName )
13        {
14            meta.This.PropertyChanged?.Invoke( meta.This, new PropertyChangedEventArgs( propertyName ) );
15        }
16    }
17}

1namespace Doc.IntroducePropertyChanged3
2{


3    [IntroducePropertyChangedAspect]
4    internal class Foo { }
5}

1using System.ComponentModel;
2
3namespace Doc.IntroducePropertyChanged3
4{
5    [IntroducePropertyChangedAspect]
6    internal class Foo
7    {
8        protected virtual void OnPropertyChanged(string propertyName)
9        {
10            this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
11        }
12
13        public event PropertyChangedEventHandler? PropertyChanged;
14    }
15}

Option 3. Use the invoker of the builder object

If neither of the approaches above offer you the required flexibility (typically because the name of the introduced member is dynamic), use the invokers exposed on the builder object returned from the advice factory method.

For more details, see Metalama.Framework.Code.Invokers.

1using Metalama.Framework.Aspects;
2using Metalama.Framework.Code;
3using System.ComponentModel;
4
5namespace Doc.IntroducePropertyChanged2
6{
7    internal class IntroducePropertyChangedAspect : TypeAspect
8    {
9        public override void BuildAspect( IAspectBuilder<INamedType> builder )
10        {
11            var propertyChangedEvent = builder.Advice.IntroduceEvent(
12                    builder.Target,
13                    nameof(this.PropertyChanged) )
14                .Declaration;
15
16            builder.Advice.IntroduceMethod(
17                builder.Target,
18                nameof(this.OnPropertyChanged),
19                args: new { theEvent = propertyChangedEvent } );
20        }
21
22        [Template]
23        public event PropertyChangedEventHandler? PropertyChanged;
24
25        [Template]
26        protected virtual void OnPropertyChanged( string propertyName, IEvent theEvent )
27        {
28            theEvent.Raise( meta.This, new PropertyChangedEventArgs( propertyName ) );
29        }
30    }
31}

1namespace Doc.IntroducePropertyChanged2
2{


3    [IntroducePropertyChangedAspect]
4    internal class Foo { }
5}

1using System.ComponentModel;
2
3namespace Doc.IntroducePropertyChanged2
4{
5    [IntroducePropertyChangedAspect]
6    internal class Foo
7    {
8        protected virtual void OnPropertyChanged(string propertyName)
9        {
10            this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
11        }
12
13        public event PropertyChangedEventHandler? PropertyChanged;
14    }
15}

Referencing introduced members from source code

If you want the source code (not your aspect code) to reference declarations introduced by your aspect, the user of your aspect needs to make the target types partial. Without this keyword, the introduced declarations will not be visible at design time in syntax completion, and the IDE will report errors. Note that the compiler will not complain because Metalama replaces the compiler, but the IDE will because it does not know about Metalama, and here Metalama, and therefore your aspect, has to follow the rules of the C# compiler. However inconvenient it may be, there is nothing you as an aspect author, or us as the authors of Metalama, can do.

If the user does not add the partial keyword, Metalama will report a warning and offer a code fix.