diff --git a/src/embed_tests/Codecs.cs b/src/embed_tests/Codecs.cs
index 18fcd32d1..266badb9e 100644
--- a/src/embed_tests/Codecs.cs
+++ b/src/embed_tests/Codecs.cs
@@ -1,33 +1,39 @@
 namespace Python.EmbeddingTest {
     using System;
     using System.Collections.Generic;
-    using System.Text;
+    using System.Linq;
     using NUnit.Framework;
     using Python.Runtime;
     using Python.Runtime.Codecs;
 
-    public class Codecs {
+    public class Codecs
+    {
         [SetUp]
-        public void SetUp() {
+        public void SetUp()
+        {
             PythonEngine.Initialize();
         }
 
         [TearDown]
-        public void Dispose() {
+        public void Dispose()
+        {
             PythonEngine.Shutdown();
         }
 
         [Test]
-        public void ConversionsGeneric() {
-            ConversionsGeneric<ValueTuple<int, string, object>, ValueTuple>();
+        public void TupleConversionsGeneric()
+        {
+            TupleConversionsGeneric<ValueTuple<int, string, object>, ValueTuple>();
         }
 
-        static void ConversionsGeneric<T, TTuple>() {
+        static void TupleConversionsGeneric<T, TTuple>()
+        {
             TupleCodec<TTuple>.Register();
             var tuple = Activator.CreateInstance(typeof(T), 42, "42", new object());
             T restored = default;
             using (Py.GIL())
-            using (var scope = Py.CreateScope()) {
+            using (var scope = Py.CreateScope())
+            {
                 void Accept(T value) => restored = value;
                 var accept = new Action<T>(Accept).ToPython();
                 scope.Set(nameof(tuple), tuple);
@@ -38,15 +44,18 @@ static void ConversionsGeneric<T, TTuple>() {
         }
 
         [Test]
-        public void ConversionsObject() {
-            ConversionsObject<ValueTuple<int, string, object>, ValueTuple>();
+        public void TupleConversionsObject()
+        {
+            TupleConversionsObject<ValueTuple<int, string, object>, ValueTuple>();
         }
-        static void ConversionsObject<T, TTuple>() {
+        static void TupleConversionsObject<T, TTuple>()
+        {
             TupleCodec<TTuple>.Register();
             var tuple = Activator.CreateInstance(typeof(T), 42, "42", new object());
             T restored = default;
             using (Py.GIL())
-            using (var scope = Py.CreateScope()) {
+            using (var scope = Py.CreateScope())
+            {
                 void Accept(object value) => restored = (T)value;
                 var accept = new Action<object>(Accept).ToPython();
                 scope.Set(nameof(tuple), tuple);
@@ -57,12 +66,15 @@ static void ConversionsObject<T, TTuple>() {
         }
 
         [Test]
-        public void TupleRoundtripObject() {
+        public void TupleRoundtripObject()
+        {
             TupleRoundtripObject<ValueTuple<int, string, object>, ValueTuple>();
         }
-        static void TupleRoundtripObject<T, TTuple>() {
+        static void TupleRoundtripObject<T, TTuple>()
+        {
             var tuple = Activator.CreateInstance(typeof(T), 42, "42", new object());
-            using (Py.GIL()) {
+            using (Py.GIL())
+            {
                 var pyTuple = TupleCodec<TTuple>.Instance.TryEncode(tuple);
                 Assert.IsTrue(TupleCodec<TTuple>.Instance.TryDecode(pyTuple, out object restored));
                 Assert.AreEqual(expected: tuple, actual: restored);
@@ -70,18 +82,220 @@ static void TupleRoundtripObject<T, TTuple>() {
         }
 
         [Test]
-        public void TupleRoundtripGeneric() {
+        public void TupleRoundtripGeneric()
+        {
             TupleRoundtripGeneric<ValueTuple<int, string, object>, ValueTuple>();
         }
 
-        static void TupleRoundtripGeneric<T, TTuple>() {
+        static void TupleRoundtripGeneric<T, TTuple>()
+        {
             var tuple = Activator.CreateInstance(typeof(T), 42, "42", new object());
-            using (Py.GIL()) {
+            using (Py.GIL())
+            {
                 var pyTuple = TupleCodec<TTuple>.Instance.TryEncode(tuple);
                 Assert.IsTrue(TupleCodec<TTuple>.Instance.TryDecode(pyTuple, out T restored));
                 Assert.AreEqual(expected: tuple, actual: restored);
             }
         }
+
+        static PyObject GetPythonIterable()
+        {
+            using (Py.GIL())
+            {
+                return PythonEngine.Eval("map(lambda x: x, [1,2,3])");
+            }
+        }
+
+        [Test]
+        public void ListDecoderTest()
+        {
+            var codec = ListDecoder.Instance;
+            var items = new List<PyObject>() { new PyInt(1), new PyInt(2), new PyInt(3) };
+
+            var pyList = new PyList(items.ToArray());
+
+            var pyListType = pyList.GetPythonType();
+            Assert.IsTrue(codec.CanDecode(pyListType, typeof(IList<bool>)));
+            Assert.IsTrue(codec.CanDecode(pyListType, typeof(IList<int>)));
+            Assert.IsFalse(codec.CanDecode(pyListType, typeof(System.Collections.IEnumerable)));
+            Assert.IsFalse(codec.CanDecode(pyListType, typeof(IEnumerable<int>)));
+            Assert.IsFalse(codec.CanDecode(pyListType, typeof(ICollection<float>)));
+            Assert.IsFalse(codec.CanDecode(pyListType, typeof(bool)));
+
+            //we'd have to copy into a list instance to do this, it would not be lossless.
+            //lossy converters can be implemented outside of the python.net core library
+            Assert.IsFalse(codec.CanDecode(pyListType, typeof(List<int>)));
+
+            //convert to list of int
+            IList<int> intList = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out intList); });
+            CollectionAssert.AreEqual(intList, new List<object> { 1, 2, 3 });
+
+            //convert to list of string.   This will not work.
+            //The ListWrapper class will throw a python exception when it tries to access any element.
+            //TryDecode is a lossless conversion so there will be no exception at that point
+            //interestingly, since the size of the python list can be queried without any conversion,
+            //the IList will report a Count of 3.
+            IList<string> stringList = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out stringList); });
+            Assert.AreEqual(stringList.Count, 3);
+            Assert.Throws(typeof(InvalidCastException), () => { var x = stringList[0]; });
+
+            //can't convert python iterable to list (this will require a copy which isn't lossless)
+            var foo = GetPythonIterable();
+            var fooType = foo.GetPythonType();
+            Assert.IsFalse(codec.CanDecode(fooType, typeof(IList<int>)));
+        }
+
+        [Test]
+        public void SequenceDecoderTest()
+        {
+            var codec = SequenceDecoder.Instance;
+            var items = new List<PyObject>() { new PyInt(1), new PyInt(2), new PyInt(3) };
+
+            //SequenceConverter can only convert to any ICollection
+            var pyList = new PyList(items.ToArray());
+            //it can convert a PyList, since PyList satisfies the python sequence protocol
+
+            Assert.IsFalse(codec.CanDecode(pyList, typeof(bool)));
+            Assert.IsFalse(codec.CanDecode(pyList, typeof(IList<int>)));
+            Assert.IsFalse(codec.CanDecode(pyList, typeof(System.Collections.IEnumerable)));
+            Assert.IsFalse(codec.CanDecode(pyList, typeof(IEnumerable<int>)));
+
+            Assert.IsTrue(codec.CanDecode(pyList, typeof(ICollection<float>)));
+            Assert.IsTrue(codec.CanDecode(pyList, typeof(ICollection<string>)));
+            Assert.IsTrue(codec.CanDecode(pyList, typeof(ICollection<int>)));
+
+            //convert to collection of int
+            ICollection<int> intCollection = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out intCollection); });
+            CollectionAssert.AreEqual(intCollection, new List<object> { 1, 2, 3 });
+
+            //no python exception should have occurred during the above conversion and check
+            Runtime.CheckExceptionOccurred();
+
+            //convert to collection of string.   This will not work.
+            //The SequenceWrapper class will throw a python exception when it tries to access any element.
+            //TryDecode is a lossless conversion so there will be no exception at that point
+            //interestingly, since the size of the python sequence can be queried without any conversion,
+            //the IList will report a Count of 3.
+            ICollection<string> stringCollection = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out stringCollection); });
+            Assert.AreEqual(3, stringCollection.Count());
+            Assert.Throws(typeof(InvalidCastException), () => {
+                string[] array = new string[3];
+                stringCollection.CopyTo(array, 0);
+            });
+
+            Runtime.CheckExceptionOccurred();
+
+            //can't convert python iterable to collection (this will require a copy which isn't lossless)
+            //python iterables do not satisfy the python sequence protocol
+            var foo = GetPythonIterable();
+            var fooType = foo.GetPythonType();
+            Assert.IsFalse(codec.CanDecode(fooType, typeof(ICollection<int>)));
+
+            //python tuples do satisfy the python sequence protocol
+            var pyTuple = new PyTuple(items.ToArray());
+            var pyTupleType = pyTuple.GetPythonType();
+
+            Assert.IsTrue(codec.CanDecode(pyTupleType, typeof(ICollection<float>)));
+            Assert.IsTrue(codec.CanDecode(pyTupleType, typeof(ICollection<int>)));
+            Assert.IsTrue(codec.CanDecode(pyTupleType, typeof(ICollection<string>)));
+
+            //convert to collection of int
+            ICollection<int> intCollection2 = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyTuple, out intCollection2); });
+            CollectionAssert.AreEqual(intCollection2, new List<object> { 1, 2, 3 });
+
+            //no python exception should have occurred during the above conversion and check
+            Runtime.CheckExceptionOccurred();
+
+            //convert to collection of string.   This will not work.
+            //The SequenceWrapper class will throw a python exception when it tries to access any element.
+            //TryDecode is a lossless conversion so there will be no exception at that point
+            //interestingly, since the size of the python sequence can be queried without any conversion,
+            //the IList will report a Count of 3.
+            ICollection<string> stringCollection2 = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyTuple, out stringCollection2); });
+            Assert.AreEqual(3, stringCollection2.Count());
+            Assert.Throws(typeof(InvalidCastException), () => {
+                string[] array = new string[3];
+                stringCollection2.CopyTo(array, 0);
+            });
+
+            Runtime.CheckExceptionOccurred();
+
+        }
+
+        [Test]
+        public void IterableDecoderTest()
+        {
+            var codec = IterableDecoder.Instance;
+            var items = new List<PyObject>() { new PyInt(1), new PyInt(2), new PyInt(3) };
+
+            var pyList = new PyList(items.ToArray());
+            var pyListType = pyList.GetPythonType();
+            Assert.IsFalse(codec.CanDecode(pyListType, typeof(IList<bool>)));
+            Assert.IsTrue(codec.CanDecode(pyListType, typeof(System.Collections.IEnumerable)));
+            Assert.IsTrue(codec.CanDecode(pyListType, typeof(IEnumerable<int>)));
+            Assert.IsFalse(codec.CanDecode(pyListType, typeof(ICollection<float>)));
+            Assert.IsFalse(codec.CanDecode(pyListType, typeof(bool)));
+
+            //ensure a PyList can be converted to a plain IEnumerable
+            System.Collections.IEnumerable plainEnumerable1 = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out plainEnumerable1); });
+            CollectionAssert.AreEqual(plainEnumerable1, new List<object> { 1, 2, 3 });
+
+            //can convert to any generic ienumerable.  If the type is not assignable from the python element
+            //it will lead to an empty iterable when decoding.  TODO - should it throw?
+            Assert.IsTrue(codec.CanDecode(pyListType, typeof(IEnumerable<int>)));
+            Assert.IsTrue(codec.CanDecode(pyListType, typeof(IEnumerable<double>)));
+            Assert.IsTrue(codec.CanDecode(pyListType, typeof(IEnumerable<string>)));
+
+            IEnumerable<int> intEnumerable = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out intEnumerable); });
+            CollectionAssert.AreEqual(intEnumerable, new List<object> { 1, 2, 3 });
+
+            Runtime.CheckExceptionOccurred();
+
+            IEnumerable<double> doubleEnumerable = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out doubleEnumerable); });
+            CollectionAssert.AreEqual(doubleEnumerable, new List<object> { 1, 2, 3 });
+
+            Runtime.CheckExceptionOccurred();
+
+            IEnumerable<string> stringEnumerable = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out stringEnumerable); });
+
+            Assert.Throws(typeof(InvalidCastException), () => {
+                foreach (string item in stringEnumerable)
+                {
+                    var x = item;
+                }
+            });
+            Assert.Throws(typeof(InvalidCastException), () => {
+                stringEnumerable.Count();
+            });
+
+            Runtime.CheckExceptionOccurred();
+
+            //ensure a python class which implements the iterator protocol can be converter to a plain IEnumerable
+            var foo = GetPythonIterable();
+            var fooType = foo.GetPythonType();
+            System.Collections.IEnumerable plainEnumerable2 = null;
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out plainEnumerable2); });
+            CollectionAssert.AreEqual(plainEnumerable2, new List<object> { 1, 2, 3 });
+
+            //can convert to any generic ienumerable.  If the type is not assignable from the python element
+            //it will be an exception during TryDecode
+            Assert.IsTrue(codec.CanDecode(fooType, typeof(IEnumerable<int>)));
+            Assert.IsTrue(codec.CanDecode(fooType, typeof(IEnumerable<double>)));
+            Assert.IsTrue(codec.CanDecode(fooType, typeof(IEnumerable<string>)));
+
+            Assert.DoesNotThrow(() => { codec.TryDecode(pyList, out intEnumerable); });
+            CollectionAssert.AreEqual(intEnumerable, new List<object> { 1, 2, 3 });
+        }
     }
 
     /// <summary>
