[Из песочницы] Как мы из CRUD-движка сервис делали24.04.2017 14:48

public static string GetClientConnectionString(this HttpContext context)
{
    #if DEBUG 
    if (Debugger.IsAttached && ConfigurationManager.ConnectionStrings[SERVICE_CONNECTION_STRING_NAME] == null)
    {
/*если мы в дебаге и приаттачены и не указан коннекшинстринг до базы сервиса (с маппингом URL в connectionstring), то мы берём имя базы для коннекта из конфига. Это удобно при разработке, чтобы каждый сидел в своей локальной базе*/
        return ConfigurationManager.AppSettings["DeveloperConnection-" + Environment.MachineName];
    }
    #endif

/*иногда в приложении необходимо в параллели выполнять несколько действий с БД. Например, при вытягивании большого количества данных в кеш, отправке уведомлений на почту и т.п. Для этого создаются отдельные Task, но у них нет HttpContext, мы не знаем URL с которого был подан запрос, либо запроса от клиента вообще не было. Данный код позволяет привязать к таску определённый connectionstring, и использовать его при доступе к данным. Структуры для передачи этих данных описаны ниже.*/
    if(context == null && TaskContext.Current != null)
    {
        //если мы в дочернем потоке, то он должен быть со стейтом!
        return TaskContext.Current.ConnectionString;
    }

/*если мы в режиме сервиса, то возьмём connectionstring из кеша*/
    if (context != null && ConfigurationManager.ConnectionStrings[SERVICE_CONNECTION_STRING_NAME] != null)
    {
        ServiceAccount account = context.GetServiceAccount();
        if (account == null)
        {
/*если мы обратились по адресу, приложения по которому не найдено, - connectionstring вернётся пустой, запросы сделать не получиться*/
            return null;
        }
        if (account.GetCurrentPurchases().Any() == false)
        {
/*если по запрошенному адресу приложение просрочено (не оплачено на текущий момент), connectionstring вернётся пустой, запросы сделать не получиться*/
            return null;
        }
        return account.ConnectionString;
    }
    else if (ConfigurationManager.ConnectionStrings[DEFAULT_CONNECTION_STRING_NAME] != null)
    {
/*если мы в режиме коробки, то возьмём connectionstring из конфига*/
        return ConfigurationManager.ConnectionStrings[DEFAULT_CONNECTION_STRING_NAME].ConnectionString;
    }
    else
    {
        return null;
    }
}

/*сделано на основе http://stackoverflow.com/a/32459724*/

public sealed class TaskContext
{
    private static readonly string contextKey = Guid.NewGuid().ToString();

    public TaskContext(string connectionString)
    {
        this.ConnectionString = connectionString;
    }

    public string ConnectionString { get; private set; }

    public static TaskContext Current
    {
        get { return (TaskContext)CallContext.LogicalGetData(contextKey); }
        internal set
        {
            if (value == null)
            {
                CallContext.FreeNamedDataSlot(contextKey);
            }
            else
            {
                CallContext.LogicalSetData(contextKey, value);
            }
        }
    }
}

public static class TaskFactoryExtensions
{
    public static Task StartNewWithContext(this TaskFactory factory, Func action, string connectionString)
    {
        Task task = new Task(() =>
        {
            T result;
            TaskContext.Current = new TaskContext(connectionString);
            try
            {
                result = action();
            }
            finally
            {
                TaskContext.Current = null;
            }
            return result;
        });

        task.Start();

        return task;
    }

    public static Task StartNewWithContext(this TaskFactory factory, Action action, string connectionString)
    {
        Task task = new Task(() =>
        {
            TaskContext.Current = new TaskContext(connectionString);
            try
            {
                action();
            }
            finally
            {
                TaskContext.Current = null;
            }
        });

        task.Start();

        return task;
    }
}

public class AuthHandler : DelegatingHandler
{
	protected async override Task SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        if (request.Method.Method == "OPTIONS")
        {
            var res = base.SendAsync(request, cancellationToken).Result;
            return res;
        }

	//ищем все API контроллеры
        string classSuffix = "Controller";
        var inheritors = Assembly.GetAssembly(typeof(BaseApiController)).GetTypes().Where(t => t.IsSubclassOf(typeof(ApiController)))
            .Where(inheritor => inheritor.Name.EndsWith(classSuffix));
			
	//ищем все методы с атрибутом UnautorizedMethod. например "белая ссылка на файл" (по GUID файла)
        var methods = inheritors.SelectMany(inheritor => inheritor.GetMethods().Select(methodInfo => new {
            Inheritor = inheritor,
            MethodInfo = methodInfo,
            Attribute = methodInfo.GetCustomAttribute(typeof(System.Web.Http.ActionNameAttribute)) as System.Web.Http.ActionNameAttribute
        })).Where(method => method.MethodInfo.GetCustomAttribute(typeof(UnautorizedMethodAttribute)) != null);

