diff --git a/src/KafkaFlow.Abstractions/Extensions/DependencyConfiguratorExtensions.cs b/src/KafkaFlow.Abstractions/Extensions/DependencyConfiguratorExtensions.cs
index c316a28b9..2c6b552db 100644
--- a/src/KafkaFlow.Abstractions/Extensions/DependencyConfiguratorExtensions.cs
+++ b/src/KafkaFlow.Abstractions/Extensions/DependencyConfiguratorExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using KafkaFlow.Configuration;
 
 namespace KafkaFlow
 {
@@ -21,6 +22,22 @@ public static IDependencyConfigurator AddSingleton<TService, TImplementation>(th
             return configurator.Add<TService, TImplementation>(InstanceLifetime.Singleton);
         }
 
+        /// <summary>
+        /// Registers a singleton type mapping if the given <typeparamref name="TService" /> is not already registered
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on.</param>
+        /// <typeparam name="TService"><see cref="Type"/> that will be requested.</typeparam>
+        /// <typeparam name="TImplementation"><see cref="Type"/> that will actually be returned.</typeparam>
+        /// <returns></returns>
+        public static IDependencyConfigurator TryAddSingleton<TService, TImplementation>(this IDependencyConfigurator configurator)
+            where TImplementation : class, TService
+            where TService : class
+        {
+            return configurator.AlreadyRegistered(typeof(TService))
+                ? configurator
+                : configurator.Add<TService, TImplementation>(InstanceLifetime.Singleton);
+        }
+
         /// <summary>
         /// Registers a singleton type mapping
         /// </summary>
@@ -33,6 +50,20 @@ public static IDependencyConfigurator AddSingleton<TService>(this IDependencyCon
             return configurator.Add<TService>(InstanceLifetime.Singleton);
         }
 
+        /// <summary>
+        /// Registers a singleton type mapping if the given <typeparamref name="TService" /> is not already registered
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on</param>
+        /// <typeparam name="TService"><see cref="Type"/> that will be created</typeparam>
+        /// <returns></returns>
+        public static IDependencyConfigurator TryAddSingleton<TService>(this IDependencyConfigurator configurator)
+            where TService : class
+        {
+            return configurator.AlreadyRegistered(typeof(TService))
+                ? configurator
+                : configurator.Add<TService>(InstanceLifetime.Singleton);
+        }
+
         /// <summary>
         /// Registers a singleton type mapping where the returned instance will be the given implementation
         /// </summary>
@@ -48,6 +79,23 @@ public static IDependencyConfigurator AddSingleton<TService>(
             return configurator.Add(service);
         }
 
+        /// <summary>
+        /// Registers a singleton type mapping where the returned instance will be the given implementation if the given <typeparamref name="TService" /> is not already registered
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on</param>
+        /// <param name="service"><see cref="Type"/> that will be returned</param>
+        /// <typeparam name="TService">Type that will be created</typeparam>
+        /// <returns></returns>
+        public static IDependencyConfigurator TryAddSingleton<TService>(
+            this IDependencyConfigurator configurator,
+            TService service)
+            where TService : class
+        {
+            return configurator.AlreadyRegistered(typeof(TService))
+                ? configurator
+                : configurator.Add(service);
+        }
+
         /// <summary>
         /// Registers a singleton type mapping where the returned instance will be given by the provided factory
         /// </summary>
@@ -65,6 +113,25 @@ public static IDependencyConfigurator AddSingleton<TService>(
                 InstanceLifetime.Singleton);
         }
 
+        /// <summary>
+        /// Registers a singleton type mapping where the returned instance will be given by the provided factory if the given <typeparamref name="TService" /> is not already registered
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on</param>
+        /// <param name="factory">A factory to create new instances of the service implementation</param>
+        /// <typeparam name="TService">Type that will be created</typeparam>
+        /// <returns></returns>
+        public static IDependencyConfigurator TryAddSingleton<TService>(
+            this IDependencyConfigurator configurator,
+            Func<IDependencyResolver, TService> factory)
+        {
+            return configurator.AlreadyRegistered(typeof(TService))
+                ? configurator
+                : configurator.Add(
+                    typeof(TService),
+                    factory,
+                    InstanceLifetime.Singleton);
+        }
+
         /// <summary>
         /// Registers a scoped type mapping where the returned instance will be given by the provided factory
         /// </summary>
