/// <summary>
/// Returns a new <see cref="ICSharpProvider"/> associated to the
/// <see cref="CSharpLanguage">C♯ language</see> relative
/// to the <paramref name="version"/>.
/// </summary>
/// <param name="version">The <see cref="CSharpLanguageVersion"/>
/// value which denotes what version of the language to return
/// the provider for.</param>
/// <returns>A new <see cref="ICSharpProvider"/> for the
/// <see cref="CSharpLanguage">C♯ language</see>.</returns>
public ICSharpProvider GetProvider(CSharpLanguageVersion version)
{
CliFrameworkVersion frameworkVersion = CliGateway.CurrentVersion;
switch (version)
{
case CSharpLanguageVersion.Version2:
frameworkVersion = CliFrameworkVersion.v2_0_50727;
break;
case CSharpLanguageVersion.Version3:
frameworkVersion = CliFrameworkVersion.v3_5;
break;
case CSharpLanguageVersion.Version4:
frameworkVersion = CliFrameworkVersion.v4_0_30319;
break;
case CSharpLanguageVersion.Version5:
frameworkVersion = CliFrameworkVersion.v4_5;
break;
case CSharpLanguageVersion.Version6:
frameworkVersion = CliFrameworkVersion.v4_6;
break;
default:
throw new ArgumentOutOfRangeException("version");
}
return(this.GetProvider(version, new IntermediateCliManager(IntermediateCliGateway.GetRuntimeEnvironmentInfo(CliGateway.CurrentPlatform, frameworkVersion))));
}
public CompilerSupport GetCompilerSupport(CSharpLanguageVersion version)
{
CompilerSupport result = CompilerSupport.FullSupport ^ (CompilerSupport.Win32Resources | CompilerSupport.PrimaryInteropEmbedding | CompilerSupport.StructuralTyping);
if (((int)version) >= (int)CSharpLanguageVersion.Version4)
{
result |= CompilerSupport.PrimaryInteropEmbedding;
}
return(result);
}
private int ExecuteCore(
RazorConfiguration configuration,
string projectDirectory,
string tagHelperManifest,
SourceItem[] sourceItems)
{
tagHelperManifest = Path.Combine(projectDirectory, tagHelperManifest);
var tagHelpers = GetTagHelpers(tagHelperManifest);
var compositeFileSystem = new CompositeRazorProjectFileSystem(new[]
{
GetVirtualRazorProjectSystem(sourceItems),
RazorProjectFileSystem.Create(projectDirectory),
});
var success = true;
var engine = RazorProjectEngine.Create(configuration, compositeFileSystem, b =>
{
b.Features.Add(new StaticTagHelperFeature()
{
TagHelpers = tagHelpers,
});
b.Features.Add(new DefaultTypeNameFeature());
if (GenerateDeclaration.HasValue())
{
b.Features.Add(new SetSuppressPrimaryMethodBodyOptionFeature());
}
if (RootNamespace.HasValue())
{
b.SetRootNamespace(RootNamespace.Value());
}
if (CSharpLanguageVersion.HasValue())
{
// Only set the C# language version if one was specified, otherwise it defaults to whatever
// value was set in the corresponding RazorConfiguration's extensions.
var rawLanguageVersion = CSharpLanguageVersion.Value();
if (LanguageVersionFacts.TryParse(rawLanguageVersion, out var csharpLanguageVersion))
{
b.SetCSharpLanguageVersion(csharpLanguageVersion);
}
else
{
success = false;
Error.WriteLine($"Unknown C# language version {rawLanguageVersion}.");
}
}
});
var results = GenerateCode(engine, sourceItems);
foreach (var result in results)
{
var errorCount = result.CSharpDocument.Diagnostics.Count;
for (var i = 0; i < errorCount; i++)
{
var error = result.CSharpDocument.Diagnostics[i];
if (error.Severity == RazorDiagnosticSeverity.Error)
{
success = false;
}
if (i < 100)
{
Error.WriteLine(error.ToString());
// Only show the first 100 errors to prevent massive string allocations.
if (i == 99)
{
Error.WriteLine($"And {errorCount - i + 1} more warnings/errors.");
}
}
}
if (success)
{
// Only output the file if we generated it without errors.
var outputFilePath = result.InputItem.OutputPath;
File.WriteAllText(outputFilePath, result.CSharpDocument.GeneratedCode);
}
}
return(success ? ExitCodeSuccess : ExitCodeFailureRazorError);
}
public ICSharpProvider GetProvider(CSharpLanguageVersion version, IIntermediateCliManager identityManager)
{
return(new CSharpProvider(version, identityManager));
}
/// <summary>
/// Creates a new <see cref="IIntermediateAssembly"/> with the <paramref name="name"/> and
/// <paramref name="version"/> provided.
/// </summary>
/// <param name="name">The <see cref="String"/> value representing part of the identity of the assembly.</param>
/// <param name="identityManager">The <see cref="IIntermediateCliManager"/> which is used to marshal type identities
/// in the current type model.</param>
/// <param name="version">The <see cref="CSharpLanguageVersion"/> to which the <see cref="ICSharpAssembly"/>
/// is built against.</param>
/// <returns>A new <see cref="ICSharpAssembly"/>
/// with the <paramref name="name"/> and <paramref name="version"/> provided.</returns>
/// <exception cref="System.ArgumentNullException">thrown when <paramref name="name"/> is null.</exception>
/// <exception cref="System.ArgumentException">thrown when <paramref name="name"/> is <see cref="String.Empty"/>
/// or <paramref name="version"/> is not one of <see cref="CSharpLanguageVersion"/>.</exception>
public ICSharpAssembly CreateAssembly(string name, IIntermediateCliManager identityManager, CSharpLanguageVersion version)
{
var provider = this.GetProvider(version);
IIntermediateAssemblyCtorLanguageService <ICSharpProvider, ICSharpLanguage, ICSharpAssembly> creatorService;
if (provider.TryGetService <IIntermediateAssemblyCtorLanguageService <ICSharpProvider, ICSharpLanguage, ICSharpAssembly> >(LanguageGuids.Services.IntermediateAssemblyCreatorService, out creatorService))
{
return(creatorService.New(name));
}
var resultAssembly = new CSharpAssembly(name, provider, provider.IdentityManager.RuntimeEnvironment);
provider.IdentityManager.AssemblyCreated(resultAssembly);
return(resultAssembly);
}
IVersionedLanguageProvider <CSharpLanguageVersion> IVersionedLanguage <CSharpLanguageVersion> .GetProvider(CSharpLanguageVersion version)
{
return(GetProvider(version));
}
