c# 省略嵌套类型参数
c# omit nested type parameters
我想创建一个 Operation class,其函数将 Data 作为输入并提供 数据作为输出:
public abstract class Data { }
public abstract class Operation {
public abstract Data Run (Data input);
}
我想要不同 Data 输出的灵活性,而不是 Data 输入:
public abstract class Data { }
public abstract class Operation<T1, T2>
where T1: Data
where T2: Data
{
public abstract T2 Run (T1 input);
}
最后,我想强制所有 Data 实现某种类型的 List:
public abstract class Data<T> : List<T> { }
public abstract class Operation<T1, T2>
where T1: Data // Error
where T2: Data // Error
{
public abstract T2 Run (T1 input);
}
然后我得到错误:"Using the generic type 'Data' requires 1 type arguments".
如果不在 where 子句中明确设置数据类型,我该如何解决此错误?
理想情况下希望有以下代码工作:
public class Operation <????> { ???? }
public class Data<T> : List<T> {}
public class Foo {}
public class FooData : Data<Foo> {}
public class Bar {}
public class BarData : Data<Bar> {}
public class FBOperation : Operation<FooData, BarData> {
public override BarData Run (FooData input) {
return ...;
}
}
我应该如何实施操作 class?
你可以这样做:
public class Foo { }
public class Bar { }
public interface IData { }
public interface IData<T> : IData
{
List<T> List{ get; set; }
}
public class Foos : IData<Foo>
{
public List<Foo> List{ get; set; }
}
public class Bars : IData<Bar>
{
public List<Bar> List{ get; set; }
}
public abstract class Operation<TD1, TD2>
where TD1 : IData
where TD2 : IData
{
public abstract TD2 Run(TD1 input);
}
public class FbOperation : Operation<Foos, Bars>
{
public override Bars Run(Foos input)
{
// TODO
return new Bars();
}
}
问题在于您不再有 Data
类型,您向它添加了一个通用参数 T
并得到了一个完全不同的类型 Data<T>
, 因此约束 where T1: Data
不正确。
最直接的解决方案是将此附加参数传播到 Operation
类型。
public abstract class Operation<T1, T2, TItem>
where T1: Data<TItem>
where T2: Data<TItem>
{
public abstract T2 Run (T1 input);
}
但是对我来说事情有点太复杂了。考虑在 Operation<,>
class 上添加这些相当严格的限制有什么好处是有道理的。
这个基本版本可能足以描述一系列操作类型。
public abstract class Operation<T1, T2>
{
public abstract T2 Run (T1 input);
}
我想创建一个 Operation class,其函数将 Data 作为输入并提供 数据作为输出:
public abstract class Data { }
public abstract class Operation {
public abstract Data Run (Data input);
}
我想要不同 Data 输出的灵活性,而不是 Data 输入:
public abstract class Data { }
public abstract class Operation<T1, T2>
where T1: Data
where T2: Data
{
public abstract T2 Run (T1 input);
}
最后,我想强制所有 Data 实现某种类型的 List:
public abstract class Data<T> : List<T> { }
public abstract class Operation<T1, T2>
where T1: Data // Error
where T2: Data // Error
{
public abstract T2 Run (T1 input);
}
然后我得到错误:"Using the generic type 'Data' requires 1 type arguments".
如果不在 where 子句中明确设置数据类型,我该如何解决此错误?
理想情况下希望有以下代码工作:
public class Operation <????> { ???? }
public class Data<T> : List<T> {}
public class Foo {}
public class FooData : Data<Foo> {}
public class Bar {}
public class BarData : Data<Bar> {}
public class FBOperation : Operation<FooData, BarData> {
public override BarData Run (FooData input) {
return ...;
}
}
我应该如何实施操作 class?
你可以这样做:
public class Foo { }
public class Bar { }
public interface IData { }
public interface IData<T> : IData
{
List<T> List{ get; set; }
}
public class Foos : IData<Foo>
{
public List<Foo> List{ get; set; }
}
public class Bars : IData<Bar>
{
public List<Bar> List{ get; set; }
}
public abstract class Operation<TD1, TD2>
where TD1 : IData
where TD2 : IData
{
public abstract TD2 Run(TD1 input);
}
public class FbOperation : Operation<Foos, Bars>
{
public override Bars Run(Foos input)
{
// TODO
return new Bars();
}
}
问题在于您不再有 Data
类型,您向它添加了一个通用参数 T
并得到了一个完全不同的类型 Data<T>
, 因此约束 where T1: Data
不正确。
最直接的解决方案是将此附加参数传播到 Operation
类型。
public abstract class Operation<T1, T2, TItem>
where T1: Data<TItem>
where T2: Data<TItem>
{
public abstract T2 Run (T1 input);
}
但是对我来说事情有点太复杂了。考虑在 Operation<,>
class 上添加这些相当严格的限制有什么好处是有道理的。
这个基本版本可能足以描述一系列操作类型。
public abstract class Operation<T1, T2>
{
public abstract T2 Run (T1 input);
}