First answer: AFAIK, there's no difference between the compiled code for those two examples. It is definitely the case that the new operator will always allocate new memory on the heap and the previous memory referenced by the variable will be deallocated and garbage collected.

Second answer: there is a certain amount of indirection involved with using properties as opposed to public fields, but it's really not severe enough to be worrying about optimising it. It's much better practice to use properties, as it makes your code more maintainable.

Are you actually having performance issues, or is this premature optimisation? The .NET runtime is pretty damn performant, and the garbage collector and property code are particularly good. And the C# compiler is one of the best optimising compilers ever, and a lot of the time you're better off using the simplest approach and letting it do its job.

On that note, are you using XNA 2.0, or the 3.0 beta? If you can, use the beta, as it allows you to use Visual C# 2008 and the C# 3.0 compiler, which is very, very good, and provides lots of coding shortcuts which often get optimised well.

Ah right. Thank you.

It's just premature optimisation.. I'm not trying to go all out with heavy optimisation and unreadable code everywhere.. we've only just started writing an actual framework for our game so I'm trying to work out a few things so I can start how I mean to go on - so I don't get a big headache at the end when we're trying to speed it up.

We're using XNA 2.0 for the game... Mostly because not all of us have VS2008 (well, we do at work but not at home which is where we do most of the development).

We could use Visual C# 2008 Express, but it lacks support for solutions which I can't live without.

To fire another question back at you - are there any .NET/C# tools that you can't live without?

I've been playing with NProf which seems pretty handy (well, I can see how it'd be handy as we get further on with development). Are there any nice tools that you use regularly?

Unfortunately for you, most of the C# tools I use (unit testing, profiling, etc) are included within Visual Studio Team System 2008, which I get through work. But if you don't have that, then:

NUnit is pretty much essential for unit-testing.

I also use Lutz Roeder's Reflector for poking about in third party assemblies, and the CodeMetrics plug-in for that is highly recommended for quality checking.

Another good code analysis tool is devAdvantage, which has now gone open source on SourceForge.

When I'm optimising, I use ildasm (from the SDK) to look at the compiled IL code from two different ways of doing something to see which uses the fewest instructions.

If you're creating a framework, then you should use FxCop to check the code for best practices. And consider Microsoft's Sandcastle for generating really excellent documentation from the doc comments I know you'll be adding to all your public and protected members...

public IEnumerable<Vector3> GetVectors()
{
  Vector3 v;
  while ((v = MakeVector()) != null)
  {
    yield return v;
  }
}
 
...
 
foreach (Vector3 v in GetVectors())
{
  // do something
  if (condition) break;
}

Hmm. Interesting stuff. I think I've done something similar in the past, but probably just due to copying and pasting someone elses work.

Thanks for your help.

 
Game    Screen        Component    Component
------- ------------- ------------ ----------
 
Game -> 3dScreen   -> Sheep     -> AI
                                -> Render
                                -> Physics
 
                   -> Dog       -> Controller
                                -> Animation
     -> MenuScreen -> Setup
     -> HUDScreen  -> Radar
                   -> Healthbar