<PackageReference Include="System.Reactive" Version="6.0.0-preview.13" />
    
    
	
	
		
		
		
	 
	
	
        
                
                ClassicEventProducer<TDelegate, TArgs>
                
                
                
                
using System.
Reactive.
Concurrency;
using System.
Reactive.
Disposables;
using System.
Runtime.
CompilerServices;
namespace System.
Reactive.
Linq.
ObservableImpl
{
    [
System.
Runtime.
CompilerServices.
NullableContext(
1)]
    [
System.
Runtime.
CompilerServices.
Nullable(
new byte[] {
        
0,
        
1,
        
1
    })]
    
internal abstract class ClassicEventProducer<[
System.
Runtime.
CompilerServices.
Nullable(
2)] 
TDelegate, [
System.
Runtime.
CompilerServices.
Nullable(
2)] 
TArgs> : 
EventProducer<
TDelegate, 
TArgs>
    {
        
private readonly Action<
TDelegate> 
_addHandler;
        
private readonly Action<
TDelegate> 
_removeHandler;
        
protected ClassicEventProducer(
Action<
TDelegate> 
addHandler, 
Action<
TDelegate> 
removeHandler, 
IScheduler scheduler)
            : 
base(
scheduler)
        {
            
_addHandler = 
addHandler;
            
_removeHandler = 
removeHandler;
        }
        
protected override IDisposable AddHandler(
TDelegate handler)
        {
            
_addHandler(
handler);
            
return Disposable.
Create<(
Action<
TDelegate>, 
TDelegate)>((
_removeHandler, 
handler), (
Action<(
Action<
TDelegate>, 
TDelegate)>)
delegate((
Action<
TDelegate> 
_removeHandler, 
TDelegate handler) 
tuple) {
                
tuple.
_removeHandler(
tuple.
handler);
            });
        }
    }
}