diff --git a/src/runtime/Codecs/IterableDecoder.cs b/src/runtime/Codecs/IterableDecoder.cs
new file mode 100644
index 000000000..346057238
--- /dev/null
+++ b/src/runtime/Codecs/IterableDecoder.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+
+namespace Python.Runtime.Codecs
+{
+    public class IterableDecoder : IPyObjectDecoder
+    {
+        internal static bool IsIterable(Type targetType)
+        {
+            //if it is a plain IEnumerable, we can decode it using sequence protocol.
+            if (targetType == typeof(System.Collections.IEnumerable))
+                return true;
+
+            if (!targetType.IsGenericType)
+                return false;
+
+            return targetType.GetGenericTypeDefinition() == typeof(IEnumerable<>);
+        }
+
+        internal static bool IsIterable(PyObject objectType)
+        {
+            return objectType.HasAttr("__iter__");
+        }
+
+        public bool CanDecode(PyObject objectType, Type targetType)
+        {
+            return IsIterable(objectType) && IsIterable(targetType);
+        }
+
+        public bool TryDecode<T>(PyObject pyObj, out T value)
+        {
+            //first see if T is a plan IEnumerable
+            if (typeof(T) == typeof(System.Collections.IEnumerable))
+            {
+                object enumerable = new CollectionWrappers.IterableWrapper<object>(pyObj);
+                value = (T)enumerable;
+                return true;
+            }
+
+            var elementType = typeof(T).GetGenericArguments()[0];
+            var collectionType = typeof(CollectionWrappers.IterableWrapper<>).MakeGenericType(elementType);
+
+            var instance = Activator.CreateInstance(collectionType, new[] { pyObj });
+            value = (T)instance;
+            return true;
+        }
+
+        public static IterableDecoder Instance { get; } = new IterableDecoder();
+
+        public static void Register()
+        {
+            PyObjectConversions.RegisterDecoder(Instance);
+        }
+    }
+}
diff --git a/src/runtime/Codecs/ListDecoder.cs b/src/runtime/Codecs/ListDecoder.cs
new file mode 100644
index 000000000..013f3f3f9
--- /dev/null
+++ b/src/runtime/Codecs/ListDecoder.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+
+namespace Python.Runtime.Codecs
+{
+    public class ListDecoder : IPyObjectDecoder
+    {
+        private static bool IsList(Type targetType)
+        {
+            if (!targetType.IsGenericType)
+                return false;
+
+            return targetType.GetGenericTypeDefinition() == typeof(IList<>);
+        }
+
+        private static bool IsList(PyObject objectType)
+        {
+            //TODO accept any python object that implements the sequence and list protocols
+            //must implement sequence protocol to fully implement list protocol
+            //if (!SequenceDecoder.IsSequence(objectType)) return false;
+
+            //returns wheter the type is a list.
+            return objectType.Handle == Runtime.PyListType;
+        }
+
+        public bool CanDecode(PyObject objectType, Type targetType)
+        {
+            return IsList(objectType) && IsList(targetType);
+        }
+
+        public bool TryDecode<T>(PyObject pyObj, out T value)
+        {
+            if (pyObj == null) throw new ArgumentNullException(nameof(pyObj));
+
+            var elementType = typeof(T).GetGenericArguments()[0];
+            Type collectionType = typeof(CollectionWrappers.ListWrapper<>).MakeGenericType(elementType);
+
+            var instance = Activator.CreateInstance(collectionType, new[] { pyObj });
+            value = (T)instance;
+            return true;
+        }
+
+        public static ListDecoder Instance { get; } = new ListDecoder();
+
+        public static void Register()
+        {
+            PyObjectConversions.RegisterDecoder(Instance);
+        }
+    }
+}
diff --git a/src/runtime/Codecs/SequenceDecoder.cs b/src/runtime/Codecs/SequenceDecoder.cs
new file mode 100644
index 000000000..dce08fd99
--- /dev/null
+++ b/src/runtime/Codecs/SequenceDecoder.cs
@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+
+namespace Python.Runtime.Codecs
+{
+    public class SequenceDecoder : IPyObjectDecoder
+    {
+        internal static bool IsSequence(Type targetType)
+        {
+            if (!targetType.IsGenericType)
+                return false;
+
+            return targetType.GetGenericTypeDefinition() == typeof(ICollection<>);
+        }
+
+        internal static bool IsSequence(PyObject objectType)
+        {
+            //must implement iterable protocol to fully implement sequence protocol
+            if (!IterableDecoder.IsIterable(objectType)) return false;
+
+            //returns wheter it implements the sequence protocol
+            //according to python doc this needs to exclude dict subclasses
+            //but I don't know how to look for that given the objectType
+            //rather than the instance.
+            return objectType.HasAttr("__getitem__");
+        }
+
+        public bool CanDecode(PyObject objectType, Type targetType)
+        {
+            return IsSequence(objectType) && IsSequence(targetType);
+        }
+
+        public bool TryDecode<T>(PyObject pyObj, out T value)
+        {
+            if (pyObj == null) throw new ArgumentNullException(nameof(pyObj));
+
+            var elementType = typeof(T).GetGenericArguments()[0];
+            Type collectionType = typeof(CollectionWrappers.SequenceWrapper<>).MakeGenericType(elementType);
+
+            var instance = Activator.CreateInstance(collectionType, new[] { pyObj });
+            value = (T)instance;
+            return true;
+        }
+
+        public static SequenceDecoder Instance { get; } = new SequenceDecoder();
+
+        public static void Register()
+        {
+            PyObjectConversions.RegisterDecoder(Instance);
+        }
+    }
+}
diff --git a/src/runtime/CollectionWrappers/IterableWrapper.cs b/src/runtime/CollectionWrappers/IterableWrapper.cs
new file mode 100644
index 000000000..97979b59b
--- /dev/null
+++ b/src/runtime/CollectionWrappers/IterableWrapper.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Collections;
+
+namespace Python.Runtime.CollectionWrappers
+{
+    internal class IterableWrapper<T> : IEnumerable<T>
+    {
+        protected readonly PyObject pyObject;
+
+        public IterableWrapper(PyObject pyObj)
+        {
+            if (pyObj == null)
+                throw new ArgumentNullException();
+            pyObject = new PyObject(pyObj.Reference);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            PyObject iterObject = null;
+            using (Py.GIL())
+                iterObject = new PyObject(Runtime.PyObject_GetIter(pyObject.Handle));
+
+            while (true)
+            {
+                using (Py.GIL())
+                {
+                    var item = Runtime.PyIter_Next(iterObject.Handle);
+                    if (item == IntPtr.Zero)
+                    {
+                        Runtime.CheckExceptionOccurred();
+                        iterObject.Dispose();
+                        break;
+                    }
+
+                    yield return (T)new PyObject(item).AsManagedObject(typeof(T));
+                }
+            }
+        }
+    }
+}
diff --git a/src/runtime/CollectionWrappers/ListWrapper.cs b/src/runtime/CollectionWrappers/ListWrapper.cs
new file mode 100644
index 000000000..ec2476370
--- /dev/null
+++ b/src/runtime/CollectionWrappers/ListWrapper.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+
+namespace Python.Runtime.CollectionWrappers
+{
+    internal class ListWrapper<T> : SequenceWrapper<T>, IList<T>
+    {
+        public ListWrapper(PyObject pyObj) : base(pyObj)
+        {
+
+        }
+
+        public T this[int index]
+        {
+            get
+            {
+                var item = Runtime.PyList_GetItem(pyObject.Reference, index);
+                var pyItem = new PyObject(item);
+                return pyItem.As<T>();
+            }
+            set
+            {
+                var pyItem = value.ToPython();
+                var result = Runtime.PyList_SetItem(pyObject.Handle, index, pyItem.Handle);
+                if (result == -1)
+                    Runtime.CheckExceptionOccurred();
+            }
+        }
+
+        public int IndexOf(T item)
+        {
+            return indexOf(item);
+        }
+
+        public void Insert(int index, T item)
+        {
+            if (IsReadOnly)
+                throw new InvalidOperationException("Collection is read-only");
+
+            var pyItem = item.ToPython();
+
+            var result = Runtime.PyList_Insert(pyObject.Reference, index, pyItem.Handle);
+            if (result == -1)
+                Runtime.CheckExceptionOccurred();
+        }
+
+        public void RemoveAt(int index)
+        {
+            var result = removeAt(index);
+
+            //PySequence_DelItem will set an error if it fails.  throw it here
+            //since RemoveAt does not have a bool return value.
+            if (result == false)
+                Runtime.CheckExceptionOccurred();
+        }
+    }
+}
diff --git a/src/runtime/CollectionWrappers/SequenceWrapper.cs b/src/runtime/CollectionWrappers/SequenceWrapper.cs
new file mode 100644
index 000000000..945019850
--- /dev/null
+++ b/src/runtime/CollectionWrappers/SequenceWrapper.cs
@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+
+namespace Python.Runtime.CollectionWrappers
+{
+    internal class SequenceWrapper<T> : IterableWrapper<T>, ICollection<T>
+    {
+        public SequenceWrapper(PyObject pyObj) : base(pyObj)
+        {
+
+        }
+
+        public int Count
+        {
+            get
+            {
+                var size = Runtime.PySequence_Size(pyObject.Reference);
+                if (size == -1)
+                {
+                    Runtime.CheckExceptionOccurred();
+                }
+
+                return (int)size;
+            }
+        }
+
+        public virtual bool IsReadOnly => false;
+
+        public virtual void Add(T item)
+        {
+            //not implemented for Python sequence.
+            //ICollection is the closest analogue but it doesn't map perfectly.
+            //SequenceWrapper is not final and can be subclassed if necessary
+            throw new NotImplementedException();
+        }
+
+        public void Clear()
+        {
+            if (IsReadOnly)
+                throw new NotImplementedException();
+            var result = Runtime.PySequence_DelSlice(pyObject.Handle, 0, Count);
+            if (result == -1)
+            {
+                Runtime.CheckExceptionOccurred();
+            }
+        }
+
+        public bool Contains(T item)
+        {
+            //not sure if IEquatable is implemented and this will work!
+            foreach (var element in this)
+                if (element.Equals(item)) return true;
+
+            return false;
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            if (array == null)
+                throw new NullReferenceException();
+
+            if ((array.Length - arrayIndex) < this.Count)
+                throw new InvalidOperationException("Attempting to copy to an array that is too small");
+
+            var index = 0;
+            foreach (var item in this)
+            {
+                array[index + arrayIndex] = item;
+                index++;
+            }
+        }
+
+        protected bool removeAt(int index)
+        {
+            if (IsReadOnly)
+                throw new NotImplementedException();
+            if (index >= Count || index < 0)
+                return false;
+
+            var result = Runtime.PySequence_DelItem(pyObject.Handle, index);
+
+            if (result == 0)
+                return true;
+
+            Runtime.CheckExceptionOccurred();
+            return false;
+        }
+
+        protected int indexOf(T item)
+        {
+            var index = 0;
+            foreach (var element in this)
+            {
+                if (element.Equals(item)) return index;
+                index++;
+            }
+
+            return -1;
+        }
+
+        public bool Remove(T item)
+        {
+            var result = removeAt(indexOf(item));
+
+            //clear the python exception from PySequence_DelItem
+            //it is idiomatic in C# to return a bool rather than
+            //throw for a failed Remove in ICollection
+            if (result == false)
+                Runtime.PyErr_Clear();
+            return result;
+        }
+    }
+}
diff --git a/src/testing/CodecTest.cs b/src/testing/CodecTest.cs
new file mode 100644
index 000000000..74f77531b
--- /dev/null
+++ b/src/testing/CodecTest.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Python.Test
+{
+    public class ListMember
+    {
+        public ListMember(int value, string name)
+        {
+            Value = value;
+            Name = name;
+        }
+
+        public int Value { get; set; }
+        public string Name { get; set; }
+    }
+
+    public class ListConversionTester
+    {
+        public int GetLength(IEnumerable<object> o)
+        {
+            return o.Count();
+        }
+        public int GetLength(ICollection<object> o)
+        {
+            return o.Count;
+        }
+        public int GetLength(IList<object> o)
+        {
+            return o.Count;
+        }
+        public int GetLength2(IEnumerable<ListMember> o)
+        {
+            return o.Count();
+        }
+        public int GetLength2(ICollection<ListMember> o)
+        {
+            return o.Count;
+        }
+        public int GetLength2(IList<ListMember> o)
+        {
+            return o.Count;
+        }
+    }
+}
diff --git a/src/testing/Python.Test.csproj b/src/testing/Python.Test.csproj
index 4b7e4d93b..f7bc10bb4 100644
--- a/src/testing/Python.Test.csproj
+++ b/src/testing/Python.Test.csproj
@@ -4,7 +4,6 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
   </PropertyGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\runtime\Python.Runtime.csproj" />
   </ItemGroup>
