C#

0

Yesterday, I made my first multithreaded tests with XNA 4.0.

I started with my own WorkerThreadManager, a BlockingQueue and some WaitHandles to setup a Worker-Queue and Workers. The testproject was a an XNA-App just drawing circles and move them around (with collision detection on the walls). The first test was rather disappointing. I could run about 4x more circles in single-threaded mode than with multi-threaded approach.

After some profiling, I found that the BlockingQueuewas the bottleneck. I then found the class BlockingCollection from .Net 4.0. Using that one improved the speed quite a bit but still about 3x slower than the single-threaded one.

After some more research, I stumbled accross the brand-new System.Threading.Tasks Namespace with some quite interesting classes.
I could replace my whole ThreadManager with this little piece of code:

List<Agent> agentList = SomeHowGetSomeAgents();
Task[] tasks = new Task[agentList.Count];
for (int index = 0; index < agentList.Count; index++)
{
    Agent agent = agentList[index];
    Task t = Task.Factory.StartNew(() => DoSomeWork(agent));
    tasks[index] = t;
}
Task.WaitAll(tasks);

Nice, eh. That further improved the speed but again, it’s still about 2x slower than the single-threaded one…

So I found one more class called Parallel.
With this class, the code now looks like:

List<Agent> agentList = SomeHowGetSomeAgents();
Parallel.ForEach(agentList, DoSomeWork);

That one finally runs faster than the single-threaded approach. Three times faster!

I might need to redo all those tests when the DoSomeWork is much more sophisticated. But for now, Parallel seems the way to go for simple Worker-Threads.

More on this Topic:

Categories , Tags , ,

0

Today I ran into this problem for the second (and hopefully last) time. Let’s take a look at the words “sorted” and “list”. “sorted” suggests that the items of the list will somehow be sorted. So far, so good. “list” would suggest that you can put any item in the list. Specifically, it isn’t called “SortedSet”, so you could expect that you in fact can add the same item twice with the same key.

Well… that’s where you’d be wrong. The documentation says that the sorted list throws an ArgumentException if “An element with the same key already exists in the SortedList”. Unfortunately I don’t go around looking through the documentation to search for stuff like that. And in fact: you shouldn’t have to. A list is a list and not a set. And if you decide to implement a sorted list with a dictionary as the backing store, then you are – quite frankly – an idiot.

If you would like to save yourself a lot of grief, just don’t use the sorted list. Use a regular List and the Sort method. But be aware, that the Sort method uses the quicksort algorithm which is unstable (elements that are “equal” don’t keep their relative positions to one another).

Categories

2

Sometimes you want to catch and specially handle an SQL-Timeout.
To do this, just put a try-catch around your SQL-Call and catch the SqlException. Now check the Property Number if it is -2 (which stands for Timeout). That’s it.

Here’s a little Code Example how that could look like:

try
{
	RunSomeSqlQuery();
}
catch (SqlException ex)
{
	// Check if it's a TimeoutException
	if (ex.Number == -2)
	{
		// It is...
		// Do whatever you need
	}
	else
	{
		// Other Type of Exception, re-throw it or whatever
		throw;
	}
}

If you want to simulate a Timeout in your SQL-Statement, just use the WAITFOR DELAY SQL-Statement to block for some Time and therefore results in a Timeout.

Here’s an example to wait for 1 Minute:

WAITFOR DELAY '00:01:00'
Categories , ,

0

I like XML. I like it a lot. For most smaller applications a database – even SQLite and the likes – is complete overkill. Still, you have to save your application data somewhere. Enter XML.

I also like to access my application data in a typesafe manner and I don’t like to reinvent the wheel (or in this case, the XML serialization). Enter System.Xml.Serialization. Continue reading System.Xml.Serialization

Categories ,

5

I tried to make a simple Application which connects to my Digital Camera (which is detected as Portable Device) and Copy or Move the Files to my Harddisk (and put them in Directories, named by the DateTaken of the Photo). At first I tried to use the .NET FolderBrowserDialog but it was soon clear, that it can’t handle Portable Devices and doesn’t even show them.

