private DummyClass Create()
        {
            var res = new DummyClass();

            DummyClasses.Add(res);
            return(res);
        }
示例#2
0
        public void SetupContainerForLookup(IContainer scope)
        {
            var allTypes = DummyClasses.GetTypes(ExtraRegistrations)
                           .Select(t => new RegistrationDefinition {
                ExportType = t, ActivationType = t
            }).ToList();

            var definitions = SmallObjectServices.Definitions().ToArray();

            var gap = allTypes.Count / definitions.Length;

            var index = gap / 2;

            foreach (var definition in definitions)
            {
                allTypes.Insert(index, definition);

                index += gap + 1;
            }

            scope.Registration(allTypes);

            scope.BuildContainer();

            foreach (var type in allTypes.Select(r => r.ExportType))
            {
                scope.Resolve(type);
            }
        }
        /// <summary>
        /// Registers definitions and dummy classes for scope
        /// </summary>
        /// <param name="container"></param>
        /// <param name="definitions"></param>
        /// <param name="resolveStatements"></param>
        protected virtual void SetupContainerForTest(IContainer container, IEnumerable <RegistrationDefinition> definitions, params Action <IResolveScope>[] resolveStatements)
        {
            var dummyTypes = DummyClasses.GetTypes(ExtraRegistrationsCount).ToArray();

            container.Registration(dummyTypes.Select(t => new RegistrationDefinition {
                ExportType = t, ActivationType = t
            }));

            var definitionArray = definitions.ToArray();

            container.Registration(definitionArray);

            container.BuildContainer();

            var resolveTypes = new List <Type>(dummyTypes.Take(ExtraRegistrationsResolveCount));

            if (resolveStatements != null && resolveStatements.Length > 0)
            {
                var gap = resolveTypes.Count / resolveStatements.Length;

                var index = gap / 2;

                for (var i = 0; i < resolveTypes.Count; i++)
                {
                    if (index < resolveStatements.Length && i == index * gap)
                    {
                        resolveStatements[index](container);
                        index++;
                    }

                    container.Resolve(resolveTypes[i]);
                }
            }
            else
            {
                var gap = resolveTypes.Count / definitionArray.Length;

                var index = gap / 2;

                foreach (var definition in definitionArray)
                {
                    resolveTypes.Insert(index, definition.ExportType);

                    index += gap + 1;
                }

                foreach (var resolveType in resolveTypes)
                {
                    container.Resolve(resolveType);
                }
            }
        }
示例#4
0
 public void Setup()
 {
     _types = DummyClasses.GetTypes(Registrations).ToArray();
 }