huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

#265 Remove Use extensions that take services.

This commit is contained in:
Chris R 2015-05-06 15:31:16 -07:00
parent f7f4d490aa
commit 550b2252ea
2 changed files with 0 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
src/Microsoft.AspNet.Http.Abstractions/Extensions/UseExtensions.cs
View File

@ -26,125 +26,5 @@ namespace Microsoft.AspNet.Builder
}; };
}); });
} }
/// <summary>
/// Use middleware defined in-line
/// </summary>
/// <typeparam name="TService1">Per-request service required by middleware</typeparam>
/// <param name="app"></param>
/// <param name="middleware">A function that handles the request or calls the given next function.</param>
/// <returns></returns>
public static IApplicationBuilder Use<TService1>(this IApplicationBuilder app, Func<HttpContext, Func<Task>, TService1, Task> middleware)
{
var applicationServices = app.ApplicationServices;
return app.Use(next => context =>
{
var serviceProvider = context.RequestServices ?? context.ApplicationServices ?? applicationServices;
if (serviceProvider == null)
{
throw new Exception("TODO: IServiceProvider is not available");
}
return middleware(
context,
() => next(context),
GetRequiredService<TService1>(serviceProvider));
});
}
/// <summary>
/// Use middleware defined in-line
/// </summary>
/// <typeparam name="TService1">Per-request service required by middleware</typeparam>
/// <typeparam name="TService2">Per-request service required by middleware</typeparam>
/// <param name="app"></param>
/// <param name="middleware">A function that handles the request or calls the given next function.</param>
/// <returns></returns>
public static IApplicationBuilder Use<TService1, TService2>(this IApplicationBuilder app, Func<HttpContext, Func<Task>, TService1, TService2, Task> middleware)
{
var applicationServices = app.ApplicationServices;
return app.Use(next => context =>
{
var serviceProvider = context.RequestServices ?? context.ApplicationServices ?? applicationServices;
if (serviceProvider == null)
{
throw new Exception("TODO: IServiceProvider is not available");
}
return middleware(
context,
() => next(context),
GetRequiredService<TService1>(serviceProvider),
GetRequiredService<TService2>(serviceProvider));
});
}
/// <summary>
/// Use middleware defined in-line
/// </summary>
/// <typeparam name="TService1">Per-request service required by middleware</typeparam>
/// <typeparam name="TService2">Per-request service required by middleware</typeparam>
/// <typeparam name="TService3">Per-request service required by middleware</typeparam>
/// <param name="app"></param>
/// <param name="middleware">A function that handles the request or calls the given next function.</param>
/// <returns></returns>
public static IApplicationBuilder Use<TService1, TService2, TService3>(this IApplicationBuilder app, Func<HttpContext, Func<Task>, TService1, TService2, TService3, Task> middleware)
{
var applicationServices = app.ApplicationServices;
return app.Use(next => context =>
{
var serviceProvider = context.RequestServices ?? context.ApplicationServices ?? applicationServices;
if (serviceProvider == null)
{
throw new Exception("TODO: IServiceProvider is not available");
}
return middleware(
context,
() => next(context),
GetRequiredService<TService1>(serviceProvider),
GetRequiredService<TService2>(serviceProvider),
GetRequiredService<TService3>(serviceProvider));
});
}
/// <summary>
/// Use middleware defined in-line
/// </summary>
/// <typeparam name="TService1">Per-request service required by middleware</typeparam>
/// <typeparam name="TService2">Per-request service required by middleware</typeparam>
/// <typeparam name="TService3">Per-request service required by middleware</typeparam>
/// <typeparam name="TService4">Per-request service required by middleware</typeparam>
/// <param name="app"></param>
/// <param name="middleware">A function that handles the request or calls the given next function.</param>
/// <returns></returns>
public static IApplicationBuilder Use<TService1, TService2, TService3, TService4>(this IApplicationBuilder app, Func<HttpContext, Func<Task>, TService1, TService2, TService3, TService4, Task> middleware)
{
var applicationServices = app.ApplicationServices;
return app.Use(next => context =>
{
var serviceProvider = context.RequestServices ?? context.ApplicationServices ?? applicationServices;
if (serviceProvider == null)
{
throw new Exception("TODO: IServiceProvider is not available");
}
return middleware(
context,
() => next(context),
GetRequiredService<TService1>(serviceProvider),
GetRequiredService<TService2>(serviceProvider),
GetRequiredService<TService3>(serviceProvider),
GetRequiredService<TService4>(serviceProvider));
});
}
private static TService GetRequiredService<TService>(IServiceProvider serviceProvider)
{
var service = (TService)serviceProvider.GetService(typeof(TService));
if (service == null)
{
throw new Exception(string.Format("TODO: No service for type '{0}' has been registered.", typeof(TService)));
}
return service;
}
} }
} }