@@ -112,6 +179,26 @@ public static IDependencyConfigurator AddTransient(
                 InstanceLifetime.Transient);
         }
 
+        /// <summary>
+        /// Registers a transient type mapping if the given <paramref name="serviceType" /> is not already registered
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on</param>
+        /// <param name="serviceType"><see cref="Type"/> that will be requested</param>
+        /// <param name="implementationType"><see cref="Type"/> that will actually be returned</param>
+        /// <returns></returns>
+        public static IDependencyConfigurator TryAddTransient(
+            this IDependencyConfigurator configurator,
+            Type serviceType,
+            Type implementationType)
+        {
+            return configurator.AlreadyRegistered(serviceType)
+                ? configurator
+                : configurator.Add(
+                    serviceType,
+                    implementationType,
+                    InstanceLifetime.Transient);
+        }
+
         /// <summary>
         /// Registers a transient type mapping
         /// </summary>
@@ -124,6 +211,50 @@ public static IDependencyConfigurator AddTransient<TService>(this IDependencyCon
             return configurator.Add<TService>(InstanceLifetime.Transient);
         }
 
+        /// <summary>
+        /// Registers a transient type mapping if the given <typeparamref name="TService" /> is not already registered
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on</param>
+        /// <typeparam name="TService">Type that will be created</typeparam>
+        /// <returns></returns>
+        public static IDependencyConfigurator TryAddTransient<TService>(this IDependencyConfigurator configurator)
+            where TService : class
+        {
+            return configurator.AlreadyRegistered(typeof(TService))
+                ? configurator
+                : configurator.Add<TService>(InstanceLifetime.Transient);
+        }
+
+        /// <summary>
+        /// Registers a singleton type mapping
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on.</param>
+        /// <typeparam name="TService"><see cref="Type"/> that will be requested.</typeparam>
+        /// <typeparam name="TImplementation"><see cref="Type"/> that will actually be returned.</typeparam>
+        /// <returns></returns>
+        public static IDependencyConfigurator AddTransient<TService, TImplementation>(this IDependencyConfigurator configurator)
+            where TImplementation : class, TService
+            where TService : class
+        {
+            return configurator.Add<TService, TImplementation>(InstanceLifetime.Transient);
+        }
+
+        /// <summary>
+        /// Registers a singleton type mapping if the given <typeparamref name="TService" /> is not already registered
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on.</param>
+        /// <typeparam name="TService"><see cref="Type"/> that will be requested.</typeparam>
+        /// <typeparam name="TImplementation"><see cref="Type"/> that will actually be returned.</typeparam>
+        /// <returns></returns>
+        public static IDependencyConfigurator TryAddTransient<TService, TImplementation>(this IDependencyConfigurator configurator)
+            where TImplementation : class, TService
+            where TService : class
+        {
+            return configurator.AlreadyRegistered(typeof(TService))
+                ? configurator
+                : configurator.Add<TService, TImplementation>(InstanceLifetime.Transient);
+        }
+
         /// <summary>
         /// Registers a transient type mapping where the returned instance will be given by the provided factory
         /// </summary>
@@ -140,5 +271,38 @@ public static IDependencyConfigurator AddTransient<TService>(
                 factory,
                 InstanceLifetime.Transient);
         }
