কিভাবে সেরা উপায়ে তালিকা আইটেম প্রতিস্থাপন

Question 1

if (listofelements.Contains(valueFieldValue.ToString()))
{
    listofelements[listofelements.IndexOf(valueFieldValue.ToString())] = value.ToString();
}

আমি উপরের মত প্রতিস্থাপন করেছি এই তুলনায় অন্য কোন সেরা ওয়ে আছে?

Question 2

তালিকায় সূচীটি পেতে ল্যাম্বদা ব্যবহার করুন এবং তালিকা আইটেমটি প্রতিস্থাপন করতে এই সূচিটি ব্যবহার করুন।

List<string> listOfStrings = new List<string> {"abc", "123", "ghi"};
listOfStrings[listOfStrings.FindIndex(ind=>ind.Equals("123"))] =  "def";

Question 3

আপনি এটিকে আরও পঠনযোগ্য এবং আরও দক্ষ করে তুলতে পারেন:

string oldValue = valueFieldValue.ToString();
string newValue = value.ToString();
int index = listofelements.IndexOf(oldValue);
if(index != -1)
    listofelements[index] = newValue;

এটি সূচকের জন্য একবার জিজ্ঞাসা করে। আপনার পদ্ধতির Containsপ্রথমে ব্যবহার করে যা সমস্ত আইটেম লুপ করা প্রয়োজন (সবচেয়ে খারাপ ক্ষেত্রে), তারপরে আপনি IndexOfযা ব্যবহার করছেন তা আবার আইটেমগুলি গণনা করা প্রয়োজন।

Question 4

একটি উপাদান প্রতিস্থাপন করতে আপনি আপনার তালিকাতে দুবার অ্যাক্সেস করছেন। আমি মনে করি সহজ forলুপটি যথেষ্ট হওয়া উচিত:

var key = valueFieldValue.ToString();
for (int i = 0; i < listofelements.Count; i++)
{
    if (listofelements[i] == key)
    {
        listofelements[i] = value.ToString();
        break;
    }
}

Question 5

কেন এক্সটেনশন পদ্ধতি ব্যবহার করবেন না?

নিম্নলিখিত কোড বিবেচনা করুন:

        var intArray = new int[] { 0, 1, 1, 2, 3, 4 };
        // Replaces the first occurance and returns the index
        var index = intArray.Replace(1, 0);
        // {0, 0, 1, 2, 3, 4}; index=1

        var stringList = new List<string> { "a", "a", "c", "d"};
        stringList.ReplaceAll("a", "b");
        // {"b", "b", "c", "d"};

        var intEnum = intArray.Select(x => x);
        intEnum = intEnum.Replace(0, 1);
        // {0, 0, 1, 2, 3, 4} => {1, 1, 1, 2, 3, 4}

কোনও কোড সদৃশ
দীর্ঘ লিনক এক্সপ্রেশন টাইপ করার প্রয়োজন নেই
অতিরিক্ত ব্যবহারের দরকার নেই

উত্স কোড:

namespace System.Collections.Generic
{
    public static class Extensions
    {
        public static int Replace<T>(this IList<T> source, T oldValue, T newValue)
        {
            if (source == null)
                throw new ArgumentNullException(nameof(source));

            var index = source.IndexOf(oldValue);
            if (index != -1)
                source[index] = newValue;
            return index;
        }

        public static void ReplaceAll<T>(this IList<T> source, T oldValue, T newValue)
        {
            if (source == null)
                throw new ArgumentNullException(nameof(source));

            int index = -1;
            do
            {
                index = source.IndexOf(oldValue);
                if (index != -1)
                    source[index] = newValue;
            } while (index != -1);
        }


        public static IEnumerable<T> Replace<T>(this IEnumerable<T> source, T oldValue, T newValue)
        {
            if (source == null)
                throw new ArgumentNullException(nameof(source));

            return source.Select(x => EqualityComparer<T>.Default.Equals(x, oldValue) ? newValue : x);
        }
    }
}

রেফারেন্স ধরনেরগুলির স্থানে স্থান পরিবর্তন করতে প্রথম দুটি পদ্ধতি যুক্ত করা হয়েছে। অবশ্যই, আপনি সমস্ত ধরণের জন্য কেবল তৃতীয় পদ্ধতি ব্যবহার করতে পারেন।

পিএস মাইকের পর্যবেক্ষণের জন্য ধন্যবাদ , আমি রিপ্লেসএল পদ্ধতিটি যুক্ত করেছি।

Question 6

রোককুচের উত্তর অনুসরণ করে, সামান্য আপগ্রেড করুন:

List<string> listOfStrings = new List<string> {"abc", "123", "ghi"};

int index = listOfStrings.FindIndex(ind => ind.Equals("123"));
if (index > -1)
    listOfStrings[index] =  "def";

Question 7

FindIndexআপনার মানগুলি খুঁজে পেতে এবং প্রতিস্থাপন করতে ল্যাম্বডা ব্যবহার করুন :

int j = listofelements.FindIndex(i => i.Contains(valueFieldValue.ToString())); //Finds the item index

