C#泛型与委托:一个简单的数组模板示例

最新推荐文章于 2025-11-22 16:47:31 发布
原创 最新推荐文章于 2025-11-22 16:47:31 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#泛型

本文介绍了如何在C#中利用泛型和委托创建一个二维数组模板，以提高代码复用性和效率。通过示例展示，模板使得避免了为不同数据类型重复编写代码的问题，提升了开发效率。

以下是个人项目中可能会用到的一个二维数组模板，简便高效(?)

using System;
using System.Collections.Generic;

namespace Array2DTemplate
{
    public class Array2D<Ty> where Ty : struct // 泛型约束 Ty必须struct类型
    {
        private int _row;
        private int _col;
        private Ty[,] _data;

        #region GetSet
        public Ty[,] Data
        {
            get
            {
                return _data;
            }
            set
            {
                _data = value;
            }
        }

        public int Row
        {
            get
            {
                return _row;
            }
        }

        public int Col
        {
            get
            {
                return _col;
            }
        }

        public void SetData(Ty[] buffer)
        {
            int _size = _row * _col;
            int size=buffer.Length;
            if(size<_size)
            {
                throw new Exception("Notenough size");
            }
            int k = 0;
            for (int i = 0; i < _row; ++i)
            {
                for (int j = 0; j < _col; ++j)
                {
                    _data[i, j] = buffer[k];
                    ++k;
                }
            }
        }

        #endregion GetSet

        #region Constructions
        public Array2D()
        {
            _row = 0;
            _col = 0;
            _data = null;
        }

        public Array2D(int row, int col)
        {
            if (row <= 0 || col <= 0)
            {
                throw new Exception("Dimension size must be positive!");
            }
            _row = row;
            _col = col;
            _data = new Ty[row, col];
        }

        #endregion Constructions

        #region SimpleOperations

        public Array2D<Ty> Add(Array2D<Ty> another)
        {
            int row = another.Row;
            int col = another.Col;
            if (row != _row || col != _col)
            {
                throw new Exception("Size must be the same!");
            }
            Array2D<Ty> result = new Array2D<Ty>(row, col);
            Ty[,] A = _data;
            Ty[,] B = another.Data;
            Ty[,] R = result.Data;
            for (int i = 0; i < row; ++i)
            {
                for (int j = 0; j < col; ++j)
                {
                    R[i, j] = BaseArithmetic.Add<Ty>(A[i, j], B[i, j]);
                }
            }

            return result;
        }

        public Array2D<Ty> Sub(Array2D<Ty> another)
        {
            int row = another.Row;
            int col = another.Col;
            if (row != _row || col != _col)
            {
                throw new Exception("Size must be the same!");
            }
            Array2D<Ty> result = new Array2D<Ty>(row, col);
            Ty[,] A = _data;
            Ty[,] B = another.Data;
            Ty[,] R = result.Data;
            for (int i = 0; i < row; ++i)
            {
                for (int j = 0; j < col; ++j)
                {
                    R[i, j] = BaseArithmetic.Sub<Ty>(A[i, j], B[i, j]);
                }
            }

            return result;
        }

        public Array2D<Ty> Mul(Array2D<Ty> another)
        {
            int row = another.Row;
            int col = another.Col;
            if (row != _row || col != _col)
            {
                throw new Exception("Size must be the same!");
            }
            Array2D<Ty> result = new Array2D<Ty>(row, col);
            Ty[,] A = _data;
            Ty[,] B = another.Data;
            Ty[,] R = result.Data;
            for (int i = 0; i < row; ++i)
            {
                for (int j = 0; j < col; ++j)
                {
                    R[i, j] = BaseArithmetic.Mul<Ty>(A[i, j], B[i, j]);
                }
            }

            return result;
        }

