সি # তে অ্যারে কীভাবে আইলিস্ট <টি> আংশিকভাবে প্রয়োগ করে?

Question 1

আপনি যেমন জানতে পারেন IList<T>, অন্যান্য ইন্টারফেসের মধ্যে সি # তে অ্যারেগুলি প্রয়োগ করে । যাইহোক, তারা গণনার গণ্য সম্পত্তিটি প্রকাশ্যে প্রয়োগ না করে এটি করে IList<T>! অ্যারেগুলির একটি দৈর্ঘ্যের সম্পত্তি রয়েছে।

এটি কি সি # /। নেট এর ইন্টারফেস বাস্তবায়ন সম্পর্কে নিজস্ব নিয়ম ভঙ্গ করে বা আমি কিছু মিস করছি?

Question 2

হান্সের উত্তরের আলোকে নতুন উত্তর

হান্সের দেওয়া উত্তরের জন্য ধন্যবাদ, আমরা দেখতে পাচ্ছি বাস্তবায়ন কিছুটা জটিল, যা আমরা ভাবি। সংকলক এবং সিএলআর উভয়ই খুব সহজে চেষ্টা করে যে কোনও অ্যারে টাইপ প্রয়োগ করে IList<T>- তবে অ্যারে বৈকল্পিক এই কৌশলটিকে আরও জটিল করে তোলে। হান্সের উত্তরের বিপরীতে, অ্যারের প্রকারগুলি (একক মাত্রিক, যাইহোক শূন্য-ভিত্তিক) জেনেরিক সংগ্রহগুলি সরাসরি বাস্তবায়িত করে, কারণ কোনও নির্দিষ্ট অ্যারের প্রকারটি নয় System.Array - এটি অ্যারের কেবলমাত্র বেস টাইপ। আপনি যদি কোনও অ্যারের প্রকারটি জিজ্ঞাসা করেন তবে এটি কোন ইন্টারফেস সমর্থন করে, এতে জেনেরিক প্রকারগুলি অন্তর্ভুক্ত রয়েছে:

foreach (var type in typeof(int[]).GetInterfaces())
{
    Console.WriteLine(type);
}

আউটপুট:

