আপনি / নেট যখন নেস্টেড ক্লাস ব্যবহার করবেন? নাকি তোমার উচিত নয়?

Question 1

ইন ক্যাথলিন Dollard 2008 ব্লগ পোস্টে তিনি .net মধ্যে নেস্টেড শ্রেণীর ব্যবহার করার জন্য একটি আকর্ষণীয় কারণ উপস্থাপন করে। তবে, তিনি আরও উল্লেখ করেছেন যে এফএক্সকপ নেস্টেড ক্লাস পছন্দ করে না। আমি ধরে নিচ্ছি যে FxCop বিধি লেখার লোকগুলি বোকা নয়, সুতরাং অবশ্যই এই অবস্থানের পিছনে যুক্তি থাকতে হবে, তবে আমি এটি সন্ধান করতে পারিনি।

Question 2

নেস্টেড ক্লাসটি ব্যবহার করুন যখন আপনি নীড় করছেন এমন ক্লাসটি কেবল বদ্ধ ক্লাসের জন্যই কার্যকর। উদাহরণস্বরূপ, নেস্টেড ক্লাসগুলি আপনাকে (সরলীকৃত) মতো কিছু লেখার অনুমতি দেয়:

public class SortedMap {
    private class TreeNode {
        TreeNode left;
        TreeNode right;
    }
}

আপনি আপনার ক্লাসের একটি সম্পূর্ণ সংজ্ঞা এক জায়গায় তৈরি করতে পারেন, আপনার শ্রেণিটি কীভাবে কাজ করে তা নির্ধারণ করতে আপনাকে কোনও পিআইএমপিএল হুপের মধ্য দিয়ে ঝাঁপিয়ে পড়তে হবে না এবং বাইরের বিশ্বের আপনার বাস্তবায়নের কোনও কিছু দেখার দরকার নেই।

TreeNode ক্লাসটি যদি বাহ্যিক হয় তবে আপনাকে হয় সমস্ত ক্ষেত্র তৈরি করতে হবে publicবা get/setএটি ব্যবহারের জন্য প্রচুর পদ্ধতি তৈরি করতে হবে। বাইরের পৃথিবীতে আরও একটি শ্রেণি থাকবে যা তাদের ইন্টেলিসেন্সকে দূষিত করে।

Question 3

সান এর জাভা টিউটোরিয়াল থেকে:

নেস্টেড ক্লাস কেন ব্যবহার করবেন? নেস্টেড ক্লাসগুলি ব্যবহারের জন্য বিভিন্ন ধরণের বাধ্যতামূলক কারণ রয়েছে:

এটি যৌক্তিকভাবে শ্রেণিবদ্ধ করার একটি উপায় যা কেবলমাত্র এক জায়গায় ব্যবহৃত হয়।
এটি এনক্যাপসুলেশন বৃদ্ধি করে।
নেস্টেড ক্লাসগুলি আরও পঠনযোগ্য এবং রক্ষণাবেক্ষণযোগ্য কোডের দিকে নিয়ে যেতে পারে।

ক্লাসগুলির যৌক্তিক গোষ্ঠীকরণ a কোনও শ্রেণি যদি কেবলমাত্র অন্য একটি শ্রেণির জন্য কার্যকর হয় তবে তা class শ্রেণিতে এটি এম্বেড করা এবং দুটিকে একসাথে রাখা যুক্তিযুক্ত। এই জাতীয় "সহায়ক শ্রেণি" বাসা বাঁধাই তাদের প্যাকেজটিকে আরও সুচলিত করে তোলে।

বর্ধিত এনক্যাপসুলেশন A দুটি শীর্ষ-স্তরের শ্রেণি, এ এবং বি বিবেচনা করুন, যেখানে বি এর সদস্যদের অ্যাক্সেস প্রয়োজন যা অন্যথায় ব্যক্তিগত হিসাবে ঘোষণা করা হবে। ক্লাস বি ক্লাস এ এর মধ্যে লুকিয়ে রাখলে এ এর সদস্যদের ব্যক্তিগত ঘোষণা করা যেতে পারে এবং বি সেগুলি অ্যাক্সেস করতে পারে। এছাড়াও, খ নিজেই বাইরের বিশ্ব থেকে আড়াল হতে পারে। <- এটি নেস্টেড ক্লাসগুলির সি # এর প্রয়োগের জন্য প্রযোজ্য নয়, এটি কেবল জাভাতে প্রযোজ্য।