        public Array2D<Ty> Div(Array2D<Ty> another)
        {
            int row = another.Row;
            int col = another.Col;
            if (row != _row || col != _col)
            {
                throw new Exception("Size must be the same!");
            }
            Array2D<Ty> result = new Array2D<Ty>(row, col);
            Ty[,] A = _data;
            Ty[,] B = another.Data;
            Ty[,] R = result.Data;
            for (int i = 0; i < row; ++i)
            {
                for (int j = 0; j < col; ++j)
                {
                    R[i, j] = BaseArithmetic.Div<Ty>(A[i, j], B[i, j]);
                }
            }

            return result;
        }

        public void FindMaxMin(out Ty max, out Ty min)
        {
            int ret = 0;
            Ty value;
            max = _data[0, 0];
            min = _data[0, 0];
            for (int i = 0; i < _row; ++i)
            {
                for (int j = 0; j < _col; ++j)
                {
                    value = _data[i, j];
                    ret = BaseComparator<Ty>.Instance.Compare(value, max);
                    if (ret >= 0) max = value;
                    else
                    {
                        ret = BaseComparator<Ty>.Instance.Compare(value, min);
                        if (ret < 0) min = value;
                    }
                }
            }

            if (BaseComparator<Ty>.Instance.Compare(max, min) == 0)
            {
                throw new Exception("Max = Min");
            }
        }

        #endregion SimpleOperations

        #region OverloadedOperations

        public static Array2D<Ty> operator +(Array2D<Ty> a, Array2D<Ty> b)
        {
            return a.Add(b);
        }

        public static Array2D<Ty> operator -(Array2D<Ty> a, Array2D<Ty> b)
        {
            return a.Sub(b);
        }

        public static Array2D<Ty> operator *(Array2D<Ty> a, Array2D<Ty> b)
        {
            return a.Mul(b);
        }

        public static Array2D<Ty> operator /(Array2D<Ty> a, Array2D<Ty> b)
        {
            return a.Div(b);
        }

        #endregion OverloadedOperations
    }

    public static class BaseArithmetic
    {
        private static string GetTypeString<Ty>(Ty t) where Ty : struct
        {
            string ts = typeof(Ty).ToString();
            return ts.Substring(ts.LastIndexOf('.') + 1);
        }

        #region BasicOperations
        public static Ty Add<Ty>(Ty a, Ty b) where Ty : struct
        {
            string str = GetTypeString<Ty>(a);
            switch (str)
            {
                case "Int16":
                case "Int32":
                    int result1 = Convert.ToInt32(a) + Convert.ToInt32(b);
                    return (Ty)(Convert.ChangeType(result1, typeof(Ty)));
                case "Byte":
                case "UInt16":
                case "UInt32":
                    uint result2 = Convert.ToUInt32(a) + Convert.ToUInt32(b);
                    return (Ty)(Convert.ChangeType(result2, typeof(Ty)));
                case "Single":
                case "Double":
                    double result3 = Convert.ToDouble(a) + Convert.ToDouble(b);
                    return (Ty)(Convert.ChangeType(result3, typeof(Ty)));
                default:
                    return (Ty)(new object());
            }
        }

        public static Ty Sub<Ty>(Ty a, Ty b) where Ty : struct
        {
            string str = GetTypeString<Ty>(a);
            switch (str)
            {
                case "Int16":
                case "Int32":
                    int result1 = Convert.ToInt32(a) - Convert.ToInt32(b);
                    return (Ty)(Convert.ChangeType(result1, typeof(Ty)));
                case "Byte":
                case "UInt16":
                case "UInt32":
                    uint result2 = Convert.ToUInt32(a) - Convert.ToUInt32(b);
                    return (Ty)(Convert.ChangeType(result2, typeof(Ty)));
                case "Single":
                case "Double":
                    double result3 = Convert.ToDouble(a) - Convert.ToDouble(b);
                    return (Ty)(Convert.ChangeType(result3, typeof(Ty)));
                default:
                    return (Ty)(new object());
            }
        }

