主頁 > .NET開發 > C#基礎篇——泛型

C#基礎篇——泛型

2020-09-13 19:43:17 .NET開發

前言

在開發編程中，我們經常會遇到功能非常相似的功能模塊，只是他們的處理的資料不一樣，所以我們會分別采用多個方法來處理不同的資料型別，但是這個時候，我們就會想一個問題，有沒有辦法實作利用同一個方法來傳遞不同種型別的引數呢？

這個時候，泛型也就因運而生，專門來解決這個問題的，

泛型是在C#2.0就推出的一個新語法，由框架升級提供的功能，

說明

泛型通過引數化型別實作在同一份代碼上操作多種資料型別，例如使用泛型的型別引數T,定義一個類Stack，

可以用Stack、Stack或者Stack實體化它，從而使類Stack可以處理int、string、Person型別資料，這樣可以避免運行時型別轉換或封箱操作的代價和風險，泛型提醒的是將具體的東西模糊化，

同時使用泛型型別可以最大限度地重用代碼、保護型別安全以及提高性能，

可以創建：泛型介面、泛型類、泛型方法、泛型事件和泛型委托

開始

泛型類

泛型類封裝不特定于特定資料型別的操作， 泛型類最常見用法是用于鏈接串列、哈希表、堆疊、佇列和樹等集合， 無論存盤資料的型別如何，添加項和從集合洗掉項等操作的執行方式基本相同，

    static void Main(string[] args)
    {

        // T是int型別
        GenericClass<int> genericInt = new GenericClass<int>();
        genericInt._T = 123;
        // T是string型別
        GenericClass<string> genericString = new GenericClass<string>();
        genericString._T = "123";

    }

新建一個GenericClass類

    /// <summary>
    /// 泛型類
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class GenericClass<T>
    {
        public T _T;
    }

泛型方法

泛型方法是通過型別引數宣告的方法, 解決用一個方法，滿足不同引數型別

    static void Main(string[] args)
    {
        #region 泛型方法
        Console.WriteLine("************Generic**************");
        int iValue = https://www.cnblogs.com/i3yuan/p/123;
        string sValue = "456";
        DateTime dtValue = DateTime.Now;
        object oValue = "MrValue";
        GenericMethod.Show(iValue);//需要指定型別引數
        //GenericMethod.Show(iValue);//必須吻合
        GenericMethod.Show(iValue);//能省略，自動推算
        GenericMethod.Show(sValue);
        GenericMethod.Show(dtValue);
        GenericMethod.Show(oValue);
        #endregion

    }


新建一個GenericMethod


/// <summary>
/// 泛型方法
/// </summary>
public class GenericMethod
{
    /// <summary>
    /// 2.0推出的新語法
    /// 泛型方法解決用一個方法，滿足不同引數型別；做相同的事兒
    /// 沒有寫死引數型別，呼叫的時候才指定的型別
    /// 延遲宣告：把引數型別的宣告推遲到呼叫
    /// 推遲一切可以推遲的~~  延遲思想
    /// 不是語法糖，而是2.0由框架升級提供的功能
    /// 需要編譯器支持+JIT支持
    /// </summary>
    /// <typeparam name="T">T/S 不要用關鍵字  也不要跟別的型別沖突 </typeparam>
    /// <param name="tParameter"></param>
    public static void Show<T>(T tParameter)
    {
        Console.WriteLine("This is {0},parameter={1},type={2}",
            typeof(GenericMethod), tParameter.GetType().Name, tParameter.ToString());
    }
}



泛型介面


為泛型集合類或表示集合中的項的泛型類定義介面通常很有用處，在c#中，通過尖括號“<>”將型別引數括起來，表示泛型，宣告泛型介面時，與宣告一般介面的唯一區別是增加了一個，一般來說，宣告泛型介面與宣告非泛型介面遵循相同的規則，


泛型介面定義完成之后，就要定義此介面的子類，定義泛型介面的子類有以下兩種方法，


(1)直接在子類后宣告泛型，


(2)在子類實作的介面中明確的給出泛型型別，


    static void Main(string[] args)
    {
        #region 泛型介面
        CommonInterface commonInterface = new CommonInterface();
        commonInterface.GetT("123");
        #endregion
    }