+
+        /// <summary>
+        /// Registers a transient type mapping where the returned instance will be given by the provided factory if the given <typeparamref name="TService" /> is not already registered
+        /// </summary>
+        /// <param name="configurator">The <see cref="IDependencyConfigurator"/> object that this method was called on</param>
+        /// <param name="factory">A factory to create new instances of the service implementation</param>
+        /// <typeparam name="TService">Type that will be created</typeparam>
+        /// <returns></returns>
+        public static IDependencyConfigurator TryAddTransient<TService>(
+            this IDependencyConfigurator configurator,
+            Func<IDependencyResolver, TService> factory)
+        {
+            return configurator.AlreadyRegistered(typeof(TService))
+                ? configurator
+                : configurator.Add(
+                    typeof(TService),
+                    factory,
+                    InstanceLifetime.Transient);
+        }
+
+        /// <summary>
+        /// Add a type mapping to the cluster dependency resolver
+        /// </summary>
+        /// <param name="cluster">Cluster configuration builder</param>
+        /// <param name="handler">A handler to set the configuration values</param>
+        /// <returns></returns>
+        public static IClusterConfigurationBuilder WithDependencies(
+            this IClusterConfigurationBuilder cluster,
+            Action<IDependencyConfigurator> handler)
+        {
+            handler(cluster.DependencyConfigurator);
+            return cluster;
+        }
     }
 }
diff --git a/src/KafkaFlow.Abstractions/IDependencyConfigurator.cs b/src/KafkaFlow.Abstractions/IDependencyConfigurator.cs
index 47d52ce46..71cd7400b 100644
--- a/src/KafkaFlow.Abstractions/IDependencyConfigurator.cs
+++ b/src/KafkaFlow.Abstractions/IDependencyConfigurator.cs
@@ -54,5 +54,12 @@ IDependencyConfigurator Add<TImplementation>(
             Type serviceType,
             Func<IDependencyResolver, TImplementation> factory,
             InstanceLifetime lifetime);
+
+        /// <summary>
+        /// Checks if the given <paramref name="registeredType" /> is already registered
+        /// </summary>
+        /// <param name="registeredType">Service type</param>
+        /// <returns></returns>
+        bool AlreadyRegistered(Type registeredType);
     }
 }
diff --git a/src/KafkaFlow.Microsoft.DependencyInjection/MicrosoftDependencyConfigurator.cs b/src/KafkaFlow.Microsoft.DependencyInjection/MicrosoftDependencyConfigurator.cs
index d7cec29e3..9ac0d17a6 100644
--- a/src/KafkaFlow.Microsoft.DependencyInjection/MicrosoftDependencyConfigurator.cs
+++ b/src/KafkaFlow.Microsoft.DependencyInjection/MicrosoftDependencyConfigurator.cs
@@ -73,6 +73,19 @@ public IDependencyConfigurator Add<TImplementation>(
             return this;
         }
 
