DirectiveProcessor.ProcessDirective Method

When overridden in a derived class, processes a single directive from a template file.

Namespace:  Microsoft.VisualStudio.TextTemplating
Assembly:  Microsoft.VisualStudio.TextTemplating.11.0 (in Microsoft.VisualStudio.TextTemplating.11.0.dll)


Public MustOverride Sub ProcessDirective ( _
    directiveName As String, _
    arguments As IDictionary(Of String, String) _
public abstract void ProcessDirective(
    string directiveName,
    IDictionary<string, string> arguments
virtual void ProcessDirective(
    String^ directiveName, 
    IDictionary<String^, String^>^ arguments
) abstract
abstract ProcessDirective : 
        directiveName:string * 
        arguments:IDictionary<string, string> -> unit
public abstract function ProcessDirective(
    directiveName : String, 
    arguments : IDictionary<String, String>


  • directiveName
    Type: String

    The name of the directive to process.

  • arguments
    Type: IDictionary<String, String>

    The arguments for the directive.


IDirectiveProcessor.ProcessDirective(String, IDictionary<String, String>)


One directive processor can support many different directives. When ProcessDirective is called, conditional statements run only the specific directive that is being called.

The directives process the arguments and generate code to be added to the generated transformation class.


The following code example shows a possible implementation for a custom directive processor. This code example is part of a larger example provided for the DirectiveProcessor class.

public override void ProcessDirective(string directiveName, IDictionary<string, string> arguments)
    if (string.Compare(directiveName, "CoolDirective", StringComparison.OrdinalIgnoreCase) == 0)
        string fileName;

        if (!arguments.TryGetValue("FileName", out fileName))
            throw new DirectiveProcessorException("Required argument 'FileName' not specified.");

        if (string.IsNullOrEmpty(fileName))
            throw new DirectiveProcessorException("Argument 'FileName' is null or empty.");

        //Now we add code to the generated transformation class.
        //This directive supports either Visual Basic or C#, so we must use the
        //System.CodeDom to create the code.
        //If a directive supports only one language, you can hard code the code.
        CodeMemberField documentField = new CodeMemberField();

        documentField.Name = "document" + directiveCount + "Value";
        documentField.Type = new CodeTypeReference(typeof(XmlDocument));
        documentField.Attributes = MemberAttributes.Private;

        CodeMemberProperty documentProperty = new CodeMemberProperty();

        documentProperty.Name = "Document" + directiveCount;
        documentProperty.Type = new CodeTypeReference(typeof(XmlDocument));
        documentProperty.Attributes = MemberAttributes.Public;
        documentProperty.HasSet = false;
        documentProperty.HasGet = true;

        CodeExpression fieldName = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), documentField.Name);
        CodeExpression booleanTest = new CodeBinaryOperatorExpression(fieldName, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
        CodeExpression rightSide = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("XmlReaderHelper"), "ReadXml", new CodePrimitiveExpression(fileName));
        CodeStatement[] thenSteps = new CodeStatement[] { new CodeAssignStatement(fieldName, rightSide) };

        CodeConditionStatement ifThen = new CodeConditionStatement(booleanTest, thenSteps);

        CodeStatement s = new CodeMethodReturnStatement(fieldName);

        CodeGeneratorOptions options = new CodeGeneratorOptions();
        options.BlankLinesBetweenMembers = true;
        options.IndentString = "    ";
        options.VerbatimOrder = true;
        options.BracingStyle = "C";

        using (StringWriter writer = new StringWriter(codeBuffer, CultureInfo.InvariantCulture))
            codeDomProvider.GenerateCodeFromMember(documentField, writer, options);
            codeDomProvider.GenerateCodeFromMember(documentProperty, writer, options);

    }//end CoolDirective

    //One directive processor can contain many directives.
    //If you want to support more directives, the code goes here...
    if (string.Compare(directiveName, "supercooldirective", StringComparison.OrdinalIgnoreCase) == 0)
        //code for SuperCoolDirective goes here...
    }//end SuperCoolDirective

    //Track how many times the processor has been called.

}//end ProcessDirective
Public Overrides Sub ProcessDirective(ByVal directiveName As String, ByVal arguments As IDictionary(Of String, String))

    If String.Compare(directiveName, "CoolDirective", StringComparison.OrdinalIgnoreCase) = 0 Then

        Dim fileName As String

        If Not (arguments.TryGetValue("FileName", fileName)) Then
            Throw New DirectiveProcessorException("Required argument 'FileName' not specified.")
        End If

        If String.IsNullOrEmpty(fileName) Then
            Throw New DirectiveProcessorException("Argument 'FileName' is null or empty.")
        End If

        'Now we add code to the generated transformation class.
        'This directive supports either Visual Basic or C#, so we must use the
        'System.CodeDom to create the code.
        'If a directive supports only one language, you can hard code the code.

        Dim documentField As CodeMemberField = New CodeMemberField()

        documentField.Name = "document" & directiveCount & "Value"
        documentField.Type = New CodeTypeReference(GetType(XmlDocument))
        documentField.Attributes = MemberAttributes.Private

        Dim documentProperty As CodeMemberProperty = New CodeMemberProperty()

        documentProperty.Name = "Document" & directiveCount
        documentProperty.Type = New CodeTypeReference(GetType(XmlDocument))
        documentProperty.Attributes = MemberAttributes.Public
        documentProperty.HasSet = False
        documentProperty.HasGet = True

        Dim fieldName As CodeExpression = New CodeFieldReferenceExpression(New CodeThisReferenceExpression(), documentField.Name)
        Dim booleanTest As CodeExpression = New CodeBinaryOperatorExpression(fieldName, CodeBinaryOperatorType.IdentityEquality, New CodePrimitiveExpression(Nothing))
        Dim rightSide As CodeExpression = New CodeMethodInvokeExpression(New CodeTypeReferenceExpression("XmlReaderHelper"), "ReadXml", New CodePrimitiveExpression(fileName))
        Dim thenSteps As CodeStatement() = New CodeStatement() {New CodeAssignStatement(fieldName, rightSide)}

        Dim ifThen As CodeConditionStatement = New CodeConditionStatement(booleanTest, thenSteps)

        Dim s As CodeStatement = New CodeMethodReturnStatement(fieldName)

        Dim options As CodeGeneratorOptions = New CodeGeneratorOptions()
        options.BlankLinesBetweenMembers = True
        options.IndentString = "    "
        options.VerbatimOrder = True
        options.BracingStyle = "VB"

        Using writer As StringWriter = New StringWriter(codeBuffer, CultureInfo.InvariantCulture)

            codeDomProvider.GenerateCodeFromMember(documentField, writer, options)
            codeDomProvider.GenerateCodeFromMember(documentProperty, writer, options)
        End Using

    End If  'CoolDirective

    'One directive processor can contain many directives.
    'If you want to support more directives, the code goes here...
    If String.Compare(directiveName, "supercooldirective", StringComparison.OrdinalIgnoreCase) = 0 Then

        'code for SuperCoolDirective goes here
    End If 'SuperCoolDirective

    'Track how many times the processor has been called.
    directiveCount += 1
End Sub 'ProcessDirective

.NET Framework Security

See Also


DirectiveProcessor Class

Microsoft.VisualStudio.TextTemplating Namespace



Other Resources

Creating Custom T4 Text Template Directive Processors

Walkthrough: Creating a Custom Directive Processor