Services may or may not provide a well-defined list of fields to you, the consumer, which doesn’t change. There are two design options with trade-offs:

1. Wrapper Classes: Create wrapper classes that convert expected fields in the JSON to a simple C# object. (Eg. for twitter, create a class with CreatedAt and Text for tweets, which expects the API to send created_at and text back.)
2. Dynamic Classes: Use the new DLR, don’t care about static typing and expecting fields at runtime. Take whatever you get, and expose it.

For the second option, you need to sort out how to make RestSharp deserialize to (in the case of Twitter tweets) List<dynamic>.

Assuming you already have this working with a wrapper class, you only need to make a couple of changes. First, add a handler with a deserializer, as per this gist:

namespace RestSharp.Deserializers
{
  public class DynamicJsonDeserializer : IDeserializer
  {
    public string RootElement { get; set; }
    public string Namespace { get; set; }
    public string DateFormat { get; set; }

    public T Deserialize<T>(IRestResponse response)
    {
      return JsonConvert.DeserializeObject<dynamic>(response.Content);
    }
  }
}

(You need JSON.NET for this.) When you build your RestClient instance, add the handler to it:

client.AddHandler("application/json", new DynamicJsonDeserializer());

Finally, deserialize it. The tricky part is deserializing. The DynamicJsonDeserializer class actually returns (in this case) a JArray instance. To convert that to List<dynamic>, you need to do this:

var response = client.Execute<JArray>(request).Data.ToObject<List<dynamic>>();

Et voila, you’re done! You now have a list of dynamic objects, and you can dynamically access their fields!

Throwing this into the trace that outputs the game FPS every second, I noticed a repetitive workflow where my game’s RAM usage kept climbing, from around 10MB (baseline) to over 30MB!

Having a qualified, quantified problem (potentially unlimited growth of memory usage, i.e. a memory leak) I sat out to answer an important question: could I somehow write an automated test that would check if this workflow leaked memory?

The answer was a resounding yes. Using the very powerful Moq framework, I was able to rip out most external dependencies and isolate my workflow to two calls: a constructor and Initialize method on one of my Screen subclasses.

Once I did this, simply creating and disposing 10k objects and checking the memory usage (before and after) indicated whether the usage shot up. A small rise (10k? 100k?) was probably insignificant; in my case, I saw more than a 20MB increase in RAM usage.

Also, one key here is to run GC.GetTotalMemory(true). This forces the GC to collect anything immediately, which is slower, but necessary. Without it, we can’t tell if the memory increase is due to disposed objects that the GC didn’t get around to disposing yet.

The culprit? Appending event handlers in the constructor which should have been removed on subsequent calls to dispose (but weren’t).

The conclusion? Testing for memory leaks is not hard, and can be very useful under certain circumstances, provided you have enough infrastructure in place to mock out dependencies.

What’s the difference?

AvailableFreeSpace returns the amount of free space available given disk quotas. Yes, it’s true; apparently, every Windows OS since Windows 2000 implements and allows you to specify storage quotas.

TotalFreeSpace, on the other hand, just gives you the total amount of free space on the disk — just bear in mind that you may not be able to use all of it (depending on your user and permissions/quotas).

Game State vs. Game Presentation

You can divide game “stuff” into two things: game state (data, classes, etc. of how things look right now — the current player the level is on, health, position), and your presentation (3D models, lights, textures, sprites, etc.).

Microsoft build XNA with the understanding that these two things are separate, but related. For example, if you have a physics-like simulation, you may want to update the state/simulation several times between calls to Draw. This could be because your users have older hardware, and while they can’t draw things at 60 (or maybe even 30) FPS, they shouldn’t have the game run slowly.

To say that another way, the state of the game and the display of the game should be independent. You want the game state to always, always be consistent and to run “fast,” even if you can’t draw that fast; this means your game will still play at the same speed, regardless of CPU/hardware performance — it’ll just draw less frames on slower computers than on newer ones.

Who Cares, Tell Me About IsFixedTimeStep?