আরও পঠনযোগ্য, রক্ষণাবেক্ষণযোগ্য কোড top শীর্ষ স্তরের শ্রেণির মধ্যে ছোট ক্লাসে বাসা বাঁধাই কোডটি যেখানে ব্যবহৃত হয় তার কাছাকাছি রাখে।

Question 4

সম্পূর্ণ অলস এবং থ্রেড-নিরাপদ একক প্যাটার্ন

public sealed class Singleton
{
    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            return Nested.instance;
        }
    }
    
    class Nested
    {
        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static Nested()
        {
        }

        internal static readonly Singleton instance = new Singleton();
    }
}

উত্স: https://csharpindepth.com/Articles/Singleton

Question 5

এটি ব্যবহারের উপর নির্ভর করে। আমি খুব কমই পাবলিক নেস্টেড ক্লাস ব্যবহার করতাম তবে সমস্ত সময় প্রাইভেট নেস্টেড ক্লাস ব্যবহার করি। একটি ব্যক্তিগত নেস্টেড ক্লাসটি উপ-অবজেক্টের জন্য ব্যবহার করা যেতে পারে যা কেবল পিতামাতার অভ্যন্তরে ব্যবহারের উদ্দেশ্যে। এর উদাহরণ হ'ল যদি কোনও হ্যাশটেবল ক্লাসে কেবলমাত্র অভ্যন্তরীণভাবে ডেটা সঞ্চয় করার জন্য একটি ব্যক্তিগত এন্ট্রি অবজেক্ট থাকে।

ক্লাসটি যদি কলার দ্বারা ব্যবহৃত হয় (বাহ্যিকভাবে), তবে আমি সাধারণত এটি একটি পৃথক স্ট্যান্ডেলোন বর্গ তৈরি করতে পছন্দ করি।

Question 6

