-3

错误在公共 IEnumerator GetEnumerator() 和私有密封类 d__0 中

您能否帮助大师将那些不可读/可理解的代码转换为我或编译器可以理解的代码......

非常感谢首先...

下面是代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;
using System.Runtime.CompilerServices;
using System.Diagnostics;

namespace MyNmSpace.Utilities.Data
{
    [Serializable]

public class MyHashList<T> : IList<T>, ICollection<T>, IEnumerable<T>, ICollection, IEnumerable where T: DbObject
{
    // Fields
    protected Dictionary<int, T> _dict;
    protected List<int> _list;
    protected int _lowestId;

    // Methods
    public MyHashList()
    {
        this._lowestId = -2;
    }

    public virtual void Add(T item)
    {
        this.Insert(this.TheList.get_Count(), item);
    }

    public virtual void AddRange(IEnumerable<T> collection)
    {
        foreach (T local in collection)
        {
            this.Add(local);
        }
    }

    public virtual void Clear()
    {
        this.TheDict.Clear();
        this.TheList.Clear();
    }

    public MyHashList<T> Clone()
    {
        MyHashList<T> list = new MyHashList<T>();
        foreach (T local in this)
        {
            list.Add(local);
        }
        return list;
    }

    public virtual bool Contains(Predicate<T> match)
    {
        foreach (T local in this)
        {
            if (match(local))
            {
                return true;
            }
        }
        return false;
    }

    public virtual bool Contains(T item)
    {
        return (bool) (item.Id.get_HasValue() && this.ContainsId(item.Id.Value));
    }

    public virtual bool ContainsId(int id)
    {
        return (bool) ((id > -1) && this.TheDict.ContainsKey(id));
    }

    public virtual void CopyTo(T[] array, int arrayIndex)
    {
        for (int i = arrayIndex; i < (arrayIndex + this.Count); i = (int) (i + 1))
        {
            array[i] = this[i];
        }
    }

    public virtual T[] Filter(Predicate<T> match)
    {
        List<T> list = new List<T>();
        foreach (T local in this)
        {
            if (match(local))
            {
                list.Add(local);
            }
        }
        return list.ToArray();
    }

    public virtual T Find(Predicate<T> match)
    {
        foreach (T local in this)
        {
            if (match(local))
            {
                return local;
            }
        }
        return default(T);
    }

    public virtual T Find(int id)
    {
        if (!this.TheDict.ContainsKey(id))
        {
            return default(T);
        }
        return this.TheDict[id];
    }

