Reactive Extensions + Async vs Threading Performance - c#-4.0

Question

Wondering if this is implemented sufficiently and efficiently. Trying to get the most speed out of this I can but I feel that I have not implemented this as best as possible. Here is the code snippet. If I tweak the .Buffer() call and only use 1 (simulating a single thread) it takes longer. If I set the buffer to 9 (based on #of cores + 1) it's much faster. However, I was under the impression that async would be faster than multi-threading.... doesn't seem to be working here.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Data;
using System.Data.Sql;
using System.Data.SqlClient;
using CryptSharp.Utility;
using CryptSharp; // CryptSharp Lib in NuGet
using System.Reactive;
using System.Reactive.Linq;
using System.Reactive.Concurrency;
using System.Reactive.Linq.Observαble;
using System.Reactive.PlatformServices;
namespace ConsoleApplication1
{
internal class Program
{
private static void Main(string[] args)
{
const bool dispalyOutput = true;
Console.WriteLine("Main thread id: {0}", Thread.CurrentThread.ManagedThreadId);
// if the bugger is adjusted then it will create threads via .net TPL Parallel foreach
var o = (from num in Enumerable.Range(1, 1000) select num).ToObservable(Scheduler.Default).Buffer(32);
var w = Stopwatch.StartNew();
o.SubscribeOn(Scheduler.Default).ObserveOn(Scheduler.Default).Subscribe(n =>
{
Parallel.ForEach(n, chunk =>
{
using (new SimultaneousDelegateCheck(false))
{
Thread.Sleep(0);
var crypto = GetCrypto(chunk.ToString());
if (dispalyOutput)
if (chunk%10 == 0)
Console.WriteLine("Hash|{0} Tid:{1}: {2}", chunk,
Thread.CurrentThread.ManagedThreadId, crypto.Result);
}
});
},
(n) => Console.WriteLine("Error: {0}", n.Message),
() =>
{
Console.WriteLine("Done!");
Console.WriteLine("Total time: {0}", w.Elapsed);
});
Console.WriteLine("Main thread finished in {0}", w.Elapsed);
Console.WriteLine("Finished (called before anon delegate runs above)");
Console.ReadLine();
}
static async Task<string> GetCrypto(string s)
{
//var crypto = Task.Run(() => s.CryptSharpSHA256Hash()); // requires CryptSharp lib from Nuget
var crypto = Task.Run(() => s.Hash(new SHA256Managed()));
//var crypto = Task.Run(() => s.Hash(new SHA256CryptoServiceProvider()));
//var crypto = Task.Factory.StartNew(() => s.CryptSharpSHA256Hash()); // requires CryptSharp lib from Nuget
//var crypto = Task.Run(() => s.Hash(new SHA256Managed()));
//var crypto = Task.Run(() => s.Hash(new SHA256CryptoServiceProvider()));
return await crypto;
}
}
public static class HashExtension
{
public static string CryptSharpScryptHash(this string input)
{
throw new NotImplementedException("don't do that");
}
public static string CryptSharpSHA256Hash(this string input)
{
return Crypter.Sha256.Crypt(input);
}
public static string Hash(this string input, HashAlgorithm algorithm = null)
{
if(algorithm==null)
algorithm=new SHA256Managed();
var inputBytes = Encoding.UTF8.GetBytes(input);
// Combine salt and input bytes
var salt = "hashsalt".GetBytes();
var saltedInput = new Byte[salt.Length + inputBytes.Length];
salt.CopyTo(saltedInput, 0);
inputBytes.CopyTo(saltedInput, salt.Length);
var hashedBytes = algorithm.ComputeHash(inputBytes);
return BitConverter.ToString(hashedBytes).Replace("-", "");
//return Convert.ToBase64String(hashedBytes);
}
public static byte[] GetBytes(this string str)
{
byte[] bytes = new byte[str.Length * sizeof(char)];
System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
return bytes;
}
public static string GetString(this byte[] bytes)
{
char[] chars = new char[bytes.Length / sizeof(char)];
System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
return new string(chars);
}
}
public class SimultaneousDelegateCheck : IDisposable
{
private static int _delegateCount = 0;
public void Dispose()
{
Interlocked.Decrement(ref _delegateCount);
}
public SimultaneousDelegateCheck(bool display = true)
{
var usage = 0;
if ((usage = Interlocked.Increment(ref _delegateCount)) == 1) return;
if(display)
Console.WriteLine("threads:{0}", _delegateCount);
}
}
}