C#泛型与linq

泛型

我们仔细观察类中的代码看那些类型需要修改，每次需要新类型（long,double,string）,我们都需要重复这个过程。在这些过程之后，我们有了很多几乎相同代码的类，占据了额外的空间。调试和维护这些代码不但复杂而且容易出错。

定义：泛型（generic）可以软糖多个类型共享一组代码,泛型允许我们声明类型参数化。可以用不同的类型进行实例化，说白了，就是可以用类型占位符，创建具体类型致命的真实概念。C#中提供了五种泛型，类，结构，接口，委托和方法。

class MyStack<T>
    {
        T[] statkArray;
        int stackPointer = 0;
        const int MaxStack = 10;
        bool IsStackFull { get { return stackPointer < MaxStack; } }
        bool IsStackEmpty { get { return stackPointer <= 0; } }

        public void Push(T x)
        {
            if (!IsStackFull)
            {
                statkArray[stackPointer++] = x;
            }

        }

        public T Pop()
        {
            return(!IsStackEmpty)?statkArray[--stackPointer]:statkArray[0];
        }

        //int[] arr={1,2,3,4};

        public void Print()
        {
            for (int i = stackPointer-1; i>=0 ; i--)
            {
                Console.WriteLine("value;{0}",statkArray[i]);
            }
        }
}

static void Main(string[] args)
        {
            MyStack<int> stackint = new MyStack<int>();
            MyStack<string> stackstring = new MyStack<string>();

            stackint.Push(3);
            stackint.Push(5);
            stackint.Push(7);
            stackint.Push(9);

            stackint.Print();
            stackstring.Push("Hava a good day");
            stackstring.Push("Hi there!");
            stackstring.Print();

            Console.ReadKey();

        }

泛型委托：

class simple
    {

        static public void PrintString(string s)
        {
            Console.WriteLine(s);
        }

        static public void PrintUpperString(string s)
        {
            Console.WriteLine("{0}",s.ToUpper());
        }
    }

delegate  void MyDelegate<T>(T value);
    class Program
    {
        static void Main(string[] args)
        {
            var mydel = new MyDelegate<string>(simple.PrintString);
            mydel += simple.PrintUpperString;

            mydel("rocky");
            Console.ReadKey();
        }
    }

泛型接口：

interface IMyfc<T>
    {
        T returnIt(T inValue);
    }

class Simple<S>:IMyfc<S>
    {

        public S returnIt(S inValue)
        {
            return inValue;
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            var trivInt = new Simple<int>();
            var trivString = new Simple<string>();
            Console.WriteLine(trivInt.returnIt(5));
            Console.WriteLine(trivString.returnIt("张三"));

            Console.ReadKey();
        }
    }

linq:

class Program
    {

        static void Main(string[] args)
        {

            int[] array = { 11, 12, 13, 14 };
            Func<int, int> func = new Func<int, int>(Method);

            var arr = array.Select(func);
            foreach (var item in arr)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();

        }

        static int Method(int x)
        {
            if (x == 12)
            {
                return x;
            }
            else
            {
                return 0;
            }
        }
    }