C#の基礎知識集基礎知識(17) ILiestインターフェース - ジェネリックス-C#.Net チュートリアル-php.cn

ホームページ

バックエンド開発

C#.Net チュートリアル

C#の基礎知識集基礎知識(17) ILiestインターフェース - ジェネリックス

黄舟

Feb 11, 2017 pm 01:48 PM

ArrayList に値の型を挿入するとボックス化操作がトリガーされ、次のように値の型を削除するにはボックス化を解除する必要があります

            ArrayList myArrayList = new ArrayList();

            myArrayList.Add(40);//装箱

            myArrayList.Add(80);//装箱
            
            Int32 a1 = (Int32)myArrayList[0];//拆箱

            Int32 a2 = (Int32)myArrayList[1];//拆箱

これによりパフォーマンスの消費が発生します。梱包の詳しい説明は次の記事をご覧ください。
これらの問題を解決するために、C# にはジェネリックをサポートする IList インターフェイスがあります。実際には、構造は IList と同じですが、ジェネリックが追加されています。

 /// <summary>
    /// 泛型集合类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class List<T> : IList<T>, IList
    {
        /// <summary>
        /// 泛型迭代器
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public struct Enumertor<T> : IEnumerator, IEnumerator<T>
        {
            //迭代索引
            private int index;

            //迭代器所属的集合对象引用
            private List<T> list;

            public Enumertor(List<T> container)
            {
                this.list = container;

                this.index = -1;
            }

            public void Dispose()
            {
            }

           /// <summary>
           /// 显示实现IEnumerator的Current属性
           /// </summary>
            object IEnumerator.Current
            {
                get
                {
                    return list[index];
                }
            }

            /// <summary>
            /// 实现IEnumerator<T>的Current属性
            /// </summary>
            public T Current
            {
                get
                {
                    return list[index];
                }
            }

            /// <summary>
            /// 迭代器指示到下一个数据位置
            /// </summary>
            /// <returns></returns>
            public bool MoveNext()
            {
                if (this.index < list.Count)
                {
                    ++this.index;
                }

                return this.index < list.Count;
            }

            public void Reset()
            {
                this.index = -1;
            }
        }

        /// <summary>
        /// 保存数据的数组，T类型则体现了泛型的作用。
        /// </summary>
        private T[] array;

        /// <summary>
        /// 当前集合的长度
        /// </summary>
        private int count;

        /// <summary>
        /// 默认构造函数
        /// </summary>
        public List()
            : this(1)
        {

        }

        public List(int capacity)
        {
            if (capacity < 0)
            {
                throw new Exception("集合初始长度不能小于0");
            }

            if (capacity == 0)
            {
                capacity = 1;
            }

            this.array = new T[capacity];
        }

        /// <summary>
        /// 集合长度
        /// </summary>
        public int Count
        {
            get
            {
                return this.count;
            }
        }

        /// <summary>
        /// 集合实际长度
        /// </summary>
        public int Capacity
        {
            get
            {
                return this.array.Length;
            }
        }

        /// <summary>
        /// 是否固定大小
        /// </summary>
        public bool IsFixedSize
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// 是否只读
        /// </summary>
        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// 是否可同属性
        /// </summary>
        public bool IsSynchronized
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// 同步对象
        /// </summary>
        public object SyncRoot
        {
            get
            {
                return null;
            }
        }

        /// <summary>
        /// 长度不够时，重新分配长度足够的数组
        /// </summary>
        /// <returns></returns>
        private T[] GetNewArray()
        {
            return new T[(this.array.Length + 1) * 2];
        }

        /// <summary>
        /// 实现IList<T>Add方法
        /// </summary>
        /// <param name="value"></param>
        public void Add(T value)
        {
            int newCount = this.count + 1;

            if (this.array.Length < newCount)
            {
                T[] newArray = GetNewArray();

                Array.Copy(this.array, newArray, this.count);

                this.array = newArray;
            }

            this.array[this.count] = value;

            this.count = newCount;
        }

        /// <summary>
        /// 向集合末尾添加对象
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
         int IList.Add(object value)
        {
            ((IList<T>)this).Add((T)value);

            return this.count - 1;
        }

        /// <summary>
        /// 实现IList<T>索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get
            {
                if (index < 0 || index >= this.count)
                {
                    throw new ArgumentOutOfRangeException("index");
                }

                return this.array[index];
            }

            set
            {
                if (index < 0 || index >= this.count)
                {
                    throw new ArgumentOutOfRangeException("index");
                }

                this.array[index] = value;
            }
        }

        /// <summary>
        /// 显示实现IList接口的索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        object IList.this[int index]
        {
            get
            {
                return ((IList<T>)this)[index];
            }

            set
            {
                ((IList<T>)this)[index] = (T)value;
            }
        }

        /// <summary>
        /// 删除集合中的元素
        /// </summary>
        /// <param name="index"></param>
        /// <param name="count"></param>
        public void RemoveRange(int index, int count)
        {
            if (index < 0)
            {
                throw new ArgumentOutOfRangeException("index");
            }

            int removeIndex = index + count;

            if (count < 0 || removeIndex > this.count)
            {
                throw new ArgumentOutOfRangeException("index");
            }

            Array.Copy(this.array, index + 1, this.array, index + count - 1, this.count - removeIndex);

            this.count -= count;
        }

        /// <summary>
        /// 实现IList<T>接口的indexOf方法
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int IndexOf(T value)
        {
            int index = 0;

            if (value == null)
            {
                while (index < this.count)
                {
                    if (this.array[index] == null)
                    {
                        return index;
                    }

                    ++index;
                }
            }
            else
            {
                while (index < this.count)
                {
                    if (value.Equals(this.array[index]))
                    {
                        return index;
                    }

                    ++index;
                }
            }
            return -1;
        }

        /// <summary>
        /// 显示实现IList接口的IndexOf方法
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
         int IList.IndexOf(object value)
        {
            return ((IList<T>)this).IndexOf((T)value);
        }

        /// <summary>
        /// 查找对应数组项
        /// </summary>
        /// <param name="o"></param>
        /// <param name="compar"></param>
        /// <returns></returns>
        public int IndexOf(object o, IComparer compar)
        {
            int index = 0;

            while (index < this.count)
            {
                if (compar.Compare(this.array[index], o) == 0)
                {
                    return index;
                }

                ++index;
            }

            return -1;
        }

        /// <summary>
        /// 实现IList<T>接口的Remove方法
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Remove(T value)
        {
            int index = this.IndexOf(value);

            if (index >= 0)
            {
                this.RemoveRange(index, 1);

                return true;
            }

            return false;
        }

        /// <summary>
        /// 显示实现IList接口的Remove方法，此处显示实现
        /// </summary>
        /// <param name="value"></param>
        void IList.Remove(object value)
        {
            ((IList<T>)this).Remove((T)value);
        }

        /// <summary>
        /// 从集合指定位置删除对象的引用
        /// </summary>
        /// <param name="index"></param>
        public void RemoveAt(int index)
        {
            RemoveRange(index, 1);
        }

        /// <summary>
        /// 弹出集合的最后一个元素
        /// </summary>
        /// <returns></returns>
        public object PopBack()
        {
            object o = this.array[this.count - 1];

            RemoveAt(this.count - 1);

            return o;
        }

        /// <summary>
        /// 弹出集合第一个对象
        /// </summary>
        /// <returns></returns>
        public object PopFront()
        {
            object o = this.array[0];

            RemoveAt(0);

            return o;
        }

        /// <summary>
        /// 实现IList<T>接口的Insert方法
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        public void Insert(int index, T value)
        {
            if (index >= this.count)
            {
                throw new ArgumentOutOfRangeException("index");
            }

            int newCount = this.count + 1;

            if (this.array.Length < newCount)
            {
                T[] newArray = GetNewArray();

                Array.Copy(this.array, newArray, index);

                newArray[index] = value;

                Array.Copy(this.array, index, newArray, index + 1, this.count - index);

                this.array = newArray;
            }
            else
            {
                Array.Copy(this.array, index, this.array, index + 1, this.count - index);

                this.array[index] = value;
            }

            this.count = newCount;
        }

        /// <summary>
        /// 显示实现IList接口的Insert方法
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        void IList.Insert(int index, object value)
        {
            ((IList<T>)this).Insert(index, (T)value);
        }

        /// <summary>
        /// 实现IList<T>接口的Contains方法
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Contains(T value)
        {
            return this.IndexOf(value) >= 0;
        }

        /// <summary>
        /// 显示实现IList<T>接口的Contains方法
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        bool IList.Contains(object value)
        {
            return ((IList<T>)this).IndexOf((T)value) >= 0;
        }

        /// <summary>
        /// 将集合压缩为实际长度
        /// </summary>
        public void TrimToSize()
        {
            if (this.array.Length > this.count)
            {
                T[] newArray = null;

                if (this.count > 0)
                {
                    newArray = new T[this.count];

                    Array.Copy(this.array, newArray, this.count);
                }
                else
                {
                    newArray = new T[1];
                }

                this.array = newArray;
            }
        }

        /// <summary>
        /// 清空集合
        /// </summary>
        public void Clear()
        {
            this.count = 0;
        }

        /// <summary>
        /// 实现IEnumerable接口的GetEnumerator方法
        /// </summary>
        /// <returns></returns>
        public IEnumerator<T> GetEnumerator()
        {
            Enumertor<T> ator = new Enumertor<T>(this);

            return ator;
        }

        /// <summary>
        /// 显示实现IEnumerable接口的GetEnumerator方法
        /// </summary>
        /// <returns></returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable<T>)this).GetEnumerator();
        }

        /// <summary>
        /// 实现ICollection<T>接口的CopyTo方法
        /// </summary>
        /// <param name="array"></param>
        /// <param name="index"></param>
        public void CopyTo(T[] array, int index)
        {
            Array.Copy(this.array, 0, array, index, this.count);
        }

        /// <summary>
        /// 显示实现实现ICollection<T>接口的CopyTo方法
        /// </summary>
        /// <param name="array"></param>
        /// <param name="index"></param>
        void ICollection.CopyTo(Array array, int index)
        {
            Array.Copy(this.array, 0, array, index, this.count);
        }
    }

