In short, “yield” allows you to return an IEnumerable without creating a List.

Example: (old way)

IEnumerable<Car> FindBlueCars(){
	var blueCars = new List<Car>();
	foreach (var c in _allCars)
		if (c.IsBlue())
			blueCars.Add(c);
	return blueCars;
}

Example: (new way)

IEnumerable<Car> FindBlueCars(){
	foreach (var c in _allCars)
		if (c.IsBlue())
			yield return c;
}

Saves some typing. MSDN reference for yield.

Read me blog on entrepreneurship: Techneur
Follow me on Twitter: @jprichardson

-JP

Here’s how you can use it:

BenchmarkTimer.Start("Long running algorithm");
for (int x = 0; x < 3; ++x) {
	BenchmarkTimer.Start("Small running algorithm");
	Thread.Sleep(1000);
	BenchmarkTimer.StopAndOutput();
}
BenchmarkTimer.StopAndOutput();

Output:
Small running algorithm: 1000.3712 ms
Small running algorithm: 1000.3712 ms
Small running algorithm: 1000.3712 ms
Long running algorithm: 3001.1136 ms

You can find my entire C# CommonLib library here: http://github.com/jprichardson/CommonLib

Here is the relevant class:

public static class BenchmarkTimer
	{
		private static Stack<BenchmarkData> _startStack = new Stack<BenchmarkData>();

		public static void Start() {
			_startStack.Push(new BenchmarkData());
		}

		public static void Start(string label) {
			var bd = new BenchmarkData() { Label = label };
			_startStack.Push(bd);
		}

		public static TimeSpan Stop() {
			var stop = DateTime.Now;
			var startBD = _startStack.Pop();
			return stop - startBD.DateTime;
		}

		public static void StopAndOutput() {
			var stop = DateTime.Now;
			var startBD = _startStack.Pop();

			var delta = stop - startBD.DateTime;

			var lbl = "{0}: {1} ms";
			Console.WriteLine(String.Format(lbl, startBD.Label, delta.TotalMilliseconds));
		}

		private class BenchmarkData
		{
			public DateTime DateTime { get; set; }
			public string Label { get; set; }

			public BenchmarkData(){
				this.DateTime = DateTime.Now;
				this.Label = "";
			}
		}
	}

Follow me on Twitter: @jprichardson
Read my blog entrepreneurship: Techneur

-JP

 <Storyboard x:Key="mouseFadeIn">
    <DoubleAnimation
	Duration="0:0:5"
	Storyboard.TargetName="myStackPanel"
	Storyboard.TargetProperty="(UIElement.Opacity)"
	From="0.25"
	To="1.0"/>
</StoryBoard>

This will cause a the Opacity of the element to change from 0.25 to 1.0 over a period of 5 seconds. Note: this should be put in the “Resources” tag. So, if it’s a Window it would be “Window.Resources” or if it’s a UserControl it would be “UserControl.Resources”…
Snippet:

<UserControl.Resources>
  <StoryBoard key="blah">...

So how do we get this to trigger on a mouse over? By using Triggers of course!
Snippet:

<UserControl.Triggers>
	<EventTrigger RoutedEvent="Mouse.MouseEnter" SourceName="myStackPanel">
		<BeginStoryboard Storyboard="{StaticResource mouseFadeIn}" />
	</EventTrigger>
</UserControl.Triggers>

If you want to create a Fade Out effect, just use the “Mouse.MouseLeave” event and reverse the animation. You can even have multiple animations in a StoryBoard. They can run simultaneously or sequentially. If you have multiple animations in a StoryBoard and you want them to run sequentially, you need to add a “BeginTime” attribute. This ensures that the animation is executed after the previous animation(s).

Follow me on Twitter: @jprichardson

-JP

So how would you do this? The first solution that came to mine is depth-first traversal of the tree. This method could be adapted to any tree structure in just about any language.

We need a callback function for everytime we ‘hit’ a tree node. Let’s create an interface called ‘Action’:
Action.java:

public interface Action<T> {
	public void execute(T object);
}

Now, we need to create a file called TreeItemUtil.java. This will include the algorithm. The algorithm is really straightforward, it just uses a stack for each node and iterates the stack. If a node has children, they are pushed onto the stack.
TreeItemUtil.java:

public class TreeItemUtil {

