Не получается настроить WCF service с callbackcontract-ом

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Runtime.Serialization;
using System.Security.Cryptography;
using System.ServiceModel;
using System.Text;
using WCFServiceLibrary.Models;
using WCFServiceLibrary.Validators;
 
namespace WCFServiceLibrary.Services
{
    [ServiceContract]
    [ServiceKnownType(typeof(User))]
    [ServiceKnownType(typeof(Validator<User>))]
    [ServiceKnownType(typeof(UserInUseValidator))]
    [ServiceKnownType(typeof(UserSignInValidator))]
    [ServiceKnownType(typeof(IObserver))]
    public interface IAuthorizationService
    {
        [OperationContract]
        string SignIn(User u, IEnumerable<Validator<User>> validators);
 
        [OperationContract]
        void SignOut(User u);
 
        [OperationContract]
        IEnumerable<int> GetUsedUserIds();        
    }
 
    [ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IObserver))]
    public interface IObservable
    {
        [OperationContract]
        void AddObserver(int usedUserId);
 
        [OperationContract]
        void RemoveObserver(int usedUserId);
 
        [OperationContract(IsOneWay = true)]
        void NotifyObservers();
    }
 
    [ServiceContract]
    public interface IObserver
    {
        [OperationContract(IsOneWay = true)]
        void OnUpdate(string text, IEnumerable<int> usedUserIds);
    }
 
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
    public class AuthorizationService : Service, IAuthorizationService, IObservable
    {        
        private GenericRepository<User> UserRepository;
        private GenericRepository<Log> LogRepository;
 
        public delegate void CallbackDelegate<T>(T t, IEnumerable<int> usedUserIds);
        public static CallbackDelegate<string> Update;
        internal static bool ObserversHaveChanged = true;
        internal static int initialLogId;
        internal static List<int> UsedUserIds = new List<int>();
 
        public AuthorizationService()
        {            
            Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 
            if (!config.ConnectionStrings.SectionInformation.IsProtected)
            {
                config.ConnectionStrings.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
                config.Save();
            }
 
            UserRepository = new GenericRepository<User>(context);
            LogRepository = new GenericRepository<Log>(context);
 
            initialLogId = context.Logs.Last().Id;
        }        
 
        public void Save()
        {
            context.SaveChanges();
        }
 
        public string SignIn(User u, IEnumerable<Validator<User>> validators)
        {
            StringBuilder sb = new StringBuilder();
            int PasswordLength;
            string buffer;
 
            // Генерация хеша пароля с солью
            u.Password = SHA512Hash.GenerateString("I aM A" + u.Password + "Lil slT");
            PasswordLength = u.Password.Length;
            // Отбор 32 символов из всего хеша (7 начальных, 23 центральных и 2 конечных символов)           
 
            sb.Append(u.Password, 0, 7);
            sb.Append(u.Password, PasswordLength / 2, 23);
            sb.Append(u.Password, PasswordLength - 2, 2);
 
            u.Password = sb.ToString();
            sb.Clear();            
 
            foreach(Validator<User> validator in validators)
            {
                buffer = validator.Check(u);
 
                if (buffer != String.Empty)
                {
                    sb.Append("● ");
                    sb.Append(buffer);
                    sb.Append("\n");
                }
            }
 
            buffer = sb.ToString();
 
            if (buffer == String.Empty)
            {               
                LogRepository.Insert(new Log() { Event_type_id = 2, Message = "Пользователь " + u.Login + " прошёл авторизацию.", Event_time = DateTime.Now });
                Save();
 
                int UserId = UserRepository.Get(uu => uu.Login == u.Login).Select(uu => uu.Id).FirstOrDefault();                    
 
                if (UserId != 0)
                    UsedUserIds.Add(UserId);
            }
 
            return buffer;
        }
 
        public void SignOut(User u)
        {
            LogRepository.Insert(new Log() { Event_type_id = 3, Message = "Пользователь " + u.Login + " вышел из учётной записи." });
            Save();
 
            UsedUserIds.Remove(u.Id);
        }
 
        public IEnumerable<int> GetUsedUserIds()
        {
            return UsedUserIds;
        }
 
        public void AddObserver(int usedUserId)
        {
            IObserver callback = OperationContext.Current.GetCallbackChannel<IObserver>();
            Update += callback.OnUpdate;
            //ICommunicationObject obj = (ICommunicationObject)callback;
 
            //obj.Closed += new EventHandler(Observer_Closed);
            // db.Event_types.Add(new Event_type { Name = "Авторизация пользователя" });
 
            UsedUserIds.Add(usedUserId);
            ObserversHaveChanged = true;            
        }
 
        //void Observer_Closed(object sender, EventArgs e)
        //{
        //    Update -= ((IObserver)sender).OnUpdate;
 
        //    //db.Event_types.Add(new Event_type { Name = "Выход из учётной записи" });
        //    ObserversHaveChanged = true;
        //}
 
        public void RemoveObserver(int usedUserId)
        {
            IObserver callback = OperationContext.Current.GetCallbackChannel<IObserver>();
            Update -= callback.OnUpdate;
 
            //db.Event_types.Add(new Event_type { Name = "Выход из учётной записи" });
 
            UsedUserIds.Remove(usedUserId);
            ObserversHaveChanged = true;            
        }
 
        public void NotifyObservers()
        {
            //foreach(IObserver o in Observers)
            //{
            //    o.Update(LogRepository.Get(orderBy: q => q.OrderByDescending(l => l.Id)).Select(l => l.Message).FirstOrDefault(), UsedUserIds);
            //}
 
            ObserversHaveChanged = false;
        }
    }        
}