C# IDataContext.TopicInfos方法代码示例

		/// <summary>
		/// Обновляет агрегатные данные по темам (таблицу topic_info).
		/// Эта процедура сначала удаляет записи соответствующие параметру filter,
		/// а потом формирует агрегатные данные и добавляет их в topic_info.
		/// Транзакция должна контролироваться вызывающим методом.
		/// </summary>
		/// <param name="db"></param>
		/// <param name="msgPredicate">Необязательный параметр позволяющий задать
		/// фильтрацию тем данные по которым нужно пересчитать. 
		/// Может быть null или string.Empty. Если параметр не задан, 
		/// обновляются все сообщения. При этом время обновления может быть
		/// довольно большим (на Athlon 2100+ 512 MB RAM ~ 1 мин.).
		/// Пример: "mid IN (1, 2, 3)" обновит агрегатные значения
		/// для тем 1, 2 и 3.</param>
		/// <param name="topicPredicate">комплиментарный <see cref="msgPredicate"/> предикат для TopicInfo</param>
		/// <returns>Возвращает количество вставленных записей.</returns>
		private static int UpdateTopicInfoByFilter(
			IDataContext db,
			[CanBeNull] Expression<Func<ITopicInfo, bool>> topicPredicate,
			[CanBeNull] Expression<Func<IForumMessage, bool>> msgPredicate)
		{
			// Удаляем.
			//
			if (topicPredicate != null)
				db
					.TopicInfos(topicPredicate)
					.Delete();
			else
				db.TopicInfos().Delete();

			var rates = db.Rates();
			var mods = db.Moderatorials();

			var msgs = db.Messages(m => m.TopicID == 0);
			if (msgPredicate != null)
				msgs = msgs.Where(msgPredicate);

			var updated =
				msgs
					.Into(db.TopicInfos())
						.Value(_ => _.MessageID, m => m.ID)
						.Value(_ => _.ForumID, m => m.ForumID)
					// ReSharper disable once UseCollectionCountProperty
						.Value(_ => _.AnswersCount, m => m.TopicAnswers.Count())
						.Value(
							_ => _.AnswersRates,
							m =>
								rates
									.Where(r => r.Message.TopicID == m.ID && r.RateType > 0)
									.Sum(r => (int)r.RateType * r.Multiplier))
						.Value(
							_ => _.AnswersUnread,
							m => m.TopicAnswers.Count(im => !im.IsRead) + (m.IsRead ? 0 : 1))
						.Value(
							_ => _.AnswersSmiles,
							m =>
								rates
									.Count(r => r.Message.TopicID == m.ID && r.RateType == MessageRates.Smile))
						.Value(
							_ => _.AnswersAgrees,
							m =>
								rates
									.Count(r => r.Message.TopicID == m.ID && r.RateType == MessageRates.Agree))
						.Value(
							_ => _.AnswersDisagrees,
							m =>
								rates
									.Count(r => r.Message.TopicID == m.ID && r.RateType == MessageRates.DisAgree))
						.Value(
							_ => _.AnswersToMeUnread,
							m =>
								m
									.TopicAnswers
									.Count(im => !im.IsRead && im.Parent.UserID == Config.Instance.SelfId))
						.Value(_ => _.AnswersMarked, m => m.TopicAnswers.Count(im => im.IsMarked))
						.Value(_ => _.LastUpdateDate, m => m.TopicAnswers.Max(im => (DateTime?)im.Date) ?? m.Date)
						.Value(
							_ => _.AnswersModeratorials,
							m =>
								mods
									.Count(
										mod =>
											mod.Message.TopicID == m.ID
											&& (mod.Message.LastModerated == null || mod.Create > mod.Message.LastModerated)))
						.Value(_ => _.SelfRates, m => m.Rating())
						.Value(_ => _.SelfSmiles, m => m.SmileCount())
						.Value(_ => _.SelfAgrees, m => m.AgreeCount())
						.Value(_ => _.SelfDisagrees, m => m.DisagreeCount())
						.Value(_ => _.SelfModeratorials, m => m.ActiveModeratorialCount())
					.Insert();

			return updated;
		}

		public static void UpdateTopicInfoSpecified(
			IServiceProvider provider,
			IDataContext db,
			IEnumerable<int> affectedIds)
		{
			foreach (var portion in affectedIds.SplitForInClause(provider))
			{
				var locPortion = portion;

				db
					.TopicInfos(ti => locPortion.Contains(ti.MessageID))
						.Set(_ => _.AnswersUnread,     0)
						.Set(_ => _.AnswersToMeUnread, 0)
					.Update();

				var msgs = db.Messages();
				var affectedTids =
					msgs
						.Where(m => locPortion.Contains(m.ID))
						.Select(m => m.TopicID == 0 ? m.ID : m.TopicID)
						.Distinct();

				var readCounts =
					affectedTids
						.Select(
							tid =>
								new
								{
									TopicID = tid,
									UnreadCount =
										msgs.Count(m => !m.IsRead && m.TopicID == tid),
									MeUnreadCount =
										msgs.Count(m => !m.IsRead && m.UserID == Config.Instance.SelfId && m.TopicID == tid)
								})
						.ToList();

				foreach (var cnt in readCounts)
				{
					var locCnt = cnt;
					db
						.TopicInfos(ti => ti.MessageID == locCnt.TopicID)
							.Set(_ => _.AnswersUnread,     locCnt.UnreadCount)
							.Set(_ => _.AnswersToMeUnread, locCnt.MeUnreadCount)
						.Update();
				}
			}
		}

        /// <summary>
        /// Удаляет маркеры.
        /// </summary>
        /// <param name="db">См. <see cref="DbManager"/></param>
        /// <param name="maxMsgId">Максимальный ID сообщения, 
        /// который учавствует в выборке.</param>
        private static void ClearMarkers(IDataContext db, int maxMsgId)
        {
            // Транзакцией занимается вызывающий код.
            db
                .Messages(m => m.IsMarked && m.ID <= maxMsgId)
                    .Set(_ => _.IsMarked, false)
                .Update();

            db
                .TopicInfos(ti => ti.AnswersMarked > 0 && ti.MessageID <= maxMsgId)
                    .Set(_ => _.AnswersMarked, 0)
                .Update();
        }

		/// <summary>
		/// Добавление сообшений полученыых с сервера в базу
		/// </summary>
		/// <param name="provider"></param>
		/// <param name="db"></param>
		/// <param name="messages">Добавляемые сообщения</param>
		/// <param name="selfid"></param>
		/// <param name="progressHandler">обработчик прогресса обработки сообщений</param>
		/// <param name="updatedTopicIds">Какие топики были обновлены.</param>
		/// <param name="updatedMessageIds">Какие сообщения были добавлены.</param>
		private static void AddMessages(
			[JetBrains.Annotations.NotNull] IServiceProvider provider,
			IDataContext db,
			JanusMessageInfo[] messages,
			int selfid,
			Action<int, int> progressHandler,
			out int[] updatedTopicIds,
			out int[] updatedMessageIds)
		{
			if (db == null)
				throw new ArgumentNullException(nameof(db));
			if (messages == null)
				throw new ArgumentNullException(nameof(messages));

			var msgIds = new List<int>();
			var topicIds = new List<int>();
			var processed = 0;
			foreach (var msg in messages)
			{
				if (ForumsSubscriptionHelper.IsTrashForum(msg.forumId))
					try
					{
						var mid = msg.messageId;
						db.TopicInfos(ti => ti.MessageID == mid).Delete();
						db.Messages(m => m.ID == mid).Delete();
					}
					catch (Exception)
					{
						provider.LogError(Resources.ErrorOnMessageDelete + msg.messageId);
					}
				else
				{
					var updatedTid = db.Message(msg.messageId, m => (int?) m.TopicID);

					if (msg.message.IsNullOrEmpty())
						msg.message = "<none>";

					var lastModerated =
						msg.lastModerated == DateTime.MinValue
							? null
							: (DateTime?) msg.lastModerated;
					try
					{
						if (!updatedTid.HasValue)
						{
							var markRead = false;
							if (msg.parentId != 0)
								markRead = db.Message(msg.parentId, m => m.ReadReplies);

							var isRead =
								msg.userId == selfid
									? provider.GetRequiredService<IRsdnSyncConfigService>().GetConfig().MarkOwnMessages
									: markRead;

							db
								.Messages()
								.Value(_ => _.ID, msg.messageId)
								.Value(_ => _.ForumID, msg.forumId)
								.Value(_ => _.TopicID, msg.topicId)
								.Value(_ => _.ParentID, msg.parentId)
								.Value(_ => _.Date, msg.messageDate)
								.Value(_ => _.UserNick, msg.userNick)
								.Value(_ => _.Subject, msg.subject)
								.Value(_ => _.Message, msg.message)
								.Value(_ => _.UserClass, ToJanusUserClass(msg.userRole))
								.Value(_ => _.IsRead, isRead)
								.Value(_ => _.UserID, msg.userId)
								.Value(_ => _.ArticleId, msg.articleId)
								.Value(_ => _.ReadReplies, markRead)
								.Value(_ => _.Name, msg.messageName)
								.Value(_ => _.LastModerated, lastModerated)
								.Value(_ => _.Closed, msg.closed)
								.Insert();

							msgIds.Add(msg.messageId);
						}
						else
						{
							var locMsg = msg;
							db
								.Messages(m => m.ID == locMsg.messageId)
								.Set(_ => _.ForumID, msg.forumId)
								.Set(_ => _.TopicID, msg.topicId)
								.Set(_ => _.ParentID, msg.parentId)
								.Set(_ => _.Date, msg.messageDate)
								.Set(_ => _.UserID, msg.userId)
								.Set(_ => _.UserNick, msg.userNick)
								.Set(_ => _.Subject, msg.subject)
								.Set(_ => _.Message, msg.message)
								.Set(_ => _.UserClass, ToJanusUserClass(msg.userRole))
//.........这里部分代码省略.........

        private IEnumerable<Forum> LoadSubscribedForums(IDataContext db)
        {
            var q = db.SubscribedForums().OrderByDescending(f => f.Priority);
            q =
                Config.Instance.ForumDisplayConfig.ShowFullForumNames
                    ? q.ThenBy(f => f.Descript)
                    : q.ThenBy(f => f.Name);

            var counts =
                from ti in db.TopicInfos()
                group ti by ti.ForumID into grp
                select
                    new
                    {
                        ForumID = grp.Key,
                        Count = grp.Count() + grp.Sum(iti => iti.AnswersCount),
                        Unread = grp.Sum(iti => iti.AnswersUnread),
                        MeUnread = grp.Sum(iti => iti.AnswersToMeUnread)
                    };
            var forums =
                from f in q
                join ti in counts on f.ID equals ti.ForumID into lj
                from ti in lj.DefaultIfEmpty() // left join forcing
                select
                    new Forum(_serviceProvider)
                    {
                        ID = f.ID,
                        Name = f.Name,
                        LastSync = f.LastSync,
                        IsSubscribed = true,
                        IsRateable = f.ServerForum.Rated,
                        RateLimit = f.ServerForum.RateLimit > 0,
                        MessagesCount = ti.Count,
                        RepliesToMeUnread = ti.MeUnread,
                        Unread = ti.Unread,
                        InTop = f.ServerForum.InTop,
                        Priority = f.Priority.GetValueOrDefault(),
                        ForumDescription = f.Descript
                    };
            return forums.ToList();
        }