internal void Verify(IClientConfiguration config, IExtClient client)
 {
     Assert.AreSame(config, _config);
     Assert.AreSame(client, _client);
     Assert.AreEqual(1, _prepareCount);
     Assert.AreEqual(1, _applyCount);
 }

        public DaemonServiceImpl(IEggHost host, IClientConfiguration configuration)
        {
            logger.Info("Constructing Daemon Service");

             this.host = host;
             this.configuration = configuration;
        }

 //!! Метод Вызывается из Дизайнера!!
 public void InitializeFromDisigner(IClientConfiguration configuration)
 {
     try
     {
         _configuration = configuration;
         _showNotifier = new ShowNotifier(_configuration);
         _showNotifier.OnPreparationFinished += _showNotifier_OnPreparationFinished;
         _showNotifier.OnProgressChanged += _showNotifier_OnProgressChanged;
         _showNotifier.OnEquipmentStateChanged += _showNotifier_OnEquipmentStateChanged;
         _showNotifier.OnNotEnoughSpace += _showNotifier_OnNotEnoughSpace;
         _showNotifier.OnShownStatusChanged += (_showNotifier_OnShownStatusChanged);
         _showNotifier.OnReceiveAgentResourcesList += _showNotifier_OnReceiveAgentResourcesList;
         _showNotifier.OnUploadSpeed += new Action<double, string, string>(_showNotifier_OnUploadSpeed);
         _showNotifier.OnPreparationForDisplayEnded += new Action<string, bool>(_showNotifier_OnPreparationForDisplayEnded);
         _showNotifier.OnLogMessage+=new Action<string>(_showNotifier_OnLogMessage);
         _svc = new DuplexClient<IShowCommon>(new InstanceContext(_showNotifier), _pingInterval);
         _svc.Open();
         _created = true;
     }
     catch (CommunicationException)
     {
         _svc.Dispose();
         _svc = null;
         _created = false;
     }
 }

 public TemporaryFileServiceImpl(IClientConfiguration configuration, IFileSystemProxy fileSystemProxy)
 {
     this.configuration = configuration;
      this.fileSystemProxy = fileSystemProxy;
      this.temporaryDirectoryRoot = Path.Combine(configuration.UserDataDirectoryPath, "temp"); ;
      this.temporaryFilesLockPath = Path.Combine(temporaryDirectoryRoot, "LOCK");
      this.temporaryFilesLock = new FileLock(temporaryFilesLockPath);
 }

 protected override dynamic BuildAccessTokenExchangeObject(NameValueCollection parameters, IClientConfiguration configuration)
 {
     return new
     {
         code = parameters["code"],
         client_id = configuration.ClientId,
         client_secret = configuration.ClientSecret,
         redirect_uri = configuration.RedirectUri,
         state = this.State,
     };
 }

 public ModificationListingSynchronizer(IPofSerializer pofSerializer, IFileSystemProxy fileSystemProxy, IClientConfiguration clientConfiguration, TemporaryFileService temporaryFileService, ExeggutorService exeggutorService, ModificationLoader modificationLoader, ObservableCollection<ModificationViewModel> modificationViewModels, LeagueBuildUtilities leagueBuildUtilities)
 {
     this.pofSerializer = pofSerializer;
      this.fileSystemProxy = fileSystemProxy;
      this.clientConfiguration = clientConfiguration;
      this.temporaryFileService = temporaryFileService;
      this.exeggutorService = exeggutorService;
      this.modificationLoader = modificationLoader;
      this.modificationViewModels = modificationViewModels;
      this.leagueBuildUtilities = leagueBuildUtilities;
 }

        public ImapMailBox(IClientConfiguration config, IMailBoxLogger mbLogger, IImapWorker imapWorker, IImapIdler imapIdler, IEmailSender emailSender)
        {
            _config = config;
            _mbLogger = mbLogger;
            _imapWorker = imapWorker;
            _imapIdler = imapIdler;
            _emailSender = emailSender;

            MailBoxName = _config.MailBoxName;
            MailBoxId = _config.Id;
        }

 public ExportPresentation(IClientConfiguration config,
     IPresentationClient remotePresentationClient,
     IPresentationClient standalonePresentationClient,
     IExportPresentationController exportPresentationController)
 {
     _config = config;
     //_standaloneSourceDAL = standaloneSourceDAL;
     //_standaloneDeviceResourceEx = standaloneDeviceResourceEx;
     _standalonePresentationClient = standalonePresentationClient;
     _remotePresentationClient = remotePresentationClient;
     _exportPresentationController = exportPresentationController;
 }

 public ExportConfiguration(IClientConfiguration config,
     IPresentationClient standalonePresentationClient, IPresentationClient remotePresentationClient,
     Action<string> successMessageDelegate, Action<string> errorMessageDelegate,
     Func<string, string, string> getFileNameForConfigurationDelegate)
 {
     _config = config;
     _standalonePresentationClient = standalonePresentationClient;
     _remotePresentationClient = remotePresentationClient;
     _successMessageDelegate = successMessageDelegate;
     _errorMessageDelegate = errorMessageDelegate;
     _getFileNameForConfigurationDelegate = getFileNameForConfigurationDelegate;
 }

		/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
		/// <exception cref="Db4objects.Db4o.Ext.OldFormatException"></exception>
		/// <exception cref="Db4objects.Db4o.Ext.InvalidPasswordException"></exception>
		public virtual IObjectContainer OpenClient(IClientConfiguration clientConfig, string
			 hostName, int port, string user, string password)
		{
			if (user == null || password == null)
			{
				throw new InvalidPasswordException();
			}
			Config4Impl config = AsLegacy(clientConfig);
			Config4Impl.AssertIsNotTainted(config);
			Socket4Adapter networkSocket = new Socket4Adapter(clientConfig.Networking.SocketFactory
				, hostName, port);
			return new ClientObjectContainer(clientConfig, networkSocket, user, password, true
				);
		}

        public RemotePresentationClient(IPresentationNotifier presentationNotifier,
            IClientConfiguration clientConfiguration, ISourceDAL sourceDAL, IDeviceSourceDAL deviceSourceDAL)
        {
            _sourceDAL = sourceDAL;
            _deviceSourceDAL = deviceSourceDAL;
            _presentationNotifier = presentationNotifier;
            _configuration = clientConfiguration;
            _presentationClient = new DuplexClient<IPresentationService>(new InstanceContext(presentationNotifier),
                clientConfiguration.PingInterval);
            _presentationClient.Open();
            _presentationClient.OnChanged += new EventHandler<ClientState>(_presentationClient_OnChanged);

            _deviceDescriptorCache = new DeviceDescriptorCache(presentationNotifier);
        }

 public ClientConfigurationDto(IClientConfiguration conf)
 {
     UserName = conf.UserName;
     Password = conf.Password;
     HostName = conf.HostName;
     Port = conf.Port;
     UseSecure = conf.UseSecure;
     MailBoxName = conf.MailBoxName;
     Id = conf.Id;
     SmtpUserName = conf.SmtpUserName;
     SmtpPassword = conf.SmtpPassword;
     SmtpHostName = conf.SmtpHostName;
     SmtpPort = conf.SmtpPort;
 }

        //public IClientConfiguration ClientConfiguration
        //{
            //get { return _configuration; }
        //}

        public bool Initialize(IClientConfiguration configuration)
        {
            using (_svc = new SimpleClient<IAdministrationService>())
            {
                try
                {
                    _svc.Open();
                }
                catch (Exception /*ex*/)
                {
                    return false;
                }
                _configuration = configuration;
                return true;
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="WindowsLiveClient"/> class.
 /// </summary>
 /// <param name="factory">The factory.</param>
 /// <param name="configuration">The configuration.</param>
 public WindowsLiveClient(IRequestFactory factory, IClientConfiguration configuration)
     : base(factory, configuration)
 {
 }

 public TwitterClient(IRequestFactory factory, IClientConfiguration configuration)
     : base(factory, configuration)
 {
 }

		/// <summary>opens a db4o client instance with the specified configuration.</summary>
		/// <remarks>opens a db4o client instance with the specified configuration.</remarks>
		/// <param name="config">the configuration to be used</param>
		/// <param name="host">the host name of the server that is to be connected to</param>
		/// <param name="port">the server port to connect to</param>
		/// <param name="user">the username for authentication</param>
		/// <param name="password">the password for authentication</param>
		/// <seealso cref="OpenServer(Db4objects.Db4o.CS.Config.IServerConfiguration, string, int)
		/// 	">OpenServer(Db4objects.Db4o.CS.Config.IServerConfiguration, string, int)</seealso>
		/// <seealso cref="Db4objects.Db4o.IObjectServer.GrantAccess(string, string)">Db4objects.Db4o.IObjectServer.GrantAccess(string, string)
		/// 	</seealso>
		/// <exception cref="System.ArgumentException">if the configuration passed in has already been used.
		/// 	</exception>
		public static IObjectContainer OpenClient(IClientConfiguration config, string host
			, int port, string user, string password)
		{
			return config.Networking.ClientServerFactory.OpenClient(config, host, port, user, 
				password);
		}

		public void Prepare(IClientConfiguration configuration)
		{
			configuration.Networking.SocketFactory = new SslSocketFactory(configuration.Networking.SocketFactory, _validationCallback);
		}

		public ClientObjectContainer(IClientConfiguration config, Socket4Adapter socket, 
			string user, string password, bool login) : this((ClientConfigurationImpl)config
			, socket, user, password, login)
		{
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="OAuth2Client"/> class.
 /// </summary>
 /// <param name="factory">The factory.</param>
 /// <param name="configuration">The configuration.</param>
 protected OAuth2Client(IRequestFactory factory, IClientConfiguration configuration)
 {
     _factory = factory;
     Configuration = configuration;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="FacebookClient"/> class.
 /// </summary>
 /// <param name="factory">The factory.</param>
 /// <param name="configuration">The configuration.</param>
 public FacebookClient(IRequestFactory factory, IClientConfiguration configuration)
     : base(factory, configuration)
 {
 }