System.ICloneable
System.Collections.IList
System.Collections.ICollection
System.Collections.IEnumerable
System.Collections.IStructuralComparable
System.Collections.IStructuralEquatable
System.Collections.Generic.IList`1[System.Int32]
System.Collections.Generic.ICollection`1[System.Int32]
System.Collections.Generic.IEnumerable`1[System.Int32]

একক মাত্রিক, শূন্য-ভিত্তিক অ্যারেগুলির জন্য, যতদূর ভাষা সম্পর্কিত, অ্যারে সত্যিই IList<T>খুব কার্যকর করে। সি # স্পেসিফিকেশনের বিভাগ 12.1.2 তাই বলে। সুতরাং অন্তর্নিহিত বাস্তবায়ন যাই ঘটুক না কেন, ভাষাটিকে এমন আচরণ করতে হবে যেন অন্য কোনও ইন্টারফেসের মতো T[]প্রয়োগের ধরণ IList<T>। এই দৃষ্টিকোণ থেকে, ইন্টারফেস হয় সদস্যদের কিছু স্পষ্টভাবে (যেমন বাস্তবায়িত হচ্ছে বাস্তবায়িত Count)। যা চলছে তার জন্য ভাষা স্তরের এটিই সেরা ব্যাখ্যা ।

দ্রষ্টব্য যে এটি কেবল একক-মাত্রিক অ্যারেগুলিকে ধারণ করে (এবং শূন্য-ভিত্তিক অ্যারে, কোনও ভাষা হিসাবে সি # নন-শূন্য-ভিত্তিক অ্যারে সম্পর্কে কিছু বলেন না)। T[,] নেই বাস্তবায়ন IList<T>।

সিএলআর দৃষ্টিকোণ থেকে, মজার কিছু চলছে। জেনেরিক ইন্টারফেস ধরণের জন্য আপনি ইন্টারফেস ম্যাপিংটি পেতে পারেন না। উদাহরণ স্বরূপ:

typeof(int[]).GetInterfaceMap(typeof(ICollection<int>))

এর ব্যতিক্রম দেয়:

Unhandled Exception: System.ArgumentException: Interface maps for generic
interfaces on arrays cannot be retrived.

তাহলে অদ্ভুততা কেন? ঠিক আছে, আমি বিশ্বাস করি এটি সত্যই অ্যারে কোভারিয়েন্সের কারণে, যা টাইপ সিস্টেমের একটি ওয়ার্ট, আইএমও। যদিও IList<T>হয় না (এবং নিরাপদে থাকতে পারে না) covariant, এরে সহভেদাংক কাজ করার জন্য এই অনুমতি দেয়:

string[] strings = { "a", "b", "c" };
IList<object> objects = strings;

... যা করে তোলে চেহারা মত typeof(string[])কার্যকরী IList<object>, যখন এটি সত্যিই না।

সিটিআই স্পেস (ইসিএমএ -৩৩৫) পার্টিশন ১, বিভাগ ৮.7.১ এ রয়েছে:

স্বাক্ষর প্রকারের টি স্বাক্ষর টাইপ ইউ এর সাথে সামঞ্জস্যপূর্ণ এবং কেবল নীচে অন্তত একটি হোল্ড থাকলে

...

টি হ'ল শূন্য-ভিত্তিক র‌্যাঙ্ক -১ অ্যারে V[], এবং Uহয় IList<W>এবং ভি হ'ল অ্যারে-উপাদান-সামঞ্জস্যপূর্ণ-ডাব্লু এর সাথে is

(এটি আসলে উল্লেখ করে না ICollection<W>বা IEnumerable<W>আমি বিশ্বাস করি যা অনুমানের মধ্যে একটি বাগ is)

ভিন্নতা না পাওয়ার জন্য, সিএলআই স্পেকটি সরাসরি ভাষার বর্ণের সাথে চলে। বিভাগ 1 এর 8.9.1 বিভাগ থেকে:

অতিরিক্তভাবে, উপাদান টাইপ টি সহ একটি তৈরি ভেক্টর ইন্টারফেসটি প্রয়োগ করে System.Collections.Generic.IList<U>, যেখানে ইউ: = টি (§8.7)

(একটি ভেক্টর একটি শূন্য বেস সহ একটি মাত্রিক অ্যারে।

এখন বাস্তবায়নের বিশদগুলির ক্ষেত্রে , স্পষ্টতই সিএলআর এখানে অ্যাসাইনমেন্টের সামঞ্জস্যতা রাখতে কিছু মজাদার ম্যাপিং করছে: যখন কোনও string[]বাস্তবায়নের জন্য জিজ্ঞাসা করা হয় ICollection<object>.Count, তখন এটি পুরোপুরি স্বাভাবিকভাবে পরিচালনা করতে পারে না । এই গণনা সুস্পষ্ট ইন্টারফেস বাস্তবায়ন হিসাবে গণ্য করা হয়? আমি মনে করি এটির সাথে সেভাবে আচরণ করা যুক্তিসঙ্গত, যতক্ষণ না আপনি সরাসরি ইন্টারফেস ম্যাপিংয়ের জন্য জিজ্ঞাসা করেন, এটি সর্বদা ভাষার দৃষ্টিকোণ থেকে সেভাবে আচরণ করে ।

কি হবে ICollection.Count?

এখনও অবধি আমি জেনেরিক ইন্টারফেস সম্পর্কে কথা বলেছি, তবে ICollectionতার Countসম্পত্তি সহ নন-জেনেরিক রয়েছে । এবার আমরা ইন্টারফেস ম্যাপিংটি পেতে পারি এবং বাস্তবে ইন্টারফেসটি সরাসরি দ্বারা প্রয়োগ করা হয় System.Array। ICollection.Countসম্পত্তি প্রয়োগের জন্য ডকুমেন্টেশন Arrayসূচিত করে যে এটি সুস্পষ্ট ইন্টারফেস প্রয়োগের মাধ্যমে প্রয়োগ করা হয়েছে।

যদি কেউ এমন কোনও উপায় নিয়ে ভাবতে পারেন যেখানে এই ধরণের সুস্পষ্ট ইন্টারফেস বাস্তবায়ন "সাধারণ" স্পষ্ট ইন্টারফেস প্রয়োগের থেকে পৃথক হয় তবে আমি এটি আরও খতিয়ে দেখে খুশি হব।

সুস্পষ্ট ইন্টারফেস বাস্তবায়ন প্রায় পুরানো উত্তর

উপরের সত্ত্বেও, যা অ্যারে সম্পর্কিত জ্ঞানের কারণে আরও জটিল, আপনি এখনও স্পষ্টত ইন্টারফেস প্রয়োগের মাধ্যমে একই দৃশ্যমান প্রভাবগুলির সাথে কিছু করতে পারেন ।

এখানে একটি সাধারণ স্ট্যান্ডেলোন উদাহরণ:

public interface IFoo
{
    void M1();
    void M2();
}

public class Foo : IFoo
{
    // Explicit interface implementation
    void IFoo.M1() {}

    // Implicit interface implementation
    public void M2() {}
}

class Test    
{
    static void Main()
    {
        Foo foo = new Foo();

        foo.M1(); // Compile-time failure
        foo.M2(); // Fine

        IFoo ifoo = foo;
        ifoo.M1(); // Fine
        ifoo.M2(); // Fine
    }
}

Question 3

আপনি যেমন জানেন যে, IList<T>অন্যান্য ইন্টারফেসের মধ্যে সি # তে অ্যারেগুলি প্রয়োগ করে

ঠিক আছে, হ্যাঁ, এরম না, আসলেই নয়। .NET 4 ফ্রেমওয়ার্কে এটি অ্যারে শ্রেণীর জন্য ঘোষণা:

[Serializable, ComVisible(true)]
public abstract class Array : ICloneable, IList, ICollection, IEnumerable, 
                              IStructuralComparable, IStructuralEquatable
{
    // etc..
}

এটি সিস্টেম.কলেকশনস.আইলিস্ট প্রয়োগ করে, সিস্টেম নয় Col সংগ্রহগুলি.জেনারিক.আইলিস্ট <>। এটি পারে না, অ্যারে জেনেরিক নয়। একই জেনেরিক আইউনামেবল <> এবং আইকোলিকেশন <> ইন্টারফেসের জন্য যায়।

তবে সিএলআর ফ্লাইতে কংক্রিট অ্যারের প্রকারগুলি তৈরি করে, তাই এটি প্রযুক্তিগতভাবে এই ইন্টারফেসগুলি প্রয়োগ করে এমন একটি তৈরি করতে পারে। এটি অবশ্য ঘটনা নয়। উদাহরণস্বরূপ এই কোডটি ব্যবহার করে দেখুন:

using System;
using System.Collections.Generic;

class Program {
    static void Main(string[] args) {
        var goodmap = typeof(Derived).GetInterfaceMap(typeof(IEnumerable<int>));
        var badmap = typeof(int[]).GetInterfaceMap(typeof(IEnumerable<int>));  // Kaboom
    }
}
abstract class Base { }
class Derived : Base, IEnumerable<int> {
    public IEnumerator<int> GetEnumerator() { return null; }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
}

"ইন্টারফেস পাওয়া যায় না" সহ একটি কংক্রিট অ্যারে টাইপের জন্য গেটইন্টারফেসম্যাপ () কল ব্যর্থ হয়। তবুও আইউনামেবল <> এর কাস্ট কোনও সমস্যা ছাড়াই কাজ করে।

এটি কোয়াক্স-এর মতো-হাঁসের টাইপিং। এটি একই ধরণের টাইপিং যা এই ধারণাটি তৈরি করে যে প্রতিটি মান টাইপই ভ্যালু টাইপ থেকে প্রাপ্ত হয় যা অবজেক্ট থেকে আসে। সংকলক এবং সিএলআর উভয়ই অ্যারে প্রকারের বিষয়ে বিশেষ জ্ঞান রাখে, যেমন তারা মান ধরণের বিষয়ে করে। সংকলকটি IList <> এ কাস্ট করার সময় আপনার প্রয়াস দেখেছে এবং বলেছে "ঠিক আছে, আমি কীভাবে এটি করতে জানি!"! এবং কাস্টক্লাস আইএল নির্দেশিকা নির্গত করে। সিএলআরটির এতে কোনও সমস্যা নেই, এটি কীভাবে আইএলিস্ট <> এর অন্তর্নিহিত অ্যারে অবজেক্টে কাজ করে তার একটি বাস্তবায়ন সরবরাহ করতে জানে। এটি অন্যথায় লুকানো সিস্টেম.এসজেডআরেলহেল্পার শ্রেণীর অন্তর্নিহিত জ্ঞান রয়েছে, একটি মোড়ক যা আসলে এই ইন্টারফেসগুলি প্রয়োগ করে।

যা এটি স্পষ্টভাবে প্রত্যেকের দাবি মতো করে না, আপনার কাছে জিজ্ঞাসা করা কাউন্টের সম্পত্তিটি এরকম দেখাচ্ছে:

    internal int get_Count<T>() {
        //! Warning: "this" is an array, not an SZArrayHelper. See comments above
        //! or you may introduce a security hole!
        T[] _this = JitHelpers.UnsafeCast<T[]>(this);
        return _this.Length;
    }

হ্যাঁ, আপনি অবশ্যই সেই মন্তব্যটিকে "নিয়ম ভঙ্গ" করতে পারেন :) এটি অন্যথায় উপকারজনক নয়। এবং অত্যন্ত ভালভাবে লুকানো, আপনি এসএসসিএলআই 20 এ সিএলআর জন্য ভাগ করে নেওয়া উত্স বিতরণে এটি পরীক্ষা করে দেখতে পারেন। টাইপ প্রতিস্থাপনটি কোথায় ঘটে তা দেখতে "আইলিস্ট" অনুসন্ধান করুন। এটিকে কর্মে দেখার জন্য সেরা স্থানটি হ'ল clr / src / vm / array.cpp, getActualImplementation forArrayGenericIListMethod () পদ্ধতি।

সিএলআর-তে এই ধরনের প্রতিস্থাপনটি সিএনআর-এর ভাষার প্রক্ষেপণে যা ঘটে যা উইনআরটি (ওরফে মেট্রো) এর জন্য পরিচালিত কোড লেখার অনুমতি দেয় তার তুলনায় বেশ হালকা। যে কোনও মূল সম্পর্কে। নেট প্রকারটি সেখানে প্রতিস্থাপিত হয়। আইভিস্ট <> আইভেক্টর <> এর মানচিত্রসমূহ উদাহরণস্বরূপ, সম্পূর্ণরূপে অপরিশোধিত টাইপ। নিজেই প্রতিস্থাপন, সিওএম জেনেরিক ধরণের সমর্থন করে না।

ঠিক আছে, পর্দার আড়ালে কী ঘটে তা এক নজর ছিল। মানচিত্রের শেষে ড্রাগন সহ এটি খুব অস্বস্তিকর, অদ্ভুত এবং অপরিচিত সমুদ্র হতে পারে। পৃথিবীকে ফ্ল্যাট করে তোলা এবং ম্যানেজড কোডগুলিতে কী চলছে তার আলাদা চিত্র তৈরি করতে এটি খুব দরকারী to প্রত্যেকের প্রিয় উত্তরের সাথে এটি ম্যাপ করা সেইভাবে আরামদায়ক। যা মান ধরণের জন্য এত ভাল কাজ করে না (কোনও কাঠামোকে রূপান্তর করবেন না) তবে এটি খুব ভালভাবে লুকানো। GetInterfaceMap () পদ্ধতির ব্যর্থতা আমি যে বিমূর্তিতে ভাবতে পারি তার মধ্যে কেবল ফুটো।

Question 4

IList<T>.Countস্পষ্টভাবে প্রয়োগ করা হয় :

int[] intArray = new int[10];
IList<int> intArrayAsList = (IList<int>)intArray;
Debug.Assert(intArrayAsList.Count == 10);

এটি এমনটি করা হয় যাতে আপনার কাছে যখন একটি সহজ অ্যারে ভেরিয়েবল থাকে, আপনার উভয় Countএবং Lengthসরাসরি উপলব্ধ থাকে না।

সাধারণভাবে, আপনি যখন ধরণের সমস্ত গ্রাহককে সেভাবে ভাবতে বাধ্য না করেন তবে কোনও ধরণের একটি নির্দিষ্ট উপায়ে ব্যবহার করা যায় তা নিশ্চিত করতে চাইলে স্পষ্টত ইন্টারফেস বাস্তবায়ন ব্যবহৃত হয়।

সম্পাদনা : ওফস, সেখানে খারাপ স্মরণ করুন। ICollection.Countস্পষ্টভাবে প্রয়োগ করা হয়। জেনেরিক IList<T>যেমন পরিচালিত হয় হান্স নিচে descibes ।

Question 5

সুস্পষ্ট ইন্টারফেস বাস্তবায়ন । সংক্ষেপে, আপনি এটি মত void IControl.Paint() { }বা ঘোষণা করেন int IList<T>.Count { get { return 0; } }।

Question 6

এটি আইলিস্টের স্পষ্ট ইন্টারফেস প্রয়োগের চেয়ে আলাদা নয়। আপনি কেবল ইন্টারফেসটি প্রয়োগ করেছেন বলে এর সদস্যদের ক্লাসের সদস্য হিসাবে উপস্থিত হওয়া প্রয়োজন নয় doesn't এটা তোলে করেন কাউন্ট সম্পত্তি বাস্তবায়ন, এটা ঠিক এক্স [] তে এটি করাবে না।

Question 7

রেফারেন্স-উত্সগুলি উপলব্ধ থাকার সাথে:

//----------------------------------------------------------------------------------------
// ! READ THIS BEFORE YOU WORK ON THIS CLASS.
// 
// The methods on this class must be written VERY carefully to avoid introducing security holes.
// That's because they are invoked with special "this"! The "this" object
// for all of these methods are not SZArrayHelper objects. Rather, they are of type U[]
// where U[] is castable to T[]. No actual SZArrayHelper object is ever instantiated. Thus, you will
// see a lot of expressions that cast "this" "T[]". 
//
// This class is needed to allow an SZ array of type T[] to expose IList<T>,
// IList<T.BaseType>, etc., etc. all the way up to IList<Object>. When the following call is
// made:
//
//   ((IList<T>) (new U[n])).SomeIListMethod()
//
// the interface stub dispatcher treats this as a special case, loads up SZArrayHelper,
// finds the corresponding generic method (matched simply by method name), instantiates
// it for type <T> and executes it. 
//
// The "T" will reflect the interface used to invoke the method. The actual runtime "this" will be
// array that is castable to "T[]" (i.e. for primitivs and valuetypes, it will be exactly
// "T[]" - for orefs, it may be a "U[]" where U derives from T.)
//----------------------------------------------------------------------------------------
sealed class SZArrayHelper {
    // It is never legal to instantiate this class.
    private SZArrayHelper() {
        Contract.Assert(false, "Hey! How'd I get here?");
    }

    /* ... snip ... */
}

বিশেষতঃ এই অংশ:

ইন্টারফেস স্টাব প্রেরণকারী এটিকে একটি বিশেষ কেস হিসাবে বিবেচনা করে , এসজেআররেহেল্পার লোড করে, সংশ্লিষ্ট জেনেরিক পদ্ধতিটি আবিষ্কার করে (কেবল পদ্ধতি অনুসারে মিলিত ) , টাইপের জন্য এটি ইনস্ট্যান্ট করে এবং এটি কার্যকর করে।

(জোর আমার)

উত্স (স্ক্রোল আপ)।