How to use session outside a controller

Question

I have a Signalr Hub called NotificationHub that handles sending new notification to connected clients. The NotificationHub class uses a NotificationManager class to retrieve notifications data. Now, I want to be able to use a session to store the last time a new notification has been accessed but when using HttpContext.Current.Session["lastRun"] in NotificationManager I get a NullReferenceException. To clarify more, here is some of the codes of both classes:

NotificationHub

[HubName("notification")]
    public class NotificationHub : Hub
    {
        private NotificationManager _manager;
        private ILog logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        public NotificationManager Manager
        {
            get { return _manager; }
            set { _manager = value; }
        }

        public NotificationHub()
        {
            _manager = NotificationManager.GetInstance(PushLatestNotifications);
        }

        public void PushLatestNotifications(ActivityStream stream)
        {
            logger.Info($"Adding {stream.TotalItems} notifications ");
            Clients.Caller.addLatestNotifications(stream);
        }
//.....
}

NotificationManager

 public class NotificationManager
        {
            private static NotificationManager _manager;
            private DateTime _lastRun;
            private DbUpdateNotifier _updateNotifier;
            private readonly INotificationService _notificationService;
            private readonly Action<ActivityStream> _dispatcher;
            private long _userId;
            private IUnitOfWork unitOfWork;
            public NotificationService NotificationService => (NotificationService)_notificationService;
            public DbUpdateNotifier UpdateNotifier
            {
                get { return _updateNotifier; }
                set { _updateNotifier = value; }
            }

            public static NotificationManager GetInstance(Action<ActivityStream> dispatcher)
            {
                return _manager ?? new NotificationManager(dispatcher);
            }



            private NotificationManager(Action<ActivityStream> dispatcher)
            {
                _userId = HttpContext.Current.User.Identity.CurrentUserId();
                _updateNotifier = new DbUpdateNotifier(_userId);
                _updateNotifier.NewNotification += NewNotificationHandler;
                unitOfWork = new UnitOfWork();
                _notificationService = new NotificationService(_userId, unitOfWork);
                _dispatcher = dispatcher;

            }



         private void NewNotificationHandler(object sender, SqlNotificationEventArgs evt)
                {

                  //Want to store lastRun variable in a session here
                    var notificationList = _notificationService.GetLatestNotifications();
                    _dispatcher(BuilActivityStream(notificationList));
                }
           //....
}

I want to able to store the value of lastRun to a session to that I can retrieve the next time a new notification arrives. How can I achieve that?

Edit:

To clarify things up, what I want to store in session is the last time the server pushed new notification(s) to the client. I can use this value to only get notifications that happened after the current value of lastRun and then update lastRun to DateTime.Now. For example: Let's say a user has three new(unread) notifications and then two new notifications arrive. In this case the server has to know the time the last new notifications have pushed to the client so that it will only send those two new notifications.

Answer 1

If you are okay with another data source, I would recommend abstracting it through DI as @Babak alludes to.

Here is what I did for the problem - this should do the trick.

I am partial to Autofac, but any IoC component will work.

1. Define two Interfaces (NotificationUpdateService and NotificationUpdateDataProvider).

The NotificationUpdateService is what you will interact with. The NotificationUpdateDataProvider abstracts out the backing store - you can change it to whatever. For this example I used the cache object.

public interface INotificationUpdateDataProvider
{
    string UserId { get;  }
    DateTime LastUpdate { get; set; }
}

public interface INotificationUpdateService
{
    DateTime GetLastUpdate();

    void SetLastUpdate(DateTime timesptamp);
}

2. Implement the the interfaces. The data provider is a simple class that uses the HttpContext. From there we get the userId - to make this implementation specific to the user.

For the Cache Item- I defined a Dictionary object - with the UserId as a key and a DateTime as the value.

