Пример #1
0
        public bool TryRender(ICSharpSource source, CSharpRenderingContext context)
        {
            if (source is ExecuteMethodDeclaration)
            {
                var directives = context.GetDirectives();
                foreach (var directive in directives)
                {
                    if (!string.Equals(directive.Name, "inject", StringComparison.Ordinal))
                    {
                        continue;
                    }

                    var typeName   = directive.GetValue(RazorDirectiveTokenType.Type);
                    var memberName = directive.GetValue(RazorDirectiveTokenType.Member);

                    context.Writer
                    .WriteLine(_injectAttribute)
                    .Write("public global::")
                    .Write(typeName)
                    .Write(" ")
                    .Write(memberName)
                    .WriteLine(" { get; private set; }");
                }
            }

            return(false);
        }
        private void Render(InitializeTagHelperStructure source, CSharpRenderingContext context)
        {
            // Call into the tag helper scope manager to start a new tag helper scope.
            // Also capture the value as the current execution context.
            context.Writer
            .WriteStartAssignment(ExecutionContextVariableName)
            .WriteStartInstanceMethodInvocation(
                ScopeManagerVariableName,
                context.CodeLiterals.GeneratedTagHelperContext.ScopeManagerBeginMethodName);

            // Assign a unique ID for this instance of the source HTML tag. This must be unique
            // per call site, e.g. if the tag is on the view twice, there should be two IDs.
            context.Writer.WriteStringLiteral(source.TagName)
            .WriteParameterSeparator()
            .Write("global::")
            .Write(typeof(TagMode).FullName)
            .Write(".")
            .Write(source.TagMode.ToString())
            .WriteParameterSeparator()
            .WriteStringLiteral(GenerateUniqueTagHelperId())
            .WriteParameterSeparator();

            // We remove and redirect writers so TagHelper authors can retrieve content.
            var nonRedirectedConventions = new CSharpRenderingConventions(context);

            using (context.UseRenderingConventions(nonRedirectedConventions))
                using (context.Writer.BuildAsyncLambda(endLine: false))
                {
                    context.Render(source.Children);
                }

            context.Writer.WriteEndMethodInvocation();
        }
        private void Render(ExecuteMethodDeclaration source, CSharpRenderingContext context)
        {
            context.Writer
            .WriteLine("#pragma warning disable 1998")
            .Write(source.Accessor)
            .Write(" ");

            for (var i = 0; i < source.Modifiers.Count; i++)
            {
                context.Writer.Write(source.Modifiers[i]);

                if (i + 1 < source.Modifiers.Count)
                {
                    context.Writer.Write(" ");
                }
            }

            context.Writer
            .Write(" ")
            .Write(source.ReturnTypeName)
            .Write(" ")
            .Write(source.Name)
            .WriteLine("()");

            using (context.Writer.BuildScope())
            {
                context.Render(source.Children);
            }

            context.Writer.WriteLine("#pragma warning restore 1998");
        }
        private static void Render(DeclarePreallocatedTagHelperHtmlAttribute source, CSharpRenderingContext context)
        {
            context.Writer
            .Write("private static readonly global::")
            .Write(context.CodeLiterals.GeneratedTagHelperContext.TagHelperAttributeTypeName)
            .Write(" ")
            .Write(source.VariableName)
            .Write(" = ")
            .WriteStartNewObject("global::" + context.CodeLiterals.GeneratedTagHelperContext.TagHelperAttributeTypeName)
            .WriteStringLiteral(source.Name);

            if (source.ValueStyle == HtmlAttributeValueStyle.Minimized)
            {
                context.Writer.WriteEndMethodInvocation();
            }
            else
            {
                context.Writer
                .WriteParameterSeparator()
                .WriteStartNewObject("global::" + context.CodeLiterals.GeneratedTagHelperContext.EncodedHtmlStringTypeName)
                .WriteStringLiteral(source.Value)
                .WriteEndMethodInvocation(endLine: false)
                .WriteParameterSeparator()
                .Write($"global::{typeof(HtmlAttributeValueStyle).FullName}.{source.ValueStyle}")
                .WriteEndMethodInvocation();
            }
        }
        private static void Render(RenderConditionalAttribute source, CSharpRenderingContext context)
        {
            var valuePieceCount      = source.ValuePieces.Count(piece => piece is LiteralAttributePiece || piece is ConditionalAttributePiece);
            var prefixLocation       = source.DocumentLocation.AbsoluteIndex;
            var suffixLocation       = source.DocumentLocation.AbsoluteIndex + source.DocumentLocation.ContentLength - source.Suffix.Length;
            var renderingConventions = context.GetRenderingConventions();

            renderingConventions
            .StartBeginWriteAttributeMethod()
            .WriteStringLiteral(source.Name)
            .WriteParameterSeparator()
            .WriteStringLiteral(source.Prefix)
            .WriteParameterSeparator()
            .Write(prefixLocation.ToString(CultureInfo.InvariantCulture))
            .WriteParameterSeparator()
            .WriteStringLiteral(source.Suffix)
            .WriteParameterSeparator()
            .Write(suffixLocation.ToString(CultureInfo.InvariantCulture))
            .WriteParameterSeparator()
            .Write(valuePieceCount.ToString(CultureInfo.InvariantCulture))
            .WriteEndMethodInvocation();

            context.Render(source.ValuePieces);

            renderingConventions
            .StartEndWriteAttributeMethod()
            .WriteEndMethodInvocation();
        }
        private static void Render(RenderHtml source, CSharpRenderingContext context)
        {
            const int MaxStringLiteralLength = 1024;

            var charactersConsumed   = 0;
            var renderingConventions = context.GetRenderingConventions();

            // Render the string in pieces to avoid Roslyn OOM exceptions at compile time: https://github.com/aspnet/External/issues/54
            while (charactersConsumed < source.Html.Length)
            {
                string textToRender;
                if (source.Html.Length <= MaxStringLiteralLength)
                {
                    textToRender = source.Html;
                }
                else
                {
                    var charactersToSubstring = Math.Min(MaxStringLiteralLength, source.Html.Length - charactersConsumed);
                    textToRender = source.Html.Substring(charactersConsumed, charactersToSubstring);
                }

                renderingConventions
                .StartWriteLiteralMethod()
                .WriteStringLiteral(textToRender)
                .WriteEndMethodInvocation();

                charactersConsumed += textToRender.Length;
            }
        }
        private void Render(RenderExpression source, CSharpRenderingContext context)
        {
            if (source.Expression.Children.Count == 0)
            {
                return;
            }

            if (source.DocumentLocation != null)
            {
                using (context.Writer.BuildLinePragma(source.DocumentLocation))
                    using (context.Writer.NoIndent())
                    {
                        var paddingString = BuildAssignmentOffsetPadding(source.Padding);

                        context.Writer
                        .Write(paddingString)
                        .WriteStartAssignment(DesignTimeVariable);

                        using (context.Writer.BuildCodeMapping(source.DocumentLocation))
                        {
                            context.Render(source.Expression.Children);
                        }

                        context.Writer.WriteLine(";");
                    }
            }
            else
            {
                context.Writer.WriteStartAssignment(DesignTimeVariable);
                context.Render(source.Expression.Children);
                context.Writer.WriteLine(";");
            }
        }
        private void Render(RenderTagHelper source, CSharpRenderingContext context)
        {
            var renderTagHelperContext = new RenderTagHelperContext();

            using (context.UseRenderTagHelperContext(renderTagHelperContext))
            {
                context.Render(source.Children);
            }
        }
 private static void Render(AddPreallocatedTagHelperHtmlAttribute source, CSharpRenderingContext context)
 {
     context.Writer
     .WriteStartInstanceMethodInvocation(
         ExecutionContextVariableName,
         context.CodeLiterals.GeneratedTagHelperContext.ExecutionContextAddHtmlAttributeMethodName)
     .Write(source.AttributeVariableName)
     .WriteEndMethodInvocation();
 }
 private static void Render(BeginInstrumentation source, CSharpRenderingContext context)
 {
     context.Writer
     .WriteStartMethodInvocation(context.CodeLiterals.BeginContextMethodName)
     .Write(source.DocumentLocation.AbsoluteIndex.ToString(CultureInfo.InvariantCulture))
     .WriteParameterSeparator()
     .Write(source.DocumentLocation.ContentLength.ToString(CultureInfo.InvariantCulture))
     .WriteParameterSeparator()
     .Write(source.Literal ? "true" : "false")
     .WriteEndMethodInvocation();
 }
        private void Render(CreateTagHelper source, CSharpRenderingContext context)
        {
            var tagHelperVariableName = GetTagHelperVariableName(source.TagHelperTypeName);

            // Create the tag helper
            context.Writer
            .WriteStartAssignment(tagHelperVariableName)
            .WriteStartMethodInvocation(
                context.CodeLiterals.GeneratedTagHelperContext.CreateTagHelperMethodName,
                "global::" + source.TagHelperTypeName)
            .WriteEndMethodInvocation();
        }
        private void Render(NamespaceDeclaration source, CSharpRenderingContext context)
        {
            context.Writer
            .Write("namespace ")
            .WriteLine(source.Namespace);

            using (context.Writer.BuildScope())
            {
                context.Writer.WriteLineHiddenDirective();
                context.Render(source.Children);
            }
        }
