我有一个泛型基类Foo<T>,Bar<U>和Bat<T>类都是从这个基类派生的。U由T派生而来。Bat和Bar是类似的实现,只是在一些地方不同,U类型的值必须以不同的方式处理。
在Foo中,我有一个工厂方法Create,它接受T类型的参数,应该创建一个Bar或Bat对象。它看起来大致如下:
public static IFoo<T> Create(T input) {
if (input.TypeIdentifier == Types.Bar) {// exemplary type check
// input is of or de
可以在C#中编译下面的代码吗?我确实用Java编译了类似的代码。
public interface IInterface
{
...
}
public class Class1 : IInterface
{
...
}
public abstract class Base<T> where T : IInterface
{
...
}
public class Class2<T> : Base<T> where T : IInterface
{
...
}
.
.
.
public SomeMethod()
{
class B : A {}
class Sub<T> where T:A
{
//...
}
我想将Sub实例存储在一个集合中。
var c = new List<Sub<A>>();
c.Add(new Sub<B>()); //doesn't work
但是,为了让它真正工作,我必须声明一个接口并存储该接口的实例。
interface IBase
{
void DoStuff(A a);
}
var c = new List<IBase>();
c.Add(new Sub<B>()); //work
我在创建查询类的泛型列表时遇到了一个问题。这些查询类是从具有自引用类型约束的抽象泛型基类派生的。
精简的基类和派生类包括:
public abstract class AbstractQuery<TQuery, TResult>
where TQuery : AbstractQuery<TQuery, TResult>
{
public IEnumerable<TResult> Query ()
{
return new List<TResult>();
}
}
public class Fi
// The Structure of the Container and the items
public interface IContainer <TItem> where TItem : IItem
{
}
public class AContainer : IContainer<ItemA>
{
}
public interface IItem
{
}
public class ItemA : IItem
{
}
// Client app
[Test]
public void Test ()
{
IContainer<IItem&g
以下总结了我对C#中差异的理解。如果你能告诉我问题出在哪里,我会很感激,因为我读过埃里克·利珀特( Eric )在上发表的那篇文章,我无法理解其中的大部分内容。
方差是指一种类型的转换(或者像Eric Lippert所说的那样的投影)可以保持赋值兼容性(协方差),或者逆转它(反方差),或者既不能保持它,也不能逆转它(不变性)。也就是说,如果我是T中的协变量转换,其中T是一组类型,那么对于T中的任何T1和T2类型,如果T1可分配给T2,则I<T1>可分配给I<T2>。如果我是反差的话,结果就会恢复。如果我是不变的,那么I<T1>既不能分配给I<T2>
给定一个通用属性类:
public class Attribute<T>
{
string Name { get; set; }
T Value { get; set; }
}
有没有办法让一个对象包含一个包含各种类型的泛型(例如int、string、datetime)的enumerable。
public class AttributableObject
{
IEnumerable<???> attributes { get; set;}
}
有没有办法做到这一点,而不会遇到方差问题?
协变性是关于接受价值的吗?
我正在通过C#通过C#书籍学习。我看到了以下节选:
由于T是协变的,所以有可能编译并成功运行以下代码:
// This method accepts an IEnumerable of any reference type
Int32 Count(IEnumerable<Object> collection) { ... }
...
// The call below passes an IEnumerable<String> to Count
Int32 c = Count(new[] { "Grant" });
我有一些逻辑,类似于下面简单的描述。谁能给我解释一下为什么fB()的执行会显示不匹配?
interface SomeInterface<T> {
fun showMe(aa: T)
fun getOne(): T
}
interface Jsonizer {
//something here
}
data class Template (val id: String): Jsonizer
object SomeImpl: SomeInterface<Template> {
override fun showMe(aa: Template)
在我的应用程序中,我使用不同的web来获取汽车信息。对于我已经实现的服务,我实现了ICarService。由于所有这些Api返回的汽车数据都不一样,我已经实现了ICar接口,因此每个服务都可以返回自己类型的汽车,但在我的应用程序中,我可以使用“通用”ICar。
以下是我的实现:
// Car Model
public interface ICar
{
string Color { get; }
}
public class CarApiA : ICar
{
public int car_color { get; set; }
public Color
{
我是一个C#游戏制造商与团结。我有可收藏的管理系统。
CollectableManager
public List<CollectableParent<Collectable>> collactableParentsList;
CollectableParent
public class CollectableParent<T> : CollectableRelatedMonoBehaviour where T : Collectable
SpawnPointDefinedCollectableParent
public class SpawnPointPa
当涉及到接口时,我不清楚C#中的协方差的概念。严格基于我下面的例子,这是一个协方差的例子,请描述为什么或为什么不是。
class Program
{
static void Main()
{
ICarInterface car = new Car();
}
}
interface ICarInterface
{
void Start();
}
class Car : ICarInterface
{
public void Start()
{
}
}
我有个问题:
class Base
{
}
class DerivedClass : Base
{
}
class Test<T> where T : Base
{
}
类似这样的东西:
Test<Base> a = new Test<DerivedClass>();
我认为在C# 4.0中有一种方法可以绕过它,但是在C# 3中有没有这样的方法呢?
是否可以将不同类型的通用对象添加到列表中?如下所示。
public class ValuePair<T>
{
public string Name { get; set;}
public T Value { get; set;
}
假设我有所有这些物体..。
ValuePair<string> data1 = new ValuePair<string>();
ValuePair<double> data2 = new ValuePair<double>(
在c#中是否有与以下Java代码等效的代码
List<? extends Number> list;
list = new ArrayList<Float>();
list = new ArrayList<Integer>();
list.add(Float.valueOf("4.0")); // doesn't compile and it is fine
Number e = list.get(0); // workds
我在读c#中的协变类型
List<SomeClass> list2 = new List<S
我得到以下错误
与`System.Collections.Generic.List>.Add(MyContainer)‘匹配的最佳重载方法具有一些无效参数(CS1502) (GenericsTest)
对于以下类:
A和B是MyBase的子类。
public class GenericConstraintsTest
{
private MyList<MyContainer<MyBase>> myList = new MyList<MyContainer<MyBase>>();
public GenericConstrai
我有如下的类结构:
public class A : AInterface { }
public interface AInterface { }
public class B<T> : BInterface<T> where T : AInterface
{
public T Element { get; set; }
}
public interface BInterface<T> where T : AInterface
{
T Element { get; set; }
}
public class Y : B<A>
为什么这个不起作用?!
public interface IBus
{
void Subscribe<T>(ISubscribe<T> subscriber) where T : class, IEvent;
void Send<T>(IEvent @event) where T : class, IEvent;
}
class InMemoryEventBus : IBus
{
private readonly IDictionary<ISubscribe<
我刚刚在VS2010中创建了一个简单的项目,C# DotNet3.5
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Business.Util
{
public interface ICalculateCurrent<in T1, in T2, in T3, in T4>
{
bool GetValue(T1 obj1, T2 obj2, T3 obj3, T4 obj4);
我有一个接口ID,它派生自另一个接口IB。 public interface IB
{
int Num { get; }
}
public interface ID : IB
{
} 假设我们有一个实现ID的类: public class DImpl : ID
{
public int Num { get; set; }
} 我知道我可以调用一个接收IB的函数,其中的变量被保存为ID。 public void FuncOfIB(IB b)
{
// do something
}
public static void Main()
{
ID d =
在scala中,选项类声明如下
sealed abstract class _Option[+A]
case object _None extends _Option[Nothing] {}
final case class _Some[+A](x: A) extends _Option[A] {}
[+A]是什么?为什么不只是[A]?它会是[-A]吗?它意味着什么?
对不起,如果是复制的话,但是我找不到答案。
我有下面的代码来理解协变和下限,我故意让代码有编译错误。
getOrElse的工作原理类似于Option+T的getOrElse方法。
我会问,为什么getOrElse2和getOrElse3不能更好地理解协变和下限。
编译错误将作为注释粘贴到代码中:
class MyOption[+A](val x: A) {
def get():A = x
//similar to Option.getOrElse,which works
def getOrElse[B>:A ](default: => B): B = {
if (x != null) x else
即
struct Child<Type> {
var item: Type
}
class Parent {
var children = [Child<**ANY subclass of UIView, for example**>]()
}
所以如果我有
let one = Child(item: UIView())
let two = Child(item: UITableView())
我想要一份
let parent = Parent()
parent.children += [one,two]
如果您使用[Child<UIView&