C# Postsharp MethodInterceptionSpect属性引发EntrypointNotFoundException

我最近将PostSharp更新为v4.1.13，在尝试构建解决方案时，我开始收到此错误：

自定义属性“True.Kentico.Caching.KenticoCacheAttribute”构造函数引发异常EntryPointNotFoundException:未找到入口点

这个属性实现了缓存，并且以前已经工作过，所以我想知道它崩溃的原因是什么。我在引用方面的包含程序集的其他程序集中使用了这个属性，我在其中也得到了这个错误

以下是该属性的代码。抱歉，它包含许多构造函数

[Serializable]
public class KenticoCacheAttribute : MethodInterceptionAspect
{
    public int CacheMinutes { get; set; }

    /// <summary>
    /// the string value of the cache dependency key. If it uses parameters from the method, include a {0} to format with the method parameter 
    /// </summary>
    public string CacheDependency { get; set; }
    public string[] CacheDependencyStrings { get; set; }

    public KenticoCacheDependencyObtainFrom ObtainCacheDependencyFrom { get; set; }

    /// <summary>
    /// whether caching is enabled - default from app settings
    /// </summary>
    public bool CacheEnabled { get; set; }

    /// <summary>
    /// this is the index of the parameter that will be used to format the cachedependency, if required 
    /// </summary>
    public int CacheDependencyParameterIndex { get; set; }


    public string CacheDependencyObjectProperty { get; set; }

    private string _methodName;

    /// <summary>
    /// initializes the cache attribute to use a static dependency
    /// </summary>
    /// <param name="cacheDependency"></param>
    public KenticoCacheAttribute(string cacheDependency)
    {
        CacheMinutes = EngineContext.Current.Resolve<AppSettings>().Cache.TTL.GlobalSetting;
        CacheEnabled = !EngineContext.Current.Resolve<AppSettings>().Cache.IgnoreCache;
        CacheDependencyParameterIndex = -1;
        CacheDependency = cacheDependency;
        if (String.IsNullOrEmpty(cacheDependency))
            ObtainCacheDependencyFrom = KenticoCacheDependencyObtainFrom.NoDependency;
        else
        {

            ObtainCacheDependencyFrom = KenticoCacheDependencyObtainFrom.Static;
        }
    }

    /// <summary>
    /// initializes the cache attribute to use a static dependency using multiple depndencies
    /// </summary>
    /// <param name="cacheDependencystrings">an array of strings</param>
    public KenticoCacheAttribute(string[] cacheDependencystrings)
    {
        CacheMinutes = EngineContext.Current.Resolve<AppSettings>().Cache.TTL.GlobalSetting;
        CacheEnabled = !EngineContext.Current.Resolve<AppSettings>().Cache.IgnoreCache;
        CacheDependencyParameterIndex = -1;
        CacheDependencyStrings = cacheDependencystrings;
        ObtainCacheDependencyFrom = KenticoCacheDependencyObtainFrom.MultipleDependenciesStatic;
    }

    /// <summary>
    /// initializes the cache attribute to take the dependency from the input parameter 
    /// </summary>
    /// <param name="cacheDependency">the static string to be used for the cache dependency. you may include {CurrentSiteName} to be replaced with the current site name, and {0} to be replaced with the value passed in as one of the method parameters</param>
    /// <param name="cacheDependencyParameterIndex">the index of the parameter in the method parameters that will be used to create the cache dependency key</param>
    public KenticoCacheAttribute(string cacheDependency, int cacheDependencyParameterIndex)
    {
        CacheMinutes = EngineContext.Current.Resolve<AppSettings>().Cache.TTL.GlobalSetting;
        CacheEnabled = !EngineContext.Current.Resolve<AppSettings>().Cache.IgnoreCache;
        CacheDependencyParameterIndex = cacheDependencyParameterIndex;
        CacheDependency = cacheDependency;
        if (String.IsNullOrEmpty(cacheDependency))
        {

            ObtainCacheDependencyFrom = KenticoCacheDependencyObtainFrom.MultipleDependenciesFromParameter;
        }
        else
        {

            ObtainCacheDependencyFrom = KenticoCacheDependencyObtainFrom.FromMethodParameter;
        }
    }

    /// <summary>
    /// initialize the cache attribute to obtain the cache dependency from the named property of the return object 
    /// </summary>
    /// <param name="cacheDependency">the static string to be used for the cache dependency. you may include {CurrentSiteName} to be replaced with the current site name, and {0} to be replaced with the value in the named parameter </param>
    /// <param name="cacheDependencyObjectPropertyName">the name of the property of the return object that will be used to replace the placeholder in the static string to build the cache dependency string</param>
    public KenticoCacheAttribute(string cacheDependency, string cacheDependencyObjectPropertyName)
    {
        CacheMinutes = EngineContext.Current.Resolve<AppSettings>().Cache.TTL.GlobalSetting;
        CacheEnabled = !EngineContext.Current.Resolve<AppSettings>().Cache.IgnoreCache;
        CacheDependencyParameterIndex = -1;
        CacheDependency = cacheDependency;
        ObtainCacheDependencyFrom = KenticoCacheDependencyObtainFrom.FromReturnObject;
        CacheDependencyObjectProperty = cacheDependencyObjectPropertyName;
    }