Пример #13
0
        public static CSharpRenderingConventions GetRenderingConventions(this CSharpRenderingContext context)
        {
            var conventions = context.Items[typeof(CSharpRenderingConventions)] as CSharpRenderingConventions;

            if (conventions == null)
            {
                conventions = new CSharpRenderingConventions(context);
                SetRenderingConventions(context, conventions);
            }

            return(conventions);
        }
 private void Render(DeclareTagHelperFields source, CSharpRenderingContext context)
 {
     foreach (var tagHelperTypeName in source.UsedTagHelperTypeNames)
     {
         var tagHelperVariableName = GetTagHelperVariableName(tagHelperTypeName);
         context.Writer
         .Write("private global::")
         .WriteVariableDeclaration(
             tagHelperTypeName,
             tagHelperVariableName,
             value: null);
     }
 }
        private static void Render(ConditionalAttributePiece source, CSharpRenderingContext context)
        {
            const string ValueWriterName = "__razor_attribute_value_writer";

            var expressionValue = source.Value.Children.First() as RenderExpression;
            var linePragma      = expressionValue != null?context.Writer.BuildLinePragma(source.DocumentLocation) : null;

            var prefixLocation       = source.DocumentLocation.AbsoluteIndex;
            var valueLocation        = source.DocumentLocation.AbsoluteIndex + source.Prefix.Length;
            var valueLength          = source.DocumentLocation.ContentLength - source.Prefix.Length;
            var renderingConventions = context.GetRenderingConventions();

            renderingConventions
            .StartWriteAttributeValueMethod()
            .WriteStringLiteral(source.Prefix)
            .WriteParameterSeparator()
            .Write(prefixLocation.ToString(CultureInfo.InvariantCulture))
            .WriteParameterSeparator();

            if (expressionValue != null)
            {
                Debug.Assert(source.Value.Children.Count == 1);

                RenderExpressionInline(expressionValue.Expression, context);
            }
            else
            {
                // Not an expression; need to buffer the result.
                context.Writer.WriteStartNewObject(context.CodeLiterals.TemplateTypeName);

                var redirectConventions = new CSharpRedirectRenderingConventions(ValueWriterName, context);
                using (context.UseRenderingConventions(redirectConventions))
                    using (context.Writer.BuildAsyncLambda(endLine: false, parameterNames: ValueWriterName))
                    {
                        context.Render(source.Value.Children);
                    }

                context.Writer.WriteEndMethodInvocation(false);
            }

            context.Writer
            .WriteParameterSeparator()
            .Write(valueLocation.ToString(CultureInfo.InvariantCulture))
            .WriteParameterSeparator()
            .Write(valueLength.ToString(CultureInfo.InvariantCulture))
            .WriteParameterSeparator()
            .WriteBooleanLiteral(false)
            .WriteEndMethodInvocation();

            linePragma?.Dispose();
        }
