AOP：权限、缓存示例

只有代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.InterceptionExtension;

namespace AOPStudy
{
    class Program
    {
        static void Main(string[] args)
        {
            var container = new UnityContainer()
                .AddNewExtension<Interception>()
                .RegisterType<ICacheManager, CacheManager>()
                .RegisterType<IPermissionService, PermissionService>()
                .RegisterType<IAuthenticationService, AuthenticationService>()
                .RegisterType<IApplicationService, ApplicationService>();

            container
                .Configure<Interception>()
                .SetInterceptorFor<IApplicationService>(new InterfaceInterceptor())
                .SetInterceptorFor<IPermissionService>(new InterfaceInterceptor());

            var applicationService = container.Resolve<IApplicationService>();

            Console.WriteLine("************************");
            applicationService.DoSometing();
            Console.WriteLine("************************");
            applicationService.DoSometing();
        }
    }

    public interface IApplicationService
    {
        void DoSometing();
    }

    public class ApplicationService : IApplicationService
    {
        [Permission]
        public void DoSometing()
        {
            //此处执行业务逻辑
        }
    }

    public class PermissionHandler : ICallHandler
    {
        private IAuthenticationService _AuthenticationService;

        public PermissionHandler(IAuthenticationService authenticationService)
        {
            _AuthenticationService = authenticationService;
        }

        public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
        {
            var userId = new Guid("58E4E105-96E9-42BE-83E4-01B6010D04BB");//真实项目中从Session中获取
            var permissionId = Guid.NewGuid();//真实项目中从自定义Attribute中获取

            if (!_AuthenticationService.HasPermission(userId, permissionId))
            {
                Console.WriteLine("您没有权限");
                //真实项目中需要抛出自定义异常
            }
            else
            {
                Console.WriteLine("您有权限");
            }

            return getNext()(input, getNext);
        }

        public int Order { get; set; }
    }

    public class PermissionAttribute : HandlerAttribute
    {
        public override ICallHandler CreateHandler(IUnityContainer container)
        {
            return container.Resolve<PermissionHandler>();
        }
    }

    public class CacheHandler : ICallHandler
    {
        private ICacheManager _CacheManager;

        public CacheHandler(ICacheManager cacheManager)
        {
            _CacheManager = cacheManager;
        }

        public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
        {
            string key = input.Arguments[0].ToString();//真实项目设置自己的策略

            if (!_CacheManager.Has(key))
            {
                _CacheManager.Add(key, getNext()(input, getNext));
                Console.WriteLine("只会执行一次");
            }

            return _CacheManager.Get(key) as IMethodReturn;
        }

        public int Order { get; set; }
    }

    public class CacheAttribute : HandlerAttribute
    {
        public override ICallHandler CreateHandler(IUnityContainer container)
        {
            return container.Resolve<CacheHandler>();
        }
    }

    public class Permission
    {
        public Guid PermissionId { get; set; }
    }

    public interface IPermissionService
    {
        IEnumerable<Permission> FindPermissionByUserId(Guid userId);
    }

    public class PermissionService : IPermissionService
    {
        [Cache]
        public IEnumerable<Permission> FindPermissionByUserId(Guid userId)
        {
            return new List<Permission> { new Permission() { PermissionId = Guid.NewGuid() } };
        }
    }

    public interface IAuthenticationService
    {
        bool HasPermission(Guid userId, Guid permissionId);
    }

    public class AuthenticationService : IAuthenticationService
    {
        private IPermissionService _PermissionService;

        public AuthenticationService(IPermissionService permissionService)
        {
            _PermissionService = permissionService;
        }

        public bool HasPermission(Guid userId, Guid permissionId)
        {
            return _PermissionService.FindPermissionByUserId(userId).Any(x => x.PermissionId == permissionId);
        }
    }

    public interface ICacheManager
    {
        void Add(string key, object value);

        bool Has(string key);

        object Get(string key);
    }

    public class CacheManager : ICacheManager
    {
        private static Dictionary<string, object> _Values = new Dictionary<string, object>();

        public void Add(string key, object value)
        {
            _Values.Add(key, value);
        }

        public bool Has(string key)
        {
            return _Values.ContainsKey(key);
        }

        public object Get(string key)
        {
            return _Values[key];
        }
    }
}