Question

How I could convert the MainEngine Observable to Cold ? from this example:

    public IObservable<int> MainEngine
    {
        get
        {
            Random rnd = new Random();
            int maxValue = rnd.Next(20);
            System.Diagnostics.Trace.TraceInformation("Max value is: " + maxValue.ToString());

            return (from sinlgeInt in Enumerable.Range(0, maxValue)
                    select sinlgeInt).ToObservable();
        }
    }

    public void Main()
    {
        // 1
        MainEngine.Subscribe(
                onNext: (item) => { System.Diagnostics.Trace.TraceInformation("Value is: " + item.ToString()); }
        );

        // 2
        MainEngine.Subscribe(
                onNext: (item) => { System.Diagnostics.Trace.TraceInformation("Gonna put it into XML: " + item.ToString()); }
        );
    }

Question 1: On subscriber 1 and subscriber 2 I get a different results but I want both of them receive the same results.

Question 2: From the point in time when I add the second subscriber both of them continue to receive the same results.

Answer 1

Regarding your first question, the issue is that the observers are not subscribing to the same IObservable since you call the getter twice.

Assigning the IObservable to a local variable seems to fix the issue:

IObservable<int> mainEngine = MainEngine;

mainEngine.Subscribe(onNext: (item) => { /* ... */ });
mainEngine.Subscribe(onNext: (item) => { /* ... */ });  

Regarding your second question, if you would like to share a subcription to a single IObservable, you can use the Publish method:

IConnectableObservable<int> published = MainEngine.Publish();

published.Subscribe(onNext: (item) => { Console.WriteLine(item + " on observer 1"); });
published.Subscribe(onNext: (item) => { Console.WriteLine(item + " on observer 2"); });

published.Connect();

The two subscribers will then see the results from the IObservable in an interleaved fashion:

0 on observer 1
0 on observer 2
1 on observer 1
1 on observer 2
etc.

You can also subscribe new observers after the call to Subscribe, after which point all subscribers will see the same events. You can modify your example to test this, by running your observable on a new thread and introducing a delay:

public static void Main()
{
    Random rnd = new Random();
    int maxValue = rnd.Next(20);

    /* Zip with Observable.Interval to introduce a delay */
    IObservable<int> mainEngine = Observable.Range(0, maxValue, Scheduler.NewThread)
        .Zip(Observable.Interval(TimeSpan.FromMilliseconds(100)), (a, b) => a);

    /* Publish the observable to share a subscription between observers */
    IConnectableObservable<int> published = mainEngine.Publish();

    /* Subscribe the first observer immediately, events are not yet being observed */
    published.Subscribe(onNext: (item) => { Console.WriteLine(item + " on observer 1"); });

    /* Start pushing events to the first observer */
    published.Connect();

    /* Wait one second and then subscribe the second observer */
    Thread.Sleep(1000);
    published.Subscribe(onNext: (item) => { Console.WriteLine(item + " on observer 2"); });

    Console.ReadKey();
}

You will see one second’s worth of events only on the first observer, and then both observers will see each event simultaneously.