使用与其他方法相同的方法实现通用C#类

我在

C.

中遇到以下问题

我有两个类公开了一些常见的成员和方法，例如：

Class myClass01{
   public int a;
   public int b;
   public void method_01(){...}
   public void method_A(){...}
}

Class myGeneric<T>{
   public T element;

   public int sum(){
       return element.a + element.b;
   }

   public void methodGeneric(){
       element.method_01();
    }
}

public interface ImyClass { //this is the common interface
    int a { get; set; }
    int b { get; set; }
    void method_01();
}

class myClass01 : ImyClass { //your special interface implementation for myClass01
    public int a { get; set; }
    public int b { get; set; }
    public void method_01() { }
    public void method_A() { }
}

class myClass02 : ImyClass {  //your special interface implementation for myClass02
    public int a { get; set; }
    public int b { get; set; }
    public void method_01() { }
    public void method_B() { }
}

public abstract class myAbstractClass { //this is the common abstract class or base class
    public int a;
    public int b;
    public void method_01(){ } // all your common implementations
}

public class myClass01 : myAbstractClass {
    public void method_A() { } //your special implementation for myClass01
}

public class myClass02 : myAbstractClass {
    public void method_B() { } //your special implementation for myClass02
}

class myGeneric<T> where T : myAbstractClass { //generic specifically from myAbstractClass 
    public T element;

    public int sum() {              
        return element.a + element.b;
    }

    public void methodGeneric() {
        element.method_01();
    }
}

及

我想创建一个新的泛型

类

，它可以使用这两个类的公共属性/方法。例如：

Class myClass01{
   public int a;
   public int b;
   public void method_01(){...}
   public void method_A(){...}
}

Class myGeneric<T>{
   public T element;

   public int sum(){
       return element.a + element.b;
   }

   public void methodGeneric(){
       element.method_01();
    }
}

public interface ImyClass { //this is the common interface
    int a { get; set; }
    int b { get; set; }
    void method_01();
}

class myClass01 : ImyClass { //your special interface implementation for myClass01
    public int a { get; set; }
    public int b { get; set; }
    public void method_01() { }
    public void method_A() { }
}

class myClass02 : ImyClass {  //your special interface implementation for myClass02
    public int a { get; set; }
    public int b { get; set; }
    public void method_01() { }
    public void method_B() { }
}

public abstract class myAbstractClass { //this is the common abstract class or base class
    public int a;
    public int b;
    public void method_01(){ } // all your common implementations
}

public class myClass01 : myAbstractClass {
    public void method_A() { } //your special implementation for myClass01
}

public class myClass02 : myAbstractClass {
    public void method_B() { } //your special implementation for myClass02
}

class myGeneric<T> where T : myAbstractClass { //generic specifically from myAbstractClass 
    public T element;

    public int sum() {              
        return element.a + element.b;
    }

    public void methodGeneric() {
        element.method_01();
    }
}

类myGeneric{
公共T元素；
公共整数和（）{
返回元素a+元素b；
}
公共void methodGeneric（）{
元素。方法_01（）；
}
}

但在这种实现中，我会收到错误，因为元素不可访问。有没有一种方法可以使用来自不同类但定义相同的方法/属性来创建泛型类？

使用接口和“where”来访问成员。例如：

public class SortedList<T> : GenericList<T> where T : System.IComparable<T>

public class SortedList:genericslist，其中T:System.IComparable

使用接口和“where”来访问成员。例如：

public class SortedList<T> : GenericList<T> where T : System.IComparable<T>

public class SortedList:genericslist，其中T:System.IComparable

---

您当前正在创建的泛型

类

不受约束，无法知道泛型类型

T

必须从哪些类派生。因此，它假定

对象

，该对象不识别任何自定义的

公共/受保护的

字段、属性和您实现的方法

如果希望泛型

T

识别两个类之间共同的

public/protected

字段、属性和方法，则应创建一个

接口

，该接口由两个类实现，并且泛型类型

T

派生自该特定的

接口

例如：

Class myClass01{
   public int a;
   public int b;
   public void method_01(){...}
   public void method_A(){...}
}