	public static Collection<TreeItem> fetchChildren(TreeItem ti){
		List<TreeItem> children = new ArrayList<TreeItem>();

		for (int i = 0; i < ti.getChildCount(); ++i)
			children.add(ti.getChild(i));
		return children;
	}

	public static void traverseDfs(TreeItem root, Action<TreeItem> onNode){
		if (onNode == null)
			throw new IllegalArgumentException("Must pass an action.");

		Stack<TreeItem> children = new Stack<TreeItem>();
		children.add(root);

		while (!children.isEmpty()){
			TreeItem current = children.pop();
			onNode.execute(current);
			List<TreeItem> currentChildren = fetchChildren(current);
			children.addAll(currentChildren);
		}
	}
}

Here is our TreeItemUtilTest.java that uses Mockito:

public void testTraverseDfs(){
		final StringBuffer sb = new StringBuffer();

		TreeItem a = createMockedTI("a");
		TreeItem b = createMockedTI("b");
		TreeItem c = createMockedTI("c");
		TreeItem d = createMockedTI("d");
		TreeItem e = createMockedTI("e");
		TreeItem f = createMockedTI("f");
		TreeItem g = createMockedTI("g");
		TreeItem h = createMockedTI("h");
		TreeItem i = createMockedTI("i");
		TreeItem j = createMockedTI("j");
		TreeItem k = createMockedTI("k");
		TreeItem l = createMockedTI("l");
		TreeItem m = createMockedTI("m");
		TreeItem n = createMockedTI("n");
		TreeItem o = createMockedTI("o");
		TreeItem p = createMockedTI("p");

		addMockedChildren(a, b, o);
		addMockedChildren(b, c, i);
		addMockedChildren(o, n, p);
		addMockedChildren(c, d);
		addMockedChildren(i, j, m);
		addMockedChildren(d, e);
		addMockedChildren(j, k, l);
		addMockedChildren(e, f, g);
		addMockedChildren(g, h);

		TreeItemUtil.traverseDfs(a, new Action<TreeItem>(){
			public void execute(TreeItem current){
				sb.append(current.getText());
			}
		});

		//I was assuming it would be leftmost child first, if so, it would be in alphabetical order
		//but it starts with rightmost node first.
		assertEquals("aopnbimjlkcdeghf", sb.toString());
	}

	private TreeItem createMockedTI(String text){
		TreeItem ti = mock(TreeItem.class);
		when(ti.getText()).thenReturn(text);
		return ti;
	}

	private void addMockedChildren(TreeItem parent, TreeItem... children){
		for (int x = 0; x < children.length; ++x){
			when(parent.getChild(x)).thenReturn(children[x]);
			when(children[x].getParentItem()).thenReturn(parent);
		}

		when(parent.getChildCount()).thenReturn(children.length);
	}

Now for the actual algorithm that clones the TreeItem into a TreeItem with checkboxes:

private TreeItem cloneTreeItemsWithCheckboxes(TreeItem root){
		final HashMap<TreeItem, TreeItem> oldNew = new HashMap<TreeItem, TreeItem>();

		TreeItemUtil.traverseDfs(root, new Action<TreeItem>(){
			public void execute(TreeItem current){
				TreeItem newTi = new TreeItem(new CheckBox(current.getText()));
				newTi.setUserObject(current.getUserObject());
				oldNew.put(current, newTi);

				if (current.getParentItem() != null && oldNew.containsKey(current.getParentItem())){
					TreeItem newParent = oldNew.get(current.getParentItem());
					newParent.addItem(newTi);
				}
			}
		});

		return oldNew.get(root);
	}

Follow me on Twitter: @jprichardson

-JP

Then the call is as simple as:

Text::Levenshtein.distance('hello', 'hell')

Follow me on Twitter: @jprichardson

-JP

Window.addWindowClosingHandler(new ClosingHandler(){
	@Override public void onWindowClosing(ClosingEvent event) {
		event.setMessage("If you leave, you may lose data. Continue?");
	}
});

Simple as pie. If event.setMessage is called, a prompt will be displayed for you.

Follow me on Twitter: @jprichardson

-JP

I’m pleased that you find my snippet blog cool enough to subscribe. I know that you’re use to me posting about once every six months and if you wanted to read my daily writings you would subscribe over at Techneur. But now that I’ve discovered that Hosted WordPress (blogs hosted by wordpress.com) supports syntax highlighting, you’ll probably see a lot more posts. Prepare for the incoming barrage of posts.

