关于泛型、继承和链接的棘手问题

Question

对于上下文 - 阅读本文。

问题：

 class Program
    {
        static void Main()
        {
            var b = new bar();

            b.buzz().fizz().buzz().fizz(); //cool
            //              ^FAIL!!!...<------------------------------------
            Console.ReadLine();
        }
    }

    public class foo
    {
        public foo fizz() { return this; }
    }

    public class bar : foo
    {
        public bar buzz()
        {
            return this;
        }
    }

解决方案：

 class Program
    {
        static void Main()
        {
            var b = new bar();

            b.buzz().fizz().buzz().fizz(); //cool stuff
            Console.ReadKey();
        }
    }

    public static class fooExtensions
    {
        public static T fizz<T>(this T t) where T : foo
        { return t; } 
    }

    public class foo{}

    public class bar : foo
    {
        public bar buzz()
        {
            return this;
        }
    }

这是一种如何“模仿”基类方法的技术，该方法能够返回派生类型（否则我的 b 无法再次调用嗡嗡声（））。

更进一步，使 foo/bar 通用（这仍然可以正常工作）：

  class Program
    {
        static void Main()
        {
            var b = new bar<buzz>();

            b.buzz().fizz().buzz().fizz(); //cool
            Console.ReadLine();
        }
    }

    public static class fooExtensions
    {
        public static T fizz<T>(this T t) where T : foo<buzz>
        { return t; }
    }

    public class buzz { public string name { get; set;} }

    public class foo<T> where T : buzz
    {}

    public class bar<T> : foo<T> where T : buzz
    {
        public bar<T> buzz()
        {
            return this;
        }
    }

---

问题是 -
如何将 lambda 传递给了解 tbuzz 及其属性的 fizz 方法，而无需显式传递类型参数。

可能反映我正在寻找的内容的损坏代码：

class Program
    {
        static void Main()
        {
            var b = new bar<buzz>();

            b.buzz().fizz(x=>x.name).buzz().fizz(); //not cool anymore
            //               ^FAIL!!!<---------------------------------
            Console.ReadLine();
        }
    }

    public static class fooExtensions
    {
        //NO IDEAS WHAT TO WRITE BELOW!!!
        public static T fizz<T, Tbuzz>(this T t, 
            Func<Tbuzz, object> superlambda)
            where T : foo<buzz>
            where Tbuzz : buzz 
        {
            return t;
        }
    }

    public class buzz { public string name { get; set;} }

    public class foo<T> where T : buzz
    {}

    public class bar<T> : foo<T> where T : buzz
    {
        public bar<T> buzz()
        {
            return this;
        }
    }

想知道这是否可能。如果不是——为什么？

理论上 - foo 知道下面有嗡嗡声。

是否有其他方法如何创建基本方法或模仿它来支持此类的链接？

Answer 1

我认为你想要实现的目标是不可能的。理论上，您需要的是某种约束，例如：

where TBuzz : T<inner> 

意味着 TBuzz 需要是 T 的内部泛型类型。据我所知，这是不可能的。

Answer 2

这个？

class Program
{
    static void Main(string[] args)
    {
        var b = new bar();
        var a = b.buzz().fizz(x => x.name).buzz().fizz();
        Console.ReadLine();
    }
}

public static class fooExtensions
{
    public static T fizz<T>(this T t) where T : foo
    { return t; }

    public static T fizz<T>(this T t,
        Func<T, object> superlambda)
        where T : foo
    {
        return t;
    }
}

public class foo { public string name { get; set; } }

public class bar : foo
{
    public bar buzz()
    {
        return this;
    }
}

Answer 3

起初我以为我在某种画眉取得了进展组合器

public static T fizz<T>(this T t, Func<T, T> f)
{ return f(t); }

但这似乎是一个死胡同。无论如何发布它，以防你可以改进它。