public class NotificationUpdateDataProvider : INotificationUpdateDataProvider
{
    private readonly Dictionary<string, DateTime> _lastUpdateCollection;
    private readonly string _userId;
    private Cache _cache;

    public NotificationUpdateDataProvider()
    {
        _cache = HttpRuntime.Cache;
        //Stack Overflow - get the User from the HubCallerContext object
        //http://stackoverflow.com/questions/12130590/signalr-getting-username
        _userId = Context.User.Identity.GetUserId();
        _lastUpdateCollection =(Dictionary<string,DateTime>) _cache["LastUpdateCollection"];

        //If null - create it and stuff it in cache
        if (_lastUpdateCollection == null)
        {
            _lastUpdateCollection = new Dictionary<string, DateTime>();
            _cache["LastUpdateCollection"] = _lastUpdateCollection;
        }
    }

    public DateTime LastUpdate
    {
        get { return _lastUpdateCollection[_userId]; }

        set
        {
            //add to existing or insert new
            if (_lastUpdateCollection.ContainsKey(_userId))
            {
                _lastUpdateCollection[_userId] = value;
            }
            else
            {
                _lastUpdateCollection.Add(_userId, value);
            }    

        }
    }

    public string UserId => _userId;
}



public class NotificationUpdateService : INotificationUpdateService
{
    private readonly INotificationUpdateDataProvider _provider;

    public NotificationUpdateService(INotificationUpdateDataProvider provider)
    {
        _provider = provider;
    }

    public DateTime GetLastUpdate()
    {
        return _provider.LastUpdate;
    }

    public void SetLastUpdate(DateTime timestamp)
    {
        _provider.LastUpdate = timestamp;
    }
}

3. I added in another static class for the Autofac registration:

   public static void RegisterComponents()
   {
       var builder = new ContainerBuilder();
   
       //First register the NotificationDataProvider
       builder.RegisterType<NotificationUpdateDataProvider>()
           .As<INotificationUpdateDataProvider>();
   
       //Register the update service
       builder.RegisterType<NotificationUpdateService>()
           .As<INotificationUpdateService>();
   
       var container = builder.Build();
   
       DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
   
   }
   

4. Update the Global.asax

       AreaRegistration.RegisterAllAreas();
       FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
       RouteConfig.RegisterRoutes(RouteTable.Routes);
       BundleConfig.RegisterBundles(BundleTable.Bundles);
       //I am partial Autofac - but unity, Ninject, etc - the concept is the same
       AutofacConfig.RegisterComponents();
   

5. You will need to modify the constructor to public if you want Autofac to resolve the service.

   public class NotificationManager
   {
           private static NotificationManager _manager;
           private DateTime _lastRun;
           private DbUpdateNotifier _updateNotifier;
           private readonly INotificationService _notificationService;
           private readonly Action<ActivityStream> _dispatcher;
           private long _userId;
           private IUnitOfWork unitOfWork;
           public NotificationService NotificationService => (NotificationService)_notificationService;
           private readonly INotificationUpdateService _updateService;                                         
           public DbUpdateNotifier UpdateNotifier
           {
               get { return _updateNotifier; }
               set { _updateNotifier = value; }
           }
   
           public static NotificationManager GetInstance(Action<ActivityStream> dispatcher)
           {
               return _manager ?? new NotificationManager(dispatcher);
           }
   
   
           //You'll need to make the constructor accessible for autofac to resolve your dependency
           public NotificationManager(Action<ActivityStream> dispatcher,  INotificationUpdateService updateService)
           {
               _userId = HttpContext.Current.User.Identity.CurrentUserId();
               _updateNotifier = new DbUpdateNotifier(_userId);
               _updateNotifier.NewNotification += NewNotificationHandler;
               unitOfWork = new UnitOfWork();
               _notificationService = new NotificationService(_userId, unitOfWork);
               _dispatcher = dispatcher;
               _updateService = updateService;
           }
   
   
   
           private void NewNotificationHandler(object sender, SqlNotificationEventArgs evt)
           {
   
               //Want to store lastRun variable in a session here
   
               //just put the datetime in through the service
               _updateService.SetLastUpdate(DateTime.Now);
   
               var notificationList = _notificationService.GetLatestNotifications();
               _dispatcher(BuilActivityStream(notificationList));
           }
   
   
   }
   

