c# জেনেরিক তালিকা-তালিকার মধ্যে একটি আইটেম চলন্ত



.net generics (8)

var item = list[oldIndex];

list.RemoveAt(oldIndex);

if (newIndex > oldIndex) newIndex--; 
// the actual index could have shifted due to the removal

list.Insert(newIndex, item);

সুতরাং আমার একটি জেনেরিক তালিকা আছে, এবং একটি oldIndex এবং একটি নতুন newIndex মান।

আমি oldIndex , নতুন oldIndex আইটেমটিকে oldIndex newIndex ... যত সহজে সম্ভব।

কোনও পরামর্শ?

বিঃদ্রঃ

আইটেমটিকে (newIndex - 1) এবং নতুন newIndex আইটেমগুলির মধ্যে শেষ হওয়া উচিত তা সরিয়ে newIndex আগে


Answer #1

আমি জানি আপনি "জেনেরিক লিস্ট" বলেছিলেন তবে আপনি তালিকাটি (টি) ক্লাসটি ব্যবহার করার জন্য আপনাকে নির্দিষ্ট করতে নির্দিষ্ট করে নি তাই এখানে অন্য কিছুতে একটি শট।

ObservableCollection (T) ক্লাসে একটি মুভ পদ্ধতি রয়েছে যা আপনি চান তা ঠিক করে।

public void Move(int oldIndex, int newIndex)

নীচে এটি মূলত এই মত প্রয়োগ করা হয়।

T item = base[oldIndex];
base.RemoveItem(oldIndex);
base.InsertItem(newIndex, item);

তাই আপনি অন্য যে প্রস্তাবিত সোয়াপ পদ্ধতিটি দেখতে পারেন তা অবশ্যই তার নিজের মুভ পদ্ধতিতে পর্যবেক্ষনকোল্লিশনটি যা করে তা অবশ্যই অপরিহার্য।

আপডেট 2015-12-30: আপনি ফ্র্যাফ্লেট / ILSpy ব্যবহার না করে এখন নিজের জন্য কোরফক্সে Move এবং MoveItem পদ্ধতিগুলির জন্য উৎস কোডটি দেখতে পারেন। নেটটি ওপেন সোর্স।


Answer #2

আমি কিভাবে একটি সরানো উপাদান এক্সটেনশন পদ্ধতি বাস্তবায়িত হয়। এটা বেশ ভাল উপাদানের জন্য পূর্বে / পরে এবং চরমের জন্য চলন্ত পরিচালনা।

public static void MoveElement<T>(this IList<T> list, int fromIndex, int toIndex)
{
  if (!fromIndex.InRange(0, list.Count - 1))
  {
    throw new ArgumentException("From index is invalid");
  }
  if (!toIndex.InRange(0, list.Count - 1))
  {
    throw new ArgumentException("To index is invalid");
  }

  if (fromIndex == toIndex) return;

  var element = list[fromIndex];

  if (fromIndex > toIndex)
  {
    list.RemoveAt(fromIndex);
    list.Insert(toIndex, element);
  }
  else
  {
    list.Insert(toIndex + 1, element);
    list.RemoveAt(fromIndex);
  }
}

Answer #3

আরো সহজ ছেলেরা শুধু এই কাজ

    public void MoveUp(object item,List Concepts){

        int ind = Concepts.IndexOf(item.ToString());

        if (ind != 0)
        {
            Concepts.RemoveAt(ind);
            Concepts.Insert(ind-1,item.ToString());
            obtenernombres();
            NotifyPropertyChanged("Concepts");
        }}

MoveDown এর সাথে একই কাজ করুন তবে "if (ind! = Concepts.Count ())" এবং কনসেপ্টস। ইন্সটল করুন (ind + 1, item.ToString ()) এর জন্য যদি পরিবর্তন করুন;


Answer #4

তালিকা <টি> তালিকাভুক্ত করুন। (মুছে ফেলুন) এবং তালিকা <টি>। অপসারণ করুন () অপসারণ করা হচ্ছে এমন আইটেমটি ফেরত না।

অতএব আপনি এই ব্যবহার করতে হবে:

var item = list[oldIndex];
list.RemoveAt(oldIndex);
list.Insert(newIndex, item);

Answer #5

oldIndex বর্তমানে আইটেমটি নতুন newIndex এবং তারপরে মূল উদাহরণটি সরিয়ে নিন।

list.Insert(newIndex, list[oldIndex]);
if (newIndex <= oldIndex) ++oldIndex;
list.RemoveAt(oldIndex);