diff --git a/src/tests/test_codec.py b/src/tests/test_codec.py
new file mode 100644
index 000000000..9fdbfbbf5
--- /dev/null
+++ b/src/tests/test_codec.py
@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+"""Test conversions using codecs from client python code"""
+import clr
+import System
+import pytest
+import Python.Runtime
+from Python.Test import ListConversionTester, ListMember
+
+class int_iterable():
+    def __init__(self):
+        self.counter = 0
+    def __iter__(self):
+        return self
+    def __next__(self):
+        if self.counter == 3:
+            raise StopIteration
+        self.counter = self.counter + 1
+        return self.counter
+
+class obj_iterable():
+    def __init__(self):
+        self.counter = 0
+    def __iter__(self):
+        return self
+    def __next__(self):
+        if self.counter == 3:
+            raise StopIteration
+        self.counter = self.counter + 1
+        return ListMember(self.counter, "Number " + str(self.counter))
+
+def test_iterable():
+    """Test that a python iterable can be passed into a function that takes an IEnumerable<object>"""
+
+    #Python.Runtime.Codecs.ListDecoder.Register()
+    #Python.Runtime.Codecs.SequenceDecoder.Register()
+    Python.Runtime.Codecs.IterableDecoder.Register()
+    ob = ListConversionTester()
+
+    iterable = int_iterable()
+    assert 3 == ob.GetLength(iterable)
+
+    iterable2 = obj_iterable()
+    assert 3 == ob.GetLength2(iterable2)
+
+    Python.Runtime.PyObjectConversions.Reset()
+
+def test_sequence():
+    Python.Runtime.Codecs.SequenceDecoder.Register()
+    ob = ListConversionTester()
+
+    tup = (1,2,3)
+    assert 3 == ob.GetLength(tup)
+
+    tup2 = (ListMember(1, "one"), ListMember(2, "two"), ListMember(3, "three"))
+    assert 3 == ob.GetLength(tup2)
+
+    Python.Runtime.PyObjectConversions.Reset()
+
+def test_list():
+    Python.Runtime.Codecs.SequenceDecoder.Register()
+    ob = ListConversionTester()
+
+    l = [1,2,3]
+    assert 3 == ob.GetLength(l)
+
+    l2 = [ListMember(1, "one"), ListMember(2, "two"), ListMember(3, "three")]
+    assert 3 == ob.GetLength(l2)
+
+    Python.Runtime.PyObjectConversions.Reset()
diff --git a/tests/tests.pyproj b/tests/tests.pyproj
index 439bc856a..fc1053f7b 100644
--- a/tests/tests.pyproj
+++ b/tests/tests.pyproj
@@ -52,6 +52,7 @@
     <Compile Include="test_recursive_types.py" />
     <Compile Include="test_subclass.py" />
     <Compile Include="test_thread.py" />
+    <Compile Include="test_codec.py" />
     <Compile Include="test_repr.py" />
     <Compile Include="utils.py" />
     <Compile Include="fixtures\argv-fixture.py" />