Decent optimizations for CssAttributeCollection

Realistic benchmark of MoveCssInline()
Original: 1.2ms 592kB
After:  1.0ms 482kB

Author: patrikwlund

PreMailer.Net/PreMailer.Net.Tests/CssParserTests.cs

@@ -188,8 +188,8 @@ public void AddStylesheet_ShouldKeepTheRightOrderOfCssAttributes()
 
 			var attributes = parser.Styles.First().Value.Attributes.ToArray();
 
-			Assert.True(attributes[0] is {Key: "background", Value: {Value: "red"}});
-			Assert.True(attributes[1] is {Key: "background-color", Value: {Value: "green"}});
+			Assert.True(attributes[0] is {Style: "background", Value: "red"});
+			Assert.True(attributes[1] is {Style: "background-color", Value: "green" });
 		}
 
         [Fact]

PreMailer.Net/PreMailer.Net/CssAttributeCollection.cs

@@ -1,46 +1,28 @@
-using System;
-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace PreMailer.Net {
-	public class CssAttributeCollection : IDictionary<string, CssAttribute> {
-		private readonly IDictionary<string, CssValue> _attributes;
-		private int _currentPosition;
-
-		public CssAttributeCollection()
-		{
-			_attributes = new Dictionary<string, CssValue>(StringComparer.CurrentCultureIgnoreCase);
-			_currentPosition = 0;
-		}
-
-		/// <summary>
-		/// Add a CssAttribute and set it's position to overwrite all previous CssAttributes in the same Collection.
-		/// </summary>
-		public void Add(KeyValuePair<string, CssAttribute> item)
-		{
-			_attributes.Add(item.Key, new CssValue(position: ++_currentPosition, attribute: item.Value));
-		}
-
-		/// <summary>
-		/// Add a CssAttribute and set it's position to overwrite all previous CssAttributes in the same Collection.
-		/// </summary>
-		public void Add(string key, CssAttribute value)
-		{
-			_attributes.Add(key, new CssValue(position: ++_currentPosition, attribute: value));
-		}
+	public class CssAttributeCollection : IEnumerable<CssAttribute> {
+		private readonly List<CssAttribute> _attributes = new List<CssAttribute>();
 
 		/// <summary>
 		/// Add or Update a CssAttribute without changing it's position in the case of an update.
 		/// </summary>
 		public CssAttribute this[string key] {
-			get => _attributes[key].Attribute;
+			get {
+				var index = IndexOfKey(key);
+				return index == -1 ? null : _attributes[index];
+			}
 			set {
-				if (_attributes.TryGetValue(key, out var existing)) {
-					_attributes[key] = new CssValue(position: existing.Position, attribute: value);
+				var index = IndexOfKey(key);
+				if (index == -1)
+				{
+					_attributes.Add(value);
+
 				}
-				else {
-					_attributes[key] = new CssValue(position: ++_currentPosition, attribute: value);
+				else
+				{
+					_attributes[index] = value;
 				}
 			}
 		}
@@ -51,110 +33,72 @@ public CssAttribute this[string key] {
 		public void Merge(CssAttribute attribute)
 		{
 			var key = attribute.Style;
-			var value = attribute;
 
-			_attributes[key] = new CssValue(position: ++_currentPosition, attribute: value);
-		}
+			// Remove previous to instead append at the end
+			Remove(key);
 
-		/// <summary>
-		/// Copy the entries of this Collection, ordered by position, to the destination Array.
-		/// </summary>
-		public void CopyTo(KeyValuePair<string, CssAttribute>[] array, int arrayIndex)
-		{
-			var arr = _attributes.OrderBy(_ => _.Value.Position).Select(_ => new KeyValuePair<string, CssAttribute>(_.Key, _.Value.Attribute)).ToArray();
-			Array.Copy(arr, 0, array, arrayIndex, arr.Length);
+			this[key] = attribute;
 		}
 
 		/// <summary>
 		/// Gets an Enumerator of the attributes in this collection, ordered by position.
 		/// </summary>
-		public IEnumerator<KeyValuePair<string, CssAttribute>> GetEnumerator()
+		public IEnumerator<CssAttribute> GetEnumerator()
 		{
-			return _attributes
-				.OrderBy(_ => _.Value.Position)
-				.Select(pair => new KeyValuePair<string, CssAttribute>(pair.Key, pair.Value.Attribute)).GetEnumerator();
+			return _attributes.GetEnumerator();
 		}
 
-		/// <summary>
-		/// Gets an Enumerator of the attributes in this collection, ordered by position.
-		/// </summary>
 		IEnumerator IEnumerable.GetEnumerator()
 		{
-			return GetEnumerator();
+			return _attributes.GetEnumerator();
 		}
 
-		/// <summary>
-		/// Gets all Keys in this Collection ordered by position.
-		/// </summary>
-		public ICollection<string> Keys => _attributes.OrderBy(_ => _.Value.Position).Select(_ => _.Key).ToList();
-
-		/// <summary>
-		/// Gets all Values in this Collection ordered by position.
-		/// </summary>
-		public ICollection<CssAttribute> Values => _attributes.Values.OrderBy(_ => _.Position).Select(_ => _.Attribute).ToList();
-
-		/// <inheritdoc />
 		public int Count => _attributes.Count;
 
-		/// <inheritdoc />
-		public bool IsReadOnly => _attributes.IsReadOnly;
-
-		/// <inheritdoc />
 		public bool TryGetValue(string key, out CssAttribute value)
 		{
-			if (_attributes.TryGetValue(key, out var data)) {
-				value = data.Attribute;
+			var index = IndexOfKey(key);
+			if (index != -1)
+			{
+				value = _attributes[index];
 				return true;
 			}
 
 			value = default;
 			return false;
 		}
 
-		/// <inheritdoc />
-		public bool Contains(KeyValuePair<string, CssAttribute> item)
+		private int IndexOfKey(string key)
 		{
-			return _attributes.TryGetValue(item.Key, out var value) && value.Attribute == item.Value;
-		}
+			for (int i = 0; i < _attributes.Count; i++)
+			{
+				var attribute = _attributes[i];
+				if (string.Equals(attribute.Style, key, System.StringComparison.OrdinalIgnoreCase))
+				{
+					return i;
+				}
+			}
 
-		/// <inheritdoc />
-		public bool ContainsKey(string key)
-		{
-			return _attributes.ContainsKey(key);
+			return -1;
 		}
 
-		/// <inheritdoc />
-		public bool Remove(string key)
+		public bool ContainsKey(string key)
 		{
-			return _attributes.Remove(key);
+			return IndexOfKey(key) != -1;
 		}
 
-		/// <inheritdoc />
-		public bool Remove(KeyValuePair<string, CssAttribute> item)
+		public void Remove(string key)
 		{
-			if (_attributes.TryGetValue(item.Key, out var value) && value.Attribute == item.Value) {
-				return _attributes.Remove(new KeyValuePair<string, CssValue>(item.Key, value));
+			var index = IndexOfKey(key);
+			if (index != -1)
+			{
+				_attributes.RemoveAt(index);
 			}
-
-			return false;
 		}
-
-		/// <inheritdoc />
+		
 		public void Clear()
 		{
 			_attributes.Clear();
 		}
-
-
-		private readonly struct CssValue {
-			public int Position { get; }
-			public CssAttribute Attribute { get; }
-
-			public CssValue(int position, CssAttribute attribute)
-			{
-				Position = position;
-				Attribute = attribute;
-			}
-		}
 	}
 }

PreMailer.Net/PreMailer.Net/CssElementStyleResolver.cs

@@ -26,18 +26,18 @@ private static void AddSpecialPremailerAttributes(List<AttributeToCss> attribute
 		{
 			while (true)
 			{
-				var premailerRuleMatch = styleClass.Attributes.FirstOrDefault(a => a.Key.StartsWith(premailerAttributePrefix));
+				var premailerRuleMatch = styleClass.Attributes.FirstOrDefault(a => a.Style.StartsWith(premailerAttributePrefix));
 
-				var key = premailerRuleMatch.Key;
-				var cssAttribute = premailerRuleMatch.Value;
-
-				if (key == null)
+				if (premailerRuleMatch == null)
 					break;
 
+				var key = premailerRuleMatch.Style;
+				var cssAttribute = premailerRuleMatch.Value;
+
 				attributeCssList.Add(new AttributeToCss
 				{
 					AttributeName = key.Replace(premailerAttributePrefix, ""),
-					CssValue = cssAttribute.Value
+					CssValue = cssAttribute
 				});
 
 				styleClass.Attributes.Remove(key);

PreMailer.Net/PreMailer.Net/StyleClass.cs

@@ -36,10 +36,10 @@ public StyleClass()
 		/// <param name="canOverwrite">if set to <c>true</c> [can overwrite].</param>
 		public void Merge(StyleClass styleClass, bool canOverwrite) {
 			foreach (var item in styleClass.Attributes) {
-				if (!Attributes.TryGetValue(item.Key, out var existing) ||
-				    canOverwrite && (!existing.Important || item.Value.Important))
+				if (!Attributes.TryGetValue(item.Style, out var existing) ||
+				    canOverwrite && (!existing.Important || item.Important))
 				{
-					Attributes.Merge(item.Value);
+					Attributes.Merge(item);
 				}
 			}
 		}
@@ -55,7 +55,7 @@ public override string ToString() {
 		/// <param name="emitImportant">When set to <c>true</c>, resulting CSS emits the !important flag.</param>
 		/// <returns> css styles with or without !important </returns>
 		public string ToString(bool emitImportant) {
-			return string.Join(";", Attributes.Values.Select(_ => _.ToString(emitImportant)));
+			return string.Join(";", Attributes.Select(_ => _.ToString(emitImportant)));
 		}
 	}
 }