Now that you (hopefully) understand this difference, lets talk about IsFixedTimeStep. IsFixedTimeStep is true by default, which means that XNA calls Draw no more than once every 1/60th of a second. (You can change this frequency if you modify the TargetElapsedTime property.)

That’s what “fixed time-step” means — every call to Draw occurs at the same, fixed, time-step. Because game state is not the same thing as game presentation, calls to Update still occur as frequently as your computer can handle. (Regardless, I suggest you use a semi-fixed timestamp to avoid troubles like fast-moving objects “skipping” through walls.)

This is generally a good thing. It means that your game will run at 60FPS, and not faster. After update calls, XNA will ask, “did 1/60th of a second pass since the last Draw call yet? No? Okay, I’m not drawing anything yet.

This also means that you don’t lose “resolution” in your game state by limiting it to 60FPS.

On the other hand, setting this to false causes XNA to call Draw after every Update. It doesn’t hold back. This means you will eat more CPU cycles, but potentially run a faster FPS on better hardware. Again, it won’t change your game state update frequency, since that runs full-tilt regardless of the framerate.

This is useful in cases where you have a component which is a Windows service, and you need to run integration tests against that service, but don’t want the hassle of continuously installing and uninstalling the service; you just want to use the latest code version.

The safest way to do this (although I wouldn’t recommend checking this in to your production code-line) would be to check if the environment is interactive (or if the debugger is running), and simply invoke the service directly, then keep the process suspended.

static void main() {
  ServiceBase someService = new ServiceBase[] { new MyService() };
  if (!Environment.UserInteractive) {
    ServiceBase.Run(someService);
  } else {
    someService[0].OnStart(new string[0]); // Pass no command-line args
    while (true) {
      Thread.Sleep(100); // Suspended animation
    }
  }
}

Yep, that’s right, I used an infinite loop and didn’t call OnStop. Like I said, this is a quick and dirty solution to get around this problem.

As an alternative, you can use InstallUtil, PowerShell, or some other methods — which I’m not familiar with and can’t recommend.

That is, we want to do something like:

enum Fruits { Apple, Pear, Mango, Grapes }
Fruits f = Fruits.Apple | Fruits.Pear;
// pseudocode, bear with me
if (f has Apple) { ... }
if (f has Mango) { ... }

How?

In Any Version of .NET

The core step is really to assign 2^n integer values to each value of the enumeration, like so:

enum Fruits {
  Apple = 1,
  Pear = 2,
  Mango = 4,
  Grapes = 8
}

Note that adding the Flags attribute is not required. It’s optional. It just gives you nice ToString() representations.

All that’s left is checking the value.

How?

In .NET 4.0

.NET 4.0 has this down. It’s as simple as:

Fruits f = Fruits.Apple | Fruits.Mango;
if (f.HasFlag(Fruit.Apple)) { ... }

In Pre-4.0

Unfortunately, it’s not that easy before .NET 4.0, but it’s still quite easy. If you understand bit operators, then the same principle applies.

Look at it as binary. If apple = 1 and mango = 4, these in binary are:

Apple: 0x001
Mango: 0x100

Combining them (ANDing them) gives us 0x101, or a value of 5.

Reversing the value of five, how do we know if the third bit (for mango) is enabled? A simple AND operation:

Source: 0x101
Mango:  0x100
=============
Result: 0x100

Since AND requires both bits to be one for the resulting bit to be one, ANDing something to any value gives you that value back if the bit was set.

So we get:

if (f & Fruits.Mango == Fruits.Mango) { ... we have mangos ... }

Simple, right?

As a simplified example, I need to instantiate A, which only has one constructor:

public class A(B b, C c);

In this case, C did not have public constructors, and B required instances of other classes which were not trivial to instantiate.

Sigh.

Reflection to the rescue! Actually, no. Using the usual someType.GetConstuctor(...).Invoke(null) required a parameterless constructor; ditto for Activator.CreateInstance. While I could have simply added a parameterless constructor, since this project was an API, that would change the API and possibly cause other problems if used outside of testing.

