错误在公共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;
}
}
}
}
答案 0 :(得分：2)
我至少可以帮助你理解为什么会这样。这可能是因为原始代码使用了迭代器块，它被转换成组成状态机的标签和gotos的混乱混合。这是Reflector无法正确转换回原始代码的事情之一。
答案 1 :(得分：0)
这是使用yield return返回IEnumerable生成的代码。编译器生成一个状态机来跟踪你的位置，这就是非C＃语法。它还使用类似的代码来实现自动属性和委托闭包。 Reflector目前无法确定yield语句来自状态机的内容，因此它可以通过gotos和标签尽力而为。
答案 2 :(得分：0)
我在net Reflector论坛中发现了一个这样的艺术，可能会帮助大家理解这个问题，并希望下一版的.net Reflector可以解决这个问题：
作者：odalet PostPosted：Thu Oct 23,2008 9:12 pm The Post是对问题的回答 - 返回新的GetEnumerator＆gt; d__0（0）{＆lt;＆gt; 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中找到一些奇怪的块：可以出现一个faultblock ...这在IL中有效，但不是在C＃
答案 3 :(得分：0)
您可以尝试替换它：
public IEnumerator<T> GetEnumerator()
{
foreach (var e in this.list)
{
yield return e;
}
}