var x = new List<int>();
Console.WriteLine(x.Length); // prints "0"

var y = new ImmutableArray<int>();
Console.WriteLine(y.Length); // throws NullReferenceException ??!?

ljw1004 fucked around with this message at 21:45 on Nov 23, 2014

public static string MyJoin (this string joiner, params string[] args) 
  {
    return string.Join(joiner, args);
  }

RICHUNCLEPENNYBAGS fucked around with this message at 14:43 on Nov 25, 2014

SirViver fucked around with this message at 16:54 on Nov 25, 2014

@helper NonBreakingSpace(string s)
{
    <text>@s.Replace(" ", "& nbsp;")</text>
}

epswing fucked around with this message at 19:28 on Nov 25, 2014

Funking Giblet fucked around with this message at 11:03 on Nov 27, 2014

	/// <remarks>
	/// NB! Must be disposed of manually or you leak the job.
	/// This class is NOT thread-safe!
	/// </remarks>
	internal abstract class Job : IDisposable
	{
		/// <summary>
		/// If the job stops running without a good reason, the run thread waits this long before starting it again
		/// (unless the job gets stopped earlier). Internal for testing purposes only - do not touch!
		/// </summary>
		internal static TimeSpan RestartDelay = TimeSpan.FromMinutes(1);

		/// <summary>
		/// Starts the job! The job will be automatically restarted on exception, until RequestStop() is called.
		/// </summary>
		public void Start()
		{
			if (_isRunning)
				return;

			// Just in case we still have some lingering thread hoooked up.
			WaitForStop();

			_isRunning = true;

			_cancellationTokenSource = new CancellationTokenSource();

			_runThread = new Thread(RunThread);
			_runThread.Name = GetType().Name;
			_runThread.IsBackground = true;
			_runThread.Start(_cancellationTokenSource.Token);
		}

		/// <summary>
		/// Notifies the job background process that it is to stop but does not wait for it to actually finish processing.
		/// </summary>
		public void RequestStop()
		{
			if (!_isRunning)
				return;

			_isRunning = false;

			_cancellationTokenSource.Cancel();
		}

		/// <summary>
		/// Waits for the job to stop. You must have called Stop() first.
		/// </summary>
		public void WaitForStop()
		{
			if (_isRunning)
				throw new InvalidOperationException("The job is running - you cannot wait for it to stop before asking it to stop!");

			if (_runThread == null)
				return;

			// You better have called Stop() before or you are in trouble!

			_runThread.Join();
		}

		public void Dispose()
		{
			RequestStop();
			WaitForStop();
		}

		protected Job(LogSource log)
		{
			Argument.ValidateIsNotNull(log, "log");

			_log = log;
		}

		/// <summary>
		/// Does the actual "work". If this function returns or throws an exception, it is simply started again.
		/// The cancellation token signals that the job was requested to stop while in the middle of processing.
		/// </summary>
		/// <remarks>
		/// Implementations are strongly recommended to check for cancel at the end of a cycle, as this greatly simplfies
		/// the patterns needed to create "run the job once" style automated tests (because you can just cancel right after start).
		/// </remarks>
		protected abstract void Run(CancellationToken cancel);

		/// <summary>
		/// The log source dedicated to this job. Use for whatever.
		/// </summary>
		protected readonly LogSource _log;

		private CancellationTokenSource _cancellationTokenSource;
		private bool _isRunning;
		private Thread _runThread;

		private void RunThread(object cancelToken)
		{
			var cancel = (CancellationToken)cancelToken;

			while (true)
			{
				try
				{
					_log.Debug("Job cycle starting.");

					Run(cancel);

					if (cancel.IsCancellationRequested)
					{
						_log.Debug("Job cycle ended. This is normal because the job is stopping.");
						return;
					}

					_log.Warning("Job cycle ended without cause even though it was not asked to stop. Scheduling job for restart.");
				}
				catch (Exception ex)
				{
					_log.Warning("Job cycle ended with exception. Scheduling job for restart.");

					ErrorReport.Send(ex);
				}

				// We deliberately check this only at the end of each cycle, to allow for the "cancel right after start" pattern.
				// Wait a bit before restarting, just so we do not cause overload in case we fall into a pit of failure.
				if (cancel.WaitHandle.WaitOne(RestartDelay))
					return;
			}
		}
	}

		protected override void Run(CancellationToken cancel)
		{
			while (true)
			{
				// Do some work

				_log.Debug("Sleeping for {0:F0} minutes.", sleepSpan.TotalMinutes);

				if (cancel.WaitHandle.WaitOne(sleepSpan))
					break;
			}

			_log.Debug("Stopping as requested.");
		}

EssOEss fucked around with this message at 23:38 on Nov 28, 2014