DirectiveProcessor.ProcessDirective-Methode

Artikel
07/20/2011

Verarbeitet beim Überschreiben in einer abgeleiteten Klasse eine einzelne Direktive aus einer Vorlagendatei.

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

Syntax

'Declaration
Public MustOverride Sub ProcessDirective ( _
    directiveName As String, _
    arguments As IDictionary(Of String, String) _
)

public abstract void ProcessDirective(
    string directiveName,
    IDictionary<string, string> arguments
)

public:
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>
)

Parameter

directiveName
Typ: System.String
Der Name der zu verarbeitenden Direktive.

arguments
Typ: System.Collections.Generic.IDictionary<String, String>
Die Argumente für die Direktive.

Hinweise

Ein Direktivenprozessor kann viele verschiedene Direktiven unterstützen. Wenn ProcessDirective aufgerufen wird, führen Bedingungsanweisungen nur die bestimmte Direktive aus, die aufgerufen wird.

Die Direktiven verarbeiten die Argumente und generieren Code, der der generierten Transformationsklasse hinzugefügt werden soll.

Beispiele

Im folgenden Codebeispiel wird eine mögliche Implementierung für einen benutzerdefinierten Direktivenprozessor veranschaulicht. Dieses Codebeispiel ist Teil eines umfangreicheren Beispiels, das für die DirectiveProcessor-Klasse bereitgestellt wird.

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);
        documentProperty.GetStatements.Add(ifThen);

        CodeStatement s = new CodeMethodReturnStatement(fieldName);
        documentProperty.GetStatements.Add(s);

        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.
    //-----------------------------------------------------------------
    directiveCount++;

}//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)
        documentProperty.GetStatements.Add(ifThen)

        Dim s As CodeStatement = New CodeMethodReturnStatement(fieldName)
        documentProperty.GetStatements.Add(s)

        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-Sicherheit

Volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer. Dieser Member kann von nur teilweise vertrauenswürdigem Code nicht verwendet werden. Weitere Informationen finden Sie unter Verwenden von Bibliotheken aus teilweise vertrauenswürdigem Code.