Przechowywanie danych o aktualnych zadaniach użytkowników.

Witam
Piszę aplikacje związaną z sieciami neuronowymi, narzazie aktualne wykonywane zadania są przypisane do sesji, ale teraz chciał bym to zmienić aby były przypisane do zalogowanego użytkowania, aby mógł sobie je podejrzeć nawet po tym jak wygaśnie sesja. Mam pewien pomysł ale nie wiem czy da się to zrealizować w MVC. Mianowicie chciałem zrobić słownik w którym bym sobie trzymał zbiory aktualnych zadań, kluczem był by unikalny identyfikator użytkownika. Chciałem taki słownik trzymać w Application, ale nie mogę się doszukać czy to istnieje w MVC.

Czy znacie może lepszy pomyśl na rozwiązanie tego?
Czy w MVC istnieje takie coś jak Application? Jeżeli tak czy warto było by tam umieścić taki słownik?

Chodzi Ci chyba o dostępne w każdym kontrolerze this.HttpContext.Application.
A czy to dobry pomysł, to nie wiem... Baza nie lepsza?

Właśnie nie wiem czy baza by nie była lepsza, może pokaże jak to mam teraz rozwiązane, to wtedy już będziesz mógł konkretniej ocenić to rozwiązanie.

Dla każdego użytkowania wymagany jest dostęp co 1 sec do NNTaskList, ponieważ stan tasków jest odświeżany co 1 sec na stronie.

Dostęp do tasków użytkownika poprzez binder:

public class NNTaskListModelBinder : IModelBinder
{
    private const string userTaskKey = "UserTaskList";
    private const string nnTaskKey = "NNTaskList";
    private HttpContextBase context;

    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingC
    {
        context = controllerContext.HttpContext;
        NNTaskList nnTaskList = CashedNNTaskList;
        if (nnTaskList == null)
        {
            UserTaskList userTaskList = (UserTaskList)context.Application[userTaskKey];
            if (userTaskList == null)
            {
                userTaskList = new UserTaskList();
                context.Application[userTaskKey] = userTaskList;
            }
            nnTaskList = userTaskList.Get((Guid)Membership.GetUser().ProviderUserKey);
            CashedNNTaskList = nnTaskList;
        }
        nnTaskList.RefreshConnection();
        return nnTaskList;
    }

    private NNTaskList CashedNNTaskList
    {
        get { return (NNTaskList)context.Session[nnTaskKey]; }
        set { context.Session[nnTaskKey] = value; }
    }
}

Lista na zbiór tasków użytkowników:

 
public class UserTaskList
{
    private Dictionary<Guid, NNTaskList> tasks;

    public UserTaskList()
    {
        tasks = new Dictionary<Guid, NNTaskList>();
    }

    public NNTaskList Get(Guid userId)
    {
        if (tasks.ContainsKey(userId))
        {
            return tasks[userId];
        }
        else
        {
            NNTaskList userTasks = new NNTaskList();
            tasks.Add(userId, userTasks);
            return userTasks;
        }
    }
}

Lista tasków użytkownika:

public class NNTaskList
{
    private NeuralNetworkClient client;
    public TaskList<FeedforwardTask> FeedforwardTasks { get; private set; }
    public TaskList<SOMTask> SOMTasks { get; private set; }

    public NNTaskList()
    {
        client = new NeuralNetworkClient();
        client.Open();
        FeedforwardTasks = new TaskList<FeedforwardTask>();
        SOMTasks = new TaskList<SOMTask>();
    }

    public void Add(FeedforwardTask feedforwardTask)
    {
        feedforwardTask.SetClient(client);
        FeedforwardTasks.Add(feedforwardTask);
    }

    public void Add(SOMTask SOMTask)
    {
        SOMTask.SetClient(client);
        SOMTasks.Add(SOMTask);
    }

    public void RefreshConnection()
    {
        if (client.State != System.ServiceModel.CommunicationState.Opened)
        {
            if (client.State == System.ServiceModel.CommunicationState.Faulted)
            {
                client.Abort();
            }
            else
            {
                client.Close();
            }
            client = new NeuralNetworkClient();
            client.Open();
        }
    }
}

public class TaskList<TNetworkTask> where TNetworkTask : NNTask
{
    private readonly List<TNetworkTask> tasks;

    public TaskList()
    {
        tasks = new List<TNetworkTask>();
    }

    internal void Add(TNetworkTask task)
    {
        tasks.Add(task);
    }

    public void Cancel(long id)
    {
        for (int i = 0; i < tasks.Count; i++)
        {
            if (tasks[i].Id == id)
            {
                tasks[i].Cancel();
                tasks.RemoveAt(i);
                break;
            }
        }
    }

    public TNetworkTask GetTask(long id)
    {
        foreach (var task in tasks)
        {
            if (task.Id == id)
            {
                return task;
            }
        }
        return null;
    }

    public TNetworkTask this[int i]
    {
        get { return tasks[i]; }
    }

    public int Count { get { return tasks.Count; } }
}  

Każdy task ma unikalne id, które jest nadawane przez serwer(proxy client). I każde obliczenia taska dzieją się po stronie serwera.
Konkretny task:

public abstract class NNTask
{
    protected NeuralNetworkClient client;
    public long Id { get; private set; }
    public int CollectionID { get; private set; }

    public NNTask() { }
    public NNTask(long id, int collectionID)
    {
        Id = id;
        CollectionID = collectionID;
    }

    internal void SetClient(NeuralNetworkClient client)
    {
        this.client = client;
    }

    public void Cancel()
    {
        client.CancelTask(Id);
    }

    public bool IsReady { get { return client.IsReady(Id); } }
    public int Iteration { get { return client.GetIteration(Id); } }
    public double Error { get { return client.GetError(Id); } }
}

public class FeedforwardTask : NNTask
{
    private FeedforwardTask() { }
    public FeedforwardTask(long id, int collectionID) : base(id, collectionID)
    { }

    public double[] Compute(double[] inputs)
    {
        return client.ComputeFeedforward(Id, inputs);
    }

    public TestResultModel TestNetwork()
    {
        TestResult result = client.TestFeedforward(Id);
        return new TestResultModel
        {
            Outputs = result.Outputs,
            IsSame = result.IsSame
        };
    }
}

public class SOMTask : NNTask
{
    private SOMTask() { }
    public SOMTask(long id, int collectionID)
        : base(id, collectionID)
    { }

    public int Compute(double[] inputs)
    {
        return client.ComputeSOM(Id, inputs);
    }

    public int[] TestNetwork()
    {
        return client.TestSOM(Id);
    }
}

Czy byłby ktoś w stanie ocenić to rozwiązanie?