示例#1
0
        static InjectableInfo CreateInjectableInfoForParam(
            Type parentType, ParameterInfo paramInfo)
        {
            var injectAttributes = paramInfo.AllAttributes<InjectAttributeBase>().ToList();

            Assert.That(injectAttributes.Count <= 1,
                "Found multiple 'Inject' attributes on type parameter '{0}' of type '{1}'.  Parameter should only have one", paramInfo.Name, parentType.Name());

            var injectAttr = injectAttributes.SingleOrDefault();

            string identifier = null;
            bool isOptional = false;
            InjectSources sourceType = InjectSources.Any;

            if (injectAttr != null)
            {
                identifier = injectAttr.Identifier;
                isOptional = injectAttr.IsOptional;
                sourceType = injectAttr.SourceType;
            }

            bool isOptionalWithADefaultValue = (paramInfo.Attributes & ParameterAttributes.HasDefault) == ParameterAttributes.HasDefault;

            return new InjectableInfo(
                isOptionalWithADefaultValue || isOptional,
                identifier,
                paramInfo.Name,
                paramInfo.ParameterType,
                parentType,
                null,
                isOptionalWithADefaultValue ? paramInfo.DefaultValue : null,
                sourceType);
        }
        public SubContainerCreatorByInstaller(
            DiContainer container, Type installerType)
        {
            _installerType = installerType;
            _container = container;

            Assert.That(installerType.DerivesFrom<InstallerBase>(),
                "Invalid installer type given during bind command.  Expected type '{0}' to derive from 'Installer<>'", installerType.Name());
        }
        public static void BindPriority(
            DiContainer container, Type tickableType, int priorityCount)
        {
            Assert.That(tickableType.DerivesFrom<ITickable>(),
                "Expected type '{0}' to derive from ITickable", tickableType.Name());

            container.Bind<Tuple<Type, int>>().To(
                Tuple.New(tickableType, priorityCount)).WhenInjectedInto<StandardKernel>();
        }
        public static void BindPriority(
            DiContainer container, Type tickableType, int priorityCount)
        {
            Assert.That(tickableType.DerivesFrom<IFixedTickable>(),
                "Expected type '{0}' to derive from IFixedTickable", tickableType.Name());

            container.Bind<ModestTree.Util.Tuple<Type, int>>("Fixed").ToInstance(
                ModestTree.Util.Tuple.New(tickableType, priorityCount)).WhenInjectedInto<TickableManager>();
        }
        public static void BindPriority(
            DiContainer container, Type initializableType, int priorityCount)
        {
            Assert.That(initializableType.DerivesFrom<IInitializable>(),
                "Expected type '{0}' to derive from IInitializable", initializableType.Name());

            container.Bind<Tuple<Type, int>>().To(
                Tuple.New(initializableType, priorityCount)).WhenInjectedInto<InitializableHandler>();
        }
示例#6
0
        public TransientProvider(Type concreteType, DiContainer container)
        {
            _concreteType = concreteType;

            var singletonMark = container.SingletonRegistry.TryGetSingletonType(concreteType);

            if (singletonMark.HasValue)
            {
                throw new ZenjectBindException(
                    "Attempted to use 'ToTransient' with the same type ('{0}') that is already marked with '{1}'".Fmt(concreteType.Name(), singletonMark.Value));
            }
        }
示例#7
0
        public InstanceProvider(Type instanceType, object instance, DiContainer container)
        {
            Assert.That(instance == null || instance.GetType().DerivesFromOrEqual(instanceType));

            _instance = instance;
            _instanceType = instanceType;

            var singletonMark = container.SingletonRegistry.TryGetSingletonType(instanceType);

            if (singletonMark.HasValue)
            {
                throw new ZenjectBindException(
                    "Attempted to use 'ToInstance' with the same type ('{0}') that is already marked with '{1}'".Fmt(instanceType.Name(), singletonMark.Value));
            }
        }
示例#8
0
        static InjectableInfo CreateForMember(MemberInfo memInfo, Type parentType)
        {
            var injectAttributes = memInfo.AllAttributes<InjectAttributeBase>().ToList();

            Assert.That(injectAttributes.Count <= 1,
                "Found multiple 'Inject' attributes on type field '{0}' of type '{1}'.  Field should only container one Inject attribute", memInfo.Name, parentType.Name());

            var injectAttr = injectAttributes.SingleOrDefault();

            string identifier = null;
            bool isOptional = false;
            bool localOnly = false;

            if (injectAttr != null)
            {
                identifier = injectAttr.Identifier;
                isOptional = injectAttr.IsOptional;
                localOnly = injectAttr.LocalOnly;
            }

            Type memberType;
            Action<object, object> setter;

            if (memInfo is FieldInfo)
            {
                var fieldInfo = (FieldInfo)memInfo;
                setter = ((object injectable, object value) => fieldInfo.SetValue(injectable, value));
                memberType = fieldInfo.FieldType;
            }
            else
            {
                Assert.That(memInfo is PropertyInfo);
                var propInfo = (PropertyInfo)memInfo;
                setter = ((object injectable, object value) => propInfo.SetValue(injectable, value, null));
                memberType = propInfo.PropertyType;
            }

            return new InjectableInfo(
                isOptional,
                identifier,
                memInfo.Name,
                memberType,
                parentType,
                setter,
                null,
                localOnly);
        }
        public GameObjectTransientProviderFromPrefab(
            Type concreteType, GameObject template, DiContainer container)
        {
            // Don't do this because it might be an interface
            //Assert.That(typeof(T).DerivesFrom<Component>());

            _concreteType = concreteType;
            _template = template;

            var singletonMark = container.SingletonRegistry.TryGetSingletonType(concreteType);

            if (singletonMark.HasValue)
            {
                throw new ZenjectBindException(
                    "Attempted to use 'ToTransientPrefab' with the same type ('{0}') that is already marked with '{1}'".Fmt(concreteType.Name(), singletonMark.Value));
            }
        }
