what is difference between _ and ()?

[INTERNALINTERFERENCE]

I have following in constructor:

var initialize = ReactiveCommand.CreateFromTask( async () =>                     
 {                                                                                
     const string databaseFileName = "log.db";                                    
     var databaseFilePath = Path.Combine( Path.GetTempPath(), databaseFileName ); 
     var database = new SQLiteAsyncConnection(databaseFilePath);                  
                                                                                  
     await database.CreateTableAsync<MqttDelivery>();                             
 } );                                                                             
 initialize.Subscribe();                                                          
 initialize.Execute();                                                            

 var initialize = ReactiveCommand.CreateFromTask( async _ =>                     
 {                                                                                
     const string databaseFileName = "log.db";                                    
     var databaseFilePath = Path.Combine( Path.GetTempPath(), databaseFileName ); 
     var database = new SQLiteAsyncConnection(databaseFilePath);                  
                                                                                  
     await database.CreateTableAsync<MqttDelivery>();                             
 } );                                                                             
 initialize.Subscribe();                                                          
 initialize.Execute();     

the first one will be executed
second one will be skipped

why?

[glennawatson]

Execute() returns a IObservable. You need to Subscribe() to it to have it execute. The observable is lazy and won't execute straight away. You can subscribe multiple times to have it execute again is a major difference as well.

[INTERNALINTERFERENCE]

yes, it works
but it's a little bit strange behavior because first one in my code works well

[glennawatson]

It's a IObservable so you can pass around etc and use in normal observable chains. So it's normal behaviour

[INTERNALINTERFERENCE]

if I can pass around etc why the second one doesn't work? I really don't understand why discarding parameter can break the logic with executing. I sent two versions of functions which can be called in constructor and only first one with () works well

[glennawatson]

The subscribe direct on the command doesn't take a parameter. Execute generates an observable based on the passed in parameter. It's an observable so it's lazy so won't run until subscribed.

[INTERNALINTERFERENCE]

ah okey I see, thanks

[INTERNALINTERFERENCE]

I have another small question:
TestCommand.Execute();
TestCommand.Subscribe();
is it the same as: TestCommand.Execute().Subscribe(); ?

[glennawatson]

TestCommand.Subscribe();

Is the same as

TestCommand.Execute().Subscribe();

You don't need the Execute() on its own beforehand for the Aubscribe direct to the command.

[Antonbreakble]

Hello. There is a place to be a little misunderstanding.
If I Execute() command like this:

TestCommand = ReactiveCommand.CreateFromTask(async () => {
            //some async operation
        });
TestCommand.Execute();

Task fired immediately (ReactiveUI ver 13.2.10 with Avalonia app). Because CreateFromTask for non cancellation token command return execute().ToObservable() which fired observable immediately.

But, if I use method which takes Func<CancellationToken, Task<TResult>> for create ReactiveCommand then Execute() call not fired Task. And everything works as described in the documentation, that is, a cold task is created.
Example:

TestCommand = ReactiveCommand.CreateFromTask(async _ => {
            //some async operation
        });
TestCommand.Execute();

Execute() here create IObservable with cold task because CreateFromTask method return Observable.FromAsync(execute)