{
public partial class AsyncCompletedEventArgs : System.EventArgs
{
- public AsyncCompletedEventArgs(System.Exception error, bool cancelled, object userState) { }
+ public AsyncCompletedEventArgs(System.Exception? error, bool cancelled, object? userState) { }
public bool Cancelled { get { throw null; } }
- public System.Exception Error { get { throw null; } }
- public object UserState { get { throw null; } }
+ public System.Exception? Error { get { throw null; } }
+ public object? UserState { get { throw null; } }
protected void RaiseExceptionIfNecessary() { }
}
- public delegate void AsyncCompletedEventHandler(object sender, System.ComponentModel.AsyncCompletedEventArgs e);
+ public delegate void AsyncCompletedEventHandler(object? sender, System.ComponentModel.AsyncCompletedEventArgs e);
public sealed partial class AsyncOperation
{
internal AsyncOperation() { }
public System.Threading.SynchronizationContext SynchronizationContext { get { throw null; } }
- public object UserSuppliedState { get { throw null; } }
+ public object? UserSuppliedState { get { throw null; } }
~AsyncOperation() { }
public void OperationCompleted() { }
- public void Post(System.Threading.SendOrPostCallback d, object arg) { }
- public void PostOperationCompleted(System.Threading.SendOrPostCallback d, object arg) { }
+ public void Post(System.Threading.SendOrPostCallback d, object? arg) { }
+ public void PostOperationCompleted(System.Threading.SendOrPostCallback d, object? arg) { }
}
public static partial class AsyncOperationManager
{
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
public static System.Threading.SynchronizationContext SynchronizationContext { get { throw null; } set { } }
- public static System.ComponentModel.AsyncOperation CreateOperation(object userSuppliedState) { throw null; }
+ public static System.ComponentModel.AsyncOperation CreateOperation(object? userSuppliedState) { throw null; }
}
public partial class BackgroundWorker : System.ComponentModel.Component
{
public bool IsBusy { get { throw null; } }
public bool WorkerReportsProgress { get { throw null; } set { } }
public bool WorkerSupportsCancellation { get { throw null; } set { } }
- public event System.ComponentModel.DoWorkEventHandler DoWork { add { } remove { } }
- public event System.ComponentModel.ProgressChangedEventHandler ProgressChanged { add { } remove { } }
- public event System.ComponentModel.RunWorkerCompletedEventHandler RunWorkerCompleted { add { } remove { } }
+ public event System.ComponentModel.DoWorkEventHandler? DoWork { add { } remove { } }
+ public event System.ComponentModel.ProgressChangedEventHandler? ProgressChanged { add { } remove { } }
+ public event System.ComponentModel.RunWorkerCompletedEventHandler? RunWorkerCompleted { add { } remove { } }
public void CancelAsync() { }
protected override void Dispose(bool disposing) { }
protected virtual void OnDoWork(System.ComponentModel.DoWorkEventArgs e) { }
protected virtual void OnProgressChanged(System.ComponentModel.ProgressChangedEventArgs e) { }
protected virtual void OnRunWorkerCompleted(System.ComponentModel.RunWorkerCompletedEventArgs e) { }
public void ReportProgress(int percentProgress) { }
- public void ReportProgress(int percentProgress, object userState) { }
+ public void ReportProgress(int percentProgress, object? userState) { }
public void RunWorkerAsync() { }
- public void RunWorkerAsync(object argument) { }
+ public void RunWorkerAsync(object? argument) { }
}
public partial class DoWorkEventArgs : System.ComponentModel.CancelEventArgs
{
- public DoWorkEventArgs(object argument) { }
- public object Argument { get { throw null; } }
- public object Result { get { throw null; } set { } }
+ public DoWorkEventArgs(object? argument) { }
+ public object? Argument { get { throw null; } }
+ public object? Result { get { throw null; } set { } }
}
- public delegate void DoWorkEventHandler(object sender, System.ComponentModel.DoWorkEventArgs e);
+ public delegate void DoWorkEventHandler(object? sender, System.ComponentModel.DoWorkEventArgs e);
public partial class ProgressChangedEventArgs : System.EventArgs
{
- public ProgressChangedEventArgs(int progressPercentage, object userState) { }
+ public ProgressChangedEventArgs(int progressPercentage, object? userState) { }
public int ProgressPercentage { get { throw null; } }
- public object UserState { get { throw null; } }
+ public object? UserState { get { throw null; } }
}
- public delegate void ProgressChangedEventHandler(object sender, System.ComponentModel.ProgressChangedEventArgs e);
+ public delegate void ProgressChangedEventHandler(object? sender, System.ComponentModel.ProgressChangedEventArgs e);
public partial class RunWorkerCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs
{
- public RunWorkerCompletedEventArgs(object result, System.Exception error, bool cancelled) : base (default(System.Exception), default(bool), default(object)) { }
- public object Result { get { throw null; } }
+ public RunWorkerCompletedEventArgs(object? result, System.Exception? error, bool cancelled) : base (default(System.Exception), default(bool), default(object)) { }
+ public object? Result { get { throw null; } }
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
- public new object UserState { get { throw null; } }
+ public new object? UserState { get { throw null; } }
}
- public delegate void RunWorkerCompletedEventHandler(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e);
+ public delegate void RunWorkerCompletedEventHandler(object? sender, System.ComponentModel.RunWorkerCompletedEventArgs e);
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
+ <Nullable>enable</Nullable>
<Configurations>netcoreapp-Debug;netcoreapp-Release</Configurations>
</PropertyGroup>
<ItemGroup>
<PropertyGroup>
<RootNamespace>System.ComponentModel.EventBasedAsync</RootNamespace>
<AssemblyName>System.ComponentModel.EventBasedAsync</AssemblyName>
+ <Nullable>enable</Nullable>
<Configurations>netcoreapp-Debug;netcoreapp-Release</Configurations>
</PropertyGroup>
<ItemGroup>
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
using System.Reflection;
namespace System.ComponentModel
{
- public delegate void AsyncCompletedEventHandler(object sender, AsyncCompletedEventArgs e);
+ public delegate void AsyncCompletedEventHandler(object? sender, AsyncCompletedEventArgs e);
public class AsyncCompletedEventArgs : EventArgs
{
- public AsyncCompletedEventArgs(Exception error, bool cancelled, object userState)
+ public AsyncCompletedEventArgs(Exception? error, bool cancelled, object? userState)
{
- _cancelled = cancelled;
- _error = error;
- _state = userState;
+ Cancelled = cancelled;
+ Error = error;
+ UserState = userState;
}
protected void RaiseExceptionIfNecessary()
}
}
- public bool Cancelled { get { return _cancelled; } }
- public Exception Error { get { return _error; } }
- public object UserState { get { return _state; } }
-
- private readonly bool _cancelled;
- private readonly Exception _error;
- private readonly object _state;
-
+ public bool Cancelled { get; }
+ public Exception? Error { get; }
+ public object? UserState { get; }
}
}
public sealed class AsyncOperation
{
private readonly SynchronizationContext _syncContext;
- private readonly object _userSuppliedState;
private bool _alreadyCompleted;
/// <summary>
/// Constructor. Protected to avoid unwitting usage - AsyncOperation objects
/// are typically created by AsyncOperationManager calling CreateOperation.
/// </summary>
- private AsyncOperation(object userSuppliedState, SynchronizationContext syncContext)
+ private AsyncOperation(object? userSuppliedState, SynchronizationContext syncContext)
{
- _userSuppliedState = userSuppliedState;
+ UserSuppliedState = userSuppliedState;
_syncContext = syncContext;
_alreadyCompleted = false;
_syncContext.OperationStarted();
}
}
- public object UserSuppliedState
- {
- get
- {
- return _userSuppliedState;
- }
- }
+ public object? UserSuppliedState { get; }
public SynchronizationContext SynchronizationContext
{
}
}
- public void Post(SendOrPostCallback d, object arg)
+ public void Post(SendOrPostCallback d, object? arg)
{
PostCore(d, arg, markCompleted: false);
}
- public void PostOperationCompleted(SendOrPostCallback d, object arg)
+ public void PostOperationCompleted(SendOrPostCallback d, object? arg)
{
PostCore(d, arg, markCompleted: true);
OperationCompletedCore();
OperationCompletedCore();
}
- private void PostCore(SendOrPostCallback d, object arg, bool markCompleted)
+ private void PostCore(SendOrPostCallback d, object? arg, bool markCompleted)
{
VerifyNotCompleted();
VerifyDelegateNotNull(d);
/// <summary>
/// Only for use by AsyncOperationManager to create new AsyncOperation objects
/// </summary>
- internal static AsyncOperation CreateOperation(object userSuppliedState, SynchronizationContext syncContext)
+ internal static AsyncOperation CreateOperation(object? userSuppliedState, SynchronizationContext syncContext)
{
AsyncOperation newOp = new AsyncOperation(userSuppliedState, syncContext);
return newOp;
{
public static class AsyncOperationManager
{
- public static AsyncOperation CreateOperation(object userSuppliedState)
+ public static AsyncOperation CreateOperation(object? userSuppliedState)
{
return AsyncOperation.CreateOperation(userSuppliedState, SynchronizationContext);
}
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}
- return SynchronizationContext.Current;
+ return SynchronizationContext.Current!;
}
// a thread should set this to null when it is done, else the context will never be disposed/GC'd
public class BackgroundWorker : Component
{
// Private instance members
- private bool _canCancelWorker = false;
- private bool _workerReportsProgress = false;
- private bool _cancellationPending = false;
- private bool _isRunning = false;
- private AsyncOperation _asyncOperation = null;
+ private bool _canCancelWorker;
+ private bool _workerReportsProgress;
+ private bool _cancellationPending;
+ private bool _isRunning;
+ private AsyncOperation? _asyncOperation;
private readonly SendOrPostCallback _operationCompleted;
private readonly SendOrPostCallback _progressReporter;
public BackgroundWorker()
{
- _operationCompleted = new SendOrPostCallback(AsyncOperationCompleted);
- _progressReporter = new SendOrPostCallback(ProgressReporter);
+ _operationCompleted = new SendOrPostCallback(AsyncOperationCompleted!);
+ _progressReporter = new SendOrPostCallback(ProgressReporter!);
}
private void AsyncOperationCompleted(object arg)
_cancellationPending = true;
}
- public event DoWorkEventHandler DoWork;
+ public event DoWorkEventHandler? DoWork;
public bool IsBusy
{
protected virtual void OnDoWork(DoWorkEventArgs e)
{
- DoWorkEventHandler handler = DoWork;
- if (handler != null)
- {
- handler(this, e);
- }
+ DoWork?.Invoke(this, e);
}
protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
{
- RunWorkerCompletedEventHandler handler = RunWorkerCompleted;
- if (handler != null)
- {
- handler(this, e);
- }
+ RunWorkerCompleted?.Invoke(this, e);
}
protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
{
- ProgressChangedEventHandler handler = ProgressChanged;
- if (handler != null)
- {
- handler(this, e);
- }
+ ProgressChanged?.Invoke(this, e);
}
- public event ProgressChangedEventHandler ProgressChanged;
+ public event ProgressChangedEventHandler? ProgressChanged;
// Gets invoked through the AsyncOperation on the proper thread.
private void ProgressReporter(object arg)
}
// Cause progress update to be posted through current AsyncOperation.
- public void ReportProgress(int percentProgress, object userState)
+ public void ReportProgress(int percentProgress, object? userState)
{
if (!WorkerReportsProgress)
{
RunWorkerAsync(null);
}
- public void RunWorkerAsync(object argument)
+ public void RunWorkerAsync(object? argument)
{
if (_isRunning)
{
_asyncOperation = AsyncOperationManager.CreateOperation(null);
Task.Factory.StartNew(
- (arg) => WorkerThreadStart(arg),
+ arg => WorkerThreadStart(arg),
argument,
CancellationToken.None,
TaskCreationOptions.DenyChildAttach,
);
}
- public event RunWorkerCompletedEventHandler RunWorkerCompleted;
+ public event RunWorkerCompletedEventHandler? RunWorkerCompleted;
public bool WorkerReportsProgress
{
}
}
- private void WorkerThreadStart(object argument)
+ private void WorkerThreadStart(object? argument)
{
Debug.Assert(_asyncOperation != null, "_asyncOperation not initialized");
- object workerResult = null;
- Exception error = null;
+ object? workerResult = null;
+ Exception? error = null;
bool cancelled = false;
try
namespace System.ComponentModel
{
- public delegate void DoWorkEventHandler(object sender, DoWorkEventArgs e);
+ public delegate void DoWorkEventHandler(object? sender, DoWorkEventArgs e);
public class DoWorkEventArgs : CancelEventArgs
{
- public DoWorkEventArgs(object argument)
+ public DoWorkEventArgs(object? argument)
{
Argument = argument;
}
- public object Argument { get; }
+ public object? Argument { get; }
- public object Result { get; set; }
+ public object? Result { get; set; }
}
}
public class ProgressChangedEventArgs : EventArgs
{
private readonly int _progressPercentage;
- private readonly object _userState;
+ private readonly object? _userState;
- public ProgressChangedEventArgs(int progressPercentage, object userState)
+ public ProgressChangedEventArgs(int progressPercentage, object? userState)
{
_progressPercentage = progressPercentage;
_userState = userState;
}
}
- public object UserState
+ public object? UserState
{
get
{
namespace System.ComponentModel
{
- public delegate void RunWorkerCompletedEventHandler(object sender, RunWorkerCompletedEventArgs e);
+ public delegate void RunWorkerCompletedEventHandler(object? sender, RunWorkerCompletedEventArgs e);
public class RunWorkerCompletedEventArgs : AsyncCompletedEventArgs
{
- private readonly object _result;
+ private readonly object? _result;
- public RunWorkerCompletedEventArgs(object result,
- Exception error,
+ public RunWorkerCompletedEventArgs(object? result,
+ Exception? error,
bool cancelled)
: base(error, cancelled, null)
{
_result = result;
}
- public object Result
+ public object? Result
{
get
{
// Hide from editor, since never used.
[EditorBrowsable(EditorBrowsableState.Never)]
- public new object UserState
+ public new object? UserState
{
get
{
projects / platform / upstream / dotnet / runtime.git / commitdiff