Пример #1
0
        public static EntityKindAttribute GetAttribute(Type type)
        {
            var attr = TryGetAttribute(type);

            if (attr == null)
                throw new InvalidOperationException("{0} does not define an EntityKindAttribute".Formato(type.TypeName()));

            return attr;
        }
Пример #2
0
 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.TypeName(),
         ContainerHasNoRegistrationsAddition(containerHasRegistrations),
         DidYouMeanToCallGetInstanceInstead(containerHasRelatedOneToOneMapping, serviceType),
         DidYouMeanToCallGetAllInstancesInstead(containerHasRelatedCollectionMapping, serviceType),
         NoteThatSkippedDecoratorsWereFound(serviceType, skippedDecorators));
Пример #3
0
        public ExtensionToken(QueryToken parent, string key, Type type, bool isProjection,
            string unit, string format, 
            Implementations? implementations,
            string isAllowed, PropertyRoute propertyRoute)
            : base(parent)
        {
            var shouldHaveImplementations = typeof(IEntity).IsAssignableFrom((isProjection ? type.ElementType() : type).CleanType());

            if (shouldHaveImplementations && implementations == null)
                throw new ArgumentException("Extension token '{0}' (of type {1}) registered on type {2} has no implementations".FormatWith(key, type.TypeName(), parent.Type.CleanType().TypeName()));

            this.key= key;
            this.type = type;
            this.isProjection = isProjection;
            this.unit = unit;
            this.format = format;
            this.implementations = implementations;
            this.isAllowed = isAllowed;
            this.propertyRoute = propertyRoute;
        }
Пример #4
0
 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).TypeName(),
             serviceType.TypeName())
         : string.Empty;
Пример #5
0
 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.TypeName());
Пример #6
0
 public void PrintType(string prefix, Type ty) {
   Contract.Requires(prefix != null);
   Contract.Requires(ty != null);
   string s = ty.TypeName(null, true);
   if (s != "?" && !s.StartsWith("_")) {
     wr.Write("{0}{1}", prefix, s);
   }
 }
Пример #7
0
 internal static string DelegateForTypeReturnedNull(Type serviceType) =>
     string.Format(CultureInfo.InvariantCulture,
         "The registered delegate for type {0} returned null.", serviceType.TypeName());
Пример #8
0
 public static Exception ArgumentNullException(Type argumentType, string argumentName)
 {
     return new ArgumentNullException(argumentName, $"The argument '{argumentName}' of type '{argumentType.TypeName()}' is null. Are you missing an [AutoInit] attribute?");
 }
Пример #9
0
        public readonly Expression CustomToStr; //Not readonly

        public LiteReferenceExpression(Type type, Expression reference, Expression customToStr) :
            base(DbExpressionType.LiteReference, type)
        {
            Type cleanType = Lite.Extract(type);

            if (cleanType != reference.Type)
                throw new ArgumentException("The type {0} is not the Lite version of {1}".Formato(type.TypeName(), reference.Type.TypeName()));

            this.Reference = reference;

            this.CustomToStr = customToStr;
        }
Пример #10
0
        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 {3}registration for {4} that you are trying to make. This new " +
                "registration would cause ambiguity, because both registrations would be used for the " +
                "same closed service types. {5}",
                isExistingRegistrationConditional ? "conditional " : string.Empty,
                openGenericServiceType.TypeName(),
                overlappingImplementationType.TypeName(),
                isNewRegistrationConditional ? "conditional " : string.Empty,
                implementationTypeOfNewRegistration.TypeName(),
                solution);
        }
Пример #11
0
 public void PrintType(string prefix, Type ty)
 {
     Contract.Requires(prefix != null);
       Contract.Requires(ty != null);
       if (DafnyOptions.O.DafnyPrintResolvedFile != null) {
     ty = ty.Normalize();
       }
       string s = ty.TypeName(null, true);
       if (!(ty is TypeProxy) && !s.StartsWith("_")) {
     wr.Write("{0}{1}", prefix, s);
       }
 }
Пример #12
0
 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().TypeName(),
         overlappingGenericImplementationType.TypeName(),
         closedServiceType.TypeName(),
         CSharpFriendlyName(closedServiceType.GetGenericTypeDefinition()),
         CSharpFriendlyName(overlappingGenericImplementationType),
         nameof(Container.RegisterConditional));
Пример #13
0
 internal static string ErrorWhileBuildingDelegateFromExpression(Type serviceType,
     Expression expression, Exception exception) =>
     string.Format(CultureInfo.InvariantCulture,
         "Error occurred while trying to build a delegate for type {0} using the expression \"{1}\". " +
         "{2}", serviceType.TypeName(), expression, exception.Message);
Пример #14
0
 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.TypeName(),
         serviceTypeParamName,
         CSharpFriendlyName(openGenericServiceType.GetGenericTypeDefinition()),
         implementationTypeParamName);
Пример #15
0
 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.TypeName(),
         CSharpFriendlyName(openGenericServiceType.GetGenericTypeDefinition()));
Пример #16
0
 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.TypeName(), serviceType.TypeName());
        static Type GetEntityType(string typeStr, Type objectType)
        {
            var type = ReflectionServer.TypesByName.Value.GetOrThrow(typeStr);

            if (type.IsEnum)
                type = EnumEntity.Generate(type);

            if (!objectType.IsAssignableFrom(type))
                throw new JsonSerializationException($"Type '{type.Name}' is not assignable to '{objectType.TypeName()}'");

            return type;

        }