    public virtual void ForEach(Action<T> function)
    {
        foreach (T local in this)
        {
            function(local);
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        <GetEnumerator>d__0<T> d__ = new <GetEnumerator>d__0<T>(0);
        d__.<>4__this = (MyHashList<T>) this;
        return d__;
    }

    public virtual int IndexOf(T item)
    {
        if (item.Id.get_HasValue())
        {
            return this.IndexOfId(item.Id.Value);
        }
        return -1;
    }

    public virtual int IndexOfId(int Id)
    {
        return this.TheList.IndexOf(Id);
    }

    public virtual void Insert(int index, T item)
    {
        if (item.Id.get_HasValue())
        {
            int? id = item.Id;
            if (!((id.GetValueOrDefault() < 0) && id.get_HasValue()) || !this.TheDict.ContainsKey(item.Id.Value))
            {
                goto Label_0083;
            }
        }
        item.Id = new int?(this._lowestId);
        this._lowestId = (int) (this._lowestId - 1);
    Label_0083:
        this.TheDict.Add(item.Id.Value, item);
        this.TheList.Insert(index, item.Id.Value);
    }

    public virtual bool Remove(T item)
    {
        return this.RemoveId(item.Id.Value);
    }

    public virtual void RemoveAt(int index)
    {
        this.TheDict.Remove(this.TheList.get_Item(index));
        this.TheList.RemoveAt(index);
    }

    public virtual bool RemoveId(int id)
    {
        if (this.TheDict.ContainsKey(id))
        {
            this.TheDict.Remove(id);
            this.TheList.Remove(id);
            return true;
        }
        return false;
    }

    public virtual void Sort(Comparison<int> compare)
    {
        this.TheList.Sort(compare);
    }

    void ICollection.CopyTo(Array array, int arrayIndex)
    {
        this.CopyTo((T[]) array, arrayIndex);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    // Properties
    public int Count
    {
        get
        {
            return this.TheList.get_Count();
        }
    }

    public T this[int index]
    {
        get
        {
            return this.TheDict[this.TheList.get_Item(index)];
        }
        set
        {
            this.RemoveAt(index);
            this.Insert(index, value);
        }
    }

    bool ICollection<T>.IsReadOnly
    {
        get
        {
            return false;
        }
    }

    bool ICollection.IsSynchronized
    {
        get
        {
            return false;
        }
    }

    object ICollection.SyncRoot
    {
        get
        {
            return this;
        }
    }

    protected virtual Dictionary<int, T> TheDict
    {
        get
        {
            if (this._dict == null)
            {
                this._dict = new Dictionary<int, T>();
            }
            return this._dict;
        }
    }

    protected virtual List<int> TheList
    {
        get
        {
            if (this._list == null)
            {
                this._list = new List<int>();
            }
            return this._list;
        }
    }

    // Nested Types
    [CompilerGenerated]
    private sealed class <GetEnumerator>d__0 : IEnumerator<T>, IEnumerator, IDisposable
    {
        // Fields
        private int <>1__state;
        private T <>2__current;
        public MyHashList<T> <>4__this;
        public List<int>.Enumerator <>7__wrap2;
        public int <id>5__1;

        // Methods
        [DebuggerHidden]
        public <GetEnumerator>d__0(int <>1__state)
        {
            this.<>1__state = <>1__state;
        }

        private bool MoveNext()
        {
            bool flag;
            try
            {
                switch (this.<>1__state)
                {
                    case 0:
                        this.<>1__state = -1;
                        this.<>7__wrap2 = this.<>4__this.TheList.GetEnumerator();
                        this.<>1__state = 1;
                        goto Label_0083;

                    case 2:
                        this.<>1__state = 1;
                        goto Label_0083;

                    default:
                        goto Label_00A8;
                }
            Label_0044:
                this.<id>5__1 = this.<>7__wrap2.Current;
                this.<>2__current = this.<>4__this.TheDict[this.<id>5__1];
                this.<>1__state = 2;
                return true;
            Label_0083:
                if (this.<>7__wrap2.MoveNext())
                {
                    goto Label_0044;
                }
                this.<>1__state = -1;
                this.<>7__wrap2.Dispose();
            Label_00A8:
                flag = false;
            }
            fault
            {
                ((IDisposable) this).Dispose();
            }
            return flag;
        }

        [DebuggerHidden]
        void IEnumerator.Reset()
        {
            throw new NotSupportedException();
        }

        void IDisposable.Dispose()
        {
            switch (this.<>1__state)
            {
                case 1:
                case 2:
                    break;

                default:
                    return;
                    try
                    {
                    }
                    finally
                    {
                        this.<>1__state = -1;
                        this.<>7__wrap2.Dispose();
                    }
                    break;
            }
        }

        // Properties
        T IEnumerator<T>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }
    }
}
4

4 回答 4

2

我至少可以帮助你理解为什么会这样。这可能是因为原始代码使用了一个迭代器块，它被翻译成一个令人困惑的标签和 goto 组合，构成了一个状态机。这是 Reflector 无法正确转换回原始代码的事情之一。

于 2009-10-07T10:15:24.967 回答
0

这是使用 yield return 返回 IEnumerable 生成的代码。编译器会生成一个状态机来跟踪您的位置，这就是非 C# 语法。它还使用类似的代码来实现自动属性和委托闭包。Reflector 目前无法计算出来自状态机的 yield 语句是什么，因此它可以使用 goto 和标签尽其所能。

于 2009-10-07T12:54:44.613 回答
0

你可以尝试用这个替换：

public IEnumerator<T> GetEnumerator()
{
        foreach (var e in this.list)
        {
            yield return e;
        }
}
于 2013-01-09T21:30:41.920 回答
0

我在net Reflector论坛上找到了一篇这样的文章，可以帮助大家理解这个问题，希望下个版本的.net Reflector可以解决这个问题：

作者：odalet 发布时间：2008 年 10 月 23 日星期四晚上 9:12 帖子是对问题的回答 - return new GetEnumerator>d__0(0) { <>4__this = this }

事实上，从 .NET 2.0 开始，一些语言结构只是语法糖，在编译时会导致 IL 生成。这些构造包括 yield 语句等（匿名委托和 lambdas、匿名类型、linq、...）

我认为您看到的代码是为收益生成的代码。每次你通过编写一个 yield return 来构建一个快速的 IEnumerable 实现......，在后台（在编译时）构建一个完整的枚举器类。因为它是直接在 IL 中生成的（嗯，我想是这样），所以变量和方法名称不必遵守 C# 命名限制。

从这篇文章开始，我说它可能是一个“缺失”的功能。如果我们可以打开一个选项，要求 Reflector 检查语句的 C# 正确性，如果不正确，生成 C# 兼容（或 VB 兼容）名称（应该不会太难：通常是这些变量和方法是私有的或内部的，任何混淆器都知道如何做到这一点......）。

在同一领域，非 C# 关键字或构造可能会出现一些问题。通常 switch 语句不能正确编译回来（因为如果一些 goto 对 C# 编译器来说跳得太远。我们可以在 try/catch/finally 中找到一些奇怪的块：可能会出现一个故障块......这在 IL 中是有效的，但不是在 C# 中

于 2009-10-07T15:22:11.837 回答