Attribute AOP 特性和AOP

最新推荐文章于 2020-06-27 16:39:34 发布
最新推荐文章于 2020-06-27 16:39:34 发布
阅读量181 收藏
点赞数
原文链接：http://www.cnblogs.com/zhengqian/p/8615112.html
版权 

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

using Castle.DynamicProxy;//Castle.Core

namespace MyAttribute.AOPWay
{
    /// <summary>
    /// 使用Castle\DynamicProxy 实现动态代理
    /// </summary>
    public class CastleProxy
    {
        public static void Show()
        {
            User user = new User() { Name = "Eleven", Password = "123123123123" };
            ProxyGenerator generator = new ProxyGenerator();
            MyInterceptor interceptor = new MyInterceptor();
            UserProcessor userprocessor = generator.CreateClassProxy<UserProcessor>(interceptor);
            userprocessor.RegUser(user);
        }


        public class MyInterceptor : IInterceptor
        {
            public void Intercept(IInvocation invocation)
            {
                PreProceed(invocation);
                invocation.Proceed();
                PostProceed(invocation);
            }
            public void PreProceed(IInvocation invocation)
            {
                Console.WriteLine("方法执行前");
            }

            public void PostProceed(IInvocation invocation)
            {
                Console.WriteLine("方法执行后");
            }
        }

        public interface IUserProcessor
        {
            void RegUser(User user);
        }

