Как сделать легконастраиваемое кеширование в проекте и спасти коллег от написания однотипного кода

Моя цель - предложение широкого ассортимента товаров и услуг на постоянно высоком качестве обслуживания по самым выгодным ценам.

«Если суть работы программиста в автоматизации работы других людей, то почему моя работа так мало автоматизирована» — думал я, копируя в очередной раз всю необходимую в проекте обвязку для добавления новой сущности в БД. И решил избавиться от этой рутины по добавлению шаблонных классов, сделав заодно «хорошо» проекту, разгрузив БД от лишних операций чтения.

Небольшое отступление про систему, которую мы разрабатываем и её состояние на момент начала этого эксперимента:

  • Система в которой 90% данных активно меняются и обрабатываются (транзакции, анкетные данные, предрассчитываемые агрегации), но редко читаются, а оставшиеся 10% очень редко меняются, но зато используются на чтение при каждом удобном случае
  • Почти монолитный сервис на .Net Framework, в котором все это реализовано
  • Nhibernate с минимальной обвязкой, используемый для доступа к БД и некоторый объем основанных на нем кешей (подписки на изменения BO-сущностей, обработчики вызываемые при коммите транзакций)
  • Десяток негласных правил «как написать код для доступа к БД, не убив производительность особенностями NHibernate», регулярно отлавливаемые на Core Review
  • Несколько подтупливающая БД, нуждающаяся в оптимизации

Во время обдумывания ситуации с БД и возникла мысль: не убрать ли из нагрузки на БД эти самые 10% запросов (а заодно и нужные для них открытия подключений к БД, удержание открытых транзакций и шаблонный код для доступа к БД через наши репозитории). При этом, надо было учесть:

  • Мы уже пытались работать с кешем Nhibernate, но нашли его поведение не всегда явным и предсказуемым
  • Менять принципиально что-то в платформе или инфраструктуре без веских на то оснований тоже не хотелось
  • Количество _рукописного_ кода, как у любого достаточно ленивого программиста, должно было в результате уменьшиться, писать руками сотни строк оберток и подписок для существующих кешей

Пример реализации одного из таких старых кешей
    /// <summary>
    /// Base class for caches, containing rarely changed entities. Updated by subscription to nHibernate session commits.
    /// </summary>
    /// <typeparam name="T">Type, used as a base for the cache. Sessions, containing changes to any instance of this class will cause cache refresh.</typeparam>
    /// <typeparam name="K">Key used for cache search.</typeparam>
    /// <typeparam name="V">Value, stored in cache.</typeparam>
    public abstract class RareChangedObjectsCache<T, K, V> : EmptySessionNotificationListener,
        ITransactionNotificationListener, IRareChangedObjectsCache<K, V>
        where T : class
    {
        [NotNull]
        private static readonly ILog Log = IikoBizLogManager.GetLogger(typeof(RareChangedObjectsCache<T, K, V>));

        [NotNull]
        protected readonly ReaderWriterLockSlim LockObj = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);

        [NotNull]
        protected readonly Dictionary<K, V> Cache = new Dictionary<K, V>();

        [NotNull]
        protected abstract QueryOver<T> GetQuery();

        [NotNull]
        private readonly ConcurrentDictionary<String, bool> changesByTransaction = new ConcurrentDictionary<string, bool>();

        private DateTime lastRefreshTime = DateTime.MinValue;

        [NotNull]
        public HibernateSessionManager SessionManager { get; set; }

        /// <summary>
        /// Interval of automatic data renewal for cases of read access to cache. Also, cache is forcibly refreshed on any commit, changing base entities of this cache.
        /// </summary>
        public TimeSpan AutoRefreshInterval { get; set; }

        public void Reset()
        {
            lastRefreshTime = DateTime.MinValue;
        }

        protected void ReloadCacheIfNeeded(ISession session = null)
        {
            if (SystemTime.Now - lastRefreshTime <= AutoRefreshInterval)
                return;

            LockObj.EnterWriteLock();
            try
            {
                if (SystemTime.Now - lastRefreshTime <= AutoRefreshInterval)
                    return;

                IList<object> result;
                
                if (session == null)
                    result = SessionManager.CallTransacted(s => GetQuery().GetExecutableQueryOver(s).List<object>());
                else
                    //TODO At that moment, the transaction may have been closed, so a new transaction opens implicitly
                    result = GetQuery().GetExecutableQueryOver(session).List<object>();

                Cache.Clear();
                ProcessResult(result);
                lastRefreshTime = SystemTime.Now;
            }
            catch (Exception e)
            {
                Log.Error("Exception on cache invalidation: ", e);
            }
            finally
            {
                LockObj.ExitWriteLock();
            }
        }

        protected abstract void ProcessResult(IList<object> result);

        public override void OnSaveOrUpdate(ISession session, object entity, Guid id, object[] currentState, object[] previousState, string[] propertyNames, IType[] types)
        {
            if (entity is T)
            {
                var transactionName = HibernateSessionManager.GetTransactionName();
                if (!string.IsNullOrEmpty(transactionName))
                {
                    changesByTransaction.TryAdd(transactionName, true);
                }
            }
        }

        public override void OnDelete(ISession session, object entity, Guid id)
        {
            if (entity is T)
            {
                var transactionName = HibernateSessionManager.GetTransactionName();
                if (!string.IsNullOrEmpty(transactionName))
                {
                    changesByTransaction.TryAdd(transactionName, true);
                }
            }
        }

        void ITransactionNotificationListener.AfterCommit(ISession session, string transactionName)
        {
            bool tmp;
            if (changesByTransaction.TryRemove(transactionName, out tmp))
                Reset();
            ReloadCacheIfNeeded(session);
        }

        void ITransactionNotificationListener.AfterRollback(ISession session, string transactionName)
        {
        }

        public bool Contains(K key)
        {
            ReloadCacheIfNeeded();
            LockObj.EnterReadLock();
            try
            {
                return Cache.ContainsKey(key);
            }
            finally
            {
                LockObj.ExitReadLock();
            }
        }

        public virtual V TryGet(K key)
        {
            ReloadCacheIfNeeded();
            LockObj.EnterReadLock();
            try
            {
                return Cache.TryGetValue(key, out var value)
                    ? value
                    : default;
            }
            finally
            {
                LockObj.ExitReadLock();
            }
        }

        protected TV GetOrAddEntry<TK, TV>(IDictionary<TK, TV> dictionary, TK key)
            where TV : new()
        {
            TV list;
            if (!dictionary.TryGetValue(key, out list))
                dictionary[key] = (list = new TV());

            return list;
        }
    }
    /// <summary>
    /// Caches all guest categories, grouped by organization or network they belong.
    /// </summary>
    [UsedImplicitly]
    public sealed class GuestCategoryCache : RareChangedObjectsCache<GuestCategory, Guid, HashSet<GuestCategory>>
    {
        private static readonly QueryOver<GuestCategory> SelectAllEntitiesQuery = QueryOver.Of<GuestCategory>()
                                                                                           .Fetch(gc => gc.Organization).Eager
                                                                                           .Fetch(gc => gc.Network).Eager;

        private readonly Dictionary<Guid, string> invertedCache = new Dictionary<Guid, string>();

        public bool TryGetNetworkExternalId(Guid id, out string extId)
        {
            ReloadCacheIfNeeded();
            LockObj.EnterReadLock();
            try
            {
                return invertedCache.TryGetValue(id, out extId);
            }
            finally
            {
                LockObj.ExitReadLock();
            }
        }

        protected override QueryOver<GuestCategory> GetQuery()
        {
            return SelectAllEntitiesQuery;
        }

        protected override void ProcessResult(IList<object> result)
        {
            invertedCache.Clear();
            foreach (GuestCategory gc in result)
            {
                var orgOrNetworkId = gc.Organization?.Id ?? gc.Network.Id;
                GetOrAddEntry(Cache, orgOrNetworkId).Add(gc);
            }
        }
    }


