private static ViewComponentContext GetViewComponentContext(IView view, Stream stream)
{
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider());
var viewContext = new ViewContext(
actionContext,
view,
viewData,
new TempDataDictionary(httpContext, new SessionStateTempDataProvider()),
TextWriter.Null,
new HtmlHelperOptions());
var writer = new StreamWriter(stream) { AutoFlush = true };
var viewComponentDescriptor = new ViewComponentDescriptor()
{
Type = typeof(object),
};
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new Dictionary<string, object>(),
new HtmlTestEncoder(),
viewContext,
writer);
return viewComponentContext;
}
/// <inheritdoc />
// We don't currently make use of the descriptor or the arguments here (they are available on the context).
// We might do this some day to cache which method we select, so resist the urge to 'clean' this without
// considering that possibility.
public IViewComponentInvoker CreateInstance(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return new Invoker(
_typeActivatorCache,
_viewComponentActivator,
_diagnosticSource,
_logger);
}
private static ViewComponentContext GetViewComponentContext(IView view, Stream stream)
{
var actionContext = new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor());
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider());
var viewContext = new ViewContext(actionContext, view, viewData, null, TextWriter.Null);
var writer = new StreamWriter(stream) { AutoFlush = true };
var viewComponentDescriptor = new ViewComponentDescriptor()
{
Type = typeof(object),
};
var viewComponentContext = new ViewComponentContext(viewComponentDescriptor, new object[0], viewContext, writer);
return viewComponentContext;
}
/// <summary>
/// Writes the <see cref="EncodedContent"/>.
/// </summary>
/// <param name="context">The <see cref="ViewComponentContext"/>.</param>
public void Execute(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var htmlWriter = context.Writer as HtmlTextWriter;
if (htmlWriter == null)
{
throw new Exception("");
//EncodedContent.WriteTo(context.Writer, context.HtmlEncoder);
}
else
{
htmlWriter.Write(EncodedContent);
}
}
public static void AfterViewComponent(
this DiagnosticSource diagnosticSource,
ViewComponentContext context,
IViewComponentResult result,
object viewComponent)
{
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterViewComponent"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.AfterViewComponent",
new
{
actionDescriptor = context.ViewContext.ActionDescriptor,
viewComponentContext = context,
viewComponentResult = result,
viewComponent = viewComponent
});
}
}
public async Task InvokeAsync(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var executor = _viewComponentInvokerCache.GetViewComponentMethodExecutor(context);
var returnType = executor.MethodReturnType;
if (returnType == typeof(void) || returnType == typeof(Task))
{
throw new InvalidOperationException(Resources.ViewComponent_MustReturnValue);
}
IViewComponentResult result;
object?component = null;
try
{
component = _viewComponentFactory.CreateViewComponent(context);
if (executor.IsMethodAsync)
{
result = await InvokeAsyncCore(executor, component, context);
}
else
{
// We support falling back to synchronous if there is no InvokeAsync method, in this case we'll still
// execute the IViewResult asynchronously.
result = InvokeSyncCore(executor, component, context);
}
}
finally
{
if (component != null)
{
await _viewComponentFactory.ReleaseViewComponentAsync(context, executor);
}
}
await result.ExecuteAsync(context);
}
/// <summary>
/// Locates and renders a view specified by <see cref="ViewName"/>. If <see cref="ViewName"/> is <c>null</c>,
/// then the view name searched for is<c>"Default"</c>.
/// </summary>
/// <param name="context">The <see cref="ViewComponentContext"/> for the current component execution.</param>
/// <returns>A <see cref="Task"/> which will complete when view rendering is completed.</returns>
public async Task ExecuteAsync(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
string viewName = ViewName;
if (string.IsNullOrEmpty(viewName))
{
viewName = context.ViewComponentDescriptor.ShortName;
}
var viewEngine = ViewEngine ?? ResolveViewEngine(context);
var viewContext = context.ViewContext;
// If view name was passed in is already a path, the view engine will handle this.
ViewEngineResult result = viewEngine.GetView(viewContext.ExecutingFilePath, viewName, false);
if (result == null || !result.Success)
{
// This will produce a string like:
//
// Views/Shared/Components/Cart.cshtml
//
result = viewEngine.FindView(viewContext, string.Format(CultureInfo.InvariantCulture, "Components/{0}", viewName), false);
}
var view = result.EnsureSuccessful(result.SearchedLocations).View;
using (view as IDisposable)
{
var childViewContext = new ViewContext(
viewContext,
view,
ViewData ?? context.ViewData,
context.Writer);
await view.RenderAsync(childViewContext);
}
}
public static void ViewComponentExecuted(
this ILogger logger,
ViewComponentContext context,
long startTimestamp,
object result)
{
// Don't log if logging wasn't enabled at start of request as time will be wildly wrong.
if (startTimestamp != 0)
{
var currentTimestamp = Stopwatch.GetTimestamp();
var elapsed = new TimeSpan((long)(TimestampToTicks * (currentTimestamp - startTimestamp)));
_viewComponentExecuted(
logger,
context.ViewComponentDescriptor.DisplayName,
elapsed.TotalMilliseconds,
Convert.ToString(result),
null);
}
}
public void Constructor_PerformsDefensiveCopies()
{
// Arrange
var httpContext = new DefaultHttpContext();
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider());
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var viewContext = new ViewContext(
actionContext,
NullView.Instance,
viewData,
tempData,
TextWriter.Null,
new HtmlHelperOptions());
var viewComponentDescriptor = new ViewComponentDescriptor();
// Act
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new Dictionary <string, object>(),
new HtmlTestEncoder(),
viewContext,
TextWriter.Null);
// Assert
// New ViewContext but initial View and TextWriter copied over.
Assert.NotSame(viewContext, viewComponentContext.ViewContext);
Assert.Same(tempData, viewComponentContext.TempData);
Assert.Same(viewContext.View, viewComponentContext.ViewContext.View);
Assert.Same(viewContext.Writer, viewComponentContext.ViewContext.Writer);
// Double-check the convenience properties.
Assert.Same(viewComponentContext.ViewContext.ViewData, viewComponentContext.ViewData);
Assert.Same(viewComponentContext.ViewContext.TempData, viewComponentContext.TempData);
Assert.Same(viewComponentContext.ViewContext.Writer, viewComponentContext.Writer);
// New VDD instance but initial ModelMetadata copied over.
Assert.NotSame(viewData, viewComponentContext.ViewData);
Assert.Same(viewData.ModelMetadata, viewComponentContext.ViewData.ModelMetadata);
}
public IViewComponentInvoker CreateInstance(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var renderingContext = context.ViewContext.HttpContext.GetCurrentRenderingWidgetContext();
if (renderingContext == null || !renderingContext.ShouldUseCustomInvoker)
{
//если стэка виджетов нет, или в нём нет отметки, что сейчас рендерится компонент как виджет структуры сайта
//используем стандартный Invoker для компонентов
return(GetDefaultInvoker(context));
}
//сейчас рендерится компонент как виджет структуры сайта
//это ясно по одноразовому флагу ShouldUseCustomInvoker, снимем его
renderingContext.ShouldUseCustomInvoker = false;
return(new WidgetViewComponentInvoker(_scope, GetDefaultInvoker(context)));
}
public void Invoke(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
//var method = ViewComponentMethodSelector.FindSyncMethod(
// context.ViewComponentDescriptor.Type.GetTypeInfo(),
// context.Arguments);
var method = context.ViewComponentDescriptor.Type.GetMethods().First(x => x.Name == "Invoke");
if (method == null)
{
throw new InvalidOperationException("SyncMethodName");
}
var result = InvokeSyncCore(method, context);
result.Execute(context);
}
/// <summary>
/// Registers dependencies, and injects them into new instances of view components in response to each request.
/// </summary>
/// <returns>A concrete instance of an <see cref="IController"/>.</returns>
public object Create(ViewComponentContext context) {
/*------------------------------------------------------------------------------------------------------------------------
| Determine view component type
\-----------------------------------------------------------------------------------------------------------------------*/
Type type = context.ViewComponentDescriptor.TypeInfo.AsType();
/*------------------------------------------------------------------------------------------------------------------------
| Configure and return appropriate view component
\-----------------------------------------------------------------------------------------------------------------------*/
if (type == typeof(MenuViewComponent)) {
return CreateMenuViewComponent(context);
}
else if (type == typeof(PageLevelNavigationViewComponent)) {
return CreatePageLevelNavigationViewComponent(context);
}
else {
throw new Exception($"Unknown view component {type.Name}");
}
}
private async Task <IHtmlContent> InvokeCoreAsync(ViewComponentDescriptor descriptor, object arguments)
{
var argumentDictionary = GetArgumentDictionary(descriptor, arguments);
var viewBuffer = new ViewBuffer(_viewBufferScope, descriptor.FullName, ViewBuffer.ViewComponentPageSize);
using (var writer = new ViewBufferTextWriter(viewBuffer, _viewContext.Writer.Encoding))
{
var context = new ViewComponentContext(descriptor, argumentDictionary, _htmlEncoder, _viewContext, writer);
var invoker = _invokerFactory.CreateInstance(context);
if (invoker == null)
{
throw new InvalidOperationException($"ViewComponentFactory_ReturnedNull:{descriptor.FullName}");
}
await invoker.InvokeAsync(context);
return(viewBuffer);
}
}
public async Task getCategoryViewComponent_Success()
{
//Arrange View Component
var httpContext = new DefaultHttpContext();
var viewContext = new ViewContext();
viewContext.HttpContext = httpContext;
var viewComponentContext = new ViewComponentContext();
viewComponentContext.ViewContext = viewContext;
//Arrange Mock Client
var categoryApiClientMock = new Mock <ICategoryApiClient>();
categoryApiClientMock.Setup(c => c.GetAllCategory()).Returns(getCategoriesValue());
var viewComponent = new CategoryViewComponent(categoryApiClientMock.Object);
//Act - Check final result is viewcomponent
var result = viewComponent.InvokeAsync();
var createdAtActionResult = await Assert.IsType <Task <IViewComponentResult> >(result);
}
/// <summary>
/// Locates and renders a module view specified by <see cref="ViewName"/>. If <see cref="ViewName"/> is <c>null</c>,
/// then the view name searched for is<c>"Default"</c>.
/// </summary>
/// <param name="context">The <see cref="ViewComponentContext"/> for the current component execution.</param>
/// <returns>A <see cref="Task"/> which will complete when view rendering is completed.</returns>
public async Task ExecuteAsync(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (ModuleDefinitionPath == null)
{
throw new ArgumentNullException(nameof(ModuleDefinitionPath));
}
IModuleViewEngine moduleViewEngine = ViewEngine ?? ResolveModuleViewEngine(context);
ViewContext viewContext = context.ViewContext;
bool isNullOrEmptyViewName = string.IsNullOrEmpty(ViewName);
IEnumerable <string> originalLocations = null;
string viewName = isNullOrEmptyViewName ? SiteConfiguration.DefaultModuleViewName : ViewName;
string qualifiedViewName = string.Format(
CultureInfo.InvariantCulture,
ModulePathFormat,
ModuleDefinitionPath,
viewName);
ViewEngineResult result = moduleViewEngine.FindModuleView(viewContext, qualifiedViewName);
IView view = result.EnsureSuccessful(originalLocations).View;
using (view as IDisposable)
{
var childViewContext = new ViewContext(
viewContext,
view,
ViewData ?? context.ViewData,
context.Writer);
await view.RenderAsync(childViewContext);
}
}
public void WithControllerContextShouldSetControllerContext()
{
var viewComponentContext = new ViewComponentContext
{
ViewComponentDescriptor = new ViewComponentDescriptor
{
TypeInfo = typeof(NormalComponent).GetTypeInfo()
}
};
MyViewComponent <NormalComponent>
.Instance()
.WithViewComponentContext(viewComponentContext)
.ShouldPassForThe <NormalComponent>(viewComponent =>
{
Assert.NotNull(viewComponent);
Assert.NotNull(viewComponent.ViewComponentContext);
Assert.Equal(
typeof(NormalComponent).GetTypeInfo(),
viewComponent.ViewComponentContext.ViewComponentDescriptor.TypeInfo);
});
}
/// <summary>
/// Registers dependencies, and injects them into new instances of view components in response to each request.
/// </summary>
/// <returns>A concrete instance of an <see cref="Controller"/>.</returns>
public object Create(ViewComponentContext context) {
/*------------------------------------------------------------------------------------------------------------------------
| Validate parameters
\-----------------------------------------------------------------------------------------------------------------------*/
Contract.Requires(context, nameof(context));
/*------------------------------------------------------------------------------------------------------------------------
| Determine view component type
\-----------------------------------------------------------------------------------------------------------------------*/
var type = context.ViewComponentDescriptor.TypeInfo.AsType();
/*------------------------------------------------------------------------------------------------------------------------
| Configure and return appropriate view component
\-----------------------------------------------------------------------------------------------------------------------*/
if (StandardEditorComposer.IsEditorComponent(type)) {
return _standardEditorComposer.ActivateEditorComponent(type, _topicRepository);
}
throw new InvalidOperationException($"Unknown view component {type.Name}");
}
public IViewComponentResult InvokeSyncCore(MethodInfo method, ViewComponentContext context)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var component = CreateComponent(context);
using (_logger.ViewComponentScope(context))
{
_diagnosticSource.BeforeViewComponent(context, component);
_logger.ViewComponentExecuting(context);
try
{
var startTime = Environment.TickCount;
var result = method.Invoke(component, context.Arguments);
var viewComponentResult = CoerceToViewComponentResult(result);
_logger.ViewComponentExecuted(context, startTime, viewComponentResult);
_diagnosticSource.AfterViewComponent(context, viewComponentResult, component);
return(viewComponentResult);
}
catch (TargetInvocationException ex)
{
// Preserve callstack of any user-thrown exceptions.
var exceptionInfo = ExceptionDispatchInfo.Capture(ex.InnerException);
exceptionInfo.Throw();
return(null); // Unreachable
}
}
}
public object Create(ViewComponentContext context)
{
var type = context.ViewComponentDescriptor.TypeInfo;
if (_constructorsCache.TryGetValue(type.AsType()
, out var constructor))
{
return(constructor.Invoke(new object[0]));
}
var cInfo = type.GetConstructors().OfType <ReflectedConstructorInfo>().FirstOrDefault();
if (cInfo == null)
{
throw new RuntimeException($"No constructor found in type {type}");
}
constructor = cInfo;
_constructorsCache[type] = constructor;
return(constructor.Invoke(new object[0]));;
}
/// <inheritdoc />
public object Create(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var componentType = context.ViewComponentDescriptor.TypeInfo;
if (componentType == null)
{
throw new ArgumentException(Resources.FormatPropertyOfTypeCannotBeNull(
nameof(context.ViewComponentDescriptor.TypeInfo),
nameof(context.ViewComponentDescriptor)));
}
var viewComponent = _typeActivatorCache.CreateInstance <object>(
context.ViewContext.HttpContext.RequestServices,
context.ViewComponentDescriptor.TypeInfo.AsType());
return(viewComponent);
}
public void ReleaseViewComponent_CallsDispose_OnTheInstance()
{
// Arrange
var context = new ViewComponentContext
{
};
var component = new ActivablePropertiesViewComponent();
var viewComponentActivator = new Mock <IViewComponentActivator>();
viewComponentActivator.Setup(vca => vca.Release(context, component))
.Callback <ViewComponentContext, object>((c, o) => (o as IDisposable)?.Dispose());
var factory = new DefaultViewComponentFactory(viewComponentActivator.Object);
// Act
factory.ReleaseViewComponent(context, component);
// Assert
Assert.True(component.Disposed);
}
/*==========================================================================================================================
| CONSTRUCTOR
\-------------------------------------------------------------------------------------------------------------------------*/
/// <summary>
/// Initializes a new instance of the <see cref="TopicControllerTest"/> with shared resources.
/// </summary>
/// <remarks>
/// This uses the <see cref="StubTopicRepository"/> to provide data, and then <see cref="CachedTopicRepository"/> to
/// manage the in-memory representation of the data. While this introduces some overhead to the tests, the latter is a
/// relatively lightweight façade to any <see cref="ITopicRepository"/>, and prevents the need to duplicate logic for
/// crawling the object graph. In addition, it initializes a shared <see cref="Topic"/> reference to use for the various
/// tests.
/// </remarks>
public TopicViewComponentTest() {
/*------------------------------------------------------------------------------------------------------------------------
| Establish dependencies
\-----------------------------------------------------------------------------------------------------------------------*/
_topicRepository = new CachedTopicRepository(new StubTopicRepository());
_topic = _topicRepository.Load("Root:Web:Web_3:Web_3_0")!;
_topicMappingService = new TopicMappingService(_topicRepository, new TopicViewModelLookupService());
/*------------------------------------------------------------------------------------------------------------------------
| Establish hierarchical topic mapping service
\-----------------------------------------------------------------------------------------------------------------------*/
_hierarchicalMappingService = new CachedHierarchicalTopicMappingService<NavigationTopicViewModel>(
new HierarchicalTopicMappingService<NavigationTopicViewModel>(
_topicRepository,
_topicMappingService
)
);
/*------------------------------------------------------------------------------------------------------------------------
| Establish view model context
\-----------------------------------------------------------------------------------------------------------------------*/
var routes = new RouteData();
routes.Values.Add("rootTopic", "Web");
routes.Values.Add("path", "Web_3/Web_3_0");
var viewContext = new ViewContext() {
HttpContext = new DefaultHttpContext(),
RouteData = routes
};
var viewComponentContext = new ViewComponentContext() {
ViewContext = viewContext
};
_context = viewComponentContext;
}
public async Task ReleaseViewComponentAsync_CallsDisposeAsync_OnAsyncDisposableComponents()
{
// Arrange
var context = new ViewComponentContext
{
};
var component = new AsyncDisposableViewComponent();
var viewComponentActivator = new Mock <IViewComponentActivator>();
viewComponentActivator.Setup(vca => vca.ReleaseAsync(context, component))
.Callback <ViewComponentContext, object>((c, o) => (o as IAsyncDisposable)?.DisposeAsync())
.Returns(default(ValueTask));
var factory = new DefaultViewComponentFactory(viewComponentActivator.Object);
// Act
await factory.ReleaseViewComponentAsync(context, component);
// Assert
Assert.True(component.Disposed);
}
public void ComponentShouldReadPropertiesFromSessionCorrectly()
{
//Arrange
var manager = new Mock <IContentfulOptionsManager>();
manager.SetupGet(c => c.Options).Returns(new ContentfulOptions
{
SpaceId = "43425",
UsePreviewApi = false
});
var mockSession = new Mock <ISession>();
byte[] dummy = Encoding.UTF8.GetBytes("Enabled");
mockSession.Setup(x => x.TryGetValue("EditorialFeatures", out dummy)).Returns(true);
var httpContext = new Mock <HttpContext>();
httpContext.SetupGet(c => c.Session).Returns(mockSession.Object);
var viewContext = new ViewContext();
viewContext.HttpContext = httpContext.Object;
var componentContext = new ViewComponentContext();
componentContext.ViewContext = viewContext;
var component = new EditorialFeaturesViewComponent(manager.Object);
component.ViewComponentContext = componentContext;
//Act
var res = component.Invoke(new[] { new SystemProperties {
Id = "3232"
} });
//Assert
Assert.IsType <ViewViewComponentResult>(res);
Assert.Equal("3232", ((res as ViewViewComponentResult).ViewData.Model as EditorialFeaturesModel).Sys.First().Id);
Assert.True(((res as ViewViewComponentResult).ViewData.Model as EditorialFeaturesModel).FeaturesEnabled);
}
public async Task InvokeAsync(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
IViewComponentResult result;
var asyncMethod = ViewComponentMethodSelector.FindAsyncMethod(
context.ViewComponentDescriptor.Type.GetTypeInfo(),
context.Arguments);
if (asyncMethod == null)
{
// We support falling back to synchronous if there is no InvokeAsync method, in this case we'll still
// execute the IViewResult asynchronously.
var syncMethod = ViewComponentMethodSelector.FindSyncMethod(
context.ViewComponentDescriptor.Type.GetTypeInfo(),
context.Arguments);
if (syncMethod == null)
{
throw new InvalidOperationException("AsyncMethodName");
}
else
{
result = InvokeSyncCore(syncMethod, context);
}
}
else
{
result = await InvokeAsyncCore(asyncMethod, context);
}
await result.ExecuteAsync(context);
}
public void CreateViewComponent_ActivatesProperties_OnTheInstance()
{
// Arrange
var context = new ViewComponentContext
{
};
var component = new ActivablePropertiesViewComponent();
var activator = new Mock <IViewComponentActivator>();
activator.Setup(a => a.Create(context))
.Returns(component);
var factory = new DefaultViewComponentFactory(activator.Object);
// Act
var result = factory.CreateViewComponent(context);
// Assert
var activablePropertiesComponent = Assert.IsType <ActivablePropertiesViewComponent>(result);
Assert.Same(component, activablePropertiesComponent);
Assert.Same(component.Context, activablePropertiesComponent.Context);
}
public void WithViewComponentContextWithoutViewContextShouldSetItToAccessor()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(services =>
{
services.AddSingleton <IActionContextAccessor, ActionContextAccessor>();
});
var context = new ViewComponentContext {
ViewContext = null
};
MyViewComponent <AccessorComponent>
.Instance()
.WithViewComponentContext(context)
.ShouldPassForThe <AccessorComponent>(viewComponent =>
{
Assert.NotNull(viewComponent);
Assert.NotNull(viewComponent.ViewContext);
});
MyApplication.StartsFrom <DefaultStartup>();
}
public object Create(ViewComponentContext context) => this.viewComponentCreator(context.ViewComponentDescriptor.TypeInfo.AsType());
public void Execute(ViewComponentContext context)
{
}
private static ViewComponentContext GetViewComponentContext(IView view, ViewDataDictionary viewData, object diagnosticListener = null)
{
var diagnosticSource = new DiagnosticListener("Microsoft.AspNet");
if (diagnosticListener == null)
{
diagnosticListener = new TestDiagnosticListener();
}
diagnosticSource.SubscribeWithAdapter(diagnosticListener);
var serviceProvider = new Mock<IServiceProvider>();
serviceProvider.Setup(s => s.GetService(typeof(DiagnosticSource))).Returns(diagnosticSource);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = serviceProvider.Object;
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewContext = new ViewContext(
actionContext,
view,
viewData,
new TempDataDictionary(new HttpContextAccessor(), new SessionStateTempDataProvider()),
TextWriter.Null,
new HtmlHelperOptions());
var viewComponentDescriptor = new ViewComponentDescriptor()
{
Type = typeof(object),
};
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new object[0],
viewContext,
TextWriter.Null);
return viewComponentContext;
}
private static ViewComponentContext GetViewComponentContext(IView view, ViewDataDictionary viewData)
{
var actionContext = new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor());
var viewContext = new ViewContext(
actionContext,
view,
viewData,
null,
TextWriter.Null,
new HtmlHelperOptions());
var viewComponentDescriptor = new ViewComponentDescriptor()
{
Type = typeof(object),
};
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new object[0],
viewContext,
TextWriter.Null);
return viewComponentContext;
}
private static ViewComponentContext GetViewComponentContext(
IView view,
ViewDataDictionary viewData,
object diagnosticListener = null)
{
var diagnosticSource = new DiagnosticListener("Microsoft.AspNet");
if (diagnosticListener == null)
{
diagnosticListener = new TestDiagnosticListener();
}
diagnosticSource.SubscribeWithAdapter(diagnosticListener);
var serviceProvider = new Mock<IServiceProvider>();
serviceProvider.Setup(s => s.GetService(typeof(DiagnosticSource))).Returns(diagnosticSource);
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = serviceProvider.Object;
var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());
var viewContext = new ViewContext(
actionContext,
view,
viewData,
new TempDataDictionary(httpContext, new SessionStateTempDataProvider()),
TextWriter.Null,
new HtmlHelperOptions());
var viewComponentDescriptor = new ViewComponentDescriptor()
{
ShortName = "Invoke",
Type = typeof(object),
MethodInfo = typeof(object).GetTypeInfo().DeclaredMethods.First()
};
var viewComponentContext = new ViewComponentContext(
viewComponentDescriptor,
new Dictionary<string, object>(),
new HtmlTestEncoder(),
viewContext,
TextWriter.Null);
return viewComponentContext;
}
public static IDisposable?ViewComponentScope(ILogger logger, ViewComponentContext context)
{
return(logger.BeginScope(new ViewComponentLogScope(context.ViewComponentDescriptor)));
}
private static IViewEngine ResolveViewEngine(ViewComponentContext context)
{
return context.ViewContext.HttpContext.RequestServices.GetRequiredService<ICompositeViewEngine>();
}
public void Invoke(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
//var method = ViewComponentMethodSelector.FindSyncMethod(
// context.ViewComponentDescriptor.Type.GetTypeInfo(),
// context.Arguments);
var method = context.ViewComponentDescriptor.Type.GetMethods().First(x => x.Name == "Invoke");
if (method == null)
{
throw new InvalidOperationException("SyncMethodName");
}
var result = InvokeSyncCore(method, context);
result.Execute(context);
}
public Task ExecuteAsync(ViewComponentContext context)
{
return Task.FromResult(0);
}
public void Execute(ViewComponentContext context) { }
public async Task InvokeAsync(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
IViewComponentResult result;
var asyncMethod = ViewComponentMethodSelector.FindAsyncMethod(
context.ViewComponentDescriptor.Type.GetTypeInfo(),
context.Arguments);
if (asyncMethod == null)
{
// We support falling back to synchronous if there is no InvokeAsync method, in this case we'll still
// execute the IViewResult asynchronously.
var syncMethod = ViewComponentMethodSelector.FindSyncMethod(
context.ViewComponentDescriptor.Type.GetTypeInfo(),
context.Arguments);
if (syncMethod == null)
{
throw new InvalidOperationException("AsyncMethodName");
}
else
{
result = InvokeSyncCore(syncMethod, context);
}
}
else
{
result = await InvokeAsyncCore(asyncMethod, context);
}
await result.ExecuteAsync(context);
}
private object CreateComponent(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var services = context.ViewContext.HttpContext.RequestServices;
var component = _typeActivatorCache.CreateInstance<object>(
services,
context.ViewComponentDescriptor.Type);
_viewComponentActivator.Activate(component, context);
return component;
}
/// <summary>
/// Writes the <see cref="EncodedContent"/>.
/// </summary>
/// <param name="context">The <see cref="ViewComponentContext"/>.</param>
/// <returns>A completed <see cref="Task"/>.</returns>
public Task ExecuteAsync(ViewComponentContext context)
{
Execute(context);
return Microsoft.AspNet.Mvc.Internal.TaskCache.CompletedTask;
}
/// <inheritdoc />
public virtual void Release(ViewComponentContext context, object viewComponent)
{
}
private async Task<IViewComponentResult> InvokeAsyncCore(
MethodInfo method,
ViewComponentContext context)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var component = CreateComponent(context);
using (_logger.ViewComponentScope(context))
{
_diagnosticSource.BeforeViewComponent(context, component);
_logger.ViewComponentExecuting(context);
var startTime = Environment.TickCount;
var result = await ControllerActionExecutor.ExecuteAsync(method, component, context.Arguments);
var viewComponentResult = CoerceToViewComponentResult(result);
_logger.ViewComponentExecuted(context, startTime, viewComponentResult);
_diagnosticSource.AfterViewComponent(context, viewComponentResult, component);
return viewComponentResult;
}
}
public void Release(ViewComponentContext context, object viewComponent) => this.viewComponentReleaser(viewComponent);
public IViewComponentResult InvokeSyncCore(MethodInfo method, ViewComponentContext context)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var component = CreateComponent(context);
using (_logger.ViewComponentScope(context))
{
_diagnosticSource.BeforeViewComponent(context, component);
_logger.ViewComponentExecuting(context);
try
{
var startTime = Environment.TickCount;
var result = method.Invoke(component, context.Arguments);
var viewComponentResult = CoerceToViewComponentResult(result);
_logger.ViewComponentExecuted(context, startTime, viewComponentResult);
_diagnosticSource.AfterViewComponent(context, viewComponentResult, component);
return viewComponentResult;
}
catch (TargetInvocationException ex)
{
// Preserve callstack of any user-thrown exceptions.
var exceptionInfo = ExceptionDispatchInfo.Capture(ex.InnerException);
exceptionInfo.Throw();
return null; // Unreachable
}
}
}
public Task ExecuteAsync(ViewComponentContext context)
{
return(Task.FromResult(0));
}
/// <summary>
/// Writes the <see cref="EncodedContent"/>.
/// </summary>
/// <param name="context">The <see cref="ViewComponentContext"/>.</param>
public void Execute(ViewComponentContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var htmlWriter = context.Writer as HtmlTextWriter;
if (htmlWriter == null)
{
throw new Exception("");
//EncodedContent.WriteTo(context.Writer, context.HtmlEncoder);
}
else
{
htmlWriter.Write(EncodedContent);
}
}
