internal static string NoRegistrationForTypeFound(Type serviceType, bool containerHasRegistrations) { return string.Format(CultureInfo.InvariantCulture, "No registration for type {0} could be found.{1}", serviceType.ToFriendlyName(), ContainsHasNoRegistrationsAddition(containerHasRegistrations)); }
// This method takes generic type and returns a 'partially' generic type definition of that same type, // where all generic arguments up to the given nesting level. This allows us to group generic types // by their partial generic type definition, which allows a much nicer user experience. internal static Type MakeTypePartiallyGenericUpToLevel(Type type, int nestingLevel) { if (nestingLevel > 100) { // Stack overflow prevention throw new ArgumentException("nesting level bigger than 100 too high. Type: " + type.ToFriendlyName(), nameof(nestingLevel)); } // example given type: IEnumerable<IQueryProcessor<MyQuery<Alpha>, int[]>> // nestingLevel 4 returns: IEnumerable<IQueryHandler<MyQuery<Alpha>, int[]> // nestingLevel 3 returns: IEnumerable<IQueryHandler<MyQuery<Alpha>, int[]> // nestingLevel 2 returns: IEnumerable<IQueryHandler<MyQuery<T>, int[]> // nestingLevel 1 returns: IEnumerable<IQueryHandler<TQuery, TResult>> // nestingLevel 0 returns: IEnumerable<T> if (!type.IsGenericType) { return type; } if (nestingLevel == 0) { return type.GetGenericTypeDefinition(); } return MakeTypePartiallyGeneric(type, nestingLevel); }
internal static string ErrorWhileBuildingDelegateFromExpression(Type serviceType, Expression expression, Exception exception) { return string.Format(CultureInfo.InvariantCulture, "Error occurred while trying to build a delegate for type {0} using the expression \"{1}\". " + "{2}", serviceType.ToFriendlyName(), expression, exception.Message); }
private static DebuggerViewItem[] GetDebugValue(Type implementationType, InstanceProducer[] dependencies) { return new[] { new DebuggerViewItem("ImplementationType", implementationType.ToFriendlyName(), implementationType), new DebuggerViewItem("Dependencies", dependencies.Length + " dependencies.", dependencies), }; }
internal static string NoRegistrationForTypeFound(Type serviceType, bool containerHasRegistrations, bool containerHasRelatedOneToOneMapping, bool containerHasRelatedCollectionMapping, Type[] skippedDecorators) => string.Format(CultureInfo.InvariantCulture, "No registration for type {0} could be found.{1}{2}{3}{4}", serviceType.ToFriendlyName(), ContainerHasNoRegistrationsAddition(containerHasRegistrations), DidYouMeanToCallGetInstanceInstead(containerHasRelatedOneToOneMapping, serviceType), DidYouMeanToCallGetAllInstancesInstead(containerHasRelatedCollectionMapping, serviceType), NoteThatSkippedDecoratorsWereFound(serviceType, skippedDecorators));
static string CreateMessage(Type messageType, IEnumerable<Exception> exceptions) { SendException sendException = exceptions .Where(x => x.GetType() == typeof(SendException)) .Cast<SendException>() .FirstOrDefault(); if (sendException != null) { return string.Format("At least one exception occurred publishing {0} to {1}", sendException.MessageType.ToFriendlyName(), sendException.Uri); } return string.Format("At least one exception occurred publishing {0}", messageType.ToFriendlyName()); }
private static DebuggerViewItem[] CreateDebugValue(Type implementationType, Lifestyle lifestyle, InstanceProducer[] affectedRegistrations) { return new[] { new DebuggerViewItem( name: "ImplementationType", description: implementationType.ToFriendlyName(), value: implementationType), new DebuggerViewItem( name: "Lifestyle", description: lifestyle.Name, value: lifestyle), new DebuggerViewItem( name: "Affected Registrations", description: ToCommaSeparatedText(affectedRegistrations), value: affectedRegistrations) }; }
private static DebuggerViewItem[] CreateDebugValue(Type implementationType, Lifestyle[] lifestyles, InstanceProducer[] conflictingRegistrations) { return new[] { new DebuggerViewItem( name: "ImplementationType", description: implementationType.ToFriendlyName(), value: implementationType), new DebuggerViewItem( name: "Lifestyles", description: ToCommaSeparatedText(lifestyles), value: lifestyles), new DebuggerViewItem( name: "Conflicting Registrations", description: ToCommaSeparatedText(conflictingRegistrations), value: conflictingRegistrations) }; }
private static string DidYouMeanToCallGetAllInstancesInstead(bool hasCollection, Type serviceType) => hasCollection ? string.Format(CultureInfo.InvariantCulture, " There is, however, a registration for {0}; Did you mean to call " + "GetAllInstances<{1}>() or depend on {0}?", typeof(IEnumerable<>).MakeGenericType(serviceType).ToFriendlyName(), serviceType.ToFriendlyName()) : string.Empty;
internal static string DelegateForTypeThrewAnException(Type serviceType) => string.Format(CultureInfo.InvariantCulture, "The registered delegate for type {0} threw an exception.", serviceType.ToFriendlyName());
internal static string AnOverlappingRegistrationExists(Type openGenericServiceType, Type overlappingImplementationType, bool isExistingRegistrationConditional, Type implementationTypeOfNewRegistration, bool isNewRegistrationConditional) { string solution = "Either remove one of the registrations or make them both conditional."; if (isExistingRegistrationConditional && isNewRegistrationConditional && overlappingImplementationType == implementationTypeOfNewRegistration) { solution = "You can merge both registrations into a single conditional registration and combine " + "both predicates into one single predicate."; } return string.Format(CultureInfo.InvariantCulture, "There is already a {0}registration for {1} (with implementation {2}) that " + "overlaps with the registration for {3} that you are trying to make. This new " + "registration would cause ambiguity, because both registrations would be used for the " + "same closed service types. {4}", isExistingRegistrationConditional ? "conditional " : string.Empty, openGenericServiceType.ToFriendlyName(), overlappingImplementationType.ToFriendlyName(), implementationTypeOfNewRegistration.ToFriendlyName(), solution); }
internal static string ServiceTypeCannotBeAPartiallyClosedType(Type openGenericServiceType, string serviceTypeParamName, string implementationTypeParamName) => string.Format(CultureInfo.InvariantCulture, "The supplied type '{0}' is a partially-closed generic type, which is not supported as " + "value of the {1} parameter. Instead, please supply the open generic type '{2}' and make " + "the type supplied to the {3} parameter partially-closed instead.", openGenericServiceType.ToFriendlyName(), serviceTypeParamName, Helpers.ToCSharpFriendlyName(openGenericServiceType.GetGenericTypeDefinition()), implementationTypeParamName);
internal static string TypeFactoryReturnedIncompatibleType(Type serviceType, Type implementationType) => string.Format(CultureInfo.InvariantCulture, "The registered type factory returned type {0} which does not implement {1}.", implementationType.ToFriendlyName(), serviceType.ToFriendlyName());
internal static string OpenGenericTypeContainsUnresolvableTypeArguments(Type openGenericImplementation) => string.Format(CultureInfo.InvariantCulture, "The supplied type {0} contains unresolvable type arguments. " + "The type would never be resolved and is therefore not suited to be used.", openGenericImplementation.ToFriendlyName());
internal static string TheConstructorOfTypeMustContainASingleInstanceOfTheServiceTypeAsArgument( Type decoratorType, Type serviceType) => string.Format(CultureInfo.InvariantCulture, "For the container to be able to use {0} as a decorator, its constructor must include a " + "single parameter of type {1} (or Func<{1}>) - i.e. the type of the instance that is being " + "decorated. The parameter type {1} is defined multiple times in the constructor of class {0}.", decoratorType.ToFriendlyName(), serviceType.ToFriendlyName());
internal static string ImplementationTypeFactoryReturnedNull(Type serviceType) => string.Format(CultureInfo.InvariantCulture, "The implementation type factory delegate that was registered for service type {0} returned null.", serviceType.ToFriendlyName());
internal static string TheTypeReturnedFromTheFactoryShouldNotBeOpenGeneric( Type serviceType, Type implementationType) => string.Format(CultureInfo.InvariantCulture, "The registered type factory returned open generic type {0} while the registered service " + "type {1} is not generic, making it impossible for a closed generic type to be constructed.", implementationType.ToFriendlyName(), serviceType.ToFriendlyName());
internal static string DecoratorCanNotBeAGenericTypeDefinitionWhenServiceTypeIsNot(Type serviceType, Type decoratorType) => string.Format(CultureInfo.InvariantCulture, "The supplied decorator {0} is an open generic type definition, while the supplied " + "service type {1} is not.", decoratorType.ToFriendlyName(), serviceType.ToFriendlyName());
internal static string ServiceTypeCannotBeAPartiallyClosedType(Type openGenericServiceType) => string.Format(CultureInfo.InvariantCulture, "The supplied type '{0}' is a partially-closed generic type, which is not supported by " + "this method. Please supply the open generic type '{1}' instead.", openGenericServiceType.ToFriendlyName(), Helpers.ToCSharpFriendlyName(openGenericServiceType.GetGenericTypeDefinition()));
internal static string CanNotDecorateContainerUncontrolledCollectionWithThisLifestyle( Type decoratorType, Lifestyle lifestyle, Type serviceType) => string.Format(CultureInfo.InvariantCulture, "You are trying to apply the {0} decorator with the '{1}' lifestyle to a collection of " + "type {2}, but the registered collection is not controlled by the container. Since the " + "number of returned items might change on each call, the decorator with this lifestyle " + "cannot be applied to the collection. Instead, register the decorator with the Transient " + "lifestyle, or use one of the {3} overloads that takes a collection of System.Type types.", decoratorType.ToFriendlyName(), lifestyle.Name, serviceType.ToFriendlyName(), nameof(Container.RegisterCollection));
internal static string RegistrationForClosedServiceTypeOverlapsWithOpenGenericRegistration( Type closedServiceType, Type overlappingGenericImplementationType) => string.Format(CultureInfo.InvariantCulture, "There is already an open generic registration for {0} (with implementation {1}) that " + "overlaps with the registration of {2} that you are trying to make. If your intention is " + "to use {1} as fallback registration, please instead call: " + "{5}(typeof({3}), typeof({4}), c => !c.Handled).", closedServiceType.GetGenericTypeDefinition().ToFriendlyName(), overlappingGenericImplementationType.ToFriendlyName(), closedServiceType.ToFriendlyName(), Helpers.ToCSharpFriendlyName(closedServiceType.GetGenericTypeDefinition()), Helpers.ToCSharpFriendlyName(overlappingGenericImplementationType), nameof(Container.RegisterConditional));
internal static string AppendingRegistrationsToContainerUncontrolledCollectionsIsNotSupported( Type serviceType) => string.Format(CultureInfo.InvariantCulture, "You are trying to append a registration to the registered collection of {0} instances, " + "which is either registered using {1}<TService>(IEnumerable<TService>) or " + "{1}(Type, IEnumerable). Since the number of returned items might change on each call, " + "appending registrations to these collections is not supported. Please register the " + "collection with one of the other {1} overloads if appending is required.", serviceType.ToFriendlyName(), nameof(Container.RegisterCollection));
internal static string MultipleApplicableRegistrationsFound(Type serviceType, Tuple<Type, Type, InstanceProducer>[] overlappingRegistrations) => string.Format(CultureInfo.InvariantCulture, "Multiple applicable registrations found for {0}. The applicable registrations are {1}. " + "If your goal is to make one registration a fallback in case another registration is not " + "applicable, make the fallback registration last using RegisterConditional and make sure " + "the supplied predicate returns false in case the Handled property is true.", serviceType.ToFriendlyName(), overlappingRegistrations.Select(BuildRegistrationName).ToCommaSeparatedText());
internal static string UnregisteredTypeEventArgsRegisterDelegateReturnedUncastableInstance( Type serviceType, InvalidCastException exception) => string.Format(CultureInfo.InvariantCulture, "The delegate that was registered for service type {0} using the {2}.{3}(Func<object>) " + "method returned an object that couldn't be casted to {0}. {1}", serviceType.ToFriendlyName(), exception.Message, nameof(UnregisteredTypeEventArgs), nameof(UnregisteredTypeEventArgs.Register));
private static string NonGenericTypeAlreadyRegistered(Type serviceType, bool existingRegistrationIsConditional) { return string.Format(CultureInfo.InvariantCulture, "Type {0} has already been registered as {1} registration. For non-generic types, " + "conditional and unconditional registrations can't be mixed.", serviceType.ToFriendlyName(), existingRegistrationIsConditional ? "conditional" : "unconditional"); }
internal static string UnregisteredTypeEventArgsRegisterDelegateThrewAnException(Type serviceType, Exception exception) => string.Format(CultureInfo.InvariantCulture, "The delegate that was registered for service type {0} using the {2}.{3}(Func<object>) " + "method threw an exception. {1}", serviceType.ToFriendlyName(), exception.Message, nameof(UnregisteredTypeEventArgs), nameof(UnregisteredTypeEventArgs.Register));
private static string SuppliedTypeIsNotGenericExplainingAlternatives(Type type, string registeringElement) => string.Format(CultureInfo.InvariantCulture, "This method only supports open generic types. " + "If you meant to register all available implementations of {0}, call " + "{2}(typeof({0}), IEnumerable<{1}>) instead.", type.ToFriendlyName(), registeringElement, nameof(Container.RegisterCollection));
internal static string TheServiceIsRequestedOutsideTheContextOfAScopedLifestyle(Type serviceType, ScopedLifestyle lifestyle) => string.Format(CultureInfo.InvariantCulture, "The {0} is registered as '{1}' lifestyle, but the instance is requested outside the " + "context of a {1}.", serviceType.ToFriendlyName(), lifestyle.Name);
internal static string OpenGenericTypesCanNotBeResolved(Type serviceType) => string.Format(CultureInfo.InvariantCulture, "The request for type {0} is invalid because it is an open generic type: it is only " + "possible to instantiate instances of closed generic types. A generic type is closed if " + "all of its type parameters have been substituted with types that are recognized by the " + "compiler.", serviceType.ToFriendlyName());
internal static string DelegateForTypeReturnedNull(Type serviceType) => string.Format(CultureInfo.InvariantCulture, "The registered delegate for type {0} returned null.", serviceType.ToFriendlyName());