示例#10
0
        static InjectableInfo CreateForMember(MemberInfo memInfo, Type parentType)
        {
            var injectAttributes = memInfo.AllAttributes<InjectAttribute>().ToList();
            var injectOptionalAttributes = memInfo.AllAttributes<InjectOptionalAttribute>().ToList();

            string identifier = null;

            Assert.That(injectAttributes.IsEmpty() || injectOptionalAttributes.IsEmpty(),
                "Found both 'InjectOptional' and 'Inject' attributes on type field '{0}' of type '{1}'.  Field should only have one or the other.", memInfo.Name, parentType.Name());

            if (injectAttributes.Any())
            {
                identifier = injectAttributes.Single().Identifier;
            }
            else if (injectOptionalAttributes.Any())
            {
                identifier = injectOptionalAttributes.Single().Identifier;
            }

            Type memberType;
            Action<object, object> setter;

            if (memInfo is FieldInfo)
            {
                var fieldInfo = (FieldInfo)memInfo;
                setter = ((object injectable, object value) => fieldInfo.SetValue(injectable, value));
                memberType = fieldInfo.FieldType;
            }
            else
            {
                Assert.That(memInfo is PropertyInfo);
                var propInfo = (PropertyInfo)memInfo;
                setter = ((object injectable, object value) => propInfo.SetValue(injectable, value, null));
                memberType = propInfo.PropertyType;
            }

            return new InjectableInfo(
                injectOptionalAttributes.Any(),
                identifier,
                memInfo.Name,
                memberType,
                parentType,
                setter,
                null);
        }
示例#11
0
文件: RuleUri.cs 项目: Jaans/csla
    /// <summary>
    /// Gets the name of the type. 
    /// Recursive processing of generic constraints and parameters.
    /// </summary>
    /// <param name="type">The type.</param>
    /// <returns></returns>
    private static string GetTypeName(Type type)
    {
#if NETFX_CORE
      if (!type.IsGenericType())
#else
      if (!type.IsGenericType)
#endif
      {
        return type.FullName;
      }
      else // generic type
      {
        var sb = new StringBuilder();
        if (!string.IsNullOrEmpty(type.Namespace)) 
          sb.Append(type.Namespace + ".");
#if NETFX_CORE
        var typeName = type.Name();
#else
        var typeName = type.Name;
#endif
        sb.Append(typeName.Replace("`1", ""));
        foreach (var t in type.GetGenericArguments())
        {
          sb.Append("-");
#if NETFX_CORE
          if (t.IsGenericType())
#else
          if (t.IsGenericType) 
#endif
            sb.Append(GetTypeName(t));
          else 
            sb.Append(t.FullName);
          sb.Append("-");
        }
        return sb.ToString();
      }
    }
示例#12
0
        static InjectableInfo CreateInjectableInfoForParam(
            Type parentType, ParameterInfo paramInfo)
        {
            var injectAttributes = paramInfo.AllAttributes<InjectAttribute>().ToList();
            var injectOptionalAttributes = paramInfo.AllAttributes<InjectOptionalAttribute>().ToList();

            string identifier = null;

            Assert.That(injectAttributes.IsEmpty() || injectOptionalAttributes.IsEmpty(),
                "Found both 'InjectOptional' and 'Inject' attributes on type parameter '{0}' of type '{1}'.  Parameter should only have one or the other.", paramInfo.Name, parentType.Name());

            if (injectAttributes.Any())
            {
                identifier = injectAttributes.Single().Identifier;
            }
            else if (injectOptionalAttributes.Any())
            {
                identifier = injectOptionalAttributes.Single().Identifier;
            }

            bool isOptionalWithADefaultValue = (paramInfo.Attributes & ParameterAttributes.HasDefault) == ParameterAttributes.HasDefault;

            return new InjectableInfo(
                isOptionalWithADefaultValue || injectOptionalAttributes.Any(),
                identifier,
                paramInfo.Name,
                paramInfo.ParameterType,
                parentType,
                null,
                isOptionalWithADefaultValue ? paramInfo.DefaultValue : null);
        }