Yours truly,

JP

No, but seriously… I didn’t know about this! I’m stoked, I got tired of looking at the crappy background of my code!

Deserialize:

public static T ReadFromFile(string file) {
	XmlSerializer xs = new XmlSerializer(typeof(T));
	StreamReader sr = new StreamReader(file);
	T ret = (T)xs.Deserialize(sr);
	sr.Close();
	return ret;
}

Serialize:

public static void WriteToFile(T obj, string file) {
	XmlSerializer xs = new XmlSerializer(typeof(T));
	StreamWriter sw = new StreamWriter(file);
	xs.Serialize(sw, obj);
	sw.Close();
}

Enjoy.

I started inserting the data into my database; lo and behold, it was taking forever! In fact, it took most of a full working day to insert my data. I knew something wasn’t right. A simple Google search pointed me to the SQLite FAQ. It turns out that SQLite wraps every INSERT into a transaction. Simple solution: start a transaction and perform multiple INSERTs. I needed my inserts to be fast, so I just had to write a class to encapsulate this.

It’s very simple to use. Make sure that your SQLite database file has been created and your table has been created as well.

Let’s assume your database schema looks like the following:
Id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
LastName VARCHAR(16) NOT NULL,
Height REAL NOT NULL

You would then use SQLiteBulkInsert as follows:

SQLiteBulkInsert sbi = new SQLiteBulkInsert(yourDatabaseConnectionObject, "yourTableName");
sbi.AddParameter("LastName", DbType.String);
sbi.AddParameter("Height", DbType.Single);

You can then insert records:

for (int x = 0; x < 10000; x++)
	sbi.Insert(new object[]{someString, someFloat});
sbi.Flush();

That’s it! You should look at the file SQLiteBulkInsertTest.cs for more details.

SQLiteBulkInsert.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SQLite;
using System.Data;

namespace YourProject.Data.SQLite
{
	public class SQLiteBulkInsert
	{
		private SQLiteConnection m_dbCon;
		private SQLiteCommand m_cmd;
		private SQLiteTransaction m_trans;

		private Dictionary m_parameters = new Dictionary();

		private uint m_counter = 0;

		private string m_beginInsertText;

		public SQLiteBulkInsert(SQLiteConnection dbConnection, string tableName) {
			m_dbCon = dbConnection;
			m_tableName = tableName;

			StringBuilder query = new StringBuilder(255);
			query.Append("INSERT INTO ["); query.Append(tableName); query.Append("] (");
			m_beginInsertText = query.ToString();
		}

		private bool m_allowBulkInsert = true;
		public bool AllowBulkInsert { get { return m_allowBulkInsert; } set { m_allowBulkInsert = value; } }

		public string CommandText {
			get {
				if (m_parameters.Count < 1)
					throw new SQLiteException("You must add at least one parameter.");

				StringBuilder sb = new StringBuilder(255);
				sb.Append(m_beginInsertText);

				foreach (string param in m_parameters.Keys) {
					sb.Append('[');
					sb.Append(param);
					sb.Append(']');
					sb.Append(", ");
				}
				sb.Remove(sb.Length - 2, 2);

				sb.Append(") VALUES (");

				foreach (string param in m_parameters.Keys) {
					sb.Append(m_paramDelim);
					sb.Append(param);
					sb.Append(", ");
				}
				sb.Remove(sb.Length - 2, 2);

				sb.Append(")");

				return sb.ToString();
			}
		}

		private uint m_commitMax = 10000;
		public uint CommitMax { get { return m_commitMax; } set { m_commitMax = value; } }

		private string m_tableName;
		public string TableName { get { return m_tableName; } }

		private string m_paramDelim = ":";
		public string ParamDelimiter { get { return m_paramDelim; } }

		public void AddParameter(string name, DbType dbType) {
			SQLiteParameter param = new SQLiteParameter(m_paramDelim + name, dbType);
			m_parameters.Add(name, param);
		}

		public void Flush() {
			try {
				if (m_trans != null)
					m_trans.Commit();
			}
			catch (Exception ex) { throw new Exception("Could not commit transaction. See InnerException for more details", ex); }
			finally {
				if (m_trans != null)
					m_trans.Dispose();

				m_trans = null;
				m_counter = 0;
			}
		}