新建GenericInterface.cs類檔案


        /// <summary>
        /// 泛型類
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class GenericClass<T>
        {
            public T _T;
        }

        /// <summary>
        /// 泛型介面
        /// </summary>
        public interface IGenericInterface<T>
        {
            //泛型型別的回傳值
            T GetT(T t);
        }


        /// <summary>
        /// 使用泛型的時候必須指定具體型別，
        /// 這里的具體型別是int
        /// </summary>
        public class CommonClass : GenericClass<int>
        {

        }

        /// <summary>
        /// 必須指定具體型別
        /// </summary>
        public class CommonInterface : IGenericInterface<string>
        {
            public string GetT(string t)
            {
                return t;
            }
        }

        /// <summary>
        /// 子類也是泛型的，繼承的時候可以不指定具體型別
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class CommonClassChild<T> : GenericClass<T>
        {

        }




泛型委托


泛型委托主要是想講一下Action和Func兩個委托，因為這兩個在Linq中是經常見到的，


Action只能委托必須是無回傳值的方法


Fun只是委托必須有回傳值的方法


不管是不是泛型委托，只要是委托委托那能用Lamdba運算式，因為不管Lamdba運算式還是匿名函式其實都是將函式變數化，


下面簡單的來做的demo說下兩個的用法,這個會了基本linq會了一半了，


    static void Main(string[] args)
    {
        #region 泛型委托
        Action<string> action = s => {
            Console.WriteLine(s);
        };
        action("i3yuan");
        Func<int, int, int> func = (int a, int b) => {
            return a + b;
        };
        Console.WriteLine("sum:{0}", func(1,1));
        Console.ReadLine();
        #endregion
    }



上面其實都是將函式做為變數，這也是委托的思想，action是實體化了一個只有一個字串引數沒有回傳值得函式變數，func是實體化了一個有兩個int型別的引數回傳值為int的函式變數，


可以看到通過Lamdba運算式和泛型的結合，算是又方便了開發者們，更加方便實用，




引入委托常用的另一方式




無論是在類定義內還是類定義外，委托可以定義自己的型別引數，參考泛型委托的代碼可以指定型別引數來創建一個封閉構造型別，這和實體化泛型類或呼叫泛型方法一樣，如下例所示：


public delegate void MyDelegate<T>(T item);
public void Notify(int i){}
//...
 
MyDelegate<int> m = new MyDelegate<int>(Notify);
 
C#2.0版有個新特性稱為方法組轉換（method group conversion），具體代理和泛型代理型別都可以使用，用方法組轉換可以把上面一行寫做簡化語法：
MyDelegate<int> m = Notify;
 
在泛型類中定義的委托，可以與類的方法一樣地使用泛型類的型別引數，
class Stack<T>
{
T[] items;
      int index
//...
public delegate void StackDelegate(T[] items);
}
 
參考委托的代碼必須要指定所在類的型別引數，如下：
 
Stack<float> s = new Stack<float>();
Stack<float>.StackDelegate myDelegate = StackNotify;
 
 
泛型委托在定義基于典型設計模式的事件時特別有用，因為sender[JX2] ，而再也不用與Object相互轉換，
public void StackEventHandler<T,U>(T sender, U eventArgs);
class Stack<T>
{
    //…
    public class StackEventArgs : EventArgs{...}
    public event StackEventHandler<Stack<T>, StackEventArgs> stackEvent;
    protected virtual void OnStackChanged(StackEventArgs a)
    {
      stackEvent(this, a);
    }
}
class MyClass
{
  public static void HandleStackChange<T>(Stack<T> stack, StackEventArgs args){...};
}
Stack<double> s = new Stack<double>();
MyClass mc = new MyClass();
s.StackEventHandler += mc.HandleStackChange;





泛型約束


所謂的泛型約束，實際上就是約束的型別T，使T必須遵循一定的規則，比如T必須繼承自某個類，或者T必須實作某個介面等等，那么怎么給泛型指定約束？其實也很簡單，只需要where關鍵字，加上約束的條件，