+        public bool AlreadyRegistered(Type registeredType)
+        {
+            foreach (var s in _services)
+            {
+                if (s.ServiceType == registeredType)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         private static ServiceLifetime ParseLifetime(InstanceLifetime lifetime)
         {
             switch (lifetime)
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ConfluentAvroTypeNameResolver.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ConfluentAvroTypeNameResolver.cs
index 79be740ff..a8dd3c3b1 100644
--- a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ConfluentAvroTypeNameResolver.cs
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ConfluentAvroTypeNameResolver.cs
@@ -4,7 +4,7 @@
 
 namespace KafkaFlow.Serializer.SchemaRegistry
 {
-    internal class ConfluentAvroTypeNameResolver : ISchemaRegistryTypeNameResolver
+    internal sealed class ConfluentAvroTypeNameResolver : IConfluentAvroTypeNameResolver
     {
         private readonly ISchemaRegistryClient _client;
 
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ConsumerConfigurationBuilderExtensions.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ConsumerConfigurationBuilderExtensions.cs
index e0e44fda5..4ca34e35e 100644
--- a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ConsumerConfigurationBuilderExtensions.cs
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ConsumerConfigurationBuilderExtensions.cs
@@ -1,5 +1,4 @@
-using Confluent.SchemaRegistry;
-using KafkaFlow.Configuration;
+using KafkaFlow.Configuration;
 using KafkaFlow.Middlewares.Serializer;
 using KafkaFlow.Serializer.SchemaRegistry;
 
@@ -18,10 +17,12 @@ public static class ConsumerConfigurationBuilderExtensions
         public static IConsumerMiddlewareConfigurationBuilder AddSchemaRegistryAvroDeserializer(
             this IConsumerMiddlewareConfigurationBuilder middlewares)
         {
+            middlewares.DependencyConfigurator.TryAddTransient<IConfluentAvroTypeNameResolver, ConfluentAvroTypeNameResolver>();
+
             return middlewares.Add(
                 resolver => new DeserializerConsumerMiddleware(
                     new ConfluentAvroDeserializer(resolver),
-                    new SchemaRegistryTypeResolver(new ConfluentAvroTypeNameResolver(resolver.Resolve<ISchemaRegistryClient>()))));
+                    new SchemaRegistryTypeResolver(resolver.Resolve<IConfluentAvroTypeNameResolver>())));
         }
     }
 }
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/IConfluentAvroTypeNameResolver.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/IConfluentAvroTypeNameResolver.cs
new file mode 100644
index 000000000..19391b03e
--- /dev/null
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/IConfluentAvroTypeNameResolver.cs
@@ -0,0 +1,7 @@
+namespace KafkaFlow.Serializer.SchemaRegistry
+{
+    /// <inheritdoc />
+    public interface IConfluentAvroTypeNameResolver : ISchemaRegistryTypeNameResolver
+    {
+    }
+}
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ProducerConfigurationBuilderExtensions.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ProducerConfigurationBuilderExtensions.cs
index 5c4e98536..57adba494 100644
--- a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ProducerConfigurationBuilderExtensions.cs
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentAvro/ProducerConfigurationBuilderExtensions.cs
@@ -21,10 +21,12 @@ public static IProducerMiddlewareConfigurationBuilder AddSchemaRegistryAvroSeria
             this IProducerMiddlewareConfigurationBuilder middlewares,
             AvroSerializerConfig config = null)
         {
+            middlewares.DependencyConfigurator.TryAddTransient<IConfluentAvroTypeNameResolver, ConfluentAvroTypeNameResolver>();
+
             return middlewares.Add(
                 resolver => new SerializerProducerMiddleware(
                     new ConfluentAvroSerializer(resolver, config),
-                    new SchemaRegistryTypeResolver(new ConfluentAvroTypeNameResolver(resolver.Resolve<ISchemaRegistryClient>()))));
+                    new SchemaRegistryTypeResolver(resolver.Resolve<IConfluentAvroTypeNameResolver>())));
         }
     }
 }
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/AssemblyInfo.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/AssemblyInfo.cs
index 17459bd5a..f8402e685 100644
--- a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/AssemblyInfo.cs
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/AssemblyInfo.cs
@@ -1,3 +1,4 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("KafkaFlow.UnitTests")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ConfluentProtobufTypeNameResolver.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ConfluentProtobufTypeNameResolver.cs
index ff754b45a..665bb4af1 100644
--- a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ConfluentProtobufTypeNameResolver.cs
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ConfluentProtobufTypeNameResolver.cs
@@ -4,9 +4,9 @@
 using Google.Protobuf;
 using Google.Protobuf.Reflection;
 