        public static Ty Mul<Ty>(Ty a, Ty b) where Ty : struct
        {
            string str = GetTypeString<Ty>(a);
            switch (str)
            {
                case "Int16":
                case "Int32":
                    int result1 = Convert.ToInt32(a) * Convert.ToInt32(b);
                    return (Ty)(Convert.ChangeType(result1, typeof(Ty)));
                case "Byte":
                case "UInt16":
                case "UInt32":
                    uint result2 = Convert.ToUInt32(a) * Convert.ToUInt32(b);
                    return (Ty)(Convert.ChangeType(result2, typeof(Ty)));
                case "Single":
                case "Double":
                    double result3 = Convert.ToDouble(a) * Convert.ToDouble(b);
                    return (Ty)(Convert.ChangeType(result3, typeof(Ty)));
                default:
                    return (Ty)(new object());
            }
        }

        public static Ty Div<Ty>(Ty a, Ty b) where Ty : struct
        {
            string str = GetTypeString<Ty>(a);
            switch (str)
            {
                case "Int16":
                case "Int32":
                    int ib = Convert.ToInt32(b);
                    if (ib == 0) throw new DivideByZeroException();
                    int result1 = Convert.ToInt32(a) / ib;
                    return (Ty)(Convert.ChangeType(result1, typeof(Ty)));
                case "Byte":
                case "UInt16":
                case "UInt32":
                    uint ub = Convert.ToUInt32(b);
                    if (ub == 0) throw new DivideByZeroException();
                    uint result2 = Convert.ToUInt32(a) / ub;
                    return (Ty)(Convert.ChangeType(result2, typeof(Ty)));
                case "Single":
                case "Double":
                    double db = Convert.ToDouble(b);
                    if (Math.Abs(db) < Double.Epsilon) throw new DivideByZeroException();
                    double result3 = Convert.ToDouble(a) / db;
                    return (Ty)(Convert.ChangeType(result3, typeof(Ty)));
                default:
                    return (Ty)(new object());
            }
        }

        #endregion BasicOperations
    }

    public static class BaseConvertor
    {
        public static Array2D<byte> ToByteArray<Ty>(Array2D<Ty> src, out double scale, out double offset) where Ty : struct
        {
            int row = src.Row;
            int col = src.Col;
            Array2D<byte> dst = new Array2D<byte>(row, col);

            byte[,] dstData = dst.Data;
            Ty[,] srcData = src.Data;

            Ty max, min;
            src.FindMaxMin(out max, out min);
            scale = Convert.ToDouble(BaseArithmetic.Sub(max, min)) / 255;
            offset = Convert.ToDouble(min);
            for (int i = 0; i < row; ++i)
            {
                for (int j = 0; j < col; ++j)
                {
                    dstData[i, j] = (byte)(Convert.ToDouble(BaseArithmetic.Sub(srcData[i, j], min)) / scale + 0.5);
                }
            }

            return dst;
        }
    }