    /// <summary>
    /// initialize the cache attribute to obtain the cache dependency from the named property of the return object 
    /// </summary>
    /// <param name="cacheDependency">the static string to be used for the cache dependency. you may include {CurrentSiteName} to be replaced with the current site name, and {0} to be replaced with the value in the named parameter </param>
    /// <param name="cacheDependencyParameterIndex"></param>
    /// <param name="cacheDependencyObjectPropertyName">the name of the property of the return object that will be used to replace the placeholder in the static string to build the cache dependency string</param>
    public KenticoCacheAttribute(string cacheDependency, int cacheDependencyParameterIndex, string cacheDependencyObjectPropertyName)
    {
        CacheMinutes = EngineContext.Current.Resolve<AppSettings>().Cache.TTL.GlobalSetting;
        CacheEnabled = !EngineContext.Current.Resolve<AppSettings>().Cache.IgnoreCache;
        CacheDependencyParameterIndex = cacheDependencyParameterIndex;
        CacheDependency = cacheDependency;
        ObtainCacheDependencyFrom = KenticoCacheDependencyObtainFrom.FromMethodParameterObjectProperty;
        CacheDependencyObjectProperty = cacheDependencyObjectPropertyName;
    }

    public override void CompileTimeInitialize(MethodBase method, AspectInfo aspectInfo)
    {
        _methodName = method.Name;
    }

    public override void OnInvoke(MethodInterceptionArgs args)
    {
        var methodInfo = args.Method as MethodInfo;
        if (methodInfo != null && (methodInfo.ReturnType != typeof(void) && CacheEnabled))
        {
            var cacheKey = BuildCacheKey(args.Arguments);

            var cacheSettings = new CacheSettings(CacheMinutes, cacheKey);
            var data = CacheHelper.Cache(cs => GetData(cs, args), cacheSettings);
            args.ReturnValue = data;
        }
        else
            base.OnInvoke(args);
    }

    private object GetData(CacheSettings cs, MethodInterceptionArgs args)
    {
        var data = args.Invoke(args.Arguments);

        // Checks whether data was loaded and whether the data should be cached (based on the CacheSettings)
        if ((data != null) && cs.Cached)
        {
            // Sets a cache dependency for the data
            // The data is removed from the cache if the objects represented by the dummy key are modified (all user objects in this case)
            var dependencyResolver = CacheDependencyFactory.GetDependecyFormatter(ObtainCacheDependencyFrom);

            var dependencyString = dependencyResolver.Format(new CacheDependencyFormatParameters()
            {
                CacheDependencyBase = CacheDependency,
                CacheDependencybaseString = CacheDependencyStrings,
                InputParameterIndex = CacheDependencyParameterIndex,
                ReturnParameterName = CacheDependencyObjectProperty,
                InputParameterData = args,
                ReturnParameterData = data
            });

            cs.CacheDependency = CacheHelper.GetCacheDependency(dependencyString);
        }



        return data;
    }

    private string BuildCacheKey(Arguments arguments)
    {
        var sb = new StringBuilder();
        sb.Append(_methodName);
        foreach (var argument in arguments.ToArray())
        {
            sb.Append(argument == null ? "_" : argument.ToString());
        }
        sb.Append(String.Format("{0}_{1}", SiteContext.CurrentSiteName,
            SiteContext.CurrentSite.DefaultVisitorCulture));
        return sb.ToString();
    }
}