定義一個People類，里面有屬性和方法：


    public interface ISports
    {
        void Pingpang();
    }
    public interface IWork
    {
        void Work();
    }
    public class People
    {
        public int Id { get; set; }
        public string Name { get; set; }
    
        public void Hi()
        {
            Console.WriteLine("Hi");
        }
    
    }
    public class Chinese : People, ISports, IWork
    {
        public void Tradition()
        {
            Console.WriteLine("仁義禮智信，溫良恭儉讓");
        }
        public void SayHi()
        {
            Console.WriteLine("吃了么？");
        }
    
        public void Pingpang()
        {
            Console.WriteLine("打乒乓球...");
        }
    
        public void Work()
        {
            throw new NotImplementedException();
        }
    } 
    public class Hubei : Chinese
    {
        public Hubei(int version)
        { }
    
        public string Changjiang { get; set; }
        public void Majiang()
        {
            Console.WriteLine("打麻將啦，，");
        }
    }
    public class Japanese : ISports
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public void Hi()
        {
            Console.WriteLine("Hi");
        }
        public void Pingpang()
        {
            Console.WriteLine("打乒乓球...");
        }
    }




列印方法


    /// <summary>
    /// 列印個object值
    /// 1 object型別是一切型別的父類
    /// 2 通過繼承，子類擁有父類的一切屬性和行為；任何父類出現的地方，都可以用子類來代替
    /// object參考型別  加入傳個值型別int  會有裝箱拆箱  性能損失
    /// 型別不安全
    /// </summary>
    /// <param name="oParameter"></param>
    public static void ShowObject(object oParameter)
    {
        Console.WriteLine("This is {0},parameter={1},type={2}",
            typeof(Constraint), oParameter.GetType().Name, oParameter);

        Console.WriteLine($"{((People)oParameter).Id}_{((People)oParameter).Name}");

    }



在main方法中


    static void Main(string[] args)
    {
        #region  Constraint 介面約束
        Console.WriteLine("************Constraint*****************");
        {
            People people = new People()
            {
                Id = 123,
                Name = "走自己的路"
            };
            Chinese chinese = new Chinese()
            {
                Id = 234,
                Name = "晴天"
            };
            Hubei hubei = new Hubei(123)
            {
                Id = 345,
                Name = "流年"
            };
            Japanese japanese = new Japanese()
            {
                Id = 7654,
                Name = "i3yuan"//
            };
            CommonMethod.ShowObject(people);
            CommonMethod.ShowObject(chinese);
            CommonMethod.ShowObject(hubei);
            CommonMethod.ShowObject(japanese);
  
            Console.ReadLine();
        }
        #endregion
    }



泛型約束總共有五種，






約束
說明






T：結構
型別引數必須是值型別




T：類
型別引數必須是參考型別；這一點也適用于任何類、介面、委托或陣列型別，




T：new()
型別引數必須具有無引數的公共建構式， 當與其他約束一起使用時，new() 約束必須最后指定，




T：<基類名>
型別引數必須是指定的基類或派生自指定的基類，




T：<介面名稱>
型別引數必須是指定的介面或實作指定的介面， 可以指定多個介面約束， 約束介面也可以是泛型的，






1、基類約束


上面列印的方法約束T型別必須是People型別，


/// 


/// 基類約束：約束T必須是People型別或者是People的子類

/// 1 可以使用基類的一切屬性方法---權利

/// 2  強制保證T一定是People或者People的子類---義務


        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter) where T : People
        {
            Console.WriteLine($"{tParameter.Id}_{tParameter.Name}");
            tParameter.Hi();
        }



注意：


基類約束時，基類不能是密封類，即不能是sealed類，sealed類表示該類不能被繼承，在這里用作約束就無任何意義，因為sealed類沒有子類，


2、介面約束


        /// <summary>
        /// 介面約束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T Get<T>(T t) where T : ISports
        {
            t.Pingpang();
            return t;
        }



3、參考型別約束 class


參考型別約束保證T一定是參考型別的，


        /// 參考型別約束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T Get<T>(T t) where T : class
        {
            return t;
        }



4、值型別約束 struct


值型別約束保證T一定是值型別的，


        /// 值型別型別約束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T Get<T>(T t) where T : struct
        {
            return t;
        }



5、無引數建構式約束 new()


        /// new()約束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T Get<T>(T t) where T : new()
        {
            return t;
        }



