C# Messages.AccountName类代码示例

		private Maybe<IDocumentIndex> DoGetDocumentFinder(AccountName accountName, DocumentIndexTypeToken documentIndexTypeToken)
		{
			Lazy<IDocumentIndex> fetched;
			return _documentIndexes[documentIndexTypeToken].TryGetValue(accountName.Value, out fetched)
				? Maybe.Return(fetched.Value)
				: Maybe.Nothing;
		}

		public ProfileGateway(IProfileReadonly profile, AccountName accountName, ITpBus bus)
		{
			_profile = profile;
			_accountName = accountName;
			_bus = bus;
			_storage = _profile.Get<ITargetProcessMessage>();
		}

		public IEnumerable<Profile> GetAll(AccountName accountName)
		{
			using (var context = CreateDataContext())
			{
				return SelectAccount(context.Accounts, accountName).Single().Profiles;
			}
		}

		public Mashup GetMashup(AccountName account, string mashupName)
		{
			_log.Info(string.Format("Getting mashup with name '{0}'", mashupName));
			Mashup mashup = _mashupLoader.Load(GetMashupFolderPath(account, mashupName), mashupName);			
			_log.Info(string.Format("Mashup with name '{0}' retrieved", mashupName));
			return mashup;
		}

		public MashupDto GetMashup(AccountName account, string mashupName)
		{
			_log.Info(string.Format("Getting mashup with name '{0}'", mashupName));

			string mashupFolderPath = GetMashupFolderPath(account, mashupName);

			if (!Directory.Exists(mashupFolderPath))
			{
				return null;
			}

			var script = Directory.GetFiles(mashupFolderPath, "*.js");
			var config = Directory.GetFiles(mashupFolderPath, MashupDto.PlaceholdersCfgFileName);

			if (!script.Any())
			{
				return null;
			}

			var scriptFileInfo = new FileInfo(script.First());
			var mashup = CreateMashupDto(config, scriptFileInfo);
			_log.Info(string.Format("Mashup with name '{0}' retrieved", mashupName));

			return mashup;
		}

		public void WriteOnceReadTwice()
		{
			int beforeProfileAdd = 0;
			int afterProfileAdded = 0;
			var account1Name = new AccountName("account1");
			AccountCollection.GetOrCreate(account1Name);
			ExecuteConcurrently(() =>
			{
				Interlocked.Increment(ref beforeProfileAdd);
				IAccount account = AccountCollection.GetOrCreate(account1Name);
				account.Profiles.Add(new ProfileCreationArgs(new ProfileName("~"), new object()));
				Interlocked.Increment(ref afterProfileAdded);
			}, () =>
			{
				var accountFirstVersion = AccountCollection.GetOrCreate(account1Name);
				var accountSecondVersion = AccountCollection.GetOrCreate(account1Name);
				bool sameVersion = false;
				if (Interlocked.Increment(ref beforeProfileAdd) == 1)
				{
					sameVersion = (accountFirstVersion == accountSecondVersion);
					sameVersion.Should(Be.True, "sameVersion.Should(Be.True)");
				}
				if (Interlocked.Increment(ref afterProfileAdded) == 2)
				{
					IAccount latestAccountVersion = AccountCollection.GetOrCreate(account1Name);
					latestAccountVersion.Profiles.Count().Should(Be.EqualTo(1), "latestAccountVersion.Profiles.Count().Should(Be.EqualTo(1))");
					if (sameVersion)
					{
						(latestAccountVersion == accountFirstVersion).Should(Be.False, "(latestAccountVersion == accountFirstVersion).Should(Be.False)");
					}
				}
			});
			AccountCollection.GetOrCreate(account1Name).Profiles.Count().Should(Be.EqualTo(1), "AccountCollection.GetOrCreate(account1Name).Profiles.Count().Should(Be.EqualTo(1))");
		}

		public MashupScriptStorage(IPluginContext context, IMashupLocalFolder folder, ILogManager logManager, IMashupLoader mashupLoader)
		{
			_folder = folder;
			_mashupLoader = mashupLoader;
			_log = logManager.GetLogger(GetType());
			_accountName = context.AccountName;
		}

		public Profile Update(ProfileName profileName, bool initialized, AccountName accountName)
		{
			var index = _profiles[accountName].FindIndex(x => x.Name == profileName.Value);
			_profiles[accountName][index].Initialized = initialized;
			_profiles[accountName][index].Name = profileName.Value;
			return _profiles[accountName][index];
		}

        public ContextQueryPlanBuilder(IDocumentIndexProvider documentIndexProvider, IDocumentIdFactory documentIdFactory, AccountName accountName, IProfileReadonly profile, IEntityTypeProvider entityTypeProvider)
		{
			_documentIndexProvider = documentIndexProvider;
			_documentIdFactory = documentIdFactory;
            _accountName = accountName;
			_profile = profile;
			_entityTypeProvider = entityTypeProvider;
		}

		public static void ShutdownDocumentIndexesIfRunning(this IDocumentIndexProvider documentIndexProvider, AccountName accountName, DocumentIndexShutdownSetup setup)
		{
			IEnumerable<IDocumentIndex> documentIndexes = documentIndexProvider.DocumentTypes.Select(t => documentIndexProvider.GetDocumentIndex(accountName, t)).Choose();
			foreach (IDocumentIndex documentIndex in documentIndexes)
			{
				documentIndex.Shutdown(setup);
			}
		}

		public ProfileDomainObject Create(Profile profile, AccountName accountName)
		{
			return new ProfileDomainObject(profile.Name, accountName, profile.Initialized, _pluginMetadata.ProfileType)
					{
						EventAggregator = _eventAggregator,
						ProfileRepository = this,
						StorageRepository = new ProfileStorageRepository(new ProfileId(profile.Id), _profileStoragePersister, _pluginMetadata)
					};
		}

		public void Delete(ProfileName profileName, AccountName accountName)
		{
			using (var context = CreateDataContext())
			{
				var profile = SelectProfile(context.Accounts, profileName, accountName);
				context.Profiles.DeleteOnSubmit(profile);
				context.SubmitChanges();
			}
		}

		public QueryPlanBuilder(IPluginContext pluginContext, IProfileReadonly profile, IDocumentIndexProvider documentIndexProvider, IEntityTypeProvider entityTypeProvider, IDocumentIdFactory documentIdFactory)
		{
			_accountName = pluginContext.AccountName;
			_profile = profile;
			_documentIndexProvider = documentIndexProvider;
			_entityTypeProvider = entityTypeProvider;
			_documentIdFactory = documentIdFactory;
			_contextQueryPlanBuilder = new ContextQueryPlanBuilder(_documentIndexProvider, _documentIdFactory, pluginContext.AccountName, _profile, _entityTypeProvider);
		}

		public void RemoveAccount()
		{
			var accountName = new AccountName("Account");
			_accountCollection.GetOrCreate(accountName);
			Assert.IsTrue(_accountCollection.Any(c => c.Name == accountName.Value));
			_accountHandler.Handle(new AccountRemovedMessage(accountName.Value));
			_accountHandler.Handle(_bus.PluginCommands.OfType<AccountRemovedLastStepMessage>().Single());
			Assert.IsFalse(_accountCollection.Any(c => c.Name == accountName.Value));
		}

		public IAccount GetOrCreate(AccountName accountName)
		{
			IAccount account;
			if(_accounts.TryGetValue(accountName, out account))
			{
				return account;
			}

			return _accounts[accountName] = new AccountDomainObject(accountName, new ProfileCollection(accountName, new ProfileDomainObject[0]));
		}