C#基础-7

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata.Ecma335;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;


namespace Wrox5
{
     //接口
     //声明接口在语法上与声明抽象类完全相同，但不允许提供接口中任何成员的实现方式
     //一般情况下，接口只能包含方法/属性/索引器/事件的声明
     //抽象类可以有实现代码或没有实现代码的成员，接口则不能有任何实现代码，纯粹的抽象
     //永远不能实例化，只能包含其成员的签名，也可以声明接口类型的变量
     //既不能有构造函数也不能有字段，也不允许包含运算符重载
     //在接口定义中还不允许声明成员的修饰符，为隐式public
     class SomeClass : IDisposable
    {
        //
        public void Dispose()
        {
            //
        }
    }


    public interface IBankAccount
    {
        void PayIn(decimal amount);
        bool Withdraw(decimal amount);
        decimal Balance { get; }
    }
    public class  SaverAccount : IBankAccount 
    {
        private decimal _balance;
        public void PayIn(decimal amount) => _balance += amount;
        public bool Withdraw(decimal amount)
        {
            if(_balance >= amount) {_balance -= amount; return true; }
            Console.WriteLine("Widthdrawl attempt failed");
            return false;
        }
        public decimal Balance { get => _balance;}
        public override string ToString()
        {
            return base.ToString();
        }

    }//接口引用完全可以看作类引用，接口引用可以引用任何实现该接口的类
    class Program
    {
        static void Main1()
        {
            IBankAccount[] accounts = new IBankAccount[2];
            accounts[0] = new SaverAccount();
            accounts[1] = new SaverAccount();
        }
    }


    //接口可以继承，方式与类相同
    public interface ITransferBankAccount : IBankAccount
    {
        bool TransferTo(IBankAccount destionation, decimal amount);
    }//在实现并调用方法时，只需要知道该对象实现了IBankAccount即可


    //is  as
    //如果一个方法接受一个对象类型，想要访问接口成员，怎么办？
    //可以进行类型转换，把对象转换成接口，任何接口中任意类型的参数，把他转换成需要的类型
    class Program1
    {
        public void WorkWithManyDifferentObjects(object o)
        {
            //IBankAccount account = (IBankAccount)o;
            IBankAccount account = o as IBankAccount;
            if(account != null)
            {
                //
            }
        }
        //除了as外，还可以使用is，根据条件是否满足，对象是否使用指定的类型返回true或false，如果为true则将所得的对象写入声明为匹配类型的变量中
        public void WorkWithManyDifferentObject(object o)
        {
            if(o is IBankAccount account)
            {
                /
            }
        }

    }




    //泛型
    //可以创建独立于被包含类型的类和方法
    //泛型类使用泛型类型，并可以根据需要特定的类型替换泛型类型，保证类型的安全性
    //泛型可以提高性能，对值类型使用非泛型集合类，在把值类型转换为引用类型，和把引用类型转换为值类型时需要装箱拆箱操作
    //值类型出存储在栈上，引用类型存储在堆上，从值类型转换为引用类型为装箱
    //装箱的值类型可以使用拆箱操作转换为值类型，在拆箱时需要使用类型强制转换运算符
    class Program3
    {
        static void Main2 ()
        {
            var list = new ArrayList();
            list.Add(44);
            int il = (int)list[0];
            foreach(int i2 in list)
            {
            
               Console.WriteLine(i2);
            }
            //装箱拆箱会使性能损失很大 使用List<T>
            //List<T>类不使用对象，而是在使用时定义类型

            var list2 = new List<int>();
            list2.Add(1);
            int il2 = list2[0];
            foreach (int i2 in list2)
            {
                Console.WriteLine(i2);
            }

        }
     }
    class myCLass
    {

    }
      //类型安全
      //如果使用对象，像ArrayList类一样，可以在集合中添加任意类型
  
    class Program4
      {
        
        static void Main()
        {

            var list = new ArrayList();
            list.Add(44);
            list.Add("mystring");
           // list.Add(new MyClass());
           foreach(int i  in list)
            {
                Console.WriteLine(i);
            }
            //在泛型类中定义了允许使用的类型List<T>
            //List<int> 就能把整数类型添加到集合中


          

            //泛型允许重用二进制代码，可以定义一次，并且可以用许多不同的类型实例化
            var list2 = new List<int>();
            list.Add(4);
            var stringList = new List<string>();
            stringList.Add("a");
            var myClassList = new List<Myclass>();
           // myClassList.Add(new myClass());

        }
      }


    //引用类型在实例化的泛型类中只需要4个字节的内存地址，同时每个值类型对内存得到要求不同，所以要为每个值类型实例化一个新类
    //命名约定：泛型类型名称用字母T作为前缀，泛型类型允许用任意类替代，且只使用一个泛型类型就可以用字符T作为名称
    public class List<T>
    {
        internal void Add(int v)
        {
            throw new NotImplementedException();
        }

        internal void Add(string v)
        {
            throw new NotImplementedException();
        }
    }
    public class LinkedList<T> { }


    //创建泛型
  /* public class LinkedListNode
    {
        //创建一个非泛型的简化连接表
        public LinkedListNode(object valye) => Value = value;
        public object Value { get; set; }
        public LinkedListNode Next { get; internal set; }
        public LinkedListNode Prev { get; internal set; }
    }
     public class LinkedList : IEnumerable
     {
         public LinkedListNode First { get; private set; }
         public LinkedListNode Last { get; private set; }
         public LinkedListNode AddLast(object valye)
         {
             var newNode = new LinkedListNode(node);
             if (First == null)
             {
                 First = newNode;
                 Last = First;
             }
             else
             {
                 LinkedListNode previous = Last;
                 Last.Next = newNode;
                 Last = newNode;
                 Last.Prev = previous;
             }
             return newNode;
         }
         public IEnumerator GetEnumerator()
         {
             LinkedListNode current = First;
             while (current != null)
             {
                 yield return current;//yield语句创建一个枚举器的状态机
                 current = current.Next;
             }
         }*/



    //创建链表的泛型版本
    public class LinkedListNode<T>
        {
            public LinkedListNode<T value> =>Value = value;
            public T Value { get; set; }
            public LinkedListNode<T> Next { get; internal set; }
            public LinkedListNode<T> Prev { get; internal set; }


        }
        public class LinkedList1<T> :IEnumerable<T>
        {
            public LinkedListNode<T> First { get; private set; }
            public LinkedListNode<T> Last { get; private set; } 
            public LinkedListNode<T> AddLast(T node) 
            {
                var newNode = new LinkedListNode<T>(node);
                if(First == null)
                {
                    First = newNode;    
                    Last = First;
                }
                else
                {
                    LinkedListNode<T> previous = Last;
                    Last.Next = newNode;
                    Last = newNode;
                    Last.Prev = previous;
                }
                return newNode;
            }
            public IEnumerator<T> GetEnumerator()
            {
                LinkedListNode<T> current = First;
                while(current != null)
                {
                    current = current.Next;
                }
            }
            IEnumerator IEnumerable.GetEnumerator() =>GetEnumerator();
        }   

    }
}