PropertyInfoManager.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="PropertyInfoManager.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Indicates that the specified property belongs</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
#if NET5_0_OR_GREATER
using System.Runtime.Loader;
 
using Csla.Runtime;
#endif
using Csla.Properties;
 
namespace Csla.Core.FieldManager
{
  internal class PropertyComparer : Comparer<IPropertyInfo>
  {
    public override int Compare(IPropertyInfo x, IPropertyInfo y)
    {
      return StringComparer.InvariantCulture.Compare(x.Name, y.Name);
    }
  }
 
  public static class PropertyInfoManager
  {
    private static object _cacheLock = new object();
 
#if NET5_0_OR_GREATER
    private static Dictionary<Type, Tuple<string, PropertyInfoList>> _propertyInfoCache;
 
    private static Dictionary<Type, Tuple<string, PropertyInfoList>> PropertyInfoCache
#else
    private static Dictionary<Type, PropertyInfoList> _propertyInfoCache;
 
    private static Dictionary<Type, PropertyInfoList> PropertyInfoCache
#endif
    {
      get
      {
        if (_propertyInfoCache == null)
        {
          lock (_cacheLock)
          {
#if NET5_0_OR_GREATER
            if (_propertyInfoCache == null)
              _propertyInfoCache = new Dictionary<Type, Tuple<string, PropertyInfoList>>();
#else
            if (_propertyInfoCache == null)
              _propertyInfoCache = new Dictionary<Type, PropertyInfoList>();
#endif
          }
        }
 
        return _propertyInfoCache;
      }
    }
 
    internal static PropertyInfoList GetPropertyListCache(Type objectType)
    {
      var cache = PropertyInfoCache;
 
#if NET5_0_OR_GREATER
      var found = cache.TryGetValue(objectType, out var listInfo);
 
      var list = listInfo?.Item2;
 
      if (!found)
      {
        lock (cache)
        {
          found = cache.TryGetValue(objectType, out listInfo);
 
          if (!found)
          {
            list = new PropertyInfoList();
 
            var cacheInstance = AssemblyLoadContextManager.CreateCacheInstance(objectType, list, OnAssemblyLoadContextUnload);
 
            cache.Add(objectType, cacheInstance);
 
            FieldDataManager.ForceStaticFieldInit(objectType);
          }
        }
      }
#else
      var found = cache.TryGetValue(objectType, out PropertyInfoList list);
 
      if (!found)
      {
        lock (cache)
        {
          found = cache.TryGetValue(objectType, out list);
 
          if (!found)
          {
            list = new PropertyInfoList();
 
            cache.Add(objectType, list);
 
            FieldDataManager.ForceStaticFieldInit(objectType);
          }
        }
      }
#endif
 
      return list;
    }
 
    internal static PropertyInfo<T> RegisterProperty<T>(Type objectType, PropertyInfo<T> info)
    {
      var list = GetPropertyListCache(objectType);
      lock (list)
      {
        if (list.IsLocked)
          throw new InvalidOperationException(string.Format(Resources.PropertyRegisterNotAllowed, info.Name, objectType.Name));
 
        // This is the semantic code for RegisterProperty
        //if (list.Any(pi => pi.Name == info.Name))
        //  throw new InvalidOperationException(string.Format(Resources.PropertyRegisterDuplicateNotAllowed, info.Name));
        //list.Add(info);
        //list.Sort();
 
        // Optimized code
        // BinarySearch uses the same comparer as list.Sort() to find the item in a sorted list.
        // If not found then returns the negative index for item in sorted list (to insert). 
        // This allows us to insert the item right away with no need for explicit Sort on the list.
        var index = list.BinarySearch(info, new PropertyComparer());
        // if found then throw DuplicateNotAllowed
        if (index >= 0)
          throw new InvalidOperationException(string.Format(Resources.PropertyRegisterDuplicateNotAllowed, info.Name));
 
        // insert info at correct sorted index
        list.Insert(~index, info);
      }
      return info;
    }
 
    public static PropertyInfoList GetRegisteredProperties(Type objectType)
    {
      // return a copy of the list to avoid
      // possible locking issues
      var list = GetPropertyListCache(objectType);
      lock (list)
        return new PropertyInfoList(list);
    }
 
    public static IPropertyInfo GetRegisteredProperty(Type objectType, string propertyName)
    {
      return GetRegisteredProperties(objectType).FirstOrDefault(p => p.Name == propertyName);
    }
#if NET5_0_OR_GREATER
 
    private static void OnAssemblyLoadContextUnload(AssemblyLoadContext context)
    {
      var cache = PropertyInfoCache;
 
      lock (cache)
        AssemblyLoadContextManager.RemoveFromCache(cache, context);
    }
#endif
  }
}