6. If you do not want to modify your constructor - then just do this:

           //This is not the preferred way  - but it does the job
           public NotificationManager(Action<ActivityStream> dispatcher)
           {
               _userId = HttpContext.Current.User.Identity.CurrentUserId();
               _updateNotifier = new DbUpdateNotifier(_userId);
               _updateNotifier.NewNotification += NewNotificationHandler;
               unitOfWork = new UnitOfWork();
               _notificationService = new NotificationService(_userId, unitOfWork);
               _dispatcher = dispatcher;
               _updateService = DependencyResolver.Current.GetService<INotificationUpdateService>(); //versus having autofac resolve in the constructor
           }
   

7. Finally - use it:

      private void NewNotificationHandler(object sender, SqlNotificationEventArgs evt)
           {
   
               //Want to store lastRun variable in a session here
   
               //just put the datetime in through the service
               _updateService.SetLastUpdate(DateTime.Now);
   
               var notificationList = _notificationService.GetLatestNotifications();
               _dispatcher(BuilActivityStream(notificationList));
           }
   

This doesn't use session - but it does solve what you are trying to do. It also gives you an element of flexibility in that you can change out your backing data providers.

Answer 2

As @Ryios mentioned, you can access HttpContext.Current.Session. The main issue, though, is that HttpContext.Current is null when you are not in an HTTP context; for example when you are running your unit tests. What you are looking for for Dependency Injection.

HttpContext.Current.Session is an instance of System.Web.SessionState.HttpSessionState so you could update your NotificationManager constructor to accept an instance of HttpSessionState and the controller calling into it would pass HttpContext.Current.Session as a parameter.

Using your example, the call to NotificationManager.GetInstance would change to

    public NotificationHub()
    {
        _manager = NotificationManager.GetInstance(PushLatestNotifications, HttpContext.Current.Session);
    }

Answer 3

Per this answer:

You shouldn't use Session with SignalR (see SignalR doesn't use Session on server). You identify logical connections by their connection id which you can map to user names.

The underlying problem is that access to SessionState is serialized in ASP.NET to ensure state consistency, so each request to the hub would block other requests. In the past, limited read-only access (I assume (but can't confirm since the gist is gone) by setting EnableSessionstate to read-only, which prevents the locking problem I described) was possible, but support for this was dropped. Also see various other places where the SignalR team made similar statements. Lastly: there's a statement in the official documentation about HTTPContext.Current.Session.

I would just mark this as an exact duplicate of the question, but since you have a bounty this question cannot be closed.

Answer 4

You can follow the below solution, it works for me fine -

Notification HUB Code Behind -

public class NotificationsHub : Hub
{
    public void NotifyAllClients(string s_Not, DateTime d_LastRun)
    {
       IHubContext context = GlobalHost.ConnectionManager.GetHubContext<NotificationsHub>();
       context.Clients.All.displayNotification(s_Not, d_LastRun);
    }
}

You can supply the variables to Notification HUB using below way (for example, you can change as per your need) -

NotificationsHub nHub = new NotificationsHub();
nHub.NotifyAllClients("Test Notification", Now.Date);

Now if you want to save the last run time in session variable you can do it using Javascript -

<script type="text/javascript">            
        $(function () {
            var notify = $.connection.notificationsHub;

            notify.client.displayNotification = function (s_Not, d_LastRun) {
                "<%=System.Web.HttpContext.Current.Session("lastRun")="' + d_LastRun + '"%>";                    
            };

            $.connection.hub.start();

        });

    </script> 

I hope this would help.