138
test/Microsoft.AspNet.Http.Extensions.Tests/UseWithServicesTests.cs
View File

@ -1,138 +0,0 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNet.Builder;
using Microsoft.Framework.DependencyInjection;
using Xunit;
namespace Microsoft.AspNet.Http.Extensions.Tests
{
public class UseWithServicesTests
{
[Fact]
public async Task CallingUseThatAlsoTakesServices()
{
var builder = new ApplicationBuilder(new ServiceCollection()
.AddScoped<ITestService, TestService>()
.BuildServiceProvider());
ITestService theService = null;
builder.Use<ITestService>(async (ctx, next, testService) =>
{
theService = testService;
await next();
});
var app = builder.Build();
await app(new DefaultHttpContext());
Assert.IsType<TestService>(theService);
}
[Fact]
public async Task ServicesArePerRequest()
{
var services = new ServiceCollection()
.AddScoped<ITestService, TestService>()
.BuildServiceProvider();
var builder = new ApplicationBuilder(services);
builder.Use(async (ctx, next) =>
{
var serviceScopeFactory = services.GetRequiredService<IServiceScopeFactory>();
using (var serviceScope = serviceScopeFactory.CreateScope())
{
var priorApplicationServices = ctx.ApplicationServices;
var priorRequestServices = ctx.ApplicationServices;
ctx.ApplicationServices = services;
ctx.RequestServices = serviceScope.ServiceProvider;
try
{
await next();
}
finally
{
ctx.ApplicationServices = priorApplicationServices;
ctx.RequestServices = priorRequestServices;
}
}
});
var testServicesA = new List<ITestService>();
builder.Use(async (HttpContext ctx, Func<Task> next, ITestService testService) =>
{
testServicesA.Add(testService);
await next();
});
var testServicesB = new List<ITestService>();
builder.Use<ITestService>(async (ctx, next, testService) =>
{
testServicesB.Add(testService);
await next();
});
var app = builder.Build();
await app(new DefaultHttpContext());
await app(new DefaultHttpContext());
Assert.Equal(2, testServicesA.Count);
Assert.IsType<TestService>(testServicesA[0]);
Assert.IsType<TestService>(testServicesA[1]);
Assert.Equal(2, testServicesB.Count);
Assert.IsType<TestService>(testServicesB[0]);
Assert.IsType<TestService>(testServicesB[1]);
Assert.Same(testServicesA[0], testServicesB[0]);
Assert.Same(testServicesA[1], testServicesB[1]);
Assert.NotSame(testServicesA[0], testServicesA[1]);
Assert.NotSame(testServicesB[0], testServicesB[1]);
}
[Fact]
public async Task InvokeMethodWillAllowPerRequestServices()
{
var services = new ServiceCollection()
.AddScoped<ITestService, TestService>()
.BuildServiceProvider();
var builder = new ApplicationBuilder(services);
builder.UseMiddleware<TestMiddleware>();
var app = builder.Build();
var ctx1 = new DefaultHttpContext();
await app(ctx1);
var testService = ctx1.Items[typeof(ITestService)];
Assert.IsType<TestService>(testService);
}
}
public interface ITestService
{
}
public class TestService : ITestService
{
}
public class TestMiddleware
{
RequestDelegate _next;
public TestMiddleware(RequestDelegate next)
{
_next = next;
}
public Task Invoke(HttpContext context, ITestService testService)
{
context.Items[typeof(ITestService)] = testService;
return Task.FromResult(0);
}
}
}