泛型約束也可以同時約束多個，例如：


        /// <summary>
        ///  泛型：不同的引數型別都能進來；任何型別都能過來，你知道我是誰?
        /// 沒有約束，也就沒有自由
        ///  泛型約束--基類約束（不能是sealed）：
        /// 1 可以使用基類的一切屬性方法---權利
        /// 2  強制保證T一定是People或者People的子類---義務
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)
        where T : People, ISports, IWork, new()
        {
            Console.WriteLine($"{tParameter.Id}_{tParameter.Name}");
            tParameter.Hi();
            tParameter.Pingpang();
            tParameter.Work();
        }



注意：有多個泛型約束時，new()約束一定是在最后，


泛型的協變和逆變


    public class Animal
    {
        public int Id { get; set; }
    }

    public class Cat : Animal
    {
        public string Name { get; set; }
    }
    




 static void Main(string[] args)
 {
    #region 協變和逆變

    // 直接宣告Animal類
    Animal animal = new Animal();
    // 直接宣告Cat類
    Cat cat = new Cat();
    // 宣告子類物件指向父類
    Animal animal2 = new Cat();
    // 宣告Animal類的集合
    List<Animal> listAnimal = new List<Animal>();
    // 宣告Cat類的集合
    List<Cat> listCat = new List<Cat>();

    #endregion
 }



那么問題來了：下面的一句代碼是不是正確的呢？


1 List<Animal> list = new List<Cat>();



可能有人會認為是正確的：因為一只Cat屬于Animal，那么一群Cat也應該屬于Animal啊，但是實際上這樣宣告是錯誤的：因為List和List之間沒有父子關系，


image-2020053023015097


這時就可以用到協變和逆變了，


1 // 協變
2 IEnumerable<Animal> List1 = new List<Animal>();
3 IEnumerable<Animal> List2 = new List<Cat>();



F12查看定義：




可以看到，在泛型介面的T前面有一個out關鍵字修飾，而且T只能是回傳值型別，不能作為引數型別，這就是協變，使用了協變以后，左邊宣告的是基類，右邊可以宣告基類或者基類的子類，


協變除了可以用在介面上面，也可以用在委托上面：


 Func<Animal> func = new Func<Cat>(() => null);



除了使用.NET框架定義好的以為，我們還可以自定義協變，例如：


    /// <summary>
    /// out 協變 只能是回傳結果
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface ICustomerListOut<out T>
    {
        T Get();
    }

    public class CustomerListOut<T> : ICustomerListOut<T>
    {
        public T Get()
        {
            return default(T);
        }
    }



使用自定義的協變：


 // 使用自定義協變
 ICustomerListOut<Animal> customerList1 = new CustomerListOut<Animal>();
 ICustomerListOut<Animal> customerList2 = new CustomerListOut<Cat>();



在來看看逆變，


在泛型介面的T前面有一個In關鍵字修飾，而且T只能方法引數，不能作為回傳值型別，這就是逆變，請看下面的自定義逆變：


    /// <summary>
    /// 逆變 只能是方法引數
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface ICustomerListIn<in T>
    {
        void Show(T t);
    }

    public class CustomerListIn<T> : ICustomerListIn<T>
    {
        public void Show(T t)
        {
        }
    }



使用自定義逆變：


 // 使用自定義逆變
 ICustomerListIn<Cat> customerListCat1 = new CustomerListIn<Cat>();
 ICustomerListIn<Cat> customerListCat2 = new CustomerListIn<Animal>();



協變和逆變也可以同時使用，看看下面的例子：


    /// <summary>
    /// inT 逆變
    /// outT 協變
    /// </summary>
    /// <typeparam name="inT"></typeparam>
    /// <typeparam name="outT"></typeparam>
    public interface IMyList<in inT, out outT>
    {
        void Show(inT t);
        outT Get();
        outT Do(inT t);
    }

    public class MyList<T1, T2> : IMyList<T1, T2>
    {

        public void Show(T1 t)
        {
            Console.WriteLine(t.GetType().Name);
        }

        public T2 Get()
        {
            Console.WriteLine(typeof(T2).Name);
            return default(T2);
        }

        public T2 Do(T1 t)
        {
            Console.WriteLine(t.GetType().Name);
            Console.WriteLine(typeof(T2).Name);
            return default(T2);
        }
    }



使用：


 IMyList<Cat, Animal> myList1 = new MyList<Cat, Animal>();
 IMyList<Cat, Animal> myList2 = new MyList<Cat, Cat>();//協變
 IMyList<Cat, Animal> myList3 = new MyList<Animal, Animal>();//逆變
 IMyList<Cat, Animal> myList4 = new MyList<Animal, Cat>();//逆變+協變



