C# C中具有泛型数据类型的泛型图像类#

我想创建具有通用数据类型的通用图像类，如下面的代码所示

在这个实现中，我不喜欢的是我必须声明类，比如：

图像a

而不是：

Image<BGR, byte> a;

图像a；

有没有办法做到这一点

public interface IColor<T>
{ }

public struct BGR<T>: IColor<T>
{
    public T B;
    public T G;
    public T R;
}

public class Image<TColor, T> where TColor: IColor<T>
{
    TColor[,] data;
}

class Program
{
    static void Main(string[] args)
    {
        Image<BGR<byte>, byte> a;
    }
}

公共接口IColor
{ }
公共结构BGR:IColor
{
公共旅游局；
公共交通；
公共交通；
}
公共类映像，其中TColor:IColor
{
t颜色[，]数据；
}
班级计划
{
静态void Main（字符串[]参数）
{
图像a；
}
}
我所做的就是将
IColor
设置为非通用，并遵循以下步骤：

public interface IColor
{ }

public struct BGR<T>: IColor
{
    public T B;
    public T G;
    public T R;
}

public class Image<TColor> where TColor: IColor
{
    TColor[,] data;
}

class Program
{
    static void Main(string[] args)
    {
        Image<BGR<byte>> a;
    }
}

公共接口IColor
{ }
公共结构BGR:IColor
{
公共旅游局；
公共交通；
公共交通；
}
公共类映像，其中TColor:IColor
{
t颜色[，]数据；
}
班级计划
{
静态void Main（字符串[]参数）
{
图像a；
}
}

根据类型
T
存在不同的
BGR
s这一事实并不意味着所有
IColor
实现都必须依赖于类型
T
。可能存在具有零、2或9个类型参数的
IColor
实现-只要它们满足
IColor
的实际契约（这很容易做到…），它们就可以了。

代码

public interface IColor<T> {
    IColor<U> FromColor<U>(IColor<U> color);
}

public class Bgr: IColor<byte>, IColor<int> /* .. more IColor<T> */ {
    public IColor<T> FromColor<T>(IColor<T> color) {
        if(null==color)
            return default(Bgr<T>);

        if(color is Bgr)
            return color;

        if(color is Bgr<T>)
            return new Bgr {
                Value=color
            } as IColor<T>;

        throw new NotImplementedException();
    }

    public object Value;
}

public struct Bgr<T>: IColor<T> {
    IColor<U> IColor<T>.FromColor<U>(IColor<U> color) {
        if(null==color)
            return default(Bgr<U>);

        if(color is Bgr)
            return (Bgr<U>)(color as Bgr).Value;

        if(color is Bgr<U>)
            return color;

        throw new NotImplementedException();
    }

    public T B, G, R;
}

public class Image<TColor, T> where TColor: IColor<T>, new() {
    public static Array CreateArray(params int[] lengths) {
        var color=(new TColor()).FromColor(default(TColor));
        return Array.CreateInstance(color.GetType(), lengths);
    }

    public Image(params int[] lengths) {
        data=Image<TColor, T>.CreateArray(lengths);
    }

    public Array data; // expose for test
}

公共接口IColor{
IColor FromColor（IColor color）；
}
公共类Bgr:IColor，IColor/*。。更多IColor*/{
公共IColor FromColor（IColor颜色）{
如果（空==颜色）
返回默认值（Bgr）；
if（颜色为Bgr）
返回颜色；
if（颜色为Bgr）
返回新的Bgr{
值=颜色
}作为IColor；
抛出新的NotImplementedException（）；
}
公共客体价值；
}
公共结构Bgr:IColor{
IColor.FromColor（IColor颜色）{
如果（空==颜色）
返回默认值（Bgr）；
if（颜色为Bgr）
返回（Bgr）（颜色为Bgr）。值；
if（颜色为Bgr）
返回颜色；
抛出新的NotImplementedException（）；
}
公共T B，G，R；
}
公共类映像，其中TColor:IColor，new（）{
公共静态数组CreateArray（参数int[]长度）{
var color=（new TColor（））.FromColor（默认值（TColor））；
返回Array.CreateInstance（color.GetType（），长度）；
}
公共映像（参数int[]长度）{
数据=Image.CreateArray（长度）；
}
公共数组数据；//为测试而公开
}

试验

public class TestClass {
    public static void TestMethod() {
        var image=new Image<Bgr, byte>(640, 480);
        var data=(Bgr<byte>[,])image.data;
        var bgr=new Bgr<byte>();
        bgr.B=123;
        data[0, 0]=bgr;
        data[0, 0].G=124;
        bgr=data[0, 0];
        Console.WriteLine("bgr{{B={0}, G={1}, R={2}}}", bgr.B, bgr.G, bgr.R);
    }
}

公共类TestClass{
公共静态void TestMethod（）{
var图像=新图像（640480）；
var data=（Bgr[，]）image.data；
var bgr=新的bgr（）；
bgr.B=123；
数据[0,0]=bgr；
数据[0,0].G=124；
bgr=数据[0,0]；
WriteLine（“bgr{{B={0}，G={1}，R={2}}}”，bgr.B，bgr.G，bgr.R）；
}
}

为什么
IColor
是通用的？为什么你不喜欢它？：-）我的意思是，如果你喜欢图像，那么你可以含蓄地喜欢图像！在这两种情况下，您都提供了一种类型。IColor是通用的，因为有不止一种颜色类型，如HSV、BGR、LSV。。。其中像素数据类型设置为T。@dajuric:但是
IColor
没有任何成员，是吗？不，没有。如果你有另一个概念，请与我分享。唯一的条件是我可以写图像或图像代替图像。我需要将TColor约束为IColor，而不是特定的颜色。但是谢谢你，谢谢你。但会有更多的颜色类型，如Bgr、Bgra、Hsv、Lsv。。。。我将需要把约束（结构）的像素类型的每种颜色类型，但在核心接口IColor。本质上，我希望有类似于EmguCV的实现，但有一个大的例外，所有颜色类都是泛型的。在你看来，这是一个好的概念，还是你为这个问题提出了其他建议？