Eddie Garmon's Weblog

Doh! Synced Actions and Funcs

2008-07-16T13:30:00Z

After a little more use of the Synchronized<T>, I realized that over half the time I was 'returning true' just to satisfy Func<T, bool> when all that was really needed was an Action<T>.

Read, ReadUpgradeableToWrite, and Write are all overloaded now to take either a Action<T> or a Func<T, TReturn>.

You can get the code here.

Sync Enumerator update.

2008-06-30T13:40:00Z

After a few more unit tests, I have fixed an issue with the GetSyncEnumerator method.

The origional had 2 issues.

was that the lock was being released too soon.
was that a write in the middle of a long enumeration would cause a race and/or a deadlock.

The fix was to 'write' lock for enumeration, and not to 'use' the lock, but to let the design of IDisposable on the enumerator itself work as intended.

/// <summary>
/// Gets a synchronized enumerator.
/// </summary>
/// <typeparam name="TValue">The type of the value.</typeparam>
/// <param name="getEnumeratorFunction">The get enumerator function.</param>
/// <returns></returns>
public IEnumerator<TValue> GetSynchronizedEnumerator<TValue>(Func<T, IEnumerator<TValue>> getEnumeratorFunction) {
Guard.ArgumentNotNull(getEnumeratorFunction, "getEnumeratorFunction");

    //cheat here and write block for enumeration.
    //otherwize a write during a long enumeration can cause a race.
    SynchronizedWriter synchronizedWriter = null;
    SynchronizedEnumerator<TValue> synchronizedEnumerator = null;
    try {
        synchronizedWriter = new SynchronizedWriter(_readerWriter);
        IEnumerator<TValue> enumerator = getEnumeratorFunction(_instance);
        synchronizedEnumerator = new SynchronizedEnumerator<TValue>(synchronizedWriter, enumerator);
        return synchronizedEnumerator;
        //When the enumerator disposes, the lock is released.
    } catch {
        if (synchronizedEnumerator != null) {
            synchronizedEnumerator.Dispose();
        } else if (synchronizedWriter != null) {
            synchronizedWriter.Dispose();
        }
        throw;
    }
}

The linked code has been updated.

Synchronization, ReaderWriterLockSlim, and Lambdas

2008-06-27T17:43:00Z

Here is a synchronization wrapper that I wrote to wrap any object, and an implementation of a SynchronizedDictionary to show how to use it.

I offer this code as-is without any waranty to fitness, to the public domain, for any purpose you see fit.

Get a text version of this code here.

On with the show:

[UPDATE: get the code via the link, only ideas are shown below.]

Synchronized<T>:
wraps an instance of type T.

Contains 3 functions:

public TValue Read<TValue>(Func<T, TValue> readFunction)
- inside a reader lock, executes the readFunction.
public bool Write(Func<T, bool> writeFunction)
- inside a writer lock, executes the writeFunction, which should return the success nature of the write.
public IEnumerator<TValue> GetSynchronizedEnumerator<TValue>(Func<T, IEnumerator<TValue>> getEnumeratorFunction)
- returns an enumerator wrapped in a lock that releases when it is disposed.

An example of how to use the Synchronized<T> class:

namespace SynapticPop.DataStructures.Dictionaries {
public class SynchronizedDictionary<TKey, TValue> : IDictionary<TKey, TValue> {
    private readonly Synchronized<IDictionary<TKey, TValue>> _synchronized;

    public SynchronizedDictionary(IDictionary<TKey, TValue> dictionary) {
      _synchronized = new Synchronized<IDictionary<TKey, TValue>>(dictionary);
    }

    ...

    public int Count {
      get { return _synchronized.Read(dictionary => dictionary.Count); }
    }

    ...

    public void Add(TKey key, TValue value) {
      _synchronized.Write(dictionary => { dictionary.Add(key, value); return true; });
    }

    ...

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() {
      return _synchronized.GetSynchronizedEnumerator(dictionary => dictionary.GetEnumerator());
    }