উপরে তালিকাভুক্ত অন্যান্য কারণগুলি ছাড়াও, এর আরও একটি কারণ রয়েছে যা আমি কেবল নেস্টেড ক্লাসগুলিই ব্যবহার করার কথা ভাবতে পারি না, তবে প্রকৃতপক্ষে পাবলিক নেস্টেড ক্লাসগুলিও ব্যবহার করতে পারি। একই জেনেরিক ধরণের পরামিতিগুলি ভাগ করে নেওয়ার জন্য একাধিক জেনেরিক ক্লাসগুলির সাথে যারা কাজ করেন তাদের পক্ষে জেনেরিক নেমস্পেস ঘোষণা করার ক্ষমতা অত্যন্ত কার্যকর be দুর্ভাগ্যক্রমে,। নেট (বা কমপক্ষে সি #) জেনেরিক নেমস্পেসের ধারণাটিকে সমর্থন করে না। সুতরাং একই লক্ষ্য অর্জনের জন্য, আমরা একই লক্ষ্য অর্জনের জন্য জেনেরিক ক্লাস ব্যবহার করতে পারি। একটি যৌক্তিক সত্তা সম্পর্কিত নিম্নলিখিত ক্লাস গ্রহণ করুন:

public  class       BaseDataObject
                    <
                        tDataObject, 
                        tDataObjectList, 
                        tBusiness, 
                        tDataAccess
                    >
        where       tDataObject     : BaseDataObject<tDataObject, tDataObjectList, tBusiness, tDataAccess>
        where       tDataObjectList : BaseDataObjectList<tDataObject, tDataObjectList, tBusiness, tDataAccess>, new()
        where       tBusiness       : IBaseBusiness<tDataObject, tDataObjectList, tBusiness, tDataAccess>
        where       tDataAccess     : IBaseDataAccess<tDataObject, tDataObjectList, tBusiness, tDataAccess>
{
}

public  class       BaseDataObjectList
                    <
                        tDataObject, 
                        tDataObjectList, 
                        tBusiness, 
                        tDataAccess
                    >
:   
                    CollectionBase<tDataObject>
        where       tDataObject     : BaseDataObject<tDataObject, tDataObjectList, tBusiness, tDataAccess>
        where       tDataObjectList : BaseDataObjectList<tDataObject, tDataObjectList, tBusiness, tDataAccess>, new()
        where       tBusiness       : IBaseBusiness<tDataObject, tDataObjectList, tBusiness, tDataAccess>
        where       tDataAccess     : IBaseDataAccess<tDataObject, tDataObjectList, tBusiness, tDataAccess>
{
}

public  interface   IBaseBusiness
                    <
                        tDataObject, 
                        tDataObjectList, 
                        tBusiness, 
                        tDataAccess
                    >
        where       tDataObject     : BaseDataObject<tDataObject, tDataObjectList, tBusiness, tDataAccess>
        where       tDataObjectList : BaseDataObjectList<tDataObject, tDataObjectList, tBusiness, tDataAccess>, new()
        where       tBusiness       : IBaseBusiness<tDataObject, tDataObjectList, tBusiness, tDataAccess>
        where       tDataAccess     : IBaseDataAccess<tDataObject, tDataObjectList, tBusiness, tDataAccess>
{
}

public  interface   IBaseDataAccess
                    <
                        tDataObject, 
                        tDataObjectList, 
                        tBusiness, 
                        tDataAccess
                    >
        where       tDataObject     : BaseDataObject<tDataObject, tDataObjectList, tBusiness, tDataAccess>
        where       tDataObjectList : BaseDataObjectList<tDataObject, tDataObjectList, tBusiness, tDataAccess>, new()
        where       tBusiness       : IBaseBusiness<tDataObject, tDataObjectList, tBusiness, tDataAccess>
        where       tDataAccess     : IBaseDataAccess<tDataObject, tDataObjectList, tBusiness, tDataAccess>
{
}

আমরা জেনেরিক নেমস্পেস (নেস্টেড ক্লাসগুলির মাধ্যমে প্রয়োগ করা) ব্যবহার করে এই শ্রেণীর স্বাক্ষরগুলি সহজ করতে পারি:

public
partial class   Entity
                <
                    tDataObject, 
                    tDataObjectList, 
                    tBusiness, 
                    tDataAccess
                >
        where   tDataObject     : Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>.BaseDataObject
        where   tDataObjectList : Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>.BaseDataObjectList, new()
        where   tBusiness       : Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>.IBaseBusiness
        where   tDataAccess     : Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>.IBaseDataAccess
{

    public  class       BaseDataObject {}

    public  class       BaseDataObjectList : CollectionBase<tDataObject> {}

    public  interface   IBaseBusiness {}

    public  interface   IBaseDataAccess {}

}

তারপরে, এরিক ভ্যান ব্র্যাকেলের প্রস্তাবিত আংশিক ক্লাস ব্যবহারের মাধ্যমে পূর্বের মন্তব্যে, আপনি ক্লাসগুলি পৃথক নেস্টেড ফাইলগুলিতে আলাদা করতে পারবেন। আংশিক শ্রেণীর ফাইলগুলিকে বাসা বাঁধতে সমর্থন করার জন্য আমি নেস্টইনের মতো ভিজ্যুয়াল স্টুডিও এক্সটেনশনটি ব্যবহার করার পরামর্শ দিচ্ছি। এটি "নেমস্পেস" শ্রেণীর ফাইলগুলিকে নেস্টেড ক্লাস ফাইলগুলিকে এভাবে ফোল্ডারে সংগঠিত করতে ব্যবহার করতে সহায়তা করে।

উদাহরণ স্বরূপ:

সত্ত্বা

public
partial class   Entity
                <
                    tDataObject, 
                    tDataObjectList, 
                    tBusiness, 
                    tDataAccess
                >
        where   tDataObject     : Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>.BaseDataObject
        where   tDataObjectList : Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>.BaseDataObjectList, new()
        where   tBusiness       : Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>.IBaseBusiness
        where   tDataAccess     : Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>.IBaseDataAccess
{
}

সত্তা.বেসডাটাঅবজেক্ট.সি

partial class   Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>
{

    public  class   BaseDataObject
    {

        public  DataTimeOffset  CreatedDateTime     { get; set; }
        public  Guid            CreatedById         { get; set; }
        public  Guid            Id                  { get; set; }
        public  DataTimeOffset  LastUpdateDateTime  { get; set; }
        public  Guid            LastUpdatedById     { get; set; }

        public
        static
        implicit    operator    tDataObjectList(DataObject dataObject)
        {
            var returnList  = new tDataObjectList();
            returnList.Add((tDataObject) this);
            return returnList;
        }

    }

}

সত্তা.বেসডাটাঅবজেক্টলিস্ট

partial class   Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>
{

    public  class   BaseDataObjectList : CollectionBase<tDataObject>
    {

        public  tDataObjectList ShallowClone() 
        {
            var returnList  = new tDataObjectList();
            returnList.AddRange(this);
            return returnList;
        }

    }

}

সত্তা.আইব্যাসব্যবসনেসি

partial class   Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>
{

    public  interface   IBaseBusiness
    {
        tDataObjectList Load();
        void            Delete();
        void            Save(tDataObjectList data);
    }

}

সত্তা.আইবেসডেটা অ্যাক্সেস.সি

partial class   Entity<tDataObject, tDataObjectList, tBusiness, tDataAccess>
{

    public  interface   IBaseDataAccess
    {
        tDataObjectList Load();
        void            Delete();
        void            Save(tDataObjectList data);
    }

}

ভিজ্যুয়াল স্টুডিও সলিউশন এক্সপ্লোরারের ফাইলগুলি এরপরে এইভাবে সংগঠিত হবে:

Entity.cs
+   Entity.BaseDataObject.cs
+   Entity.BaseDataObjectList.cs
+   Entity.IBaseBusiness.cs
+   Entity.IBaseDataAccess.cs

এবং আপনি জেনেরিক নেমস্পেস নিম্নলিখিতগুলির মতো প্রয়োগ করবেন:

ব্যবহারকারীর

public
partial class   User
:
                Entity
                <
                    User.DataObject, 
                    User.DataObjectList, 
                    User.IBusiness, 
                    User.IDataAccess
                >
{
}

ব্যবহারকারী.ডাটাঅবজেক্ট.সি

partial class   User
{

    public  class   DataObject : BaseDataObject 
    {
        public  string  UserName            { get; set; }
        public  byte[]  PasswordHash        { get; set; }
        public  bool    AccountIsEnabled    { get; set; }
    }

}

ব্যবহারকারী.ডাটাঅবজেক্টলিস্ট

partial class   User
{

    public  class   DataObjectList : BaseDataObjectList {}

}

ব্যবহারকারী.আইবসনেস.সি

partial class   User
{

    public  interface   IBusiness : IBaseBusiness {}

}

ব্যবহারকারী.আইডিটাএ্যাক্সেস.সি

partial class   User
{

    public  interface   IDataAccess : IBaseDataAccess {}

}

ফাইলগুলি সমাধান এক্সপ্লোরারগুলিতে নিম্নরূপভাবে সংগঠিত হবে:

User.cs
+   User.DataObject.cs
+   User.DataObjectList.cs
+   User.IBusiness.cs
+   User.IDataAccess.cs

উপরেরটি একটি জেনেরিক নেমস্পেস হিসাবে বাইরের শ্রেণি ব্যবহারের একটি সাধারণ উদাহরণ example আমি অতীতে 9 বা ততোধিক ধরণের পরামিতিগুলি ধারণ করে "জেনেরিক নেমস্পেস" তৈরি করেছি। এই ধরণের পরামিতিগুলিকে নয়টি ধরণের সিঙ্ক্রোনাইজ করে রাখার জন্য যা টাইপ পরামিতিগুলি জানতে প্রয়োজনীয় সমস্ত ক্লান্তিকর ছিল, বিশেষত একটি নতুন পরামিতি যুক্ত করার সময়। জেনেরিক নেমস্পেসের ব্যবহার সেই কোডটিকে আরও বেশি পরিচালনাযোগ্য এবং পঠনযোগ্য করে তোলে।

Question 7

যদি আমি ক্যাথলিনের নিবন্ধটি সঠিকভাবে বুঝতে পারি তবে সে সত্ত্বা শ্রেণি <<< কিছু>> এর পরিবর্তে সামেরেন্টি.কলেকশন লিখতে সক্ষম হওয়ার জন্য নেস্টেড ক্লাস ব্যবহার করার প্রস্তাব দেয়। আমার মতে এটি আপনাকে বিতর্কিত কিছু টাইপ সংরক্ষণ করার উপায় save আমি পুরোপুরি নিশ্চিত যে বাস্তব জগতের অ্যাপ্লিকেশন সংগ্রহগুলি বাস্তবায়নে কিছুটা পার্থক্য রাখে, তাই আপনাকে যাইহোক পৃথক শ্রেণি তৈরি করতে হবে। আমি মনে করি অন্যান্য শ্রেণির সুযোগ সীমাবদ্ধ করতে শ্রেণীর নাম ব্যবহার করা ভাল ধারণা নয়। এটি ইন্টেলিজেন্সকে দূষিত করে এবং শ্রেণীর মধ্যে নির্ভরতা জোরদার করে। ক্লাসের সুযোগ নিয়ন্ত্রণ করার জন্য নেমস্পেস ব্যবহার করা একটি মানক উপায়। তবে আমি দেখতে পেয়েছি যে @ হাজন মন্তব্যের মতো নেস্টেড ক্লাসগুলির ব্যবহার গ্রহণযোগ্য হবে যদি না আপনার কাছে টন নেস্টেড ক্লাস থাকে যা খারাপ ডিজাইনের লক্ষণ।

Question 8

আমি প্রায়শই প্রয়োগের বিবরণ গোপন করার জন্য নেস্টেড ক্লাস ব্যবহার করি। এরিক লিপার্টের উত্তর থেকে এখানে একটি উদাহরণ:

abstract public class BankAccount
{
    private BankAccount() { }
    // Now no one else can extend BankAccount because a derived class
    // must be able to call a constructor, but all the constructors are
    // private!
    private sealed class ChequingAccount : BankAccount { ... }
    public static BankAccount MakeChequingAccount() { return new ChequingAccount(); }
    private sealed class SavingsAccount : BankAccount { ... }
}

জেনেরিক ব্যবহারের সাথে এই প্যাটার্নটি আরও উন্নত হয়। দুটি দুর্দান্ত উদাহরণের জন্য এই প্রশ্নটি দেখুন । তাই আমি লেখার শেষ

Equality<Person>.CreateComparer(p => p.Id);

পরিবর্তে

new EqualityComparer<Person, int>(p => p.Id);

এছাড়াও আমি একটি জেনেরিক তালিকা থাকতে পারে Equality<Person>কিন্তু নাEqualityComparer<Person, int>

var l = new List<Equality<Person>> 
        { 
         Equality<Person>.CreateComparer(p => p.Id),
         Equality<Person>.CreateComparer(p => p.Name) 
        }

যেখানে হিসাবে

var l = new List<EqualityComparer<Person, ??>>> 
        { 
         new EqualityComparer<Person, int>>(p => p.Id),
         new EqualityComparer<Person, string>>(p => p.Name) 
        }

সম্ভব নয়. পিতা-মাতার ক্লাস থেকে নেস্টেড বর্গ উত্তরাধিকার সূত্রে এটাই সুবিধা।

আরেকটি কেস (একই প্রকৃতির - বাস্তবায়ন গোপন করা) হ'ল আপনি যখন কোনও শ্রেণীর সদস্যদের (ক্ষেত্র, বৈশিষ্ট্যাদি ইত্যাদি) কেবলমাত্র একক শ্রেণীর জন্য অ্যাক্সেসযোগ্য করতে চান:

public class Outer 
{
   class Inner //private class
   {
       public int Field; //public field
   }

   static inner = new Inner { Field = -1 }; // Field is accessible here, but in no other class
}

Question 9

নেস্টেড ক্লাসগুলির জন্য এখনও উল্লেখ না করা আরেকটি ব্যবহার হ'ল জেনেরিক ধরণের পৃথককরণ। উদাহরণস্বরূপ, ধরুন যে কোনও স্ট্যাটিক ক্লাসের কিছু জেনেরিক পরিবার থাকতে চান যারা সেই সমস্ত পরামিতিগুলির মানগুলির সাথে বিভিন্ন সংখ্যক পরামিতিগুলির সাথে পদ্ধতি গ্রহণ করতে পারে এবং কম পরামিতি সহ প্রতিনিধি তৈরি করতে পারে। উদাহরণস্বরূপ, কেউ একটি স্থিতিশীল পদ্ধতি থাকতে চান যা গ্রহণ করতে পারে Action<string, int, double>এবং একটি ফলন করতে পারে String<string, int>যা সরবরাহকৃত পদক্ষেপকে 3.5 হিসাবে পাস করার কল হিসাবে ডাকে double; একটি স্থিতিশীল পদ্ধতি থাকতে পারে যা একটি নিতে পারে Action<string, int, double>এবং ফলন করতে পারে Action<string>, 7হিসাবে intএবং 5.3হিসাবে হিসাবে পাস করে double। জেনেরিক নেস্টেড ক্লাসগুলি ব্যবহার করে, কেউ পদ্ধতিটির অনুরোধগুলি এমন কিছু হওয়ার ব্যবস্থা করতে পারেন:

MakeDelegate<string,int>.WithParams<double>(theDelegate, 3.5);
MakeDelegate<string>.WithParams<int,double>(theDelegate, 7, 5.3);

বা, কারণ প্রতিটি অভিব্যক্তিতে পরবর্তী প্রকারগুলি অনুমান করা যায় যদিও পূর্বেরগুলি তা না করে:

MakeDelegate<string,int>.WithParams(theDelegate, 3.5);
MakeDelegate<string>.WithParams(theDelegate, 7, 5.3);

নেস্টেড জেনেরিক প্রকারগুলি ব্যবহার করে সামগ্রিক ধরণের বর্ণনের কোন অংশগুলির জন্য কোন প্রতিনিধি প্রযোজ্য তা বলা সম্ভব করে তোলে।

Question 10

নেস্টেড ক্লাসগুলি নিম্নলিখিত প্রয়োজনের জন্য ব্যবহার করা যেতে পারে:

তথ্য শ্রেণীবদ্ধ
যখন প্রধান শ্রেণীর যুক্তি জটিল হয় এবং আপনার মনে হয় ক্লাস পরিচালনা করার জন্য আপনার অধস্তন বস্তুর প্রয়োজন
আপনি যখন ক্লাসের অবস্থা এবং অস্তিত্ব পুরোপুরি ঘেরের ক্লাসের উপর নির্ভর করে

Question 11

নওফাল যেমন অ্যাবস্ট্রাক্ট ফ্যাক্টরি প্যাটার্ন বাস্তবায়নের উল্লেখ করেছেন, ক্লাস ক্লাস্টার্স প্যাটার্ন অর্জনের জন্য সেই কোডটি প্রসারিত করা যেতে পারে যা অ্যাবস্ট্রাক্ট ফ্যাক্টরি প্যাটার্নের উপর ভিত্তি করে।

Question 12

আমি নীড় ব্যতিক্রমগুলি পছন্দ করি যা একক শ্রেণীর কাছে অনন্য are যেগুলি অন্য কোনও জায়গা থেকে কখনও নিক্ষেপ করা হয় না।

উদাহরণ স্বরূপ:

public class MyClass
{
    void DoStuff()
    {
        if (!someArbitraryCondition)
        {
            // This is the only class from which OhNoException is thrown
            throw new OhNoException(
                "Oh no! Some arbitrary condition was not satisfied!");
        }
        // Do other stuff
    }

    public class OhNoException : Exception
    {
        // Constructors calling base()
    }
}

এটি আপনার প্রকল্পের ফাইলগুলিকে পরিস্কার রাখতে এবং একশ একগুঁয়ে ছোট্ট ব্যতিক্রম শ্রেণিতে পূর্ণ নয় helps

Question 13

মনে রাখবেন যে আপনাকে নেস্টেড ক্লাসটি পরীক্ষা করতে হবে। যদি এটি ব্যক্তিগত হয় তবে আপনি এটিকে বিচ্ছিন্নভাবে পরীক্ষা করতে পারবেন না।

বৈশিষ্ট্যের সাথে মিল রেখে আপনিInternalsVisibleTo এটি অভ্যন্তরীণ করতে পারেন । তবে এটি কেবল পরীক্ষার উদ্দেশ্যে ব্যক্তিগত ক্ষেত্রের অভ্যন্তরীণ করার মতো হবে, যা আমি খারাপ স্ব-ডকুমেন্টেশন মনে করি।

সুতরাং, আপনি কেবলমাত্র কম জটিলতায় জড়িত ব্যক্তিগত নেস্টেড ক্লাসগুলি প্রয়োগ করতে চাইতে পারেন।

Question 14

হ্যাঁ এই ক্ষেত্রে:

class Join_Operator
{

    class Departamento
    {
        public int idDepto { get; set; }
        public string nombreDepto { get; set; }
    }

    class Empleado
    {
        public int idDepto { get; set; }
        public string nombreEmpleado { get; set; }
    }

    public void JoinTables()
    {
        List<Departamento> departamentos = new List<Departamento>();
        departamentos.Add(new Departamento { idDepto = 1, nombreDepto = "Arquitectura" });
        departamentos.Add(new Departamento { idDepto = 2, nombreDepto = "Programación" });

        List<Empleado> empleados = new List<Empleado>();
        empleados.Add(new Empleado { idDepto = 1, nombreEmpleado = "John Doe." });
        empleados.Add(new Empleado { idDepto = 2, nombreEmpleado = "Jim Bell" });

        var joinList = (from e in empleados
                        join d in departamentos on
                        e.idDepto equals d.idDepto
                        select new
                        {
                            nombreEmpleado = e.nombreEmpleado,
                            nombreDepto = d.nombreDepto
                        });
        foreach (var dato in joinList)
        {
            Console.WriteLine("{0} es empleado del departamento de {1}", dato.nombreEmpleado, dato.nombreDepto);
        }
    }
}

Question 15

এই ধারণাটি সম্পর্কে আমার বোঝার ভিত্তিতে যখন ক্লাসগুলি একে অপরের সাথে ধারণাগতভাবে সম্পর্কিত হয় তখন আমরা এই বৈশিষ্ট্যটি ব্যবহার করতে পারি। আমি বলতে চাইছি তাদের মধ্যে কিছু হ'ল আমাদের ব্যবসায় সম্পূর্ণ আইটেম যেমন ডিডিডি বিশ্বে বিদ্যমান সত্তা যা একটি সামগ্রিক মূল অবজেক্টকে তার ব্যবসার যুক্তি পূর্ণ করতে সহায়তা করে।

স্পষ্ট করার জন্য আমি এটি একটি উদাহরণের মাধ্যমে দেখাবো:

ধারণা করুন যে আমাদের অর্ডার এবং অর্ডার আইটেমের মতো দুটি ক্লাস রয়েছে। অর্ডার ক্লাসে, আমরা সমস্ত অর্ডার আইটেম পরিচালনা করতে যাচ্ছি এবং অর্ডার আইটেমে আমরা স্পষ্টকরণের জন্য একটি একক অর্ডার সম্পর্কে ডেটা ধরে রেখেছি, আপনি নীচের ক্লাসগুলি দেখতে পারেন:

 class Order
    {
        private List<OrderItem> _orderItems = new List<OrderItem>();

        public void AddOrderItem(OrderItem line)
        {
            _orderItems.Add(line);
        }

        public double OrderTotal()
        {
            double total = 0;
            foreach (OrderItem item in _orderItems)
            {
                total += item.TotalPrice();
            }

            return total;
        }

        // Nested class
        public class OrderItem
        {
            public int ProductId { get; set; }
            public int Quantity { get; set; }
            public double Price { get; set; }
            public double TotalPrice() => Price * Quantity;
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            Order order = new Order();

            Order.OrderItem orderItem1 = new Order.OrderItem();
            orderItem1.ProductId = 1;
            orderItem1.Quantity = 5;
            orderItem1.Price = 1.99;
            order.AddOrderItem(orderItem1);

            Order.OrderItem orderItem2 = new Order.OrderItem();
            orderItem2.ProductId = 2;
            orderItem2.Quantity = 12;
            orderItem2.Price = 0.35;
            order.AddOrderItem(orderItem2);

            Console.WriteLine(order.OrderTotal());
            ReadLine();
        }


    }