public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure)
{
// Rewrite the assembly name into a full name just like this one, but with the name of the MVC design time assembly.
var assemblyName = new AssemblyName(typeof(LegacyProjectEngineFactory_3_0).Assembly.FullName);
assemblyName.Name = AssemblyName;
var extension = new AssemblyExtension(configuration.ConfigurationName, Assembly.Load(assemblyName));
var initializer = extension.CreateInitializer();
return(RazorProjectEngine.Create(configuration, fileSystem, b =>
{
CompilerFeatures.Register(b);
initializer.Initialize(b);
configure?.Invoke(b);
// See comments on MangleClassNames
var componentDocumentClassifier = b.Features.OfType <ComponentDocumentClassifierPass>().FirstOrDefault();
if (componentDocumentClassifier != null)
{
componentDocumentClassifier.MangleClassNames = true;
}
}));
}
// intentionally private - we don't want individual tests messing with the project engine
private RazorProjectEngine CreateProjectEngine(RazorConfiguration configuration, MetadataReference[] references)
{
return(RazorProjectEngine.Create(configuration, FileSystem, b =>
{
b.SetRootNamespace(DefaultRootNamespace);
// Turn off checksums, we're testing code generation.
b.Features.Add(new SuppressChecksum());
b.Features.Add(new TestImportProjectFeature(ImportItems));
if (LineEnding != null)
{
b.Phases.Insert(0, new ForceLineEndingPhase(LineEnding));
}
b.Features.Add(new DefaultTypeNameFeature());
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultMetadataReferenceFeature()
{
References = references,
});
b.SetCSharpLanguageVersion(CSharpParseOptions.LanguageVersion);
CompilerFeatures.Register(b);
}));
}
public void Execute(GeneratorExecutionContext context)
{
var razorContext = RazorSourceGenerationContext.Create(context);
if (razorContext is null ||
(razorContext.RazorFiles.Count == 0 && razorContext.CshtmlFiles.Count == 0))
{
return;
}
HandleDebugSwitch(razorContext.WaitForDebugger);
var tagHelpers = ResolveTagHelperDescriptors(context, razorContext);
var projectEngine = RazorProjectEngine.Create(razorContext.Configuration, razorContext.FileSystem, b =>
{
b.Features.Add(new DefaultTypeNameFeature());
b.SetRootNamespace(razorContext.RootNamespace);
b.Features.Add(new StaticTagHelperFeature {
TagHelpers = tagHelpers,
});
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
RazorExtensions.Register(b);
b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion);
});
CodeGenerateRazorComponents(context, razorContext, projectEngine);
GenerateViews(context, razorContext, projectEngine);
}
public Generator()
{
Declarations = new Dictionary <string, string>();
References = new List <MetadataReference>();
GC.KeepAlive(typeof(EditForm));
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (!assembly.IsDynamic && assembly.Location != null)
{
References.Add(MetadataReference.CreateFromFile(assembly.Location));
}
}
BaseCompilation = CSharpCompilation.Create(
assemblyName: "__Test",
Array.Empty <SyntaxTree>(),
References.ToArray(),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
References.Add(BaseCompilation.ToMetadataReference());
FileSystem = new TestRazorProjectFileSystem();
Engine = RazorProjectEngine.Create(RazorConfiguration.Default, FileSystem, builder =>
{
builder.Features.Add(new CompilationTagHelperFeature());
builder.Features.Add(new DefaultMetadataReferenceFeature()
{
References = References,
});
CompilerFeatures.Register(builder);
});
}
private static RazorProjectEngine GetDeclarationProjectEngine(
SourceGeneratorProjectItem item,
IEnumerable <SourceGeneratorProjectItem> imports,
RazorSourceGenerationOptions razorSourceGeneratorOptions)
{
var fileSystem = new VirtualRazorProjectFileSystem();
fileSystem.Add(item);
foreach (var import in imports)
{
fileSystem.Add(import);
}
var discoveryProjectEngine = RazorProjectEngine.Create(razorSourceGeneratorOptions.Configuration, fileSystem, b =>
{
b.Features.Add(new DefaultTypeNameFeature());
b.Features.Add(new ConfigureRazorCodeGenerationOptions(options =>
{
options.SuppressPrimaryMethodBody = true;
options.SuppressChecksum = true;
}));
b.SetRootNamespace(razorSourceGeneratorOptions.RootNamespace);
CompilerFeatures.Register(b);
RazorExtensions.Register(b);
b.SetCSharpLanguageVersion(razorSourceGeneratorOptions.CSharpLanguageVersion);
});
return(discoveryProjectEngine);
}
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure)
{
return(RazorProjectEngine.Create(configuration, fileSystem, b =>
{
CompilerFeatures.Register(b);
configure?.Invoke(b);
}));
}
public void Execute(GeneratorExecutionContext context)
{
var _razorContext = new RazorSourceGenerationContext(context);
if (_razorContext is null)
{
context.ReportDiagnostic(Diagnostic.Create(RazorDiagnostics.InvalidRazorContextComputedDescriptor, Location.None));
return;
}
if (_razorContext.RazorFiles.Count == 0 && _razorContext.CshtmlFiles.Count == 0)
{
return;
}
if (_razorContext.SuppressRazorSourceGenerator)
{
return;
}
HandleDebugSwitch(_razorContext.WaitForDebugger);
var tagHelpers = ResolveTagHelperDescriptors(context, _razorContext);
AssertOrFailFast(tagHelpers.Count == 0, "No tag helpers resolved.");
var projectEngine = RazorProjectEngine.Create(_razorContext.Configuration, _razorContext.FileSystem, b =>
{
b.Features.Add(new DefaultTypeNameFeature());
b.SetRootNamespace(_razorContext.RootNamespace);
b.Features.Add(new ConfigureRazorCodeGenerationOptions(options =>
{
options.SuppressMetadataSourceChecksumAttributes = !_razorContext.GenerateMetadataSourceChecksumAttributes;
}));
b.Features.Add(new StaticTagHelperFeature {
TagHelpers = tagHelpers,
});
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
RazorExtensions.Register(b);
b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion);
});
if (_razorContext.CshtmlFiles.Count != 0)
{
context.AddSource($"{context.Compilation.AssemblyName}.UnifiedAssembly.Info.g.cs", ProvideApplicationPartFactoryAttributeSourceText);
}
RazorGenerateForSourceTexts(_razorContext.CshtmlFiles, context, projectEngine);
RazorGenerateForSourceTexts(_razorContext.RazorFiles, context, projectEngine);
}
private RazorProjectEngine CreateProjectEngine(IReadOnlyList <MetadataReference> references) =>
RazorProjectEngine.Create(this.Configuration, this.FileSystem, b =>
{
b.SetRootNamespace(DefaultRootNamespace);
// Features that use Roslyn are mandatory for components
CompilerFeatures.Register(b);
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultMetadataReferenceFeature {
References = references,
});
});
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure)
{
return(RazorProjectEngine.Create(configuration, fileSystem, b =>
{
CompilerFeatures.Register(b);
configure?.Invoke(b);
// See comments on MangleClassNames
var componentDocumentClassifier = b.Features.OfType <ComponentDocumentClassifierPass>().FirstOrDefault();
if (componentDocumentClassifier != null)
{
componentDocumentClassifier.MangleClassNames = true;
}
}));
}
private int ExecuteCore(RazorConfiguration configuration, string projectDirectory, string outputFilePath, string[] assemblies)
{
outputFilePath = Path.Combine(projectDirectory, outputFilePath);
var metadataReferences = new MetadataReference[assemblies.Length];
for (var i = 0; i < assemblies.Length; i++)
{
metadataReferences[i] = Parent.AssemblyReferenceProvider(assemblies[i], default(MetadataReferenceProperties));
}
var engine = RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Empty, b =>
{
b.Features.Add(new DefaultMetadataReferenceFeature()
{
References = metadataReferences
});
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
});
var feature = engine.Engine.Features.OfType <ITagHelperFeature>().Single();
var tagHelpers = feature.GetDescriptors();
using (var stream = new MemoryStream())
{
Serialize(stream, tagHelpers);
stream.Position = 0;
var newHash = Hash(stream);
var existingHash = Hash(outputFilePath);
if (!HashesEqual(newHash, existingHash))
{
stream.Position = 0;
using (var output = File.Open(outputFilePath, FileMode.Create))
{
stream.CopyTo(output);
}
}
}
return(ExitCodeSuccess);
}
public RazorProjectEngine CreateRazorProjectEngine(IReadOnlyList <MetadataReference> references)
{
Console.WriteLine("CreateRazorProjectEngine");
return(RazorProjectEngine.Create(_config, _fileSystem, builder =>
{
builder.SetRootNamespace(DefaultRootNamespace);
builder.AddDefaultImports(RazorConstants.DefaultUsings);
// Features that use Roslyn are mandatory for components
CompilerFeatures.Register(builder);
builder.Features.Add(new CompilationTagHelperFeature());
builder.Features.Add(new DefaultMetadataReferenceFeature {
References = references
});
}));
}
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure)
{
// Rewrite the assembly name into a full name just like this one, but with the name of the MVC design time assembly.
var assemblyName = new AssemblyName(typeof(RazorProjectEngine).Assembly.FullName);
assemblyName.Name = AssemblyName;
var extension = new AssemblyExtension(configuration.ConfigurationName, Assembly.Load(assemblyName));
var initializer = extension.CreateInitializer();
return(RazorProjectEngine.Create(configuration, fileSystem, b =>
{
CompilerFeatures.Register(b);
initializer.Initialize(b);
configure?.Invoke(b);
}));
}
private static RazorProjectEngine GetDiscoveryProjectEngine(
IReadOnlyList <MetadataReference> references,
StaticCompilationTagHelperFeature tagHelperFeature)
{
var discoveryProjectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, new VirtualRazorProjectFileSystem(), b =>
{
b.Features.Add(new DefaultMetadataReferenceFeature {
References = references
});
b.Features.Add(tagHelperFeature);
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
RazorExtensions.Register(b);
});
return(discoveryProjectEngine);
}
// intentionally private - we don't want individual tests messing with the project engine
private RazorProjectEngine CreateProjectEngine(RazorConfiguration configuration, MetadataReference[] references)
{
return(RazorProjectEngine.Create(configuration, FileSystem, b =>
{
// Turn off checksums, we're testing code generation.
b.Features.Add(new SuppressChecksum());
if (LineEnding != null)
{
b.Phases.Insert(0, new ForceLineEndingPhase(LineEnding));
}
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultMetadataReferenceFeature()
{
References = references,
});
CompilerFeatures.Register(b);
}));
}
private static RazorProjectEngine GetGenerationProjectEngine(
IReadOnlyList <TagHelperDescriptor> tagHelpers,
SourceGeneratorProjectItem item,
IEnumerable <SourceGeneratorProjectItem> imports,
RazorSourceGenerationOptions razorSourceGeneratorOptions)
{
var fileSystem = new VirtualRazorProjectFileSystem();
fileSystem.Add(item);
foreach (var import in imports)
{
fileSystem.Add(import);
}
var projectEngine = RazorProjectEngine.Create(razorSourceGeneratorOptions.Configuration, fileSystem, b =>
{
b.Features.Add(new DefaultTypeNameFeature());
b.SetRootNamespace(razorSourceGeneratorOptions.RootNamespace);
b.Features.Add(new ConfigureRazorCodeGenerationOptions(options =>
{
options.SuppressMetadataSourceChecksumAttributes = !razorSourceGeneratorOptions.GenerateMetadataSourceChecksumAttributes;
options.SupportLocalizedComponentNames = razorSourceGeneratorOptions.SupportLocalizedComponentNames;
}));
b.Features.Add(new StaticTagHelperFeature {
TagHelpers = tagHelpers
});
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
RazorExtensions.Register(b);
b.SetCSharpLanguageVersion(razorSourceGeneratorOptions.CSharpLanguageVersion);
});
return(projectEngine);
}
byte[] CompileCode(string code)
{
typeof(EventHandlers).ToString();
typeof(EditContext).ToString(); //ensure more assemblies..
if (refs == null)
{
refs = AppDomain.CurrentDomain.GetAssemblies().Select(v =>
{
try
{
return(Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(v.Location));
}
catch
{
return(null);
}
}).Where(v => v != null).ToArray();
}
if (exts == null)
{
exts = new List <RazorExtension>();
exts.Add(new AssemblyExtension("ComponentBase", typeof(ComponentBase).Assembly));
exts.Add(new AssemblyExtension("ComponentWeb", typeof(BindAttributes).Assembly));
foreach (AssemblyName asm in this.GetType().Assembly.GetReferencedAssemblies())
{
exts.Add(new AssemblyExtension(asm.FullName, AppDomain.CurrentDomain.Load(asm.FullName)));
}
}
var config = RazorConfiguration.Create(RazorLanguageVersion.Version_3_0, "Default", exts);
var proj = new MyProject();
if (tagHelpers == null)
{
var rpe1 = RazorProjectEngine.Create(config, proj, b =>
{
//Check Microsoft.AspNetCore.Razor.Tools.DiscoverCommand
b.Features.Add(new DefaultMetadataReferenceFeature
{
References = refs
});
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
});
tagHelpers = rpe1.Engine.Features.OfType <ITagHelperFeature>().Single().GetDescriptors().ToArray();
}
if (code == null)
{
return(null);
}
var engine = RazorProjectEngine.Create(config, proj, b =>
{
var mf = new MyFeatureV2()
{
TagHelpers = tagHelpers
};
b.Features.Add(mf);
});
var projitem = new MyProjectItem()
{
Name = "MyComponent.razor", Code = code
};
var razorDoc = engine.Process(projitem);
var csdoc = razorDoc.GetCSharpDocument();
foreach (var diag in csdoc.Diagnostics)
{
switch (diag.Id)
{
case "RZ9980":
case "RZ9981":
throw new Exception("Error : " + diag.Id);
}
}
string targetCode = csdoc.GeneratedCode;
if (string.IsNullOrEmpty(targetCode) && csdoc.Diagnostics.Count != 0)
{
return(null);
}
var invalidAttrChars = new char[] { '@', '/', '\\' };
foreach (string eachline in targetCode.Split('\n'))
{
var line = eachline.Trim();
if (line.StartsWith("__builder.AddAttribute"))
{
int p1 = line.IndexOf('"') + 1;
int p2 = line.IndexOf('"', p1);
var attrname = line.Substring(p1, p2 - p1);
if (attrname.IndexOfAny(invalidAttrChars) != -1)
{
throw new Exception("Invalid attribute name [" + attrname + "]");
}
}
}
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
var st = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(csdoc.GeneratedCode);
var csc = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("new" + DateTime.Now.Ticks)
.WithOptions(new Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary))
.AddSyntaxTrees(st)
.AddReferences(refs);
System.IO.MemoryStream ms = new System.IO.MemoryStream();
var result = csc.Emit(ms);
if (!result.Success)
{
throw new Exception(result.Diagnostics.First(v => v.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Error).ToString());
}
return(ms.ToArray());
}
public void Execute(GeneratorExecutionContext context)
{
var configuration = RazorConfiguration.Default;
var compilation = context.Compilation;
// TODO: Figure these out.
var projectDirectory = @"C:\Users\prkrishn\source\repos\ClassLibrary2\ConsoleApp2\";
var rootNamespace = "ConsoleApp2";
var tagHelperFeature = new CompilationTagHelperFeature(() => compilation);
var discoveryProjectEngine = RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Create(projectDirectory), b =>
{
b.Features.Add((IRazorFeature)Activator.CreateInstance(typeof(CompilerFeatures).Assembly.GetType("Microsoft.CodeAnalysis.Razor.DefaultTypeNameFeature")));
b.Features.Add(new SetSuppressPrimaryMethodBodyOptionFeature());
b.Features.Add(new SuppressChecksumOptionsFeature());
b.SetRootNamespace(rootNamespace);
var metadataReferences = new List <MetadataReference>(context.Compilation.References);
b.Features.Add(new DefaultMetadataReferenceFeature {
References = metadataReferences
});
b.Features.Add(tagHelperFeature);
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion);
});
foreach (var file in context.AdditionalFiles.Where(f => f.Path.EndsWith(".razor", StringComparison.OrdinalIgnoreCase)))
{
var codeGen = discoveryProjectEngine.Process(discoveryProjectEngine.FileSystem.GetItem(file.Path, FileKinds.Component));
compilation = compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(codeGen.GetCSharpDocument().GeneratedCode));
}
var tagHelpers = tagHelperFeature.GetDescriptors();
var projectEngine = RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Create(projectDirectory), b =>
{
b.Features.Add((IRazorFeature)Activator.CreateInstance(typeof(CompilerFeatures).Assembly.GetType("Microsoft.CodeAnalysis.Razor.DefaultTypeNameFeature")));
b.SetRootNamespace(rootNamespace);
b.Features.Add(new StaticTagHelperFeature {
TagHelpers = tagHelpers,
});
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion);
});
foreach (var file in context.AdditionalFiles.Where(f => f.Path.EndsWith(".razor", StringComparison.OrdinalIgnoreCase)))
{
var codeGen = projectEngine.Process(projectEngine.FileSystem.GetItem(file.Path, FileKinds.Component));
var path = file.Path.Replace(':', '_').Replace('\\', '_').Replace('/', '_');
context.AddSource(path, SourceText.From(codeGen.GetCSharpDocument().GeneratedCode, Encoding.UTF8));
}
}
private async Task <Project> OpenProjectWithRazorFileAsync(string projectDirectory)
{
Project project = null;
var projectFilePath = Directory.GetFiles(projectDirectory, "*.csproj", SearchOption.TopDirectoryOnly).FirstOrDefault();
if (projectFilePath == null)
{
return(project);
}
var razorFiles = Directory.GetFiles(Path.Combine(projectDirectory), "*.cshtml", SearchOption.AllDirectories);
var razorCSCodes = new string[razorFiles.Length];
IEnumerable <MetadataReference> references = Array.Empty <MetadataReference>();
using (var msbws = MSBuildWorkspace.Create())
{
msbws.SkipUnrecognizedProjects = true;
msbws.LoadMetadataForReferencedProjects = true;
msbws.WorkspaceFailed += (object sender, WorkspaceDiagnosticEventArgs e) => Console.WriteLine("ERR" + ":" + e.Diagnostic.Message);
// load project file
project = await msbws.OpenProjectAsync(projectDirectory);
var compilation = await project.GetCompilationAsync();
Console.WriteLine("-------------------------------------------");
var diagnostics = msbws.Diagnostics;
foreach (var diagnostic in diagnostics)
{
Console.WriteLine(diagnostic.Message);
}
references = compilation.References;
}
// discover tagHelpers
var fileSystem = RazorProjectFileSystem.Create(projectDirectory);
var engine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, b =>
{
b.Features.Add(new DefaultMetadataReferenceFeature()
{
References = references.ToList()
});
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
});
var feature = engine.Engine.Features.OfType <ITagHelperFeature>().Single();
var tagHelpers = feature.GetDescriptors();
// generate C# code
var razorConfiguration = RazorConfiguration.Create(
RazorLanguageVersion.Latest,
"MVC-3.0",
new[] { new AssemblyExtension("MVC-3.0", typeof(RazorExtensions).Assembly) });
engine = RazorProjectEngine.Create(razorConfiguration, fileSystem, b =>
{
b.Features.Add(new StaticTagHelperFeature()
{
TagHelpers = tagHelpers,
});
//CompilerFeatures.Register(b);
});
foreach (var file in razorFiles)
{
var item = engine.FileSystem.GetItem(file, "cshtml");
var razorCode = engine.Process(item).GetCSharpDocument().GeneratedCode;
project = project.AddDocument(Path.ChangeExtension(Path.GetRandomFileName(), ".cshtml.g.cs"), razorCode).Project;
}
return(project);
}
