public async Task <IEnumerable <DirectiveDescriptor> > GetRazorEngineDirectivesAsync(Workspace workspace, Project project, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var client = await RazorLanguageServiceClientFactory.CreateAsync(workspace, cancellationToken);
using (var session = await client.CreateSessionAsync(project.Solution))
{
var directives = await session.InvokeAsync <IEnumerable <DirectiveDescriptor> >(
"GetDirectivesAsync",
new object[] { project.Id.Id, "Foo", },
cancellationToken)
.ConfigureAwait(false);
return(directives);
}
}
catch (Exception exception)
{
throw new RazorLanguageServiceException(
typeof(DefaultRazorEngineDirectiveResolver).FullName,
nameof(GetRazorEngineDirectivesAsync),
exception);
}
}
public async Task <RazorEngineDocument> GenerateDocumentAsync(Workspace workspace, Project project, string filePath, string text, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var client = await RazorLanguageServiceClientFactory.CreateAsync(workspace, cancellationToken);
using (var session = await client.CreateSessionAsync(project.Solution))
{
var document = await session.InvokeAsync <RazorEngineDocument>(
"GenerateDocumentAsync",
new object[] { project.Id.Id, "Foo", filePath, text },
cancellationToken)
.ConfigureAwait(false);
return(document);
}
}
catch (Exception exception)
{
throw new RazorLanguageServiceException(
typeof(DefaultRazorEngineDocumentGenerator).FullName,
nameof(GenerateDocumentAsync),
exception);
}
}
public async Task <TagHelperResolutionResult> GetTagHelpersAsync(Project project)
{
try
{
TagHelperResolutionResult result;
// We're being overly defensive here because the OOP host can return null for the client/session/operation
// when it's disconnected (user stops the process).
//
// This will change in the future to an easier to consume API but for VS RTM this is what we have.
var client = await RazorLanguageServiceClientFactory.CreateAsync(Workspace, CancellationToken.None);
if (client != null)
{
using (var session = await client.CreateSessionAsync(project.Solution))
{
if (session != null)
{
var jsonObject = await session.InvokeAsync <JObject>(
"GetTagHelpersAsync",
new object[] { project.Id.Id, "Foo", },
CancellationToken.None
).ConfigureAwait(false);
result = GetTagHelperResolutionResult(jsonObject);
if (result != null)
{
return(result);
}
}
}
}
// The OOP host is turned off, so let's do this in process.
var compilation = await project.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false);
result = GetTagHelpers(compilation, designTime: true);
return(result);
}
catch (Exception exception)
{
var log = GetActivityLog();
if (log != null)
{
var hr = log.LogEntry(
(uint)__ACTIVITYLOG_ENTRYTYPE.ALE_ERROR,
"Razor Language Services",
$"Error discovering TagHelpers:{Environment.NewLine}{exception}");
ErrorHandler.ThrowOnFailure(hr);
}
throw new RazorLanguageServiceException(
typeof(DefaultTagHelperResolver).FullName,
nameof(GetTagHelpersAsync),
exception);
}
}
public async Task <TagHelperResolutionResult> GetTagHelpersAsync(Project project)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
try
{
TagHelperResolutionResult result;
// We're being overly defensive here because the OOP host can return null for the client/session/operation
// when it's disconnected (user stops the process).
//
// This will change in the future to an easier to consume API but for VS RTM this is what we have.
var client = await RazorLanguageServiceClientFactory.CreateAsync(_workspace, CancellationToken.None);
if (client != null)
{
using (var session = await client.CreateSessionAsync(project.Solution))
{
if (session != null)
{
var jsonObject = await session.InvokeAsync <JObject>(
"GetTagHelpersAsync",
new object[] { project.Id.Id, "Foo", },
CancellationToken.None).ConfigureAwait(false);
result = GetTagHelperResolutionResult(jsonObject);
if (result != null)
{
return(result);
}
}
}
}
// The OOP host is turned off, so let's do this in process.
var compilation = await project.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false);
result = GetTagHelpers(compilation);
return(result);
}
catch (Exception exception)
{
_errorReporter.ReportError(exception, project);
throw new InvalidOperationException(
Resources.FormatUnexpectedException(
typeof(DefaultTagHelperResolver).FullName,
nameof(GetTagHelpersAsync)),
exception);
}
}
public override async Task <TagHelperResolutionResult> GetTagHelpersAsync(Project project, CancellationToken cancellationToken)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
try
{
TagHelperResolutionResult result = null;
// We're being defensive here because the OOP host can return null for the client/session/operation
// when it's disconnected (user stops the process).
var client = await RazorLanguageServiceClientFactory.CreateAsync(_workspace, cancellationToken);
if (client != null)
{
using (var session = await client.CreateSessionAsync(project.Solution))
{
if (session != null)
{
var jsonObject = await session.InvokeAsync <JObject>(
"GetTagHelpersAsync",
new object[] { project.Id.Id, "Foo", },
cancellationToken).ConfigureAwait(false);
result = GetTagHelperResolutionResult(jsonObject);
}
}
}
if (result == null)
{
// Was unable to get tag helpers OOP, fallback to default behavior.
result = await _defaultResolver.GetTagHelpersAsync(project, cancellationToken);
}
return(result);
}
catch (Exception exception)
{
throw new InvalidOperationException(
Resources.FormatUnexpectedException(
typeof(DefaultTagHelperResolver).FullName,
nameof(GetTagHelpersAsync)),
exception);
}
}
protected virtual async Task <TagHelperResolutionResult> ResolveTagHelpersOutOfProcessAsync(IProjectEngineFactory factory, ProjectSnapshot project)
{
// We're being overly defensive here because the OOP host can return null for the client/session/operation
// when it's disconnected (user stops the process).
//
// This will change in the future to an easier to consume API but for VS RTM this is what we have.
try
{
var client = await RazorLanguageServiceClientFactory.CreateAsync(_workspace, CancellationToken.None);
if (client != null)
{
using (var session = await client.CreateSessionAsync(project.WorkspaceProject.Solution))
{
if (session != null)
{
var args = new object[]
{
Serialize(project),
factory == null ? null : factory.GetType().AssemblyQualifiedName,
};
var json = await session.InvokeAsync <JObject>("GetTagHelpersAsync", args, CancellationToken.None).ConfigureAwait(false);
return(Deserialize(json));
}
}
}
}
catch (Exception ex)
{
// We silence exceptions from the OOP host because we don't want to bring down VS for an OOP failure.
// We will retry all failures in process anyway, so if there's a real problem that isn't unique to OOP
// then it will report a crash in VS.
_errorReporter.ReportError(ex, project);
}
return(null);
}