public void Initialize(XmlElement config, IEventManager eventManager, IProfile profile) {
            this.eventManager = eventManager;
            this.profile = profile;
            this.eventManager.Subscribe(typeof(IntervalSync), OnInterval);

            logger = new Logger(eventManager);
        }

        public void Initialize(XmlElement config, IEventManager eventManager, IProfile profile)
        {
            string reposServer = config["RepositoryServer"].InnerText;
            _profile = profile;
            _respostoryPath =reposServer + config["RepositoryPath"].InnerText;

            if (!_usernames.ContainsKey(reposServer))
            {
                Console.Write(String.Format("Please enter {0} Username : ", reposServer));
                _usernames[reposServer] = Console.ReadLine();

                Console.Write(String.Format("Please enter {0} Password : ", reposServer));
                _passwords[reposServer] = Console.ReadLine();
            }

            _connector.SetAuthentication(_usernames[reposServer],  _passwords[reposServer]);

            _eventManager = eventManager;
            _eventManager.Subscribe(PubType, PokeRepository);

            _connector.Revision += _connector_Revision;
            _connector.Error += _connector_Error;

            InernalInitialize(config, eventManager, profile);
        }

 // Copy config.cfg to csgo\cfg folder.
 public string CopyProfileConfig(IProfile profile)
 {
     string destCfg = SteamPaths.CfgFolder + "config.cfg";
     File.Copy(profile.FolderPath + profile.Config, destCfg, true);
     Changes++;
     return profile.Config + " succesfully created. \n";
 }

		public SearchCommand(QueryRunner queryRunner, IProfile profile, DocumentIndexRebuilder documentIndexRebuilder, IActivityLogger logger)
		{
			_queryRunner = queryRunner;
			_profile = profile;
			_documentIndexRebuilder = documentIndexRebuilder;
			_logger = logger;
		}

 public virtual void Initialize(XmlElement config, IEventManager eventManager, IProfile profile) {
     Config = config;
     EventManager = eventManager;
     Logger = new Logger(eventManager);
     
     Logger.LogVersionOneConfiguration(LogMessage.SeverityType.Info, Config["Settings"]);
 }

        public void Initialize(XmlElement config, IEventManager eventManager, IProfile profile)
        {
            eventManager.Subscribe(typeof(LogMessage), HandleLogMessage);
            eventManager.Subscribe(typeof(ServiceHostState), HandleServiceHostStateMessage);

            ConfigureAppenders(config);
        }

 public virtual void Initialize(XmlElement config, IEventManager eventManager, IProfile profile) {
     folderFilterPattern = config["Filter"].InnerText;
     suiteName = config["SuiteName"].InnerText;
     monitor = new RecyclingFileMonitor(profile, config["Watch"].InnerText, folderFilterPattern, Process);
     this.eventManager = eventManager;
     this.eventManager.Subscribe(EventSinkType, monitor.ProcessFolder);
 }

		public BuildSearchIndexesCommand(ITpBus bus, IProfileCollection profileCollection, IProfile profile, IPluginContext pluginContext, IPluginMetadata pluginMetadata)
		{
			_bus = bus;
			_profileCollection = profileCollection;
			_profile = profile;
			_pluginContext = pluginContext;
			_pluginMetadata = pluginMetadata;
		}

 public void SerializeProfiles(IProfile profile)
 {
     using (StreamWriter writer = new StreamWriter(@"..\..\Database\Users\Profiles.txt", true))
     {
         writer.WriteLine();
         writer.Write(profile);
     }
 }

        public UserSettingsService(ISecurityService securityService, IProfile profileRepository)
        {
            Security = securityService;



            Repository = profileRepository;
        }

        private VirtualNode(IProfile rootnode, IProfile node)
        {
            if (!node.Path.StartsWith(rootnode.Path))
                throw new ArgumentOutOfRangeException("node");

            _rootnode = rootnode;
            _node = node;
        }

 public void Submit(IProfile profile)
 {
     var message = string.Format("{0}\n{1}\n{2}",
         profile.Name,
         profile.Age,
         profile.Mail);
     MessageBox.Show(message, "送信");
 }

 private IDisposable QueryContacts(IProfile profile)
 {
     //TODO: What to do when a failure occurs?
     return _contactQueryAggregator.Search(profile)
                                   .SubscribeOn(_schedulerProvider.Concurrent)
                                   .ObserveOn(_schedulerProvider.Dispatcher)
                                   .Subscribe(_contact);
 }

        protected override void InternalInitialize(XmlElement config, IEventManager eventmanager, IProfile profile) 
        {
            ReferenceExpression = config[ReferenceExpressionField].InnerText;
            repositoryFriendlyNameSpec = config[RepositoryFriendlyNameSpecField].InnerText;
            LoadLinkInfo(config[LinkNode]);

            svnInfo = connector.GetSvnInformation(RepositoryPath);
        }

 public virtual bool AreEqual(IProfileModel model, IProfile entity)
 {
     return NameableEntityMapper.AreEqual(model, entity)
         // Profile Properties
         // <None>
         // Related Objects
         // <None>
         ;
 }

        public void Initialize(XmlElement config, IEventManager eventManager, IProfile profile) {
            this.eventManager = eventManager;
            this.eventManager.Subscribe(typeof(V1TestReady), CreateQCTest);
            this.eventManager.Subscribe(typeof(WorkitemCreationResult), OnDefectCreated);
            this.eventManager.Subscribe(typeof(WorkitemStateChangeCollection), OnDefectStateChange);
            this.eventManager.Subscribe(typeof(ServiceHostState), HostStateChanged);

            logger = new Logger(eventManager);
        }

 public void SaveCommit(IProfile profile, out bool success)
 {
     using (IUnitOfWork u = UnitOfWork.Begin())
     {
         Save(profile, out success);
         if (success)
             u.Commit();
     }
 }

        public void DeleteCommit(IProfile profile)
        {
            Checks.Argument.IsNotNull(profile, "profile");

            using (IUnitOfWork u = UnitOfWork.Begin())
            {
                _repo.Remove(profile);
                u.Commit();
            }
        }

        public void Initialize(XmlElement configElement, IEventManager manager, IProfile profile) {
            eventManager = manager;
            this.profile = profile;
            logger = new Logger(eventManager);
            this.configElement = configElement;

            ConfigurationReader.ReadConfigurationValues(configuration, configElement);

            InitializeComponents();
        }

        public void Initialize(XmlElement config, IEventManager eventManager, IProfile profile) {
            if(!double.TryParse(config["Interval"].InnerText, out interval)) {
                interval = -1;
            }

            publishtype = Type.GetType(config["PublishClass"].InnerText);
            eventmanager = eventManager;
            eventmanager.Subscribe(typeof(ServiceHostState), HostStateChanged);
            logger = new Logger(eventManager);
        }