public void ConnectWithNonmatchingExport()
        {
            var plugins    = CreatePluginTypes();
            var repository = new Mock <IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                .Returns(plugins);
            }

            var importEngine = new Mock <IConnectParts>();
            Func <Type, TypeIdentity>   identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func <IBuildFixedSchedules> scheduleBuilder   = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo  = builder.RegisterObject(typeof(ImportOnProperty));
            var secondInfo = builder.RegisterObject(typeof(ActionOnMethod));

            Assert.Throws <CannotMapExportToImportException>(
                () => builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First()));
        }
        public void RegisterObject()
        {
            var plugins    = CreatePluginTypes();
            var repository = new Mock <IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                .Returns(plugins);
            }

            var importEngine = new Mock <IConnectParts>();
            Func <Type, TypeIdentity>   identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func <IBuildFixedSchedules> scheduleBuilder   = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var info = builder.RegisterObject(typeof(ActionOnMethod));

            Assert.IsFalse(info.RegisteredConditions.Any());
            Assert.IsFalse(info.RegisteredImports.Any());

            Assert.AreEqual(1, info.RegisteredExports.Count());
            Assert.AreEqual("ActionExport", info.RegisteredExports.First().ContractName);

            Assert.AreEqual(1, info.RegisteredActions.Count());
        }
        public void DefineImportWithObjectImports()
        {
            var             plugins    = CreatePluginTypes();
            GroupDefinition groupInfo  = null;
            var             repository = new Mock <IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                .Returns(plugins);
                repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>()))
                .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g);
            }

            var importEngine = new Mock <IConnectParts>();
            {
                importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
                .Returns(true);
            }

            Func <Type, TypeIdentity>   identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func <IBuildFixedSchedules> scheduleBuilder   = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo = builder.RegisterObject(typeof(ImportOnProperty));

            var groupImportName = "groupImport";

            builder.DefineImport(groupImportName, new List <ImportRegistrationId> {
                firstInfo.RegisteredImports.First()
            });

            var groupName = "MyGroup";

            builder.Register(groupName);

            Assert.IsNotNull(groupInfo);
            Assert.AreEqual(new GroupRegistrationId(groupName), groupInfo.GroupImports.First().ContainingGroup);
            Assert.IsNull(groupInfo.GroupImports.First().ScheduleInsertPosition);

            Assert.That(
                groupInfo.GroupImports.First().ImportsToMatch,
                Is.EquivalentTo(
                    new List <ImportRegistrationId>
            {
                firstInfo.RegisteredImports.First(),
            }));
        }
        public void RegisterObjectWithUnknownType()
        {
            var repository   = new Mock <IPluginRepository>();
            var importEngine = new Mock <IConnectParts>();
            Func <Type, TypeIdentity>   identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func <IBuildFixedSchedules> scheduleBuilder   = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));

            Assert.Throws <UnknownPluginTypeException>(() => builder.RegisterObject(typeof(ExportOnPropertyWithName)));
        }
        public void DefineSchedule()
        {
            var             plugins    = CreatePluginTypes();
            GroupDefinition groupInfo  = null;
            var             repository = new Mock <IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                .Returns(plugins);
                repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>()))
                .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g);
            }

            var importEngine = new Mock <IConnectParts>();
            {
                importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
                .Returns(true);
            }

            Func <Type, TypeIdentity>   identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func <IBuildFixedSchedules> scheduleBuilder   = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var actionInfo    = builder.RegisterObject(typeof(ActionOnMethod));
            var conditionInfo = builder.RegisterObject(typeof(ConditionOnProperty));

            var registrator = builder.RegisterSchedule();
            {
                var vertex = registrator.AddExecutingAction(actionInfo.RegisteredActions.First());
                registrator.LinkFromStart(vertex, conditionInfo.RegisteredConditions.First());
                registrator.LinkToEnd(vertex);
                registrator.Register();
            }

            var groupName = "MyGroup";

            builder.Register(groupName);

            Assert.AreEqual(actionInfo.RegisteredActions.First(), groupInfo.Schedule.Actions.First().Value);
            Assert.AreEqual(conditionInfo.RegisteredConditions.First(), groupInfo.Schedule.Conditions.First().Value);
            Assert.AreEqual(3, groupInfo.Schedule.Schedule.Vertices.Count());
        }
        public void ConnectOverridingCurrentConnection()
        {
            var             plugins    = CreatePluginTypes();
            GroupDefinition groupInfo  = null;
            var             repository = new Mock <IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                .Returns(plugins);
                repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>()))
                .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g);
            }

            var importEngine = new Mock <IConnectParts>();
            {
                importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
                .Returns(true);
            }

            Func <Type, TypeIdentity>   identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func <IBuildFixedSchedules> scheduleBuilder   = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo  = builder.RegisterObject(typeof(ImportOnProperty));
            var secondInfo = builder.RegisterObject(typeof(ExportOnProperty));

            builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First());

            var thirdInfo = builder.RegisterObject(typeof(ExportOnProperty));

            builder.Connect(firstInfo.RegisteredImports.First(), thirdInfo.RegisteredExports.First());

            var groupName = "MyGroup";

            builder.Register(groupName);

            Assert.IsNotNull(groupInfo);
            Assert.AreEqual(firstInfo.RegisteredImports.First(), groupInfo.InternalConnections.First().Import);
            Assert.AreEqual(1, groupInfo.InternalConnections.First().Exports.Count());
            Assert.AreEqual(thirdInfo.RegisteredExports.First(), groupInfo.InternalConnections.First().Exports.First());
        }
        public void Connect()
        {
            var plugins = CreatePluginTypes();
            GroupDefinition groupInfo = null;
            var repository = new Mock<IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                    .Returns(plugins);
                repository.Setup(r => r.AddGroup(It.IsAny<GroupDefinition>(), It.IsAny<PluginFileInfo>()))
                    .Callback<GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g);
            }

            var importEngine = new Mock<IConnectParts>();
            {
                importEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
                    .Returns(true);
            }

            Func<Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func<IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo = builder.RegisterObject(typeof(ImportOnProperty));
            var secondInfo = builder.RegisterObject(typeof(ExportOnProperty));
            builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First());

            var groupName = "MyGroup";
            builder.Register(groupName);

            Assert.IsNotNull(groupInfo);
            Assert.AreEqual(firstInfo.RegisteredImports.First(), groupInfo.InternalConnections.First().Import);
            Assert.AreEqual(1, groupInfo.InternalConnections.First().Exports.Count());
            Assert.AreEqual(secondInfo.RegisteredExports.First(), groupInfo.InternalConnections.First().Exports.First());
        }
        public void RegisterObjectWithMultipleSameType()
        {
            var plugins    = CreatePluginTypes();
            var repository = new Mock <IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                .Returns(plugins);
            }

            var importEngine = new Mock <IConnectParts>();
            Func <Type, TypeIdentity>   identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func <IBuildFixedSchedules> scheduleBuilder   = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo  = builder.RegisterObject(typeof(ActionOnMethod));
            var secondInfo = builder.RegisterObject(typeof(ActionOnMethod));

            Assert.AreNotEqual(firstInfo.Id, secondInfo.Id);
        }
        public void RegisterObjectWithMultipleSameType()
        {
            var plugins = CreatePluginTypes();
            var repository = new Mock<IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                    .Returns(plugins);
            }

            var importEngine = new Mock<IConnectParts>();
            Func<Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func<IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo = builder.RegisterObject(typeof(ActionOnMethod));
            var secondInfo = builder.RegisterObject(typeof(ActionOnMethod));

            Assert.AreNotEqual(firstInfo.Id, secondInfo.Id);
        }
        public void RegisterObject()
        {
            var plugins = CreatePluginTypes();
            var repository = new Mock<IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                    .Returns(plugins);
            }

            var importEngine = new Mock<IConnectParts>();
            Func<Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func<IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var info = builder.RegisterObject(typeof(ActionOnMethod));

            Assert.IsFalse(info.RegisteredConditions.Any());
            Assert.IsFalse(info.RegisteredImports.Any());

            Assert.AreEqual(1, info.RegisteredExports.Count());
            Assert.AreEqual("ActionExport", info.RegisteredExports.First().ContractName);

            Assert.AreEqual(1, info.RegisteredActions.Count());
        }
        public void DefineSchedule()
        {
            var plugins = CreatePluginTypes();
            GroupDefinition groupInfo = null;
            var repository = new Mock<IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                    .Returns(plugins);
                repository.Setup(r => r.AddGroup(It.IsAny<GroupDefinition>(), It.IsAny<PluginFileInfo>()))
                    .Callback<GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g);
            }

            var importEngine = new Mock<IConnectParts>();
            {
                importEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
                    .Returns(true);
            }

            Func<Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func<IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var actionInfo = builder.RegisterObject(typeof(ActionOnMethod));
            var conditionInfo = builder.RegisterObject(typeof(ConditionOnProperty));

            var registrator = builder.RegisterSchedule();
            {
                var vertex = registrator.AddExecutingAction(actionInfo.RegisteredActions.First());
                registrator.LinkFromStart(vertex, conditionInfo.RegisteredConditions.First());
                registrator.LinkToEnd(vertex);
                registrator.Register();
            }

            var groupName = "MyGroup";
            builder.Register(groupName);

            Assert.AreEqual(actionInfo.RegisteredActions.First(), groupInfo.Schedule.Actions.First().Value);
            Assert.AreEqual(conditionInfo.RegisteredConditions.First(), groupInfo.Schedule.Conditions.First().Value);
            Assert.AreEqual(3, groupInfo.Schedule.Schedule.Vertices.Count());
        }
        public void DefineImportWithScheduleElement()
        {
            var plugins = CreatePluginTypes();
            GroupDefinition groupInfo = null;
            var repository = new Mock<IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                    .Returns(plugins);
                repository.Setup(r => r.AddGroup(It.IsAny<GroupDefinition>(), It.IsAny<PluginFileInfo>()))
                    .Callback<GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g);
            }

            var importEngine = new Mock<IConnectParts>();
            {
                importEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
                    .Returns(true);
            }

            Func<Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func<IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            builder.RegisterObject(typeof(ImportOnProperty));

            var registrator = builder.RegisterSchedule();
            var vertex = registrator.AddInsertPoint();
            registrator.LinkFromStart(vertex);
            registrator.LinkToEnd(vertex);
            registrator.Register();

            var groupImportName = "groupImport";
            builder.DefineImport(groupImportName, vertex);

            var groupName = "MyGroup";
            builder.Register(groupName);

            Assert.IsNotNull(groupInfo);
            Assert.AreEqual(new GroupRegistrationId(groupName), groupInfo.GroupImports.First().ContainingGroup);
            Assert.AreEqual(vertex, groupInfo.GroupImports.First().ScheduleInsertPosition);

            Assert.IsFalse(groupInfo.GroupImports.First().ImportsToMatch.Any());
        }
        public void DefineExport()
        {
            var plugins = CreatePluginTypes();
            GroupDefinition groupInfo = null;
            var repository = new Mock<IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                    .Returns(plugins);
                repository.Setup(r => r.AddGroup(It.IsAny<GroupDefinition>(), It.IsAny<PluginFileInfo>()))
                    .Callback<GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g);
            }

            var importEngine = new Mock<IConnectParts>();
            {
                importEngine.Setup(i => i.Accepts(It.IsAny<SerializableImportDefinition>(), It.IsAny<SerializableExportDefinition>()))
                    .Returns(true);
            }

            Func<Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func<IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo = builder.RegisterObject(typeof(ImportOnProperty));
            var secondInfo = builder.RegisterObject(typeof(ExportOnProperty));
            var thirdInfo = builder.RegisterObject(typeof(ActionOnMethod));
            var fourthInfo = builder.RegisterObject(typeof(ConditionOnProperty));
            builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First());

            var registrator = builder.RegisterSchedule();
            {
                var vertex = registrator.AddExecutingAction(thirdInfo.RegisteredActions.First());
                registrator.LinkFromStart(vertex, fourthInfo.RegisteredConditions.First());
                registrator.LinkToEnd(vertex);
                registrator.Register();
            }

            var groupExportName = "groupExport";
            builder.DefineExport(groupExportName);

            var groupName = "MyGroup";
            builder.Register(groupName);

            Assert.IsNotNull(groupInfo);
            Assert.AreEqual(new GroupRegistrationId(groupName), groupInfo.GroupExport.ContainingGroup);
            Assert.AreEqual(groupExportName, groupInfo.GroupExport.ContractName);

            Assert.That(
                groupInfo.GroupExport.ProvidedExports,
                Is.EquivalentTo(
                    new List<ExportRegistrationId>
                    {
                        firstInfo.RegisteredExports.First(),
                        thirdInfo.RegisteredExports.First(),
                        fourthInfo.RegisteredExports.First(),
                    }));
        }
        public void DefineExport()
        {
            var             plugins    = CreatePluginTypes();
            GroupDefinition groupInfo  = null;
            var             repository = new Mock <IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                .Returns(plugins);
                repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>()))
                .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g);
            }

            var importEngine = new Mock <IConnectParts>();
            {
                importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>()))
                .Returns(true);
            }

            Func <Type, TypeIdentity>   identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func <IBuildFixedSchedules> scheduleBuilder   = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo  = builder.RegisterObject(typeof(ImportOnProperty));
            var secondInfo = builder.RegisterObject(typeof(ExportOnProperty));
            var thirdInfo  = builder.RegisterObject(typeof(ActionOnMethod));
            var fourthInfo = builder.RegisterObject(typeof(ConditionOnProperty));

            builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First());

            var registrator = builder.RegisterSchedule();
            {
                var vertex = registrator.AddExecutingAction(thirdInfo.RegisteredActions.First());
                registrator.LinkFromStart(vertex, fourthInfo.RegisteredConditions.First());
                registrator.LinkToEnd(vertex);
                registrator.Register();
            }

            var groupExportName = "groupExport";

            builder.DefineExport(groupExportName);

            var groupName = "MyGroup";

            builder.Register(groupName);

            Assert.IsNotNull(groupInfo);
            Assert.AreEqual(new GroupRegistrationId(groupName), groupInfo.GroupExport.ContainingGroup);
            Assert.AreEqual(groupExportName, groupInfo.GroupExport.ContractName);

            Assert.That(
                groupInfo.GroupExport.ProvidedExports,
                Is.EquivalentTo(
                    new List <ExportRegistrationId>
            {
                firstInfo.RegisteredExports.First(),
                thirdInfo.RegisteredExports.First(),
                fourthInfo.RegisteredExports.First(),
            }));
        }
        public void RegisterObjectWithUnknownType()
        {
            var repository = new Mock<IPluginRepository>();
            var importEngine = new Mock<IConnectParts>();
            Func<Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func<IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            Assert.Throws<UnknownPluginTypeException>(() => builder.RegisterObject(typeof(ExportOnPropertyWithName)));
        }
        public void ConnectWithNonmatchingExport()
        {
            var plugins = CreatePluginTypes();
            var repository = new Mock<IPluginRepository>();
            {
                repository.Setup(r => r.Parts())
                    .Returns(plugins);
            }

            var importEngine = new Mock<IConnectParts>();
            Func<Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t);
            Func<IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder();

            var builder = new GroupDefinitionBuilder(
                repository.Object,
                importEngine.Object,
                identityGenerator,
                scheduleBuilder,
                new PluginFileInfo("a", DateTimeOffset.Now));
            var firstInfo = builder.RegisterObject(typeof(ImportOnProperty));
            var secondInfo = builder.RegisterObject(typeof(ActionOnMethod));
            Assert.Throws<CannotMapExportToImportException>(
                () => builder.Connect(firstInfo.RegisteredImports.First(), secondInfo.RegisteredExports.First()));
        }
        private void ScanAssembly(Assembly assembly)
        {
            try
            {
                m_Logger.Log(
                    LevelToLog.Trace,
                    string.Format(
                        CultureInfo.InvariantCulture,
                        Resources.RemoteAssemblyScanner_LogMessage_ScanningAssembly_WithName,
                        assembly.FullName));

                var file = new FileInfo(assembly.LocalFilePath());
                var fileInfo = new PluginFileInfo(file.FullName, file.LastWriteTimeUtc);

                var createTypeIdentity = TypeIdentityBuilder.IdentityFactory(m_Repository, new Dictionary<Type, TypeIdentity>());
                var mefParts = ExtractImportsAndExports(assembly, createTypeIdentity);
                var parts = mefParts.Select(p => ExtractActionsAndConditions(p.Item1, p.Item2, createTypeIdentity));
                foreach (var part in parts)
                {
                    m_Logger.Log(
                        LevelToLog.Trace,
                        string.Format(
                            CultureInfo.InvariantCulture,
                            Resources.RemoteAssemblyScanner_LogMessage_AddingPartToRepository_WithPartInformation,
                            part.Identity));

                    m_Repository.AddPart(part, fileInfo);
                }

                var groupExporters = assembly.GetTypes().Where(t => typeof(IExportGroupDefinitions).IsAssignableFrom(t));
                foreach (var t in groupExporters)
                {
                    try
                    {
                        m_Logger.Log(
                            LevelToLog.Trace,
                            string.Format(
                                CultureInfo.InvariantCulture,
                                Resources.RemoteAssemblyScanner_LogMessage_RegisteringGroupsViaExporter_WithExporterType,
                                t.AssemblyQualifiedName));

                        var builder = new GroupDefinitionBuilder(
                            m_Repository,
                            m_ImportEngine,
                            createTypeIdentity,
                            m_ScheduleBuilder,
                            fileInfo);

                        var exporter = Activator.CreateInstance(t) as IExportGroupDefinitions;
                        exporter.RegisterGroups(builder);
                    }
                    catch (Exception e)
                    {
                        m_Logger.Log(LevelToLog.Warn, e.ToString());
                    }
                }
            }
            catch (Exception e)
            {
                m_Logger.Log(
                    LevelToLog.Error,
                    string.Format(
                        CultureInfo.InvariantCulture,
                        Resources.Plugins_LogMessage_Scanner_TypeScanFailed_WithAssemblyAndException,
                        assembly.GetName().FullName,
                        e));
            }
        }
        private void ScanAssembly(Assembly assembly)
        {
            try
            {
                m_Logger.Log(
                    LevelToLog.Trace,
                    string.Format(
                        CultureInfo.InvariantCulture,
                        Resources.RemoteAssemblyScanner_LogMessage_ScanningAssembly_WithName,
                        assembly.FullName));

                var file     = new FileInfo(assembly.LocalFilePath());
                var fileInfo = new PluginFileInfo(file.FullName, file.LastWriteTimeUtc);

                var createTypeIdentity = TypeIdentityBuilder.IdentityFactory(m_Repository, new Dictionary <Type, TypeIdentity>());
                var mefParts           = ExtractImportsAndExports(assembly, createTypeIdentity);
                var parts = mefParts.Select(p => ExtractActionsAndConditions(p.Item1, p.Item2, createTypeIdentity));
                foreach (var part in parts)
                {
                    m_Logger.Log(
                        LevelToLog.Trace,
                        string.Format(
                            CultureInfo.InvariantCulture,
                            Resources.RemoteAssemblyScanner_LogMessage_AddingPartToRepository_WithPartInformation,
                            part.Identity));

                    m_Repository.AddPart(part, fileInfo);
                }

                var groupExporters = assembly.GetTypes().Where(t => typeof(IExportGroupDefinitions).IsAssignableFrom(t));
                foreach (var t in groupExporters)
                {
                    try
                    {
                        m_Logger.Log(
                            LevelToLog.Trace,
                            string.Format(
                                CultureInfo.InvariantCulture,
                                Resources.RemoteAssemblyScanner_LogMessage_RegisteringGroupsViaExporter_WithExporterType,
                                t.AssemblyQualifiedName));

                        var builder = new GroupDefinitionBuilder(
                            m_Repository,
                            m_ImportEngine,
                            createTypeIdentity,
                            m_ScheduleBuilder,
                            fileInfo);

                        var exporter = Activator.CreateInstance(t) as IExportGroupDefinitions;
                        exporter.RegisterGroups(builder);
                    }
                    catch (Exception e)
                    {
                        m_Logger.Log(LevelToLog.Warn, e.ToString());
                    }
                }
            }
            catch (Exception e)
            {
                m_Logger.Log(
                    LevelToLog.Error,
                    string.Format(
                        CultureInfo.InvariantCulture,
                        Resources.Plugins_LogMessage_Scanner_TypeScanFailed_WithAssemblyAndException,
                        assembly.GetName().FullName,
                        e));
            }
        }