lstString[j] = lstString[j].Replace(valueFieldValue.ToString(), value.ToString()); //Replaces the item by new value

Question 8

আপনি পরবর্তী এক্সটেনশানগুলি ব্যবহার করতে পারেন যা একটি পূর্বাভাস শর্তের উপর ভিত্তি করে:

    /// <summary>
    /// Find an index of a first element that satisfies <paramref name="match"/>
    /// </summary>
    /// <typeparam name="T">Type of elements in the source collection</typeparam>
    /// <param name="this">This</param>
    /// <param name="match">Match predicate</param>
    /// <returns>Zero based index of an element. -1 if there is not such matches</returns>
    public static int IndexOf<T>(this IList<T> @this, Predicate<T> match)
    {
        @this.ThrowIfArgumentIsNull();
        match.ThrowIfArgumentIsNull();

        for (int i = 0; i < @this.Count; ++i)
            if (match(@this[i]))
                return i;

        return -1;
    }

    /// <summary>
    /// Replace the first occurance of an oldValue which satisfies the <paramref name="removeByCondition"/> by a newValue
    /// </summary>
    /// <typeparam name="T">Type of elements of a target list</typeparam>
    /// <param name="this">Source collection</param>
    /// <param name="removeByCondition">A condition which decides is a value should be replaced or not</param>
    /// <param name="newValue">A new value instead of replaced</param>
    /// <returns>This</returns>
    public static IList<T> Replace<T>(this IList<T> @this, Predicate<T> replaceByCondition, T newValue)
    {
        @this.ThrowIfArgumentIsNull();
        removeByCondition.ThrowIfArgumentIsNull();

        int index = @this.IndexOf(replaceByCondition);
        if (index != -1)
            @this[index] = newValue;

        return @this;
    }

    /// <summary>
    /// Replace all occurance of values which satisfy the <paramref name="removeByCondition"/> by a newValue
    /// </summary>
    /// <typeparam name="T">Type of elements of a target list</typeparam>
    /// <param name="this">Source collection</param>
    /// <param name="removeByCondition">A condition which decides is a value should be replaced or not</param>
    /// <param name="newValue">A new value instead of replaced</param>
    /// <returns>This</returns>
    public static IList<T> ReplaceAll<T>(this IList<T> @this, Predicate<T> replaceByCondition, T newValue)
    {
        @this.ThrowIfArgumentIsNull();
        removeByCondition.ThrowIfArgumentIsNull();

        for (int i = 0; i < @this.Count; ++i)
            if (replaceByCondition(@this[i]))
                @this[i] = newValue;

        return @this;
    }

নোটস: - থ্রোএফআরগমেন্টমেন্টস নাল এক্সটেনশনের পরিবর্তে আপনি সাধারণ পদ্ধতির মতো ব্যবহার করতে পারেন:

if (argName == null) throw new ArgumentNullException(nameof(argName));

সুতরাং এই এক্সটেনশনগুলির সাথে আপনার কেস হিসাবে সমাধান করা যেতে পারে:

string targetString = valueFieldValue.ToString();
listofelements.Replace(x => x.Equals(targetString), value.ToString());

Question 9

আমি এটি সেরা বা না তা না করে তবে আপনি এটি ব্যবহার করতে পারেন

List<string> data = new List<string>
(new string[]   { "Computer", "A", "B", "Computer", "B", "A" });
int[] indexes = Enumerable.Range(0, data.Count).Where
                 (i => data[i] == "Computer").ToArray();
Array.ForEach(indexes, i => data[i] = "Calculator");

Question 10

অথবা, রুশিয়ান এল এর পরামর্শ অনুযায়ী আপনি যে আইটেমটি অনুসন্ধান করছেন তা যদি তালিকার একাধিকবার হতে পারে তবে ::

[Extension()]
public void ReplaceAll<T>(List<T> input, T search, T replace)
{
    int i = 0;
    do {
        i = input.FindIndex(i, s => EqualityComparer<T>.Default.Equals(s, search));

        if (i > -1) {
            FileSystem.input(i) = replace;
            continue;
        }

        break;  
    } while (true);
}

Question 11

আপনি এইভাবে ল্যাম্বডা এক্সপ্রেশন ব্যবহার করতে পারেন।

int index = listOfElements.FindIndex(item => item.Id == id);  
if (index != -1) 
{
    listOfElements[index] = newValue;
}

Question 12

আমি এটি দ্রুত এবং সহজ করার জন্য সবচেয়ে ভাল খুঁজে পাই

তালিকায় আপনার আইটেম সন্ধান করুন
```
var d = Details.Where(x => x.ProductID == selectedProduct.ID).SingleOrDefault();
```
বর্তমান থেকে ক্লোন তৈরি করুন
```
OrderDetail dd = d;
```
আপনার ক্লোন আপডেট করুন
```
dd.Quantity++;
```
তালিকায় সূচকটি সন্ধান করুন
```
int idx = Details.IndexOf(d);
```
প্রতিষ্ঠিত আইটেমটি সরান (1)
```
  Details.Remove(d);
```

.োকান

 if (idx > -1)
      Details.Insert(idx, dd);
  else
      Details.Insert(Details.Count, dd);