на тот момент уже несколько надоело.
— Новая фича не должна глобально затрагивать других разработчиков, миграция на новый подход должна происходить плавно и нежно.

Хотелось при этом сделать так, чтобы добавление новой сущности в механизмы кеширования занимало минимум усилий, код остался читаемым и прямолинейным, и при получении данных из кеша можно было бы минимально думать о том, какой вспомогательный код надо написать. Два последних пункта сильно срезали ассортимент вариантов. По сути, надо или городить что-то с рефлексией и generic-классами, или же обратиться к старому доброму метапрограммированию.

Так как основной инструмент разработки — Visual Studio, а много сил тратить на то, что не факт что привнесет грандиозный эффект, не хотелось — решил сделать решение «в лоб» максимально стандартными средствами и только уже на этапе готового Proof Of Concept на паре самых частоиспользуемых сущностей — предъявить решение коллегам на суд.

Дальше была некоторая моральная дилемма. Использовать ли в качестве первоисточника какой-то класс обвешанный атрибутами на все случаи жизни (в стиле Fluent-маппинга Nhibernate на стероидах), или же написать милую аккуратную XML. Помня, что лень — лучший друг программиста, а описание классов атрибутами более трудозатратно, чем написание небольшой XML, сделал выбор в пользу последнего.

По сути, что мне нужно было от описания сущностей?

  • Описание кешируемых полей
  • Возможность указать свойства, по которым мы будем делать выборки из этих данных, по необходимости возможность заоптимизировать эти выборки избавившись от линейного прохода по спискам (коли играть в оптимизации, так по полной)
  • Всякое дополнительное удобство для того чтобы разнести классы по разным папкам и использовать имеющиеся наработки в коде для уменьшения его количества

Получили вот такую структуру xml
<class name="GuestCategory" logicallyDeletable="true" revisioned="true" organizationNetworkBased="true" basedOn="BO.GuestCategory" >
    <emitBo emitMapping="true"/>
    <emitRepository dependsOn="guestCategoryCache">IGuestCategoryRepository</emitRepository>
    <field name="IsActive" type="bool"/>
    <field name="IsDefaultForNewGuests" type="bool"/>
    <field name="Name" type="string" notNull="true"/>
  </class>


И большой страшный T4 шаблон для её парсинга и генерации разномастных, но столь нужных классов:

  • «Кешируемый» тип с теми же полями что и BO, но не допускающий редактирования
  • Реализацию кеша для типа с методами выборок по фильтрам
  • Реестр кешей для подписки на механизмы Nhibernate об уведомлениях и регистрации в DI (Spring в нашем случае)
  • Интерфейсы для всего этого для сокрытия внутренностей и возможности при необходимости замены генерируемого кода на рукописный и назад.
  • Как приятный незапланированный изначально бонус, коли уже была готова работа с основными сущностями — сделал еще пол-шажочка к счастью, и сбоку добавил возможность генерации простых BO-типов и маппингов к ним, чтобы дать коллегам возможность добавлять новые классы с пол-пинка.