Call:

 static void Main(string[] args)
        {
            //由于已经指定了int，因此加入值类型不会有装箱拆箱操作。
            List<int> tList = new List<int>();

            tList.Add(25);

            tList.Add(30);

            foreach (int n in tList)
            {
                Console.WriteLine(n);
            }

            Console.ReadLine();
        }

以上は C# の基礎知識の内容です基礎知識 (17) ILiest インターフェイス - ジェネリックス関連内容については、PHP 中国語 Web サイト (www.php.cn) をご覧ください。）！

声明

この記事の内容はネチズンが自主的に寄稿したものであり、著作権は原著者に帰属します。このサイトは、それに相当する法的責任を負いません。盗作または侵害の疑いのあるコンテンツを見つけた場合は、admin@php.cn までご連絡ください。

C＃.NETで開発：実用的なガイドと例May 12, 2025 am 12:16 AM

C＃と.NETは、強力な機能と効率的な開発環境を提供します。 1）C＃は、CのパワーとJavaのシンプルさを組み合わせた最新のオブジェクト指向プログラミング言語です。 2）.NETフレームワークは、複数のプログラミング言語をサポートするアプリケーションを構築および実行するためのプラットフォームです。 3）C＃のクラスとオブジェクトは、オブジェクト指向プログラミングの中核です。クラスはデータと動作を定義し、オブジェクトはクラスのインスタンスです。 4）.NETのゴミ収集メカニズムは、開発者の作業を簡素化するためにメモリを自動的に管理します。 5）C＃および.NETは、同期および非同期プログラミングをサポートする強力なファイル操作関数を提供します。 6）一般的なエラーは、デバッガー、ロギング、例外処理を通じて解決できます。 7）パフォーマンスの最適化とベストプラクティスには、StringBuildの使用が含まれます