-namespace KafkaFlow
+namespace KafkaFlow.Serializer.SchemaRegistry
 {
-    internal class ConfluentProtobufTypeNameResolver : ISchemaRegistryTypeNameResolver
+    internal class ConfluentProtobufTypeNameResolver : IConfluentProtobufTypeNameResolver
     {
         private readonly ISchemaRegistryClient _client;
 
@@ -21,7 +21,18 @@ public async Task<string> ResolveAsync(int id)
 
             var protoFields = FileDescriptorProto.Parser.ParseFrom(ByteString.FromBase64(schemaString));
 
-            return $"{protoFields.Package}.{protoFields.MessageType.FirstOrDefault()?.Name}";
+            return BuildTypeName(protoFields);
+        }
+
+        private static string BuildTypeName(FileDescriptorProto protoFields)
+        {
+            var package = protoFields.Package;
+            if (string.IsNullOrEmpty(package))
+            {
+                package = protoFields.Options.CsharpNamespace;
+            }
+
+            return $"{package}.{protoFields.MessageType.FirstOrDefault()?.Name}";
         }
     }
 }
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ConsumerConfigurationBuilderExtensions.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ConsumerConfigurationBuilderExtensions.cs
index 558eb8056..b60d20812 100644
--- a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ConsumerConfigurationBuilderExtensions.cs
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ConsumerConfigurationBuilderExtensions.cs
@@ -1,5 +1,4 @@
-using Confluent.SchemaRegistry;
-using KafkaFlow.Configuration;
+using KafkaFlow.Configuration;
 using KafkaFlow.Middlewares.Serializer;
 using KafkaFlow.Serializer.SchemaRegistry;
 
@@ -18,10 +17,12 @@ public static class ConsumerConfigurationBuilderExtensions
         public static IConsumerMiddlewareConfigurationBuilder AddSchemaRegistryProtobufDeserializer(
             this IConsumerMiddlewareConfigurationBuilder middlewares)
         {
+            middlewares.DependencyConfigurator.TryAddTransient<IConfluentProtobufTypeNameResolver, ConfluentProtobufTypeNameResolver>();
+
             return middlewares.Add(
                 resolver => new DeserializerConsumerMiddleware(
                     new ConfluentProtobufDeserializer(),
-                    new SchemaRegistryTypeResolver(new ConfluentProtobufTypeNameResolver(resolver.Resolve<ISchemaRegistryClient>()))));
+                    new SchemaRegistryTypeResolver(resolver.Resolve<IConfluentProtobufTypeNameResolver>())));
         }
     }
 }
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/IConfluentProtobufTypeNameResolver.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/IConfluentProtobufTypeNameResolver.cs
new file mode 100644
index 000000000..1f17fa35f
--- /dev/null
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/IConfluentProtobufTypeNameResolver.cs
@@ -0,0 +1,7 @@
+namespace KafkaFlow.Serializer.SchemaRegistry
+{
+    /// <inheritdoc />
+    public interface IConfluentProtobufTypeNameResolver : ISchemaRegistryTypeNameResolver
+    {
+    }
+}
diff --git a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ProducerConfigurationBuilderExtensions.cs b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ProducerConfigurationBuilderExtensions.cs
index 180073f59..9c7e0b977 100644
--- a/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ProducerConfigurationBuilderExtensions.cs
+++ b/src/KafkaFlow.Serializer.SchemaRegistry.ConfluentProtobuf/ProducerConfigurationBuilderExtensions.cs
@@ -1,5 +1,4 @@
-using Confluent.SchemaRegistry;
-using Confluent.SchemaRegistry.Serdes;
+using Confluent.SchemaRegistry.Serdes;
 using KafkaFlow.Configuration;
 using KafkaFlow.Middlewares.Serializer;
 using KafkaFlow.Serializer.SchemaRegistry;
@@ -21,10 +20,12 @@ public static IProducerMiddlewareConfigurationBuilder AddSchemaRegistryProtobufS
             this IProducerMiddlewareConfigurationBuilder middlewares,
             ProtobufSerializerConfig config = null)
         {
+            middlewares.DependencyConfigurator.TryAddTransient<IConfluentProtobufTypeNameResolver, ConfluentProtobufTypeNameResolver>();
+
             return middlewares.Add(
                 resolver => new SerializerProducerMiddleware(
                     new ConfluentProtobufSerializer(resolver, config),
-                    new SchemaRegistryTypeResolver(new ConfluentProtobufTypeNameResolver(resolver.Resolve<ISchemaRegistryClient>()))));
+                    new SchemaRegistryTypeResolver(resolver.Resolve<IConfluentProtobufTypeNameResolver>())));
         }
     }
 }