	//определяем текущий ConnectionString пользователя до БД
        string connection = System.Web.HttpContext.Current.GetClientConnectionString();
        if (string.IsNullOrEmpty(connection))
        {
            var res = new HttpResponseMessage(System.Net.HttpStatusCode.NotFound);
            return res;
        }

	//делаем ли мы запрос к методу, который не надо проверять на авторизацию
        if (!request.RequestUri.LocalPath.EndsWith("/api/login/login") && 
            methods.All(method => !request.RequestUri.LocalPath.ToLower().EndsWith($"/api/{method.Inheritor.Name.Substring(0, method.Inheritor.Name.Length - classSuffix.Length)}/{method.Attribute?.Name ?? method.MethodInfo.Name}".ToLower())))
        {
            //если метод не login или любой другой без аттрибута UnautorizedMethod
            //данный код роутозависим, это плохо.. но роуты менять вроде не собираемся, да и UnautorizedMethod - метод разрешающий.
            //в хучшем случае метод отпадёт без авторизации
            var accessToken = request.GetAccessToken();
            
            var accountDbWorker = new AccountDbWorker(connection, null, DbWorkerCacheManager.GetCacheProvider(connection));
            var checkAccountExists = accountDbWorker.CheckAccountExists(accessToken);
            if (checkAccountExists == false)
            {
                var res = new HttpResponseMessage(System.Net.HttpStatusCode.Unauthorized);
                return res;
            }
            else
            {
		//продлить время жизни токена юзера в кеше. раз в пару минут кеш свапнет данные в БД
                AuthTokenManager.Instance.Refresh(request.GetTokenHeader());
            }
        }
        else
        {
            //methods without any auth
        }

	//стандартный обработчки события
        var response = await base.SendAsync(request, cancellationToken);
        return response;
    }
}

/*типы данных, которые мы трекаем. String[] - поля, которые мы НЕ трекаем (неважные поля, которые часто изменяются)*/
static readonly Dictionary _trackedTypes = new Dictionary()
{
    { typeof(Account), new string[] { GetPropertyName((Account a) => a.Settings) } },
//..
    { typeof(Table), new string[0] },
};

//получаем название проперти, чтобы не хардкодить
static string GetPropertyName(Expression> action)
{
    var expression = (MemberExpression)action.Body;
    string name = expression.Member.Name;
    return name;
}

/*проверяем, какие поля поменяли*/
string[] GetChangedValues(DbEntityEntry entry)
{
    return entry.CurrentValues
            .PropertyNames
            .Where(n => entry.Property(n).IsModified)
            .ToArray();
}

/*проверяем поменяли ли поля вне списка не интересующих полей*/
bool IsInterestingChange(DbEntityEntry entry)
{
    Type entityType = ObjectContext.GetObjectType(entry.Entity.GetType());
    if (_trackedTypes.Keys.Contains(entityType))
    {
        switch (entry.State)
        {
            case System.Data.Entity.EntityState.Added:
            case System.Data.Entity.EntityState.Deleted:
                return true;
            case System.Data.Entity.EntityState.Detached:
            case System.Data.Entity.EntityState.Unchanged:
                return false;
            case System.Data.Entity.EntityState.Modified:
                return GetChangedValues(entry).Any(v => !_trackedTypes[entityType].Contains(v));
            default:
                throw new NotImplementedException();
        }
    }
    else
        return false;
}
public override int SaveChanges()
{
    bool needRefreshCache = ChangeTracker
                            .Entries()
                            .Any(e => IsInterestingChange(e));

    int answer = base.SaveChanges();

    if (needRefreshCache)
    {
        if (Transaction.Current == null)
        {
            RefreshCache(null, null);
        }
        else
        {
            Transaction.Current.TransactionCompleted -= RefreshCache;
            Transaction.Current.TransactionCompleted += RefreshCache;
        }
    }
    return answer;
}

//Пример кода
var taskColumns = Task.Factory.StartNewWithContext(() =>
{
/*у нас свой конструктор контекста, в isReadOnly режиме мы убираем все авто подтягивания свойств, трекинг изменений и т.п.*/
    using (var entities = new Context(connectionString, isReadOnly: true))
    {
        return entities.Columns.ToList();
    }
}, connectionString);

var taskTables = Task.Factory.StartNewWithContext(() =>
{
    using (var entities = new Context(connectionString, isReadOnly: true ))
    {
        return entities.Tables.ToList();
    }
}, connectionString);

var columns = taskColumns.Result;
var tables = taskTables.Result;

/*сворачиваем в Dictionary, чтобы в цикле обращение было более быстрым (это сильно решает)*/
var columnsDictByTableId = columns
    .GroupBy(c => c.TableId)
    .ToDictionary(c => c.Key, c => c.ToList());

