C# ServiceContainer.AddService方法代码示例

        public void Setup()
        {
            mr = new MockRepository();
            mockFactory = new MockFactory(mr);
            var platform = mockFactory.CreatePlatform();
            var imageMap = new SegmentMap(Address32.Ptr32(0x05));
            program = new Program(imageMap, platform.Architecture, platform);
            interactor = new CombinedCodeViewInteractor();
            var uiPreferencesSvc = mr.Stub<IUiPreferencesService>();
            var uiSvc = mr.Stub<IDecompilerShellUiService>();

            var styles = new Dictionary<string, UiStyle>()
            {
                {
                    UiStyles.CodeWindow,
                    new UiStyle
                    {
                        Background = new SolidBrush(Color.White),
                    }
                }
            };
            uiPreferencesSvc.Stub(u => u.Styles).Return(styles);
            var sc = new ServiceContainer();
            sc.AddService<IUiPreferencesService>(uiPreferencesSvc);
            sc.AddService<IDecompilerShellUiService>(uiSvc);
            interactor.SetSite(sc);
        }

		protected Program RewriteFile(string relativePath, Address addrBase)
		{
            var sc = new ServiceContainer();
            var config = new FakeDecompilerConfiguration();
            sc.AddService<IConfigurationService>(config);
            sc.AddService<DecompilerHost>(new FakeDecompilerHost());
            sc.AddService<DecompilerEventListener>(new FakeDecompilerEventListener());
            sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
            ILoader ldr = new Loader(sc);
            var program = ldr.AssembleExecutable(
                FileUnitTester.MapTestPath(relativePath),
                new X86TextAssembler(sc, new IntelArchitecture(ProcessorMode.Real)),
                addrBase);
            program.Platform = new DefaultPlatform(sc, program.Architecture);
            var ep = new EntryPoint(program.Image.BaseAddress, program.Architecture.CreateProcessorState());
            var project = new Project { Programs = { program } };
            var scan = new Scanner(
                program,
                new Dictionary<Address, ProcedureSignature>(),
                new ImportResolver(project),
                sc);
			scan.EnqueueEntryPoint(ep);
			scan.ScanImage();

			var dfa = new DataFlowAnalysis(program, new FakeDecompilerEventListener());
			dfa.AnalyzeProgram();
            return program;
		}

        private void BuildTest(Address addrBase, IPlatform platform , Action<X86Assembler> asmProg)
        {
            var sc = new ServiceContainer();
            sc.AddService<DecompilerEventListener>(new FakeDecompilerEventListener());
            sc.AddService<DecompilerHost>(new FakeDecompilerHost());
            sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
            var entryPoints = new List<EntryPoint>();
            var asm = new X86Assembler(sc, platform, addrBase, entryPoints);
            asmProg(asm);

            var lr = asm.GetImage();
            program = new Program(
                lr.Image,
                lr.ImageMap,
                arch,
                platform);
            var project = new Project { Programs = { program } };
            scanner = new Scanner(
                program,
                new Dictionary<Address, ProcedureSignature>(),
                new ImportResolver(project),
                sc);
            scanner.EnqueueEntryPoint(new EntryPoint(addrBase, arch.CreateProcessorState()));
            scanner.ScanImage();
        }

        public void Sgrom_LoadImage()
        {
            var sc = new ServiceContainer();
            var cfgSvc = mr.Stub<IConfigurationService>();
            var openv = mr.Stub<OperatingEnvironment>();
            var diagSvc = mr.StrictMock<IDiagnosticsService>();
            var arch = new M68kArchitecture();
            var platform = new SegaGenesisPlatform(sc, arch);
            cfgSvc.Expect(c => c.GetArchitecture("m68k")).Return(arch);
            cfgSvc.Expect(c => c.GetEnvironment("sega-genesis")).Return(openv);
            openv.Expect(o => o.Load(sc, arch)).Return(platform);
            sc.AddService<IConfigurationService>(cfgSvc);
            sc.AddService<IDiagnosticsService>(diagSvc);
            Given_AbsoluteMemoryMap(platform);
            mr.ReplayAll();

            var rawBytes = new byte[0x300];
            var sgrom = new RomLoader(sc, "foo.bin", rawBytes);
            var program = sgrom.Load(Address.Ptr32(0));

            var romSegment = program.SegmentMap.Segments.Values.First();
            Assert.IsNotNull(romSegment.MemoryArea, "ROM image should have been loaded into first segment");
            Assert.AreSame(rawBytes, romSegment.MemoryArea.Bytes, "ROM image should have been loaded into first segment");
            Assert.AreEqual(rawBytes.Length, romSegment.ContentSize);
            var ramSegment = program.SegmentMap.Segments.Values.First(s => s.Name == ".data");
            Assert.IsNotNull(ramSegment.MemoryArea, "RAM segment should have a MemoryArea");
        }

		protected Program RewriteFile(string relativePath, Address addrBase)
		{
            sc = new ServiceContainer();
            var config = new FakeDecompilerConfiguration();
            var eventListener = new FakeDecompilerEventListener();
            sc.AddService<IConfigurationService>(config);
            sc.AddService<DecompilerHost>(new FakeDecompilerHost());
            sc.AddService<DecompilerEventListener>(eventListener);
            sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
            ILoader ldr = new Loader(sc);
            var program = ldr.AssembleExecutable(
                FileUnitTester.MapTestPath(relativePath),
                new X86TextAssembler(sc, new X86ArchitectureReal()),
                addrBase);
            program.Platform = new DefaultPlatform(sc, program.Architecture);
            var ep = new ImageSymbol(program.SegmentMap.BaseAddress);
            var project = new Project { Programs = { program } };
            var scan = new Scanner(
                program,
                new ImportResolver(project, program, eventListener),
                sc);
			scan.EnqueueImageSymbol(ep, true);
			scan.ScanImage();

            var importResolver = new ImportResolver(project, program, eventListener);
            var dfa = new DataFlowAnalysis(program, importResolver, eventListener);
			dfa.AnalyzeProgram();
            return program;
		}

        public void SysV_TerminatingFunction()
        {
            var mr = new MockRepository();
            var sc = new ServiceContainer();
            var arch = mr.Stub<IProcessorArchitecture>();
            var tlSvc = mr.Stub<ITypeLibraryLoaderService>();
            var cfgSvc = mr.Stub<IConfigurationService>();
            sc.AddService<IConfigurationService>(cfgSvc);
            sc.AddService<ITypeLibraryLoaderService>(tlSvc);
            cfgSvc.Stub(c => c.GetEnvironment(null))
                .IgnoreArguments()
                .Return(new OperatingEnvironmentElement
                {
                     TypeLibraries = 
                     {
                         new TypeLibraryElement 
                         {
                              Name="libc.xml"
                         }
                     },
                     CharacteristicsLibraries =
                     {
                         new TypeLibraryElement
                         {
                             Name="libcharacteristics.xml",
                         }
                     }
                });
            tlSvc.Stub(t => t.LoadCharacteristics(null))
                .IgnoreArguments()
                .Return(new CharacteristicsLibrary
                {
                    Entries =
                    {
                        { 
                            "exit", 
                            new ProcedureCharacteristics {
                                Terminates = true
                            }
                        }
                    }
                });
            tlSvc.Stub(t => t.LoadLibrary(null, null))
                .IgnoreArguments()
                .Return(new TypeLibrary
                {
                    Signatures =
                    {
                         {
                            "exit",
                            new ProcedureSignature(null)
                         }
                     }
                });
            mr.ReplayAll();

            var sysv = new SysVPlatform(sc, arch);
            var proc = sysv.LookupProcedureByName(null, "exit");
            Assert.IsTrue(proc.Characteristics.Terminates, "exit should have been marked as terminating.");
        }

 public void Setup()
 {
     mr = new MockRepository();
     sc = new ServiceContainer();
     listener = mr.Stub<DecompilerEventListener>();
     sc.AddService<DecompilerEventListener>(listener);
     sc.AddService<DecompilerHost>(new FakeDecompilerHost());
 }

 public void Setup()
 {
     mr = new MockRepository();
     sc = new ServiceContainer();
     svc = new DecompilerService();
     sc.AddService(typeof(IDecompilerService), svc);
     sc.AddService(typeof(DecompilerEventListener), new FakeDecompilerEventListener());
 }

 public void Setup()
 {
     this.mr = new MockRepository();
     this.mockFactory = new MockFactory(mr);
     this.cfgSvc = mr.Stub<IConfigurationService>();
     this.sc = new ServiceContainer();
     sc.AddService<IFileSystemService>(new FileSystemServiceImpl('/'));
     sc.AddService<IConfigurationService>(cfgSvc);
 }

 public static void Main(string[] args)
 {
     var services = new ServiceContainer();
     services.AddService(typeof(IServiceFactory), new ServiceFactory(services));
     services.AddService(typeof(IDialogFactory), new WindowsFormsDialogFactory(services));
     services.AddService(typeof(IRegistryService), new WindowsFormsRegistryService());
     services.AddService(typeof(ISettingsService), new WindowsFormsSettingsService(services));
     var interactor = new MainFormInteractor(services);
     interactor.Run();
 }

 public void Setup()
 {
     mr = new MockRepository();
     sc = new ServiceContainer();
     cfgSvc = mr.Stub<IConfigurationService>();
     fsSvc = mr.Stub<IFileSystemService>();
     diagSvc = mr.Stub<IDiagnosticsService>();
     sc.AddService<IFileSystemService>(fsSvc);
     sc.AddService<IDiagnosticsService>(diagSvc);
 }

 public virtual void InstantiateIn(Control container)
 {
     IServiceProvider serviceProvider = null;
     if (this._designerHost != null)
     {
         serviceProvider = this._designerHost;
     }
     else if (!base.IsNoCompile)
     {
         ServiceContainer container2 = new ServiceContainer();
         if (container is IThemeResolutionService)
         {
             container2.AddService(typeof(IThemeResolutionService), (IThemeResolutionService) container);
         }
         if (container is IFilterResolutionService)
         {
             container2.AddService(typeof(IFilterResolutionService), (IFilterResolutionService) container);
         }
         serviceProvider = container2;
     }
     HttpContext current = null;
     TemplateControl templateControl = null;
     TemplateControl control2 = container as TemplateControl;
     if (control2 != null)
     {
         current = HttpContext.Current;
         if (current != null)
         {
             templateControl = current.TemplateControl;
         }
     }
     try
     {
         if (!base.IsNoCompile)
         {
             base.SetServiceProvider(serviceProvider);
         }
         if (current != null)
         {
             current.TemplateControl = control2;
         }
         this.BuildChildren(container);
     }
     finally
     {
         if (!base.IsNoCompile)
         {
             base.SetServiceProvider(null);
         }
         if (current != null)
         {
             current.TemplateControl = templateControl;
         }
     }
 }

		public EditorHost (MonoDevelopProxy proxy)
		{
			this.proxy = proxy;
			
			//set up the services
			services = new ServiceContainer ();
			services.AddService (typeof(INameCreationService), new NameCreationService ());
			services.AddService (typeof(ISelectionService), new SelectionService ());
			services.AddService (typeof(ITypeResolutionService), new TypeResolutionService ());
			services.AddService (
				typeof(IEventBindingService),
				new AspNetEdit.Editor.ComponentModel.EventBindingService (proxy)
			);
			ExtenderListService extListServ = new ExtenderListService ();
			services.AddService (typeof(IExtenderListService), extListServ);
			services.AddService (typeof(IExtenderProviderService), extListServ);
			services.AddService (typeof(ITypeDescriptorFilterService), new TypeDescriptorFilterService ());
			services.AddService (typeof (IMenuCommandService), new AspNetEdit.Editor.ComponentModel.MenuCommandService ());
			//services.AddService (typeof (IToolboxService), toolboxService);

			var project = MonoDevelop.Ide.IdeApp.Workbench.ActiveDocument.Project as AspNetAppProject;
			var aspParsedDoc = MonoDevelop.Ide.IdeApp.Workbench.ActiveDocument.ParsedDocument as AspNetParsedDocument;
			if (project != null && aspParsedDoc != null) {
				WebFormReferenceManager refMan = new WebFormReferenceManager (project);
				refMan.Doc = aspParsedDoc;
				services.AddService (typeof(WebFormReferenceManager), refMan);
			}

			System.Diagnostics.Trace.WriteLine ("Creating DesignerHost");
			designerHost = new DesignerHost (services, this);
			System.Diagnostics.Trace.WriteLine ("Created DesignerHost");
			designerHost.DocumentChanged += new DesignerHost.DocumentChangedEventHandler (OnDocumentChanged);
		}

		public void Setup()
		{
            mr = new MockRepository();
            form = new MainForm();
            sc = new ServiceContainer();
            loader = mr.StrictMock<ILoader>();
            dec = mr.StrictMock<IDecompiler>();
            sc = new ServiceContainer();
            uiSvc = new FakeShellUiService();
            host = mr.StrictMock<DecompilerHost>();
            memSvc = mr.StrictMock<ILowLevelViewService>();
            var image = new LoadedImage(Address.Ptr32(0x10000), new byte[1000]);
            var imageMap = image.CreateImageMap();
            var arch = mr.StrictMock<IProcessorArchitecture>();
            var platform = mr.StrictMock<IPlatform>();
            program = new Program(image, imageMap, arch, platform);
            project = new Project { Programs = { program } };

            browserSvc = mr.StrictMock<IProjectBrowserService>();

            sc.AddService<IDecompilerUIService>(uiSvc);
            sc.AddService(typeof(IDecompilerShellUiService), uiSvc);
            sc.AddService(typeof(IDecompilerService), new DecompilerService());
            sc.AddService(typeof(IWorkerDialogService), new FakeWorkerDialogService());
            sc.AddService(typeof(DecompilerEventListener), new FakeDecompilerEventListener());
            sc.AddService(typeof(IProjectBrowserService), browserSvc);
            sc.AddService(typeof(ILowLevelViewService), memSvc);
            sc.AddService<ILoader>(loader);
            sc.AddService<DecompilerHost>(host);

            i = new TestInitialPageInteractor(sc, dec);

		}

        public void Setup()
        {
            this.mr = new MockRepository();
            this.sc = new ServiceContainer();
            this.arch = mr.Stub<IProcessorArchitecture>();
            this.tlSvc = mr.Stub<ITypeLibraryLoaderService>();
            this.cfgSvc = mr.Stub<IConfigurationService>();
            sc.AddService<IConfigurationService>(cfgSvc);
            sc.AddService<ITypeLibraryLoaderService>(tlSvc);

        }