[3.5] Transformer une SerializableList<T> en Enumérable

Version imprimable

Salut,

J'aimerais faire hériter la classe suivante de l'interface IEnumerable mais je ne sais pas implementer le GetEnumerator.

Pourriez-vous m'aider ?

Voici le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Xml.Serialization;
using System.Runtime.Serialization;
using System.Collections;
 
namespace InnovaSites.Objects.CommonLayer
{
    [XmlRoot("list")]
    [Serializable]
    public class SerializableList<T> : List<T>, IXmlSerializable
    {
        #region "Contructors"
        public SerializableList() : base() { }
        public SerializableList(IList<T> list) : base(list) { }
        public SerializableList(int capacity) : base(capacity) { }
        protected SerializableList(SerializationInfo info, StreamingContext context) { }
        #endregion
        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
        public void ReadXml(System.Xml.XmlReader reader)
        {
            XmlSerializer itemSerializer = new XmlSerializer(typeof(T));
 
            bool wasEmpty = reader.IsEmptyElement;
            reader.Read();
 
            if (wasEmpty)
                return;
 
            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
            {
                reader.ReadStartElement("item");
                T item = (T)itemSerializer.Deserialize(reader);
                reader.ReadEndElement();
 
                this.Add(item);
 
                reader.ReadEndElement();
                reader.MoveToContent();
            }
            reader.ReadEndElement();
        }
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            XmlSerializer itemSerializer = new XmlSerializer(typeof(T));
 
            foreach (T item in this)
            {
                writer.WriteStartElement("item");
                itemSerializer.Serialize(writer, item);
                writer.WriteEndElement();
            }
        }
        #endregion
    }
}

D'avance merci (P.S. Google est mon ami mais il n'a pas suffit)

Laurent

Dans le code que tu montres, la classe hérite de List<T> qui implémente déjà IEnumerable<T>. La fonction GetEnumerator est donc déjà définie.

Autrement voici un exemple d'enumerator pour la classe LinkList (pas celle du framework, une perso)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
    public class LinkedListEnumerator<T> : IEnumerator<T>
    {
        private readonly LinkedListNode<T> _listNode;
        private LinkedListNode<T> _current;
 
        public LinkedListEnumerator(LinkedListNode<T> listNode)
        {
            _listNode = listNode;
        }
 
        #region Implementation of IDisposable
 
        public void Dispose()
        {
        }
 
        #endregion
 
        #region Implementation of IEnumerator
 
        public bool MoveNext()
        {
            _current = _current == null ? _listNode : _current.Next;
            return _current != null;
        }
 
        public void Reset()
        {
            _current = null;
        }
 
        public T Current
        {
            get
            {
                if (_current == null)
                    throw new InvalidOperationException(
                        "The enumerator is positioned before the first element of the collection or after the last element.");
                return _current.Value;
            }
        }
 
        object IEnumerator.Current
        {
            get { return Current; }
        }
 
        #endregion
    }

Et la fonction GetEnumerator

Code:

1
2
3
4
5
 
        public IEnumerator<T> GetEnumerator()
        {
            return new LinkedListEnumerator<T>(Head);
        }

05/07/2010, 11h51
CUCARACHA

J'ai fais une erreur dans le titre, c'est IQueryable

Salut,

Ta remarque était tout à fait juste mais je me suis trompé dans le titre.
Comme indiquait plus haut, j'ai besoin que la liste soit IQueryable pour lui permettre de s'initialiser directement avec un résultat de requête linq.

Tu sais faire ?

D'avance merci

Laurent

Une solution toute simple (je te laisse adapter a ton cas)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    public class MyList<T> : IQueryable
    {
        List<T> list = new List<T>();
 
        public Type ElementType
        {
            get { return list.AsQueryable<T>().ElementType; }
        }
 
        public System.Linq.Expressions.Expression Expression
        {
            get { return list.AsQueryable<T>().Expression; }
        }
 
        public IQueryProvider Provider
        {
            get { return list.AsQueryable<T>().Provider; }
        }
 
        public System.Collections.IEnumerator GetEnumerator()
        {
            return list.AsQueryable<T>().GetEnumerator();
        }
    }