petar.petrov.myopenid.com

[C#] On IEnumerable<> comparision extension method

2009-07-06T16:43:58-07:00

Yes, you can't use this on IEnumerable<int> but the idea was to eliminate the against null on value types - it's always false ( value types cannot be null ). You can remove the zero counter and the checks in the loops. Doing so you will eliminate first.Count + second.Count checks and some increments/decrements. I think you can get the best version by splitting the code in two private methods for value and reference types equality check. Of course if you want you can stay with your current version it's quite good.

		public static bool ContentEquals<T>(
	this IEnumerable<T> first,
	IEnumerable<T> second,
	IEqualityComparer<T> comparer)
		{
			var isValueType = typeof(T).IsValueType;
			if (isValueType)
			{
				return ValueTypeContentEquals(comparer, first, second);
			}
			return ReferenceTypeContentEquals(comparer, first, second);
		}

		private static bool ReferenceTypeContentEquals<T>(IEqualityComparer<T> comparer, IEnumerable<T> first, IEnumerable<T> second)
		{
			throw new NotImplementedException();
		}

		private static bool ValueTypeContentEquals<T>(IEqualityComparer<T> comparer, IEnumerable<T> first, IEnumerable<T> second)
		{
			throw new NotImplementedException();
		}

[C#] On IEnumerable<> comparision extension method

2009-06-26T07:51:40-07:00

I have some suggestions about your code.
The first thing to do is to constraint T to be a class, because (item == null) will be always false for value types.
After that you can optimize you code by counting the elements in the first sequence and in the second. If the second count becomes greater then the first one (you have two sequences with different length ) - they are different.
Place the cheep check (zero != 0) before iterating on itemCounts.
One last thing I think it will lead to a better performance is to use TryGetValue for the dictionary. Here's the code
:
if (itemCounts.ContainsKey(item))
{
itemCounts[item]++;
}
else
{
itemCounts[item] = 1;
}

which is compiled as
if (itemCounts.ContainsKey(item))
{
itemCounts[item] = itemCounts[item] + 1;
}
else
{
itemCounts[item] = 1;
}
You always perform the check for the item and setting the value(it's a part of the algorithm). However itemCounts[item]++ (itemCounts[item] = itemCounts[item] + 1) is not that innocent. The indexer get will perform FindKey() (the same as ContainsKey) to get the value or throw an exception if the key is not found. In total it FindKey is called twice ! By changing the code to

int count;
itemCounts.TryGetValue(item, out count);
itemCounts[item] = ++count;

This hidden problem is eliminated.
Here's my proposition

		public static bool ContentEquals<T>(
	this IEnumerable<T> first,
	IEnumerable<T> second,
	IEqualityComparer<T> comparer) where T : class
		{
			// Declare a dictionary to count the occurence of the items in the collection			
			Dictionary<T, int> itemCounts = new Dictionary<T, int>(comparer);

			// null references are stored here.
			int zero = 0;
			var totalFirst = 0;

			// Increase the count for each occurence of the item in the first collection
			foreach (T item in first)
			{
				if (item == null)
				{
					zero++;
				}
				else
				{
					totalFirst++;
					int count;
					itemCounts.TryGetValue(item, out count);
					itemCounts[item] = ++count;
				}
			}

			var totalSecond = 0;
			// Decrease the count for each occurence of the item in the second collection
			foreach (T item in second)
			{
				if (item == null)
				{
					zero--;
				}
				else
				{
					totalSecond++;
					if (totalSecond > totalFirst)
					{
						return false;
					}
					int count;
					if (itemCounts.TryGetValue(item, out count))
					{
						itemCounts[item] = --count;
					}
					else
					{
						return false;
					}
				}
			}

			if (zero != 0)
			{
				return false;
			}

			// The count of each item should be 0 if the contents of the collections are equal
			foreach (int value in itemCounts.Values)
			{
				if (value != 0)
				{
					return false;
				}
			}

			// The collections are equal
			return true;
		}

[C#] On Plugin Loader

2009-04-23T07:14:06-07:00

Your code is just fine. Why do you want to use LINQ ? :)
Why not returning IEnumerable<Plugin> ?
However I have one thing to point out - not every DLL is a .NET assembly ;) You can add a try/catch but if you are absolutely sure that there's only .NET assemblies it's OK.

public static IEnumerable<Plugin> LoadPlugins()
{
	var pluginFolder = Path.Combine(Environment.CurrentDirectory, "plugins");

	foreach (var pluginFile in Directory.GetFiles(pluginFolder, "*.dll"))
	{
		var pluginAssembly = Assembly.LoadFile(pluginFile);

		var plugins =
			from type in pluginAssembly.GetTypes()
			where Plugin.ImplementsInterface(type)
			select Plugin.CreatePlugIn(type);

		var plugin = plugins.FirstOrDefault();
		if (plugin != null)
		{
			yield return plugin;
		}
	}
}