用于学习目的的复杂C#

我试图阅读一些其他人的代码，既帮助我学习C#，也纯粹是为了培养我理解其他人代码的能力，但我在网上发现的很多内容都很长，而且相对简单。我想知道是否有人能给我指出一些简短但更复杂的东西，最好包括不太常见的语言用法

（它不需要做任何明智的事情，只要它做了一些事情。一些完全没有意义的事情，比如XSLT Mandelbrot的C#等价物，就完全可以了）

请查看。它是.Net语言的混合体，一些（大多数）项目非常酷。也很酷。。。有很多示例，如果你有XBox360或Zune，你也可以为它们编写游戏。

这个怎么样

private Element ReadMemberExpression()
{
    var queue = new Queue<Element[]>();
    var newDepth = 0;
    var argsCount = 0;
    _scanner.CreateRestorePoint();
    while (true)
    {
        _scanner.CreateRestorePoint();
        {
            var a = ReadArguments();
            if (a != null)
            {
                argsCount++;
                if (argsCount > newDepth)
                {
                    _scanner.Restore();
                    break;
                }
                queue.Enqueue(new[] { default(Element), default(Element), a });
                _scanner.DeleteRestorePoint();
                continue;
            }
        }
        _scanner.DeleteRestorePoint();

        var pe = ReadPrimaryExpression();
        if (pe != null)
        {
            queue.Enqueue(new[] { pe });
            continue;
        }

        var fe = ReadFunctionExpression();
        if (fe != null)
        {
            queue.Enqueue(new[] { fe });
            continue;
        }

        if (_scanner.MatchNext(Grammar.New))
        {
            newDepth++;
            queue.Enqueue(new[] { Grammar.New });
        }
        else if (_scanner.Match(Grammar.LeftSquareBracket))
        {
            var e = ReadExpression();
            if (e == null)
            {
                throw new ParseException();
            }
            if (!_scanner.MatchNext(Grammar.RightSquareBracket))
            {
                throw new ParseException();
            }
            queue.Enqueue(new[]{default(Element), Grammar.LeftSquareBracket, e, Grammar.RightSquareBracket});
        }
        else if (_scanner.Match(Grammar.FullStop))
        {
            if (!_scanner.MatchNext(ElementType.IdentifierName))
            {
                throw new ParseException();
            }
            queue.Enqueue(new[] { default(Element), Grammar.FullStop, _scanner.Current });
        }
        else
        {
            _scanner.Unwind();
            break;
        }
    }
    if (queue.Count == 0)
    {
        _scanner.DeleteRestorePoint();
        return null;
    }
    else
    {
        var element = default(Element);
        var children = queue.Dequeue();
        while (children[0] == Grammar.New)
        {
            children = queue.Dequeue();
        }
        element = new Element(ElementType.MemberExpression, children);
        while (queue.Count > 0)
        {
            children = queue.Dequeue();
            if (children.Length == 3 && children[2].Type == ElementType.Arguments)
            {
                newDepth--;
                children[0] = Grammar.New;
                children[1] = element;
                element = new Element(ElementType.MemberExpression, children);
            }
            else
            {
                children[0] = element;
                element = new Element(ElementType.MemberExpression, children);
            }
        }
        if (newDepth > 0)
        {
            _scanner.Restore();
            return null;
        }
        _scanner.DeleteRestorePoint();
        return element;
    }
}

private元素ReadMemberExpression（）
{
var queue=新队列（）；
var-newDepth=0；
var argscont=0；
_scanner.CreateRestorePoint（）；
while（true）
{
_scanner.CreateRestorePoint（）；
{
var a=ReadArguments（）；
如果（a！=null）
{
argscont++；
如果（argscont>newDepth）
{
_scanner.Restore（）；
打破
}
Enqueue（new[]{default（Element），default（Element），a}）；
_scanner.DeleteRestorePoint（）；
继续；
}
}
_scanner.DeleteRestorePoint（）；
var pe=ReadPrimaryExpression（）；
如果（pe！=null）
{
排队（新[]{pe}）；
继续；
}
var fe=ReadFunctionExpression（）；
如果（fe！=null）
{
排队（新[]{fe}）；
继续；
}
if（_scanner.MatchNext（Grammar.New））
{
newDepth++；
queue.Enqueue（new[]{Grammar.new}）；
}
else if（_scanner.Match（Grammar.LeftSquareBracket））
{
var e=ReadExpression（）；
如果（e==null）
{
抛出新的ParseException（）；
}
if（！\u scanner.MatchNext（Grammar.rightsquare括号））
{
抛出新的ParseException（）；
}
Enqueue（new[]{default（元素），Grammar.LeftSquareBracket，e，Grammar.RightSquareBracket}）；
}
else if（_scanner.Match（Grammar.FullStop））
{
if（！\u scanner.MatchNext（ElementType.IdentifierName））
{
抛出新的ParseException（）；
}
Enqueue（新[]{default（元素），Grammar.FullStop，_scanner.Current}）；
}
其他的
{
_扫描器。展开（）；
打破
}
}
如果（queue.Count==0）
{
_scanner.DeleteRestorePoint（）；
返回null；
}
其他的
{
var元素=默认值（元素）；
var children=queue.Dequeue（）；
while（children[0]==Grammar.New）
{
children=queue.Dequeue（）；
}
元素=新元素（ElementType.MemberExpression，子元素）；
而（queue.Count>0）
{
children=queue.Dequeue（）；
if（children.Length==3&&children[2].Type==ElementType.Arguments）
{
新深度--；
children[0]=语法。新建；
子元素[1]=元素；
元素=新元素（ElementType.MemberExpression，子元素）；
}
其他的
{
子元素[0]=元素；
元素=新元素（ElementType.MemberExpression，子元素）；
}
}
如果（newDepth>0）
{
_scanner.Restore（）；
返回null；
}
_scanner.DeleteRestorePoint（）；
返回元素；
}
}

看一下-许多BCL类都已实现，您肯定会学到一些东西：）

还有许多开源的.NET项目，它们不是小而简单的应用程序，您可以查看它们

以下是我脑海中的一些想法：

• -一个.NET IDE
• -ORM
• -图像处理是一个很好的方法

---

这并不十分复杂，但可能只是简单的娱乐——Mads Torgersen在C#中实现了一个定点组合器，如下所示：

---

我建议你看看有效的C#图书。他们将帮助你学习更复杂的语言用法。

最近正在写一个关于英语的系列文章。这很可能是一个让你全神贯注的东西，因为这是一个由多部分组成的系列，在他解释图形着色的过程中，应该可以让你从简单到大脑的触觉

Luke Hoban的博客中的，立刻让我想起了。

使用。里面有很多很棒的东西，在我的学习过程中帮了我很多

---

很多时候，我都在想微软是如何在这个框架中完成某些事情的，我很容易就能在他们的源代码中找到答案。

这可能是一个显而易见的建议，但我会在上查看文章。您可以搜索与C#相关的特定文章，而贡献者通常会很好地解释他们的代码

例如，这里有一篇关于创建的文章（尽管这可能没有您所期望的那么复杂）

---

除此之外，我会在任何你可以通过谷歌找到的东西里面找到一个峰值

你可以看看我以前同事的代码。其中大部分都非常复杂，完全没有意义。这可能会帮助我学习阅读代码。另一方面，它可能会对我自己的编码产生负面影响。我用其他语言读过的一些“生产”代码让我怀疑我的职业选择。别担心，科林，所有最好的程序员似乎都是这样