diff --git a/SaasKit.sln b/SaasKit.sln index 12c226b..9606858 100644 --- a/SaasKit.sln +++ b/SaasKit.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 14 -VisualStudioVersion = 14.0.24720.0 +VisualStudioVersion = 14.0.25420.1 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{C3B2A3F2-5EF9-4128-8035-255A1AC1AF7B}" ProjectSection(SolutionItems) = preProject diff --git a/samples/AspNetMvcAuthDemo/Startup.cs b/samples/AspNetMvcAuthDemo/Startup.cs index 8817a9d..3b15cd8 100644 --- a/samples/AspNetMvcAuthDemo/Startup.cs +++ b/samples/AspNetMvcAuthDemo/Startup.cs @@ -82,6 +82,7 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerF ClientId = clientId, ClientSecret = clientSecret + }); } }); diff --git a/samples/AspNetMvcAuthDemo/project.json b/samples/AspNetMvcAuthDemo/project.json index d2460ac..177e540 100644 --- a/samples/AspNetMvcAuthDemo/project.json +++ b/samples/AspNetMvcAuthDemo/project.json @@ -93,9 +93,9 @@ "web.config" ] }, - "scripts": { - "prepublish": [ "bower install", "dotnet bundle" ], - "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ] - }, + "scripts": { + "prepublish": [ "bower install", "dotnet bundle" ], + "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ] + }, "userSecretsId": "aspnet5-AspNetMvcAuthSample-20160229033356" } diff --git a/samples/AspNetMvcAuthDemo/wwwroot/css/site.min.css b/samples/AspNetMvcAuthDemo/wwwroot/css/site.min.css new file mode 100644 index 0000000..1c10250 --- /dev/null +++ b/samples/AspNetMvcAuthDemo/wwwroot/css/site.min.css @@ -0,0 +1 @@ +body{padding-top:50px;padding-bottom:20px}.body-content{padding-left:15px;padding-right:15px}input,select,textarea{max-width:280px}.carousel-caption{z-index:10 !important}.carousel-caption p{font-size:20px;line-height:1.4}@media(min-width:768px){.carousel-caption{z-index:10 !important}} \ No newline at end of file diff --git a/samples/AspNetMvcAuthDemo/wwwroot/js/site.min.js b/samples/AspNetMvcAuthDemo/wwwroot/js/site.min.js new file mode 100644 index 0000000..e5539c1 --- /dev/null +++ b/samples/AspNetMvcAuthDemo/wwwroot/js/site.min.js @@ -0,0 +1 @@ +// Write your Javascript code. \ No newline at end of file diff --git a/samples/AspNetMvcSample/Controllers/HomeController.cs b/samples/AspNetMvcSample/Controllers/HomeController.cs index 5f9d071..d0653e9 100644 --- a/samples/AspNetMvcSample/Controllers/HomeController.cs +++ b/samples/AspNetMvcSample/Controllers/HomeController.cs @@ -4,16 +4,18 @@ using System.Threading.Tasks; using Microsoft.AspNetCore.Mvc; using Microsoft.Extensions.Logging; +using SaasKit.Multitenancy; namespace AspNetMvcSample.Controllers { - public class HomeController : Controller + + public class HomeController : Controller { - private AppTenant tenant; + private readonly AppTenant tenant; - public HomeController(AppTenant tenant) + public HomeController(ITenant tenant) { - this.tenant = tenant; + this.tenant = tenant?.Value; } public IActionResult Index() diff --git a/samples/AspNetMvcSample/project.json b/samples/AspNetMvcSample/project.json index 5c1cb4d..301c9e7 100644 --- a/samples/AspNetMvcSample/project.json +++ b/samples/AspNetMvcSample/project.json @@ -88,8 +88,8 @@ "web.config" ] }, - "scripts": { - "prepublish": [ "bower install", "dotnet bundle" ], - "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ] - } + "scripts": { + "prepublish": [ "bower install", "dotnet bundle" ], + "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ] + } } diff --git a/samples/AspNetMvcSample/wwwroot/css/site.min.css b/samples/AspNetMvcSample/wwwroot/css/site.min.css new file mode 100644 index 0000000..2e9df54 --- /dev/null +++ b/samples/AspNetMvcSample/wwwroot/css/site.min.css @@ -0,0 +1 @@ +body{padding-top:50px;padding-bottom:20px}.body-content{padding-top:30px;padding-left:15px;padding-right:15px}input,select,textarea{max-width:280px}.carousel-caption{z-index:10 !important}.carousel-caption p{font-size:20px;line-height:1.4}@media(min-width:768px){.carousel-caption{z-index:10 !important}} \ No newline at end of file diff --git a/samples/AspNetMvcSample/wwwroot/js/site.min.js b/samples/AspNetMvcSample/wwwroot/js/site.min.js new file mode 100644 index 0000000..e5539c1 --- /dev/null +++ b/samples/AspNetMvcSample/wwwroot/js/site.min.js @@ -0,0 +1 @@ +// Write your Javascript code. \ No newline at end of file diff --git a/samples/AspNetSample/project.json b/samples/AspNetSample/project.json index 5f83781..f7bd51f 100644 --- a/samples/AspNetSample/project.json +++ b/samples/AspNetSample/project.json @@ -27,6 +27,7 @@ } }, "tools": { + "BundlerMinifier.Core": "2.0.238", "Microsoft.AspNetCore.Server.IISIntegration.Tools": "1.0.0-preview2-final" }, "buildOptions": { @@ -50,6 +51,7 @@ ] }, "scripts": { + "prepublish": [ "bower install", "dotnet bundle" ], "postpublish": "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" } } diff --git a/samples/AspNetStructureMapSample/project.json b/samples/AspNetStructureMapSample/project.json index 481ac61..c8beacd 100644 --- a/samples/AspNetStructureMapSample/project.json +++ b/samples/AspNetStructureMapSample/project.json @@ -23,12 +23,13 @@ } } }, - "tools": { - "Microsoft.AspNetCore.Server.IISIntegration.Tools": { - "version": "1.0.0-preview2-final", - "imports": "portable-net45+win8+dnxcore50" - } - }, + "tools": { + "BundlerMinifier.Core": "2.0.238", + "Microsoft.AspNetCore.Server.IISIntegration.Tools": { + "version": "1.0.0-preview2-final", + "imports": "portable-net45+win8+dnxcore50" + } + }, "buildOptions": { "emitEntryPoint": true, "preserveCompilationContext": true @@ -49,8 +50,8 @@ "web.config" ] }, - "scripts": { - "prepublish": [ "bower install", "dotnet bundle" ], - "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ] - } + "scripts": { + "prepublish": [ "bower install", "dotnet bundle" ], + "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ] + } } diff --git a/src/SaasKit.Multitenancy.StructureMap/project.json b/src/SaasKit.Multitenancy.StructureMap/project.json index 5141a48..074d451 100644 --- a/src/SaasKit.Multitenancy.StructureMap/project.json +++ b/src/SaasKit.Multitenancy.StructureMap/project.json @@ -1,45 +1,49 @@ { - "version": "1.1.3", - "description": "Multi-tenancy support for ASP.NET Core using StructureMap.", - "authors": [ "Ben Foster" ], + "version": "1.1.4", + "description": "Multi-tenancy support for ASP.NET Core using StructureMap.", + "authors": [ "Ben Foster" ], "packOptions": { "authors": [ "Ben Foster" ], "owners": [ "Ben Foster" ], - "tags": [ "Multi-tenancy", "Multi-tenant", "Saas", "StructureMap" ], - "releaseNotes": "Updated to support ASP.NET Core RC-2", + "tags": [ "Multi-tenancy", "Multitenant", "Multitenancy", "Multitenant", "Saas", "StructureMap" ], + "releaseNotes": "Updated to support ASP.NET Core RTM. Resolves an issue with MemoryCache cache dependencies.", "projectUrl": "http://saaskit.net", "licenseUrl": "https://github.com/saaskit/saaskit/blob/master/LICENSE.md", + "requireLicenseAcceptance": false, "repository": { "type": "git", "url": "https://github.com/saaskit/saaskit/" } }, - "dependencies": { - "NETStandard.Library": "1.6.0", - "Microsoft.AspNetCore.Http.Abstractions": "1.0.0", - "Microsoft.AspNetCore.Http.Extensions": "1.0.0", - "Microsoft.Extensions.Caching.Abstractions": "1.0.0", - "Microsoft.Extensions.Caching.Memory": "1.0.0", - "Microsoft.Extensions.Logging.Abstractions": "1.0.0", - "StructureMap.Dnx": "0.5.1-rc2-final", - "SaasKit.Multitenancy": { "target": "project" } - }, - "frameworks": { - "net46": { }, - "net452": { }, - "net451": { }, - "netstandard1.6": { - "dependencies": { - "Microsoft.CSharp": "4.0.1-rc2-*", - "System.Collections": "4.0.11-rc2-*", - "System.Linq": "4.1.0-rc2-*", - "System.Runtime": "4.1.0-rc2-*", - "System.Threading": "4.0.11-rc2-*" - }, - "imports": [ - "dotnet5.4", - "portable-net45+win8" - ] - } - } + "dependencies": { + "NETStandard.Library": "1.6.0", + "Microsoft.AspNetCore.Http.Abstractions": "1.0.0", + "Microsoft.AspNetCore.Http.Extensions": "1.0.0", + "Microsoft.Extensions.Caching.Abstractions": "1.0.0", + "Microsoft.Extensions.Caching.Memory": "1.0.0", + "Microsoft.Extensions.Logging.Abstractions": "1.0.0", + "StructureMap.Dnx": "0.5.1-rc2-final", + "SaasKit.Multitenancy": { "target": "project" } + }, + "frameworks": { + "net46": {}, + "net452": {}, + "net451": {}, + "netstandard1.6": { + "dependencies": { + "Microsoft.CSharp": "4.0.1", + "System.Collections": "4.0.11", + "System.Linq": "4.1.0", + "System.Runtime": "4.1.0", + "System.Threading": "4.0.11" + }, + "imports": [ + "dotnet5.4", + "portable-net45+win8" + ] + } + }, + "buildOptions": { + "optimize": true + } } \ No newline at end of file diff --git a/src/SaasKit.Multitenancy/Ensure.cs b/src/SaasKit.Multitenancy/Ensure.cs index bfd8f0d..71a8cf3 100644 --- a/src/SaasKit.Multitenancy/Ensure.cs +++ b/src/SaasKit.Multitenancy/Ensure.cs @@ -4,9 +4,12 @@ namespace SaasKit.Multitenancy { - /// + using System.Diagnostics; + + /// /// Helper class that will throw exceptions when conditions are not satisfied. /// + [DebuggerStepThrough] public static class Ensure { /// diff --git a/src/SaasKit.Multitenancy/ITenant.cs b/src/SaasKit.Multitenancy/ITenant.cs new file mode 100644 index 0000000..74531a4 --- /dev/null +++ b/src/SaasKit.Multitenancy/ITenant.cs @@ -0,0 +1,7 @@ +namespace SaasKit.Multitenancy +{ + public interface ITenant + { + TTenant Value { get; } + } +} \ No newline at end of file diff --git a/src/SaasKit.Multitenancy/Internal/Tenant.cs b/src/SaasKit.Multitenancy/Internal/Tenant.cs new file mode 100644 index 0000000..0552cb8 --- /dev/null +++ b/src/SaasKit.Multitenancy/Internal/Tenant.cs @@ -0,0 +1,12 @@ +namespace SaasKit.Multitenancy.Internal +{ + internal class Tenant : ITenant + { + public Tenant(TTenant value) + { + Value = value; + } + + public TTenant Value { get; } + } +} \ No newline at end of file diff --git a/src/SaasKit.Multitenancy/Internal/TenantResolutionMiddleware.cs b/src/SaasKit.Multitenancy/Internal/TenantResolutionMiddleware.cs index 95fb496..f2ae106 100644 --- a/src/SaasKit.Multitenancy/Internal/TenantResolutionMiddleware.cs +++ b/src/SaasKit.Multitenancy/Internal/TenantResolutionMiddleware.cs @@ -4,7 +4,9 @@ namespace SaasKit.Multitenancy.Internal { - public class TenantResolutionMiddleware + using System; + + public class TenantResolutionMiddleware { private readonly RequestDelegate next; private readonly ILogger log; diff --git a/src/SaasKit.Multitenancy/MemoryCacheTenantResolver.cs b/src/SaasKit.Multitenancy/MemoryCacheTenantResolver.cs index 2c70d16..180ba2c 100644 --- a/src/SaasKit.Multitenancy/MemoryCacheTenantResolver.cs +++ b/src/SaasKit.Multitenancy/MemoryCacheTenantResolver.cs @@ -7,7 +7,11 @@ namespace SaasKit.Multitenancy { - public abstract class MemoryCacheTenantResolver : ITenantResolver + using System.Threading; + + using Microsoft.Extensions.Primitives; + + public abstract class MemoryCacheTenantResolver : ITenantResolver { protected readonly IMemoryCache cache; protected readonly ILogger log; @@ -24,11 +28,32 @@ public MemoryCacheTenantResolver(IMemoryCache cache, ILoggerFactory loggerFactor protected virtual MemoryCacheEntryOptions CreateCacheEntryOptions() { return new MemoryCacheEntryOptions() - .SetSlidingExpiration(new TimeSpan(1, 0, 0)) - .RegisterPostEvictionCallback((key, value, reason, state) - => DisposeTenantContext(key, value as TenantContext)); + .SetSlidingExpiration(new TimeSpan(1, 0, 0)); } + private MemoryCacheEntryOptions GetCacheEntryOptions() + { + var cacheEntryOptions = CreateCacheEntryOptions(); + + if (DisposeTenantOnExpiration) + { + var changeToken = new CancellationTokenSource(); + + cacheEntryOptions + .RegisterPostEvictionCallback( + (key, value, reason, state) => + { + DisposeTenantContext(key, value as TenantContext); + changeToken.Cancel(); + }) + .AddExpirationToken(new CancellationChangeToken(changeToken.Token)); + } + + return cacheEntryOptions; + } + + protected virtual bool DisposeTenantOnExpiration => true; + protected virtual void DisposeTenantContext(object cacheKey, TenantContext tenantContext) { if (tenantContext != null) @@ -67,9 +92,9 @@ async Task> ITenantResolver.ResolveAsync(HttpCon if (tenantIdentifiers != null) { - var cacheEntryOptions = CreateCacheEntryOptions(); + var cacheEntryOptions = GetCacheEntryOptions(); - log.LogDebug("TenantContext:{id} resolved. Caching with keys \"{tenantIdentifiers}\".", tenantContext.Id, tenantIdentifiers); + log.LogDebug("TenantContext:{id} resolved. Caching with keys \"{tenantIdentifiers}\".", tenantContext.Id, tenantIdentifiers); foreach (var identifier in tenantIdentifiers) { diff --git a/src/SaasKit.Multitenancy/MultitenancyServiceCollectionExtensions.cs b/src/SaasKit.Multitenancy/MultitenancyServiceCollectionExtensions.cs index a1e559e..bf07510 100644 --- a/src/SaasKit.Multitenancy/MultitenancyServiceCollectionExtensions.cs +++ b/src/SaasKit.Multitenancy/MultitenancyServiceCollectionExtensions.cs @@ -5,7 +5,9 @@ namespace Microsoft.Extensions.DependencyInjection { - public static class MultitenancyServiceCollectionExtensions + using SaasKit.Multitenancy.Internal; + + public static class MultitenancyServiceCollectionExtensions { public static IServiceCollection AddMultitenancy(this IServiceCollection services) where TResolver : class, ITenantResolver @@ -18,15 +20,15 @@ public static class MultitenancyServiceCollectionExtensions // No longer registered by default as of ASP.NET Core RC2 services.TryAddSingleton(); - // Make Tenant and TenantContext injectable - services.AddScoped(prov => - prov.GetService()?.HttpContext?.GetTenant()); + // Make Tenant and TenantContext injectable + services.AddScoped(prov => prov.GetService()?.HttpContext?.GetTenantContext()); + services.AddScoped(prov => prov.GetService>()?.Tenant); - services.AddScoped(prov => - prov.GetService()?.HttpContext?.GetTenantContext()); + // Make ITenant injectable for handling null injection, similar to IOptions + services.AddScoped>(prov => new Tenant(prov.GetService())); - // Ensure caching is available for caching resolvers - var resolverType = typeof(TResolver); + // Ensure caching is available for caching resolvers + var resolverType = typeof(TResolver); if (typeof(MemoryCacheTenantResolver).IsAssignableFrom(resolverType)) { services.AddMemoryCache(); diff --git a/src/SaasKit.Multitenancy/TenantContext.cs b/src/SaasKit.Multitenancy/TenantContext.cs index 6869b34..7dc9e0e 100644 --- a/src/SaasKit.Multitenancy/TenantContext.cs +++ b/src/SaasKit.Multitenancy/TenantContext.cs @@ -3,7 +3,7 @@ namespace SaasKit.Multitenancy { - public class TenantContext : IDisposable + public class TenantContext : IDisposable { private bool disposed; @@ -38,7 +38,9 @@ protected virtual void Dispose(bool disposing) { TryDisposeProperty(prop.Value as IDisposable); } - } + + TryDisposeProperty(Tenant as IDisposable); + } disposed = true; } diff --git a/src/SaasKit.Multitenancy/project.json b/src/SaasKit.Multitenancy/project.json index 212bd60..164b4a7 100644 --- a/src/SaasKit.Multitenancy/project.json +++ b/src/SaasKit.Multitenancy/project.json @@ -1,46 +1,49 @@ { - "version": "1.1.3", - "description": "Multi-tenancy support for ASP.NET Core.", - "copyright": "Copyright © Ben Foster", - "packOptions": { - "authors": [ "Ben Foster" ], - "owners": [ "Ben Foster" ], - "tags": [ "Multi-tenancy", "Multi-tenant", "Saas" ], - "releaseNotes": "Updated to support ASP.NET Core RC-2", - "projectUrl": "http://saaskit.net", - "licenseUrl": "https://github.com/saaskit/saaskit/blob/master/LICENSE.md", - "repository": { - "type": "git", - "url": "https://github.com/saaskit/saaskit/" - } - }, - "dependencies": { - "NETStandard.Library": "1.6.0", - "Microsoft.AspNetCore.Http": "1.0.0", - "Microsoft.AspNetCore.Http.Abstractions": "1.0.0", - "Microsoft.AspNetCore.Http.Extensions": "1.0.0", - "Microsoft.Extensions.DependencyInjection.Abstractions": "1.0.0", - "Microsoft.Extensions.Caching.Abstractions": "1.0.0", - "Microsoft.Extensions.Caching.Memory": "1.0.0", - "Microsoft.Extensions.Logging.Abstractions": "1.0.0" - }, - "frameworks": { - "net46": { }, - "net452": { }, - "net451": {}, - "netstandard1.6": { - "dependencies": { - - "Microsoft.CSharp": "4.0.1", - "System.Collections": "4.0.11", - "System.Linq": "4.1.0", - "System.Runtime": "4.1.0", - "System.Threading": "4.0.11" - }, - "imports": [ - "dotnet5.4", - "portable-net45+win8" - ] - } - } + "version": "1.1.4", + "description": "Multi-tenancy support for ASP.NET Core.", + "copyright": "Copyright © Ben Foster", + "packOptions": { + "authors": [ "Ben Foster" ], + "owners": [ "Ben Foster" ], + "tags": [ "Multi-tenancy", "Multitenant", "Multitenancy", "Multitenant", "Saas" ], + "releaseNotes": "Updated to support ASP.NET Core RTM. Resolves an issue with MemoryCache cache dependencies.", + "projectUrl": "http://saaskit.net", + "licenseUrl": "https://github.com/saaskit/saaskit/blob/master/LICENSE.md", + "requireLicenseAcceptance": false, + "repository": { + "type": "git", + "url": "https://github.com/saaskit/saaskit/" + } + }, + "dependencies": { + "NETStandard.Library": "1.6.0", + "Microsoft.AspNetCore.Http": "1.0.0", + "Microsoft.AspNetCore.Http.Abstractions": "1.0.0", + "Microsoft.AspNetCore.Http.Extensions": "1.0.0", + "Microsoft.Extensions.DependencyInjection.Abstractions": "1.0.0", + "Microsoft.Extensions.Caching.Abstractions": "1.0.0", + "Microsoft.Extensions.Caching.Memory": "1.0.0", + "Microsoft.Extensions.Logging.Abstractions": "1.0.0" + }, + "frameworks": { + "net46": {}, + "net452": {}, + "net451": {}, + "netstandard1.6": { + "dependencies": { + "Microsoft.CSharp": "4.0.1", + "System.Collections": "4.0.11", + "System.Linq": "4.1.0", + "System.Runtime": "4.1.0", + "System.Threading": "4.0.11" + }, + "imports": [ + "dotnet5.4", + "portable-net45+win8" + ] + } + }, + "buildOptions": { + "optimize": true + } } diff --git a/src/Shared/JetBrains.Annotations.cs b/src/Shared/JetBrains.Annotations.cs new file mode 100644 index 0000000..aef03db --- /dev/null +++ b/src/Shared/JetBrains.Annotations.cs @@ -0,0 +1,1138 @@ +/* MIT License + +Copyright (c) 2016 JetBrains http://www.jetbrains.com + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. */ + +using System; +using System.Diagnostics; + +#pragma warning disable 1591 +// ReSharper disable UnusedMember.Global +// ReSharper disable MemberCanBePrivate.Global +// ReSharper disable UnusedAutoPropertyAccessor.Global +// ReSharper disable IntroduceOptionalParameters.Global +// ReSharper disable MemberCanBeProtected.Global +// ReSharper disable InconsistentNaming +// ReSharper disable once CheckNamespace + +namespace JetBrains.Annotations +{ + /// + /// Indicates that the value of the marked element could be null sometimes, + /// so the check for null is necessary before its usage. + /// + /// + /// [CanBeNull] object Test() => null; + /// + /// void UseTest() { + /// var p = Test(); + /// var s = p.ToString(); // Warning: Possible 'System.NullReferenceException' + /// } + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class CanBeNullAttribute : Attribute { } + + /// + /// Indicates that the value of the marked element could never be null. + /// + /// + /// [NotNull] object Foo() { + /// return null; // Warning: Possible 'null' assignment + /// } + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field | AttributeTargets.Event | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.GenericParameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class NotNullAttribute : Attribute { } + + /// + /// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task + /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property + /// or of the Lazy.Value property can never be null. + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class ItemNotNullAttribute : Attribute { } + + /// + /// Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task + /// and Lazy classes to indicate that the value of a collection item, of the Task.Result property + /// or of the Lazy.Value property can be null. + /// + [AttributeUsage( + AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | + AttributeTargets.Delegate | AttributeTargets.Field)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class ItemCanBeNullAttribute : Attribute { } + + /// + /// Implicitly apply [NotNull]/[ItemNotNull] annotation to all the of type members and parameters + /// in particular scope where this annotation is used (type declaration or whole assembly). + /// + [AttributeUsage( + AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Assembly)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class ImplicitNotNullAttribute : Attribute { } + + /// + /// Indicates that the marked method builds string by format pattern and (optional) arguments. + /// Parameter, which contains format string, should be given in constructor. The format string + /// should be in -like form. + /// + /// + /// [StringFormatMethod("message")] + /// void ShowError(string message, params object[] args) { /* do something */ } + /// + /// void Foo() { + /// ShowError("Failed: {0}"); // Warning: Non-existing argument in format string + /// } + /// + [AttributeUsage( + AttributeTargets.Constructor | AttributeTargets.Method | + AttributeTargets.Property | AttributeTargets.Delegate)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class StringFormatMethodAttribute : Attribute + { + /// + /// Specifies which parameter of an annotated method should be treated as format-string + /// + public StringFormatMethodAttribute([NotNull] string formatParameterName) + { + FormatParameterName = formatParameterName; + } + + [NotNull] + public string FormatParameterName { get; private set; } + } + + /// + /// For a parameter that is expected to be one of the limited set of values. + /// Specify fields of which type should be used as values for this parameter. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class ValueProviderAttribute : Attribute + { + public ValueProviderAttribute([NotNull] string name) + { + Name = name; + } + + [NotNull] + public string Name { get; private set; } + } + + /// + /// Indicates that the function argument should be string literal and match one + /// of the parameters of the caller function. For example, ReSharper annotates + /// the parameter of . + /// + /// + /// void Foo(string param) { + /// if (param == null) + /// throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol + /// } + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class InvokerParameterNameAttribute : Attribute { } + + /// + /// Indicates that the method is contained in a type that implements + /// System.ComponentModel.INotifyPropertyChanged interface and this method + /// is used to notify that some property value changed. + /// + /// + /// The method should be non-static and conform to one of the supported signatures: + /// + /// NotifyChanged(string) + /// NotifyChanged(params string[]) + /// NotifyChanged{T}(Expression{Func{T}}) + /// NotifyChanged{T,U}(Expression{Func{T,U}}) + /// SetProperty{T}(ref T, T, string) + /// + /// + /// + /// public class Foo : INotifyPropertyChanged { + /// public event PropertyChangedEventHandler PropertyChanged; + /// + /// [NotifyPropertyChangedInvocator] + /// protected virtual void NotifyChanged(string propertyName) { ... } + /// + /// string _name; + /// + /// public string Name { + /// get { return _name; } + /// set { _name = value; NotifyChanged("LastName"); /* Warning */ } + /// } + /// } + /// + /// Examples of generated notifications: + /// + /// NotifyChanged("Property") + /// NotifyChanged(() => Property) + /// NotifyChanged((VM x) => x.Property) + /// SetProperty(ref myField, value, "Property") + /// + /// + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class NotifyPropertyChangedInvocatorAttribute : Attribute + { + public NotifyPropertyChangedInvocatorAttribute() { } + public NotifyPropertyChangedInvocatorAttribute([NotNull] string parameterName) + { + ParameterName = parameterName; + } + + [CanBeNull] + public string ParameterName { get; private set; } + } + + /// + /// Describes dependency between method input and output. + /// + /// + ///

Function Definition Table syntax:

+ /// + /// FDT ::= FDTRow [;FDTRow]* + /// FDTRow ::= Input => Output | Output <= Input + /// Input ::= ParameterName: Value [, Input]* + /// Output ::= [ParameterName: Value]* {halt|stop|void|nothing|Value} + /// Value ::= true | false | null | notnull | canbenull + /// + /// If method has single input parameter, it's name could be omitted.
+ /// Using halt (or void/nothing, which is the same) + /// for method output means that the methos doesn't return normally.
+ /// canbenull annotation is only applicable for output parameters.
+ /// You can use multiple [ContractAnnotation] for each FDT row, + /// or use single attribute with rows separated by semicolon.
+ /// + /// + /// + /// [ContractAnnotation("=> halt")] + /// public void TerminationMethod() + /// + /// + /// [ContractAnnotation("halt <= condition: false")] + /// public void Assert(bool condition, string text) // regular assertion method + /// + /// + /// [ContractAnnotation("s:null => true")] + /// public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty() + /// + /// + /// // A method that returns null if the parameter is null, + /// // and not null if the parameter is not null + /// [ContractAnnotation("null => null; notnull => notnull")] + /// public object Transform(object data) + /// + /// + /// [ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")] + /// public bool TryParse(string s, out Person result) + /// + /// + [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class ContractAnnotationAttribute : Attribute + { + public ContractAnnotationAttribute([NotNull] string contract) + : this(contract, false) { } + + public ContractAnnotationAttribute([NotNull] string contract, bool forceFullStates) + { + Contract = contract; + ForceFullStates = forceFullStates; + } + + [NotNull] + public string Contract { get; private set; } + public bool ForceFullStates { get; private set; } + } + + /// + /// Indicates that marked element should be localized or not. + /// + /// + /// [LocalizationRequiredAttribute(true)] + /// class Foo { + /// string str = "my string"; // Warning: Localizable string + /// } + /// + [AttributeUsage(AttributeTargets.All)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class LocalizationRequiredAttribute : Attribute + { + public LocalizationRequiredAttribute() : this(true) { } + public LocalizationRequiredAttribute(bool required) + { + Required = required; + } + + public bool Required { get; private set; } + } + + /// + /// Indicates that the value of the marked type (or its derivatives) + /// cannot be compared using '==' or '!=' operators and Equals() + /// should be used instead. However, using '==' or '!=' for comparison + /// with null is always permitted. + /// + /// + /// [CannotApplyEqualityOperator] + /// class NoEquality { } + /// + /// class UsesNoEquality { + /// void Test() { + /// var ca1 = new NoEquality(); + /// var ca2 = new NoEquality(); + /// if (ca1 != null) { // OK + /// bool condition = ca1 == ca2; // Warning + /// } + /// } + /// } + /// + [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class CannotApplyEqualityOperatorAttribute : Attribute { } + + /// + /// When applied to a target attribute, specifies a requirement for any type marked + /// with the target attribute to implement or inherit specific type or types. + /// + /// + /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement + /// class ComponentAttribute : Attribute { } + /// + /// [Component] // ComponentAttribute requires implementing IComponent interface + /// class MyComponent : IComponent { } + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + [BaseTypeRequired(typeof(Attribute))] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class BaseTypeRequiredAttribute : Attribute + { + public BaseTypeRequiredAttribute([NotNull] Type baseType) + { + BaseType = baseType; + } + + [NotNull] + public Type BaseType { get; private set; } + } + + /// + /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library), + /// so this symbol will not be marked as unused (as well as by other usage inspections). + /// + [AttributeUsage(AttributeTargets.All)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class UsedImplicitlyAttribute : Attribute + { + public UsedImplicitlyAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { } + + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { } + + public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { } + + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) + { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + public ImplicitUseKindFlags UseKindFlags { get; private set; } + public ImplicitUseTargetFlags TargetFlags { get; private set; } + } + + /// + /// Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes + /// as unused (as well as by other usage inspections) + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.GenericParameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class MeansImplicitUseAttribute : Attribute + { + public MeansImplicitUseAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { } + + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { } + + public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { } + + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) + { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + [UsedImplicitly] + public ImplicitUseKindFlags UseKindFlags { get; private set; } + [UsedImplicitly] + public ImplicitUseTargetFlags TargetFlags { get; private set; } + } + + [Flags] + internal enum ImplicitUseKindFlags + { + Default = Access | Assign | InstantiatedWithFixedConstructorSignature, + /// Only entity marked with attribute considered used. + Access = 1, + /// Indicates implicit assignment to a member. + Assign = 2, + /// + /// Indicates implicit instantiation of a type with fixed constructor signature. + /// That means any unused constructor parameters won't be reported as such. + /// + InstantiatedWithFixedConstructorSignature = 4, + /// Indicates implicit instantiation of a type. + InstantiatedNoFixedConstructorSignature = 8, + } + + /// + /// Specify what is considered used implicitly when marked + /// with or . + /// + [Flags] + internal enum ImplicitUseTargetFlags + { + Default = Itself, + Itself = 1, + /// Members of entity marked with attribute are considered used. + Members = 2, + /// Entity marked with attribute and all its members considered used. + WithMembers = Itself | Members + } + + /// + /// This attribute is intended to mark publicly available API + /// which should not be removed and so is treated as used. + /// + [MeansImplicitUse(ImplicitUseTargetFlags.WithMembers)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class PublicAPIAttribute : Attribute + { + public PublicAPIAttribute() { } + public PublicAPIAttribute([NotNull] string comment) + { + Comment = comment; + } + + [CanBeNull] + public string Comment { get; private set; } + } + + /// + /// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack. + /// If the parameter is a delegate, indicates that delegate is executed while the method is executed. + /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed. + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class InstantHandleAttribute : Attribute { } + + /// + /// Indicates that a method does not make any observable state changes. + /// The same as System.Diagnostics.Contracts.PureAttribute. + /// + /// + /// [Pure] int Multiply(int x, int y) => x * y; + /// + /// void M() { + /// Multiply(123, 42); // Waring: Return value of pure method is not used + /// } + /// + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class PureAttribute : Attribute { } + + /// + /// Indicates that the return value of method invocation must be used. + /// + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class MustUseReturnValueAttribute : Attribute + { + public MustUseReturnValueAttribute() { } + public MustUseReturnValueAttribute([NotNull] string justification) + { + Justification = justification; + } + + [CanBeNull] + public string Justification { get; private set; } + } + + /// + /// Indicates the type member or parameter of some type, that should be used instead of all other ways + /// to get the value that type. This annotation is useful when you have some "context" value evaluated + /// and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one. + /// + /// + /// class Foo { + /// [ProvidesContext] IBarService _barService = ...; + /// + /// void ProcessNode(INode node) { + /// DoSomething(node, node.GetGlobalServices().Bar); + /// // ^ Warning: use value of '_barService' field + /// } + /// } + /// + [AttributeUsage( + AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.Method | + AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.GenericParameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class ProvidesContextAttribute : Attribute { } + + /// + /// Indicates that a parameter is a path to a file or a folder within a web project. + /// Path can be relative or absolute, starting from web root (~). + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class PathReferenceAttribute : Attribute + { + public PathReferenceAttribute() { } + public PathReferenceAttribute([NotNull, PathReference] string basePath) + { + BasePath = basePath; + } + + [CanBeNull] + public string BasePath { get; private set; } + } + + /// + /// An extension method marked with this attribute is processed by ReSharper code completion + /// as a 'Source Template'. When extension method is completed over some expression, it's source code + /// is automatically expanded like a template at call site. + /// + /// + /// Template method body can contain valid source code and/or special comments starting with '$'. + /// Text inside these comments is added as source code when the template is applied. Template parameters + /// can be used either as additional method parameters or as identifiers wrapped in two '$' signs. + /// Use the attribute to specify macros for parameters. + /// + /// + /// In this example, the 'forEach' method is a source template available over all values + /// of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block: + /// + /// [SourceTemplate] + /// public static void forEach<T>(this IEnumerable<T> xs) { + /// foreach (var x in xs) { + /// //$ $END$ + /// } + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class SourceTemplateAttribute : Attribute { } + + /// + /// Allows specifying a macro for a parameter of a source template. + /// + /// + /// You can apply the attribute on the whole method or on any of its additional parameters. The macro expression + /// is defined in the property. When applied on a method, the target + /// template parameter is defined in the property. To apply the macro silently + /// for the parameter, set the property value = -1. + /// + /// + /// Applying the attribute on a source template method: + /// + /// [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")] + /// public static void forEach<T>(this IEnumerable<T> collection) { + /// foreach (var item in collection) { + /// //$ $END$ + /// } + /// } + /// + /// Applying the attribute on a template method parameter: + /// + /// [SourceTemplate] + /// public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) { + /// /*$ var $x$Id = "$newguid$" + x.ToString(); + /// x.DoSomething($x$Id); */ + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class MacroAttribute : Attribute + { + /// + /// Allows specifying a macro that will be executed for a source template + /// parameter when the template is expanded. + /// + public string Expression { get; set; } + + /// + /// Allows specifying which occurrence of the target parameter becomes editable when the template is deployed. + /// + /// + /// If the target parameter is used several times in the template, only one occurrence becomes editable; + /// other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence, + /// use values >= 0. To make the parameter non-editable when the template is expanded, use -1. + /// > + public int Editable { get; set; } + + /// + /// Identifies the target parameter of a source template if the + /// is applied on a template method. + /// + public string Target { get; set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcAreaMasterLocationFormatAttribute : Attribute + { + public AspMvcAreaMasterLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcAreaPartialViewLocationFormatAttribute : Attribute + { + public AspMvcAreaPartialViewLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcAreaViewLocationFormatAttribute : Attribute + { + public AspMvcAreaViewLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcMasterLocationFormatAttribute : Attribute + { + public AspMvcMasterLocationFormatAttribute(string format) + { + Format = format; + } + + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcPartialViewLocationFormatAttribute : Attribute + { + public AspMvcPartialViewLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] + public string Format { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcViewLocationFormatAttribute : Attribute + { + public AspMvcViewLocationFormatAttribute([NotNull] string format) + { + Format = format; + } + + [NotNull] + public string Format { get; private set; } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC action. If applied to a method, the MVC action name is calculated + /// implicitly from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcActionAttribute : Attribute + { + public AspMvcActionAttribute() { } + public AspMvcActionAttribute([NotNull] string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] + public string AnonymousProperty { get; private set; } + } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC area. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcAreaAttribute : Attribute + { + public AspMvcAreaAttribute() { } + public AspMvcAreaAttribute([NotNull] string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] + public string AnonymousProperty { get; private set; } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is + /// an MVC controller. If applied to a method, the MVC controller name is calculated + /// implicitly from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcControllerAttribute : Attribute + { + public AspMvcControllerAttribute() { } + public AspMvcControllerAttribute([NotNull] string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + + [CanBeNull] + public string AnonymousProperty { get; private set; } + } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC Master. Use this attribute + /// for custom wrappers similar to System.Web.Mvc.Controller.View(String, String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcMasterAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC model type. Use this attribute + /// for custom wrappers similar to System.Web.Mvc.Controller.View(String, Object). + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcModelTypeAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC + /// partial view. If applied to a method, the MVC partial view name is calculated implicitly + /// from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcPartialViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method. + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcSuppressViewErrorAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcDisplayTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC editor template. + /// Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcEditorTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC template. + /// Use this attribute for custom wrappers similar to + /// System.ComponentModel.DataAnnotations.UIHintAttribute(System.String). + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component. If applied to a method, the MVC view name is calculated implicitly + /// from the context. Use this attribute for custom wrappers similar to + /// System.Web.Mvc.Controller.View(Object). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component name. + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcViewComponentAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter + /// is an MVC view component view. If applied to a method, the MVC view component view name is default. + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcViewComponentViewAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. When applied to a parameter of an attribute, + /// indicates that this parameter is an MVC action name. + /// + /// + /// [ActionName("Foo")] + /// public ActionResult Login(string returnUrl) { + /// ViewBag.ReturnUrl = Url.Action("Foo"); // OK + /// return RedirectToAction("Bar"); // Error: Cannot resolve action + /// } + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMvcActionSelectorAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Field)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class HtmlElementAttributesAttribute : Attribute + { + public HtmlElementAttributesAttribute() { } + public HtmlElementAttributesAttribute([NotNull] string name) + { + Name = name; + } + + [CanBeNull] + public string Name { get; private set; } + } + + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Field | AttributeTargets.Property)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class HtmlAttributeValueAttribute : Attribute + { + public HtmlAttributeValueAttribute([NotNull] string name) + { + Name = name; + } + + [NotNull] + public string Name { get; private set; } + } + + /// + /// Razor attribute. Indicates that a parameter or a method is a Razor section. + /// Use this attribute for custom wrappers similar to + /// System.Web.WebPages.WebPageBase.RenderSection(String). + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorSectionAttribute : Attribute { } + + /// + /// Indicates how method, constructor invocation or property access + /// over collection type affects content of the collection. + /// + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Property)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class CollectionAccessAttribute : Attribute + { + public CollectionAccessAttribute(CollectionAccessType collectionAccessType) + { + CollectionAccessType = collectionAccessType; + } + + public CollectionAccessType CollectionAccessType { get; private set; } + } + + [Flags] + internal enum CollectionAccessType + { + /// Method does not use or modify content of the collection. + None = 0, + /// Method only reads content of the collection but does not modify it. + Read = 1, + /// Method can change content of the collection but does not add new elements. + ModifyExistingContent = 2, + /// Method can add new elements to the collection. + UpdatedContent = ModifyExistingContent | 4 + } + + /// + /// Indicates that the marked method is assertion method, i.e. it halts control flow if + /// one of the conditions is satisfied. To set the condition, mark one of the parameters with + /// attribute. + /// + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AssertionMethodAttribute : Attribute { } + + /// + /// Indicates the condition parameter of the assertion method. The method itself should be + /// marked by attribute. The mandatory argument of + /// the attribute is the assertion type. + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AssertionConditionAttribute : Attribute + { + public AssertionConditionAttribute(AssertionConditionType conditionType) + { + ConditionType = conditionType; + } + + public AssertionConditionType ConditionType { get; private set; } + } + + /// + /// Specifies assertion type. If the assertion method argument satisfies the condition, + /// then the execution continues. Otherwise, execution is assumed to be halted. + /// + internal enum AssertionConditionType + { + /// Marked parameter should be evaluated to true. + IS_TRUE = 0, + /// Marked parameter should be evaluated to false. + IS_FALSE = 1, + /// Marked parameter should be evaluated to null value. + IS_NULL = 2, + /// Marked parameter should be evaluated to not null value. + IS_NOT_NULL = 3, + } + + /// + /// Indicates that the marked method unconditionally terminates control flow execution. + /// For example, it could unconditionally throw exception. + /// + [Obsolete("Use [ContractAnnotation('=> halt')] instead")] + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class TerminatesProgramAttribute : Attribute { } + + /// + /// Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select, + /// .Where). This annotation allows inference of [InstantHandle] annotation for parameters + /// of delegate type by analyzing LINQ method chains. + /// + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class LinqTunnelAttribute : Attribute { } + + /// + /// Indicates that IEnumerable, passed as parameter, is not enumerated. + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class NoEnumerationAttribute : Attribute { } + + /// + /// Indicates that parameter is regular expression pattern. + /// + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RegexPatternAttribute : Attribute { } + + /// + /// XAML attribute. Indicates the type that has ItemsSource property and should be treated + /// as ItemsControl-derived type, to enable inner items DataContext type resolve. + /// + [AttributeUsage(AttributeTargets.Class)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class XamlItemsControlAttribute : Attribute { } + + /// + /// XAML attribute. Indicates the property of some BindingBase-derived type, that + /// is used to bind some item of ItemsControl-derived type. This annotation will + /// enable the DataContext type resolve for XAML bindings for such properties. + /// + /// + /// Property should have the tree ancestor of the ItemsControl type or + /// marked with the attribute. + /// + [AttributeUsage(AttributeTargets.Property)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class XamlItemBindingOfItemsControlAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspChildControlTypeAttribute : Attribute + { + public AspChildControlTypeAttribute([NotNull] string tagName, [NotNull] Type controlType) + { + TagName = tagName; + ControlType = controlType; + } + + [NotNull] + public string TagName { get; private set; } + [NotNull] + public Type ControlType { get; private set; } + } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspDataFieldAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspDataFieldsAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspMethodPropertyAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspRequiredAttributeAttribute : Attribute + { + public AspRequiredAttributeAttribute([NotNull] string attribute) + { + Attribute = attribute; + } + + [NotNull] + public string Attribute { get; private set; } + } + + [AttributeUsage(AttributeTargets.Property)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class AspTypePropertyAttribute : Attribute + { + public bool CreateConstructorReferences { get; private set; } + + public AspTypePropertyAttribute(bool createConstructorReferences) + { + CreateConstructorReferences = createConstructorReferences; + } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorImportNamespaceAttribute : Attribute + { + public RazorImportNamespaceAttribute([NotNull] string name) + { + Name = name; + } + + [NotNull] + public string Name { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorInjectionAttribute : Attribute + { + public RazorInjectionAttribute([NotNull] string type, [NotNull] string fieldName) + { + Type = type; + FieldName = fieldName; + } + + [NotNull] + public string Type { get; private set; } + [NotNull] + public string FieldName { get; private set; } + } + + [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorDirectiveAttribute : Attribute + { + public RazorDirectiveAttribute([NotNull] string directive) + { + Directive = directive; + } + + [NotNull] + public string Directive { get; private set; } + } + + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorHelperCommonAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Property)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorLayoutAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorWriteLiteralMethodAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Method)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorWriteMethodAttribute : Attribute { } + + [AttributeUsage(AttributeTargets.Parameter)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class RazorWriteMethodParameterAttribute : Attribute { } + + /// + /// Prevents the Member Reordering feature from tossing members of the marked class. + /// + /// + /// The attribute must be mentioned in your member reordering patterns + /// + [AttributeUsage(AttributeTargets.All)] + [Conditional("JETBRAINS_ANNOTATIONS")] + internal sealed class NoReorder : Attribute { } +} \ No newline at end of file diff --git a/tests/SaasKit.Multitenancy.Tests/MemoryCacheResolverTests.cs b/tests/SaasKit.Multitenancy.Tests/MemoryCacheResolverTests.cs new file mode 100644 index 0000000..1c6ffe2 --- /dev/null +++ b/tests/SaasKit.Multitenancy.Tests/MemoryCacheResolverTests.cs @@ -0,0 +1,246 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; + +namespace SaasKit.Multitenancy.Tests +{ + using System.Threading; + + using Microsoft.AspNetCore.Http; + using Microsoft.AspNetCore.Http.Internal; + using Microsoft.Extensions.Caching.Memory; + using Microsoft.Extensions.Internal; + using Microsoft.Extensions.Logging; + using Microsoft.Extensions.Primitives; + + using Xunit; + + public class MemoryCacheTenantResolverTests + { + private HttpContext CreateContext(string requestPath) + { + var context = new DefaultHttpContext(); + context.Request.Path = requestPath; + + return context; + } + + [Fact] + public async Task Can_retrieve_tenant_from_resolver() + { + var harness = new TestHarness(); + var context = CreateContext("/apple"); + + var tenantContext = await harness.Resolver.ResolveAsync(context); + + Assert.NotNull(tenantContext); + Assert.Equal("fruit", tenantContext.Tenant.Id); + } + + + [Fact] + public async Task Can_retrieve_tenant_from_cache() + { + var harness = new TestHarness(); + var context = CreateContext("/apple"); + + var tenantContext = await harness.Resolver.ResolveAsync(context); + + TenantContext cachedTenant; + + Assert.True(harness.Cache.TryGetValue("/apple", out cachedTenant)); + + Assert.Equal(tenantContext.Tenant.Id, cachedTenant.Tenant.Id); + } + + [Fact] + public async Task Can_retrieve_tenant_from_cache_with_different_key() + { + var harness = new TestHarness(); + var context = CreateContext("/apple"); + + var tenantContext = await harness.Resolver.ResolveAsync(context); + + TenantContext cachedTenant; + + Assert.True(harness.Cache.TryGetValue("/pear", out cachedTenant)); + + Assert.Equal(tenantContext.Tenant.Id, cachedTenant.Tenant.Id); + } + + [Fact] + public async Task Tenant_expires_from_cache() + { + var harness = new TestHarness(cacheExpirationInSeconds: 1, disposeOnExpiration: true); + var context = CreateContext("/apple"); + + var tenantContext = await harness.Resolver.ResolveAsync(context); + + TenantContext cachedTenant; + + Thread.Sleep(3 * 1000); + + Assert.False(harness.Cache.TryGetValue("/pear", out cachedTenant)); + + Assert.Null(cachedTenant); + } + + + [Fact] + public async Task Tenant_expires_from_cache_for_only_its_identifier() + { + TenantContext cachedTenant; + var harness = new TestHarness(cacheExpirationInSeconds: 2, disposeOnExpiration: false); + var context = CreateContext("/apple"); + + // first request for apple + await harness.Resolver.ResolveAsync(CreateContext("/apple")); + + // wait 1 second + Thread.Sleep(1000); + + // second request for pear + await harness.Resolver.ResolveAsync(CreateContext("/pear")); + + // wait 1 second + Thread.Sleep(1000); + + // apple is expired + Assert.False(harness.Cache.TryGetValue("/apple", out cachedTenant), "Apple Exists"); + + // pear is not expired + Assert.True(harness.Cache.TryGetValue("/pear", out cachedTenant), "Pear Does Not Exist"); + } + + + [Fact] + public async Task Tenant_expires_from_cache_for_all_of_its_identifiers_start() + { + var harness = new TestHarness(cacheExpirationInSeconds: 10, disposeOnExpiration: true); + + // first request for apple + await harness.Resolver.ResolveAsync(CreateContext("/apple")); + + // cache should have all 3 entries + Assert.NotNull(harness.Cache.Get("/apple")); + Assert.NotNull(harness.Cache.Get("/pear")); + Assert.NotNull(harness.Cache.Get("/grape")); + + TenantContext cachedTenant; + + // expire apple + harness.Cache.Remove("/apple"); + + // look it up again so it registers + harness.Cache.TryGetValue("/apple", out cachedTenant); + + // need to spin up a new task as "long running" + // so that MemoryCache can fire the eviction callbacks first + await Task.Factory.StartNew(state => { + Thread.Sleep(500); + + // pear is expired - because apple is + Assert.False(harness.Cache.TryGetValue("/pear", out cachedTenant), "Pear Exists"); + }, this, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.FromCurrentSynchronizationContext()); + } + + class TestTenant : IDisposable + { + private bool disposed; + + public string Id { get; set; } + + public List Paths { get; set; } + + public CancellationTokenSource Cts = new CancellationTokenSource(); + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposed) + { + return; + } + + if (disposing) + { + Cts.Cancel(); + } + + disposed = true; + } + } + + class TestTenantMemoryCacheResolver : MemoryCacheTenantResolver + { + readonly List tenants = new List() + { + new TestTenant() { Id = "fruit", Paths = new List() { "/apple","/pear","/grape" }}, + new TestTenant() { Id = "vegetable", Paths = new List() { "/lettuce","/carrot","/onion" }} + }; + + private readonly int cacheExpirationInSeconds; + + public TestTenantMemoryCacheResolver(IMemoryCache cache, ILoggerFactory loggerFactory, bool disposeOnExpiration = true, int cacheExpirationInSeconds = 10) + : base(cache, loggerFactory) + { + this.DisposeTenantOnExpiration = disposeOnExpiration; + this.cacheExpirationInSeconds = cacheExpirationInSeconds; + } + + protected override bool DisposeTenantOnExpiration { get; } + + protected override MemoryCacheEntryOptions CreateCacheEntryOptions() + { + return new MemoryCacheEntryOptions() + .SetSlidingExpiration(TimeSpan.FromSeconds(cacheExpirationInSeconds)); + } + + protected override string GetContextIdentifier(HttpContext context) + { + return context.Request.Path; + } + + protected override IEnumerable GetTenantIdentifiers(TenantContext context) + { + return context?.Tenant?.Paths; + } + + protected override Task> ResolveAsync(HttpContext context) + { + var tenant = tenants.FirstOrDefault(testTenant => testTenant.Paths.Contains(context.Request.Path)); + + var tenantContext = new TenantContext(tenant); + + tenantContext.Properties.Add("Created", DateTime.UtcNow); + + return Task.FromResult(tenantContext); + } + } + + class TestHarness + { + static ILoggerFactory loggerFactory = new LoggerFactory().AddConsole(); + + public IMemoryCache Cache = new MemoryCache(new MemoryCacheOptions() + { + // for testing purposes, we'll scan every 100 milliseconds + ExpirationScanFrequency = TimeSpan.FromMilliseconds(100), + Clock = new SystemClock() + }); + + public TestHarness(bool disposeOnExpiration = false, int cacheExpirationInSeconds = 10) + { + Resolver = new TestTenantMemoryCacheResolver(Cache, loggerFactory, disposeOnExpiration, cacheExpirationInSeconds); + } + + public ITenantResolver Resolver { get; } + } + } +} diff --git a/tests/SaasKit.Multitenancy.Tests/project.json b/tests/SaasKit.Multitenancy.Tests/project.json index dd177a8..cabd9d5 100644 --- a/tests/SaasKit.Multitenancy.Tests/project.json +++ b/tests/SaasKit.Multitenancy.Tests/project.json @@ -14,7 +14,7 @@ "testRunner": "xunit", "dependencies": { - "xunit": "2.2.0-beta2-build3254", + "xunit": "2.2.0-beta2-*", "Microsoft.AspNetCore.Http": "1.0.0", "Microsoft.AspNetCore.Hosting": "1.0.0", "Microsoft.AspNetCore.TestHost": "1.0.0", @@ -24,7 +24,8 @@ "version": "2.2.0-preview2-build1029", "target": "package" }, - "Microsoft.NETCore.Platforms": "1.0.1" + "Microsoft.NETCore.Platforms": "1.0.1", + "Microsoft.Extensions.Logging.Console": "1.0.0" }, "frameworks": { /*"net46": { @@ -35,14 +36,14 @@ "netcoreapp1.0": { "dependencies": { "Microsoft.NETCore.App": { - "version": "1.0.0-rc2-*", + "version": "1.0.0", "type": "platform" }, - "Microsoft.CSharp": "4.0.1-rc2-*", - "System.Collections": "4.0.11-rc2-*", - "System.Linq": "4.1.0-rc2-*", - "System.Runtime": "4.1.0-rc2-*", - "System.Threading": "4.0.11-rc2-*" + "Microsoft.CSharp": "4.0.1", + "System.Collections": "4.0.11", + "System.Linq": "4.1.0", + "System.Runtime": "4.1.0", + "System.Threading": "4.0.11" }, "imports": [ "dnxcore50",