diff --git a/src/KafkaFlow.Unity/UnityDependencyConfigurator.cs b/src/KafkaFlow.Unity/UnityDependencyConfigurator.cs
index 452e0d19e..7e24b35ac 100644
--- a/src/KafkaFlow.Unity/UnityDependencyConfigurator.cs
+++ b/src/KafkaFlow.Unity/UnityDependencyConfigurator.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Linq;
-using global::Unity;
-using global::Unity.Lifetime;
+using Unity;
+using Unity.Lifetime;
 
 namespace KafkaFlow.Unity
 {
@@ -67,7 +67,7 @@ public IDependencyConfigurator Add<TImplementation>(
         {
             string name = null;
 
-            if (this.AlreadyRegistered(serviceType))
+            if (AlreadyRegistered(serviceType))
             {
                 name = Guid.NewGuid().ToString();
             }
@@ -81,6 +81,12 @@ public IDependencyConfigurator Add<TImplementation>(
             return this;
         }
 
+        /// <inheritdoc />
+        public bool AlreadyRegistered(Type registeredType)
+        {
+            return _container.Registrations.Any(x => x.RegisteredType == registeredType);
+        }
+
         private static object ParseLifetime(InstanceLifetime lifetime) =>
             lifetime switch
             {
@@ -89,10 +95,5 @@ private static object ParseLifetime(InstanceLifetime lifetime) =>
                 InstanceLifetime.Transient => new TransientLifetimeManager(),
                 _ => throw new InvalidCastException($"There is not mapping defined to {lifetime}")
             };
-
-        private bool AlreadyRegistered(Type registeredType)
-        {
-            return _container.Registrations.Any(x => x.RegisteredType == registeredType);
-        }
     }
 }
diff --git a/tests/KafkaFlow.UnitTests/ConfigurationBuilders/DependencyConfiguratorExtensionsTests.cs b/tests/KafkaFlow.UnitTests/ConfigurationBuilders/DependencyConfiguratorExtensionsTests.cs
new file mode 100644
index 000000000..71b87e606
--- /dev/null
+++ b/tests/KafkaFlow.UnitTests/ConfigurationBuilders/DependencyConfiguratorExtensionsTests.cs
@@ -0,0 +1,143 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+
+namespace KafkaFlow.UnitTests.ConfigurationBuilders
+{
+    [TestClass]
+    public class DependencyConfiguratorExtensionsTests
+    {
+        private static IEnumerable<object[]> _methodsForAdd
+        {
+            get
+            {
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.AddSingleton<IList, ArrayList>()),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add<IList, ArrayList>(InstanceLifetime.Singleton)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.AddSingleton<ArrayList>()),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add<ArrayList>(InstanceLifetime.Singleton)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.AddSingleton(new ArrayList())),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add(It.IsAny<ArrayList>())),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.AddSingleton(_ => new ArrayList())),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add(typeof(ArrayList), It.IsAny<Func<IDependencyResolver, ArrayList>>(), InstanceLifetime.Singleton)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.AddTransient<IList, ArrayList>()),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add<IList, ArrayList>(InstanceLifetime.Transient)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.AddTransient<ArrayList>()),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add<ArrayList>(InstanceLifetime.Transient)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.AddTransient(_ => new ArrayList())),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add(typeof(ArrayList), It.IsAny<Func<IDependencyResolver, ArrayList>>(), InstanceLifetime.Transient)),
+                };
+            }
+        }
+
+        private static IEnumerable<object[]> _methodsForTryAdd
+        {
+            get
+            {
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.TryAddSingleton<IList, ArrayList>()),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add<IList, ArrayList>(InstanceLifetime.Singleton)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.TryAddSingleton<ArrayList>()),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add<ArrayList>(InstanceLifetime.Singleton)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.TryAddSingleton(new ArrayList())),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add(It.IsAny<ArrayList>())),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.TryAddSingleton(_ => new ArrayList())),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add(typeof(ArrayList), It.IsAny<Func<IDependencyResolver, ArrayList>>(), InstanceLifetime.Singleton)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.TryAddTransient<IList, ArrayList>()),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add<IList, ArrayList>(InstanceLifetime.Transient)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.TryAddTransient<ArrayList>()),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add<ArrayList>(InstanceLifetime.Transient)),
+                };
+                yield return new object[]
+                {
+                    (Action<IDependencyConfigurator>)(configurator => configurator.TryAddTransient(_ => new ArrayList())),
+                    (Expression<Action<IDependencyConfigurator>>)(configurator => configurator.Add(typeof(ArrayList), It.IsAny<Func<IDependencyResolver, ArrayList>>(), InstanceLifetime.Transient)),
+                };
+            }
+        }
+
+        [TestMethod]
+        [DynamicData(nameof(_methodsForAdd))]
+        public void Add(Action<IDependencyConfigurator> addMethod, Expression<Action<IDependencyConfigurator>> underlyingAddMethod)
+        {
+            // Arrange
+            var configurator = new Mock<IDependencyConfigurator>();
+
+            // Act
+            addMethod(configurator.Object);
+
+            // Assert
+            configurator.Verify(underlyingAddMethod, Times.Once);
+        }
+
+        [TestMethod]
+        [DynamicData(nameof(_methodsForTryAdd))]
+        public void TryAdd_AddWhenNotExists(Action<IDependencyConfigurator> tryAddMethod, Expression<Action<IDependencyConfigurator>> underlyingAddMethod)
+        {
+            // Arrange
+            var configurator = new Mock<IDependencyConfigurator>();
+            configurator.Setup(c => c.AlreadyRegistered(typeof(IList))).Returns(false);
+            configurator.Setup(c => c.AlreadyRegistered(typeof(ArrayList))).Returns(false);
+
+            // Act
+            tryAddMethod(configurator.Object);
+
+            // Assert
+            configurator.Verify(underlyingAddMethod, Times.Once);
+        }
+
+        [TestMethod]
+        [DynamicData(nameof(_methodsForTryAdd))]
+        public void TryAdd_IgnoreWhenExists(Action<IDependencyConfigurator> tryAddMethod, Expression<Action<IDependencyConfigurator>> underlyingAddMethod)
+        {
+            // Arrange
+            var configurator = new Mock<IDependencyConfigurator>();
+            configurator.Setup(c => c.AlreadyRegistered(typeof(IList))).Returns(true);
+            configurator.Setup(c => c.AlreadyRegistered(typeof(ArrayList))).Returns(true);
+
+            // Act
+            tryAddMethod(configurator.Object);
+
+            // Assert
+            configurator.Verify(underlyingAddMethod, Times.Never);
+        }
+    }
+}
diff --git a/tests/KafkaFlow.UnitTests/KafkaFlow.UnitTests.csproj b/tests/KafkaFlow.UnitTests/KafkaFlow.UnitTests.csproj
index 4819c54ce..62f4b7482 100644
--- a/tests/KafkaFlow.UnitTests/KafkaFlow.UnitTests.csproj
+++ b/tests/KafkaFlow.UnitTests/KafkaFlow.UnitTests.csproj
@@ -26,6 +26,8 @@
         <PackageReference Include="Moq" Version="4.16.1" />
         <PackageReference Include="MSTest.TestAdapter" Version="2.2.5" />
         <PackageReference Include="MSTest.TestFramework" Version="2.2.5" />