有關可變性的注意事項


    

  • 變化只適用于參考型別，因為不能直接從值型別派生其他型別
    • 

  • 顯示變化使用in和out關鍵字只適用于委托和介面，不適用于類、結構和方法
    • 

  • 不包括in和out關鍵字的委托和介面型別引數叫做不變
    • 



泛型快取


在前面我們學習過，類中的靜態型別無論實體化多少次，在記憶體中只會有一個，靜態建構式只會執行一次，在泛型類中，T型別不同，每個不同的T型別，都會產生一個不同的副本，所以會產生不同的靜態屬性、不同的靜態建構式，請看下面的例子：


public class GenericCache<T>
{
    static GenericCache()
    {
        Console.WriteLine("This is GenericCache 靜態建構式");
        _TypeTime = string.Format("{0}_{1}", typeof(T).FullName, DateTime.Now.ToString("yyyyMMddHHmmss.fff"));
    }

    private static string _TypeTime = "";

    public static string GetCache()
    {
        return _TypeTime;
    }
}
public class GenericCacheTest
{
    public static void Show()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine(GenericCache<int>.GetCache());
            Thread.Sleep(10);
            Console.WriteLine(GenericCache<long>.GetCache());
            Thread.Sleep(10);
            Console.WriteLine(GenericCache<DateTime>.GetCache());
            Thread.Sleep(10);
            Console.WriteLine(GenericCache<string>.GetCache());
            Thread.Sleep(10);
            Console.WriteLine(GenericCache<GenericCacheTest>.GetCache());
            Thread.Sleep(10);
        }
    }
}



Main()方法里面呼叫：


 static void Main(string[] args)
 {
    #region 泛型快取
	GenericCacheTest.Show();
    #endregion
 }



結果：


20200530232600809


從上面的截圖中可以看出，泛型會為不同的型別都創建一個副本，所以靜態建構式會執行5次， 而且每次靜態屬性的值都是一樣的，利用泛型的這一特性，可以實作快取，


注意：只能為不同的型別快取一次，泛型快取比字典快取效率高，泛型快取不能主動釋放，


注意


1.泛型代碼中的 default 關鍵字


在泛型類和泛型方法中會出現的一個問題是，如何把預設值賦給引數化型別，此時無法預先知道以下兩點：


    

  • 

    T將是值型別還是參考型別
    

    • 

  • 

    如果T是值型別，那么T將是數值還是結構
    

    • 



對于一個引數化型別T的變數t，僅當T是參考型別時，t = null陳述句才是合法的； t = 0只對數值的有效，而對結構則不行，這個問題的解決辦法是用default關鍵字，它對參考型別回傳空，對值型別的數值型回傳零，而對于結構，它將回傳結構每個成員，并根據成員是值型別還是參考型別，回傳零或空，下面GenericList類的例子顯示了如何使用default關鍵字，


    static void Main(string[] args)
    {
        #region 泛型代碼默認關鍵字default
        // 使用非空的整數串列進行測驗.
        GenericList<int> gll = new GenericList<int>();
        gll.AddNode(5);
        gll.AddNode(4);
        gll.AddNode(3);
        int intVal = gll.GetLast();
        // 下面一行顯示5.
        Console.WriteLine(intVal);

        // 用一個空的整數串列進行測驗.
        GenericList<int> gll2 = new GenericList<int>();
        intVal = gll2.GetLast();
        // 下面一行顯示0.
        Console.WriteLine(intVal);

        // 使用非空字串串列進行測驗.
        GenericList<string> gll3 = new GenericList<string>();
        gll3.AddNode("five");
        gll3.AddNode("four");
        string sVal = gll3.GetLast();
        // 下面一行顯示five.
        Console.WriteLine(sVal);

        // 使用一個空字串串列進行測驗.
        GenericList<string> gll4 = new GenericList<string>();
        sVal = gll4.GetLast();
        // 下面一行顯示一條空白行.
        Console.WriteLine(sVal);
        #endregion
        Console.ReadKey();
    }



    public class GenericList<T>
    {
        private class Node
        {
            // 每個節點都有一個指向串列中的下一個節點的參考.
            public Node Next;
            // 每個節點都有一個T型別的值.
            public T Data;
        }

        // 這個串列最初是空的.
        private Node head = null;

        // 在串列開始的時候添加一個節點，用t作為它的資料值.
        public void AddNode(T t)
        {
            Node newNode = new Node();
            newNode.Next = head;
            newNode.Data = https://www.cnblogs.com/i3yuan/p/t;
            head = newNode;
        }

        // 下面的方法回傳存盤在最后一個節點中的資料值串列. 如果串列是空的, 回傳型別T的默認值.
        public T GetLast()
        {
            // 臨時變數的值作為方法的值回傳. 
            // 下面的宣告初始化了臨時的溫度 
            // 型別T的默認值. 如果該串列為慷訓傳默認值.
            T temp = default(T);

            Node current = head;
            while (current != null)
            {
                temp = current.Data;
                current = current.Next;
            }
            return temp;
        }
    }



