public static IRInterpreterInfo GetMicrosoftRClientInfo(IRegistry registry = null, IFileSystem fileSystem = null) {
            registry = registry ?? new RegistryImpl();
            fileSystem = fileSystem ?? new FileSystem();

            // If yes, check 32-bit registry for R engine installed by the R Server.
            // TODO: remove this when MRS starts writing 64-bit keys.
            if (IsMRCInstalledInSql(registry)) {
                using (IRegistryKey hklm = registry.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32)) {
                    try {
                        using (var key = hklm.OpenSubKey(@"SOFTWARE\R-core\R64")) {
                            foreach (var keyName in key.GetSubKeyNames()) {
                                using (var rsKey = key.OpenSubKey(keyName)) {
                                    try {
                                        var path = (string)rsKey?.GetValue("InstallPath");
                                        if (!string.IsNullOrEmpty(path) && path.Contains(_rServer)) {
                                            var info = new RInterpreterInfo(string.Empty, path);
                                            if (info.VerifyInstallation(new SupportedRVersionRange(), fileSystem)) {
                                                return new RInterpreterInfo(Invariant($"Microsoft R Client (SQL) {info.Version.Major}.{info.Version.Minor}.{info.Version.Build}"), info.InstallPath);
                                            }
                                        }
                                    } catch (Exception) { }
                                }
                            }
                        }
                    } catch (Exception) { }
                }
            }

            return null;
        }

        public void UpdatePluginList(IRegistry registry)
        {
            PluginDescriptors = new List<IPluginDescriptor>(registry.Plugins);
            PluginDescriptors.Sort((l, r) => l.PluginId.CompareTo(r.PluginId));

            OnStructureChanged(new TreePathEventArgs(new TreePath(root)));
        }

        private static void SetupExtensibility(IRegistry registry)
        {
            var dynamicProxy = new CastleDynamicProxyProvider();
            var aopRepository = new AspectRepository(dynamicProxy);

            var dllPlugins =
                (from key in ConfigurationManager.AppSettings.AllKeys
                 where key.StartsWith("PluginsPath", StringComparison.OrdinalIgnoreCase)
                 let path = ConfigurationManager.AppSettings[key]
                 let pathRelative = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path)
                 let chosenPath = Directory.Exists(pathRelative) ? pathRelative : path
                 select chosenPath)
                .ToList();
            registry.RegisterInstance(new PluginsConfiguration { Directories = dllPlugins });

            registry.Register<SystemInitialization>();
            registry.Register<IObjectFactory, DryIocObjectFactory>(Reuse.Singleton);
            registry.Register<IExtensibilityProvider, DryIocMefProvider>(Reuse.Singleton);
            registry.Register(typeof(IPluginRepository<>), typeof(PluginRepository<>), Reuse.Singleton);

            registry.RegisterInstance<IAspectRegistrator>(aopRepository);
            registry.RegisterInstance<IAspectComposer>(aopRepository);
            //registry.RegisterInstance<IInterceptorRegistrator>(aopRepository);
            registry.RegisterInstance<IMixinProvider>(dynamicProxy);
            registry.RegisterInstance<IDynamicProxyProvider>(dynamicProxy);
        }

        public static void Register(IRegistry registry)
        {
            if(registry == null)
                throw new ArgumentNullException("registry");

            registry.For<IConfigurationManager>().Singleton().Use<ConfigurationManagerWrapper>();
        }

        /// <summary>
        /// Creates a resource locator based on a registry.
        /// </summary>
        /// <param name="registry">The registry.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="registry"/> is null.</exception>
        public RegistryResourceLocator(IRegistry registry)
        {
            if (registry == null)
                throw new ArgumentNullException("registry");

            this.registry = registry;
        }

 private void Process(Type type, IRegistry registry)
 {
     if (!type.IsAbstract && typeof (IController).IsAssignableFrom(type))
     {
         registry.AddType(type, type);
     }
 }

        // protected internal constructors...
        /// <summary>
        ///     Initializes a new instance of the <see cref="NKCellRecord" /> class.
        ///     <remarks>Represents a Key Node Record</remarks>
        /// </summary>
        protected internal NKCellRecord(int recordSize, long relativeOffset, IRegistry registryHive)
        {
            RelativeOffset = relativeOffset;
            _registryHive = registryHive;
            _rawBytesLength = recordSize;

                        ValueOffsets = new List<ulong>();
        }

        public LoggingPermissions(IApplicationConstants appConstants, ITelemetryService telemetryService, IRegistry registry) {
            _appConstants = appConstants;
            _telemetryService = telemetryService;
            _registry = registry;

            _registryVerbosity = GetLogLevelFromRegistry();
            _registryFeedbackSetting = GetFeedbackFromRegistry();
        }

 private static void AddRegistryInfo(IRegistry registry)
 {
     registry.Scan(scanner =>
     {
         scanner.AssemblyContainingType<Bootstrapper>();
         scanner.LookForRegistries();
     });
 }

        internal ObjectCreator(IRegistry registry)
        {
            ReturnType = null;
            IsSingleton = false;

            _onCreation = null;
            _registry = registry;
        }

 public TDNetRunnerInstaller(ITestFrameworkManager testFrameworkManager, IRegistry registry, ILogger logger,
     TDNetPreferenceManager preferenceManager)
 {
     this.testFrameworkManager = testFrameworkManager;
     this.registry = registry;
     this.logger = logger;
     this.preferenceManager = preferenceManager;
 }

        public bool IsValid(ref IRegistry registry, List<OperandeVariable> variables)
        {
            if (_expression == null)
              {
            return false;
              }

              return _expression.Accept(new ValidatorVisitor(ref registry, variables));
        }

 private static void ApplyCatalogToRegistry(IProgressMonitor progressMonitor, 
     IPluginCatalog pluginCatalog, IRegistry registry)
 {
     using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(45))
     {
         subProgressMonitor.BeginTask(Resources.UpdatePluginFolderCommand_Applying_catalog_to_registry, 100);
         pluginCatalog.ApplyTo(registry);
     }
 }

        /// <summary>
        /// Adds the registry to the builder.
        /// </summary>
        /// <param name="registry">The registry to be added to the builder.</param>
        /// <remarks>
        /// Registry instances must be applied to a new container in the order that they are added for deterministic behavior.
        /// </remarks>
        public void AddRegistry(IRegistry registry)
        {
            if (null == registry)
            {
                throw new ArgumentNullException("registry");
            }

            _registries.Add(registry);
        }

 internal static void RegisterIoC(IRegistry registry)
 {
     registry.Register<ICodeLocationRepository>(new CodeLocationRepository());
     registry.Register<IApiDataRepository>(new ApiDataRepository());
     registry.Register<IJobRepository>(new JobRepository());
     registry.Register<IWorkerRepository>(new WorkerRepository());
     registry.Register<IFileRepository>(new FileRepository());
     registry.Register<IRepositoryController>(new RepositoryController());
 }

 private static void RegisterStandard(IRegistry registry)
 {
     registry.Register<Singleton1>().As<ISingleton1>().WithLifetime(Lifetime.Container).PreCreateInstance();
     registry.Register<Transient1>().As<ITransient1>().WithLifetime(Lifetime.Transient);
     registry.Register<Combined1>().As<ICombined1>().WithLifetime(Lifetime.Transient)
         .UsingConstructor()
         .WithResolvedParameter<ISingleton1>()
         .WithResolvedParameter<ITransient1>()
         .AsLastParameter();
 }

        public void Setup()
        {
            //RhinoMocks.Logger = new TextWriterExpectationLogger(Console.Out);
            mocks = new MockRepository();
            registry = mocks.DynamicMock<IRegistry>();
            fileSystem = mocks.DynamicMock<IFilesSystem>();

            task = new AddTnsName(registry, fileSystem);
            task.BuildEngine = new MockBuild();
        }

 private void RegisterComplex(IRegistry registry)
 {
     registry.Register<SubObjectOne>().As<ISubObjectOne>().WithLifetime(Lifetime.Transient);
     registry.Register<SubObjectTwo>().As<ISubObjectTwo>().WithLifetime(Lifetime.Transient);
     registry.Register<SubObjectThree>().As<ISubObjectThree>().WithLifetime(Lifetime.Transient);
     registry.Register<FirstService>().As<IFirstService>().WithLifetime(Lifetime.Container).PreCreateInstance();
     registry.Register<SecondService>().As<ISecondService>().WithLifetime(Lifetime.Container).PreCreateInstance();
     registry.Register<ThirdService>().As<IThirdService>().WithLifetime(Lifetime.Container).PreCreateInstance();
     registry.Register<Complex>().As<IComplex>().WithLifetime(Lifetime.Transient);
 }

 public DefaultImManager(IRegistry localRegistry, IIMApiProvider imApi, 
     ICallApiProvider callApi, IEventsProvider eventsProvider)
 {
     Helper.GuardNotNull(localRegistry);
     Helper.GuardNotNull(imApi);
     Helper.GuardNotNull(callApi);
     Helper.GuardNotNull(eventsProvider);
     _imApi = imApi;
     _callApi = callApi;
     _eventsProvider = eventsProvider;
     _localRegistry = localRegistry; 
 }

        /// <inheritodc />
        public void ApplyTo(IRegistry registry)
        {
            if (registry == null)
                throw new ArgumentNullException("registry");

            var topologicallySortedPlugins = TopologicalSortByDependencies(plugins);

            IList<IPluginDescriptor> pluginDescriptors = RegisterPlugins(registry,
                topologicallySortedPlugins);
            RegisterServices(registry, topologicallySortedPlugins, pluginDescriptors);
            RegisterComponents(registry, topologicallySortedPlugins, pluginDescriptors);
        }