		public void Insert(object[] paramValues) {
			if (paramValues.Length != m_parameters.Count)
				throw new Exception("The values array count must be equal to the count of the number of parameters.");

			m_counter++;

			if (m_counter == 1) {
				if (m_allowBulkInsert)
					m_trans = m_dbCon.BeginTransaction();

				m_cmd = m_dbCon.CreateCommand();
				foreach (SQLiteParameter par in m_parameters.Values)
					m_cmd.Parameters.Add(par);

				m_cmd.CommandText = this.CommandText;
			}

			int i = 0;
			foreach (SQLiteParameter par in m_parameters.Values) {
				par.Value = paramValues[i];
				i++;
			}

			m_cmd.ExecuteNonQuery();

			if (m_counter == m_commitMax) {
				try {
					if (m_trans != null)
						m_trans.Commit();
				}
				catch (Exception ex) { }
				finally {
					if (m_trans != null) {
						m_trans.Dispose();
						m_trans = null;
					}

					m_counter = 0;
				}
			}
		}
	}
}

SQLiteBulkInsertTest.cs:

using YourProject.Data.SQLite;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Data.SQLite;
using System.Data;
using System.IO;
using System;

namespace TestYourProject
{
    ///
    ///This is a test class for SQLiteBulkInsertTest and is intended
    ///to contain all SQLiteBulkInsertTest Unit Tests
    ///
	[TestClass()]
	public class SQLiteBulkInsertTest
	{
		private static string m_testDir;
		private static string m_testFile;
		private static string m_testTableName = "test_table";
		private static string m_connectionString;

		private static string m_deleteAllQuery = "DELETE FROM [{0}]";
		private static string m_countAllQuery = "SELECT COUNT(id) FROM [{0}]";
		private static string m_selectAllQuery = "SELECT * FROM [{0}]";

		private static SQLiteConnection m_dbCon;
		private static SQLiteCommand m_deleteAllCmd;
		private static SQLiteCommand m_countAllCmd;
		private static SQLiteCommand m_selectAllCmd;

		private TestContext testContextInstance;

		///
		///Gets or sets the test context which provides
		///information about and functionality for the current test run.
		///
		public TestContext TestContext {
			get {
				return testContextInstance;
			}
			set {
				testContextInstance = value;
			}
		}

		#region Additional test attributes
		//
		//You can use the following additional attributes as you write your tests:
		//
		//Use ClassInitialize to run code before running the first test in the class
		[ClassInitialize()]
		public static void MyClassInitialize(TestContext testContext){
			Random rand = new Random(Environment.TickCount);
			int rn = rand.Next(0, int.MaxValue);
			m_testDir = @"C:\SqliteBulkInsertTest-" + rn + @"\";
			m_testFile = m_testDir + "db.sqlite";

			if (!Directory.Exists(m_testDir))
				Directory.CreateDirectory(m_testDir);

			if (!File.Exists(m_testFile)) {
				FileStream fs = File.Create(m_testFile);
				fs.Close();
			}

			m_connectionString = string.Format(@"data source={0};datetimeformat=Ticks", m_testFile);
			m_dbCon = new SQLiteConnection(m_connectionString);
			m_dbCon.Open();

			SQLiteCommand cmd = m_dbCon.CreateCommand();
			string query = "CREATE TABLE IF NOT EXISTS [{0}] (id INTEGER PRIMARY KEY AUTOINCREMENT, somestring VARCHAR(16), somereal REAL, someint INTEGER(4), somedt DATETIME)";
			query = string.Format(query, m_testTableName);
			cmd.CommandText = query;
			cmd.ExecuteNonQuery();
		}
		//
		//Use ClassCleanup to run code after all tests in a class have run
		[ClassCleanup()]
		public static void MyClassCleanup(){
			m_dbCon.Close();

			File.Delete(m_testFile);
			Directory.Delete(m_testDir);
		}
		#endregion

		private void AddParameters(SQLiteBulkInsert target) {
			target.AddParameter("somestring", DbType.String);
			target.AddParameter("somereal", DbType.String);
			target.AddParameter("someint", DbType.Int32);
			target.AddParameter("somedt", DbType.DateTime);
		}

