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 Task ExecuteAsync(ViewComponentContext context) { return Task.FromResult(0); }
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)); }