    ...
}

NUnit extensions updated for 2.2.2

2005-10-19T12:55:00Z

I have updated the ObjectGraphAssert and TimedTest extensions for NUnit 2.2.2.

You can get them here

per the read me...

ObjectGraphAssert - allows you to compare 2 objects via all their properties, and the properties of all children in sub collections.
TimedTest - a time limited test. This helps keep your long running tests from going over a set amount of time.
There only needs to be one change in the current source of NUnit (2.2.2) to support this version of the timed test. In the TemplateTestCase class, change the method signature of doTestCase from private void to protected virtual void.

Happy Testing

Why a Timed Test in NUnit 2.2?

2005-02-14T05:38:00Z

In response to questions about the value add of Timed Tests in NUnit: There are several uses for timed tests, here are 6, and an update to the TimedTest code... (read more) ...(read more)

NUnit 2.2 Timed Tests...

2005-02-09T07:26:00Z

Well I finally got around to working on some more NUnit enhancements. I have finished creating an extension for a timed test with resolution in milliseconds. (read more)...(read more)

Visual Studio .Net C# Item Templates Version 1.1.0

2005-02-08T19:54:00Z

Updates were made for design time support for the 2 typed collection classes, courtesy Brendan Tompkins. I also updated the Registry class, as I found that it was not in sync with the template that I currently use. (read more)...(read more)

More Visual Studio Templates (with Installer)

2005-02-08T08:06:00Z

Due to feedback from local sources, I am urged to share my most common Visual Studio Templates. Packaged in an installer for both VS 2002 and VS 2003 are the following templates: a class template, an enumeration template, an exception template, a nunit test template, a registry template, a typed collection template, and a typed hashed collection template ... read more ...(read more)

Cleaning the Visual Studio 2005 MRU list.

2005-02-04T05:09:00Z

After playing with Visual Studio 2005 for a while, I have collecter many a deal link in my most recently used items list. Unfortunately, VS2k5 always shows every item in the MRU list on the start page... (read more) ...(read more)

Quickest way to create a repeating string in c#?

2005-01-12T20:48:00Z

int repeatCount = 10;
string value = "hello world.";
string repeated = string.Join(value, new string[repeatCount + 1]);
Console.WriteLine(repeated);

More Extending Nunit (version 2.2)

2005-01-12T06:08:00Z

There is some slight code duplication (from the NUnit framework), but it works with 1.X and 2.0 frameworks...

ObjectGraphAssert and ObjectGraphFixture: Here is the zip.

If you create a failing test, please pass it on so I can update my code.

Enjoy

Delimited String Builder

2004-10-30T01:52:00Z

This went out in the DNR chat room... enjoy.

http://synapticpop.com/code/delimitedstringbuilder.cs.txt

NewsGator wishlist...

2004-01-23T16:57:00Z

Number of recent posts to display: Disable or set to 0 causes a bug, Fix.

Mark all read and delete all on folder bars in newspaper view. (specific to folder/subfolders/)

Enable newspaper view on subfolders when they exist. (ie sections of a newspaper.)

Newspaper view: Delete a post, expand any folder below that one, and delete a post in the folder, causes a script error, Fix.

Auto-Incrementing Build Numbers (C# for VS.Net)

2003-12-04T00:34:00Z

I finally got fed up with manually updating the build numbers in the AssemblyInfo.cs files. I needed an automated solution, so now I have one, even though it is definately more of a hack than good code.

To the point, I created a simple console app that I placed in my bin directory, and use a Pre-BuildEvent to call. (i.e. BuildNumberIncrementer “Path to a\AssemblyInfo.cs”).

The hack that is BuildNumberIncrementer goes like :

   1:  using System;

   2:  using System.IO;

   3:  using System.Text.RegularExpressions;

4:

   5:  namespace BuildNumberIncrementer {

   6:      class EntryPoint {

   7:          [STAThread]

   8:          static void Main(string[] args) {

   9:              if (args.Length != 1) {

  10:                  Console.WriteLine("Please specify the 'AssemblyInfo.cs' you want to update.");

  11:                  return;

  12:              }

  13:              string infoPath = args[0];

14:

  15:              if (!infoPath.EndsWith("AssemblyInfo.cs")) {

  16:                  Console.WriteLine("Please specify the 'AssemblyInfo.cs' you want to update.");

  17:                  return;

  18:              }

19:

  20:              if (!File.Exists(infoPath)) {

  21:                  Console.WriteLine(infoPath + " does not exist.");

  22:                  return;

  23:              }

24:

  25:              StreamReader reader = File.OpenText(infoPath);

  26:              string contents = reader.ReadToEnd();

  27:              reader.Close();

  28:              Regex version = new Regex(@"(\d+\.\d+\.\d+\.)(\d+)");

  29:              Match versionMatch = version.Match(contents);

  30:              string oldVersion = versionMatch.Value;

  31:              string newVersion = versionMatch.Groups[1].Value + (Convert.ToUInt32(versionMatch.Groups[2].Value) + 1).ToString();

  32:              contents = contents.Replace(oldVersion, newVersion);

  33:              StreamWriter writer = File.CreateText(infoPath);

  34:              writer.Write(contents);

  35:              writer.Close();

36:

  37:              Console.WriteLine(string.Format("New version is [{0}]", newVersion));

  38:          }

  39:      }

  40:  }