Author: Bob Crowley

Breakpoints

Bob CrowleyLeave a comment

The first in a series of beginner posts on debugging skills, this will introduce you to one of the most basic and fundamental debugging techniques – Breakpoints.

This won’t take long. Breakpoints are a simple concept but one that can elude new programmers for a while. I recall my early days in college when hearing about debugging with breakpoints seemed “advanced”. I know this is still a problem by my observations made from StackOverflow.com questions.

A program is a process and a debugger attaches to that process to provide debugging services. Modern integrated development environments (Visual Studio, Eclipse, Android Studio, Visual Studio Code, etc., etc.) can automatically run and attach a debugger to your program. If you have set a breakpoint, the code will pause execution on that line and wait for you to allow it to continue. While paused, there are a myriad of things you can do to interrogate the state of your program. Exactly what you can do depends on your IDE but all modern IDE’s support very similar capabilities.

Let’s look at a quick demo. I am using the built-in Chrome Developer Tools against a my demo site http://newup.consulting/dliyj/

I have chosen to demo a website because nearly everyone has Chrome and the Internet. Your language and environment will work very similarly to this process.

Advertisement

ConfigureAwait (sometimes) Saves the Day Everytime!

Bob CrowleyLeave a comment

I get in a lot of fights.

Fights about async/await anyway. Despite async/await being over 5 years old (AOTW), there still remains a lot of confusion regarding some basic functionality.

I do not presume to be an in-depth expert. Some of the things I read from Stephen Cleary or Jon Skeet make my eyes go crossed. But for your average, everyday usage, it doesn’t need to be so misunderstood.

I am not going to rehash the excellent articles that explain these things. I am going to share a WPF application that demonstrates some of the commonly misunderstood pitfalls so you can actually observe the things you read about by the experts like Stephen Cleary, Stephen Toub, Jon Skeet.

Introducing “WPFGui”…. This is a simple Windows Presentation Foundation application that will attempt to update the UI on each of the button clicks. Of course I don’t need to update the UI directly with MVVM, but this is a contrived example after all….

Continue reading →

Using HttpClient as it was intended (because you’re not)

Bob Crowley5 Comments

sink

Async programming has become ubiquitous and the standard tool for making async HTTP requests with C# is HttpClient from the System.Net.Http namespace. Examples are aplenty, but good examples are few and far between. Because HttpClient implements IDisposable we are conditioned to new it up in a using statement, make the call and get out as fast as possible.

This is WRONG.

This blog post will pull together advice from the few good resources online that touch on various aspects of why you are using it wrong, and how to use it correctly.

Continue reading →

C# Data Binding example with Adapters and DataGridView

Bob CrowleyLeave a comment
sink

A Basic Example of CRUD with DataGridView in VB.Net being one of my more popular posts, I thought I should provide a C# example. I find people on stackoverflow.com continue to struggle with setting up DataAdapters to perform inserts, updates and deletes, and the use of WinForms is still often the platform used by beginners and students.

So here is a small sample application demonstrating how easy it is. There is an embeded SQLite database so you can immediately run the project without worrying about database setup. The code itself is easily translated for your data provider of choice – where you see “SQLite” just replace it with “SQL” or “OleDB”, or whatever you are using:

SQLiteCommand => becomes => SqlCommand

This time I’ll allow the code to speak for itself, get it here on GitHub.

Fun With NTFS Alternate Data Streams

Bob CrowleyLeave a comment

Are you familiar with the feature of NTFS called Alternate Data Streams? Our typical usage of files is pretty simple. We double click it and it opens. But  by default we are only accessing the “default” data stream. We can write to multiple data streams, effectively storing multiple files in a single file. These alternate streams are generally hidden, but we can see them and even write to them. I’ll show  you how to do it from the command line and from C#.

Continue reading →

Custom Serilog Sink Development

Bob CrowleyLeave a comment
sink
The code shown here is part of a VS 2015 solution hosted on GitHub.

If you are coming to this blog post you probably already know what Serilog is and you need to write to a “sink” that is not already provided in the list of Available Sinks. The list is quite long so definitely look closely before developing your own because there is most likely one already built for  your needs.

But what if there isn’t? Continue reading →

Testing the Un-Testable

Bob CrowleyLeave a comment

wood-pile-2

As developers, we are often faced with legacy code bases that were never designed with unit testing in mind. Of course, we now know the value of unit tests and we want to test as much as possible. A good place to start implementing tests in old code is to write tests around each bug and feature. Do not try to refactor the entire pile of rubble, but instead begin with tests around just the code you are adding or changing.

Here I will show you a simple technique to refactor “just enough” to get some tests running without introducing unacceptable risk in your modifications. The examples with be in C#, but the technique applies everywhere.

Continue reading →

Upgrade your butler to Async

Bob CrowleyLeave a comment

The async and await keywords have been around for a while (since .Net 4.5) yet there still remains a fair amount of confusion regarding how it works. First off, while the compiler is arguably doing something akin to magic, you could achieve much the same results with BeginInvoke and EndInvoke. The async/await way of doing things makes the code more natural to write and reason about but there is nothing new in the operating system to make this magic.

A basic thing async/await does for you is to allow scalability by allowing your thread to go off and do other work while you wait on some asynchronous activity. It does not mean you spin up new threads and do processing in parallel (though, you could). I’ll describe this in non-technical terms to make it clear.

Suppose you have a butler and we will say he is a synchronous butler. Your butler has been tasked with folding your underwear but you decide to order pizza so you tell your butler to stop folding and go wait at the door for the delivery. Your butler is effectively blocked from doing anything while the pizza is cooked and delivered. When the doorbell rings he will open the door, pay the driver, serve your pizza then get back to folding your spiderman underoos.

What a waste. Why can’t your butler keep folding clothes while the pizza is on its way? If you got the asynchronous model he easily could. He would call to order your pizza, put the task of answering the doorbell on hold, then go do other work. When the doorbell rings, he will pick up his task of serving you pizza where he left off and get the door.

That is the very basics of async/await. When you await a task the thread is free to do other work but it will come back and finish up when it needs to. This provides scalability by not wasting threads and forcing them to sit around idle. You are allowing your application and the operating system to operate more efficiently.

 

Input, Output and Input/Output SqlParameter Behavior Explained

Bob CrowleyLeave a comment


In this article I will explain the sometimes surprising behavior of  the ADO.Net SqlParameter and particularly the effects of ParameterDirection, null value and DBNull.Value on how the parameter is sent to the database.

The companion VisualStudio 2015 solution contains the database project and unit tests for each scenario outlined below.

Continue reading →