2.泛型集合


通常情況下，建議您使用泛型集合，因為這樣可以獲得型別安全的直接優點而不需要從基集合型別派生并實作型別特定的成員，下面的泛型型別對應于現有的集合型別：


1、List 是對應于 ArrayList 的泛型類，

2、Dictionary 是對應于 Hashtable 的泛型類，

3、Collection 是對應于 CollectionBase 的泛型類，

4、ReadOnlyCollection 是對應于 ReadOnlyCollectionBase 的泛型類，

5、Queue、Stack 和 SortedList 泛型類分別對應于與其同名的非泛型類，

6、LinkedList 是一個通用鏈接串列，它提供運算復雜度為 O(1) 的插入和移除操作，

7、SortedDictionary 是一個排序的字典，其插入和檢索操作的運算復雜度為 O(log n)，這使得它成為 SortedList 的十分有用的替代型別，

8、KeyedCollection 是介于串列和字典之間的混合型別，它提供了一種存盤包含自己鍵的物件的方法，


總結


    

  1. 作為一個開發人員，當我們程式代碼有相同的邏輯，有可能是方法、介面、類或者委托，只是某些引數型別不同，我們希望代碼可以通用、復用，甚至是說為了偷懶，也可以說是在不確定型別的情況下，就應該考慮用泛型的思維去實作，
    2. 

  2. 在非泛型編程中，雖然所有的東西都可以作為Object傳遞，但是在傳遞的程序中免不了要進行型別轉換，而型別轉換在運行時是不安全的，使用泛型編程將可以減少不必要的型別轉換，從而提高安全性，不僅是值型別，參考型別也存在這樣的問題，因此有必要的盡量的去使用泛型集合，
    3. 

  3. 在非泛型編程中，將簡單型別作為Object傳遞時會引起裝箱和拆箱的操作，這兩個程序都是具有很大開銷的，使用泛型編程就不必進行裝箱和拆箱操作了，
    4. 



參考 檔案    《C#圖解教程》


注：搜索關注公眾號【DotNet技術谷】--回復【C#圖解】，可獲取 C#圖解教程檔案








      
  

      轉載請註明出處，本文鏈接：https://www.uj5u.com/net/26979.html
      
標籤：C# 

      
上一篇：自定義值型別一定不要忘了重寫Equals，否則性能和空間雙雙堪憂
下一篇：Asp.Net Mvc基于Fleck開發的多人網頁版即時聊天室

     


  

    

      

        

      

    

    

      
標籤雲

      

        
    其他(157675)        Python(38076)        JavaScript(25376)        Java(17977)        C(15215)        區塊鏈(8255)        C＃(7972)        AI(7469)        爪哇(7425)        MySQL(7132)        html(6777)        基礎類(6313)        sql(6102)        熊猫(6058)        PHP(5869)        数组(5741)        R(5409)        Linux(5327)        反应(5209)        腳本語言(PerlPython)(5129)        非技術區(4971)        Android(4554)        数据框(4311)        css(4259)        节点.js(4032)        C語言(3288)        json(3245)        列表(3129)        扑(3119)        C++語言(3117)        安卓(2998)        打字稿(2995)        VBA(2789)        Java相關(2746)        疑難問題(2699)        细绳(2522)        單片機工控(2479)        iOS(2429)        ASP.NET(2402)        MongoDB(2323)        麻木的(2285)        正则表达式(2254)        字典(2211)        循环(2198)        迅速(2185)        擅长(2169)        镖(2155)        功能(1967)        .NET技术(1958)        Web開發(1951)        python-3.x(1918)        HtmlCss(1915)        弹簧靴(1913)        C++(1909)        xml(1889)        PostgreSQL(1872)        .NETCore(1853)        谷歌表格(1846)        Unity3D(1843)        for循环(1842)        

      

    

    

      
      

        









      

    

    

      
