refactored configuration

BusDemo/Program.cs

@@ -3,17 +3,13 @@
 using Microsoft.ServiceBus.Messaging;
 using Simple.ServiceBus;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Simple.ServiceBus.Autofac;
 
 namespace BusDemo
 {
     class Program
     {
-        static void Main(string[] args)
+        static void Main()
         {
             var container = new ContainerBuilder()
                 .RegisterServiceBus()

Simple.ServiceBus.Autofac/Extensions.cs

@@ -31,10 +31,6 @@ public static ISimpleBusConfigurator RegisterHandlers(this BuilderInitialized bu
 
         public static ISimpleBusConfigurator RegisterConfiguration(this ISimpleBusConfigurator builder, Assembly assembly)
         {
-            builder.Builder.RegisterAssemblyTypes(assembly)
-                .Where(x => x.GetInterfaces().Contains(typeof(ISubscriptionConfiguration<>)))
-                .AsImplementedInterfaces();
-
             return new SimpleBusConfigurator(builder.Builder);
         }
 
@@ -57,7 +53,7 @@ public BuilderInitialized(ContainerBuilder builder)
 
     public interface ISubscriptionConfigurator<T> : IBuilderAccessor
     {
-        ISimpleBusConfigurator Configure(Action<ISubscriptionConfiguration<T>> action);
+        ISimpleBusConfigurator Configure(Action<SubscriptionConfiguration> action);
         ISimpleBusConfigurator WithContainerConfig();
 
     }

Simple.ServiceBus.Autofac/ServiceBusModule.cs

@@ -15,7 +15,6 @@ public class ServiceBusModule : Module
         protected override void Load(ContainerBuilder builder)
         {
             builder.RegisterAssemblyTypes(System.Reflection.Assembly.GetAssembly(typeof (IServiceBus)))
-                .Except<Subscription.SubscriptionConfigurationRepository>()
                 .AsImplementedInterfaces()
                 .SingleInstance();
 
@@ -25,12 +24,7 @@ protected override void Load(ContainerBuilder builder)
             builder.Register(x => MessagingFactory.Create())
                 .AsSelf()
                 .SingleInstance();
-
-            builder.RegisterType<SubscriptionConfigurationRepository>()
-                .AsImplementedInterfaces()
-                .SingleInstance();
-
-
+
         }
     }
 }

Simple.ServiceBus.Autofac/Simple.ServiceBus.Autofac.csproj

@@ -53,7 +53,6 @@
     <Compile Include="ServiceBusModule.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SimpleBusConfigurator.cs" />
-    <Compile Include="SubscriptionConfigurationRepository.cs" />
     <Compile Include="SubscriptionConfigurator.cs" />
   </ItemGroup>
   <ItemGroup>

Simple.ServiceBus.Autofac/SubScriptionConfigurator.cs

@@ -14,9 +14,9 @@ public SubscriptionConfigurator(ISimpleBusConfigurator configurator)
             _configurator = configurator;
         }
 
-        public ISimpleBusConfigurator Configure(Action<ISubscriptionConfiguration<T>> action)
+        public ISimpleBusConfigurator Configure(Action<SubscriptionConfiguration> action)
         {
-            var config = new SubscriptionConfiguration<T>();
+            var config = new SubscriptionConfiguration();
             action(config);
             Builder.RegisterInstance(config)
                 .AsImplementedInterfaces()

Simple.ServiceBus/ServiceBusFactory.cs

@@ -1,11 +1,6 @@
 using Microsoft.ServiceBus;
 using Microsoft.ServiceBus.Messaging;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Simple.ServiceBus.Infrastructure;
 using Simple.ServiceBus.Publishing;
 using Simple.ServiceBus.Subscription;
 using MessageReceiver = Simple.ServiceBus.Subscription.MessageReceiver;
@@ -17,11 +12,10 @@ public class ServiceBusFactory
         private static readonly MessagingFactory MessagingFactory = MessagingFactory.Create();
         private static readonly NamespaceManager NamespaceManager = NamespaceManager.Create();
         private static readonly TopicRepository TopicRepository = new TopicRepository(NamespaceManager);
-        private static readonly SubscriptionConfigurationRepository SubscriptionConfigurationRepository =  new SubscriptionConfigurationRepository();
+
 
         internal static readonly ObservableSubscriptionManagerFactory ObservableSubscriptionManagerFactory = new ObservableSubscriptionManagerFactory(
-                    new MessageReceiver(new SubscriptionClientFactory(MessagingFactory, new SubscriptionRepository(NamespaceManager, TopicRepository)), SubscriptionConfigurationRepository),
-                    new SubscriptionConfigurationRepository()
+                    new MessageReceiver(new SubscriptionClientFactory(MessagingFactory, new SubscriptionRepository(NamespaceManager, TopicRepository)))
                 );
 
         private static readonly IServiceBus ServiceBus = new ServiceBus(

Simple.ServiceBus/Simple.ServiceBus.csproj

@@ -60,18 +60,17 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ServiceBusFactory.cs" />
     <Compile Include="Subscription\DisposableAction.cs" />
+    <Compile Include="Subscription\IConfigurated.cs" />
     <Compile Include="Subscription\IMessageReceiver.cs" />
     <Compile Include="Subscription\IObservableSubscriptionManagerFactory.cs" />
     <Compile Include="Subscription\ISubscriptionClientFactory.cs" />
-    <Compile Include="Subscription\ISubscriptionConfigurationRepository.cs" />
     <Compile Include="Subscription\ISubscriptionManager.cs" />
     <Compile Include="Subscription\ISubscriptionRepository.cs" />
     <Compile Include="Subscription\MessageReceiver.cs" />
     <Compile Include="Subscription\ObservableSubscriptionManagerFactory.cs" />
     <Compile Include="Subscription\ObservaleSubscriptionManager.cs" />
     <Compile Include="Subscription\SubscriptionClientFactory.cs" />
     <Compile Include="Subscription\SubscriptionConfiguration.cs" />
-    <Compile Include="Subscription\SubscriptionConfigurationRepository.cs" />
     <Compile Include="Subscription\SubscriptionManager.cs" />
     <Compile Include="Subscription\SubscriptionRepository.cs" />
   </ItemGroup>

Simple.ServiceBus/Subscription/DisposableAction.cs

@@ -2,7 +2,7 @@
 
 namespace Simple.ServiceBus.Subscription
 {
-    internal class DisposableAction : IDisposable
+    internal class DisposableAction : IConfigurated
     {
         private readonly Action _action;
 
@@ -16,6 +16,6 @@ public void Dispose()
             _action();
         }
 
-        public string Id { get; set; }
+        public SubscriptionConfiguration Config { get; set; }
     }
 }

Simple.ServiceBus/Subscription/IConfigurated.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Simple.ServiceBus.Subscription
+{
+    public interface IConfigurated:IDisposable
+    {
+        SubscriptionConfiguration Config { get; set; }
+    }
+}

Simple.ServiceBus/Subscription/IMessageReceiver.cs

@@ -5,6 +5,6 @@ namespace Simple.ServiceBus.Subscription
 {
     public interface IMessageReceiver
     {
-        IDisposable Receive<T>(ISubscriptionConfiguration<T> config, IObserver<T> observer);
+        IDisposable Receive<T>(SubscriptionConfiguration config, IObserver<T> observer);
     }
 }

Simple.ServiceBus/Subscription/ISubscriptionClientFactory.cs

@@ -4,6 +4,6 @@ namespace Simple.ServiceBus.Subscription
 {
     public interface ISubscriptionClientFactory
     {
-        SubscriptionClient CreateFor<T>(ISubscriptionConfiguration<T> config);
+        SubscriptionClient CreateFor<T>(SubscriptionConfiguration config);
     }
 }

Simple.ServiceBus/Subscription/MessageReceiver.cs

@@ -10,18 +10,17 @@ namespace Simple.ServiceBus.Subscription
     public class MessageReceiver : IMessageReceiver
     {
         private readonly ISubscriptionClientFactory _subscriptionClientFactory;
-        private readonly ISubscriptionConfigurationRepository _configurationRepository;
+
 
-        public MessageReceiver(ISubscriptionClientFactory subscriptionClientFactory, ISubscriptionConfigurationRepository configurationRepository)
+        public MessageReceiver(ISubscriptionClientFactory subscriptionClientFactory)
         {
             _subscriptionClientFactory = subscriptionClientFactory;
-            _configurationRepository = configurationRepository;
         }
 
-        public IDisposable Receive<T>(ISubscriptionConfiguration<T> config, IObserver<T> observer)
+        public IDisposable Receive<T>(SubscriptionConfiguration config, IObserver<T> observer)
         {
             //NOTE config is not used yet
-            var client = _subscriptionClientFactory.CreateFor(_configurationRepository.Get<T>());
+            var client = _subscriptionClientFactory.CreateFor<T>(config);
             Receive<T>(client, observer.OnNext, observer.OnError);
 
             return new DisposableAction(() => Stop<T>(client));

Simple.ServiceBus/Subscription/ObservableSubscriptionManagerFactory.cs

@@ -5,20 +5,17 @@ namespace Simple.ServiceBus.Subscription
     public class ObservableSubscriptionManagerFactory : IObservableSubscriptionManagerFactory
     {
         private readonly IMessageReceiver _messageReceiver;
-        private readonly ISubscriptionConfigurationRepository _configurationRepository;
+
 
-        public ObservableSubscriptionManagerFactory(
-            IMessageReceiver messageReceiver,
-            ISubscriptionConfigurationRepository configurationRepository
-            )
+        public ObservableSubscriptionManagerFactory(IMessageReceiver messageReceiver)
         {
             _messageReceiver = messageReceiver;
-            _configurationRepository = configurationRepository;
+
         }
 
         public INamedObservable<T> Create<T>()
-        {
-            return new ObservaleSubscriptionManager<T>(_messageReceiver, _configurationRepository);
-        }
+    {
+        return new ObservaleSubscriptionManager<T>(_messageReceiver);
+    }
     }
 }

Simple.ServiceBus/Subscription/ObservaleSubscriptionManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Data;
 using System.Linq;
 
@@ -10,34 +11,29 @@ public class ObservaleSubscriptionManager<T> : INamedObservable<T>
     {
         private readonly IMessageReceiver _messageReceiver;
         private readonly IDictionary<string, IObserver<T>> _observers;
-        private readonly ISubscriptionConfiguration<T> _config;
-
+
         public ObservaleSubscriptionManager(
-            IMessageReceiver messageReceiver,
-            ISubscriptionConfigurationRepository subscriptionConfigurationRepository)
+            IMessageReceiver messageReceiver)
         {
             _messageReceiver = messageReceiver;
             _observers = new ConcurrentDictionary<string, IObserver<T>>();
-            _config = subscriptionConfigurationRepository.Get<T>();
         }
 
         public IDisposable Subscribe(IObserver<T> observer)
         {
-            return Subscribe(observer, Guid.NewGuid().ToString());
+            return Subscribe(observer, new SubscriptionConfiguration { SubscriptionName = Guid.NewGuid().ToString() });
         }
-        public IDisposable Subscribe(IObserver<T> observer, string subscriptionKey)
+
+        public IConfigurated Subscribe(IObserver<T> observer, SubscriptionConfiguration config)
         {
             //TODO: needs to be unique for multiple application use
-            if (_observers.ContainsKey(subscriptionKey))
-                throw new DuplicateNameException(subscriptionKey);
-
-            _observers[subscriptionKey] = observer;
-            _config.SubscriptionName = subscriptionKey;
-
-            var stop = _messageReceiver.Receive(_config, observer);
-
+            if (_observers.ContainsKey(config.SubscriptionName))
+                throw new DuplicateNameException(config.SubscriptionName);
+            _observers[config.SubscriptionName] = observer;
+
+            var stop = _messageReceiver.Receive(config, observer);
 
-            return new DisposableAction(() => Unhsubscribe(subscriptionKey, stop)) { Id = subscriptionKey };
+            return new DisposableAction(() => Unhsubscribe(config.SubscriptionName, stop)) { Config=config };
         }
 
         private void Unhsubscribe(string subscriptionKey, IDisposable stoppable)
@@ -54,6 +50,6 @@ private void Unhsubscribe(string subscriptionKey, IDisposable stoppable)
 
     public interface INamedObservable<out T> : IObservable<T>
     {
-        IDisposable Subscribe(IObserver<T> observer, string name);
+        IConfigurated Subscribe(IObserver<T> observer, SubscriptionConfiguration config);
     }
 }

Simple.ServiceBus/Subscription/SubscriptionClientFactory.cs

@@ -14,7 +14,7 @@ public SubscriptionClientFactory(MessagingFactory messagingFactory,
             _subscriptionRepository = subscriptionRepository;
         }
 
-        public SubscriptionClient CreateFor<T>(ISubscriptionConfiguration<T> config)
+        public SubscriptionClient CreateFor<T>(SubscriptionConfiguration config)
         {
             var subscription = _subscriptionRepository.Get<T>(config.SubscriptionName);
             var topicPath = subscription.TopicPath;

Simple.ServiceBus/Subscription/SubscriptionConfiguration.cs

@@ -3,18 +3,7 @@
 
 namespace Simple.ServiceBus.Subscription
 {
-    public interface ISubscriptionConfiguration<T> : ISubscriptionReceiveConfiguration<T>
-    {
-        string SubscriptionName { get; set; }
-    }
-
-    public interface ISubscriptionReceiveConfiguration<T>
-    {
-        TimeSpan TimeSpan { get; set; }
-        ReceiveMode ReceiveMode { get; set; }
-    }
-
-    public class SubscriptionConfiguration<T> : ISubscriptionConfiguration<T>
+    public class SubscriptionConfiguration
     {
         public ReceiveMode ReceiveMode { get; set; }