    public class BaseComparator<Ty>
    {
        Comparison<Ty> _comparison;                  //比较委托
        static readonly Dictionary<Type, Delegate> _map = new Dictionary<Type, Delegate>();
        //实现单例
        static readonly BaseComparator<Ty> _instance = new BaseComparator<Ty>();
        private BaseComparator() { }
        public static BaseComparator<Ty> Instance
        {
            get
            {
                System.Diagnostics.Debug.Assert(_map.ContainsKey(typeof(Ty)));
                //强转为具体的比较委托
                _instance._comparison = (Comparison<Ty>)_map[typeof(Ty)];
                return _instance;
            }
        }
        //情态构造,初始化
        static BaseComparator()
        {
            //基础类型比较器
            Type t = typeof(Ty);
            if (t == typeof(Byte))
            {
                Comparison<Byte> cmp_Byte = delegate(Byte t1, Byte t2) { return t1 > t2 ? 1 : (t1 == t2 ? 0 : -1); };
                _map.Add(typeof(Byte), (Delegate)cmp_Byte);
            }
            else if(t==typeof(UInt16))
            {
                Comparison<UInt16> cmp_UInt16 = delegate(UInt16 t1, UInt16 t2) { return t1 > t2 ? 1 : (t1 == t2 ? 0 : -1); };
                _map.Add(typeof(UInt16), (Delegate)cmp_UInt16);
            }
            else if (t == typeof(Int16))
            {
                Comparison<Int16> cmp_Int16 = delegate(Int16 t1, Int16 t2) { return t1 > t2 ? 1 : (t1 == t2 ? 0 : -1); };
                _map.Add(typeof(Int16), (Delegate)cmp_Int16);
            }
            else if(t==typeof(UInt32))
            {
                Comparison<UInt32> cmp_UInt32 = delegate(UInt32 t1, UInt32 t2) { return t1 > t2 ? 1 : (t1 == t2 ? 0 : -1); };
                _map.Add(typeof(UInt32), (Delegate)cmp_UInt32);
            }
            else if(t==typeof(Int32))
            {
                Comparison<Int32> cmp_Int32 = delegate(Int32 t1, Int32 t2) { return t1 > t2 ? 1 : (t1 == t2 ? 0 : -1); };
                _map.Add(typeof(Int32), (Delegate)cmp_Int32);
            }
            else if (t == typeof(Single))
            {
                Comparison<Single> cmp_Single = delegate(Single t1, Single t2) { return t1 > t2 ? 1 : (t1 == t2 ? 0 : -1); };
                _map.Add(typeof(Single), (Delegate)cmp_Single);
            }
            else if (t == typeof(Double))
            {
                Comparison<Double> cmp_Double = delegate(Double t1, Double t2) { return t1 > t2 ? 1 : (t1 == t2 ? 0 : -1); };
                _map.Add(typeof(Double), (Delegate)cmp_Double);
            }
            else
            {
                throw new Exception("Unsupported type!");
            }
        }
        //注册自定义比较
        public static void Register<NewTy>(Comparison<NewTy> comparison)
        {
            System.Diagnostics.Debug.Assert(_map.ContainsKey(typeof(NewTy)) == false);

            _map.Add(typeof(NewTy), (Delegate)comparison);
        }
        //比较函数,以后用来实现IComparator用
        public int Compare(Ty t1, Ty t2)
        {
            System.Diagnostics.Debug.Assert(_comparison != null);

            return _comparison(t1, t2);
        }
    }
}


使用示例 

            Array2D<int> ia = new Array2D<int>(800, 800);
            for (int i = 0; i < 800; ++i)
            {
                for (int j = 0; j < 800; ++j)
                {
                    ia.Data[i, j] = ((400 - i) * (400 - j)) % 400;
                }
            }
            double scale,offset;
            Array2D<byte> ba = BaseConvertor.ToByteArray(ia, out scale,out offset);


生成的二维数组转换成灰度图像如下



瞬间科技感了~~~

还可以这样

            Array2D<int> ia = new Array2D<int>(800, 800);
            Array2D<int> ib = new Array2D<int>(800, 800);
            Random rnd = new Random();
            for (int i = 0; i < 800; ++i)
            {
                for (int j = 0; j < 800; ++j)
                {
                    ia.Data[i, j] = ((400 - i) * (400 - j)) % 400;  //同上
                    ib.Data[i, j] =rnd.Next(-200,200); //随机噪声
                }
            }
            Array2D<int> ic = ia - ib; // 重载了基本运算符(+,-,*,/) 用起来很方便了

添加噪声后的数组ic，现将其转换为byte数组 
Array2D<byte> bc=BaseConvertor.ToByteArray(ic,scale,offset);
将bc转换为灰度图如下


更加科技感了~~~

这个模板会用到个人的项目中，更多内容不便公开，待项目完成之后再公布。

如果不使用模板，那么针对每一种数据类型都要分别编写代码，

大量的重复工作，效率很低，因此建议使用泛型(Generics)和委托(Delegates).


LOG@ 2014/08/15 11:36 Fri. BJ


