//See Wes Haggard's updated implementation here: http://codepaste.net/ktdgoh
 
//Adapting collection is a generic collection that allows you to adapt the contents using your own custom logic.
 
    public abstract class AdaptingCollection<T> : 
        ICollection<T>
    {
        private readonly List<T> _innerCollection = new List<T>();
        private List<T> _adaptedCollection;
        private bool _changed=true;
 
        private IEnumerable<T> AdaptCore(ICollection<T> collection)
        {
            if (_changed)
            {
                _adaptedCollection = Adapt(collection).ToList();
                _changed = false;
            }
            return _adaptedCollection;
        }
 
        protected virtual IEnumerable<T> Adapt(ICollection<T> collection)
        {
            return collection;
        }
 
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return AdaptCore(_innerCollection).GetEnumerator(); 
        }
 
        public IEnumerator GetEnumerator()
        {
            return AdaptCore(_innerCollection).GetEnumerator();
        }
 
 
        public void Add(T item)
        {
            _innerCollection.Add(item);
            _changed = true;
        }
 
        public void Clear()
        {
            _innerCollection.Clear();
            _changed = true;
        }
 
        public bool Contains(T item)
        {
            return AdaptCore(_adaptedCollection).Contains(item);
        }
 
        public void CopyTo(T[] array, int arrayIndex)
        {
            AdaptCore(_innerCollection).ToArray().CopyTo(array, arrayIndex);
        }
 
        public bool Remove(T item)
        {
            bool removed = _adaptedCollection.Remove(item);
            _changed = true;
            return removed;
        }
 
        public int Count
        {
            get { return _innerCollection.Count; }
        }
 
        public bool IsReadOnly
        {
            get { return false; }
        }
 
    }
 
    public class FuncComparer<TMetadataView> : IComparer<TMetadataView>
    {
        private Func<TMetadataView, TMetadataView, int> _orderComparer;
 
        public FuncComparer(Func<TMetadataView, TMetadataView, int> orderComparer)
        {
            _orderComparer = orderComparer;
        }
 
        public int Compare(TMetadataView x, TMetadataView y)
        {
            return _orderComparer(x, y);
        }
    }
 
//sample implementation
 
    public interface IAddin
    {
    }
 
 
    public interface IAddinView
    {
        int Sequence { get;}
    }
 
    [Export]
    public class ImportsAddins
    {
        [ImportMany]
        public AddinCollection Addins { get; set; }
 
    }
 
    public class AddinCollection : AdaptingCollection<Lazy<IAddin, IAddinView>>
    {
        protected override IEnumerable<Lazy<IAddin, IAddinView>> Adapt(ICollection<Lazy<IAddin, IAddinView>> collection)
        {
            var comparer = new FuncComparer<IAddinView>(Compare);
            return collection.
                Where(p => p.Metadata.Sequence < 3).
                OrderBy(k => k.Metadata, comparer);
        }
 
        static int Compare(IAddinView i1, IAddinView i2)
        {
            if (i1.Sequence < i2.Sequence)
                return -1;
 
            if (i1.Sequence > i2.Sequence)
                return 1;
 
            return 0;
        }
    }