Сам шаблон, с логической точки зрения, состоит из двух частей: парсинг исходной xml в классы, описывающие нужную структуру классов (для уменьшения риска образования какого-либо неявного поведения, при этом, было решено сделать именно через явный парсинг тегов, а не через маппинг атрибутами.

Классы, описывающие структуру
class DalClass
{
    public string Name { get; }
    public bool LogicallyDeletable { get; }
    public string BasedOn { get; }
    public string DalBOType { get; }
    public string[] Implements { get; }
    public string[] Include { get; }

    public bool CustomConsistencyManager { get; }
    
    public List<DalField> Fields { get; }
    public List<DalField> ExplicitlyDefinedFields { get; }
    public DalGetBy[] GetBy { get; }
    public DalGetBy[] GetAllBy { get; }

    public bool GenerateInterface { get; }

    public DalEmitBo EmitBo { get; }
    public DalEmitRepository EmitRepository { get; }

    public DalClass(XmlElement sourceXml)
    {
      Implements = sourceXml.SelectNodes("*[local-name()='implements']")
        .Cast<XmlElement>()
        .Select(f => f.InnerText + ",")
        .ToArray();
      Include = sourceXml.SelectNodes("*[local-name()='include']")
        .Cast<XmlElement>()
        .Select(f => f.InnerText)
        .ToArray();
      Name = sourceXml.GetAttribute("name");
      LogicallyDeletable = sourceXml.HasAttribute("logicallyDeletable");
      BasedOn = sourceXml.GetAttribute("basedOn");
      DalBOType = sourceXml.HasAttribute("dalBoType") ? sourceXml.GetAttribute("dalBoType") : BasedOn;
      CustomConsistencyManager = sourceXml.HasAttribute("customConsistencyManager") ? sourceXml.GetAttribute("customConsistencyManager") == "true" : false;
      Fields = sourceXml.SelectNodes("*[local-name()='field']")
        .Cast<XmlElement>()
        .Select(f => new DalField(f))
        .ToList();
      ExplicitlyDefinedFields = Fields.ToList();
      Fields = Fields.OrderBy(f=>f.Name).ToList();
      GetBy = sourceXml.SelectNodes("*[local-name()='getBy']")
        .Cast<XmlElement>()
        .Select(f => new DalGetBy(f))
        .ToArray();
      GetAllBy = sourceXml.SelectNodes("*[local-name()='getAllBy']")
        .Cast<XmlElement>()
        .Select(f => new DalGetBy(f))
        .ToArray();
      EmitBo = sourceXml.SelectNodes("*[local-name()='emitBo']")
        .Cast<XmlElement>()
        .Select(f => new DalEmitBo(f))
      .SingleOrDefault();
      EmitRepository = sourceXml.SelectNodes("*[local-name()='emitRepository']")
        .Cast<XmlElement>()
        .Select(f => new DalEmitRepository(f, Name))
      .SingleOrDefault();
      GenerateInterface = true;
    }

    public string GetIncludedNamespaces()
    {
        return string.Join("/n", Include.Select(i => "using " + i + ";"));
    }
    
    public string GetBoClassDefinition()
    {
        return Name + " :\n\t\tBaseEntity,\n\t\t"
              + (LogicallyDeletable ? "ILogicallyDeletable,\n\t\t" : string.Empty)
          + (Implements.Any() ? string.Join("\n\t\t", Implements) + "\n\t\t" : string.Empty)
          + "I" + Name;
    }

    public string GetCachedClassDefinition()
    {
        return "Cached" + Name + " :\n\t\t"
          + (LogicallyDeletable ? "Deletable" : string.Empty)
          + "CachedEntity<" + BasedOn + ">,\n\t\t"
          + (Implements.Any() ? string.Join("\n\t\t", Implements) + "\n\t\t" : string.Empty)
          + "I" + Name;
    }


    public string TryGetIsDeletedParameter()
    {
        if (LogicallyDeletable)
            return ",bool getDeleted";
        else
            return String.Empty;
    }
    public string TryGetIsDeletedFilter()
    {
        if (LogicallyDeletable)
            return @"
        if (!getDeleted)
          entities = entities.Where(e => !e.IsDeleted);
";
        else
            return String.Empty;
    }

    public string GetFilterParameters(DalGetBy getBy)
    {
        var filters = new List<FieldDescription>();
        foreach (var filter in getBy.Filters)
            filters.Add(new FieldDescription { TypeName = Fields.Single(f => f.Name == filter.Key).FieldType, Alias = filter.Value });

        return string.Join(", ", filters.Select(f => f.TypeName + " " + f.Alias));
    }

    private struct FieldDescription
    {
        public string TypeName;
        public string Alias;
    }

}
class DalField
{
    public string Name { get; }
    public string FieldType { get; }
    public string Source { get; }
    public string PropertySource { get; }
    public bool NotNull { get; }

    public DalField(string name, string type)
    {
        Name = name;
        FieldType = type;
        Source = name;
    }

    public DalField(XmlElement sourceXml)
    {
        Name = sourceXml.GetAttribute("name");
        FieldType = sourceXml.GetAttribute("type");
        Source = sourceXml.HasAttribute("source") ? sourceXml.GetAttribute("source") : sourceXml.GetAttribute("name");
        PropertySource = sourceXml.HasAttribute("propertySource") ? sourceXml.GetAttribute("propertySource") : null;
        NotNull = sourceXml.HasAttribute("notNull") ? sourceXml.GetAttribute("notNull") == "true" : false;
    }

    public string GetConstructorInitValueExpression()
    {
        var fieldIsArray = FieldType.EndsWith("[]");
        var fieldRealType = FieldType.Replace("[]", "");
        if (PropertySource!=null && fieldRealType.StartsWith("I"))
            fieldRealType = "Cached" + fieldRealType.Substring(1);

        return UpperInitial(Name)
        + " = source." + Source
        + (fieldIsArray ? ".Select(i=>new " + fieldRealType + "(i)).ToArray()" : "")
        + ";";
    }
    
    public string GetPropertyDefinitionExpression()
    {
          return "public " + GetType() + " " + UpperInitial(Name) 
              + (PropertySource != null
                  ? " => " + PropertySource + ";"
                  : " { get; private set; }");
    }

    public string GetBOPropertyDefinitionExpression()
    {
        return "public virtual " + GetBoType() + " " + UpperInitial(Name) + " { get; set; }";
    }

    public string GetInterfacePropertyDefinitionExpression()
    {
        return GetNullAttribute() + GetType() + " " + UpperInitial(Name) + " { get; }";
    }
    
    public string GetType()
    {
        var fieldIsArray = FieldType.EndsWith("[]");
        if (fieldIsArray)
            return "IEnumerable<" + FieldType.Replace("[]", "") + ">";

        return FieldType;
    }

    public string GetBoType()
    {
        var fieldIsArray = FieldType.EndsWith("[]");
        if (fieldIsArray)
            return "IList<" + FieldType.Replace("[]", "") + ">";

        return FieldType;
    }

    private string GetNullAttribute() => 
    TypeCanBeNull()
    ? NotNull ? "[NotNull] " : "[CanBeNull] "
    : string.Empty;

    private static string[] NotNullTypes = 
    {
        "Guid", "DateTime", "DateTimeOffset", 
        "bool", "int", "long", "short",
        "ProgramType", "GuestSubscriptionTypes", "SenderType", 
        "ApiClientType"
    };

    public bool TypeCanBeNull() => !NotNullTypes.Contains(FieldType);

    private string UpperInitial(string name)
    { return name[0].ToString().ToUpperInvariant() + name.Substring(1); }

}

class DalGetBy
{
    public bool IsTry { get; }
    public string Alias { get; }
    public Dictionary<string, string> Filters { get; } = new Dictionary<string, string>();

    public DalGetBy(XmlElement sourceXml)
    {
        IsTry = sourceXml.HasAttribute("try");
        Alias = sourceXml.GetAttribute("alias");

        foreach (XmlElement filterNode in sourceXml.SelectNodes("*[local-name()='field']"))
            Filters.Add(filterNode.GetAttribute("field"), filterNode.GetAttribute("alias"));
    }

    public string GetConditions()
    {
        return string.Join(" && ", Filters.Select(f => $"e.{f.Key} == {f.Value}"));
        return string.Join(" && ", Filters.Select(f => $"e.{f.Key} == {f.Value}"));
    }
}
class DalEmitBo
{
    public string Namespace { get; }
    public bool EmitMapping { get; }
    private XmlElement sourceXml;

    public DalEmitBo(XmlElement sourceXml)
    {
        Namespace = sourceXml.GetAttribute("ns");
        EmitMapping = sourceXml.HasAttribute("emitMapping");
        this.sourceXml = sourceXml;
    }

    public string GetMapping(DalField field)
    {
        bool notNull = !field.TypeCanBeNull() || field.NotNull;
        var overridenXml = sourceXml.SelectNodes("*[local-name()='column']").Cast<XmlElement>().SingleOrDefault(e => e.GetAttribute("name") == field.Name);
        var props = overridenXml != null ? new OverridenProperties(overridenXml) : null;

        switch(field.FieldType)
        {
            case "string": return $"<property name=\"{field.Name}\"><column name=\"{field.Name}\" {(notNull ? "not-null=\"true\"" : string.Empty)} {(props?.SqlType !=null ? "sql-type=\"" + props.SqlType+"\"" : string.Empty)}/></property>";
            case "bool": return $"<property name=\"{field.Name}\" not-null=\"true\" type=\"boolean\"><column name=\"{field.Name}\" not-null=\"true\" default=\"{props?.DefaultValue??"0"}\" sql-type=\"bit\" /></property>";
            case "DateTime": return $"<property name=\"{field.Name}\" not-null=\"true\"/>";
            case "DateTime?": return $"<property name=\"{field.Name}\" />";
            case "ProgramType": return $"<property name=\"{field.Name}\"><column name=\"{field.Name}\" default=\"{props?.DefaultValue??"0"}\" {(notNull ? "not-null=\"true\"" : string.Empty)}/></property>";
            case "Guid?": return $"<property name=\"{field.Name}\" />";

            default: throw new ArgumentOutOfRangeException($"Not supported type {field.FieldType}. Edit DAL.tt to add mapping definition.");
        }
    }
    private class OverridenProperties
    {
        public string DefaultValue { get; }
        public string SqlType { get; }

        public OverridenProperties(XmlElement sourceXml)
        {
            DefaultValue = sourceXml.GetAttribute("default");
            SqlType = sourceXml.GetAttribute("sql-type");
        }
    }
}
class DalEmitRepository
{
    public string Interface { get; }
    public string DependsOn { get; }
    public DalEmitRepository(XmlElement sourceXml, string className)
    {
        Interface = string.IsNullOrEmpty(sourceXml.InnerText) ? "IRepository<"+className+">" : sourceXml.InnerText;
        DependsOn = sourceXml.GetAttribute("dependsOn");
    }

