protected virtual PartialOrder ComparePartialOrder(RefreshRequestEventArgs leftValue, RefreshRequestEventArgs rightValue)
{
PartialOrder result = int.MinValue;
if (leftValue.IsFullRefresh)
{
result = (rightValue.IsFullRefresh ? 0 : 1);
}
else if (rightValue.IsFullRefresh)
{
result = -1;
}
else
{
PartialRefreshRequestEventArgs partialRefreshRequestEventArgs = leftValue as PartialRefreshRequestEventArgs;
PartialRefreshRequestEventArgs partialRefreshRequestEventArgs2 = rightValue as PartialRefreshRequestEventArgs;
if (!partialRefreshRequestEventArgs.Identities.IsEmptyCollection() && !partialRefreshRequestEventArgs2.Identities.IsEmptyCollection())
{
if (partialRefreshRequestEventArgs.Identities.Length > partialRefreshRequestEventArgs2.Identities.Length)
{
if (RefreshableComponent.IsSubsetOf(partialRefreshRequestEventArgs.Identities, partialRefreshRequestEventArgs2.Identities))
{
result = 1;
}
}
else if (RefreshableComponent.IsSubsetOf(partialRefreshRequestEventArgs2.Identities, partialRefreshRequestEventArgs.Identities))
{
result = -1;
}
}
}
return(result);
}
protected override PartialOrder ComparePartialOrder(RefreshRequestEventArgs leftValue, RefreshRequestEventArgs rightValue)
{
if (this.ResultsLoaderProfile != null && this.ResultsLoaderProfile.InputTablePartialOrderComparer != null)
{
return(this.ResultsLoaderProfile.InputTablePartialOrderComparer.Compare((leftValue.Argument as ResultsLoaderProfile).InputTable, (rightValue.Argument as ResultsLoaderProfile).InputTable));
}
return(base.ComparePartialOrder(leftValue, rightValue));
}
protected override void DoPostRefreshAction(RefreshRequestEventArgs refreshRequest)
{
ResultsLoaderProfile resultsLoaderProfile = refreshRequest.Argument as ResultsLoaderProfile;
if (resultsLoaderProfile != null && resultsLoaderProfile.PostRefreshAction != null)
{
resultsLoaderProfile.PostRefreshAction.DoPostRefreshAction(this, refreshRequest);
}
}
protected virtual void OnCancelFill(RefreshRequestEventArgs e)
{
RefreshRequestEventHandler refreshRequestEventHandler = (RefreshRequestEventHandler)base.Events[DataTableLoader.EventCancelFill];
if (refreshRequestEventHandler != null)
{
refreshRequestEventHandler(this, e);
}
}
protected virtual void OnDoRefreshWork(RefreshRequestEventArgs e)
{
RefreshRequestEventHandler refreshRequestEventHandler = (RefreshRequestEventHandler)base.Events[RefreshableComponent.EventDoRefreshWork];
if (refreshRequestEventHandler != null)
{
refreshRequestEventHandler(this, e);
}
}
protected void RefreshCore(IProgress progress, RefreshRequestEventArgs refreshRequest)
{
ExTraceGlobals.ProgramFlowTracer.TracePerformance <RefreshableComponent, string>(0L, "Time: {1}. Start Refresh in UI thread. -->RefreshableComponent.RefreshCore: {0}. ", this, ExDateTime.Now.ToString("MM/dd/yyyy HH:mm:ss.fff"));
if (!this.IsInitialized || this.IsInCriticalState)
{
progress.ReportProgress(100, 100, string.Empty);
return;
}
this.EnqueueRequest(progress, refreshRequest);
}
public RefreshProgressChangedEventArgs(RefreshRequestEventArgs request, int workProcessed, int totalWork, string statusText, object userState) : base(RefreshProgressChangedEventArgs.GetPercentage(workProcessed, totalWork), userState)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
this.request = request;
this.workProcessed = workProcessed;
this.totalWork = totalWork;
this.statusText = statusText;
this.isFirstProgressReport = !request.ReportedProgress;
}
private void CancelRefresh(RefreshRequestEventArgs refreshRequest)
{
if (refreshRequest.CancellationPending || refreshRequest.Cancel)
{
return;
}
if (refreshRequest.BackgroundWorker.IsBusy)
{
refreshRequest.BackgroundWorker.CancelAsync();
return;
}
refreshRequest.Cancel = true;
}
public void Refresh(IProgress progress)
{
CancelEventArgs cancelEventArgs = new CancelEventArgs();
this.OnRefreshStarting(cancelEventArgs);
if (!cancelEventArgs.Cancel)
{
RefreshRequestEventArgs refreshRequest = this.CreateFullRefreshRequest(progress);
this.RefreshCore(progress, refreshRequest);
return;
}
progress.ReportProgress(100, 100, string.Empty);
}
private void ProcessRequest(RefreshRequestEventArgs refreshRequest)
{
BackgroundWorker backgroundWorker = refreshRequest.BackgroundWorker;
backgroundWorker.WorkerReportsProgress = true;
backgroundWorker.WorkerSupportsCancellation = true;
backgroundWorker.DoWork += this.worker_DoWork;
backgroundWorker.RunWorkerCompleted += this.worker_RunWorkerCompleted;
backgroundWorker.ProgressChanged += this.worker_ProgressChanged;
SynchronizationContext.SetSynchronizationContext(new WindowsFormsSynchronizationContext());
backgroundWorker.RunWorkerAsync(refreshRequest);
this.Refreshing = true;
this.OnRefreshStarted(EventArgs.Empty);
}
protected override void OnFillTable(RefreshRequestEventArgs e)
{
DataTable dataTable = (DataTable)e.Result;
if (this.Mvp != null)
{
foreach (object obj in ((IEnumerable)this.Mvp))
{
dataTable.Rows.Add(new object[]
{
obj
});
}
}
base.OnFillTable(e);
}
private void worker_DoWork(object sender, DoWorkEventArgs e)
{
ExTraceGlobals.ProgramFlowTracer.TracePerformance <RefreshableComponent, string, string>(0L, "Time:{1}. Start Refresh {2} in worker thread. -->RefreshableComponent.worker_DoWork: {0}", this, ExDateTime.Now.ToString("MM/dd/yyyy HH:mm:ss.fff"), (this is DataTableLoader) ? (this as DataTableLoader).Table.TableName : string.Empty);
RefreshRequestEventArgs refreshRequestEventArgs = (RefreshRequestEventArgs)e.Argument;
try
{
this.OnDoRefreshWork(refreshRequestEventArgs);
}
finally
{
refreshRequestEventArgs.ShellProgress.ReportProgress(100, 100, "");
}
e.Result = refreshRequestEventArgs.Result;
e.Cancel = refreshRequestEventArgs.CancellationPending;
ExTraceGlobals.ProgramFlowTracer.TracePerformance <RefreshableComponent, string, string>(0L, "Time:{1}. End Refresh {2} in worker thread. <--RefreshableComponent.worker_DoWork: {0}", this, ExDateTime.Now.ToString("MM/dd/yyyy HH:mm:ss.fff"), (this is DataTableLoader) ? (this as DataTableLoader).Table.TableName : string.Empty);
}
private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
RefreshRequestEventArgs refreshRequestEventArgs = this.refreshRequestQueue[0];
if (!refreshRequestEventArgs.Cancel)
{
this.DoPostRefreshAction(refreshRequestEventArgs);
}
this.refreshRequestQueue.RemoveAt(0);
List <RefreshRequestEventArgs> list = new List <RefreshRequestEventArgs>();
while (this.refreshRequestQueue.Count > 0 && this.refreshRequestQueue[0].Cancel)
{
list.Add(this.refreshRequestQueue[0]);
this.refreshRequestQueue.RemoveAt(0);
}
if (this.refreshRequestQueue.Count > 0)
{
this.ProcessRequest(this.refreshRequestQueue[0]);
}
else
{
this.Refreshing = false;
}
this.isInCriticalState = true;
try
{
if (e.Error != null && this.UIService != null)
{
this.UIService.ShowError(e.Error);
}
}
finally
{
this.isInCriticalState = false;
}
this.OnRefreshCompleted(e);
foreach (RefreshRequestEventArgs refreshRequestEventArgs2 in list)
{
refreshRequestEventArgs2.ShellProgress.ReportProgress(100, 100, "");
this.OnRefreshCompleted(new RunWorkerCompletedEventArgs(null, null, true));
}
ExTraceGlobals.ProgramFlowTracer.TracePerformance <RefreshableComponent, string>(0L, "Time:{1}. End Refresh in UI thread. <--RefreshableComponent.worker_RunWorkerCompleted: {0}", this, ExDateTime.Now.ToString("MM/dd/yyyy HH:mm:ss.fff"));
}
private void Cancel(RefreshRequestEventArgs e)
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "-->DataTableLoader.Cancel: {0}", this);
IDbCommand dbCommand = e.Argument as IDbCommand;
if (dbCommand != null)
{
ExTraceGlobals.ProgramFlowTracer.TraceDebug <DataTableLoader, IDbCommand>((long)this.GetHashCode(), "DataTableLoader.Cancel: {0} cancelling IDbCommand: {1}", this, dbCommand);
dbCommand.Cancel();
}
ResultsLoaderProfile resultsLoaderProfile = e.Argument as ResultsLoaderProfile;
if (resultsLoaderProfile != null)
{
foreach (AbstractDataTableFiller abstractDataTableFiller in resultsLoaderProfile.TableFillers)
{
abstractDataTableFiller.Cancel();
}
}
this.OnCancelFill(e);
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "<--DataTableLoader.Cancel: {0}", this);
}
private void EnqueueRequest(IProgress progress, RefreshRequestEventArgs refreshRequest)
{
int num = 0;
bool flag = false;
foreach (RefreshRequestEventArgs refreshRequestEventArgs in this.refreshRequestQueue)
{
if (refreshRequest.Priority < refreshRequestEventArgs.Priority)
{
if (flag)
{
break;
}
}
else if (refreshRequest.Priority == refreshRequestEventArgs.Priority && !refreshRequestEventArgs.Cancel)
{
PartialOrder partialOrder = this.ComparePartialOrder(refreshRequest, refreshRequestEventArgs);
if (partialOrder == null || partialOrder == 1)
{
this.CancelRefresh(refreshRequestEventArgs);
}
else if (partialOrder == -1 && flag)
{
this.CancelRefresh(refreshRequest);
break;
}
}
num++;
flag = true;
}
this.refreshRequestQueue.Insert(num, refreshRequest);
if (this.refreshRequestQueue.Count == 1)
{
this.ProcessRequest(refreshRequest);
}
}
protected virtual void DoPostRefreshAction(RefreshRequestEventArgs refreshRequest)
{
}
private void ReportDataTable(int rowCount, int expectedRowCount, DataTable dataTable, RefreshRequestEventArgs e, bool resolved, TimeSpan elapsed)
{
ResultsLoaderProfile resultsLoaderProfile = e.Argument as ResultsLoaderProfile;
this.FillColumnsBasedOnLambdaExpression(dataTable, resultsLoaderProfile);
ColumnValueCalculator.CalculateAll(dataTable);
DataTable dataTable2 = this.MoveRows(dataTable, null, false);
if (resultsLoaderProfile != null && resolved && resultsLoaderProfile.IsResolving)
{
foreach (object obj in resultsLoaderProfile.PipelineObjects)
{
if (this.FindRowByIdentity(dataTable2, obj) != null)
{
resultsLoaderProfile.ResolvedObjects.Add(obj);
}
}
}
ExTraceGlobals.ProgramFlowTracer.TraceFunction((long)this.GetHashCode(), "-->DataTableLoader.ReportDataTable: report batch: {0}. progressReportTable.Rows.Count:{1}, this.BatchSize:{2}, rowCount:{3}, expectedRowCount:{4}. ElapsedTime:{5}", new object[]
{
this,
dataTable2.Rows.Count,
this.BatchSize,
rowCount,
expectedRowCount,
elapsed
});
if (!e.ReportedProgress)
{
ExTraceGlobals.ProgramFlowTracer.TracePerformance <DataTableLoader, string, string>(0L, "Time:{1}. {2} First batch data arrived in worker thread. {0}", this, ExDateTime.Now.ToString("MM/dd/yyyy HH:mm:ss.fff"), (this != null) ? this.Table.TableName : string.Empty);
}
e.ReportProgress(rowCount, expectedRowCount, this.ProgressText, dataTable2);
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "<--DataTableLoader.ReportDataTable: report batch: {0}", this);
}
protected override void OnDoRefreshWork(RefreshRequestEventArgs e)
{
Stopwatch sw = Stopwatch.StartNew();
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "-->DataTableLoader.OnDoRefreshWork: {0}", this);
this.expressionCalculator = null;
DataTable dataTable = (e as DataTableLoader.IDataTableLoaderRefreshRequest).DataTable.Clone();
e.Result = dataTable;
dataTable.RowChanging += delegate(object param0, DataRowChangeEventArgs param1)
{
if (e.CancellationPending)
{
e.Cancel = true;
this.Cancel(e);
e.Result = dataTable;
}
};
int rowCount = 0;
int expectedRowCount = Math.Max(this.lastRowCount, this.BatchSize);
ResultsLoaderProfile profile = e.Argument as ResultsLoaderProfile;
if (profile != null)
{
foreach (AbstractDataTableFiller abstractDataTableFiller in profile.TableFillers)
{
abstractDataTableFiller.FillCompleted += delegate(object sender, FillCompletedEventArgs args)
{
AbstractDataTableFiller filler = sender as AbstractDataTableFiller;
if (this.IsPreFillForResolving(filler) || profile.FillType == null)
{
expectedRowCount = Math.Max(expectedRowCount, rowCount + this.BatchSize + 1);
bool flag = !this.IsPreFillForResolving(filler) && profile.FillType == 0;
this.ReportDataTable(rowCount, expectedRowCount, args.DataTable, e, flag, sw.Elapsed);
if (profile.IsResolving && profile.PipelineObjects != null && flag)
{
foreach (object obj in profile.PipelineObjects)
{
if (this.FindRowByIdentity(args.DataTable, obj) != null)
{
profile.ResolvedObjects.Add(obj);
}
}
IEnumerable <object> source = from id in profile.PipelineObjects
where !profile.ResolvedObjects.Contains(id)
select id;
profile.PipelineObjects = source.ToArray <object>();
profile.ResolvedObjects.Clear();
}
}
};
}
}
dataTable.RowChanged += delegate(object sender, DataRowChangeEventArgs rowChangedEvent)
{
if (rowChangedEvent.Action == DataRowAction.Add)
{
rowCount++;
ExTraceGlobals.DataFlowTracer.Information <DataTableLoader, int, TimeSpan>((long)this.GetHashCode(), "DataTableLoader.OnDoRefreshWork: {0}, rowCount:{1}. ElapsedTime:{2}", this, rowCount, sw.Elapsed);
ConvertTypeCalculator.Convert(rowChangedEvent.Row);
if (dataTable.Rows.Count >= this.BatchSize && (profile == null || profile.FillType == null))
{
expectedRowCount = Math.Max(expectedRowCount, rowCount + this.BatchSize + 1);
this.ReportDataTable(rowCount, expectedRowCount, dataTable, e, true, sw.Elapsed);
}
}
};
try
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, TimeSpan>((long)this.GetHashCode(), "-->DataTableLoader.OnDoRefreshWork: Fill: {0}. ElapsedTime:{1}", this, sw.Elapsed);
this.Fill(e);
}
catch (MonadDataAdapterInvocationException ex)
{
if (!(ex.InnerException is ManagementObjectNotFoundException) && !(ex.InnerException is MapiObjectNotFoundException))
{
throw;
}
}
finally
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, TimeSpan>((long)this.GetHashCode(), "<--DataTableLoader.OnDoRefreshWork: Fill: {0}. ElapsedTime:{1}", this, sw.Elapsed);
e.Result = dataTable;
ExTraceGlobals.ProgramFlowTracer.TraceFunction((long)this.GetHashCode(), "-->DataTableLoader.OnDoRefreshWork: report last batch: {0}. dataTable.Rows.Count:{1}, this.BatchSize:{2}, rowCount:{3}, expectedRowCount:{4}", new object[]
{
this,
dataTable.Rows.Count,
this.BatchSize,
rowCount,
rowCount + 1
});
this.FillColumnsBasedOnLambdaExpression(dataTable, e.Argument as ResultsLoaderProfile);
ColumnValueCalculator.CalculateAll(dataTable);
if (!e.ReportedProgress)
{
ExTraceGlobals.ProgramFlowTracer.TracePerformance <DataTableLoader, string, string>(0L, "Time:{1}. {2} First batch data arrived in worker thread. {0}", this, ExDateTime.Now.ToString("MM/dd/yyyy HH:mm:ss.fff"), (this != null) ? this.Table.TableName : string.Empty);
}
e.ReportProgress(rowCount, rowCount + 1, this.ProgressText, this.MoveRows(dataTable, null, false));
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "<--DataTableLoader.OnDoRefreshWork: report last batch: {0}", this);
}
base.OnDoRefreshWork(e);
e.Result = dataTable;
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, TimeSpan>((long)this.GetHashCode(), "<--DataTableLoader.OnDoRefreshWork: {0}. Total ElapsedTime:{1}", this, sw.Elapsed);
}
private void Fill(RefreshRequestEventArgs e)
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "-->DataTableLoader.Fill: {0}", this);
ResultsLoaderProfile profile = e.Argument as ResultsLoaderProfile;
if (profile != null)
{
DataTable dataTable = e.Result as DataTable;
dataTable.RowChanged += delegate(object sender, DataRowChangeEventArgs eventArgs)
{
if (eventArgs.Action == DataRowAction.Add)
{
this.FillPrimaryKeysBasedOnLambdaExpression(eventArgs.Row, profile);
}
};
DataTable dataTable2 = dataTable.Clone();
dataTable2.RowChanged += delegate(object sender, DataRowChangeEventArgs eventArgs)
{
if (eventArgs.Action == DataRowAction.Add)
{
this.FillPrimaryKeysBasedOnLambdaExpression(eventArgs.Row, profile);
}
};
if (!this.EnforeViewEntireForest && !profile.HasPermission())
{
goto IL_26F;
}
using (DataAdapterExecutionContext dataAdapterExecutionContext = this.executionContextFactory.CreateExecutionContext())
{
dataAdapterExecutionContext.Open(base.UIService, this.WorkUnits, this.EnforeViewEntireForest, profile);
foreach (AbstractDataTableFiller filler in profile.TableFillers)
{
if (profile.IsRunnable(filler))
{
if (e.CancellationPending)
{
break;
}
profile.BuildCommand(filler);
if (profile.FillType == 1 || this.IsPreFillForResolving(filler))
{
dataAdapterExecutionContext.Execute(filler, dataTable2, profile);
this.MergeChanges(dataTable2, dataTable);
dataTable2.Clear();
}
else
{
dataAdapterExecutionContext.Execute(filler, dataTable, profile);
}
}
}
goto IL_26F;
}
}
MonadCommand monadCommand = e.Argument as MonadCommand;
if (monadCommand != null)
{
this.AttachCommandToMonitorWarnings(monadCommand);
using (MonadConnection monadConnection = new MonadConnection(PSConnectionInfoSingleton.GetInstance().GetConnectionStringForScript(), new CommandInteractionHandler(), ADServerSettingsSingleton.GetInstance().CreateRunspaceServerSettingsObject(), PSConnectionInfoSingleton.GetInstance().GetMonadConnectionInfo(ExchangeRunspaceConfigurationSettings.SerializationLevel.Full)))
{
monadConnection.Open();
monadCommand.Connection = monadConnection;
using (MonadDataAdapter monadDataAdapter = new MonadDataAdapter(monadCommand))
{
DataTable dataTable3 = (DataTable)e.Result;
if (dataTable3.Columns.Count != 0)
{
monadDataAdapter.MissingSchemaAction = MissingSchemaAction.Ignore;
monadDataAdapter.EnforceDataSetSchema = true;
}
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, MonadCommand>((long)this.GetHashCode(), "-->DataTableLoader.Fill: calling dataAdapter.Fill: {0}. Command:{1}", this, monadCommand);
monadDataAdapter.Fill(dataTable3);
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, MonadCommand>((long)this.GetHashCode(), "<--DataTableLoader.Fill: calling dataAdaptr.Fill: {0}. Command:{1}", this, monadCommand);
}
}
this.DetachCommandFromMonitorWarnings(monadCommand);
}
IL_26F:
this.OnFillTable(e);
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "<--DataTableLoader.Fill: {0}", this);
}