Class myGeneric<T>{
   public T element;

   public int sum(){
       return element.a + element.b;
   }

   public void methodGeneric(){
       element.method_01();
    }
}

public interface ImyClass { //this is the common interface
    int a { get; set; }
    int b { get; set; }
    void method_01();
}

class myClass01 : ImyClass { //your special interface implementation for myClass01
    public int a { get; set; }
    public int b { get; set; }
    public void method_01() { }
    public void method_A() { }
}

class myClass02 : ImyClass {  //your special interface implementation for myClass02
    public int a { get; set; }
    public int b { get; set; }
    public void method_01() { }
    public void method_B() { }
}

public abstract class myAbstractClass { //this is the common abstract class or base class
    public int a;
    public int b;
    public void method_01(){ } // all your common implementations
}

public class myClass01 : myAbstractClass {
    public void method_A() { } //your special implementation for myClass01
}

public class myClass02 : myAbstractClass {
    public void method_B() { } //your special implementation for myClass02
}

class myGeneric<T> where T : myAbstractClass { //generic specifically from myAbstractClass 
    public T element;

    public int sum() {              
        return element.a + element.b;
    }

    public void methodGeneric() {
        element.method_01();
    }
}

然后在泛型中，使用

接口

class myGeneric<T> where T : ImyClass {
    public T element;

    public int sum() {              
        return element.a + element.b;
    }

    public void methodGeneric() {
        element.method_01();
    }
}

---

在任何情况下，都需要公共继承来识别

公共/受保护的

字段、属性和方法。

您当前创建的泛型

类

不受约束，无法知道泛型

类

必须从何派生。因此，它假定

对象

，该对象不识别任何自定义的

公共/受保护的

字段、属性和您实现的方法

如果希望泛型

T

识别两个类之间共同的

public/protected

字段、属性和方法，则应创建一个

接口

，该接口由两个类实现，并且泛型类型

T

派生自该特定的

接口

例如：

Class myClass01{
   public int a;
   public int b;
   public void method_01(){...}
   public void method_A(){...}
}

Class myGeneric<T>{
   public T element;

   public int sum(){
       return element.a + element.b;
   }

   public void methodGeneric(){
       element.method_01();
    }
}

public interface ImyClass { //this is the common interface
    int a { get; set; }
    int b { get; set; }
    void method_01();
}

class myClass01 : ImyClass { //your special interface implementation for myClass01
    public int a { get; set; }
    public int b { get; set; }
    public void method_01() { }
    public void method_A() { }
}

class myClass02 : ImyClass {  //your special interface implementation for myClass02
    public int a { get; set; }
    public int b { get; set; }
    public void method_01() { }
    public void method_B() { }
}

public abstract class myAbstractClass { //this is the common abstract class or base class
    public int a;
    public int b;
    public void method_01(){ } // all your common implementations
}

public class myClass01 : myAbstractClass {
    public void method_A() { } //your special implementation for myClass01
}

public class myClass02 : myAbstractClass {
    public void method_B() { } //your special implementation for myClass02
}

class myGeneric<T> where T : myAbstractClass { //generic specifically from myAbstractClass 
    public T element;

    public int sum() {              
        return element.a + element.b;
    }

    public void methodGeneric() {
        element.method_01();
    }
}

然后在泛型中，使用

接口

class myGeneric<T> where T : ImyClass {
    public T element;

    public int sum() {              
        return element.a + element.b;
    }

    public void methodGeneric() {
        element.method_01();
    }
}

---

在任何情况下，都需要公共继承来识别

公共/受保护的

字段、属性和方法。

请注意，除了在使用接口时使用通用继承外，您可以简单地使用泛型继承

class myGeneric {
    public ImyClass element;

    public int sum() {              
        return element.a + element.b;
    }

    public void methodGeneric() {
        element.method_01();
    }
}

---

尽管这不是实际的问题

请注意，除了在使用接口时给出答案外，您还可以简单地使用泛型

class myGeneric {
    public ImyClass element;

    public int sum() {              
        return element.a + element.b;
    }

    public void methodGeneric() {
        element.method_01();
    }
}

---

虽然这不是实际问题

为什么不使用接口或抽象类？有时间时请查看命名约定为什么不使用接口或抽象类？有时间时请查看命名约定