foreach(var table in tables) {
	table.Columns = columnsDictByTableId[table.Id];
}

//загрузить список сущностей
private Task> GetEntitiesAsync(string connectionString, Func> getter)
{
    var task = Task.Factory.StartNewWithContext(() =>
    {
        using (var entities = new SokolDWEntities(connectionString, isReadOnly: true))
        {
            return getter(entities);
        }
    }, connectionString);

    return task;
}

/// 

/// принимает на вход список списков сущностей, в списке список каждого типа встречается только один раз
/// для всех свойств всех сущностей ищет в исходном списке списков сущность для привязки NavigationProp
/// и выполняет эту привязку. В общем делает тоже самое, что Include в EF, только быстрее.
/// Скорость обусловлена тем, что все данные уже подтянуты, мы точно знаем, что там есть всё что нам надо.
/// Мы немного завязаны на структуру привязки. Все сущности, на которые можно ссылаться, наследуются от класса BaseEntity.
/// BaseEntity содержит поле [Required][Key][DatabaseGenerated(DatabaseGeneratedOption.Identity)] public long Id { get; set; }
/// таким образом большинство Dictionary можно построить без использования рефлексии (что заметно быстрее)
/// 
/// список списков сущностей, которые надо связать между собой
private void SetProperties(params object[] entities)
{
	//тип сущности -> список сущностей #entitiesByTypes[typeof(Account)] -> список аккаунтов
    var entitiesByTypes = new Dictionary();
	//dictsById[typeof(Account)][1] -> аккаунт с номером 1
    var dictsById = new Dictionary>();
	//dictsByCustomAttr[typeof(Column)]["TableId"][1] -> все колонки, которые принадлежат таблице 1
    var dictsByCustomAttr = new Dictionary>>();
	//pluralFksMetadata[typeof(Table)] для сущности Table хранит список Свойств обратных ссылок
    var pluralFksMetadata = new Dictionary>();
	//needGroupByPropList[typeof(Column)] хранит список свойств, по которым надо делать Dictionary (по ним идёт ссылка на другую сущность)
    var needGroupByPropList = new Dictionary>();

    //заполняем entitiesByTypes и dictsById
    foreach (var entitySetObject in entities)
    {
        var listType = entitySetObject.GetType();
        if (listType.IsGenericType && (listType.GetGenericTypeDefinition() == typeof(List<>)))
        {
            Type entityType = listType.GetGenericArguments().Single();
            entitiesByTypes.Add(entityType, entitySetObject);

            if (typeof(BaseEntity).IsAssignableFrom(entityType))
            {
                //dictsById заполняем только для BaseEntity (только на такие сущьности можно ссылаться)
                var entitySetList = entitySetObject as IEnumerable;
                var dictById = entitySetList.ToDictionary(o => o.Id);
                dictsById.Add(entityType, dictById);
            }
        }
        else
        {
            throw new ArgumentException();
        }
    }

    //заполняем pluralFksMetadata и needGroupByPropList
    foreach (var entitySet in entitiesByTypes)
    {
        Type entityType = entitySet.Key;
        var virtualProps = entityType
            .GetProperties()
            .Where(p => p.GetCustomAttributes(true).Any(attr => attr.GetType() == typeof(ForeignKeyAttribute)))
            .Where(p => p.GetGetMethod().IsVirtual)
            .ToList();

        //обратные NavigationProp
        var pluralFKs = virtualProps
            .Where(p => typeof(IEnumerable).IsAssignableFrom(p.PropertyType))
            .Where(p => entitiesByTypes.Keys.Contains(p.PropertyType.GetGenericArguments().Single()))
            .ToDictionary(p => p, p => (p.GetCustomAttributes(true).Single(attr => attr.GetType() == typeof(ForeignKeyAttribute)) as ForeignKeyAttribute));
        pluralFksMetadata.Add(entityType, pluralFKs);
        foreach (var pluralFK in pluralFKs)
        {
            Type pluralPropertyType = pluralFK.Key.PropertyType.GetGenericArguments().Single();
            if (!needGroupByPropList.ContainsKey(pluralPropertyType))
            {
                needGroupByPropList.Add(pluralPropertyType, new List());
            }
            if (!needGroupByPropList[pluralPropertyType].Contains(pluralFK.Value.Name))
            {
                needGroupByPropList[pluralPropertyType].Add(pluralFK.Value.Name);
            }
        }

        //прямые NavigationProp
        var singularFKsDictWithAttribute = virtualProps
            .Where(p => entitiesByTypes.Keys.Contains(p.PropertyType))
            .ToDictionary(p => p, p => entityType.GetProperty((p.GetCustomAttributes(true).Single(attr => attr.GetType() == typeof(ForeignKeyAttribute)) as ForeignKeyAttribute).Name));

        var entitySetList = entitySet.Value as IEnumerable