示例#13
0
        public static IEnumerable<ZenjectResolveException> ValidateObjectGraph(
            DiContainer container, Type concreteType, InjectContext currentContext, params Type[] extras)
        {
            var typeInfo = TypeAnalyzer.GetInfo(concreteType);
            var extrasList = extras.ToList();

            foreach (var dependInfo in typeInfo.AllInjectables)
            {
                Assert.IsEqual(dependInfo.ObjectType, concreteType);

                if (TryTakingFromExtras(dependInfo.MemberType, extrasList))
                {
                    continue;
                }

                var context = dependInfo.CreateInjectContext(container, currentContext, null);

                foreach (var error in ValidateContract(container, context))
                {
                    yield return error;
                }
            }

            if (!extrasList.IsEmpty())
            {
                yield return new ZenjectResolveException(
                    "Found unnecessary extra parameters passed when injecting into '{0}' with types '{1}'.  \nObject graph:\n{2}"
                    .Fmt(concreteType.Name(), String.Join(",", extrasList.Select(x => x.Name()).ToArray()), currentContext.GetObjectGraphString()));
            }
        }
示例#14
0
        public static IEnumerable<ZenjectResolveException> ValidateContract(
            DiContainer container, Type contractType, InjectContext context, bool isOptional)
        {
            var matches = container.GetProviderMatches(contractType, context);

            if (matches.IsLength(1))
            {
                foreach (var error in matches.Single().ValidateBinding(contractType, context))
                {
                    yield return error;
                }
            }
            else
            {
                if (ReflectionUtil.IsGenericList(contractType))
                {
                    var subType = contractType.GetGenericArguments().Single();

                    matches = container.GetProviderMatches(subType, context);

                    if (matches.IsEmpty())
                    {
                        if (!isOptional)
                        {
                            if (container.FallbackProvider != null)
                            {
                                foreach (var error in container.FallbackProvider.ValidateBinding(contractType, context))
                                {
                                    yield return error;
                                }
                            }
                            else
                            {
                                yield return new ZenjectResolveException(
                                    "Could not find dependency with type 'List<{0}>'{1}.  If the empty list is also valid, you can allow this by using the [InjectOptional] attribute.' \nObject graph:\n{2}"
                                    .With(
                                        subType.Name(),
                                        (context.EnclosingType == null ? "" : " when injecting into '{0}'".With(context.EnclosingType.Name())),
                                        DiContainer.GetCurrentObjectGraph()));
                            }
                        }
                    }
                    else
                    {
                        foreach (var match in matches)
                        {
                            foreach (var error in match.ValidateBinding(contractType, context))
                            {
                                yield return error;
                            }
                        }
                    }
                }
                else
                {
                    if (!isOptional)
                    {
                        if (matches.IsEmpty())
                        {
                            if (container.FallbackProvider != null)
                            {
                                foreach (var error in container.FallbackProvider.ValidateBinding(contractType, context))
                                {
                                    yield return error;
                                }
                            }
                            else
                            {
                                yield return new ZenjectResolveException(
                                    "Could not find required dependency with type '{0}'{1} \nObject graph:\n{2}"
                                    .With(
                                        contractType.Name(),
                                        (context.EnclosingType == null ? "" : " when injecting into '{0}'".With(context.EnclosingType.Name())),
                                        DiContainer.GetCurrentObjectGraph()));
                            }
                        }
                        else
                        {
                            yield return new ZenjectResolveException(
                                "Found multiple matches when only one was expected for dependency with type '{0}'{1} \nObject graph:\n{2}"
                                .With(
                                    contractType.Name(),
                                    (context.EnclosingType == null ? "" : " when injecting into '{0}'".With(context.EnclosingType.Name())),
                                    DiContainer.GetCurrentObjectGraph()));
                        }
                    }
                }
            }
        }
        public IEnumerable<ZenjectResolveException> ValidateBinding(
            Type componentType, InjectContext context)
        {
            if (!ContainsComponent(componentType))
            {
                yield return new ZenjectResolveException(
                    "Could not find component of type '{0}' in prefab with resource path '{1}' \nObject graph:\n{2}"
                    .Fmt(componentType.Name(), _id.ResourcePath, context.GetObjectGraphString()));
                yield break;
            }

            // In most cases componentType will be a MonoBehaviour but we also want to allow interfaces
            // And in that case we can't validate it
            if (!componentType.IsAbstract)
            {
                // Note that we always want to cache _container instead of using context.Container
                // since for singletons, the container they are accessed from should not determine
                // the container they are instantiated with
                // Transients can do that but not singletons
                foreach (var err in _container.ValidateObjectGraph(componentType, context))
                {
                    yield return err;
                }
            }
        }
 private static string GetDisplayName(object instance, string name, Type type)
 {
     string text = instance == null ? null : PlatformExtensions.TryGetValue(instance, "Text");
     return $"{name} ({type.Name}{(string.IsNullOrEmpty(text) ? "" : ", " + text)})";
 }
        static string GetFormattedTypeName(Type type)
        {
            var str = type.Name();

            // GraphViz does not read names with <, >, or . characters so replace them
            str = str.Replace(">", "_");
            str = str.Replace("<", "_");
            str = str.Replace(".", "_");

            return str;
        }