C＃.NET：Microsoft .NETフレームワークの理解May 11, 2025 am 12:17 AM

.NetFrameworkは、一貫したプログラミングモデルと強力なランタイム環境を提供する、クロス言語のクロスプラットフォーム開発プラットフォームです。 1）メモリとスレッドを管理するCLRとFCLで構成され、FCLは事前に構築された機能を提供します。 2）使用の例には、読み取りファイルとLINQクエリが含まれます。 3）一般的なエラーには、未処理の例外とメモリリークが含まれ、デバッグツールを使用して解決する必要があります。 4）パフォーマンスの最適化は、非同期プログラミングとキャッシュを通じて実現でき、コードの読みやすさと保守性を維持することが重要です。

c＃.netの寿命：その永続的な人気の理由May 10, 2025 am 12:12 AM

C＃.NETが永続的に魅力的なままである理由には、その優れたパフォーマンス、リッチエコシステム、強力なコミュニティサポート、クロスプラットフォーム開発機能が含まれます。 1）優れたパフォーマンスであり、エンタープライズレベルのアプリケーションとゲーム開発に適しています。 2）.NETフレームワークは、さまざまな開発分野をサポートするための幅広いクラスライブラリとツールを提供します。 3）アクティブな開発者コミュニティと豊富な学習リソースがあります。 4）.NetCoreは、クロスプラットフォーム開発を実現し、アプリケーションシナリオを拡張します。