熱門瀏覽

      

        
    

  • 
        
     WebAPI簡介
          
    Web體系結構： 有三個核心：資源(resource)，URL(統一資源識別符號)和表示 他們的關系是這樣的：一個資源由一個URL進行標識，HTTP客戶端使用URL定位資源，表示是從資源回傳資料，媒體型別是資源回傳的資料格式。 接下來我們說下HTTP. HTTP協議的系統是一種無狀態的方式，使用請求/ ......
    
           uj5u.com 2020-09-09 22:07:47 more
    
      
  • 
        
     asp.net core 3.1 入口：Program.cs中的Main函式
          
    本文分析Program.cs 中Main()函式中代碼的運行順序分析asp.net core程式的啟動，重點不是剖析原始碼，而是理清程式開始時執行的順序。到呼叫了哪些實體，哪些法方。asp.net core 3.1 的程式入口在專案Program.cs檔案里，如下。ususing System; us ......
    
           uj5u.com 2020-09-09 22:07:49 more
    
      
  • 
        
     asp.net網站作為websocket服務端的應用該如何寫
          
    最近被websocket的一個問題困擾了很久，有一個需求是在web網站中搭建websocket服務。客戶端通過網頁與服務器建立連接，然后服務器根據ip給客戶端網頁發送資訊。 其實，這個需求并不難，只是剛開始對websocket的內容不太了解。上網搜索了一下，有通過asp.net core 實作的、有 ......
    
           uj5u.com 2020-09-09 22:08:02 more
    
      
  • 
        
     ASP.NET 開源匯入匯出庫Magicodes.IE Docker中使用
          
    Magicodes.IE在Docker中使用 更新歷史 2019.02.13 【Nuget】版本更新到2.0.2 【匯入】修復單列匯入的Bug，單元測驗“OneColumnImporter_Test”。問題見（https://github.com/dotnetcore/Magicodes.IE/is ......
    
           uj5u.com 2020-09-09 22:08:05 more
    
      
  • 
        
     在webform中使用ajax
          
    如果你用過Asp.net webform， 說明你也算是.NET 開發的老兵了。WEBform應該是2011 2013左右，當時還用visual studio 2005、 visual studio 2008。后來基本都用的是MVC。 如果是新開發的專案，估計沒人會用webform技術。但是有些舊版 ......
    
           uj5u.com 2020-09-09 22:08:50 more
    
      
  • 
        
     iis添加asp.net網站，訪問提示：由于擴展配置問題而無法提供您請求的
          
    今天在iis服務器配置asp.net網站，遇到一個問題，記錄一下： 問題：由于擴展配置問題而無法提供您請求的頁面。如果該頁面是腳本，請添加處理程式。如果應下載檔案，請添加 MIME 映射。 WindowServer2012服務器，添加角色安裝完.netframework和iis之后，運行aspx頁面 ......
    
           uj5u.com 2020-09-09 22:10:00 more
    
      
  • 
        
     WebAPI-處理架構
          
    帶著問題去思考，大家好！ 問題1：HTTP請求和回傳相應的HTTP回應資訊之間發生了什么？ 1：首先是最底層，托管層，位于WebAPI和底層HTTP堆疊之間 2：其次是 訊息處理程式管道層，這里比如日志和快取。OWIN的參考是將訊息處理程式管道的一些功能下移到堆疊下端的OWIN中間件了。 3：控制器處理 ......
    
           uj5u.com 2020-09-09 22:11:13 more
    
      
  • 
        
     微信門戶開發框架-使用指導說明書
          
    微信門戶應用管理系統，采用基于 MVC + Bootstrap + Ajax + Enterprise Library的技術路線，界面層采用Boostrap + Metronic組合的前端框架，資料訪問層支持Oracle、SQLServer、MySQL、PostgreSQL等資料庫。框架以MVC5，... ......
    
           uj5u.com 2020-09-09 22:15:18 more
    
      
  • 
        
     WebAPI-HTTP編程模型
          
    帶著問題去思考，大家好！它是什么？它包含什么？它能干什么？ 訊息 HTTP編程模型的核心就是訊息抽象，表示為：HttPRequestMessage,HttpResponseMessage.用于客戶端和服務端之間交換請求和回應訊息。 HttpMethod類包含了一組靜態屬性： private stat ......
    
           uj5u.com 2020-09-09 22:15:23 more
    
      
  • 
        
     部署WebApi隨筆
          
    一、跨域 NuGet參考Microsoft.AspNet.WebApi.Cors WebApiConfig.cs中配置： // Web API 配置和服務 config.EnableCors(new EnableCorsAttribute("*", "*", "*")); 二、清除默認回傳XML格式 ......
    
           uj5u.com 2020-09-09 22:15:48 more
    
      
    •         

      

    

    

      
      

        

      

    



      
