I left my last blog very indecisive, would I use CPP, would I use .NET or would it be html/js.
Again I’m thinking Cpp is really for faster and better performance, and while it might even be the hands down winner on ARM architecture, I don’t expect to see any performance differences in the app I’m going to write.
I’m actually going to write the same application 3 times, and I’ll review my findings as I go along.
I’ll present the c++ and the c# apps here and the html/js will follow in the next blog post.
First up was the cpp. To be honest I did find this painful to write, the syntax is pretty convoluted. At least the markup for cpp is Silverlight so that was a no brainer.
<Grid x:Name="LayoutRoot" Background="#FF0C0C0C">
<Button Content="Open" HorizontalAlignment="Left"
Height="4" Margin="84,45,0,0" VerticalAlignment="Top"
<TextBlock HorizontalAlignment="Left" Height="381"
Margin="282,45,0,0" Text="TextBox" VerticalAlignment="Top"
I’ll even use the same markup for the C# application.
Now to the code
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;
using namespace Windows::UI::Xaml::Data;
using namespace Windows::Storage;
using namespace Windows::Storage::Pickers;
using namespace Windows::Storage::Streams;
using namespace Windows::Foundation;
using namespace CppApplication17;
void CppApplication17::MainPage::Button_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
auto openPicker = ref new FileOpenPicker();
openPicker->SuggestedStartLocation = PickerLocationId::Desktop;
auto pickOp = openPicker->PickSingleFileAsync();
TextBlock^ content = tb1;
pickOp->Completed = ref new AsyncOperationCompletedHandler<StorageFile^>(
StorageFile^ file = operation->GetResults();
//content->Text = file->FileName;
auto openOp = file->OpenForReadAsync();
openOp->Completed = ref new AsyncOperationCompletedHandler<IInputStream^>(
[content, file](IAsyncOperation<IInputStream^>^ readOperation)
auto stream = readOperation->GetResults();
auto reader = ref new DataReader(stream);
auto loadOp = reader->LoadAsync(file->Size);
loadOp->Completed = ref new AsyncOperationCompletedHandler<unsigned int>(
[content, reader](IAsyncOperation<unsigned int>^ bytesRead)
auto contentString = reader->ReadString(bytesRead->GetResults());
content->Text = contentString;
partial class MainPage
async private void Button_Click(object sender, RoutedEventArgs e)
var openPicker = new FileOpenPicker();
openPicker.SuggestedStartLocation = PickerLocationId.Desktop;
var file = await openPicker.PickSingleFileAsync();
if (file != null)
uint size = (uint)file.Size;
var inputStream = await file.OpenForReadAsync();
var dataReader = new DataReader(inputStream);
tb1.Text = dataReader.ReadString(await dataReader.LoadAsync(size));
Now I’m not going to explain every trivial detail, but’s here where I felt I c# won out.
- C++ 11 lambda syntax is a bit clumbsy, I don’t like having to pass down my closure variables or having to make a local copy first
- C++ intellisense is vastly inferior, to the point of being just painful. Lets be honest, tooling cannot be under estimated when it comes to productivity. (this is why I when I write Java I find that only since i started using IntelliJ has my speed really ramped up, it’s the right tool for my background.)
- I’m fast at typing, but using . is a lot faster than –> for pointers.
- The async await construct is just magical!, now, to those you who I’m sure will complain that I’m comparing apples with oranges, you have a bit of a moot point, in C++ I could have used the parallel patterns library to make it a little neater, but nowhere near as close to C#.
My next post I’ll rewrite the same application in html + js. I predict that the syntax is not that difficult but productivity is where I feel I may fall down… let’s see.. It promises to be interesting.