Colin Thomsen's Microsoft Blog : C#

Performance: Inserting Marks Using Code

colinth — Thu, 01 May 2008 17:55:00 GMT

Ian previously covered using the VS 2008 Data Collection Control to choose when to collect data. The Data Collection Control can also be used to insert marks into the performance report, but sometimes it is convenient to modify the source code to do this automatically.

Consider a typical application (PeopleTrax) where I am interested in gathering profiler data only between when a button is clicked and when data is displayed. The application is shown below.

After the 'Get People' button is clicked, data is displayed after just over 6 seconds. This seems a little excessive so I want to focus my performance investigation in this area.

To filter the data so that it only shows information collected between those two points, I could use the Data Collection Control, but maybe I'm planning to run a complicated scenario and don't want to have to remember to insert the marks manually. Instead, it is possible to modify the original code to request the profiler insert marks in the required locations.

The Profiler API is available for managed code in an assembly that can be added directly to the project from \Program Files\Microsoft Visual Studio 9.0\Team Tools\Performance Tools.

After adding the reference it shows up in the 'References' list for the PeopleTrax project.

I can then use functions in the Profiler API to control the profiler. This might include starting or stopping data collection or in this case, inserting marks into the datastream. This is easily achieved as shown below.

I can then profile the application and when I open the Performance Report and switch to Marks View I see that the marks have been correctly inserted. We can also see that the time elapsed between the marks is about 6.5 seconds, which corresponds with the measurement that is already displayed in the PeopleTrax UI.

I can use the marks to filter the report to only show profiling data for the time between the two inserted marks and then start my performance investigation.

Scripting for C#

colinth — Tue, 01 Jan 2008 02:29:00 GMT

Have you ever wanted to quickly run a C# application without having to setup a new project in Visual Studio and configure all the settings? A fellow developer here at Microsoft has written a tool called Code Runner .NET that allows just that. It isn't scripting exactly because the code is still compiled before being run instead of being interpreted, but you don't have to maintain project or solution files or worry about binaries.

To try it out I downloaded the tool and installed it to c:\temp\csr. I created a file test.csr after referring to the Getting Started Guide:

   1: using System;

   2: using Microsoft.Tools.CodeRunner;

3:

   4: public class Program

   5: {

   6:     public static int Main(string[] args)

   7:     {

   8:         if (args.Length == 0)

   9:         {

  10:             // TODO: Fill out usage information

  11:             Console.WriteLine("Usage: {0}", ScriptEnvironment.ScriptPath.FileAndExtension);

  12:             return 0;

  13:         }

14:

  15:         // TODO: Script code goes here...

16:

  17:         return 0;

  18:     }

  19: }

My directory was completely empty aside from this file:

C:\temp\cr\mytest>dir /b
test.csr

I could then run the file as follows:

C:\temp\cr\mytest>..\csr test.csr
Usage: test.csr

That's it. The directory was still clean after the run:

C:\temp\cr\mytest>dir /b
test.csr

You can also debug your code in Visual Studio using a a nifty tool called scaffold which makes the requisite csproj and sln files and conveniently cleans up after we're done:

C:\temp\cr\mytest>..\Scaffold.exe test.csr
Response file 'C:\temp\cr\csc.rsp' processed
File 'C:\temp\cr\mytest\Scaffold_78D592CA\test.csproj' created
File 'C:\temp\cr\mytest\Scaffold_78D592CA\test.csproj.user' created
File 'C:\temp\cr\mytest\Scaffold_78D592CA\test.sln' created
Starting Visual Studio
Waiting for Visual Studio to exit

We can now debug as usual:

When Visual Studio closes:

Sub-directory 'C:\temp\cr\mytest\Scaffold_78D592CA\' was deleted

Code Runner .NET has already been updated to support Visual Studio 2008 so download it from CodePlex now.

C# For C++ Devs: ~A() doesn't act like a destructor

colinth — Thu, 09 Aug 2007 02:14:00 GMT

In C++, memory allocated with the 'new' keyword must be deallocated using 'delete' or it is not deallocated until the application finishes. A call to delete results in a call to the destructor for that class. Classes that are allocated on the stack are automatically destroyed, which calls their destructor, when they go out of scope.

Sometimes this 'deterministic' memory allocation/deallocation behavior is exploited by developers using scoped objects on the stack to acquire and then automatically release resources even in the presence of exceptions (this pattern is known as Resource Acquisition Is Initialization - RAII).

Here is a C++ class designed to be used in RAII pattern:

class A
{
public:
   A()
   {
      // Acquire a resource (e.g. mutex or file)
   }

   ~A()
   {
      // Release the resource
   }
};

The class is then used as follows:

void f()
{
   {
      A raii;
      // do some stuff, maybe even throw exceptions
   }
   // raii has gone out of scope, so the destructor has been called. If an exception was thrown A still went out of scope and the destructor was still called
}

C# is a language with automatic garbage collection which means that developers allocate memory but in most cases they don't need to worry about when that memory is deallocated. There is no way to explicitly call the destructor. It is called whenever the garbage collector decides it is necessary to clean up, which is called Finalizing the class. In most cases classes should not implement a destructor.