    public string GetRepositoryClassName() => Interface.Substring(1);
}


Код получившегося шаблона
<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Xml" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="EnvDTE" #>
<#@ import namespace="System.Xml" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Linq" #>
<#@ output extension="/" #>
<#  
EnvDTE.DTE dte = (EnvDTE.DTE) ((IServiceProvider) this.Host)  
                       .GetService(typeof(EnvDTE.DTE));  
 XmlDocument doc = new XmlDocument();  
 doc.Load(System.IO.Path.Combine(dte.ActiveDocument.Path, "DAL.xml"));
 var classes = doc.SelectNodes("//*[local-name()='class']").Cast<XmlElement>().Select(classXml=>new DalClass(classXml)).ToArray();  

 //fields
 foreach(var classNode in classes)
 {
#>
/* The file was generated automatically and should not be edited manually. For any changes edit DAL.xml or DAL.tt. */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using JetBrains.Annotations;
<#=classNode.GetIncludedNamespaces()#>
namespace Domain.DALV2
{
    public class <#=classNode.GetCachedClassDefinition()#>
    {
        public Cached<#=classNode.Name#>(<#=classNode.DalBOType#> source) : base(source)
        {
            <#=string.Join("\n\t\t\t", classNode.Fields.Where(f => f.PropertySource == null).Select(f=>f.GetConstructorInitValueExpression()))#>
        }

        <#=string.Join("\n\n\t\t", classNode.Fields.Select(f=>f.GetPropertyDefinitionExpression()))#>
    }
}
<#if (classNode.GenerateInterface){#>

namespace Domain.DAL
{
    public interface I<#=classNode.Name#>
<#if (classNode.LogicallyDeletable){#>
    :ILogicallyDeletableReadonly
<#}#>
    {
        Guid Id { get; }

        <#=string.Join("\n\n\t\t", classNode.Fields.Select(f=>f.GetInterfacePropertyDefinitionExpression()))#>
    }
}
<#SaveOutput("Entities//gen//"+classNode.Name+".g.cs");#>
<#}#>
/* The file was generated automatically and should not be edited manually. For any changes edit DAL.xml or DAL.tt. */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using Resto.Framework.Common;
using JetBrains.Annotations;
<#=classNode.GetIncludedNamespaces()#>
namespace Domain.DALV2
{
    public partial class <#=classNode.Name#>DAL :
        DAL<Cached<#=classNode.Name#>, <#=classNode.BasedOn#>, <#=classNode.DalBOType#>>
    {    
        internal <#=classNode.Name#>DAL(ISessionManager sessionManager, ICacheConsistencyManager<<#=classNode.BasedOn#>, <#=classNode.DalBOType#>> consistencyManager) : base(sessionManager,    Repositories.<#=classNode.Name#>, consistencyManager)
        {
        }
        
<#foreach (var getBy in classNode.GetBy){#>
        <#=getBy.IsTry?"[CanBeNull]":"[NotNull]"#>
        public Cached<#=classNode.Name#> <#=getBy.IsTry?"Try":""#>GetBy<#=getBy.Alias#>(<#=classNode.GetFilterParameters(getBy)#>)
        {
      UpdateCacheIfNeeded();
      using (ConsistencyManager.GetReadLock())
      {
        return Cache.Values.Single<#=getBy.IsTry?"OrDefault":""#>(e => <#=getBy.GetConditions()#>);
      }
        }
<#}#>
<#foreach (var fieldNode in classNode.GetAllBy){#>
        [NotNull]
        [ItemNotNull]
        public IList<Cached<#=classNode.Name#>> GetAllBy<#=fieldNode.Alias#>(<#=classNode.GetFilterParameters(fieldNode)#>)
        {
      UpdateCacheIfNeeded();
      using (ConsistencyManager.GetReadLock())
      {
        return Cache.Values.Where(e => <#=fieldNode.GetConditions()#>).ToList();
      }
        }

<#}#>
        [NotNull]
        protected override Cached<#=classNode.Name#> Convert(<#=classNode.DalBOType#> source)
        {
              return new Cached<#=classNode.Name#>(source);
        }
    }
}
<#SaveOutput("Repositories//gen//"+ classNode.Name+".g.cs");#>
<#if(classNode.EmitBo != null){#>
<?xml version="1.0" encoding="utf-8"?>

<hibernate-mapping
  xmlns="urn:nhibernate-mapping-2.2"
  assembly="Domain"
  namespace="<#=classNode.EmitBo.Namespace#>">
  <class name="<#=classNode.Name#>" dynamic-update="true" dynamic-insert="true">
    <id name="Id">
      <generator class="assigned" />
    </id>
        <#=string.Join("\n\t\t", classNode.ExplicitlyDefinedFields.Select(f=>classNode.EmitBo.GetMapping(f)))#>

<#if (classNode.LogicallyDeletable){#>
    <property name="IsDeleted" not-null="true" type="boolean">
      <column name="IsDeleted" not-null="true" default="0" />
    </property>
    <property name="WhenDeleted" type="DateTime" not-null="false"/>
<#}#>
  </class>
</hibernate-mapping>
<#SaveOutput("..\\..\\DAL.Hibernate\\Mapping\\gen\\"+classNode.Name+".hbm.xml");#>
/* The file was generated automatically and should not be edited manually. For any changes edit DAL.xml or DAL.tt. */

using System;
using Common.Domain.BO.DB;
using Domain.DAL;
using Domain.DALV2;
using JetBrains.Annotations;
<#=classNode.GetIncludedNamespaces()#>

namespace <#=classNode.EmitBo.Namespace#>
{
    public partial class <#=classNode.GetBoClassDefinition()#>
    {
        [UsedImplicitly]
        protected <#=classNode.Name#>(){}

        <#=string.Join("\n\n\t\t", classNode.ExplicitlyDefinedFields.Select(f=>f.GetBOPropertyDefinitionExpression()))#>
        
<#if (classNode.LogicallyDeletable){#>
        public virtual bool IsDeleted { get; set; }
        public virtual DateTime? WhenDeleted { get; set; }
<#}#>
    }
}
<#
    SaveOutput("..//BO//gen//"+ classNode.Name+".g.cs");
    }
}
#>
<!-- The file was generated automatically and should not be edited manually. For any changes edit DAL.xml or DAL.tt. -->
<objects xmlns="http://www.springframework.net"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:db="http://www.springframework.net/database"
           xsi:schemaLocation="http://www.springframework.net http://www.springframework.net/xsd/spring-objects.xsd">

