C# IRegistryCore类代码示例

        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry,
                               string defaultConnectionString)
        {
            GD = GenericData;
            m_registry = registry;

            IConfig config = source.Configs["Currency"];
            if (config == null || source.Configs["Currency"].GetString("Module", "") != "BaseCurrency")
                return;

            IConfig gridInfo = source.Configs["GridInfoService"];
            if (gridInfo != null)
            {
                InWorldCurrency = gridInfo.GetString ("CurrencySymbol", string.Empty) + " ";
                RealCurrency = gridInfo.GetString ("RealCurrencySymbol", string.Empty) + " ";
            }

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            if (GenericData != null)
                GenericData.ConnectToDatabase(defaultConnectionString, "SimpleCurrency", true);
            Framework.Utilities.DataManager.RegisterPlugin(Name, this);

            m_config = new BaseCurrencyConfig(config);

            Init(m_registry, Name, "", "/currency/", "CurrencyServerURI");

        }

        public void LoadLibrary(ILibraryService service, IConfigSource source, IRegistryCore registry)
        {
            m_service = service;
            m_registry = registry;
            m_Database = Framework.Utilities.DataManager.RequestPlugin<IInventoryData>();

            IConfig libConfig = source.Configs["InventoryIARLoader"];
            const string pLibrariesLocation = "DefaultInventory/";
            AddDefaultAssetTypes();
            if (libConfig != null)
            {
                if (libConfig.GetBoolean("WipeLibrariesOnNextLoad", false))
                {
                    service.ClearDefaultInventory(); //Nuke it
                    libConfig.Set("WipeLibrariesOnNextLoad", false);
                    source.Save();
                }
                if (libConfig.GetBoolean("PreviouslyLoaded", false))
                    return; //If it is loaded, don't reload
                foreach (string iarFileName in Directory.GetFiles(pLibrariesLocation, "*.iar"))
                {
                    LoadLibraries(iarFileName);
                }
            }
        }

 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     ReadConfig(config);
     IConfig handlers = config.Configs["Handlers"];
     if (handlers.GetString("NeighborHandler", "") == Name)
         registry.RegisterModuleInterface<INeighborService>(this);
 }

        public void Start(IConfigSource config, IRegistryCore registry)
        {
            if (config.Configs["Currency"] == null ||
                config.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
                return;
            if (!config.Configs["Currency"].GetBoolean("RunServer", false))
                return;

            m_connector = DataManager.RequestPlugin<ISimpleCurrencyConnector>() as SimpleCurrencyConnector;

            if (m_connector.GetConfig().ClientPort == 0 && MainServer.Instance == null)
                return;
            IHttpServer server =
                registry.RequestModuleInterface<ISimulationBase>()
                        .GetHttpServer((uint) m_connector.GetConfig().ClientPort);
            server.AddXmlRPCHandler("getCurrencyQuote", QuoteFunc);
            server.AddXmlRPCHandler("buyCurrency", BuyFunc);
            server.AddXmlRPCHandler("preflightBuyLandPrep", PreflightBuyLandPrepFunc);
            server.AddXmlRPCHandler("buyLandPrep", LandBuyFunc);
            server.AddXmlRPCHandler("getBalance", GetbalanceFunc);
            server.AddXmlRPCHandler("/currency.php", GetbalanceFunc);
            server.AddXmlRPCHandler("/landtool.php", GetbalanceFunc);

            m_syncMessagePoster = registry.RequestModuleInterface<ISyncMessagePosterService>();
            m_agentInfoService = registry.RequestModuleInterface<IAgentInfoService>();
        }

        public void Initialize(IConfigSource config, IRegistryCore registry)
        {
            if (MainConsole.Instance != null)
            {
                MainConsole.Instance.Commands.AddCommand(
                    "save archive",
                    "save archive",
                    "Saves a WhiteCore '.abackup' archive (deprecated)",
                    SaveWhiteCoreArchive, true, false);

                MainConsole.Instance.Commands.AddCommand(
                    "load archive",
                    "load archive",
                    "Loads a WhiteCore '.abackupArchive",
                    LoadWhiteCoreArchive, true, false);
            }
            //Register the extension
            const string ext = ".abackup";
            try
            {
                if(Util.IsWindows())
                {
                    RegistryKey key = Registry.ClassesRoot.CreateSubKey(ext + "\\DefaultIcon");
                    key.SetValue("", Application.StartupPath + "\\CrateDownload.ico");
                    key.Close();
                }
            }
            catch
            {
            }
            //Register the interface
            registry.RegisterModuleInterface<IWhiteCoreBackupArchiver>(this);
        }

 public void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = Framework.Utilities.DataManager.RequestPlugin<IAvatarData>();
     m_ArchiveService = registry.RequestModuleInterface<IAvatarAppearanceArchiver>();
     registry.RequestModuleInterface<ISimulationBase>()
             .EventManager.RegisterEventHandler("DeleteUserInformation", DeleteUserInformation);
 }

 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     IConfig handlerConfig = config.Configs["Handlers"];
     if (handlerConfig.GetString("AssetHandler", "") != Name)
         return;
     Configure(config, registry);
 }

 public void Configure(IConfigSource config, IRegistryCore registry)
 {
     if (MainConsole.Instance != null)
     {
         MainConsole.Instance.Commands.AddCommand(
                 "create user",
                 "create user [<first> [<last> [<pass> [<email>]]]]",
                 "Create a new user", HandleCreateUser);
         MainConsole.Instance.Commands.AddCommand("reset user password",
                 "reset user password [<first> [<last> [<password>]]]",
                 "Reset a user password", HandleResetUserPassword);
         MainConsole.Instance.Commands.AddCommand (
                 "show account",
                 "show account <first> <last>",
                 "Show account details for the given user", HandleShowAccount);
         MainConsole.Instance.Commands.AddCommand (
                     "set user level",
                     "set user level [<first> [<last> [<level>]]]",
                     "Set user level. If >= 200 and 'allow_grid_gods = true' in OpenSim.ini, "
                         + "this account will be treated as god-moded. "
                         + "It will also affect the 'login level' command. ",
                         HandleSetUserLevel);
     }
     registry.RegisterModuleInterface<IUserAccountService>(this);
 }

 public AssetServerGetHandler(IAssetService service, string url, string SessionID, IRegistryCore registry) :
     base("GET", url)
 {
     m_AssetService = service;
     m_SessionID = SessionID;
     m_registry = registry;
 }

 public void Initialize(IConfigSource config, IRegistryCore registry)
 {
     m_config = config;
     m_registry = registry;
     registry.RequestModuleInterface<ISimulationBase>().EventManager.RegisterEventHandler("PreRegisterRegion",
                                                                                          EventManager_OnGenericEvent);
 }

 public AbuseReportsHandler(string url, IAbuseReports service, IRegistryCore reg, string SessionID) :
     base("POST", url)
 {
     m_AbuseReportsService = service;
     m_registry = reg;
     m_SessionID = SessionID;
 }

        public void Initialize (ILoginService service, IConfigSource config, IRegistryCore registry)
        {
            IConfig loginServerConfig = config.Configs ["LoginService"];
            if (loginServerConfig != null) {
                m_UseTOS = loginServerConfig.GetBoolean ("UseTermsOfServiceOnFirstLogin", false);
                m_TOSLocation = loginServerConfig.GetString ("FileNameOfTOS", "");

                if (m_TOSLocation.Length > 0) {
                    // html appears to be broken
                    if (m_TOSLocation.ToLower ().StartsWith ("http://", StringComparison.Ordinal))
                        m_TOSLocation = m_TOSLocation.Replace ("ServersHostname", MainServer.Instance.HostName);
                    else {
                        var simBase = registry.RequestModuleInterface<ISimulationBase> ();
                        var TOSFileName = PathHelpers.VerifyReadFile (m_TOSLocation, ".txt", simBase.DefaultDataPath);
                        if (TOSFileName == "") {
                            m_UseTOS = false;
                            MainConsole.Instance.ErrorFormat ("Unable to locate the Terms of Service file : '{0}'", m_TOSLocation);
                            MainConsole.Instance.Error (" Show 'Terms of Service' for a new user login is disabled!");
                        } else
                            m_TOSLocation = TOSFileName;
                    }
                } else
                    m_UseTOS = false;

            }
            m_AuthenticationService = registry.RequestModuleInterface<IAuthenticationService> ();
            m_LoginService = service;
        }

 public AvatarServerPostHandler(string url, IAvatarService service, string SessionID, IRegistryCore registry) :
     base("POST", url)
 {
     m_AvatarService = service;
     m_SessionID = SessionID;
     m_registry = registry;
 }

 public MessagingServiceInPostHandler (string url, IRegistryCore registry, MessagingServiceInHandler handler, string SessionID) :
         base("POST", url)
 {
     m_handler = handler;
     m_SessionID = SessionID;
     ulong.TryParse (SessionID, out m_ourRegionHandle);
 }

 public virtual void Start(IConfigSource config, IRegistryCore registry)
 {
     m_Database = Aurora.DataManager.DataManager.RequestPlugin<IInventoryData> ();
     m_UserAccountService = registry.RequestModuleInterface<IUserAccountService>();
     m_LibraryService = registry.RequestModuleInterface<ILibraryService>();
     m_AssetService = registry.RequestModuleInterface<IAssetService>();
 }