Metalama 1.0 / / Metalama Documentation / Aspect API Documentation / Metalama.​Framework.​Aspects / meta

Class meta

The entry point for the meta model, which can be used in templates to inspect the target code or access other features of the template language.

Inheritance
meta
Namespace: Metalama.Framework.Aspects
Assembly: Metalama.Framework.dll
Syntax
[CompileTime]
public static class meta : Object

Properties

Name Description
AspectInstance

Gets the current IAspectInstance, which gives access to the Predecessors and the SecondaryInstances of the current aspect.

Base

Gets a dynamic object that must be used to get access to instance members of the instance (e.g. meta.Base.MyMethod()). The Base property exposes the state of the target type as it is before the application of the current aspect layer. To access the final layer, use This. To access static members, use BaseType.

BaseStatic
BaseType

Gets a dynamic object that must be used to get access to static members of the type (e.g. meta.BaseStatic.MyStaticMethod()). The BaseType property exposes the state of the target type as it is before the application of the current aspect layer. To access the final layer, use ThisType. To access instance members, use Base.

Tags

Gets the dictionary of tags that were passed to the IAdviceFactory method by the BuildAspect(IAspectBuilder<T>) method.

Target

Gets access to the declaration being overridden or introduced.

This

Gets a dynamic object that represents an instance of the target type. It can be used as a value (e.g. as a method argument) or can be used to get access to instance members of the instance (e.g. meta.This.MyMethod()). The This property exposes the state of the target type as it is after the application of all aspects. If the member is virtual, a virtual call is performed, therefore the implementation on the child type (possibly with all applied aspects) is performed. To access the prior layer (or the base type, if there is no prior layer), use Base. To access static members, use ThisType.

ThisStatic
ThisType

Gets a dynamic object that must be used to get access to static members of the type (e.g. meta.ThisStatic.MyStaticMethod()). The ThisType property exposes the state of the target type as it is after the application of all aspects. To access the prior layer (or the base type, if there is no prior layer), use BaseType. To access instance members, use This.

Methods

Name Description
Cast(IType, Object)

Generates the cast syntax for the specified type.

CompileTime<T>(T)

Coerces an expression to be interpreted as compile time. This is typically used to coerce expressions that can be either run-time or compile-time, such as a literal. Since ambiguous expressions are interpreted as run-time by default, this method allows to change that behavior.

DebugBreak()

Requests the debugger to break, if any debugger is attached to the current process.

DefineExpression(Object, out IExpression)
InsertComment(String[])

Injects a comment to the target code.

InsertStatement(IExpression)

Inserts a statement into the target code, where the statement is given as an IExpression. Note that not all expressions can be used as statements.

InsertStatement(IStatement)

Inserts a statement into the target code, where the statement is given as an IStatement.

InsertStatement(String)

Inserts a statement into the target code, where the statement is given as a String. Calling this overload is equivalent to calling the InsertStatement(IStatement) overload with the result of the ParseStatement(String) method.

ParseExpression(String)
ParseStatement(String)
Proceed()

Invokes the logic that has been overwritten. For instance, in an OverrideMethodAspect, calling Proceed() invokes the method being overridden. Note that the way how the logic is invoked (as a method call or inlining) is considered an implementation detail.

ProceedAsync()

Synonym to Proceed(), but the return type is exposed as a Task<dynamic?>. Only use this method when the return type of the method or accessor is task-like. Note that the actual return type of the overridden method or accessor is the one of the overwritten semantic, so it can be a void Task, a ValueType, or any other type.

ProceedAsyncEnumerable()
ProceedAsyncEnumerator()
ProceedEnumerable()

Synonym to Proceed(), but the return type is exposed as a IEnumerable<dynamic?>.

ProceedEnumerator()

Synonym to Proceed(), but the return type is exposed as a IEnumerator<dynamic?>.

RunTime<T>(T)

Converts a compile-value into run-time value by serializing the compile-time value into a some syntax that will evaluate, at run time, to the same value as at compile time.

See Also