Пример #18
0
 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.TypeName(),
         overlappingRegistrations.Select(BuildRegistrationName).ToCommaSeparatedText());
        public static FixTokenResult FixValue(Replacements replacements, Type type, ref string valueString, bool allowRemoveToken, bool isList)
        {
            object val;
            string error = FilterValueConverter.TryParse(valueString, type, out val, isList);

            if (error == null)
                return FixTokenResult.Nothing;

            if (isList && valueString.Contains('|'))
            {
                List<string> changes = new List<string>();
                foreach (var str in valueString.Split('|'))
                {
                    string s = str;
                    var result = FixValue(replacements, type, ref s, allowRemoveToken, false);

                    if (result == FixTokenResult.DeleteEntity || result == FixTokenResult.SkipEntity || result == FixTokenResult.RemoveToken)
                        return result;

                    changes.Add(s);
                }

                valueString = changes.ToString("|");
                return FixTokenResult.Fix;
            }

            if (type.IsLite())
            {
                var m = Lite.ParseRegex.Match(valueString);
                if (m.Success)
                {
                    var typeString = m.Groups["type"].Value;

                    if (!TypeLogic.NameToType.ContainsKey(typeString))
                    {
                        string newTypeString = AskTypeReplacement(replacements, typeString);

                        if (newTypeString.HasText())
                        {
                            valueString = valueString.Replace(typeString, newTypeString);
                            return FixTokenResult.Fix;
                        }
                    }
                }
            }

            if (Replacements.AutoReplacement != null)
            {
                Replacements.Selection? sel = Replacements.AutoReplacement(valueString, null);

                if (sel != null && sel.Value.NewValue != null)
                {
                    valueString = sel.Value.NewValue;
                    return FixTokenResult.Fix;
                }
            }

            SafeConsole.WriteLineColor(ConsoleColor.White, "Value '{0}' not convertible to {1}.".FormatWith(valueString, type.TypeName()));
            SafeConsole.WriteLineColor(ConsoleColor.Yellow, "- s: Skip entity");
            if (allowRemoveToken)
                SafeConsole.WriteLineColor(ConsoleColor.DarkRed, "- r: Remove token");
            SafeConsole.WriteLineColor(ConsoleColor.Red, "- d: Delete entity");
            SafeConsole.WriteLineColor(ConsoleColor.Green, "- freeText: New value");

            string answer = Console.ReadLine();

            if (answer == null)
                throw new InvalidOperationException("Impossible to synchronize interactively without Console");

            string a = answer.ToLower();

            if (a == "s")
                return FixTokenResult.SkipEntity;

            if (allowRemoveToken && a == "r")
                return FixTokenResult.RemoveToken;

            if (a == "d")
                return FixTokenResult.DeleteEntity;

            valueString = answer;
            return FixTokenResult.Fix;

        }
Пример #20
0
 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.TypeName(),
         existingRegistrationIsConditional ? "conditional" : "unconditional");
 }
Пример #21
0
 public static EntityKindAttribute TryGetAttribute(Type type)
 {
     return dictionary.GetOrAdd(type, t =>
     {
         if (!t.IsIEntity())
             throw new InvalidOperationException("{0} should be a non-abstrat Entity".FormatWith(type.TypeName()));
         
         return t.GetCustomAttribute<EntityKindAttribute>(true);
     });
 }
Пример #22
0
 internal static string DelegateForTypeThrewAnException(Type serviceType) =>
     string.Format(CultureInfo.InvariantCulture,
         "The registered delegate for type {0} threw an exception.", serviceType.TypeName());
Пример #23
0
 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.TypeName());
Пример #24
0
        protected virtual string WriteQuery(Type type)
        {
            if (ShouldWriteSimpleQuery(type))
                return null;

            string typeName = type.TypeName();

            var v = GetVariableName(type);

            StringBuilder sb = new StringBuilder();
            sb.AppendLine("dqm.RegisterQuery(typeof({0}), () =>".FormatWith(typeName));
            sb.AppendLine("    from {0} in Database.Query<{1}>()".FormatWith(v, typeName));
            sb.AppendLine("    select " + WriteQueryConstructor(type, v) + ");");
            return sb.ToString();
        }
Пример #25
0
    // ----------------------------- PrintType -----------------------------

    public void PrintType(Type ty) {
      Contract.Requires(ty != null);
      wr.Write(ty.TypeName(null, true));
    }
Пример #26
0
 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.TypeName(),
         lifestyle.Name);
Пример #27
0
        protected virtual string WriteInclude(Type type)
        {
            var ops = GetOperationsSymbols(type);
            var save = ops.SingleOrDefaultEx(o => GetOperationType(o) == OperationType.Execute && IsSave(o));
            var delete = ops.SingleOrDefaultEx(o => GetOperationType(o) == OperationType.Delete);
            var p = ShouldWriteSimpleQuery(type) ?  GetVariableName(type)  : null;

            return new[]
            {
                "sb.Include<" + type.TypeName() + ">()",
                save != null && ShouldWriteSimpleOperations(save) ? ("   .WithSave(" + save.Symbol.ToString() + ")") : null,
                delete != null && ShouldWriteSimpleOperations(delete) ? ("   .WithDelete(" + delete.Symbol.ToString() + ")") : null,
                p == null ? null : $"   .WithQuery(dqm, {p} => {WriteQueryConstructor(type, p)})"
            }.NotNull().ToString("\r\n") + ";";
        }
Пример #28
0
 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.TypeName(),
         serviceType.TypeName());
Пример #29
0
 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.TypeName(),
         registeringElement,
         nameof(Container.RegisterCollection));
Пример #30
0
 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.TypeName(),
         exception.Message,
         nameof(UnregisteredTypeEventArgs),
         nameof(UnregisteredTypeEventArgs.Register));