		private long CountRecords() {
			m_countAllCmd = m_dbCon.CreateCommand();
			m_countAllCmd.CommandText = string.Format(m_countAllQuery, m_testTableName);

			long ret = (long)m_countAllCmd.ExecuteScalar();
			m_countAllCmd.Dispose();

			return ret;
		}

		private void DeleteRecords() {
			m_deleteAllCmd = m_dbCon.CreateCommand();
			m_deleteAllCmd.CommandText = string.Format(m_deleteAllQuery, m_testTableName);

			m_deleteAllCmd.ExecuteNonQuery();
			m_deleteAllCmd.Dispose();
		}

		private SQLiteDataReader SelectAllRecords() {
			m_selectAllCmd = m_dbCon.CreateCommand();
			m_selectAllCmd.CommandText = string.Format(m_selectAllQuery, m_testTableName);
			return m_selectAllCmd.ExecuteReader();
		}

		[TestMethod()]
		public void AddParameterTest() {
			SQLiteBulkInsert target = new SQLiteBulkInsert(m_dbCon, m_testTableName);
			AddParameters(target);

			string pd = target.ParamDelimiter;
			string expectedStmnt = "INSERT INTO [{0}] ([somestring], [somereal], [someint], [somedt]) VALUES ({1}somestring, {2}somereal, {3}someint, {4}somedt)";
			expectedStmnt = string.Format(expectedStmnt, m_testTableName, pd, pd, pd, pd);
			Assert.AreEqual(expectedStmnt, target.CommandText);
		}

		[TestMethod()]
		public void SQLiteBulkInsertConstructorTest() {
			SQLiteBulkInsert target = new SQLiteBulkInsert(m_dbCon, m_testTableName);
			Assert.AreEqual(m_testTableName, target.TableName);

			bool wasException = false;
			try {
				string a = target.CommandText;
			}
			catch (SQLiteException ex) { wasException = true; }

			Assert.IsTrue(wasException);
		}

		[TestMethod()]
		public void CommandTextTest() {
			SQLiteBulkInsert target = new SQLiteBulkInsert(m_dbCon, m_testTableName);
			AddParameters(target);

			string pd = target.ParamDelimiter;
			string expectedStmnt = "INSERT INTO [{0}] ([somestring], [somereal], [someint], [somedt]) VALUES ({1}somestring, {2}somereal, {3}someint, {4}somedt)";
			expectedStmnt = string.Format(expectedStmnt, m_testTableName, pd, pd, pd, pd);
			Assert.AreEqual(expectedStmnt, target.CommandText);
		}

		[TestMethod()]
		public void TableNameTest() {
			SQLiteBulkInsert target = new SQLiteBulkInsert(m_dbCon, m_testTableName);
			Assert.AreEqual(m_testTableName, target.TableName);
		}

		[TestMethod()]
		public void InsertTest() {
			SQLiteBulkInsert target = new SQLiteBulkInsert(m_dbCon, m_testTableName);

			bool didThrow = false;
			try {
				target.Insert(new object[] { "hello" }); //object.length must equal the number of parameters added
			}
			catch (Exception ex) { didThrow = true; }
			Assert.IsTrue(didThrow);

			AddParameters(target);

			target.CommitMax = 4;
			DateTime dt1 = DateTime.Now; DateTime dt2 = DateTime.Now; DateTime dt3 = DateTime.Now; DateTime dt4 = DateTime.Now;
			target.Insert(new object[] { "john", 3.45f, 10, dt1 });
			target.Insert(new object[] { "paul", -0.34f, 100, dt2 });
			target.Insert(new object[] { "ringo", 1000.98f, 1000, dt3 });
			target.Insert(new object[] { "george", 5.0f, 10000, dt4 });

			long count = CountRecords();
			Assert.AreEqual(4, count);

			SQLiteDataReader reader = SelectAllRecords();

			Assert.IsTrue(reader.Read());
			Assert.AreEqual("john", reader.GetString(1)); Assert.AreEqual(3.45f, reader.GetFloat(2));
			Assert.AreEqual(10, reader.GetInt32(3)); Assert.AreEqual(dt1, reader.GetDateTime(4));

			Assert.IsTrue(reader.Read());
			Assert.AreEqual("paul", reader.GetString(1)); Assert.AreEqual(-0.34f, reader.GetFloat(2));
			Assert.AreEqual(100, reader.GetInt32(3)); Assert.AreEqual(dt2, reader.GetDateTime(4));

			Assert.IsTrue(reader.Read());
			Assert.AreEqual("ringo", reader.GetString(1)); Assert.AreEqual(1000.98f, reader.GetFloat(2));
			Assert.AreEqual(1000, reader.GetInt32(3)); Assert.AreEqual(dt3, reader.GetDateTime(4));

			Assert.IsTrue(reader.Read());
			Assert.AreEqual("george", reader.GetString(1)); Assert.AreEqual(5.0f, reader.GetFloat(2));
			Assert.AreEqual(10000, reader.GetInt32(3)); Assert.AreEqual(dt4, reader.GetDateTime(4));

			Assert.IsFalse(reader.Read());

			DeleteRecords();

			count = CountRecords();
			Assert.AreEqual(0, count);
		}