マスターC＃.NETデザインパターン：シングルトンから依存関係への注入までMay 09, 2025 am 12:15 AM

C＃.NETの設計パターンには、Singletonパターンと依存関係の注入が含まれます。 1.シングルトンモードは、クラスに1つのインスタンスしかないことを保証します。これは、グローバルアクセスポイントが必要なシナリオに適していますが、安全性と虐待の問題をスレッドすることに注意する必要があります。 2。依存関係の噴射により、依存関係を注入することにより、コードの柔軟性とテスト可能性が向上します。多くの場合、コンストラクターの注入に使用されますが、複雑さを高めるために過度の使用を避ける必要があります。

C＃.NET現代世界：アプリケーションと産業May 08, 2025 am 12:08 AM

C＃.NETは、ゲーム開発、金融サービス、モノのインターネット、クラウドコンピューティングの分野で現代世界で広く使用されています。 1）ゲーム開発では、C＃を使用してUnityエンジンを介してプログラムします。 2）金融サービスの分野では、C＃.NETが高性能取引システムとデータ分析ツールの開発に使用されます。 3）IoTおよびクラウドコンピューティングに関して、C＃.NETはAzure Servicesを通じてサポートを提供して、デバイス制御ロジックとデータ処理を開発します。

C＃.NETフレームワークvs.Net Core/5/6：違いは何ですか？May 07, 2025 am 12:06 AM

.NETFRAMEWORKISWINDOWS-CENTRIC、while.netcore/5/6supportscross-platformdevelopment.1）.netframework、2002年以来、isidealforwindowsprimitedincross-platformcapabilities.2）.netcore、andtseverutions（andtseverutions（andtseverution）

C＃.NET開発者のコミュニティ：リソースとサポートMay 06, 2025 am 12:11 AM

C＃.NET開発者コミュニティは、次のような豊富なリソースとサポートを提供します。1。Microsoftの公式文書、2。StackoverflowやRedditなどのコミュニティフォーラム、3。Githubのオープンソースプロジェクト。これらのリソースは、開発者が基本的な学習から高度なアプリケーションまでプログラミングスキルを向上させるのに役立ちます。

C＃.NETアドバンテージ：機能、利点、およびユースケースMay 05, 2025 am 12:01 AM

C＃.NETの利点には以下が含まれます。1）非同期プログラミングなどの言語機能により、開発が簡素化されます。 2）パフォーマンスと信頼性、JITコンピレーションとゴミ収集メカニズムによる効率の向上。 3）クロスプラットフォームサポート、.NetCoreはアプリケーションシナリオを拡張します。 4）Webからデスクトップ、ゲーム開発までの優れたパフォーマンスを備えた幅広い実用的なアプリケーション。

See all articles