+        <PackageReference Include="Confluent.SchemaRegistry" Version="2.1.1" />
+        <PackageReference Include="Confluent.SchemaRegistry.Serdes.Protobuf" Version="2.1.1" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/tests/KafkaFlow.UnitTests/Middlewares/Serialization/ConfluentProtobufTypeNameResolverTests.cs b/tests/KafkaFlow.UnitTests/Middlewares/Serialization/ConfluentProtobufTypeNameResolverTests.cs
index 4185222eb..5252be581 100644
--- a/tests/KafkaFlow.UnitTests/Middlewares/Serialization/ConfluentProtobufTypeNameResolverTests.cs
+++ b/tests/KafkaFlow.UnitTests/Middlewares/Serialization/ConfluentProtobufTypeNameResolverTests.cs
@@ -1,10 +1,10 @@
 using System;
 using System.Threading.Tasks;
 using Confluent.SchemaRegistry;
-
 using FluentAssertions;
-
 using Google.Protobuf;
+using Google.Protobuf.Reflection;
+using KafkaFlow.Serializer.SchemaRegistry;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
 
@@ -13,36 +13,63 @@ namespace KafkaFlow.UnitTests.Middlewares.Serialization
     [TestClass]
     public class ConfluentProtobufTypeNameResolverTests
     {
-        private readonly Mock<ISchemaRegistryClient> _schemaRegistryClient;
-        private readonly ConfluentProtobufTypeNameResolver _schemaRegistryTypeResolver;
+        private const string MessageTypeName = "TestMessage";
 
-        public ConfluentProtobufTypeNameResolverTests()
+        [TestMethod]
+        public async Task ResolveAsync_WithPackage_ReturnTypeName()
         {
-            _schemaRegistryClient = new Mock<ISchemaRegistryClient>();
-            _schemaRegistryTypeResolver = new ConfluentProtobufTypeNameResolver(_schemaRegistryClient.Object);
+            // Arrange
+            var schemaRegistryClientMock = CreateSchemaRegistryClientMock(p => p.Package = "TestPackage");
+            var resolver = new ConfluentProtobufTypeNameResolver(schemaRegistryClientMock.Object);
+
+            // Act
+            var typeName = await resolver.ResolveAsync(1);
+
+            // Assert
+            typeName.Should().Be($"TestPackage.{MessageTypeName}");
         }
 
         [TestMethod]
-        public async Task ResolveAsync_ValidProtobufObject_ReturnsProtoFields()
+        public async Task ResolveAsync_NoPackageWithCsharpNamespace_ReturnTypeName()
         {
             // Arrange
-            var schemaId = 420;
+            var schemaRegistryClientMock = CreateSchemaRegistryClientMock(p =>
+            {
+                p.Package = string.Empty;
+                p.Options.CsharpNamespace = "TestCsharpNamespace";
+            });
+            var resolver = new ConfluentProtobufTypeNameResolver(schemaRegistryClientMock.Object);
 
-            var dummyProtobufObj = new DummyProtobufObject
+            // Act
+            var typeName = await resolver.ResolveAsync(1);
+
+            // Assert
+            typeName.Should().Be($"TestCsharpNamespace.{MessageTypeName}");
+        }
+
+        private static Mock<ISchemaRegistryClient> CreateSchemaRegistryClientMock(Action<FileDescriptorProto> configure)
+        {
+            var protoFields = new FileDescriptorProto
             {
-                Field1 = "Field1",
-                Field2 = 8,
+                MessageType =
+                {
+                    new DescriptorProto
+                    {
+                        Name = MessageTypeName,
+                    },
+                },
+                Options = new FileOptions(),
             };
-            var base64Encoded = Convert.ToBase64String(dummyProtobufObj.ToByteArray());
+            configure(protoFields);
 
-            _schemaRegistryClient.Setup(client => client.GetSchemaAsync(schemaId, "serialized"))
-                .ReturnsAsync(new Schema(base64Encoded, SchemaType.Protobuf));
+            var schema = new Schema(protoFields.ToByteString().ToBase64(), SchemaType.Protobuf);
 
-            // Act
-            var protoFields = await _schemaRegistryTypeResolver.ResolveAsync(schemaId);
+            var schemaRegistryClientMock = new Mock<ISchemaRegistryClient>();
+            schemaRegistryClientMock
+                .Setup(o => o.GetSchemaAsync(1, "serialized"))
+                .ReturnsAsync(schema);
 
-            // Assert
-            protoFields.Should().NotBeNull();
+            return schemaRegistryClientMock;
         }
     }
 }