		[TestMethod()]
		public void FlushTest() {
			string[] names = new string[] { "metalica", "beatles", "coldplay", "tiesto", "t-pain", "blink 182", "plain white ts", "staind", "pink floyd" };
			Random rand = new Random(Environment.TickCount);

			SQLiteBulkInsert target = new SQLiteBulkInsert(m_dbCon, m_testTableName);
			AddParameters(target);

			target.CommitMax = 1000;

			//Insert less records than commitmax
			for (int x = 0; x < 50; x++)
				target.Insert(new object[] { names[rand.Next(names.Length)], (float)rand.NextDouble(), rand.Next(50), DateTime.Now });

			//Close connect to verify records were not inserted
			m_dbCon.Close();

			m_dbCon = new SQLiteConnection(m_connectionString);
			m_dbCon.Open();

			long count = CountRecords();
			Assert.AreEqual(0, count);

			//Now actually verify flush worked
			target = new SQLiteBulkInsert(m_dbCon, m_testTableName);
			AddParameters(target);

			target.CommitMax = 1000;

			//Insert less records than commitmax
			for (int x = 0; x < 50; x++)
				target.Insert(new object[] { names[rand.Next(names.Length)], (float)rand.NextDouble(), rand.Next(50), DateTime.Now });

			target.Flush();

			count = CountRecords();
			Assert.AreEqual(50, count);

			//Close connect to verify flush worked
			m_dbCon.Close();

			m_dbCon = new SQLiteConnection(m_connectionString);
			m_dbCon.Open();

			count = CountRecords();
			Assert.AreEqual(50, count);

			DeleteRecords();
			count = CountRecords();
			Assert.AreEqual(0, count);
		}

		[TestMethod()]
		public void CommitMaxTest() {
			SQLiteBulkInsert target = new SQLiteBulkInsert(m_dbCon, m_testTableName);

			target.CommitMax = 4;
			Assert.AreEqual(4, target.CommitMax);

			target.CommitMax = 1000;
			Assert.AreEqual(1000, target.CommitMax);
		}

		//SPEED TEST
		[TestMethod()]
		public void AllowBulkInsertTest() {
			string[] names = new string[] { "metalica", "beatles", "coldplay", "tiesto", "t-pain", "blink 182", "plain white ts", "staind", "pink floyd"};
			Random rand = new Random(Environment.TickCount);

			SQLiteBulkInsert target = new SQLiteBulkInsert(m_dbCon, m_testTableName);
			AddParameters(target);

			const int COUNT = 100;

			target.CommitMax = COUNT;

			DateTime start1 = DateTime.Now;
			for (int x = 0; x < COUNT; x++)
				target.Insert(new object[] { names[rand.Next(names.Length)], (float)rand.NextDouble(), rand.Next(COUNT), DateTime.Now });

			DateTime end1 = DateTime.Now;
			TimeSpan delta1 = end1 - start1;

			DeleteRecords();

			target.AllowBulkInsert = false;
			DateTime start2 = DateTime.Now;
			for (int x = 0; x < COUNT; x++)
				target.Insert(new object[] { names[rand.Next(names.Length)], (float)rand.NextDouble(), rand.Next(COUNT), DateTime.Now });

			DateTime end2 = DateTime.Now;
			TimeSpan delta2 = end2 - start2;

			//THIS MAY FAIL DEPENDING UPON THE MACHINE THE TEST IS RUNNING ON.
			Assert.IsTrue(delta1.TotalSeconds < 0.1); //approx true for 100 recs 			Assert.IsTrue(delta2.TotalSeconds > 1.0); //approx true for 100 recs;

			//UNCOMMENT THIS TO MAKE IT FAIL AND SEE ACTUAL NUMBERS IN FAILED REPORT
			//Assert.AreEqual(delta1.TotalSeconds, delta2.TotalSeconds);

			DeleteRecords();
		}
	}
}

