제네릭, 상속 및 연결에 관한 까다로운 질문

Question

컨텍스트 - read this.

문제 :

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는 일반/바 (이 여전히 잘 작동합니다) 만들기 :

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; 
     } 
    } 

---

그리고 질문은 -에 대한 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<T>은 아래에 buzz이 있음을 알고 있습니다.

기본 메서드를 만드는 방법이나 이러한 클래스에 대해 체인을 지원하는 다른 방법이 있습니까?

Answer 1

나는 당신이 성취하고자하는 것이 가능하다고 생각하지 않습니다.

where TBuzz : T<inner> 

의미 TBuzz 이것은 내가 아는 한 수 없습니다 T.의 내부 일반적인 유형의 형식이어야합니다 : 이론적으로 무엇을해야하는 등 제약의 일종이다.

Answer 2

this?

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

는 처음에 나는 Thrush combinator

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

의 종류 진전을하지만 그 막 다른 것 같다 생각했다. 어쨌든 그것을 향상시킬 수 있도록 게시하십시오.