<#  
 foreach(var classNode in classes.Where(c => !c.CustomConsistencyManager))
 {  
#>

    <object id="<#=LowerInitial(classNode.Name)#>CacheManager" type="Domain.DALV2.TransactionSubscribedManager<<#=classNode.BasedOn#>, <#=classNode.DalBOType#>>, Domain" singleton="true">
    </object>
<#}#>

    <object id="dalGeneratedListeners" type="System.Collections.Generic.List<Common.Hibernate.DAL.ISessionNotificationListener>, mscorlib">
      <constructor-arg>
          <list element-type="Common.Hibernate.DAL.ISessionNotificationListener, Common.Hibernate">
<#  
 foreach(var classNode in classes)
 {  
#>
                <ref object="<#=LowerInitial(classNode.Name)#>CacheManager"/>
<#}#>
            </list>
        </constructor-arg>
    </object>
</objects>
<#SaveOutput("..//Config//DALSpringDefinitions.g.xml");#>
/* The file was generated automatically and should not be edited manually. For any changes edit DAL.xml or DAL.tt. */

using Common;
using Common.Domain.DAL;
using Domain.BO;
using Domain.DALV2;
using Spring.Context.Support;
using JetBrains.Annotations;
<#=string.Join("\n", classes.Select(c=>c.GetIncludedNamespaces()).Where(s=>!string.IsNullOrEmpty(s)))#>

namespace Domain.DAL
{
    public partial class DALs
    {
        private static readonly SafeLazy<DALs> instance = new SafeLazy<DALs>(() => new DALs());
        private DALs()
        {
            var sessionManager = (ISessionManager)ContextRegistry.GetContext().GetObject("sessionManager");
<#
    foreach(var classNode in classes){
#>
             this.<#=LowerInitial(classNode.Name)#> = new <#=classNode.Name#>DAL(sessionManager, (ICacheConsistencyManager<<#=classNode.BasedOn#>, <#=classNode.DalBOType#>>)ContextRegistry.GetContext().GetObject("<#=LowerInitial(classNode.Name)#>CacheManager"));
<#
    }
#>
        }
          
  <#  
 foreach(var classNode in classes)
 {  
#>
        [NotNull]
    private readonly <#=classNode.Name#>DAL <#=LowerInitial(classNode.Name)#>;
        [NotNull]
    public static <#=classNode.Name#>DAL <#=classNode.Name#> => instance.Value.<#=LowerInitial(classNode.Name)#>;
<#}#>
        
        public static void ResetAll() => instance.Value.ResetAllImpl();

        private void ResetAllImpl()
        {
<#foreach(var classNode in classes){#>
            this.<#=LowerInitial(classNode.Name)#>.Reset();
<#}#>
        }
    }
}
<#SaveOutput("DALs.g.cs");#>
/* The file was generated automatically and should not be edited manually. For any changes edit DAL.xml or DAL.tt. */

using JetBrains.Annotations;
namespace Domain.DAL
{
    public partial interface IRepositoryFactory
    {
<#foreach(var classNode in classes.Where(c => c.EmitRepository != null)){#>
        [NotNull]
        <#=classNode.EmitRepository.Interface#> <#=classNode.Name#> { get; }
<#}#>
    }
}
<#SaveOutput("IRepositoryFactory.g.cs");#>
/* The file was generated automatically and should not be edited manually. For any changes edit DAL.xml or DAL.tt. */

using JetBrains.Annotations;
namespace Domain.DAL
{
    public static partial class Repositories
    {
<#foreach(var classNode in classes.Where(c => c.EmitRepository != null)){#>
        [NotNull]
        public static <#=classNode.EmitRepository.Interface#> <#=classNode.Name#> => Instance.Value.<#=classNode.Name#>;
<#}#>
    }
}
<#SaveOutput("Repositories.g.cs");#>
/* The file was generated automatically and should not be edited manually. For any changes edit DAL.xml or DAL.tt. */

using Common.Domain.DAL;
using Common.Hibernate.DAL;
using DAL.Hibernate.Cache.CachingProviders;
using Domain.BO;
using Domain.DAL;
using Domain.DAL.Cache;
using Domain.SaveManager;
using System;
using System.Collections.Generic;
using JetBrains.Annotations;
using Engine.Main;
<#=string.Join("\n", classes.Select(c=>c.GetIncludedNamespaces()).Where(s=>!string.IsNullOrEmpty(s)))#>

namespace DAL.Hibernate.DAL
{
    public partial class RepositoryFactory : IRepositoryFactory
    {
            public void Init([NotNull] IOrganizationsByNetworkCache organizationsByNetworkCache,
            [NotNull] INetworkCache networkCache,
            [NotNull] ITransactionSaveManager transactionSaveManager,
            [NotNull] ILoginEntryDataProvider loginEntryDataProvider,
            ListenerNotifier listenerNotifier)
        {
        
<#foreach(var classNode in classes.Where(c => c.EmitRepository != null)){#>
            this.<#=classNode.Name#> = new <#=classNode.EmitRepository.GetRepositoryClassName()#>(<#=classNode.EmitRepository.DependsOn#>);
<#}#>
        }
          
<#foreach(var classNode in classes.Where(c => c.EmitRepository != null)){#>
        [NotNull]
        public <#=classNode.EmitRepository.Interface#> <#=classNode.Name#> { get; private set; }
<#}#>
    }
}
<#SaveOutput("..\\..\\DAL.Hibernate\\DAL\\RepositoryFactory.g.cs");#>
<#+  
 private string LowerInitial(string name)  
 { return name[0].ToString().ToLowerInvariant() + name.Substring(1); }  

 private string UpperInitial(string name)  
 { return name[0].ToString().ToUpperInvariant() + name.Substring(1); }  

  void SaveOutput(string outputFileName)
  {
      string templateDirectory = Path.GetDirectoryName(Host.TemplateFile);
      string outputFilePath = Path.Combine(templateDirectory, outputFileName);
      File.WriteAllText(outputFilePath, this.GenerationEnvironment.ToString()); 

      this.GenerationEnvironment.Remove(0, this.GenerationEnvironment.Length);
  }
#>


И куда же без некоторого количества хитрого Generic-кода, для подписки на внесение изменений в БД, обновления кешей по требованию, и прочих радостей жизни. Тут generic оказалось вполне достаточно, чтобы закрыть все сценарии использования, вкупе с уже использующимися с

Общий код для доступа к данным
    public abstract class DAL<T, TBase, TCachedBo>
        where T : CachedEntity<TBase>
        where TBase : class, IEntity
        where TCachedBo : class, IIdEntity<Guid>
    {
        [NotNull] private readonly ILog log;
        [NotNull] protected readonly ISessionManager SessionManager;
        [NotNull] protected readonly IReadonlyRepository<TBase> BaseRepository;
        [NotNull] protected readonly ICacheConsistencyManager<TBase, TCachedBo> ConsistencyManager;
        [NotNull] protected Dictionary<Guid, T> Cache = new Dictionary<Guid, T>();

        protected DAL([NotNull] ISessionManager sessionManager,
            [NotNull] IReadonlyRepository<TBase> baseRepository,
            [NotNull] ICacheConsistencyManager<TBase, TCachedBo> consistencyManager)
        {
            this.SessionManager = sessionManager;
            this.BaseRepository = baseRepository;
            this.ConsistencyManager = consistencyManager;
            log = LogManager.GetLogger(GetType());
        }

        [CanBeNull]
        public T TryGetById(Guid id)
        {
            UpdateCacheIfNeeded();
            using (ConsistencyManager.GetReadLock())
            {
                return Cache.GetOrDefault(id);
            }
        }

        [NotNull]
        public T GetById(Guid id)
        {
            UpdateCacheIfNeeded();
            using (ConsistencyManager.GetReadLock())
            {
                return ValidateEntityFound(Cache.GetOrDefault(id), "{0} with id {1} not found", null, typeof(T), id);
            }
        }

        [NotNull]
        public TBase GetEntity([NotNull] ISession session, Guid id)
        {
            return BaseRepository.GetById(session, id);
        }

        [NotNull]
        public TBase GetEntity([NotNull] ISession session, [NotNull] T e)
        {
            return BaseRepository.GetById(session, e.Id);
        }

        [NotNull]
        public HashSet<T> GetByIds([NotNull] HashSet<Guid> ids)
        {
            UpdateCacheIfNeeded();
            using (ConsistencyManager.GetReadLock())
            {
                return ids
                    .Select(id => Cache.GetOrDefault(id))
                    .ToHashSet();
            }
        }

        public void Reset()
        {
            ConsistencyManager.Reset();
        }

        protected abstract T Convert(TCachedBo source);

        protected void UpdateCacheIfNeeded()
        {
            if (!ConsistencyManager.UpdateRequired)
                return;

            log.Debug($"{typeof(T).Name} DAL: Update required, getting writeLock");
            using (var updateScope = ConsistencyManager.GetWriteLock())
            {
                if (updateScope.UpdateRequired ?? ConsistencyManager.UpdateRequired)
                    SessionManager.RunTransacted(session =>
                    {
                        try
                        {
                            var updatedEntities = updateScope.GetUpdatedEntities(BaseRepository, session);
                            foreach (var updatedEntity in updatedEntities)
                                if (updatedEntity.Value != null)
                                    Cache[updatedEntity.Key] = Convert(updatedEntity.Value);
                                else
                                    Cache.Remove(updatedEntity.Key);
                            Reindex();
                        }
                        catch (Exception)
                        {
                            ConsistencyManager.Reset();
                            throw;
                        }
                    });
            }
        }

        /// <summary>
        /// Reevaluate specific indexes, used for search in cached entities. Called after cache has been updated.
        /// </summary>
        protected virtual void Reindex()
        {
        }

        [NotNull]
        protected T1 ValidateEntityFound<T1>([CanBeNull] T1 entity, [NotNull] string errorMessage, [NotNull] string frontMessage, [NotNull] params object[] p)
        {
            if (entity == null)
                throw new DataAccessException(Util.GetMessage(errorMessage, p), Util.GetMessage(frontMessage, p));

            return entity;
        }
    }



Интересным, на мой взгляд получился класс следящий за консистентностью кеша и управляющий его обновлением, главное место где пришлось задуматься над реализацией блокировок чтобы это все было оптимально и минимально блокирующе, но при этом защищенно

Собственно реализация
    [UsedImplicitly]
    public class TransactionSubscribedManager<TBase, TCachedBo> : EmptySessionNotificationListener, ICacheConsistencyManager<TBase, TCachedBo>, ITransactionNotificationListener
        where TBase : class, IEntity where TCachedBo : class, IIdEntity<Guid>
    {
        public bool UpdateRequired => needFullUpdate || !entitiesToUpdate.IsEmpty;
        [NotNull] protected readonly ReaderWriterLockSlim LockObj = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);

        [NotNull] private readonly ConcurrentDictionary<string, ConcurrentBag<Guid>> changesByTransaction = new ConcurrentDictionary<string, ConcurrentBag<Guid>>();

        [NotNull]
        protected ConcurrentBag<Guid> entitiesToUpdate = new ConcurrentBag<Guid>();
        protected bool needFullUpdate = true;

        public virtual CacheWriteLockScope<TBase, TCachedBo> GetWriteLock()
        {
            try
            {
                LockObj.EnterWriteLock();
                if (needFullUpdate)
                {
                    needFullUpdate = false;
                    return new CacheWriteLockScope<TBase, TCachedBo>(LockObj);
                }

                return new IdBasedCacheWriteLockScope<TBase, TCachedBo>(LockObj, ChangedEntitiesIdsProvider);
            }
            catch (Exception)
            {
                LockObj.ExitWriteLock();
                throw;
            }
        }

        protected ICollection<Guid> ChangedEntitiesIdsProvider()
        {
            var ids = new List<Guid>();
            var newBag = new ConcurrentBag<Guid>();
            var oldBag = Interlocked.Exchange(ref entitiesToUpdate, newBag);
            while (oldBag.TryTake(out var id))
                ids.Add(id);

            return ids;
        }

        public CacheReadLockScope GetReadLock()
        {
            return new CacheReadLockScope(LockObj);
        }

        public override void OnSaveOrUpdate(ISession session, object entity, Guid id, object[] currentState, object[] previousState, string[] propertyNames, IType[] types)
        {
            if (entity is TBase)
            {
                var transactionName = HibernateSessionManager.GetTransactionName();
                if (!string.IsNullOrEmpty(transactionName))
                {
                    if (changesByTransaction.TryAdd(transactionName, new ConcurrentBag<Guid>() { id }))
                        return;

                    changesByTransaction.TryGetValue(transactionName, out var transactionChangedEntities);
                    // ReSharper disable once PossibleNullReferenceException
                    // R# does not have attributes telling that value in dictionary is not null. But we know it.
                    transactionChangedEntities.Add(id);
                }
            }
        }

        public override void OnDelete(ISession session, object entity, Guid id)
        {
            if (entity is TBase)
            {
                var transactionName = HibernateSessionManager.GetTransactionName();
                if (string.IsNullOrEmpty(transactionName))
                    return;
                if (changesByTransaction.TryAdd(transactionName, new ConcurrentBag<Guid>() { id }))
                    return;

                changesByTransaction.TryGetValue(transactionName, out var transactionChangedEntities);
                // ReSharper disable once PossibleNullReferenceException
                // R# does not have attributes telling that value in dictionary is not null. But we know it.
                transactionChangedEntities.Add(id);
            }
        }

        public void Reset()
        {
            needFullUpdate = true;
        }

        void ITransactionNotificationListener.AfterCommit(ISession session, string transactionName)
        {
            if (changesByTransaction.TryRemove(transactionName, out var transactionChangedEntities) && !transactionChangedEntities.IsEmpty)
                while (transactionChangedEntities.TryTake(out var id))
                    entitiesToUpdate.Add(id);
        }

        void ITransactionNotificationListener.AfterRollback(ISession session, string transactionName)
        {
            changesByTransaction.TryRemove(transactionName, out _);
        }
    }

    public class IdBasedCacheWriteLockScope<TBase, TCachedBo> : CacheWriteLockScope<TBase, TCachedBo> where TBase : class, IEntity where TCachedBo : class, IIdEntity<Guid>
    {
        [NotNull] private readonly ICollection<Guid> changedEntitiesIds;
        public override bool? UpdateRequired => changedEntitiesIds.Any();

        public IdBasedCacheWriteLockScope([NotNull] ReaderWriterLockSlim lockObj, [NotNull] Func<ICollection<Guid>> changedEntitiesIdsProvider)
            : base(lockObj)
        {
            changedEntitiesIds = changedEntitiesIdsProvider() ?? throw new InvalidOperationException(nameof(changedEntitiesIdsProvider));
        }

        public override IDictionary<Guid, TCachedBo> GetUpdatedEntities(IReadonlyRepository<TBase> repository, ISession session)
        {
            var entities = repository.GetByIds(session, changedEntitiesIds, true).ToDictionary(e => e.Id, be => be as TCachedBo);
            foreach (var id in changedEntitiesIds.Where(i => !entities.ContainsKey(i)))
                entities.Add(id, null);

            return entities;
        }
    }


Интересные косяки, которые вскрылись в процессе разработки и раскатки на бою:

  • Просто так нельзя вытаскивать и кешировать связанные сущности с прямыми ссылками между ними. Иначе, когда мы изменяем одну из сущностей, устаревшая копия остается в объектах, ссылающихся на неё. Вместо того чтобы делать хитрую логику инвалидации таких связей, решили просто при обращении по свойству — всегда доставать свежую информацию из кеша
  • Надо учитывать момент, что даже самый простой запрос на инициализацию кеша может упасть при обращении к БД, приводя при этом к некорректности данных в кеше (дифферинциальные обновления при этом ловко подтягивали изменяемые данные, а вот то, что должно было лежать там с момента старта и никем не трогалось, отсутствовало). Изначально не подумалось об этом, в итоге код отслеживания таких ситуаций и сброса инициализации кеша получился малость запутанным
  • Партиционирование с обновлением только «нужных» сегментов кеша (благо у нас данные очень хорошо разделены на несвязанные сегменты) стоило заложить сразу, теперь уже не факт что до него дойдут руки, благо пока что операции обновления кеша проходят достаточно быстро
Источник: https://habr.com/ru/post/453382/

Интересные статьи

Интересные статьи

В этой статье мы рассмотрим, как система управления 1С-Битрикс справляется с большими нагрузками. Данный вопрос особенно актуален сегодня, когда электронная торговля начинает конкурировать по обороту ...
… или знакомство с плагинами Vue JS на примере интегрированной шины событий Пара слов о… Всем привет! Сразу оговорюсь. Я очень люблю VueJS, активно пишу на нем уже больше 2-х лет и не считаю, ч...
Недавно наш разработчик сочинил IT-сказку по мотивам одной ну очень известной эпопеи. Финал он дописать так и не успел: конец спринта, хотфикс-откат хотфикса, сами понимаете. Теперь мы запускаем ...
Почти каждый Java разработчик знает, что программы, написанные на языке Java изначально компилируются в JVM-байткод и хранятся в виде class-файлов стандартизованного формата. После попадания таки...
Многие кошельки биткоина при выборе монет для отправки предпочитают использовать крупную монету, баланс которой больше отправляемой суммы. После каждой такой транзакции образуется монета-сдача....