public override bool ShouldCreateFolder(FolderMap.EnumFolderContext context, FolderRecWrapper sourceFolderRecWrapper) { FolderMapping folderMapping = sourceFolderRecWrapper as FolderMapping; Guid contentMailboxGuid = this.GetContentMailboxGuid(sourceFolderRecWrapper); bool isRoot = base.IsRoot; bool flag = contentMailboxGuid == base.TargetMailboxGuid; if (!isRoot && !flag && (!this.ShouldCreateUnderParentInSecondary() || !this.DoesAnySubFolderResideInTargetMailbox(sourceFolderRecWrapper))) { MrsTracer.Service.Debug("Not creating folder \"{0}\" in mailbox {1}. This is neither the primary hierarchy mailbox nor the content mailbox of this folder or any of its subfolders.", new object[] { sourceFolderRecWrapper.FullFolderName, base.TargetMailboxGuid }); return(false); } switch (folderMapping.WKFType) { case WellKnownFolderType.Root: case WellKnownFolderType.NonIpmSubtree: case WellKnownFolderType.IpmSubtree: case WellKnownFolderType.EFormsRegistry: return(false); default: if (folderMapping.IsLegacyPublicFolder) { context.Result = EnumHierarchyResult.SkipSubtree; return(false); } return(true); } }
private ConflictResolutionOption GetConflictResolutionOption(FolderMapping fm) { WellKnownFolderType wkftype = fm.WKFType; switch (wkftype) { case WellKnownFolderType.DumpsterDeletions: case WellKnownFolderType.DumpsterVersions: case WellKnownFolderType.DumpsterPurges: break; default: switch (wkftype) { case WellKnownFolderType.DumpsterAdminAuditLogs: case WellKnownFolderType.DumpsterAudits: break; default: { ConflictResolutionOption?conflictResolutionOption = base.MRSJob.CachedRequestJob.ConflictResolutionOption; if (conflictResolutionOption == null) { return(ConflictResolutionOption.KeepSourceItem); } return(conflictResolutionOption.GetValueOrDefault()); } } break; } return(ConflictResolutionOption.KeepAll); }
private void CreateFolderHierarchy() { base.RefreshRequestIfNeeded(); base.CheckServersHealth(); MrsTracer.Service.Debug("WorkItem: create folder hierarchy.", new object[0]); MrsTracer.Service.Debug("Creating missing folders in target", new object[0]); this.MailboxMerger.DestHierarchy.CreateMissingFolders(); base.RefreshRequestIfNeeded(); base.CheckServersHealth(); List <FolderMapping> foldersToCopy = new List <FolderMapping>(); foreach (WellKnownFolderType wkfType in MergeJob.FolderSyncOrder) { FolderMapping wellKnownFolder = this.MailboxMerger.SourceHierarchy.GetWellKnownFolder(wkfType); if (wellKnownFolder != null && wellKnownFolder.IsIncluded) { foldersToCopy.Add(wellKnownFolder); } } this.MailboxMerger.SourceHierarchy.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper folderRec, FolderMap.EnumFolderContext context) { FolderMapping folderMapping = (FolderMapping)folderRec; if (folderMapping.IsIncluded && !foldersToCopy.Contains(folderMapping)) { foldersToCopy.Add(folderMapping); } }); base.ScheduleWorkItem <List <FolderMapping> >(new Action <List <FolderMapping> >(this.CopyMessages), foldersToCopy, WorkloadType.Unknown); }
public override byte[] GetDestinationFolderEntryId(byte[] sourceId) { FolderMapping result = (FolderMapping)this.SourceHierarchy[sourceId]; if (result != null && result.TargetFolder != null) { return(result.TargetFolder.EntryId); } result = null; this.DestHierarchy.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; byte[] eid = folderMapping.FolderRec[this.DestHierarchy.SourceEntryIDPtag] as byte[]; if (CommonUtils.IsSameEntryId(sourceId, eid)) { result = folderMapping; ctx.Result = EnumHierarchyResult.Cancel; } }); if (result == null) { return(null); } return(result.EntryId); }
private void HashFolderMessages(WellKnownFolderType wkfType, HashSet <byte[]> hashset) { MrsTracer.Service.Debug("Enumerating target {0} folder to check for deleted messages", new object[] { wkfType }); FolderMapping wellKnownFolder = this.DestHierarchy.GetWellKnownFolder(wkfType); if (wellKnownFolder != null) { using (IDestinationFolder folder = base.DestMailbox.GetFolder(wellKnownFolder.EntryId)) { if (folder != null) { List <MessageRec> list = folder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages, this.GetEnumerateMessagesPropsForContentVerification(MailboxWrapperFlags.Target)); foreach (MessageRec messageRec in list) { byte[] array = messageRec[this.DestHierarchy.SourceEntryIDPtag] as byte[]; if (array != null && !hashset.Contains(array)) { hashset.Add(array); } } } } } }
public static FolderContentsMapper Create(FolderMapping folderMapping, ISourceFolder srcFolder, FolderHierarchy sourceHierarchy, IDestinationFolder destFolder, FolderHierarchy destHierarchy, ConflictResolutionOption conflictResolutionOption, FAICopyOption faiCopyOption, FolderContentsMapperFlags mapperFlags) { if (!mapperFlags.HasFlag(FolderContentsMapperFlags.ImapSync)) { return(new FolderContentsMapper(folderMapping, srcFolder, sourceHierarchy, destFolder, destHierarchy, conflictResolutionOption, faiCopyOption, mapperFlags)); } return(new ImapFolderContentsMapper(folderMapping, srcFolder, sourceHierarchy, destFolder, destHierarchy, conflictResolutionOption, faiCopyOption, mapperFlags)); }
public override FolderRecWrapper CreateTargetFolderRec(FolderRecWrapper sourceFolderRec) { FolderMapping folderMapping = (FolderMapping)sourceFolderRec; FolderMapping folderMapping2 = new FolderMapping(sourceFolderRec.FolderRec); folderMapping2.SourceFolder = folderMapping; folderMapping.TargetFolder = folderMapping2; return(folderMapping2); }
public void LoadHierarchy(EnumerateFolderHierarchyFlags flags, string rootFolderPath, bool createRootIfNeeded, PropTag[] additionalPtagsToLoad) { List <PropTag> list = new List <PropTag>(); if (this.SourceWKFTypePtag != PropTag.Null) { list.Add(this.SourceWKFTypePtag); } if (this.SourceEntryIDPtag != PropTag.Null) { list.Add(this.SourceEntryIDPtag); } if (additionalPtagsToLoad != null) { list.AddRange(additionalPtagsToLoad); } List <FolderRecWrapper> folders = this.mbxWrapper.LoadFolders <FolderMapping>(flags, list.ToArray()); base.Config(folders); this.DiscoverWellKnownFolders(); if (string.IsNullOrEmpty(rootFolderPath)) { this.rootFolder = (FolderMapping)this.RootRec; } else { FolderMappingFlags folderMappingFlags; this.rootFolder = this.FindFolderByPath(string.Empty, rootFolderPath, createRootIfNeeded, out folderMappingFlags); if (this.rootFolder == null) { throw new FolderIsMissingPermanentException(rootFolderPath); } if (!base.IsPublicFolderMailbox) { this.wellKnownFolderMap.Reset(); this.wellKnownFolderMap.Clear(); this.EnumerateSubtree(EnumHierarchyFlags.AllFolders, this.rootFolder, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; object obj = folderMapping.FolderRec[this.SourceWKFTypePtag]; if (obj != null) { this.SetWellKnownFolder((WellKnownFolderType)((int)obj), folderMapping); } }); if (this.GetWellKnownFolder(WellKnownFolderType.IpmSubtree) == null) { this.SetWellKnownFolder(WellKnownFolderType.IpmSubtree, this.rootFolder); } } } this.rootFolder.Flags |= FolderMappingFlags.Root; if (this.GetWellKnownFolder(WellKnownFolderType.IpmSubtree) == null && !base.IsPublicFolderMailbox) { throw new FolderIsMissingPermanentException("IPM subtree"); } }
public void Add(WellKnownFolderType wkfType, FolderMapping fm) { fm.WKFType = wkfType; this.wellKnownFolders[wkfType] = fm; if (fm.EntryId != null) { this.wellKnownFolderTypes[fm.EntryId] = wkfType; } }
protected override void PerformFolderRecoverySync(MailboxChanges changes, MailboxContentsCrawler crawler) { foreach (FolderChangesManifest folderChangesManifest in from folderChanges in changes.FolderChanges.Values where folderChanges.FolderRecoverySync select folderChanges) { FolderMapping folder = base.MailboxMerger.SourceHierarchy[folderChangesManifest.FolderId] as FolderMapping; crawler.ResetFolder(folder); } }
public override byte[] GetSourceFolderEntryId(FolderRecWrapper targetFolder) { FolderMapping folderMapping = (FolderMapping)targetFolder; if (folderMapping.SourceFolder != null) { return(folderMapping.SourceFolder.EntryId); } return(folderMapping.FolderRec[this.DestHierarchy.SourceEntryIDPtag] as byte[]); }
private void VerifyFolderContents(FolderMapping fm, List <FolderSizeRec> verificationResults) { FolderSizeRec folderSizeRec = this.MailboxMerger.VerifyFolderContents(fm, fm.WKFType, false); if (folderSizeRec != null) { verificationResults.Add(folderSizeRec); this.MailboxMerger.ReportBadItems(folderSizeRec.MissingItems); } }
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 override FolderRecWrapper GetTargetFolderBySourceId(byte[] sourceId) { FolderMap sourceFolderMap = base.SourceFolderMap; FolderMapping folderMapping = base.SourceFolderMap[sourceId] as FolderMapping; if (folderMapping != null && folderMapping.IsSystemPublicFolder) { FolderHierarchy folderHierarchy = base.TargetFolderMap as FolderHierarchy; return folderHierarchy.GetWellKnownFolder(folderMapping.WKFType); } return base.TargetFolderMap[this.destinationMailbox.GetSessionSpecificEntryId(sourceId)]; }
private void MapSubtreeByName(FolderMapping root, bool createIfNeeded) { this.EnumerateSubtree(EnumHierarchyFlags.AllFolders, root, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; if (folderMapping.IsIncluded && folderMapping.TargetFolder == null) { this.MapFolderChainByName(folderMapping, createIfNeeded); } }); }
public void CreateMissingFolders() { IDestinationMailbox destMailbox = (IDestinationMailbox)this.MbxWrapper.Mailbox; base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { if (fRec.EntryId != null) { return; } FolderMapping fm = (FolderMapping)fRec; fm.FolderRec.ParentId = fm.ParentId; ExecutionContext.Create(new DataContext[] { new FolderRecWrapperDataContext(fRec) }).Execute(delegate { byte[] array; destMailbox.CreateFolder(fRec.FolderRec, CreateFolderFlags.FailIfExists, out array); fm.FolderRec.EntryId = array; this[array] = fm; if (fm.SourceFolder != null) { List <PropValueData> list = new List <PropValueData>(); list.Add(new PropValueData(this.SourceEntryIDPtag, fm.SourceFolder.EntryId)); list.Add(new PropValueData(this.SourceLastModifiedTimestampPtag, fm.SourceFolder.FolderRec.LastModifyTimestamp)); if (fm.SourceFolder.WKFType != WellKnownFolderType.None) { list.Add(new PropValueData(this.SourceWKFTypePtag, (int)fm.SourceFolder.WKFType)); } using (IDestinationFolder folder = destMailbox.GetFolder(array)) { if (folder != null) { folder.SetProps(list.ToArray()); } else { MrsTracer.Service.Warning("Something just deleted newly created folder from under us. Ignoring.", new object[0]); } } if (fm.SourceFolder.WKFType != WellKnownFolderType.None && this.GetWellKnownFolder(fm.SourceFolder.WKFType) == null) { this.SetWellKnownFolder(fm.SourceFolder.WKFType, fm); if (this.RootFolder == this.RootRec && (this.MbxWrapper.Flags & MailboxWrapperFlags.Archive) == (MailboxWrapperFlags)0 && (this.MbxWrapper.Flags & MailboxWrapperFlags.PST) == (MailboxWrapperFlags)0) { this.WriteWellKnownFolderReference(fm.SourceFolder.WKFType, fm.EntryId); } } } }); }); }
private void FindNamedFolders(NamedFolderMapping[] map) { foreach (NamedFolderMapping namedFolderMapping in map) { FolderMapping wellKnownFolder = this.GetWellKnownFolder(namedFolderMapping.ParentType); if (wellKnownFolder != null) { FolderMapping folder = wellKnownFolder.FindChildByName(namedFolderMapping.FolderName, base.TargetMailboxCulture) as FolderMapping; this.SetWellKnownFolder(namedFolderMapping.WKFType, folder); } } }
protected FolderContentsMapper(FolderMapping folderMapping, ISourceFolder srcFolder, FolderHierarchy sourceHierarchy, IDestinationFolder destFolder, FolderHierarchy destHierarchy, ConflictResolutionOption conflictResolutionOption, FAICopyOption faiCopyOption, FolderContentsMapperFlags mapperFlags) { this.folderMapping = folderMapping; this.srcFolder = srcFolder; this.destFolder = destFolder; this.destHierarchy = destHierarchy; this.sourceHierarchy = sourceHierarchy; this.conflictResolutionOption = conflictResolutionOption; this.faiCopyOption = faiCopyOption; this.sourceMapping = new EntryIdMap <MessageRec>(); this.targetMapping = new EntryIdMap <MessageRec>(); this.mapperFlags = mapperFlags; }
public byte[] TranslateFolderId(byte[] sourceEntryId) { if (sourceEntryId == null) { return(null); } FolderMapping folderMapping = (FolderMapping)this.sourceHierarchy[sourceEntryId]; if (folderMapping == null || folderMapping.TargetFolder == null) { return(null); } return(folderMapping.TargetFolder.EntryId); }
private void MapPublicFolderDumpster(FolderMapping sourceFolder, FolderMapping targetFolder) { if (!base.IsPublicFolderMailbox) { return; } FolderMapping folderMapping = (FolderMapping)sourceFolder.PublicFolderDumpster; FolderMapping folderMapping2 = (FolderMapping)targetFolder.PublicFolderDumpster; if (folderMapping != null && folderMapping2 != null) { folderMapping.TargetFolder = folderMapping2; folderMapping2.SourceFolder = folderMapping; } }
private void MapFolderChainByName(FolderMapping fm, bool createIfNeeded) { if (fm.TargetFolder != null) { return; } this.MapFolderChainByName((FolderMapping)fm.Parent, createIfNeeded); FolderMapping targetFolder = ((FolderMapping)fm.Parent).TargetFolder; if (targetFolder == null) { return; } this.MapFolderByName(fm, targetFolder, createIfNeeded); }
public void CopyFolderData(FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder) { MrsTracer.Service.Debug("Loading mappable folder properties", new object[0]); FolderRecDataFlags dataToCopy = FolderRecDataFlags.SearchCriteria; if (!base.MRSJob.CachedRequestJob.IsPublicFolderMailboxRestore) { bool flag; this.CopyFolderProperties(fm, srcFolder, destFolder, dataToCopy, out flag); } if (fm.FolderType != FolderType.Search) { this.MergeFolderContents(fm, srcFolder, destFolder); } }
protected void ScheduleContentVerification() { base.Report.Append(MrsStrings.ReportVerifyingMailboxContents); List <FolderSizeRec> verificationResults = new List <FolderSizeRec>(); this.MailboxMerger.SourceHierarchy.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper folderRecWrapper, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)folderRecWrapper; if (folderMapping.IsIncluded) { this.ScheduleWorkItem <FolderMapping, List <FolderSizeRec> >(new Action <FolderMapping, List <FolderSizeRec> >(this.VerifyFolderContents), folderMapping, verificationResults, WorkloadType.Unknown); } }); base.ScheduleWorkItem <List <FolderSizeRec> >(new Action <List <FolderSizeRec> >(this.OutputVerificationResults), verificationResults, WorkloadType.Unknown); }
private void DiscoverWellKnownFolders() { this.wellKnownFolderMap.Clear(); this.SetWellKnownFolder(WellKnownFolderType.Root, (FolderMapping)this.RootRec); List <WellKnownFolder> list = this.MbxWrapper.Mailbox.DiscoverWellKnownFolders((int)this.Flags); if (list != null) { foreach (WellKnownFolder wellKnownFolder in list) { FolderMapping folder = (FolderMapping) base[wellKnownFolder.EntryId]; this.SetWellKnownFolder((WellKnownFolderType)wellKnownFolder.WKFType, folder); } } this.FindNamedFolders(FolderHierarchyUtils.NamedFolderRefs); }
internal void ResetFolder(FolderMapping folder) { MrsTracer.Service.Function("MailboxContentsCrawler.ResetFolder: '{0}'", new object[] { folder }); base.CheckDisposed(); byte[] entryId = folder.EntryId; this.crawledFolders.Remove(entryId); FolderContentsCrawler folderContentsCrawler; if (this.crawlers.TryGetValue(entryId, out folderContentsCrawler)) { folderContentsCrawler.Dispose(); this.crawlers.Remove(entryId); } }
private void MarkPublicFolderDumpster(FolderRecWrapper sourceFolder) { if (!base.IsPublicFolderMailbox) { return; } FolderMapping folderMapping = (FolderMapping)sourceFolder; if (!folderMapping.IsPublicFolderDumpster && ((folderMapping.Flags & FolderMappingFlags.Include) != FolderMappingFlags.None || (folderMapping.Flags & FolderMappingFlags.InheritedInclude) != FolderMappingFlags.None)) { FolderMapping folderMapping2 = (FolderMapping)sourceFolder.PublicFolderDumpster; if (folderMapping2 != null) { folderMapping2.Flags |= FolderMappingFlags.Include; } } }
private void MapFolderByName(FolderMapping sourceFolder, FolderMapping parentTargetFolder, bool createIfNeeded) { FolderMapping folderMapping = (FolderMapping)parentTargetFolder.FindChildByName(sourceFolder.FolderName, base.TargetMailboxCulture); if (folderMapping == null) { if (!createIfNeeded) { return; } folderMapping = new FolderMapping(sourceFolder.FolderName, sourceFolder.FolderType, sourceFolder.FolderClass); folderMapping.Parent = parentTargetFolder; } sourceFolder.TargetFolder = folderMapping; folderMapping.SourceFolder = sourceFolder; this.MapPublicFolderDumpster(sourceFolder, folderMapping); }
public void MergeFolderContentsPaged(FolderMapping folder, FolderContentsCrawler sourceFolderCrawler, IDestinationFolder destFolder, TimeSpan maxOperationDuration) { MrsTracer.Service.Function("MailboxMerger.MergeFolderContentsPaged({0})", new object[] { folder.FullFolderName }); ISourceFolder wrappedObject = sourceFolderCrawler.WrappedObject; if (this.ContentRestriction != null) { wrappedObject.SetContentsRestriction(this.ContentRestriction); } FolderContentsMapper folderContentsMapper = FolderContentsMapper.Create(folder, wrappedObject, this.SourceHierarchy, destFolder, this.DestHierarchy, this.GetConflictResolutionOption(folder), base.MRSJob.CachedRequestJob.AssociatedMessagesCopyOption ?? FAICopyOption.DoNotCopy, (base.MRSJob.CachedRequestJob.SyncProtocol == SyncProtocol.Imap) ? FolderContentsMapperFlags.ImapSync : FolderContentsMapperFlags.None); DateTime utcNow = DateTime.UtcNow; int alreadyCopiedCount; ulong alreadyCopiedSize; List <MessageRec> itemsToCopy; List <MessageRec> list; while (folderContentsMapper.ComputeMappingPaged(sourceFolderCrawler, (base.SyncState == null) ? null : base.SyncState.BadItems, out alreadyCopiedCount, out alreadyCopiedSize, out itemsToCopy, out list)) { SyncProtocol syncProtocol = base.MRSJob.CachedRequestJob.SyncProtocol; foreach (MessageRec messageRec in list) { destFolder.SetMessageProps(messageRec.EntryId, messageRec.AdditionalProps); } base.MailboxSizeTracker.TrackFolder(folder.EntryId, sourceFolderCrawler.TotalMessageCount, alreadyCopiedCount, alreadyCopiedSize); base.MRSJob.MessagesWritten += base.MailboxSizeTracker.AlreadyCopiedCount; base.MRSJob.MessageSizeWritten += base.MailboxSizeTracker.AlreadyCopiedSize; base.MRSJob.TotalMessages = base.MailboxSizeTracker.MessageCount; base.MRSJob.TotalMessageByteSize = base.MailboxSizeTracker.TotalMessageSize; this.CopyMessageBatch(folderContentsMapper, itemsToCopy, folder); DateTime utcNow2 = DateTime.UtcNow; if (utcNow2 - utcNow >= maxOperationDuration) { MrsTracer.Service.Debug("MergeFolderContentsPaged times out for assigned duration {0}. Start:{1}, End:{2}", new object[] { maxOperationDuration, utcNow, utcNow2 }); return; } } }
public override bool IsContentAvailableInTargetMailbox(FolderRecWrapper destinationFolderRec) { FolderMapping folderMapping = destinationFolderRec as FolderMapping; if (folderMapping.IsSystemPublicFolder || destinationFolderRec.IsPublicFolderDumpster) { return(false); } byte[] array = destinationFolderRec.FolderRec[PropTag.ReplicaList] as byte[]; if (array != null) { StorePropertyDefinition replicaList = CoreFolderSchema.ReplicaList; string[] stringArrayFromBytes = ReplicaListProperty.GetStringArrayFromBytes(array); Guid a; return(stringArrayFromBytes.Length > 0 && GuidHelper.TryParseGuid(stringArrayFromBytes[0], out a) && a == base.TargetMailboxGuid); } return(true); }
private void CopyFolderPropertiesAndContents(FolderMapping folder, FolderContentsCrawler sourceFolderCrawler, bool shouldCopyProperties, TimeSpan maxOperationDuration) { PagedMergeJob.< > c__DisplayClass1 CS$ < > 8__locals1 = new PagedMergeJob.< > c__DisplayClass1(); CS$ < > 8__locals1.folder = folder; CS$ < > 8__locals1.sourceFolderCrawler = sourceFolderCrawler; CS$ < > 8__locals1.shouldCopyProperties = shouldCopyProperties; CS$ < > 8__locals1.maxOperationDuration = maxOperationDuration; CS$ < > 8__locals1.< > 4__this = this; using (IDestinationFolder destFolder = base.MailboxMerger.DestMailbox.GetFolder(CS$ < > 8__locals1.folder.TargetFolder.EntryId)) { if (destFolder == null) { base.Report.Append(MrsStrings.ReportTargetFolderDeleted(CS$ < > 8__locals1.folder.TargetFolder.FullFolderName, TraceUtils.DumpEntryId(CS$ < > 8__locals1.folder.TargetFolder.EntryId), CS$ < > 8__locals1.folder.FullFolderName)); return; } ExecutionContext.Create(new DataContext[] { new FolderRecWrapperDataContext(CS$ < > 8__locals1.folder) }).Execute(delegate