i am writing a program to test WCF service performance in high concurrency circumstance.
On client side, i start many threads to call a WCF service function which returns a long list of data object.
On server side, in that function called by my client, i need to know the number of clients calling the function.
For doing that, i set a counter variable. In the beginning of the function, i add the counter by 1, but how can i decrease it after the funtion has returned the result?
int clientCount=0;
public DataObject[] GetData()
{
Interlocked.Increment(ref clientCount);
List<DataObject> result = MockDb.GetData();
return result.ToArray();
Interlocked.Decrement(ref clientCount); //can't run to here...
}
i have seen a way in c++.
Create a new class named counter.
In the constructor of the counter class, increase the variable.
And decrease it in the destructor.
In the function, make a counter object so that its constructor will be called.
And after the function returns, its destructor will be called.
Like this:
class counter
{
public:
counter(){++clientCount; /* not simply like this, need to be atomic*/}
~counter(){--clientCount; /* not simply like this, need to be atomic*/}
};
...
myfunction()
{
counter c;
//do something
return something;
}
In c# i think i can do so with the following codes, but not for sure.
public class Service1 : IService1
{
static int clientCount = 0;
private class ClientCounter : IDisposable
{
public ClientCounter()
{
Interlocked.Increment(ref clientCount);
}
public void Dispose()
{
Interlocked.Decrement(ref clientCount);
}
}
public DataObject[] GetData()
{
using (ClientCounter counter = new ClientCounter())
{
List<DataObject> result = MockDb.GetData();
return result.ToArray();
}
}
}
i write a counter class implement the IDisposable interface.
And put my function codes into a using block.
But it seems that it doesn't work so good.
No matter how many threads i start, the clientCount variable is up to 3.
Any advise would be appreciated.