While searching for another solution, I found this pro tip by Mark Gravell: you can actually create an instance without initializing it by calling:

A a = (A) System.Runtime.Serialization.FormatterServices.GetUninitializedObject(typeof(A));

Where A is the class you wish to instantiate. It’s tricky, and probably not what you ever want to do in production code; in test code, it was exactly the solution I needed. Thanks, Mark!

Disk Queue Length, incidentally, is something you can see in Windows 7+, under the Resource Monitor (Start > Task Manager > Performance tab > Resource Monitor > Disk tab)

Anyway, during large inserts, or imports, or selects, you may see your disk queue length spike up. This means that your computer is requesting data from the disk, but it’s busy spinning and getting data for different requests; so they start to rack up.

If you see a queue length of, say, 50, that means you have some heavy IO that’s sucking up all your disk availability and queueing up tons of requests — like when you’re restoring an 8GB database into SQL Server (please, use Attach next time.)

Two easy ways to increase performance in this case:

1. Not the Windows Partition: By default, SQL Server installs to C:\, the same place as Windows. Move the data files off of the Windows drive. You will immediately see an (often drastic) drop in queue length. Why? Because Windows makes a lot of requests, and if they start to queue up, it can make the queue much longer. If you have a second (physical, not logical) hard drive, that’s an ideal place to locate the files.
2. Split MDF and LDF Drives: Ideally, if you have three or more drives, you should put Windows on one, your MDFs on a second, and your LDFs on a third for maximum performance.

Again, unless you see the specific problem of disk queue length, you might not need to do all this. Plus, memory is usually a heavier bottleneck for SQL Server, not disk — so check that first.

How can you set the location of the MDF and LDF files? With new databases, when creating them, SQL Server shows you “Database Files” listed under “General,” with a “Path” property. Just change it to something else.

<appSettings>
  <add key="drive" value="C:\" />
</appsettings>

At runtime, you can access these values like so:

System.Configuration.ConfigurationManager.AppSettings["drive"]; // returns "C:\"

This is great for storing a few key/value pairs for different uses. But what if you wanted to store a list of strings? In our example, what if you wanted to store multiple drives? How can you do this?

One solution is to use multiple key/value pairs, like so:

<appSettings>
  <add key="drive1" value="C:\" />
  <add key="drive2" value="D:\" />
</appsettings>

Of course, this means you have to individually access the values at runtime; you can’t just grab them all into a single array or string.

The answer is surprisingly easy: just store the value as a delimited list and split it at runtime, like so:

<appSettings>
  <add key="drives" value="C:, D:" />
</appsettings>

And at runtime:

string[] drives = ConfigurationManager.AppSettings["drives"].Split(',').Select(s => s.Trim()).ToArray();

(The Select and Trim calls allow us to use white-spaces in the config file, and get a trimmed, whitespace-free list of drives.) This code would return, as expected, a string array:

drives[0] = "C:"
drives[1] = "D:"

Easy, right? But not so obvious. In fact, the obvious answer to this is to use a custom section. Personally, I feel that this is overkill for asimple list of strings, ints, or other basic types. (Technically, you can shove any serializable class in here; as long as you have a non-ambiguous delimiter, you’re good.)

Procedure or function "..." expects parameter '@foo', which was not supplied

This doesn’t make sense when you have code like:

string foo = getSomeFoo(); // May return null
SqlCommand cmd = new SqlCommand("SELECT * FROM someTable WHERE foo = @foo");
cmd.Parameters.AddWithValue("@foo", foo);
cmd.ExecuteNonQuery(); // Throws exception

You can see that @foo is, indeed, supplied. But in the case where the value is null, you will see an exception.

So what’s the solution? You can make sure that foo has a value, or some non-null value (like empty string or DBNull.Value), or you can conditionally add the parameter when needed.

And calling a stored procedure with a parameter that may be null? That, my friends, is a question for Google.