public void DispatchEvent(MyEvents gridEvent)
{
System.EventHandler <MyEventInfo> eventToDispatch = null;
switch (gridEvent)
{
case MyEvents.Event_1: { eventToDispatch = Event_1; break; }
case MyEvents.Event_2: { eventToDispatch = Event_2; break; }
case MyEvents.Event_3: { eventToDispatch = Event_3; break; }
case MyEvents.Event_4: { eventToDispatch = Event_4; break; }
case MyEvents.Event_5: { eventToDispatch = Event_5; break; }
}
if (eventToDispatch == null)
{
return;
}
var eventInfo = new MyEventInfo()
{
Event = gridEvent
};
eventToDispatch(this, eventInfo);
}
/// <summary>
/// Occurs when the user moves away from the text box containing the stint length
/// </summary>
void stintLength_LostFocus(object sender, EventArgs e)
{
int newStintLaps;
//Validates the input
bool incorrectValue = !int.TryParse(stintLength.Text, out newStintLaps);
if (!incorrectValue)
{
newStintLaps = (int)Functions.ValidateBetweenExclusive(newStintLaps, 0, upperBound, "stint length", ref incorrectValue, true);
}
if (!incorrectValue)
{
thisStrategy.Stints = thisStrategy.ChangeStintLength(stintIndex, newStintLaps);
}
//If something has changed, update the stint and the strategy.
if (newStintLaps != originalLength)
{
originalLength = newStintLaps;
stintLength.LostFocus -= stintLength_LostFocus;
thisStrategy.UpdateStrategyParameters();
MyEvents.OnStrategyModified(thisDriver, thisStrategy, false);
}
}
void UpdateCalendar()
{
var events = MyEvents.Select(i => new CalendarInlineEvent
{
StartTime = i.StartTime.ToLocalTime(),
EndTime = i.StartTime.AddHours(3).ToLocalTime(),//i.EndTime.ToLocalTime(),
Subject = i.Name,
Color = i.RSVPStatus == "attending" ? Color.Blue : Color.Red
});
CalEvents.Clear();
ScheduleEvents.Clear();
foreach (var ev in MyEvents)
{
CalEvents.Add(new CalendarInlineEvent()
{
StartTime = ev.StartTime.ToLocalTime(),
EndTime = ev.EndTime.AddHours(3).ToLocalTime(),
Subject = ev.Name,
Color = ev.RSVPStatus == "attending" ? Color.Blue : Color.Red
});
ScheduleEvents.Add(new ScheduleAppointment()
{
StartTime = ev.StartTime.ToLocalTime(),
EndTime = ev.EndTime.AddHours(3).ToLocalTime(),
Subject = ev.Name,
Notes = ev.Id,
Color = ev.RSVPStatus == "attending" ? Color.Blue : Color.Red
});
}
;
}
void MyPanel_PanelClosed()
{
if (inContentPanel)
{
MyEvents.OnRemoveContentPanel(this.PanelIndex);
}
removed = true;
}
/// <summary>
/// Shows a detailed section of the axes around the specified lap
/// </summary>
/// <param name="displayUpToLap">The lap to show in detail</param>
void ScaleAxes(int displayUpToLap)
{
int displayFromLap = (displayUpToLap - 15 < 0 ? 0 : displayUpToLap - 15);
horizontalAxis.axisLabelSpacing = 1;
horizontalAxis.baseOffset = displayFromLap;
horizontalAxis.scaleFactor = (float)(graphArea.Width) / (float)(displayUpToLap - displayFromLap);
MyEvents.OnAxesComputerGenerated(horizontalAxis, verticalAxis, graphNormalisationType);
}
private async void SetupSampleData()
{
var items = await SampleData.GetEventFeed();
foreach (var item in items)
{
FeatureEvents.Add(item);
MyEvents.Add(item);
AllEvents.Add(item);
}
}
/// <summary>
/// Saves the current settings data and writes it to files if it is valid
/// </summary>
void ConfirmChanges()
{
bool incorrectValue = false;
SaveSettingsData(ref incorrectValue);
if (!incorrectValue)
{
Data.Settings.WriteSettingsData();
}
MyEvents.OnSettingsModified();
}
public void ChangeStintTyreType(int stintToChange, TyreType newTyreType)
{
listOfStints[stintToChange].tyreType = newTyreType;
int lapsThroughRace = listOfStints[stintToChange].startLap;
listOfStints[stintToChange] = PopulateSingleStint(Stints[stintToChange], ref lapsThroughRace);
UpdateStrategyParameters();
MyEvents.OnStrategyModified(Data.Drivers[driverIndex], this, false);
}
void OK_Click(object sender, EventArgs e)
{
//Validate the input
bool incorrectValue = false;
PopulateAxisValues(ref incorrectValue);
if (!incorrectValue) //If all values are within reasonable bounds
{
//Modify the axes
MyEvents.OnAxesChangedByUser(localHorizontalAxis, localVerticalAxis, localNormalisationType);
}
}
/// <summary>
/// Once data is loaded, displays and populates the controls on the panel
/// </summary>
void StrategyViewerData_DataLoaded()
{
MyEvents.OnFinishedLoadingStrategies();
if (!isInitialised)
{
InitialiseControls();
AddToolStrip();
isInitialised = true;
}
DrawGraph(true, true);
DisplayStints(Data.DriverIndex);
}
/// <summary>
/// Sets the axes to default locations proportional to the size of the graph panel
/// </summary>
public void SetupAxes(int raceLaps)
{
horizontalAxis.startLocation = 50;
//Get the available graph area
graphArea = SetGraphArea();
horizontalAxis.baseOffset = 0;
horizontalAxis.scaleFactor = (float)(graphArea.Width) / (float)(raceLaps + 1);
horizontalAxis.axisLabelSpacing = (int)((25 * raceLaps) / (graphArea.Width));
verticalAxis.baseOffset = 0;
verticalAxis.scaleFactor = (float)((graphArea.Height) / 100);
verticalAxis.startLocation = (graphArea.Height / 2) + 10;
verticalAxis.axisLabelSpacing = (int)(50 / verticalAxis.scaleFactor);
MyEvents.OnAxesModified(horizontalAxis, verticalAxis, graphNormalisationType, false);
}
public void DispatchEvent(MyEvents gridEvent)
{
System.EventHandler<MyEventInfo> eventToDispatch = null;
switch (gridEvent)
{
case MyEvents.Event_1: { eventToDispatch = Event_1; break; }
case MyEvents.Event_2: { eventToDispatch = Event_2; break; }
case MyEvents.Event_3: { eventToDispatch = Event_3; break; }
case MyEvents.Event_4: { eventToDispatch = Event_4; break; }
case MyEvents.Event_5: { eventToDispatch = Event_5; break; }
}
if (eventToDispatch == null) return;
var eventInfo = new MyEventInfo() { Event = gridEvent };
eventToDispatch(this, eventInfo);
}
private void AddPitStopToStrategy(int driverIndex, int lapNumber)
{
Strategy thisStrategy = strategyViewerData.GetStrategy(driverIndex);
bool stopWithinRange;
int nearestStop = thisStrategy.GetNearestPitStop(lapNumber, 1, out stopWithinRange);
if (stopWithinRange)
{
thisStrategy.Stints = thisStrategy.RemovePitStop(nearestStop);
}
else
{
thisStrategy.Stints = thisStrategy.AddPitStop(lapNumber);
}
thisStrategy.UpdateStrategyParameters();
MyEvents.OnStrategyModified(Data.Drivers[driverIndex], thisStrategy, false);
}
void StartTimingDataPanel(bool loadFromFile)
{
Model.CalculationControllers.CalculationController.PopulateDriverDataFromFiles(Data.RaceIndex);
Model.CalculationControllers.CalculationController.CalculatePaceParameters();
if (Program.TimeAnalysis != null)
{
RemoveContentPanel(Program.TimeAnalysis);
//If the panel has been started and not initialised (i.e. data not loaded):
if (Program.TimeAnalysis.Removed && Program.TimeAnalysis.IsInitialised)
{
Program.TimeAnalysis.OnPanelClosed(AssociatedForm);
}
}
Program.TimeAnalysis = new PaceParameters(base.AssociatedForm, loadFromFile);
MyEvents.OnFinishedLoadingParameters();
}
public bool AddAvatarPedestalsToTrigger(GameObject MyObjectWithTrigger, List <GameObject> MyAvatarPedestals)
{
VRC_Trigger MyTriggerScript;
List <VRC_Trigger.TriggerEvent> TriggerEvents;
VRC_Trigger.TriggerEvent MyTriggerEvent;
List <VRC_EventHandler.VrcEvent> MyEvents;
VRC_EventHandler.VrcEvent MyEvent;
if (MyObjectWithTrigger == null)
{
CustomMessage = "Select Objects With Trigger If You Want To Toggle Avatar Pedestals By Pressing Button";
return(false);
}
MyTriggerScript = MyObjectWithTrigger.GetComponent <VRC_Trigger>();
if (MyTriggerScript == null)
{
CustomMessage = "Object Does Not Contain A Trigger";
return(false);
}
MyTriggerScript.interactText = "Avatars";
TriggerEvents = MyTriggerScript.Triggers;
MyTriggerEvent = new VRC_Trigger.TriggerEvent();
MyTriggerEvent.TriggerType = VRC_Trigger.TriggerType.OnInteract;
if (bLocalActivateByTrigger)
{
MyTriggerEvent.BroadcastType = VRC_EventHandler.VrcBroadcastType.Local;
}
MyEvents = MyTriggerEvent.Events;
MyEvent = new VRC_EventHandler.VrcEvent();
MyEvent.EventType = VRC_EventHandler.VrcEventType.SetGameObjectActive;
MyEvent.ParameterObjects = MyAvatarPedestals.ToArray();
MyEvent.ParameterBoolOp = VRC_EventHandler.VrcBooleanOp.Toggle;
MyEvents.Add(MyEvent);
TriggerEvents.Add(MyTriggerEvent);
return(true);
}
public async Task GetMyEvents()
{
var feedResultEntity =
await
_eventManager.GetMyEvents(Locator.ViewModels.MainPageVm.CurrentTokens, "inSessionAndUpcoming",
Locator.ViewModels.MainPageVm.CurrentUser.Region);
var result = await ResultChecker.CheckSuccess(feedResultEntity);
if (!result)
{
return;
}
var feedEntity = JsonConvert.DeserializeObject <EventsResponse>(feedResultEntity.ResultJson);
foreach (var feed in feedEntity.Events)
{
MyEvents.Add(feed);
}
}
/// <summary>
/// Handles the button clicked events on any of the buttons within the control.
/// </summary>
/// <param name="controlNumber">The control number that fired the event</param>
void ButtonClicked(int controlNumber)
{
int startLapNumber = thisStrategy.Stints[stintIndex].startLap;
int midLapNumber = (int)((thisStrategy.Stints[stintIndex].stintLength) / 2) + startLapNumber;
//Performs the required action on the strategy:
switch (controlNumber)
{
case 0: thisStrategy.SwapStints(stintIndex - 1, stintIndex); break; //moves stint up
case 1: thisStrategy.SwapStints(stintIndex, stintIndex + 1); break; //moves stint down
case 2: thisStrategy.Stints = thisStrategy.AddPitStop(midLapNumber); break; //splits stint
case 3: thisStrategy.Stints = thisStrategy.RemovePitStop(startLapNumber); break; //merges stint with previous
}
//Updates the strategy's parameters
thisStrategy.UpdateStrategyParameters();
MyEvents.OnStrategyModified(thisDriver, thisStrategy, false);
}
void AddClass(string name, ManagementClass c)
{
TreeNode node = treeClasses.Nodes[0];
if (c.Derivation.Contains("__Event"))
{
Globals.FindOrAddNode("Event-Generating", ref node);
MyEvents.Classify(name, ref node);
}
else
{
if (TestForProperties(c, ref node))
{
MyProperties.Classify(name, ref node);
}
else
{
Globals.FindOrAddNode("Other", ref node);
MyOther.Classify(name, ref node);
}
}
node.Nodes.Add(name, name, 3, 2);
}
/// <summary>
/// Scales the axes after the availabe graph area is changed
/// </summary>
/// <param name="oldSize">The old graph area</param>
/// <param name="newSize">The new graph area</param>
void ScaleAxes(Rectangle oldSize, Rectangle newSize)
{
float scaleFactorX = (float)newSize.Width / (float)oldSize.Width;
float scaleFactorY = (float)newSize.Height / (float)oldSize.Height;
horizontalAxis.axisLabelSpacing = (int)Math.Round(scaleFactorX * horizontalAxis.axisLabelSpacing);
if (horizontalAxis.axisLabelSpacing == 0)
{
horizontalAxis.axisLabelSpacing = 1;
}
verticalAxis.axisLabelSpacing = (int)Math.Round(scaleFactorY * verticalAxis.axisLabelSpacing);
if (verticalAxis.axisLabelSpacing == 0)
{
verticalAxis.axisLabelSpacing = 1;
}
horizontalAxis.scaleFactor *= scaleFactorX;
verticalAxis.scaleFactor *= scaleFactorY;
verticalAxis.startLocation = (int)(scaleFactorY * verticalAxis.startLocation);
MyEvents.OnAxesComputerGenerated(horizontalAxis, verticalAxis, graphNormalisationType);
}
public MyEventArgs(MyEvents myEvents)
{
MyEvents = myEvents;
}
public List <Event> GetUpcoming()
{
var events = MyEvents.Where(m => m.FromDate >= DateTime.UtcNow && !m.IsDeleted).OrderBy(e => e.FromDate).ToList();
return(events);
}
public List <Event> PastEvents()
{
var events = MyEvents.Where(m => m.FromDate < DateTime.UtcNow && !m.IsDeleted).OrderByDescending(e => e.FromDate).Take(5).ToList();
return(events);
}
void lapNumber_SelectedIndexChanged(object sender, EventArgs e)
{
currentLapNumber = lapNumber.SelectedIndex + 1;
MyEvents.OnLapNumberChanged(currentLapNumber);
}
private void Awake()
{
GameSystem.dailyData11 = data;
MyEvents.Add(new MyEvent7(ref MyEvents));
}
public ActionResult My(string Search, int Order = 0)
{
var friendship = new MyEvents(DB, Search, Order, CurrentUser);
return(PartialView(friendship));
}
public void LoadList()
{
MyEvents <T, M> .LoadList("getList").ForEach(w => this.Items.Add(w));
}
/// <summary>
/// Runs a race simulation and outputs the results to a graph.
/// </summary>
public void SimulateRace()
{
//overtake variables:
Driver driverAhead, driverBehind;
RaceStrategy temp;
for (int lapNumber = 0; lapNumber < laps; lapNumber++) //for each lap
{
for (int position = 0; position < Data.NumberOfDrivers; position++)
{
//check for lapped car encounters:
bool stayInLoop = true;
float previousLapDeltaTime = 0;
float thisLapDeltaTime = 0;
for (int lappedPosition = Data.NumberOfDrivers - 1; stayInLoop; lappedPosition--)
{
previousLapDeltaTime = (raceStrategies[lappedPosition].CumulativeTime - raceStrategies[position].CumulativeTime);
thisLapDeltaTime = (raceStrategies[lappedPosition].RaceLapTimes[lapNumber] - raceStrategies[position].RaceLapTimes[lapNumber]);
if ((previousLapDeltaTime % raceStrategies[position].RaceLapTimes[lapNumber]) < thisLapDeltaTime)
{
raceStrategies[lappedPosition].RaceLapTimes[lapNumber] += Data.Settings.BackmarkerLoss;
}
stayInLoop = (previousLapDeltaTime > raceStrategies[position].RaceLapTimes[lapNumber]);
}
}
for (int position = 1; position < raceStrategies.Length; position++)
{
//check for overtakes:
driverAhead = raceStrategies[position - 1].Driver;
driverBehind = raceStrategies[position].Driver;
if (CalculateOvertake(driverAhead, driverBehind, position, lapNumber) || forcedOvertake[driverBehind.DriverIndex, lapNumber])
{
raceStrategies[position - 1].RaceLapTimes[lapNumber] += Data.Settings.TimeLoss;
//swap strategies
temp = raceStrategies[position - 1];
raceStrategies[position - 1] = raceStrategies[position];
raceStrategies[position] = temp;
}
else
{
//check for following in traffic
if (FollowingInTraffic(position - 1, position, lapNumber))
{
float minimumTime = raceStrategies[position - 1].CumulativeTime + raceStrategies[position - 1].RaceLapTimes[lapNumber] + Data.Settings.TimeGap;
float requiredLap = minimumTime - raceStrategies[position].CumulativeTime;
raceStrategies[position].RaceLapTimes[lapNumber] = requiredLap;
}
}
}
List <PitStop> pitStopList = new List <PitStop>();
for (int position = 0; position < raceStrategies.Length; position++)
{
//update pit stops:
if (raceStrategies[position].PitStops.Exists(lapNumber + 1))
{
pitStopList.Add(new PitStop(position, lapNumber, raceStrategies[position].PaceParameters.PitStopLoss));
}
}
foreach (PitStop p in pitStopList)
{
p.SimulateStop(ref raceStrategies);
}
PitStop.UpdateRacePositionsAfterPitStop(ref raceStrategies, pitStopList);
for (int position = 0; position < raceStrategies.Length; position++)
{
//update the times:
raceStrategies[position].CumulativeTime += raceStrategies[position].RaceLapTimes[lapNumber];
//update the positions:
positions[position, lapNumber].driver = raceStrategies[position].Driver.DriverIndex;
positions[position, lapNumber].position = position;
positions[position, lapNumber].cumulativeTime = raceStrategies[position].CumulativeTime;
if (position == 0)
{
positions[position, lapNumber].gap = 0;
positions[position, lapNumber].interval = lapNumber;
}
else
{
positions[position, lapNumber].gap = GetGapBetweenCars(0, position, lapNumber);
positions[position, lapNumber].interval = GetGapBetweenCars(position - 1, position, lapNumber);
}
}
MyEvents.OnUpdateIntervals(positions, lapNumber);
} //end for each lap
StartGraph();
}
public bool RemoveObjectsInTrigger(GameObject MyGameObject, GameObject MyObjectWithTrigger)
{
VRC_Trigger MyTriggerScript;
List <VRC_Trigger.TriggerEvent> TriggerEvents = null;
List <VRC_EventHandler.VrcEvent> MyEvents;
int i, l, m, n, k;
if (MyObjectWithTrigger != null)
{
MyTriggerScript = MyObjectWithTrigger.GetComponent <VRC_Trigger>();
if (MyTriggerScript != null)
{
TriggerEvents = MyTriggerScript.Triggers;
}
}
if (TriggerEvents != null)
{
for (k = 0; k < TriggerEvents.Count; k++)
{
MyEvents = TriggerEvents[k].Events;
if (MyEvents == null || MyEvents.Count == 0)
{
TriggerEvents.RemoveAt(k);
k--;
}
if (MyEvents != null)
{
for (i = 0; i < MyEvents.Count; i++)
{
n = 0;
for (l = MyEvents[i].ParameterObjects.Length - 1; l >= 0; l--)
{
if (MyEvents[i].ParameterObjects[l] == MyGameObject)
{
for (m = l; m < MyEvents[i].ParameterObjects.Length - 1; m++)
{
MyEvents[i].ParameterObjects[m] = MyEvents[i].ParameterObjects[m + 1];
}
n++;
}
}
if (n > 0)
{
n = MyEvents[i].ParameterObjects.Length - n;
Array.Resize(ref MyEvents[i].ParameterObjects, n);
if (MyEvents[i].ParameterObjects.Length == 0)
{
MyEvents.RemoveAt(i);
i--;
if (MyEvents.Count == 0)
{
TriggerEvents.RemoveAt(k);
k--;
}
}
}
if (MyEvents == null)
{
break;
}
}
}
}
}
return(true);
}
public bool RemoveWrongVariablesInTrigger(GameObject MyObjectWithTrigger)
{
VRC_Trigger MyTriggerScript;
List <VRC_Trigger.TriggerEvent> TriggerEvents = null;
List <VRC_EventHandler.VrcEvent> MyEvents;
int i, l, m, n, k;
if (MyObjectWithTrigger == null)
{
CustomMessage = "Select \"Objects With Trigger\" To Remove Wrong Variables";
return(false);
}
MyTriggerScript = MyObjectWithTrigger.GetComponent <VRC_Trigger>();
if (MyTriggerScript == null)
{
CustomMessage = "Object Does Not Contain A Trigger";
return(false);
}
TriggerEvents = MyTriggerScript.Triggers;
if (TriggerEvents != null)
{
for (k = 0; k < TriggerEvents.Count; k++)
{
MyEvents = TriggerEvents[k].Events;
if (MyEvents.Count == 0)
{
TriggerEvents.RemoveAt(k);
k--;
}
if (MyEvents != null)
{
for (i = 0; i < MyEvents.Count; i++)
{
n = 0;
for (l = MyEvents[i].ParameterObjects.Length - 1; l >= 0; l--)
{
if (MyEvents[i].ParameterObjects[l] == null)
{
for (m = l; m < MyEvents[i].ParameterObjects.Length - 1; m++)
{
MyEvents[i].ParameterObjects[m] = MyEvents[i].ParameterObjects[m + 1];
}
n++;
}
}
if (n > 0)
{
n = MyEvents[i].ParameterObjects.Length - n;
Array.Resize(ref MyEvents[i].ParameterObjects, n);
if (MyEvents[i].ParameterObjects.Length == 0)
{
MyEvents.RemoveAt(i);
i--;
if (MyEvents.Count == 0)
{
TriggerEvents.RemoveAt(k);
k--;
}
}
}
if (MyEvents == null)
{
break;
}
}
}
}
}
return(true);
}
public static void Trigger(MyEvents myEvents)
{
OnMyEvent(new MyEventArgs(myEvents));
}
private void AxisModified(object sender, axisParameters e)
{
MyEvents.OnAxesComputerGenerated(GraphPanel.HorizontalAxis, GraphPanel.VerticalAxis, GraphPanel.NormalisationType);
Invalidate();
}
static void Bridges()
{
var evt = new MyEvents();
//
// Rx doesn't claim to substitue existing technologies with some new
// approach using IObservable exclusively. For example, regular .NET
// events, the asynchronous pattern, etc. are still perfectly fine to
// be used. However, when composition enters the picture, Rx provides
// a solution. Therefore we can bridge the old world to the new world
// using various operators. Rx is the glue that binds those worlds
// together using operators and combinators.
//
//
// A first sample is FromEvent for which we have a reflective version
// as well as one that uses add/remove handler delegates.
//
Console.WriteLine("FromEvent");
var mme1 = Observable.FromEvent<MyEventArgs>(evt, "Bar");
var mme2 = Observable.FromEvent<MyEventArgs>(handler => evt.Bar += handler, handler => evt.Bar -= handler);
using (mme1.Subscribe(e => Console.WriteLine("1 --> " + e.EventArgs.Value)))
using (mme2.Subscribe(e => Console.WriteLine("2 --> " + e.EventArgs.Value)))
{
evt.Raise(42);
evt.Raise(43);
}
evt.Raise(24); // All subscriptions gone; no output expected.
Console.WriteLine();
//
// Secondly, there's the asynchronous invocation Begin/End pair pattern,
// which can be bridged using FromAsyncPattern.
//
Console.WriteLine("FromAsyncPattern");
using (var fs = File.OpenRead(@"..\..\Program.cs"))
{
//
// The signature of the Begin method is reflected in the FromAsyncPattern
// generic parameters. The last one is the return type, in this case an
// int returning the number of bytes read, as seen on the End method.
//
var readAsync = Observable.FromAsyncPattern<byte[], int, int, int>(fs.BeginRead, fs.EndRead);
//
// Using readAsync, we can invoke the Begin/End pair without worrying about
// the IAsyncResult madness. In here, res will be an IObservable<int> which
// will contain the result of the EndRead call, i.e. the number of bytes
// read from the input.
//
var data = new byte[16];
var res = readAsync(data, 0, data.Length);
//
// We'll use Run to go synchronously here, such that we don't dispose the
// opened FileStream prematurely.
//
res.Run(x => Console.WriteLine("{0} bytes read: {1}", x, Encoding.ASCII.GetString(data)));
}
Console.WriteLine();
//
// Third, the Task Parallel Library introduced in .NET 4 (and backported to 3.5
// when installing Rx) has the notion of a Task<T> which is like a single-result
// IObservable<T> (i.e. a deferred Return<T> observable). We can convert this to
// an observable as well.
//
Console.WriteLine("Task<T>");
var tsk = Task<int>.Factory.StartNew(() => { Thread.Sleep(2000); return 42; });
tsk.ToObservable().Run(Console.WriteLine);
Console.WriteLine();
//
// Fourth, enumerable sequences can be iterated asynchronously, resulting in an
// observable sequence as well. Let's create some sequence that ticks at a slow
// pace, producing values 0..9, and watch it using observables. Instead of using
// Run which would make the whole thing synchronous, we're printing dots on the
// main thread till completion is signaled by the enumeration that's happening
// on a background thread spawn by ToObservable. This illustrates how concurrency
// is introduced by ToObservable.
//
Console.WriteLine("ToObservable");
var xs = Enumerable.Range(0, 10).Select(x => { Thread.Sleep(x * 100); return x; });
var isDone = false;
xs.ToObservable(Scheduler.ThreadPool /* where to do the iteration */)
.Subscribe(Console.WriteLine, () => isDone = true);
while (!isDone)
{
Console.Write(".");
Thread.Sleep(500);
}
Console.WriteLine();
//
// Finally, regular functions or actions can be invoked in the background as well,
// exposing their results through an IObservable using the Start operator.
//
Console.WriteLine("Func");
var anw = Observable.Start(() => { Thread.Sleep(2000); return 42; });
anw.Run(Console.WriteLine);
Console.WriteLine();
}