点此领取楼主 (本文全原创,转载请注明出处 http://blog.youkuaiyun.com/fengyhack)


C# 委托和泛型委托示例
深南大道
11-23 304
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApp6 { class Program { public delegate void SaySomething(string name); //定义委托 public static event.
C# 泛型深度解析：从原理到高级应用
hy_4377的博客
04-03 473
泛型（Generics）是C# 2.0引入的核心特性，它允许开发者在定义类、接口、方法时使用类型参数（Type Parameters）。通过占位符T表示的通用类型，可在使用时指定具体类型，实现代码的通用性和类型安全。// 明确类型约束泛型技术是C#类型系统的核心支柱，通过：✅ 提升代码复用率✅ 增强类型安全性✅ 优化运行时性能✅ 支持复杂设计模式成为现代C#开发不可或缺的利器。掌握泛型的深度应用，将显著提升代码质量和开发效率。
C# 泛型委托示例 应用解析
02-09
这是一个泛型委托的示例，主要是让初学者了解泛型委托的用法，虽然很简单，但是代码有注释，我的这个例子是在vs2010中做的，用vs08的朋友们，最好还是转一下，但是绝对能实现（本程序是控制台应用程序，适合初学者），呵呵。
二维数组
Sunshine8430的博客
12-19 293
int main(void) { printf("输入矩阵的高和宽\n"); scanf_s("%d %d", &amp;nRow, &amp;nCol); int **p = malloc_Array2D(nRow, nCol); //输入二维数组 int i, j; for (i = 0; i &lt; nRow; i++) for (j = 0; j &lt; nCol; j++) { ...
C# 数组
江江的博客
06-13 4207
当需要存储多个相同类型的元素时，C# 数组是一种非常常用的数据结构。数组是一种固定长度的数据结构，它由连续的内存单元组成，每个内存单元存储一个元素。
C#泛型-模板特化
c1sdn19的专栏
10-16 661
C#泛型-模板特化 class TClass&lt;T, K&gt; { } class SubTClass&lt;T, C, K&gt; : TClass&lt;Char, K&gt; { } class SubTClass1&lt;K&gt; : TClass&lt;Char, K&gt; {...
34、C 泛型与委托：深入解析与应用
grafana6viz的博客
11-22 9
本文深入解析了C#中的泛型与委托机制，涵盖泛型的优势、Java与C#泛型的差异、委托的定义与实例化、匿名方法、系统内置泛型委托Func和Action的应用。通过冒泡排序、事件处理等实例，展示了如何利用泛型提升类型安全与代码复用，以及通过委托实现灵活的回调与方法传递。同时分析了性能影响并提供最佳实践建议，帮助开发者编写更高效、可维护的C#代码。
34、深入理解C泛型与委托：从基础到高级应用
最新发布
yhn456789的博客
11-22 8
本文深入探讨了C#中的泛型与委托机制，从基础概念到高级应用。详细对比了C#与Java泛型的实现差异，阐述了泛型在提升类型安全和代码复用方面的优势。文章系统讲解了委托的定义、实例化、匿名方法、系统内置委托Func和Action的使用，并展示了委托在事件处理、委托链及多线程异步调用中的实际应用场景，帮助开发者构建更灵活、可维护的C#程序。
C泛型与委托：提升编程效率与灵活性
### C# 泛型与委托：提升编程效率与灵活性 #### 1. 泛型概述 泛型从根本上改变了 C# 1.0 的编码风格。在 C# 1.0 代码中，程序员经常使用 `object` 类型，而在 C# 2.0 及后续版本中，泛型成为了更好的选择。特别是在...
C#数组(Array)
nazabanne的博客
08-22 3371
数组是一个存储相同类型元素的固定大小的顺序集合.数组是用来存储数据的集合,通常认为数组是一个同一类型变量的集合.声明数组变量并不是声明number0,number1,......,number99一个一个单独的变量,而是声明一个就像numbers这样的变量,然后使用number[0],number[1],...,number[99]来表示一个个单独的变量,数组中某个指定的元素是通过索引来访问的.
单例模板泛型
12-04
如果项目中有很多个单例，那么我们就必须每次都写这些代码，有什么办法可以省去这些不必要的代码呢? 那就是面向对象最重要的思想：继承。用这个单例模板类直接继承即可
C# 泛型
ฅ两脚喵ฅ的博客
01-29 3401
一.泛型所解决的问题及适用情形 假设我们声明了一个叫做MyIntStack的类，它实现了把一个int类型的值压入栈以及把它们弹出。 class MyIntStack { int StackPointer = 0; int[] StackArray; public void Push(int x) { //... } public int Pop() { //... } } 然后我们希望相同的功能应用于flo.
C#之泛型
互联网底层民工的博客
07-28 2823
一、概述一、概述泛型是用于处理算法、数据结构的一种编程方法。泛型的目标是采用广泛适用和可交互性的形式来表示算法和数据结构，以使它们能够直接用于软件构造。泛型类、结构、接口、委托和方法可以根据它们存储和操作的数据的类型来进行参数化。泛型能在编译时提供强大的类型检查，减少数据类型之间的显示转换、装箱操作和运行时的类型检查。泛型类和泛型方法同时具备可重用性、类型安全和效率高等特性，这是非泛型类和非泛型方法无法具备的。泛型通常用在集合和在集合上运行的方法中。泛型主要是提高了代码的重要性。
深入了解C#泛型
爱技术、爱生活、爱健康
06-28 910
现代程序员写代码没有人敢说自己没用过泛型，这个泛型模板T可以被任何你想要的类型替代，确实很魔法很神奇，很多人也习以为常了，但就是这么有趣的泛型T底层到底是怎么帮你实现的，不知道有多少人清楚底层玩法。现在的netcore 3.1和最新的.netframework8早已经没有当初那个被人诟病的ArrayList了，但很巧这玩意不得不说，因为它决定了C#团队痛改前非，抛弃过往重新上路，上一段ArrayList案例代码。 上面这段代码，为了保证在Add中可以塞入各种类型 eg: int,double,class
C#中Array类的使用
热门推荐
一蓑烟雨任平生 也无风雨也无晴
07-22 1万+
Array类 提供创建、操作、搜索和排序数组的方法，因而在公共语言运行时中用作所有数组的基类。 命名控件： System 程序集：mscorlib 语法：public abstract class Array:ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuraEquatab
PerlinNoise-C#柏林噪声的探讨与实现
kuangben2000的博客
10-11 2755
PerlinNoise-C#柏林噪声的探讨与实现 https://www.jianshu.com/p/987b1349c94d 2018.06.23 20:12:46字数 3059阅读 885 前言 1985年Ken Perlin指出，一个理想的噪声应该具有以下性质：维基百科 1.对旋转具有统计不变性； 2.能量在频谱上集中于一个窄带，即：图像是连续的，高频分量受限； 3。对变换具...
C#图像添加高斯噪声和椒盐噪声及图像恢复
世界很大我很小
11-30 7945
图像噪声是影响人们接受图像信息的因素，常见的噪声有高斯噪声和椒盐噪声。因为最近课程要求，做一个图像恢复的Project，所以掌握了给图像添加噪声以及去除噪声的方法。         给图像添加高斯噪声        高斯噪声是大量具有正太分布的随机变量性质的值加到原图像造成的，要给图像添加高斯噪声，其实问题就是怎么产生正太分布随机变量。首先用Randdom对象的NextDouble产生两个0
【WPF学习手记】C#产生0~1之间的随机数
Taosy
08-11 1万+
函数功能：产生 0~1 之间的随机数。 代码 private double random() { var seed = Guid.NewGuid().GetHashCode(); Random r = new Random(seed); int i = r.Next(0, 100000); return (double)i / 100000; } 补充说明...
C#泛型深度解析：数据类型判定与转换技巧
在C#编程语言中，泛型是一种强大的工具，它允许我们创建可重用的代码模板，这些模板可以在多种数据类型上工作，提供了类型安全性和效率。本篇将深入探讨在泛型中如何判断和转换数据类型。 首先，我们要理解C#中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值