[可序列化]
公共类KenticoCacheAttribute:MethodInterceptionSpect
{
公共int缓存分钟数{get；set；}
/// 
///缓存依赖项键的字符串值。如果它使用方法中的参数，请包含一个{0}以使用方法参数进行格式化
/// 
公共字符串缓存依赖项{get；set；}
公共字符串[]CacheDependencyStrings{get；set；}
public KenticoCacheDependencyOccainFrom OccainCacheDependencyFrom{get；set；}
/// 
///是否启用缓存-应用程序设置中的默认值
/// 
公共布尔缓存已启用{get；set；}
/// 
///这是用于格式化cachedependency（如果需要）的参数的索引
/// 
public int CacheDependencyParameterIndex{get；set；}
公共字符串CacheDependencyObjectProperty{get；set；}
私有字符串_methodName；
/// 
///初始化缓存属性以使用静态依赖项
/// 
/// 
公共缓存属性（字符串缓存依赖项）
{
CacheMinutes=EngineContext.Current.Resolve（）.Cache.TTL.GlobalSetting；
CacheEnabled=！EngineContext.Current.Resolve（）.Cache.IgnoreCache；
CacheDependencyParameterIndex=-1；
CacheDependency=CacheDependency；
if（String.IsNullOrEmpty（cacheDependency））
ActainCacheDependencyFrom=KenticocacheDependencyActainFrom.NodeDependency；
其他的
{
ActainCacheDependencyFrom=KenticocacheDependencyActainFrom.Static；
}
}
/// 
///初始化缓存属性以使用多个Dependencies的静态依赖项
/// 
///字符串数组
public KenticoCacheAttribute（字符串[]cacheDependencystrings）
{
CacheMinutes=EngineContext.Current.Resolve（）.Cache.TTL.GlobalSetting；
CacheEnabled=！EngineContext.Current.Resolve（）.Cache.IgnoreCache；
CacheDependencyParameterIndex=-1；
CacheDependencyStrings=CacheDependencyStrings；
ActainCacheDependencyFrom=KenticoCacheDependencyActainFrom.MultipleDependenciessStatic；
}
/// 
///初始化缓存属性以从输入参数获取依赖项
/// 
///用于缓存依赖项的静态字符串。可以包括{CurrentSiteName}替换为当前站点名称，以及{0}替换为作为方法参数之一传入的值
///将用于创建缓存依赖项键的方法参数中的参数索引
public KenticoCacheAttribute（字符串cacheDependency，int-cacheDependencyParameterIndex）
{
CacheMinutes=EngineContext.Current.Resolve（）.Cache.TTL.GlobalSetting；
CacheEnabled=！EngineContext.Current.Resolve（）.Cache.IgnoreCache；
CacheDependencyParameterIndex=CacheDependencyParameterIndex；
CacheDependency=CacheDependency；
if（String.IsNullOrEmpty（cacheDependency））
{
ActainCacheDependencyFrom=KenticoCacheDependencyActainFrom.MultipleDependenciesFromParameter；
}
其他的
{
ActainCacheDependencyFrom=KenticocacheDependencyActainFrom.FromMethodParameter；
}
}
/// 
///初始化缓存属性以从返回对象的命名属性获取缓存依赖项
/// 
///用于缓存依赖项的静态字符串。您可以在命名参数中包含{CurrentSiteName}以替换为当前站点名称，以及{0}以替换为值
///将用于替换静态字符串中的占位符以生成缓存依赖项字符串的返回对象的属性的名称
public KenticoCacheAttribute（字符串cacheDependency、字符串cacheDependencyObjectPropertyName）
{
CacheMinutes=EngineContext.Current.Resolve（）.Cache.TTL.GlobalSetting；
CacheEnabled=！EngineContext.Current.Resolve（）.Cache.IgnoreCache；
CacheDependencyParameterIndex=-1；
CacheDependency=CacheDependency；
ActainCacheDependencyFrom=KenticoCacheDependencyActainFrom.FromReturnObject；
CacheDependencyObjectProperty=cacheDependencyObjectPropertyName；
}
/// 
///初始化缓存属性以从返回对象的命名属性获取缓存依赖项
/// 
///用于缓存依赖项的静态字符串。您可以在命名参数中包含{CurrentSiteName}以替换为当前站点名称，以及{0}以替换为值
/// 
///将用于替换静态字符串中的占位符以生成缓存依赖项字符串的返回对象的属性的名称
public KenticoCacheAttribute（字符串cacheDependency、int-cacheDependencyParameterIndex、字符串cacheDependencyObjectPropertyName）
{
CacheMinutes=EngineContext.Current.Resolve（）.Cache.TTL.GlobalSetting；
CacheEnabled=！EngineContext.Current.Resolve（）.Cache.IgnoreCache；
CacheDependencyParameterIndex=CacheDependencyParameterIndex；
CacheDependency=CacheDependency；
ActainCacheDependencyFrom=KenticocacheDependencyActainFrom.FromMethodParameterObjectProperty；
CacheDependencyOb
CacheMinutes = EngineContext.Current.Resolve<AppSettings>().Cache.TTL.GlobalSetting;
CacheEnabled = !EngineContext.Current.Resolve<AppSettings>().Cache.IgnoreCache;

public override void OnInvoke(MethodInterceptionArgs args)
    {

        CacheMinutes = EngineContext.Current.Resolve<AppSettings>().Cache.TTL.GlobalSetting;
        CacheEnabled = !EngineContext.Current.Resolve<AppSettings>().Cache.IgnoreCache;
        var methodInfo = args.Method as MethodInfo;
......