My approach was to use the shell32.dll. It contains a BrowseForFolder which is able to handle Portable Devices. Continue reading Copy/Move Files from Portable Device

Categories , Tags , , , , ,

2

An Image can contain additional Information about the Camera or the Date it was taken. It’s quite easy to access those Information with C-Sharp. All you need to do is to add a Reference to PresentationCore and WindowsBase, include the System.Windows.Media.Imaging Namespace and use the following Code-Snippet as a StartingPoint:

public DateTime GetDateTaken(string filePath)
{
    using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
    {
        BitmapFrame bitmapFrame = BitmapFrame.Create(fileStream, BitmapCreateOptions.DelayCreation, BitmapCacheOption.None);
        BitmapMetadata bitmapMetadata = bitmapFrame.Metadata as BitmapMetadata;
        return DateTime.Parse(bitmapMetadata.DateTaken);
    }
}
Categories , Tags , , , ,

0

There are multiple possibilities to call an Operation Asynchronous from a WCF Service:

Event Based Model

In this model, you register to a Completed-Event and call your Operation with an Async appended. The Callback Method is run on the same Thread that was used to call the Async Request, so you don’t need to invoke it in case you’re modifying the UI.

Example:

public void AsyncCall()
{
    MyServiceClient client = new MyServiceClient();
    client.SomeMethodCompleted += SomeMethodCompletedCallback;
    client.SomeMethodAsync(<Your Parameters>);
}

public void SomeMethodCompletedCallback(object sender, SomeMethodCompletedEventArgs e)
{
    MyServiceClient client = sender as MyServiceClient;
    if (client != null)
    {
        client.Close();
    }
    <Your Return Value> = e.Result;
}

 

IAsyncResult Model (Client-Side)

In this model, you call your Operation with a prepending Begin. Note that the Callback is running on a Worker-Thread so if you’re modifying the UI, don’t forget to invoke in the Callback.

Example:

public void AsyncCall()
{
    MyServiceClient client = new MyServiceClient();
    client.BeginSomeMethod(<Your Parameters>, new AsyncCallback(OnEndSomeMethod), client);
}

public void OnEndSomeMethod(IAsyncResult asyncResult)
{
    MyServiceClient client = asyncResult.AsyncState as MyServiceClient;
    if (client != null)
    {
        <Your Return Value> = client.EndSomeMethod(asyncResult)
        client.Close();
    }
}

 

IAsyncResult Model (Server-Side)

This is the only “true” Asynchronous Model. It will run in a Server-Thread so you are able to get the status of a pending Operation or even cancel it. The implementation is more time-consuming than the other two but, in some cases, worth the effort.
I suggest you Google for some examples.
 

 

There is a very good series of posts at Dan Rigsby’s Blog
starting at this Post. Have a look at it to get more information and examples.

Categories , Tags , ,

0

When working with XML, you sometimes want to save some Text into the XML.
That can lead to problems when you use special Chars which then confuses the XML Parser.

To fix that you could just use multiple Replaces over your String or just use the .Net Function:
System.Security.SecurityElement.Escape

Example:

string myText = "Hello & World! <3";
string myTextXMLSafe = System.Security.SecurityElement.Escape(myText);
// myTextXMLSafe is now "Hello &amp; World! &lt;3"
Categories , Tags ,

0

C# 3.0 has a “nice” Feature called “Anonymous Types”.

Basically it is great for LINQ where you want to create a Type on the fly.
To create such a Type just use

var myAnonymousObject = new {
    Firstname = "John",
    Lastname = "Doe"
};

Now you possibly want to extend that a little and have a Function return a List of such a Type.
You can’t use List<T> because you don’t know the Type. You could use a List<object> but that’s not nice. It’s better to use a Feature called “Casting by Example”.

An Example Function implementing this Feature could look like:

public List<T> GetList<T>(T exampleObject)
{
    List<T> newList = new List<T>();
    // TODO: Fill the List somehow
    return newList;
}

You can then call this Function like this:

var someList = GetList(
    new {
        Firstname = "",
        Lastname = ""
    }
);
Categories , Tags , , , ,