最新发布

      

        
    

  • 
        
     C#多執行緒學習(二) 如何操縱一個執行緒
          
    <a href="https://www.cnblogs.com/x-zhi/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/2943582/20220801082530.png" alt="" /></...
    
           uj5u.com 2023-04-19 09:17:20 more
    
      
  • 
        
     C#多執行緒學習(二) 如何操縱一個執行緒
          
    C#多執行緒學習(二) 如何操縱一個執行緒 執行緒學習第一篇：C#多執行緒學習(一) 多執行緒的相關概念 下面我們就動手來創建一個執行緒，使用Thread類創建執行緒時，只需提供執行緒入口即可。（執行緒入口使程式知道該讓這個執行緒干什么事） 在C#中，執行緒入口是通過ThreadStart代理（delegate）來提供的 ......
    
           uj5u.com 2023-04-19 09:16:49 more
    
      
  • 
        
     記一次 .NET某醫療器械清洗系統 卡死分析
          
    <a href="https://www.cnblogs.com/huangxincheng/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/214741/20200614104537.png" alt="" /&g...
    
           uj5u.com 2023-04-18 08:39:04 more
    
      
  • 
        
     記一次 .NET某醫療器械清洗系統 卡死分析
          
    一：背景 1. 講故事 前段時間協助訓練營里的一位朋友分析了一個程式卡死的問題，回過頭來看這個案例比較經典，這篇稍微整理一下供后來者少踩坑吧。 二：WinDbg 分析 1. 為什么會卡死 因為是表單程式，理所當然就是看主執行緒此時正在做什么? 可以用 ~0s ; k 看一下便知。 0:000> k # ......
    
           uj5u.com 2023-04-18 08:33:10 more
    
      
  • 
        
     SignalR, No Connection with that ID，IIS
          
    <a href="https://www.cnblogs.com/smartstar/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/u36196.jpg" alt="" /></a>...
    
           uj5u.com 2023-03-30 17:21:52 more
    
      
  • 
        
     一次對pool的誤用導致的.net頻繁gc的診斷分析
          
    <a href="https://www.cnblogs.com/dotnet-diagnostic/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/3115652/20230225090434.png" alt=""...
    
           uj5u.com 2023-03-28 10:15:33 more
    
      
  • 
        
     一次對pool的誤用導致的.net頻繁gc的診斷分析
          
    <a href="https://www.cnblogs.com/dotnet-diagnostic/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/3115652/20230225090434.png" alt=""...
    
           uj5u.com 2023-03-28 10:13:31 more
    
      
  • 
        
     C#遍歷指定檔案夾中所有檔案的3種方法
          
    <a href="https://www.cnblogs.com/xbhp/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/957602/20230310105611.png" alt="" /></a&...
    
           uj5u.com 2023-03-27 14:46:55 more
    
      
  • 
        
     C#/VB.NET：如何將PDF轉為PDF/A
          
    <a href="https://www.cnblogs.com/Carina-baby/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/2859233/20220427162558.png" alt="" />...
    
           uj5u.com 2023-03-27 14:46:35 more
    
      
  • 
        
     武裝你的WEBAPI-OData聚合查詢
          
    <a href="https://www.cnblogs.com/podolski/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/616093/20140323000327.png" alt="" /><...
    
           uj5u.com 2023-03-27 14:46:16 more
    
      
    •         

      

    

    
    

      
      

        

      

    

  


  

    

      
Copyright © 2010-2020 有解無憂