Пример #16
0
        public static IDisposable UseRenderTagHelperContext(
            this CSharpRenderingContext context,
            RenderTagHelperContext renderTagHelperContext)
        {
            var initialContext = context.GetRenderTagHelperContext();
            var scope          = new ActionScope(() =>
            {
                context.SetRenderTagHelperContext(initialContext);
            });

            context.SetRenderTagHelperContext(renderTagHelperContext);

            return(scope);
        }
 private static void Render(Checksum source, CSharpRenderingContext context)
 {
     if (!string.IsNullOrEmpty(source.Bytes))
     {
         context.Writer
         .Write("#pragma checksum \"")
         .Write(source.FileName)
         .Write("\" \"")
         .Write(source.Guid)
         .Write("\" \"")
         .Write(source.Bytes)
         .WriteLine("\"");
     }
 }
Пример #18
0
        public static IDisposable UseRenderingConventions(
            this CSharpRenderingContext context,
            CSharpRenderingConventions conventions)
        {
            var initialConventions = context.GetRenderingConventions();
            var scope = new ActionScope(() =>
            {
                context.SetRenderingConventions(initialConventions);
            });

            context.SetRenderingConventions(conventions);

            return(scope);
        }
        private void Render(ViewClassDeclaration source, CSharpRenderingContext context)
        {
            context.Writer
            .Write(source.Accessor)
            .Write(" class ")
            .Write(source.Name);

            if (source.BaseTypeName != null || source.ImplementedInterfaceNames != null)
            {
                context.Writer.Write(" : ");
            }

            if (source.BaseTypeName != null)
            {
                context.Writer.Write(source.BaseTypeName);

                if (source.ImplementedInterfaceNames != null)
                {
                    context.Writer.WriteParameterSeparator();
                }
            }

            if (source.ImplementedInterfaceNames != null)
            {
                for (var i = 0; i < source.ImplementedInterfaceNames.Count; i++)
                {
                    context.Writer.Write(source.ImplementedInterfaceNames[i]);

                    if (i + 1 < source.ImplementedInterfaceNames.Count)
                    {
                        context.Writer.WriteParameterSeparator();
                    }
                }
            }

            context.Writer.WriteLine();

            using (context.Writer.BuildScope())
            {
                context.Writer
                .Write("private static object @")
                .Write(DesignTimeVariable)
                .WriteLine(";");

                context.Render(source.Children);
            }
        }
        private static void Render(RenderExpression source, CSharpRenderingContext context)
        {
            IDisposable linePragmaScope = null;

            if (source.DocumentLocation != null)
            {
                linePragmaScope = context.Writer.BuildLinePragma(source.DocumentLocation);
            }

            var renderingConventions = context.GetRenderingConventions();

            renderingConventions.StartWriteMethod();
            context.Render(source.Expression.Children);
            context.Writer.WriteEndMethodInvocation();

            linePragmaScope?.Dispose();
        }
        private static void Render(SetPreallocatedTagHelperProperty source, CSharpRenderingContext context)
        {
            var tagHelperVariableName  = GetTagHelperVariableName(source.TagHelperTypeName);
            var propertyValueAccessor  = GetTagHelperPropertyAccessor(tagHelperVariableName, source.AttributeName, source.AssociatedDescriptor);
            var attributeValueAccessor = $"{source.AttributeVariableName}.{context.CodeLiterals.GeneratedTagHelperContext.TagHelperAttributeValuePropertyName}";

            context.Writer
            .WriteStartAssignment(propertyValueAccessor)
            .Write("(string)")
            .Write(attributeValueAccessor)
            .WriteLine(";")
            .WriteStartInstanceMethodInvocation(
                ExecutionContextVariableName,
                context.CodeLiterals.GeneratedTagHelperContext.ExecutionContextAddTagHelperAttributeMethodName)
            .Write(source.AttributeVariableName)
            .WriteEndMethodInvocation();
        }
        private static void Render(RenderStatement source, CSharpRenderingContext context)
        {
            if (string.IsNullOrWhiteSpace(source.Code))
            {
                return;
            }

            if (source.DocumentLocation != null)
            {
                using (context.Writer.BuildLinePragma(source.DocumentLocation))
                {
                    context.Writer.WriteLine(source.Code);
                }
            }
            else
            {
                context.Writer.WriteLine(source.Code);
            }
        }
 private static void RenderExpressionInline(ICSharpSource expression, CSharpRenderingContext context)
 {
     if (expression is CSharpSource)
     {
         context.Writer.Write(((CSharpSource)expression).Code);
     }
     else if (expression is RenderExpression)
     {
         RenderExpressionInline(((RenderExpression)expression).Expression, context);
     }
     else if (expression is CSharpBlock)
     {
         var expressionBlock = (CSharpBlock)expression;
         for (var i = 0; i < expressionBlock.Children.Count; i++)
         {
             RenderExpressionInline(expressionBlock.Children[i], context);
         }
     }
 }
        private void Render(Template source, CSharpRenderingContext context)
        {
            const string ItemParameterName  = "item";
            const string TemplateWriterName = "__razor_template_writer";

            context.Writer
            .Write(ItemParameterName).Write(" => ")
            .WriteStartNewObject(context.CodeLiterals.TemplateTypeName);

            var redirectConventions = new CSharpRedirectRenderingConventions(TemplateWriterName, context);

            using (context.UseRenderingConventions(redirectConventions))
                using (context.Writer.BuildAsyncLambda(endLine: false, parameterNames: TemplateWriterName))
                {
                    context.Render(source.Children);
                }

            context.Writer.WriteEndMethodInvocation();
        }
        private void Render(RenderSection source, CSharpRenderingContext context)
        {
            const string SectionWriterName = "__razor_section_writer";

            context.Writer
            .WriteStartMethodInvocation(context.CodeLiterals.DefineSectionMethodName)
            .WriteStringLiteral(source.Name)
            .WriteParameterSeparator();

            var redirectConventions = new CSharpRedirectRenderingConventions(SectionWriterName, context);

            using (context.UseRenderingConventions(redirectConventions))
                using (context.Writer.BuildAsyncLambda(endLine: false, parameterNames: SectionWriterName))
                {
                    context.Render(source.Children);
                }

            context.Writer.WriteEndMethodInvocation();
        }
        public bool TryRender(ICSharpSource source, CSharpRenderingContext context)
        {
            if (source is NamespaceDeclaration)
            {
                Render((NamespaceDeclaration)source, context);
            }
            else if (source is ExecuteMethodDeclaration)
            {
                Render((ExecuteMethodDeclaration)source, context);
            }
            else if (source is ViewClassDeclaration)
            {
                Render((ViewClassDeclaration)source, context);
            }
            else
            {
                return(false);
            }

            return(true);
        }
        private static void Render(LiteralAttributePiece source, CSharpRenderingContext context)
        {
            var prefixLocation       = source.DocumentLocation.AbsoluteIndex;
            var valueLocation        = source.DocumentLocation.AbsoluteIndex + source.Prefix.Length;
            var valueLength          = source.DocumentLocation.ContentLength - source.Prefix.Length;
            var renderingConventions = context.GetRenderingConventions();

            renderingConventions
            .StartWriteAttributeValueMethod()
            .WriteStringLiteral(source.Prefix)
            .WriteParameterSeparator()
            .Write(prefixLocation.ToString(CultureInfo.InvariantCulture))
            .WriteParameterSeparator()
            .WriteStringLiteral(source.Value)
            .WriteParameterSeparator()
            .Write(valueLocation.ToString(CultureInfo.InvariantCulture))
            .WriteParameterSeparator()
            .Write(valueLength.ToString(CultureInfo.InvariantCulture))
            .WriteParameterSeparator()
            .WriteBooleanLiteral(true)
            .WriteEndMethodInvocation();
        }
        private static void Render(ExecuteTagHelpers source, CSharpRenderingContext context)
        {
            context.Writer
            .Write("await ")
            .WriteStartInstanceMethodInvocation(RunnerVariableName, context.CodeLiterals.GeneratedTagHelperContext.RunnerRunAsyncMethodName)
            .Write(ExecutionContextVariableName)
            .WriteEndMethodInvocation();

            var tagHelperOutputAccessor =
                $"{ExecutionContextVariableName}.{context.CodeLiterals.GeneratedTagHelperContext.ExecutionContextOutputPropertyName}";

            context.Writer
            .Write("if (!")
            .Write(tagHelperOutputAccessor)
            .Write(".")
            .Write(context.CodeLiterals.GeneratedTagHelperContext.TagHelperOutputIsContentModifiedPropertyName)
            .WriteLine(")");

            using (context.Writer.BuildScope())
            {
                context.Writer
                .Write("await ")
                .WriteInstanceMethodInvocation(
                    ExecutionContextVariableName,
                    context.CodeLiterals.GeneratedTagHelperContext.ExecutionContextSetOutputContentAsyncMethodName);
            }

            var renderingConventions = context.GetRenderingConventions();

            renderingConventions
            .StartWriteMethod()
            .Write(tagHelperOutputAccessor)
            .WriteEndMethodInvocation()
            .WriteStartAssignment(ExecutionContextVariableName)
            .WriteInstanceMethodInvocation(
                ScopeManagerVariableName,
                context.CodeLiterals.GeneratedTagHelperContext.ScopeManagerEndMethodName);
        }
 private static void RenderTagHelperAttributeInline(
     ICSharpSource attributeValue,
     MappingLocation documentLocation,
     CSharpRenderingContext context)
 {
     if (attributeValue is CSharpSource)
     {
         context.Writer.Write(((CSharpSource)attributeValue).Code);
     }
     else if (attributeValue is RenderHtml)
     {
         context.Writer.Write(((RenderHtml)attributeValue).Html);
     }
     else if (attributeValue is RenderExpression)
     {
         RenderTagHelperAttributeInline(((RenderExpression)attributeValue).Expression, documentLocation, context);
     }
     else if (attributeValue is RenderStatement)
     {
         context.ErrorSink.OnError(
             documentLocation,
             "TODO: RazorResources.TagHelpers_CodeBlocks_NotSupported_InAttributes");
     }
     else if (attributeValue is Template)
     {
         context.ErrorSink.OnError(
             documentLocation,
             "TODO: RazorResources.FormatTagHelpers_InlineMarkupBlocks_NotSupported_InAttributes(_attributeTypeName)");
     }
     else if (attributeValue is CSharpBlock)
     {
         var expressionBlock = (CSharpBlock)attributeValue;
         for (var i = 0; i < expressionBlock.Children.Count; i++)
         {
             RenderTagHelperAttributeInline(expressionBlock.Children[i], documentLocation, context);
         }
     }
 }
        private void Render(ExecuteMethodDeclaration source, CSharpRenderingContext context)
        {
            const string DesignTimeHelperMethodName    = "__RazorDesignTimeHelpers__";
            const int    DisableVariableNamingWarnings = 219;

            context.Writer
            .Write("private static object @")
            .Write(DesignTimeVariable)
            .WriteLine(";");

            using (context.Writer.BuildMethodDeclaration("private", "void", "@" + DesignTimeHelperMethodName))
            {
                using (context.Writer.BuildDisableWarningScope(DisableVariableNamingWarnings))
                {
                    context.Writer.WriteVariableDeclaration(typeof(Action).FullName, ActionHelper, value: null);

                    var directives = context.GetDirectives();
                    foreach (var directive in directives)
                    {
                        Render(directive, context);
                    }
                }
            }
        }