        public class UserProcessor : IUserProcessor
        {
            public virtual void RegUser(User user)
            {
                Console.WriteLine("用户已注册。Name:{0},PassWord:{1}", user.Name, user.Password);
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAttribute.AOPWay
{
    /// <summary>
    /// 装饰器模式实现静态代理
    /// AOP 在方法前后增加自定义的方法
    /// </summary>
    public class Decorator
    {
        public static void Show()
        {
            User user = new User() { Name = "Eleven", Password = "123123123123" };
            IUserProcessor processor = new UserProcessor();
            processor = new UserProcessorDecorator(processor);
            processor.RegUser(user);
        }

        public interface IUserProcessor
        {
            void RegUser(User user);
        }
        public class UserProcessor : IUserProcessor
        {
            public void RegUser(User user)
            {
                Console.WriteLine("用户已注册。Name:{0},PassWord:{1}", user.Name, user.Password);
            }
        }

        /// <summary>
        /// 装饰器的模式去提供一个AOP功能
        /// </summary>
        public class UserProcessorDecorator : IUserProcessor
        {
            private IUserProcessor UserProcessor { get; set; }
            public UserProcessorDecorator(IUserProcessor userprocessor)
            {
                UserProcessor = userprocessor;
            }

            public void RegUser(User user)
            {
                PreProceed(user);
                try
                {
                    this.UserProcessor.RegUser(user);
                }
                catch (Exception)
                {

                    throw;
                }
                PostProceed(user);
            }

            public void PreProceed(User user)
            {
                Console.WriteLine("方法执行前");
            }

            public void PostProceed(User user)
            {
                Console.WriteLine("方法执行后");
            }
        }

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

namespace MyAttribute.AOPWay
{

    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Password { get; set; }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;
using System.Text;
using System.Threading.Tasks;

namespace MyAttribute.AOPWay
{
    /// <summary>
    /// 使用.Net Remoting/RealProxy 实现动态代理
    /// </summary>
    public class Proxy
    {
        public static void Show()
        {
            User user = new User() { Name = "Eleven", Password = "123123123123" };

            //UserProcessor processor = new UserProcessor();

            UserProcessor userprocessor = TransparentProxy.Create<UserProcessor>();
            userprocessor.RegUser(user);
        }

        public class MyRealProxy<T> : RealProxy
        {
            private T tTarget;
            public MyRealProxy(T target)
                : base(typeof(T))
            {
                this.tTarget = target;
            }

            public override IMessage Invoke(IMessage msg)
            {
                PreProceede(msg);
                IMethodCallMessage callMessage = (IMethodCallMessage)msg;
                object returnValue = callMessage.MethodBase.Invoke(this.tTarget, callMessage.Args);
                PostProceede(msg);
                return new ReturnMessage(returnValue, new object[0], 0, null, callMessage);
            }
            public void PreProceede(IMessage msg)
            {
                Console.WriteLine("方法执行前");
            }
            public void PostProceede(IMessage msg)
            {
                Console.WriteLine("方法执行后");
            }
        }

        //TransparentProxy
        public static class TransparentProxy
        {
            public static T Create<T>()
            {
                T instance = Activator.CreateInstance<T>();
                MyRealProxy<T> realProxy = new MyRealProxy<T>(instance);
                T transparentProxy = (T)realProxy.GetTransparentProxy();
                return transparentProxy;
            }
        }

        public interface IUserProcessor
        {
            void RegUser(User user);
        }

        public class UserProcessor : MarshalByRefObject, IUserProcessor
        {
            public void RegUser(User user)
            {
                Console.WriteLine("用户已注册。用户名称{0} Password{1}", user.Name, user.Password);
            }
        }

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

using Microsoft.Practices.Unity.InterceptionExtension;//InterceptionExtension扩展
using Microsoft.Practices.Unity;
namespace MyAttribute.AOPWay
{
    /// <summary>
    /// 使用EntLib\PIAB Unity 实现动态代理
    /// </summary>
    public class UnityAOP
    {
        public static void Show()
        {
            User user = new User()
            {
                Name = "Eleven",
                Password = "123123123123"
            };

            IUnityContainer container = new UnityContainer();//声明一个容器
            container.RegisterType<IUserProcessor, UserProcessor>();//声明UnityContainer并注册IUserProcessor
            IUserProcessor processor = container.Resolve<IUserProcessor>();
            processor.RegUser(user);//调用

            container.AddNewExtension<Interception>().Configure<Interception>()
                .SetInterceptorFor<IUserProcessor>(new InterfaceInterceptor());


            //IUserProcessor userprocessor = new UserProcessor();
            IUserProcessor userprocessor = container.Resolve<IUserProcessor>();

            Console.WriteLine("********************");
            userprocessor.RegUser(user);//调用
            //userprocessor.GetUser(user);//调用
        }

        #region 特性对应的行为
        public class UserHandler : ICallHandler
        {
            public int Order { get; set; }
            public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
            {
                User user = input.Inputs[0] as User;
                if (user.Password.Length < 10)
                {
                    return input.CreateExceptionMethodReturn(new Exception("密码长度不能小于10位"));
                }
                Console.WriteLine("参数检测无误");


                IMethodReturn methodReturn = getNext.Invoke().Invoke(input, getNext);

                //Console.WriteLine("已完成操作");

                return methodReturn;
            }
        }

        public class LogHandler : ICallHandler
        {
            public int Order { get; set; }
            public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
            {
                User user = input.Inputs[0] as User;
                string message = string.Format("RegUser:Username:{0},Password:{1}", user.Name, user.Password);
                Console.WriteLine("日志已记录，Message:{0},Ctime:{1}", message, DateTime.Now);
                return getNext()(input, getNext);
            }
        }


        public class ExceptionHandler : ICallHandler
        {
            public int Order { get; set; }
            public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
            {
                IMethodReturn methodReturn = getNext()(input, getNext);
                if (methodReturn.Exception == null)
                {
                    Console.WriteLine("无异常");
                }
                else
                {
                    Console.WriteLine("异常:{0}", methodReturn.Exception.Message);
                }
                return methodReturn;
            }
        }

        public class AfterLogHandler : ICallHandler
        {
            public int Order { get; set; }
            public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
            {
                IMethodReturn methodReturn = getNext()(input, getNext);
                User user = input.Inputs[0] as User;
                string message = string.Format("RegUser:Username:{0},Password:{1}", user.Name, user.Password);
                Console.WriteLine("完成日志，Message:{0},Ctime:{1},计算结果{2}", message, DateTime.Now, methodReturn.ReturnValue);
                return methodReturn;
            }
        }
        #endregion 特性对应的行为

        #region 特性
        public class UserHandlerAttribute : HandlerAttribute
        {
            public override ICallHandler CreateHandler(IUnityContainer container)
            {
                ICallHandler handler = new UserHandler() { Order = this.Order };
                return handler;
            }
        }

        public class LogHandlerAttribute : HandlerAttribute
        {
            public override ICallHandler CreateHandler(IUnityContainer container)
            {
                return new LogHandler() { Order = this.Order };
            }
        }

        public class ExceptionHandlerAttribute : HandlerAttribute
        {
            public override ICallHandler CreateHandler(IUnityContainer container)
            {
                return new ExceptionHandler() { Order = this.Order };
            }
        }

        public class AfterLogHandlerAttribute : HandlerAttribute
        {
            public override ICallHandler CreateHandler(IUnityContainer container)
            {
                return new AfterLogHandler() { Order = this.Order };
            }
        }
        #endregion 特性

        #region 业务
        [UserHandlerAttribute(Order = 1)]
        [ExceptionHandlerAttribute(Order = 3)]
        [LogHandlerAttribute(Order = 2)]
        [AfterLogHandlerAttribute(Order = 5)]
        public interface IUserProcessor
        {
            void RegUser(User user);
            User GetUser(User user);
        }

        public class UserProcessor : IUserProcessor//MarshalByRefObject,
        {
            public void RegUser(User user)
            {
                Console.WriteLine("用户已注册。");
                //throw new Exception("11");
            }

            public User GetUser(User user)
            {
                return user;
            }
        }
        #endregion 业务

        /*
         TransparentProxyInterceptor：直接在类的方法上进行标记，但是这个类必须继承MarshalByRefObject...不建议用
         VirtualMethod：直接在类的方法上进行标记，但这个方法必须是虚方法（就是方法要带virtual关键字）
         InterfaceInterceptor：在接口的方法上进行标记，这样继承这个接口的类里实现这个接口方法的方法就能被拦截
         */
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAttribute.AttributeExtend
{
    public class BaseDAL
    {
        /// <summary>
        /// 校验而且保存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        public static void Save<T>(T t)
        {
            bool isSafe = true;

            Type type = t.GetType();

            foreach (var property in type.GetProperties())
            {
                object[] oAttributeList = property.GetCustomAttributes(true);
                foreach (var item in oAttributeList)
                {
                    if (item is IntValidateAttribute)
                    {
                        IntValidateAttribute attribute = item as IntValidateAttribute;
                        isSafe = attribute.Validate((int)property.GetValue(t));
                    }
                }
                if (!isSafe)
                    break;
            }

            if (isSafe)
                Console.WriteLine("保存到数据库");
            else
                Console.WriteLine("数据不合法");
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace MyAttribute.AttributeExtend
{
    public enum UserState
    {
        /// <summary>
        /// 正常
        /// </summary>
        [Remark("正常")]
        Normal = 0,
        /// <summary>
        /// 冻结
        /// </summary>
        [Remark("冻结")]
        Frozen = 1,
        /// <summary>
        /// 删除
        /// </summary>
        [Remark("删除")]
        Delete = 2
    }

    //public enum UserState1
    //{
    //    /// <summary>
    //    /// 正常
    //    /// </summary>
    //    [Remark("正常")]
    //    正常 = 0,
    //    /// <summary>
    //    /// 冻结
    //    /// </summary>
    //    [Remark("冻结")]
    //    冻结 = 1,
    //    /// <summary>
    //    /// 删除
    //    /// </summary>
    //    [Remark("删除")]
    //    删除 = 2
    //}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace MyAttribute.AttributeExtend
{
    public class RemarkAttribute : Attribute
    {
        public RemarkAttribute(string remark)
        {
            _Remark = remark;
        }

        private string _Remark;

        public string Remark
        {
            get
            {
                return _Remark;
            }
        }
    }


    public static class RemarkExtend
    {
        public static string GetRemark(this Enum eValue)
        {
            Type type = eValue.GetType();
            FieldInfo field = type.GetField(eValue.ToString());
            RemarkAttribute remarkAttribute = (RemarkAttribute)field.GetCustomAttribute(typeof(RemarkAttribute));
            return remarkAttribute.Remark;
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAttribute.AttributeExtend
{
    [AttributeUsage(AttributeTargets.Property)]
    public class IntValidateAttribute : Attribute
    {

        private int _Min = 0;
        private int _Max = 0;

        public IntValidateAttribute(int min, int max)
        {
            this._Min = min;
            this._Max = max;
        }

        public bool Validate(int num)
        {
            return num > this._Min && num < this._Max;
        }


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

namespace MyAttribute
{
    /// <summary>
    /// 特性是一个继承或者间接继承Attribute的类
    /// 通常用attribute结尾，那么在使用的时候，可以去掉这个结尾
    /// 
    /// </summary>

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
    public class CustomAttribute : Attribute
    {
        public CustomAttribute()
        { }

        public CustomAttribute(int id)
        { }

        public CustomAttribute(int id, string name)
        { }

        public string Remark { get; set; }

        public string Description = null;

        public void Show()
        { }
    }

    public class TableAttribute : Attribute
    {
        private string _TableName = null;

        public TableAttribute(string tableName)
        {
            this._TableName = tableName;
        }

        public string GetTableName()
        {
            return this._TableName;
        }

    }

    public class CustomChildAttribute : CustomAttribute
    {
    }

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

namespace MyAttribute
{
    public static class Extend
    {
        /// <summary>
        /// 根据类型获取表名称
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static string GetTableName<T>(this T t) where T : new()
        {
            Type type = t.GetType();
            object[] oAttributeList = type.GetCustomAttributes(true);
            foreach (var item in oAttributeList)
            {
                if (item is TableAttribute)
                {
                    TableAttribute attribute = item as TableAttribute;
                    return attribute.GetTableName();
                }
            }

            return type.Name;
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAttribute
{
    /// <summary>
    /// 这里是注释，除了让人看懂这里写的是什么，对运行没有任何影响
    /// </summary>
    //[Obsolete("请不要使用这个了，请使用什么来代替", true)]
    [Serializable]
    public class People
    {
        //[Obsolete("请不要使用这个了1")]

        public int Id { get; set; }
        public string Name { get; set; }
    }
}
using MyAttribute.AOPWay;
using MyAttribute.AttributeExtend;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAttribute
{
    /// <summary>
    /// 1 特性attribute，和注释有什么区别
    /// 特性可以影响编译
    /// 特性可以影响运行
    /// 2 声明和使用attribute
    /// 3 应用attribute
    /// 特性就是在不影响类型封装的前提下，额外的添加一些信息
    /// 如果你用这个信息，那特性就有用，
    /// 如果你不管这个信息，那特性就没用
    /// 
    /// 4 AOP面向切面编程 
    /// Aspect Oriented Programming
    /// OOP 面向对象编程
    /// 
    /// 5 多种方式实现AOP
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("今天的内容是特性和AOP===================================");
                People people = new People();

                UserModel user = new UserModel();
                user.Id = 1;

                string name = user.GetTableName<UserModel>();

                string remark = UserState.Normal.GetRemark();

                BaseDAL.Save<UserModel>(user);


                #region AOP show
                Console.WriteLine("***********************");
                Decorator.Show();
                Console.WriteLine("***********************");
                Proxy.Show();
                Console.WriteLine("***********************");
                CastleProxy.Show();
                Console.WriteLine("***********************");
                UnityAOP.Show();
                #endregion
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }
    }
}
using MyAttribute.AttributeExtend;
using System;
namespace MyAttribute
{
    /// <summary>
    /// User:实体类(业务信息)
    /// </summary>
    //[CustomAttribute]
    //[Custom]
    //[CustomAttribute()]
    //[Custom()]
    //[Custom(123)]
    //[CustomAttribute(123)]
    //[Custom(123,"456")]
    //[CustomAttribute(123, "456")]
    //[Custom(Remark="这里是特性")]
    //[Custom(123, Remark = "这里是特性")]
    //[CustomAttribute(123, Remark = "这里是特性")]
    //[Custom(123, "456",Remark="这里是特性")]
    //[CustomAttribute(123, "456", Remark = "这里是特性", Description = "Description")]










    [Table("User")]

    public class UserModel
    {
        //public string TableName = "User";

        [IntValidateAttribute(0, 10000)]
        //[IntValidateAttribute(2, 5000)]
        public int Id { get; set; }
        #region Model

        /// <summary>
        /// 
        /// </summary>
        public string Account
        {
            set;
            get;
        }
        /// <summary>
        /// 密码
        /// </summary>
        public string Password
        {
            set;
            get;
        }
        /// <summary>
        /// EMaill
        /// </summary>
        public string Email
        {
            set;
            get;
        }
        /// <summary>
        /// 手提
        /// </summary>
        public string Mobile
        {
            set;
            get;
        }
        /// <summary>
        /// 企业ID
        /// </summary>
        public int? CompanyId
        {
            set;
            get;
        }
        /// <summary>
        /// 企业名称
        /// </summary>
        public string CompanyName
        {
            set;
            get;
        }
        /// <summary>
        /// 用户状态  0正常 1冻结 2删除
        /// </summary>
        public int? State
        {
            set;
            get;
        }
        /// <summary>
        /// 用户类型  1 普通用户 2管理员 4超级管理员
        /// </summary>
        public int? UserType
        {
            set;
            get;
        }
        /// <summary>
        /// 最后一次登陆时间
        /// </summary>
        public DateTime? LastLoginTime
        {
            set;
            get;
        }

        /// <summary>
        /// 最后一次修改人
        /// </summary>
        public int? LastModifierId
        {
            set;
            get;
        }
        /// <summary>
        /// 最后一次修改时间
        /// </summary>
        public DateTime? LastModifyTime
        {
            set;
            get;
        }
        #endregion Model

    }
}

 

转载于:https://www.cnblogs.com/zhengqian/p/8615112.html

weixin_34258838
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c#用特性实现aop_C#基础-特性(Attribute+AOP)
weixin_39854951的博客
12-19 665
序言:一个程序员在海滩上发现了一盏神灯。他在灯上擦了几下，一个妖怪就从灯里跳出来说：“我是世界上法术最强的妖怪。我可以实现你的任何梦想，但现在，我只能满足你一个愿望。”程序员摊开了一幅中东地图说：“我想让中东得到永久的和平。”妖怪答道：“哦，我没办法。自打创世纪以来，那里的战火就没有停息过。这世上几乎没有我办不到的事，但这件事除外。”程序员于是说：“好吧，我是一个程序员，我编写的程序有许多用户。你...
c#用特性实现aop_利用C#实现AOP常见的几种方法详解
weixin_39989443的博客
12-19 516
前言AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的中统一处理业务逻辑的一种技术，比较常见的场景是：日志记录，错误捕获、性能监控等AOP的本质是通过代理对象来间接执行真实对象，在代理类中往往会添加装饰一些额外的业务代码，比如如下代码：class RealA{public virtual string Pro { ...
.net中attribute实现方法调用拦截(就是aop)
04-19
包含2篇attribute高级应用文章，以及相应的代码。 代码关键处，都有详细注释。 看过后，你会对attribute,context有更深刻的认识
Attribute（特性）与AOP
weixin_30855099的博客
08-24 175
提到特性，好多人都会疑惑特性(attribute)，和注释有什么区别，简单来说，特性是给机器看的，而注释是给人看的。 特性不仅可以影响编译还可以影响运行，而注释只是为了让人更加容易理解、看懂代码而特别加注的解释而已。 那么怎么声明一个特性呢。 特性是一个继承或者间接继承Attribute的类通常用attribute结尾，那么在使用的时候，可以去掉这个结尾 public class ...
Attribute 实现Aop
weixin_30347009的博客
06-12 110
1、先定义一个 拦截属性 AopAttribute using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ZH.Aop { using System...
【C# / Pattern】C#中利用Attribute实现AOP(面向切面编程)
ls9512
01-05 1万+
AOP - 面向切面编程 在软件业，AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，
利用Attribute实现AOP
weixin_30709635的博客
11-12 131
AOP现在是如火如荼，DotNet下的AOP框架也不少，但是如果你仅仅是需要写日志、权限管理这样的不是十分庞大规模的模块的话，真的是没有必要去引用一个或多个dll，所谓的“没有你在，我自己来”，也大概就是这样吧。 现在通用的做法一般有两种：一个是上下文消息传递，一个是利用代理RealProxy，这里的做法是前面一种。 首先定义一个Attribute。 1[AttributeUsag...
利用C#实现AOP常见的几种方法详解
08-29
C#支持特性（Attribute），可以定义自定义特性来表示切面，并在运行时通过反射找到并执行这些特性。这种方式简单易用，但可能会导致代码可读性下降，且需要在运行时解析特性，性能上可能不如前两者。 4. **拦截器...
特性attribute,声明和使用attribute,应用attribute,AOP面向切面,多种方式实现AOP
weixin_30556161的博客
07-31 139
1 特性attribute，和注释有什么区别2 声明和使用attribute3 应用attribute4 AOP面向切面5 多种方式实现AOP 　　　　　　　　　　　------------------------------Anker_张 (博客园) 文件下载 链接: http://pan.baidu.com/s/1o8kctGe 密码: q6yh 特性是一个继承或者间接继承Att...
自己实现简单的AOP（二）引入Attribute 为方法指定增强对象
weixin_33812433的博客
08-31 112
话续前文 ： 自己实现简单的AOP（一）简介    在前一篇文章中，对AOP的实现方式做了一个简单介绍。接下来，引入Attribute 为方法指定增强对象，由此实现一个简单的AOP。 注意：指定的是增强对象，“对象”，也就是说Attribute标记，标记的其实是一个对象。由此、使用多态便可轻松实现增强的扩展。   自定义的Attribute  /// &lt;summa...
用Attribute实现AOP事务
weixin_34279246的博客
05-23 107
前言      使用Attribute来实现方法级别事务一直是我的梦想，浅谈Attribute [C# | Attribute | DefaultValueAttribute]有体现我的无奈，Attribute确实是真真切切的非侵入式的东西(其实我是想侵入的: ) )，前有DUDU的Attribute在.net编程中的应用系列文章，但是总是离想象和需求有那么点出入，通过三天的努力，Google的...
利用Attribute实现Aop
weixin_30252155的博客
12-01 93
Aop“面向切面编程”，与OOP“面向对象编程”一样是一种编程思路。个人理解：在不改变原有逻辑的基础上，注入其他行为。 基础代码（仿MVC拦截器实现） namespace HGL.Toolkit.Aop { [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] public sea...
.net利用Attribute简单实现AOP
Mcdull28的专栏
02-07 5127
近日在学AOP,前一篇文章是基于透明代理/真实代理实现的,(前文参考链接:http://blog.csdn.net/jiujiu28/article/details/43562909),但是每次实现AOP之前需要实例化一个新对象,总感觉不爽.这不.接下来我们使用Attribute来实现AOP. 一、什么是Attribute？ Attribute是一个类,在MSDN文档中对它是这样描述的。
使用HandleErrorAttribute处理异常
weixin_30751947的博客
04-11 502
ASP.NET MVC 默认提供了一个异常过滤器HandleError特性，使用该特性可以极为方便的捕捉并处理控制器和操作抛出的异常，也可以将此特性注册为全局异常过滤器从而捕捉项目中的所有异常。如果想要简单的消灭错误黄页（错误详细页），使用HandlerErrorAttribute是不错的选择！ 本文演示项目下载地址：GlobalExceptionHandle-By-HandleErrorAtt...
Ioc 之 Unity的AOP功能
weixin_30252155的博客
06-18 209
　　前面我们介绍了Unity的依赖注入功能，现在来介绍下Unity的AOP功能。AOP是面向切面编程，它能够使我们在不改变现有代码结构的情况下额外的为其添加一些功能。 　　我们还是使用配置文件来对类型进行注入 <configuration> <configSections> <!--<section name="unity" type="...
(精华)2020年6月27日 C#类库 BaseAOPAttribute(Castle-AOP的封装)
热门推荐
时光隧道
06-27 56万+
using System; using System.Threading.Tasks; namespace Core.Util { /// <summary> /// AOP基类 /// 注:不支持控制器,需要定义接口并实现接口,自定义AOP特性放到接口实现类上 /// </summary> public abstract class BaseAOPAttribute : Attribute { public virt
C# 用Attribute实现AOP事务
weixin_34242331的博客
01-07 237
前言      使用Attribute来实现方法级别事务一直是我的梦想，浅谈Attribute [C# | Attribute | DefaultValueAttribute]有体现我的无奈，Attribute确实是真真切切的非侵入式的东西(其实我是想侵入的: ) )，前有DUDU的Attribute在.net编程中的应用系列文章，但是总是离想象和需求有那么点出入，通过三天的努力，Google的...
Unity容器中AOP应用示例程序
anfeng4628的博客
06-02 147
转发请注明出处：https://www.cnblogs.com/zhiyong-ITNote/p/9127001.html 实在没有找到Unity容器的AOP应用程序示例的说明，在微软官网找到了教程（https://docs.microsoft.com/zh-cn/previous-versions/msp-n-p/dn507492(v%3dpandp.30)）看的眼睛疼，而且说得也不...
C# AOP基础与简单实现解析
在C#中实现AOP，我们可以选择第三方库如PostSharp或使用.NET自带的特性（Attribute）结合反射来实现。例如，定义一个特性`LogAttribute`，然后将其应用于需要日志记录的方法上，就可以在运行时自动进行日志记录，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值