আপনি যে আইটেমটি সরাতে চান তার সূচী সন্নিবেশের কারণে পরিবর্তিত হতে পারে তা বিবেচনা করতে হবে।


Answer #6

আমি হয় আশা করি:

// Makes sure item is at newIndex after the operation
T item = list[oldIndex];
list.RemoveAt(oldIndex);
list.Insert(newIndex, item);

... বা:

// Makes sure relative ordering of newIndex is preserved after the operation, 
// meaning that the item may actually be inserted at newIndex - 1 
T item = list[oldIndex];
list.RemoveAt(oldIndex);
newIndex = (newIndex > oldIndex ? newIndex - 1, newIndex)
list.Insert(newIndex, item);

... কৌশলটি করবে, কিন্তু আমার কাছে এই মেশিনে ভিসির চেক নেই।


Answer #7

আমি একটি তালিকা আইটেম চলন্ত জন্য একটি এক্সটেনশান পদ্ধতি তৈরি।

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

@ ওলিভারের প্রান্তের ক্ষেত্রে নীচের অংশটি নির্দেশ করে (তালিকার শেষের দিকে একটি আইটেম সরাতে) প্রকৃতপক্ষে পরীক্ষাগুলি ব্যর্থ হতে পারে তবে এটি ডিজাইনের দ্বারা হয়। তালিকা শেষে একটি নতুন আইটেম সন্নিবেশ করতে আমরা কেবল List<T>.Add কল করব। যুক্ত করুন। list.Move(predicate, list.Count) ব্যর্থ হওয়া উচিত কারণ এই সূচক অবস্থান চলার আগে বিদ্যমান নেই।

যে কোনও ক্ষেত্রে, আমি দুটি অতিরিক্ত এক্সটেনশান পদ্ধতি তৈরি করেছি, MoveToEnd এবং MoveToBeginning MoveToEnd MoveToBeginning , যার উৎস here পাওয়া here

/// <summary>
/// Extension methods for <see cref="System.Collections.Generic.List{T}"/>
/// </summary>
public static class ListExtensions
{
    /// <summary>
    /// Moves the item matching the <paramref name="itemSelector"/> to the <paramref name="newIndex"/> in a list.
    /// </summary>
    public static void Move<T>(this List<T> list, Predicate<T> itemSelector, int newIndex)
    {
        Ensure.Argument.NotNull(list, "list");
        Ensure.Argument.NotNull(itemSelector, "itemSelector");
        Ensure.Argument.Is(newIndex >= 0, "New index must be greater than or equal to zero.");

        var currentIndex = list.FindIndex(itemSelector);
        Ensure.That<ArgumentException>(currentIndex >= 0, "No item was found that matches the specified selector.");

        // Copy the current item
        var item = list[currentIndex];

        // Remove the item
        list.RemoveAt(currentIndex);

        // Finally add the item at the new index
        list.Insert(newIndex, item);
    }
}

[Subject(typeof(ListExtensions), "Move")]
public class List_Move
{
    static List<int> list;

    public class When_no_matching_item_is_found
    {
        static Exception exception;

        Establish ctx = () => {
            list = new List<int>();
        };

        Because of = ()
            => exception = Catch.Exception(() => list.Move(x => x == 10, 10));

        It Should_throw_an_exception = ()
            => exception.ShouldBeOfType<ArgumentException>();
    }

    public class When_new_index_is_higher
    {
        Establish ctx = () => {
            list = new List<int> { 1, 2, 3, 4, 5 };
        };

        Because of = ()
            => list.Move(x => x == 3, 4); // move 3 to end of list (index 4)

        It Should_be_moved_to_the_specified_index = () =>
            {
                list[0].ShouldEqual(1);
                list[1].ShouldEqual(2);
                list[2].ShouldEqual(4);
                list[3].ShouldEqual(5);
                list[4].ShouldEqual(3);
            };
    }

    public class When_new_index_is_lower
    {
        Establish ctx = () => {
            list = new List<int> { 1, 2, 3, 4, 5 };
        };

        Because of = ()
            => list.Move(x => x == 4, 0); // move 4 to beginning of list (index 0)

        It Should_be_moved_to_the_specified_index = () =>
        {
            list[0].ShouldEqual(4);
            list[1].ShouldEqual(1);
            list[2].ShouldEqual(2);
            list[3].ShouldEqual(3);
            list[4].ShouldEqual(5);
        };
    }
}




list