In C#, it is possible to get somewhat deterministic garbage collection (at least for unmanaged objects like files) by implementing the IDisposable interface and adding a Dispose() method. That method acts much more like C++'s destructor than the equivalent class destructor. The dispose pattern is described pretty well for C# in the MSDN help for IDisposable.

Things to note:

The C# destructor will only (and can only) be called by the Finalizer.
Dispose() may be called in code.
If Dispose() is called before the Finalizer is called, finalization is suppressed using GC.SuppressFinalize(this);.
You must be careful not to reference any managed objects if Dispose is called from the destructor (this is achieved in the example by using an extra Dispose() function that takes a bool parameter).
It isn't covered in the code, but if you have member variables that implement IDisposable, your class should also implement IDisposable.

Working with unmanaged resources is clearly much more work than working with managed resources.

To implement the same RAII pattern from above in C#, assuming you have set up your class A to implement IDisposable, code with the 'using' statement to ensure Dispose() is called at the end of the block as follows:

using (A raii = new A())
{
// Do some stuff...
}

This is safe in the presence of exceptions in the same way that the C++ scoped class pattern was above.

C# for C++ Devs: Generics vs Templates for Primitive Types

colinth — Tue, 03 Jul 2007 03:46:00 GMT

I was trying to write some type-generic (almost) code in C# using a pattern that I commonly use in C++. A very simple version of what I was trying to do looks something like:

class B
{};

template<typename T>

int convert(T value)

{

    return (int)value;

}

int main(int argc, char* argv[])

{

    convert(3.5f);

    convert(11.5);

    // The line below would fail with "error C2440: 'type cast' : cannot convert from 'B' to 'int'"

    //convert(B());

    return 0;

}

In C++ this compiles and runs just fine, as long as you don't uncomment the convert function for the class. For templates, code is only generated when needed at compile time and as long as the substituted code supports the required functions (or in this case cast), everything is just fine.

The equivalent C# program using generics looks like this:

class Program

{

   static int convert<T>(T value)

   {

      return (int)value;

   }

   static void Main(string[] args)

   {

      convert(11.5);

   }

}

Unfortunately it doesn't compile. I get an error: Cannot convert type 'T' to 'int'

This is due to the way generics are handled in C#. Instead of having code generated for different types at compile time, generics are resolved to the particular type at runtime (JIT actually). This means that the convert function shown above must support all types at compile time. This is not the case, since generic objects cannot always be converted to integers.

It is possible to use constraints if you are not using a primitive type, but there doesn't seem to be a nice way to support 'generic across primitive types' in C#. Am I missing something?

C# for C++ Devs: Structs vs Classes

colinth — Mon, 14 May 2007 23:58:00 GMT

I'm from a C++ background and now I'm working quite a bit more with C# so I'm learning new things all the time. One thing that baffled me recently was caused by the difference between structs and classes in C#.

In C++ the only difference between struct and class is the default member accessibility. For example, in the code below A::f() is private, whereas B::f() is public

class A
{
void f();
}

struct B
{
void f();
}

That's the only difference. Structs can have member functions and classes can contain only data members. For C#, things are different, as I found out recently.

In C#, structs are always passed by value, whereas classes are always passed by reference. What this means in practice is that anywhere you pass a struct to a function as a parameter or return it you are doing so by value.

The confusing piece of code for me was equivalent to the following:

struct Animal
{
public int Spots;
}

class Program
{
    static void Main(string[] args)
    {
        List<Animal> allAnimals = new List<Animal>();
        allAnimals.Add(new Animal());
        allAnimals.Add(new Animal());

        foreach (Animal animal in allAnimals)
        {
            animal.Spots = 5;
        }
       Debug.WriteLine(String.Format("First animal spots: {0}", allAnimals[0].Spots));
    }
}

When I compiled the code above I got the error:

error CS1654: Cannot modify members of 'animal' because it is a 'foreach iteration variable'

How strange, I thought. OK, maybe in a foreach loop you can't modify public members. Let's try calling a function instead:

struct Animal
{
    public void setSpots(int NewSpots)
    {
        Spots = NewSpots;
    }
    public int Spots;
}

class Program
{
    static void Main(string[] args)
    {
        List<Animal> allAnimals = new List<Animal>();
        allAnimals.Add(new Animal());
        allAnimals.Add(new Animal());

        foreach (Animal animal in allAnimals)
        {
            animal.setSpots(5);
        }
       Debug.WriteLine(String.Format("First animal spots: {0}", allAnimals[0].Spots));
    }
}

So the compile error went away, but the message printed out was:

First animal spots: 0

I was expecting 5 here. After reading a little bit about structs and classes in C#, the penny dropped. Each iteration through allAnimals was getting a copy of the animal and calling setSpots. If I changed the definition of Animal to a class instead of struct, I could use the original code.

class Animal
{
public int Spots;
}

Incidentally, members of structs also do not have default public accessibility in C#.