Enjoy. Drop me a line if you have any problems.

Follow me on Twitter: @jprichardson

-JP

Gears offers a method to allow a user to select file(s). You can then use the returned “getFiles” method of the “OpenFilesEvent” object to find out what file(s) the user selected. Each “File” class has a method called “getBlob” that returns a “Blob” object. However, each blob object doesn’t provide any direct way to access the blobs contents. Many people haven’t found a way to read the blob contents.

I wrote a class to access the contents of the blob. The class is called “BlobReader” and is very simple to use. The trick lies in the fact that in Javascript we can access the “getBytes” method of the blob.

Here is an example reading line by line of a text file:

try {
	Desktop dt = Factory.getInstance().createDesktop();
	dt.openFiles(new OpenFilesHandler(){
		public void onOpenFiles(OpenFilesEvent event) {
			File[] files = event.getFiles();
			File file = files[0];
			Blob data = file.getBlob();

			BlobReader br = new BlobReader(data);
			while (!br.endOfBlob())
				Window.alert(br.readLine());
			}
		}, true);
} catch (Exception ex){
	Window.alert(ex.toString());
}

Here is BlobReader.java:

package com.yourpackage.client;
import com.google.gwt.core.client.JsArrayInteger;
import com.google.gwt.gears.client.blob.Blob;

public class BlobReader {

	private final int CHUNK_SIZE = 1024;

	public BlobReader(Blob blob){
		this.blob = blob;
	}

	private Blob blob;
	public Blob getBlob(){ return this.blob; }

	private int blobPointer = 0;
	public int getBlobPointer(){ return this.blobPointer; }

	public boolean endOfBlob(){
		return (blobPointer >= blob.getLength());
	}

	public byte[] readAllBytes(){
		return getBlobBytes(this.blob);
	}

	public String readAllText(){
		int size = this.blob.getLength();
		StringBuilder sb = new StringBuilder(size);

		JsArrayInteger bytes = getBlobBytes(this.blob, 0, size);
		for (int x = 0; x < size; x++)
			sb.append((char)bytes.get(x));

		return sb.toString();
	}

	public String readLine(){
		int size = CHUNK_SIZE;
		boolean foundEndOfLine = false;

		JsArrayInteger bytes;
		StringBuilder sb = new StringBuilder(CHUNK_SIZE);

		while (!foundEndOfLine && size > 0){
			int dif = this.blob.getLength() - this.blobPointer; //remainder of the data
			if (dif < CHUNK_SIZE)
				size = dif;
			bytes = getBlobBytes(this.blob, this.blobPointer, size);

			for (int x = 0; x < size; x++){
				blobPointer++;
				int b = bytes.get(x);
				if (b == 10){ //newline
					foundEndOfLine = true;
					break;
				}
				sb.append((char)b);

				if (this.getBlobPointer() % 1000000 == 0)
					Window.alert("" + this.getBlobPointer());
			}
		}

		if (sb.substring(sb.length() - 1) == "\r")
			sb.deleteCharAt(sb.length() - 1);

		return sb.toString();
	}

       public void reset(){
		this.blobPointer = 0;
	}

	private byte[] getBlobBytes(Blob b){
		JsArrayInteger array = getBlobBytes(b, 0, b.getLength());
		byte[] bytes = new byte[array.length()];
		for (int x = 0; x < bytes.length; x++)
			bytes[x] = (byte) array.get(x); //in google docs we are told these are from 0-255

		return bytes;
	}

	private native JsArrayInteger getBlobBytes(Blob b, int offset, int length) /*-{
		return b.getBytes(offset, length);
	}-*/;
}

Notes:
1) This hasn’t been thoroughly tested/debugged.
2) At the time of this writing, I’m using Gears 0.5 with the GWT-Gears 1.2.1. In the current GWT-Gears svn trunk you can see upcoming support for the GWT methods “getNativeBytes” and “getBytes”

Enjoy!