ISourceFolder ISourceMailbox.GetFolder(byte[] entryId) { MrsTracer.Provider.Function("EasSourceMailbox.GetFolder({0})", new object[] { TraceUtils.DumpEntryId(entryId) }); Add add; EasFolderBase easFolderBase; if (base.EasFolderCache.TryGetValue(entryId, out add)) { easFolderBase = new EasSourceFolder(add, base.EasConnectionWrapper.UserSmtpAddress); } else if (EasMailbox.GetStringId(entryId) == EasSyntheticFolder.RootFolder.ServerId) { easFolderBase = EasSyntheticFolder.RootFolder; } else { if (!(EasMailbox.GetStringId(entryId) == EasSyntheticFolder.IpmSubtreeFolder.ServerId)) { MrsTracer.Provider.Debug("Folder with folderId '{0}' does not exist.", new object[] { entryId }); return(null); } easFolderBase = EasSyntheticFolder.IpmSubtreeFolder; } return((ISourceFolder)easFolderBase.Configure(this)); }
private void FlushBatchToFolder(List <MessageRec> batch, IFxProxyPool proxyPool) { if (batch.Count == 0) { return; } MrsTracer.Provider.Function("MapiSourceMailbox.FlushBatchToFolder({0} messages)", new object[] { batch.Count }); byte[] folderId = batch[0].FolderId; using (MapiSourceFolder folder = base.GetFolder <MapiSourceFolder>(folderId)) { if (folder == null) { MrsTracer.Provider.Debug("Folder {0} is missing in source. Will sync its deletion later.", new object[] { TraceUtils.DumpEntryId(folderId) }); } else { folder.CopyBatch(proxyPool, batch); } } }
private void ReadRulesFromAllFolders() { List <FolderRec> list = ((IMailbox)this).EnumerateFolderHierarchy(EnumerateFolderHierarchyFlags.None, null); foreach (FolderRec folderRec in list) { if (folderRec.FolderType != FolderType.Search) { using (MapiSourceFolder folder = base.GetFolder <MapiSourceFolder>(folderRec.EntryId)) { if (folder == null) { MrsTracer.Provider.Debug("Folder {0} is missing in source while reading rules. Will sync its deletion later.", new object[] { TraceUtils.DumpEntryId(folderRec.EntryId) }); break; } using (base.RHTracker.Start()) { folder.Folder.GetRules(null); } } } } }
void IDestinationMailbox.DeleteFolder(FolderRec folderRec) { MrsTracer.Provider.Function("StorageDestinationMailbox.DeleteFolder(\"{0}\")", new object[] { folderRec.FolderName }); base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None); using (base.RHTracker.Start()) { using (CoreFolder coreFolder = CoreFolder.Bind(base.StoreSession, base.GetFolderId(folderRec.ParentId))) { GroupOperationResult groupOperationResult = coreFolder.DeleteFolder(DeleteFolderFlags.DeleteMessages | DeleteFolderFlags.DeleteSubFolders, StoreObjectId.FromProviderSpecificId(folderRec.EntryId)); if (groupOperationResult.OperationResult != OperationResult.Succeeded) { MrsTracer.Provider.Error("StorageDestinationMailbox.DeleteFolder failed with '{0}'. Folder name: '{1}', type: '{2}', entry id: '{3}'.", new object[] { groupOperationResult.Exception.ToString(), folderRec.FolderName, folderRec.FolderType, TraceUtils.DumpEntryId(folderRec.EntryId) }); groupOperationResult.Exception.PreserveExceptionStack(); throw groupOperationResult.Exception; } } } }
ISourceFolder ISourceMailbox.GetFolder(byte[] entryId) { MrsTracer.Provider.Function("PopSourceMailbox.GetFolder({0})", new object[] { TraceUtils.DumpEntryId(entryId) }); return(base.GetFolder <PopSourceFolder>(entryId)); }
IDestinationFolder IDestinationMailbox.GetFolder(byte[] entryId) { MrsTracer.Provider.Function("PstDestinationMailbox.GetFolder({0})", new object[] { TraceUtils.DumpEntryId(entryId) }); return base.GetFolder<PstDestinationFolder>(entryId); }
protected override void CopySingleMessage(MessageRec curMsg, IFolderProxy folderProxy, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps) { ExecutionContext.Create(new DataContext[] { new OperationDataContext("MapiSourceMailbox.CopySingleMessage", OperationType.None), new EntryIDsDataContext(curMsg.EntryId) }).Execute(delegate { using (this.RHTracker.Start()) { using (MapiMessage mapiMessage = (MapiMessage)this.OpenMapiEntry(curMsg.FolderId, curMsg.EntryId, OpenEntryFlags.DontThrowIfEntryIsMissing)) { if (mapiMessage == null) { MrsTracer.Provider.Debug("Message {0} is missing in source, ignoring", new object[] { TraceUtils.DumpEntryId(curMsg.EntryId) }); } else { using (IMessageProxy messageProxy = folderProxy.OpenMessage(curMsg.EntryId)) { using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(messageProxy, false, new Func <IDisposable>(this.RHTracker.StartExclusive), new Action <uint>(this.RHTracker.Charge))) { mapiMessage.ExportObject(fxProxyBudgetWrapper, CopyPropertiesFlags.None, excludeProps); } if (propsToCopyExplicitly != null && propsToCopyExplicitly.Length > 0) { PropValue[] props = mapiMessage.GetProps(propsToCopyExplicitly); using (this.RHTracker.StartExclusive()) { List <PropValueData> list = new List <PropValueData>(); foreach (PropValue propValue in props) { if (!propValue.IsNull() && !propValue.IsError()) { list.Add(new PropValueData(propValue.PropTag, propValue.Value)); } } if (list.Count > 0) { messageProxy.SetProps(list.ToArray()); } } } using (this.RHTracker.StartExclusive()) { messageProxy.SaveChanges(); } } } } } }); }
public override string ToString() { return(string.Format("{0}: EntryID: {1}, ParentID: {2}, Type: {3}", new object[] { this.FolderName, TraceUtils.DumpEntryId(this.EntryId), TraceUtils.DumpEntryId(this.ParentId), this.FolderType })); }
internal static List <MoveHistoryEntryInternal> LoadMoveHistory(MapiStore mailbox) { MrsTracer.Common.Function("MoveHistoryEntryInternal.LoadMoveHistory", new object[0]); List <MoveHistoryEntryInternal> list = new List <MoveHistoryEntryInternal>(); using (MapiFolder mapiFolder = MapiUtils.OpenFolderUnderRoot(mailbox, MoveHistoryEntryInternal.MHEFolderName, false)) { if (mapiFolder == null) { return(list); } using (MapiTable contentsTable = mapiFolder.GetContentsTable(ContentsTableFlags.DeferredErrors)) { PropValue[][] array = MapiUtils.QueryAllRows(contentsTable, null, new PropTag[] { PropTag.EntryId }); foreach (PropValue[] array3 in array) { byte[] bytes = array3[0].GetBytes(); string subject = string.Format("MoveHistoryEntry {0}", TraceUtils.DumpEntryId(bytes)); MoveObjectInfo <MoveHistoryEntryInternal> moveObjectInfo = new MoveObjectInfo <MoveHistoryEntryInternal>(Guid.Empty, mailbox, bytes, MoveHistoryEntryInternal.MHEFolderName, MoveHistoryEntryInternal.MHEMessageClass, subject, null); using (moveObjectInfo) { MoveHistoryEntryInternal moveHistoryEntryInternal = null; try { moveHistoryEntryInternal = moveObjectInfo.ReadObject(ReadObjectFlags.DontThrowOnCorruptData); } catch (MailboxReplicationPermanentException ex) { MrsTracer.Common.Warning("Failed to read move history entry: {0}", new object[] { ex.ToString() }); } if (moveHistoryEntryInternal != null) { list.Add(moveHistoryEntryInternal); } else if (moveObjectInfo.CreationTimestamp < DateTime.UtcNow - TimeSpan.FromDays(365.0)) { MrsTracer.Common.Warning("Removing old corrupt MHEI entry {0}", new object[] { TraceUtils.DumpEntryId(bytes) }); moveObjectInfo.DeleteMessage(); } } } } } list.Sort(); return(list); }
public override void ApplyContentsChanges(SyncContext ctx, MailboxChanges changes) { MrsTracer.Service.Function("MailboxMerger.ApplyContentsChanges", new object[0]); if (changes.HasFolderRecoverySync) { return; } foreach (FolderChangesManifest folderChangesManifest in changes.FolderChanges.Values) { FolderMapping folderMapping = (FolderMapping)this.SourceHierarchy[folderChangesManifest.FolderId]; if (folderMapping == null) { MrsTracer.Service.Warning("Folder {0} is not discovered in source, will not apply changes", new object[] { TraceUtils.DumpEntryId(folderChangesManifest.FolderId) }); return; } using (ISourceFolder folder = base.SourceMailbox.GetFolder(folderMapping.EntryId)) { if (folder == null) { MrsTracer.Service.Warning("Folder {0} disappeared from source, will not apply changes", new object[] { TraceUtils.DumpEntryId(folderChangesManifest.FolderId) }); return; } byte[] array = base.FolderIdTranslator.TranslateFolderId(folderChangesManifest.FolderId); if (array == null) { MrsTracer.Service.Warning("Source folder {0} is not present in target mailbox, will not apply changes", new object[] { TraceUtils.DumpEntryId(folderChangesManifest.FolderId) }); return; } using (IDestinationFolder folder2 = base.DestMailbox.GetFolder(array)) { if (folder2 == null) { MrsTracer.Service.Warning("Destination folder {0} disappeared, will not apply changes", new object[] { TraceUtils.DumpEntryId(array) }); return; } this.ApplyFolderChanges(ctx, folderChangesManifest, folderMapping, folder, folder2); } } } base.ReportContentChangesSynced(ctx); base.ICSSyncState.ProviderState = base.SourceMailbox.GetMailboxSyncState(); base.SaveICSSyncState(false); }
public T GetFolder <T>(byte[] folderId) where T : PopFolder, new() { MrsTracer.Provider.Function("PopMailbox.GetFolder({0})", new object[] { TraceUtils.DumpEntryId(folderId) }); T result = Activator.CreateInstance <T>(); result.Config(folderId, this); return(result); }
public override string ToString() { return(string.Concat(new string[] { base.ToString(), ", ItemId: ", TraceUtils.DumpEntryId(this.ItemId), ", PreviousItemId: ", TraceUtils.DumpEntryId(this.PreviousItemId) })); }
void IDestinationMailbox.MoveFolder(byte[] folderId, byte[] oldParentId, byte[] newParentId) { base.CreateContext("IDestinationMailbox.MoveFolder", new DataContext[] { new EntryIDsDataContext(folderId), new SimpleValueDataContext("OldParentId", TraceUtils.DumpEntryId(oldParentId)), new SimpleValueDataContext("NewParentId", TraceUtils.DumpEntryId(newParentId)) }).Execute(delegate { ((IDestinationMailbox)this.WrappedObject).MoveFolder(folderId, oldParentId, newParentId); }, true); }
public override string ToString() { return(string.Concat(new object[] { base.ToString(), ", EntryId: ", TraceUtils.DumpEntryId(base.ItemId), ", Data: [len=", this.Data.Length, "], Recipients: ", string.Join(",", this.Recipients) })); }
byte[] IEntryIdTranslator.GetSourceFolderIdFromTargetFolderId(byte[] targetFolderId) { ArgumentValidator.ThrowIfNull("targetFolderId", targetFolderId); byte[] array = this.Merger.FolderIdTranslator.TranslateTargetFolderId(targetFolderId); if (array == null) { MrsTracer.Service.Warning("Destination folder {0} doesn't have mapped source folder", new object[] { TraceUtils.DumpEntryId(targetFolderId) }); } return(array); }
private void WriteEntryIdReference(PropTagFolderMapping ptfm, byte[] folderId, FolderHierarchy.GetPropsDelegate getProps, FolderHierarchy.SetPropsDelegate setProps) { InboxNamedPropFolderMapping inboxNamedPropFolderMapping = ptfm as InboxNamedPropFolderMapping; PropTag propTag; if (inboxNamedPropFolderMapping != null) { propTag = this.MbxWrapper.NamedPropMapper.MapNamedProp(inboxNamedPropFolderMapping.NamedPropData, PropType.Binary); } else { propTag = ptfm.Ptag; } MrsTracer.Service.Debug("Writing WKF reference {0}: {1} -> {2}", new object[] { ptfm.WKFType, propTag, TraceUtils.DumpEntryId(folderId) }); InboxIndexedFolderMapping inboxIndexedFolderMapping = ptfm as InboxIndexedFolderMapping; object value; if (inboxIndexedFolderMapping != null) { List <byte[]> list = new List <byte[]>(); PropValueData[] array = getProps(new PropTag[] { propTag }); byte[][] array2 = array[0].Value as byte[][]; if (array2 != null) { list.AddRange(array2); } while (list.Count < inboxIndexedFolderMapping.EntryIndex + 1) { list.Add(Array <byte> .Empty); } list[inboxIndexedFolderMapping.EntryIndex] = folderId; value = list.ToArray(); } else { value = folderId; } PropValueData[] pvda = new PropValueData[] { new PropValueData(propTag, value) }; setProps(pvda); }
IDestinationFolder IDestinationMailbox.GetFolder(byte[] entryId) { MrsTracer.Provider.Function("MapiDestinationMailbox.GetFolder({0})", new object[] { TraceUtils.DumpEntryId(entryId) }); IDestinationFolder folder; using (base.RHTracker.Start()) { folder = base.GetFolder <MapiDestinationFolder>(entryId); } return(folder); }
private void IdentifyDuplicateSecondaryKeys(MessageRec message, List <byte[]> secondaryKeys, HashSet <byte[]> uniqueSecondaryKeys, HashSet <byte[]> duplicateSecondaryKeys) { foreach (byte[] array in secondaryKeys) { if (array != null && !duplicateSecondaryKeys.Contains(array) && !uniqueSecondaryKeys.Add(array)) { MrsTracer.Service.Debug("Duplicate secondary key found for source message {0}", new object[] { TraceUtils.DumpEntryId(message.EntryId) }); uniqueSecondaryKeys.Remove(array); duplicateSecondaryKeys.Add(array); } } }
ISourceFolder ISourceMailbox.GetFolder(byte[] entryId) { MrsTracer.ProxyClient.Function("RemoteSourceMailbox.GetFolder({0})", new object[] { TraceUtils.DumpEntryId(entryId) }); base.VerifyMailboxConnection(); long num = base.MrsProxy.ISourceMailbox_GetFolder(base.Handle, entryId); if (num == 0L) { return(null); } return(new RemoteSourceFolder(base.MrsProxy, num, entryId, this)); }
public void PrefetchSourceMessageIdsFromTargetMessageIds(EntryIdMap <List <byte[]> > destMessagesToTranslate) { this.prefetchedSourceEntryIdMap.Clear(); PropTag sourceEntryIDPtag = this.Merger.DestHierarchy.SourceEntryIDPtag; PropTag[] additionalPtagsToLoad = new PropTag[] { sourceEntryIDPtag }; foreach (KeyValuePair <byte[], List <byte[]> > keyValuePair in destMessagesToTranslate) { byte[] key = keyValuePair.Key; List <byte[]> value = keyValuePair.Value; foreach (byte[] key2 in value) { this.prefetchedSourceEntryIdMap[key2] = null; } using (IDestinationFolder folder = this.Merger.DestMailbox.GetFolder(key)) { if (folder == null) { MrsTracer.Service.Warning("Destination folder {0} disappeared", new object[] { TraceUtils.DumpEntryId(key) }); } else { List <MessageRec> list = folder.LookupMessages(PropTag.EntryId, value, additionalPtagsToLoad); foreach (MessageRec messageRec in list) { byte[] array = messageRec[sourceEntryIDPtag] as byte[]; if (array == null) { MrsTracer.Service.Warning("Destination message {0} doesn't have mapped source message", new object[] { TraceUtils.DumpEntryId(messageRec.EntryId) }); } else { this.prefetchedSourceEntryIdMap[messageRec.EntryId] = array; } } } } } }
internal void TranslateFolderId(IEntryIdTranslator translator) { byte[] folderId = this.FolderId; byte[] sourceFolderIdFromTargetFolderId = translator.GetSourceFolderIdFromTargetFolderId(folderId); if (sourceFolderIdFromTargetFolderId == null) { MrsTracer.Common.Warning("Destination folder {0} doesn't have mapped source folder for action {1}", new object[] { TraceUtils.DumpEntryId(folderId), this }); this.Ignored = true; } this.OriginalFolderId = folderId; this.FolderId = sourceFolderIdFromTargetFolderId; }
internal void TranslateEntryId(IEntryIdTranslator translator) { byte[] itemId = this.ItemId; byte[] sourceMessageIdFromTargetMessageId = translator.GetSourceMessageIdFromTargetMessageId(itemId); if (sourceMessageIdFromTargetMessageId == null) { MrsTracer.Common.Warning("Destination message {0} doesn't have mapped source message for action {1}", new object[] { TraceUtils.DumpEntryId(itemId), this }); this.Ignored = true; } this.OriginalItemId = itemId; this.ItemId = sourceMessageIdFromTargetMessageId; }
internal override void TranslateEntryIds(IEntryIdTranslator translator) { base.TranslateEntryIds(translator); byte[] previousFolderId = this.PreviousFolderId; byte[] sourceFolderIdFromTargetFolderId = translator.GetSourceFolderIdFromTargetFolderId(previousFolderId); if (sourceFolderIdFromTargetFolderId == null) { MrsTracer.Common.Warning("Previous destination folder {0} doesn't have mapped source folder for action {1}", new object[] { TraceUtils.DumpEntryId(previousFolderId), this }); base.Ignored = true; } this.PreviousFolderId = sourceFolderIdFromTargetFolderId; }
private void ExportSingleFolder(IFxProxyPool proxyPool, byte[] folderEntryId, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludePropertiesFromCopy, AclFlags extendedAclFlags) { ExecutionContext.Create(new DataContext[] { new OperationDataContext("StorageSourceMailbox.ExportSingleFolder", OperationType.None), new EntryIDsDataContext(folderEntryId), new SimpleValueDataContext("exportFoldersDataToCopyFlags", exportFoldersDataToCopyFlags), new SimpleValueDataContext("folderRecFlags", folderRecFlags), new PropTagsDataContext(additionalFolderRecProps), new SimpleValueDataContext("copyPropertiesFlags", copyPropertiesFlags), new PropTagsDataContext(excludePropertiesFromCopy), new SimpleValueDataContext("extendedAclFlags", extendedAclFlags) }).Execute(delegate { using (this.RHTracker.Start()) { using (ISourceFolder folder = this.GetFolder <StorageSourceFolder>(folderEntryId)) { if (folder == null) { MrsTracer.Provider.Debug("Folder {0} is missing in source. Skipping.", new object[] { TraceUtils.DumpEntryId(folderEntryId) }); } else { using (IFolderProxy folderProxyForExportFolder = StorageSourceMailbox.GetFolderProxyForExportFolder(proxyPool, folder, exportFoldersDataToCopyFlags, folderRecFlags, additionalFolderRecProps)) { if (extendedAclFlags != AclFlags.None) { this.ExportExtendedAcls(extendedAclFlags, folder, folderProxyForExportFolder); } using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(folderProxyForExportFolder, false, new Func <IDisposable>(this.RHTracker.StartExclusive), new Action <uint>(this.RHTracker.Charge))) { if (exportFoldersDataToCopyFlags.HasFlag(ExportFoldersDataToCopyFlags.IncludeCopyToStream)) { folder.CopyTo(fxProxyBudgetWrapper, copyPropertiesFlags, excludePropertiesFromCopy); } } } } } } }); }
public override string ToString() { switch (this.folderRecWrapper.FolderType) { case FolderType.Root: return(string.Format("Root folder: entryId {0}", TraceUtils.DumpEntryId(this.folderRecWrapper.EntryId))); case FolderType.Generic: return(string.Format("Folder: '{0}', entryId {1}, parentId {2}", this.folderRecWrapper.FullFolderName, TraceUtils.DumpEntryId(this.folderRecWrapper.EntryId), TraceUtils.DumpEntryId(this.folderRecWrapper.ParentId))); case FolderType.Search: return(string.Format("Search folder: '{0}', entryId {1}, parentId {2}", this.folderRecWrapper.FullFolderName, TraceUtils.DumpEntryId(this.folderRecWrapper.EntryId), TraceUtils.DumpEntryId(this.folderRecWrapper.ParentId))); default: return(string.Format("Folder: entryId {0}", TraceUtils.DumpEntryId(this.folderRecWrapper.EntryId))); } }
private void UpdateSourceId(byte[] destinationFolderId, byte[] destinationMessageId, byte[] sourceId) { using (IDestinationFolder folder = base.DestMailbox.GetFolder(destinationFolderId)) { if (folder == null) { MrsTracer.Service.Warning("Destination folder {0} disappeared", new object[] { TraceUtils.DumpEntryId(destinationFolderId) }); } else { folder.SetMessageProps(destinationMessageId, new PropValueData[] { new PropValueData(this.DestHierarchy.SourceEntryIDPtag, sourceId) }); } } }
private void DeleteItem(byte[] destinationFolderId, byte[] destinationMessageId) { using (IDestinationFolder folder = base.DestMailbox.GetFolder(destinationFolderId)) { if (folder == null) { MrsTracer.Service.Warning("Destination folder {0} disappeared", new object[] { TraceUtils.DumpEntryId(destinationFolderId) }); } else { folder.DeleteMessages(new byte[][] { destinationMessageId }); } } }
public T GetFolder <T>(byte[] folderId) where T : PstFolder, new() { MrsTracer.Provider.Function("PstMailbox.GetFolder({0})", new object[] { TraceUtils.DumpEntryId(folderId) }); uint nodeIdFromEntryId = PstMailbox.GetNodeIdFromEntryId(this.iPst.MessageStore.Guid, folderId); IFolder folder; try { folder = this.iPst.ReadFolder(nodeIdFromEntryId); } catch (PSTIOException innerException) { throw new UnableToReadPSTFolderTransientException(nodeIdFromEntryId, innerException); } catch (PSTExceptionBase innerException2) { throw new UnableToReadPSTFolderPermanentException(nodeIdFromEntryId, innerException2); } if (folder == null) { MrsTracer.Provider.Debug("Folder does not exist", new object[0]); return(default(T)); } PstFxFolder pstFxFolder = new PstFxFolder(this, folder); if (MrsTracer.Provider.IsEnabled(TraceType.DebugTrace)) { MrsTracer.Provider.Debug("Opened folder '{0}'", new object[] { (string)pstFxFolder.GetProp(PropertyTag.DisplayName).Value }); } T result = Activator.CreateInstance <T>(); result.Config(folderId, pstFxFolder); return(result); }
public T GetFolder <T>(byte[] folderId) where T : ImapFolder, new() { MrsTracer.Provider.Function("ImapMailbox.GetFolder({0})", new object[] { TraceUtils.DumpEntryId(folderId) }); base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None); ImapClientFolder folder; if (!this.folderCache.TryGetValue(folderId, out folder)) { MrsTracer.Provider.Debug("Folder with entryId {0} does not exist", new object[] { folderId }); return(default(T)); } T result = Activator.CreateInstance <T>(); result.Config(folderId, folder, this); return(result); }
public void CopyMailboxProperties() { MrsTracer.Service.Function("MailboxMerger.CopyMailboxProperties", new object[0]); PropValue[] native = DataConverter <PropValueConverter, PropValue, PropValueData> .GetNative(base.SourceMailbox.GetProps(MailboxMerger.MailboxPtags)); List <PropValue> list = new List <PropValue>(); foreach (PropValue item in native) { if (!item.IsNull() && !item.IsError()) { if (item.PropTag == PropTag.SentMailEntryId) { byte[] array2 = item.Value as byte[]; if (array2 != null) { FolderMapping folderMapping = this.SourceHierarchy[array2] as FolderMapping; if (folderMapping != null && folderMapping.IsIncluded && folderMapping.TargetFolder != null) { MrsTracer.Service.Debug("Remapped SentItemsEntryId from {0} to {1}", new object[] { TraceUtils.DumpEntryId(array2), TraceUtils.DumpEntryId(folderMapping.TargetFolder.EntryId) }); list.Add(new PropValue(item.PropTag, folderMapping.TargetFolder.EntryId)); } } } else { list.Add(item); } } } if (list.Count > 0) { base.DestMailbox.SetProps(DataConverter <PropValueConverter, PropValue, PropValueData> .GetData(list.ToArray())); } }