使用派生类型和同名 C# 覆盖属性

Question

我正在尝试使用不同但具有相同名称的派生类型覆盖基类中的属性。我认为它可能通过协方差或泛型实现，但不知道该怎么做？

以下代码得到错误：

错误 1 ​​'Sun.Cache'：类型必须是 'OuterSpace.Cache' 匹配被覆盖 成员'OuterSpace.Cache'

public class OuterSpace {
    public virtual OuterSpaceData Data {get; set;}
    public virtual OuterSpaceAnalysis Analysis {get; set;}
    public virtual OuterSpaceCache Cache {get; set;}


    public class OuterSpaceData {
        //Lots of basic Data Extraction routines eg
        public virtual GetData();
    }
    public class OuterSpaceAnalysis {
        //Lots of Generic Analysis on Data routines eg
        public virtual GetMean();
    }
    public class OuterSpaceCache {
        //Lots of Caches of Past Analysis Results:
        public Dictionary<AnalysisType, List<Result>> ResultCache;
    }
}

public class Sun : OuterSpace {
    public override SunData Data {get; set;}
    public override SunAnalysis Analysis {get; set;}
    public override SunCache Cache {get; set;}

    public SunData : OuterSpaceData {
        //Routines to specific get data from the sun eg
        public override GetData();
    }

    public SunAnalysis : OuterSpaceAnalysis {
        //Routines specific to analyse the sun: eg
        public double ReadTemperature();
    }
    public SunCache : OuterSpaceCache {
        //Any data cache's specific to Sun's Analysis
        public Dictionary<AnalysisType, List<Result>> TempCache;
    }
}

public class Moon : OuterSpace {} etc.

对于最终结果，当我处理 Sun 的“数据”对象时，我不希望有两个数据对象（继承和基类），但是当我尝试覆盖该属性时，它需要 Sun 变量与基类相同的类型。例如：

Sun EarthSun = new Sun()
EarthSun.Analyse()  //The OuterSpace Analysis Saves results to Sun Cache:

//Now try use the result:
EarthSun.Cache[0]...

与此非常相似，但使用派生类型而不是字符串数组： C# Member variable overrides used by base class method

这个答案对我来说没有多大意义： How to override member of base class after inheritance in C++

或者这意味着它不可能？ Can I Override with derived types?

帮助！ :) 有什么解决办法吗？

Answer 1

这不可能完全按照你想要的方式。

您可以创建一个具有相同名称的“新”属性：

public new SunData Data
{
  get { return (SunData) base.Data; }
  set { base.Data = value; }
}

这并不完全相同，但它可能与您将要得到的一样接近。

另一种可能的方法是：

public SunData SunData { get; set; }

public override OuterSpaceData Data
{
  get { return SunData; }
  set { SunData = (SunData)value; }
}

这种方法的优点是它确实保证不可能在您的 Data 属性中放入不是 SunData 的东西。缺点是您的 Data 属性不是强类型的，如果您希望将其静态类型为 SunData，则必须使用 SunData 属性。

有一种丑陋的方式来获得“两全其美”，但代价是代码混淆并且之后难以理解 - 通过引入一个中间派生类，该类对基类 Data 属性和重定向到具有新名称的不同受保护属性，然后让最终派生类添加一个“新”数据属性，然后调用中间属性。不过，这确实是一个丑陋的 hack，即使我已经这样做了，我也不推荐它。

Answer 2

尝试使用泛型。以下类为OuterSpace 提供了一个通用基类，其参数约束对属性类型强制继承规则。为了清楚起见，我省略了小类型中的方法。

public class OuterSpace<TData, TAnalysis, TCache>
    where TData : OuterSpaceData
    where TAnalysis : OuterSpaceAnalysis
    where TCache : OuterSpaceCache
{
    public virtual TData Data { get; set; }
    public virtual TAnalysis Analysis { get; set; }
    public virtual TCache Cache { get; set; }
}
public class OuterSpaceData { }
public class OuterSpaceAnalysis { }
public class OuterSpaceCache { }

public class Sun : OuterSpace<SunData, SunAnalysis, SunCache>
{
    public override SunData Data { get; set; }
    public override SunAnalysis Analysis { get; set; }
    public override SunCache Cache { get; set; }
}
public class SunData : OuterSpaceData { }
public class SunAnalysis : OuterSpaceAnalysis { }
public class SunCache : OuterSpaceCache { }

这种方法的吸引力在于它允许您返回强类型属性并对这些属性的类型强制执行基本继承约束。这些方法是完全可覆盖的；但是，请注意，可能需要重写以避免基类实现的转换问题。

Answer 3

如果您正在寻找协方差路线，这样的方法应该可以：

public class OuterSpace<TCacheType> where TCacheType : OuterSpaceCache {
    public virtual OuterSpaceData Data {get; set;}
    public virtual OuterSpaceAnalysis Analysis {get; set;}
    public virtual TCacheType Cache {get; set;}


    public class OuterSpaceData {
        //Lots of basic Data Extraction routines eg
        public virtual GetData();
    }
    public class OuterSpaceAnalysis {
        //Lots of Generic Analysis on Data routines eg
        public virtual GetMean();
    }
    public class OuterSpaceCache {
        //Lots of Caches of Past Analysis Results:
        public Dictionary<AnalysisType, List<Result>> ResultCache;
    }
}

public class Sun : OuterSpace<SunCache> {
    public override SunData Data {get; set;}
    public override SunAnalysis Analysis {get; set;}

    public SunData : OuterSpaceData {
        //Routines to specific get data from the sun eg
        public override GetData();
    }

    public SunAnalysis : OuterSpaceAnalysis {
        //Routines specific to analyse the sun: eg
        public double ReadTemperature();
    }
    public SunCache : OuterSpaceCache {
        //Any data cache's specific to Sun's Analysis
        public Dictionary<AnalysisType, List<Result>> TempCache;
    }
}

公平警告，完全未编译的代码，我可能完全错了 :) 但这是我认为你想要的东西......

哦，我认为这是一个仅适用于 .Net 4.0 的解决方案，我不认为您可以更早地做到这一点，那里引入了协方差...

Answer 4

如果 SunData 与 Outerspace Data 的赋值兼容（继承自），则无需修改 OuterSpaceData 的类型

Answer 5

不确定泛型，但您可以通过简单的多态实现有限的效果（假设 SunData 继承自 Data 等）

public class Sun : OuterSpace 
{
  void SomeInitializationMethod()
  {
    Data = new SunData();
    Analysis = new SunAnalysis(); // etc
  }

    }

// You could also make casting simpler with a generic method on the base
public T GetData<T>()
{
  if (Data is T)
  {
    return Data as T;
  }
  return null;
};