LINQ ব্যবহার করে কোনও সংগ্রহের সমস্ত অবজেক্ট আপডেট করুন


498

লিনকিউ ব্যবহার করে নীচের উপায়গুলি কী?

foreach (var c in collection)
{
    c.PropertyToSet = value;
}

স্পষ্ট করার জন্য, আমি সংগ্রহের প্রতিটি বস্তুর মাধ্যমে পুনরাবৃত্তি করতে চাই এবং তারপরে প্রতিটি বস্তুর একটি বৈশিষ্ট্য আপডেট করতে চাই।

আমার ব্যবহারের ক্ষেত্রে হ'ল আমার একটি ব্লগ পোস্টে বেশ কিছু মন্তব্য রয়েছে এবং আমি একটি ব্লগ পোস্টে প্রতিটি মন্তব্যে পুনরাবৃত্তি করতে এবং ব্লগ পোস্টে তারিখের সময়টি +10 ঘন্টা নির্ধারণ করতে চাই। আমি এটি এসকিউএলে করতে পারি, তবে আমি এটি ব্যবসায়ের স্তরে রাখতে চাই।


14
আকর্ষণীয় প্রশ্ন। ব্যক্তিগতভাবে আমি পছন্দ করি আপনি কীভাবে এটি উপরে পেয়েছেন - কী চলছে তা আরও পরিষ্কার!
নোবেলাস

8
আমি এখানে একই প্রশ্নের উত্তরের সন্ধান করতে এসেছি এবং স্থির করেছি যে ভবিষ্যতে বিকাশকারীদের পক্ষে ওপি তে আপনি যেভাবে করেছিলেন ঠিক তেমনই করা সহজ, কম কোড এবং সহজ বোঝা understand
কেসি ক্রুকস্টন

4
আপনি এটি লিনকিতে করতে চান কেন?
ক্যালটার 14

13
এই প্রশ্নটি ভুল জিনিসটির জন্য জিজ্ঞাসা করে, এর একমাত্র সঠিক উত্তর:
ডেটাসোর্সটি

আমি এই প্রশ্নটিকে অফ-টপিক হিসাবে বন্ধ করতে ভোট দিচ্ছি কারণ এই প্রশ্নের প্রায় সমস্ত উত্তর সক্রিয়ভাবে নতুন প্রোগ্রামারদের লিনকিউ সম্পর্কে বোঝার জন্য ক্ষতিকারক।
তানভীর বদর

উত্তর:


840

আপনি যখন কোনও ForEachএক্সটেনশন পদ্ধতি ব্যবহার করতে পারেন , আপনি যদি করতে পারেন তবে কেবল ফ্রেমওয়ার্ক ব্যবহার করতে পারেন

collection.Select(c => {c.PropertyToSet = value; return c;}).ToList();

ToListআদেশের কারণে অবিলম্বে নির্বাচন নির্ণয় করা প্রয়োজন হয় অলস মূল্যায়ন


6
আমি এই upvoted কারণ এটি একটি বেশ সুন্দর সমাধান ... একমাত্র কারণ আমি এক্সটেনশন পদ্ধতি মত এটি এটা একটু পরিস্কার বুঝতে ঠিক কি উপর ... তবে আপনার সমাধান এখনও বেশ মিষ্টি যাচ্ছে তোলে
lomaxx

9
যদি সংগ্রহটি ObservableCollectionবলার মতো হয়, তবে নতুন তালিকা তৈরি করার পরিবর্তে আইটেমগুলি জায়গায় রেখে দেওয়া কার্যকর হতে পারে।
ক্যামেরন ম্যাকফারল্যান্ড

7
@ দেসাইভভ হ্যাঁ এটি একটি সিনট্যাক্স অপব্যবহারের কিছুটা, তাই রেশার্পার আপনাকে এ সম্পর্কে সতর্ক করে দিচ্ছে।
ক্যামেরন ম্যাকফারল্যান্ড

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

37
এই উত্তরটি সবচেয়ে খারাপ অনুশীলন। এটি কখনও করবেন না।
এরিক লিপার্ট

351
collection.ToList().ForEach(c => c.PropertyToSet = value);

36
@ সন্তোষকুমার: ব্যবহার করুনcollection.ToList().ForEach(c => { c.Property1ToSet = value1; c.Property2ToSet = value2; });
Г И І И О

@ ক্যামেরনম্যাকফারল্যান্ড: অবশ্যই স্ট্রাক্টগুলি পরিবর্তনযোগ্য না হওয়ার কারণে এটি হবে না। তবে আপনি যদি সত্যিই চান তবে আপনি এটি করতে পারেন:collection.ToList().ForEach(c => { collection[collection.IndexOf(c)] = new <struct type>() { <propertyToSet> = value, <propertyToRetain> = c.Property2Retain }; });
Ε Г И І И О

11
ক্যামেরন ম্যাকফারল্যান্ডের নতুন তালিকা তৈরির পরিবর্তে তালিকার জায়গায় আপডেট করার জবাব পেয়ে এর সুবিধা রয়েছে।
সাইমন তেউসি

7
বাহ, এই উত্তরটি আসলে কার্যকর নয়। একটি লুপ ব্যবহার করতে সক্ষম হতে একটি নতুন সংগ্রহ তৈরি করা হচ্ছে
টিম শ্মেলেটার

@ সিমোনটিউজি যেহেতু এটি বস্তুর সংগ্রহ, সুতরাং তালিকাটি যেভাবেই হোক আপডেট করা উচিত। সংগ্রহটি নতুন হবে তবে সংগ্রহের বিষয়গুলি একই থাকবে be
ক্রিস

70

আমি এই কাজ করছি

Collection.All(c => { c.needsChange = value; return true; });

আমি মনে করি এটি এটি করার সবচেয়ে পরিষ্কার উপায়।
ডাব্লুএমসি

31
এই পদ্ধতির অবশ্যই কাজ করে কিন্তু এটি All()এক্সটেনশন পদ্ধতির উদ্দেশ্য লঙ্ঘন করে , অন্য কেউ কোড পড়লে সম্ভাব্য বিভ্রান্তির সৃষ্টি করে।
টম

এই পদ্ধতিটি আরও ভাল each প্রতিটি লুপ ব্যবহারের পরিবর্তে সকলের ব্যবহার করুন
ইউজেএস

2
এটি অযৌক্তিকভাবে টোললিস্ট () কল করার চেয়ে অবশ্যই এটিকে অগ্রাধিকার দিন, এমনকি এটি সমস্ত () কী ব্যবহার করছে তা সম্পর্কে কিছুটা বিভ্রান্তিকর হলেও।
iupchris10

1
আপনি যদি এর মতো সংগ্রহ ব্যবহার List<>করেন তবে ForEach()পদ্ধতিটি এটি সম্পাদন করার জন্য খুব কম ক্রিপ্টিক উপায়। প্রাক্তনForEach(c => { c.needsChange = value; })
ড্যান ইজ ফায়ডলিং ফায়ারলাইট

27

আমি প্রকৃতপক্ষে একটি এক্সটেনশন পদ্ধতি পেয়েছি যা আমি যা চাই সুন্দরভাবে করব

public static IEnumerable<T> ForEach<T>(
    this IEnumerable<T> source,
    Action<T> act)
{
    foreach (T element in source) act(element);
    return source;
}

4
সুন্দর :) লোমাএক্সএক্স, সম্ভবত একটি উদাহরণ যুক্ত করুন যাতে উঁকি দেওয়া লোকেরা এটি 'অ্যাকশন' (বুম টিশ!) এ দেখতে পারে।
বিশুদ্ধ.ক্রোম

2
আপনি যদি সত্যিই একটি foreachলুপ এড়িয়ে চলতে চান (তবে যে কোনও কারণেই হোক) তবে এটি কেবলমাত্র কার্যকর উপায় approach
টিম শ্মেলেটার

@ র্যাংগো যা আপনি এখনও এড়ানো যাচ্ছেন না foreachকারণ foreach
কোডটিতে

@ গোল্ডবিশপ নিশ্চিত, পদ্ধতিটি লুপটি আড়াল করে।
টিম শেমলেটার

1
লিঙ্কটি নষ্ট হয়ে গেছে, এটি এখন পাওয়া যাবে: কোডউইরকস.ব্লগ / ইন্ডেক্স.এফপি / ২০০৮ / 08 / 13/… । এখানে একটি ব্লগের মন্তব্যও রয়েছে যা স্ট্যাকওভারফ্লো / প্রশ্নগুলি / ২০০৫74৪ এর লিঙ্ক । ঘুরেফিরে , শীর্ষস্থানীয় প্রশ্ন মন্তব্যগুলি ব্লগস.এমএসএনএন.মাইক্রোসফট . / মাইক্রোসফট . / এসিক্লিপার্ট/2009/05/18/… এ লিঙ্ক করেছে । সম্ভবত উত্তরটি এমএসডিএন ব্যবহার করে পুনরায় লিখিত হবে (আপনি যদি চান তবে আপনি প্রথম লিঙ্কটি জমা দিতে পারেন)। Sidenote: মরচে অনুরূপ বৈশিষ্ট্য আছে, এবং শেষ পর্যন্ত দিলাম এবং যোগ সমতুল্য ফাংশন: stackoverflow.com/a/50224248/799204
sourcejedi

14

ব্যবহার করুন:

ListOfStuff.Where(w => w.Thing == value).ToList().ForEach(f => f.OtherThing = vauleForNewOtherThing);

আমি নিশ্চিত না যে এটি লিনকিউকে অতিরিক্ত ব্যবহার করছে বা না, তবে নির্দিষ্ট শর্তের জন্য তালিকায় নির্দিষ্ট আইটেম আপডেট করতে চাইলে এটি আমার পক্ষে কাজ করেছে।


7

এটি করার জন্য কোনও বিল্ট-ইন এক্সটেনশন পদ্ধতি নেই। যদিও একজনকে সংজ্ঞা দেওয়া মোটামুটি সোজা এগিয়ে। পোস্টের নীচে একটি পদ্ধতি যা আমি Iterate নামে সংজ্ঞায়িত করেছি। এটি যেমন ব্যবহার করা যেতে পারে

collection.Iterate(c => { c.PropertyToSet = value;} );

উত্স উত্স

public static void Iterate<T>(this IEnumerable<T> enumerable, Action<T> callback)
{
    if (enumerable == null)
    {
        throw new ArgumentNullException("enumerable");
    }

    IterateHelper(enumerable, (x, i) => callback(x));
}

public static void Iterate<T>(this IEnumerable<T> enumerable, Action<T,int> callback)
{
    if (enumerable == null)
    {
        throw new ArgumentNullException("enumerable");
    }

    IterateHelper(enumerable, callback);
}

private static void IterateHelper<T>(this IEnumerable<T> enumerable, Action<T,int> callback)
{
    int count = 0;
    foreach (var cur in enumerable)
    {
        callback(cur, count);
        count++;
    }
}

আইট্রেট কি প্রয়োজনীয়, কাউন্ট, সম, গড় বা অন্যান্য বিদ্যমান এক্সটেনশন পদ্ধতিতে কী ভুল যা কোনও স্কেলারের মান দেয়?
অ্যান্টনিডব্লু জোন্স

2
এটি আমি যা চাই তার কাছাকাছি কিন্তু একটি সামান্য .. জড়িত। আমি পোস্ট করা ব্লগ পোস্টটির একই বাস্তবায়ন রয়েছে তবে কোডের কম লাইন রয়েছে।
lomaxx

1
আইট্রেটহেল্পারকে ওভারকিল মনে হচ্ছে। কোনও ওভারলোড যা সূচক নেয় না তা আরও অনেক বেশি কাজ করে শেষ হয় (কলম্ব্যাককে ল্যাম্বডায় রূপান্তর করে যা সূচক নেয়, একটি গণনা রাখুন যা কখনই ব্যবহৃত হয় না)। আমি বুঝতে পারি এটির পুনঃব্যবহার, তবে এটি যেভাবেই হোক কেবল একটি ললুপ ব্যবহার করার জন্য এটি একটি কার্যকরী বিষয় যাতে এটি দক্ষ হওয়া উচিত।
ক্যামেরন ম্যাকফারল্যান্ড 23

2
@ ক্যামেরন, আইট্রেটহেল্পার 2 উদ্দেশ্যে কাজ করে। 1) একক বাস্তবায়ন এবং 2) কল টাইম বনাম ব্যবহারের সময় আর্গুমেন্টনাল এক্সসেপশন নিক্ষেপ করার অনুমতি দেয়। সি # পুনরাবৃত্তিকে মৃত্যুদন্ড কার্যকর করতে বিলম্ব হয়, সাহায্যকারী থাকার কারণে পুনরাবৃত্তির সময় নিক্ষিপ্ত হওয়া ব্যতিক্রমের অদ্ভুত আচরণকে বাধা দেয়।
জেয়ার্ডপাড়

2
@ জারেডপার: আপনি যদি কোনও পুনরায় ব্যবহারকারীর ব্যবহার না করেন তবে। কোনও ফলনের বিবৃতি নেই।
ক্যামেরন ম্যাকফারল্যান্ড

7

যদিও আপনি নির্দিষ্টভাবে একটি লিনকিউ সমাধানের জন্য বলেছেন এবং এই প্রশ্নটি বেশ পুরনো আমি একটি লিনকিউ-সমাধান পোস্ট করি না। এর কারণ হল LINQ (= ভাষা সংহতিপূর্ণ ক্যোয়ারী ) সংগ্রহের উপর প্রশ্নের জন্য ব্যবহার করা হবে বোঝানো হয়। সমস্ত লিনকুই-পদ্ধতি অন্তর্নিহিত সংগ্রহটি সংশোধন করে না, তারা কেবলমাত্র একটি নতুন ফিরিয়ে দেয় (বা একটি নতুন সংকলনে আরও সঠিকভাবে একটি পুনরাবৃত্তকারী)। সুতরাং আপনি উদাহরণস্বরূপ যা কিছু Selectকরেন তা অন্তর্নিহিত সংগ্রহকে প্রভাবিত করে না, আপনি কেবল নতুন একটি পান।

অবশ্যই আপনি এটি দিয়ে করতে পারেন ForEach(যা লিনকুই নয়, তবে কোনও এক্সটেনশন List<T>)। তবে এটি আক্ষরিকভাবেforeach যাইহোক, তবে ল্যাম্বডা-এক্সপ্রেশন সহ ব্যবহার করে। এগুলি ছাড়াও প্রতিটি লিনকুই পদ্ধতি অভ্যন্তরীণভাবে আপনার সংগ্রহকে পুনরায় করে যেমন ব্যবহার করে foreachবা এর মাধ্যমেfor তবে এটি কেবল ক্লায়েন্টের কাছ থেকে এটি লুকিয়ে রাখে। আমি এটিকে আর পঠনযোগ্য বা রক্ষণাবেক্ষণযোগ্য বিবেচনা করব না (ল্যাম্বডা-এক্সপ্রেশনযুক্ত কোনও পদ্ধতি ডিবাগ করার সময় আপনার কোড সম্পাদনা করার কথা ভাবেন)।

বলার পরে এটি আপনার সংগ্রহে আইটেমগুলি সংশোধন করতে লিনকিউ ব্যবহার করা উচিত নয় । আপনার প্রশ্নের মধ্যে ইতিমধ্যে সরবরাহ করা সমাধানের একটি আরও ভাল উপায়। একটি ক্লাসিক লুপের সাহায্যে আপনি সহজেই আপনার সংগ্রহটিকে পুনরাবৃত্তি করতে এবং এর আইটেমগুলি আপডেট করতে পারেন। প্রকৃতপক্ষে এই সমস্ত সমাধানগুলির উপর নির্ভর করে List.ForEachকিছু আলাদা নয়, তবে আমার দৃষ্টিকোণ থেকে পড়া আরও শক্ত।

সুতরাং যেখানে আপনি আপনার সংগ্রহের উপাদানগুলি আপডেট করতে চান সে ক্ষেত্রে আপনার লিনকউ ব্যবহার করা উচিত নয় ।


3
অফ-টপিক: আমি সম্মত, এবং লিনকিউ-এর অপব্যবহারের অনেক উদাহরণ রয়েছে, লোকেরা "উচ্চ কার্যকারিতা লিনকুই চেইন" র অনুরোধ করে, একটি লুপ দিয়ে কী অর্জন করা যায় ইত্যাদি করার জন্য আমি উদাহরণস্বরূপ, আমি ধন্যবাদ জানাই যে লিনকিউ ব্যবহার না করা হয় আমার মধ্যে খুব জড়িত, এবং সাধারণত এটি ব্যবহার করবেন না। আমি লিনকিউ চেইনগুলি ব্যবহার করে একটি একক ক্রিয়া সম্পাদন করতে দেখছি, যখনই লিনকিউ কমান্ড ব্যবহার করা হয় আপনি for"হুডের নীচে" অন্য একটি লুপ তৈরি করছেন তা বুঝতে পারছেন না । আমি সাধারন কোডিংয়ের প্রতিস্থাপন না হয়ে সাধারণ কাজগুলি করার কম ভার্বোজ উপায় তৈরি করা সিনট্যাটিক চিনির অনুভব করছি।
ForeverZer0

6

আমি এটিতে কয়েকটি বৈকল্পিক চেষ্টা করেছি এবং আমি এই লোকটির সমাধানে ফিরে যেতে চাই।

http://www.hookedonlinq.com/UpdateOperator.ashx

আবার, এটি অন্য কারও সমাধান। তবে আমি কোডটি একটি ছোট লাইব্রেরিতে সংকলন করেছি এবং এটি নিয়মিত ব্যবহার করি।

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

    public static class UpdateExtensions {

    public delegate void Func<TArg0>(TArg0 element);

    /// <summary>
    /// Executes an Update statement block on all elements in an IEnumerable<T> sequence.
    /// </summary>
    /// <typeparam name="TSource">The source element type.</typeparam>
    /// <param name="source">The source sequence.</param>
    /// <param name="update">The update statement to execute for each element.</param>
    /// <returns>The numer of records affected.</returns>
    public static int Update<TSource>(this IEnumerable<TSource> source, Func<TSource> update)
    {
        if (source == null) throw new ArgumentNullException("source");
        if (update == null) throw new ArgumentNullException("update");
        if (typeof(TSource).IsValueType)
            throw new NotSupportedException("value type elements are not supported by update.");

        int count = 0;
        foreach (TSource element in source)
        {
            update(element);
            count++;
        }
        return count;
    }
}



int count = drawingObjects
        .Where(d => d.IsSelected && d.Color == Colors.Blue)
        .Update(e => { e.Color = Color.Red; e.Selected = false; } );

1
Action<TSource>অতিরিক্ত প্রতিনিধি তৈরির পরিবর্তে আপনি একটি ব্যবহার করতে পারেন । যদিও এটি লেখার সময় হিসাবে এটি উপলব্ধ ছিল না।
ফ্রাঙ্ক জে

হ্যাঁ, এটি সেই সময়টিতে পুরানো স্কুল ডটনেট ছিল। ভাল মন্তব্য ফ্র্যাঙ্ক।
গ্রানাডা কোডার

ইউআরএল মারা গেছে! (এই ডোমেন নামটির মেয়াদ শেষ হয়ে গেছে) ভাল জিনিস আমি কোডটি এখানে অনুলিপি করেছি! # পাটঅনশোল্ডার
গ্রানাডা কোডার

1
মান প্রকারের জন্য যাচাই করা অর্থপূর্ণ, তবে সম্ভবত এটি একটি where T: structসঙ্কলন করার সময়, এটি সংকলনের সময় ধরা ভাল।
গ্রু

4

না, লিনকিউ একসাথে বড় বড় আপডেট করার পক্ষে সমর্থন করে না। একমাত্র সংক্ষিপ্ত উপায়টি হ'ল একটি ForEachএক্সটেনশন পদ্ধতি ব্যবহার করা - কেন আইএনউমারেবলের জন্য কোনও ফোরইচ এক্সটেনশন পদ্ধতি নেই?


3

এটি থেকে আমাকে সাহায্য করার জন্য আমি কিছু এক্সটেনশন পদ্ধতি লিখেছি।

namespace System.Linq
{
    /// <summary>
    /// Class to hold extension methods to Linq.
    /// </summary>
    public static class LinqExtensions
    {
        /// <summary>
        /// Changes all elements of IEnumerable by the change function
        /// </summary>
        /// <param name="enumerable">The enumerable where you want to change stuff</param>
        /// <param name="change">The way you want to change the stuff</param>
        /// <returns>An IEnumerable with all changes applied</returns>
        public static IEnumerable<T> Change<T>(this IEnumerable<T> enumerable, Func<T, T> change  )
        {
            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
            ArgumentCheck.IsNullorWhiteSpace(change, "change");

            foreach (var item in enumerable)
            {
                yield return change(item);
            }
        }

        /// <summary>
        /// Changes all elements of IEnumerable by the change function, that fullfill the where function
        /// </summary>
        /// <param name="enumerable">The enumerable where you want to change stuff</param>
        /// <param name="change">The way you want to change the stuff</param>
        /// <param name="where">The function to check where changes should be made</param>
        /// <returns>
        /// An IEnumerable with all changes applied
        /// </returns>
        public static IEnumerable<T> ChangeWhere<T>(this IEnumerable<T> enumerable, 
                                                    Func<T, T> change,
                                                    Func<T, bool> @where)
        {
            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
            ArgumentCheck.IsNullorWhiteSpace(change, "change");
            ArgumentCheck.IsNullorWhiteSpace(@where, "where");

            foreach (var item in enumerable)
            {
                if (@where(item))
                {
                    yield return change(item);
                }
                else
                {
                    yield return item;
                }
            }
        }

        /// <summary>
        /// Changes all elements of IEnumerable by the change function that do not fullfill the except function
        /// </summary>
        /// <param name="enumerable">The enumerable where you want to change stuff</param>
        /// <param name="change">The way you want to change the stuff</param>
        /// <param name="where">The function to check where changes should not be made</param>
        /// <returns>
        /// An IEnumerable with all changes applied
        /// </returns>
        public static IEnumerable<T> ChangeExcept<T>(this IEnumerable<T> enumerable,
                                                     Func<T, T> change,
                                                     Func<T, bool> @where)
        {
            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
            ArgumentCheck.IsNullorWhiteSpace(change, "change");
            ArgumentCheck.IsNullorWhiteSpace(@where, "where");

            foreach (var item in enumerable)
            {
                if (!@where(item))
                {
                    yield return change(item);
                }
                else
                {
                    yield return item;
                }
            }
        }

        /// <summary>
        /// Update all elements of IEnumerable by the update function (only works with reference types)
        /// </summary>
        /// <param name="enumerable">The enumerable where you want to change stuff</param>
        /// <param name="update">The way you want to change the stuff</param>
        /// <returns>
        /// The same enumerable you passed in
        /// </returns>
        public static IEnumerable<T> Update<T>(this IEnumerable<T> enumerable,
                                               Action<T> update) where T : class
        {
            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
            ArgumentCheck.IsNullorWhiteSpace(update, "update");
            foreach (var item in enumerable)
            {
                update(item);
            }
            return enumerable;
        }

        /// <summary>
        /// Update all elements of IEnumerable by the update function (only works with reference types)
        /// where the where function returns true
        /// </summary>
        /// <param name="enumerable">The enumerable where you want to change stuff</param>
        /// <param name="update">The way you want to change the stuff</param>
        /// <param name="where">The function to check where updates should be made</param>
        /// <returns>
        /// The same enumerable you passed in
        /// </returns>
        public static IEnumerable<T> UpdateWhere<T>(this IEnumerable<T> enumerable,
                                               Action<T> update, Func<T, bool> where) where T : class
        {
            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
            ArgumentCheck.IsNullorWhiteSpace(update, "update");
            foreach (var item in enumerable)
            {
                if (where(item))
                {
                    update(item);
                }
            }
            return enumerable;
        }

        /// <summary>
        /// Update all elements of IEnumerable by the update function (only works with reference types)
        /// Except the elements from the where function
        /// </summary>
        /// <param name="enumerable">The enumerable where you want to change stuff</param>
        /// <param name="update">The way you want to change the stuff</param>
        /// <param name="where">The function to check where changes should not be made</param>
        /// <returns>
        /// The same enumerable you passed in
        /// </returns>
        public static IEnumerable<T> UpdateExcept<T>(this IEnumerable<T> enumerable,
                                               Action<T> update, Func<T, bool> where) where T : class
        {
            ArgumentCheck.IsNullorWhiteSpace(enumerable, "enumerable");
            ArgumentCheck.IsNullorWhiteSpace(update, "update");

            foreach (var item in enumerable)
            {
                if (!where(item))
                {
                    update(item);
                }
            }
            return enumerable;
        }
    }
}

আমি এটি এর মতো ব্যবহার করছি:

        List<int> exampleList = new List<int>()
            {
                1, 2 , 3
            };

        //2 , 3 , 4
        var updated1 = exampleList.Change(x => x + 1);

        //10, 2, 3
        var updated2 = exampleList
            .ChangeWhere(   changeItem => changeItem * 10,          // change you want to make
                            conditionItem => conditionItem < 2);    // where you want to make the change

        //1, 0, 0
        var updated3 = exampleList
            .ChangeExcept(changeItem => 0,                          //Change elements to 0
                          conditionItem => conditionItem == 1);     //everywhere but where element is 1

রেফারেন্সের জন্য আর্গুমেন্ট চেক:

/// <summary>
/// Class for doing argument checks
/// </summary>
public static class ArgumentCheck
{


    /// <summary>
    /// Checks if a value is string or any other object if it is string
    /// it checks for nullorwhitespace otherwhise it checks for null only
    /// </summary>
    /// <typeparam name="T">Type of the item you want to check</typeparam>
    /// <param name="item">The item you want to check</param>
    /// <param name="nameOfTheArgument">Name of the argument</param>
    public static void IsNullorWhiteSpace<T>(T item, string nameOfTheArgument = "")
    {

        Type type = typeof(T);
        if (type == typeof(string) ||
            type == typeof(String))
        {
            if (string.IsNullOrWhiteSpace(item as string))
            {
                throw new ArgumentException(nameOfTheArgument + " is null or Whitespace");
            }
        }
        else
        {
            if (item == null)
            {
                throw new ArgumentException(nameOfTheArgument + " is null");
            }
        }

    }
}

2

আমার 2 পেনি:

 collection.Count(v => (v.PropertyToUpdate = newValue) == null);

7
আমি চিন্তাভাবনাটি পছন্দ করি, তবে কোডটি কী করছে তা সত্যিই পরিষ্কার নয়
লমএক্সএক্স

2

আপনি আপনার সংগ্রহকে একটি অ্যারেতে রূপান্তর করতে লিনকিউ ব্যবহার করতে পারেন এবং তারপরে অ্যারে অনুরোধ করতে পারেন For

Array.ForEach(MyCollection.ToArray(), item=>item.DoSomeStuff());

স্পষ্টতই এটি স্ট্রাক্ট বা ইনবিল্ট প্রকারের পূর্ণসংখ্যা বা স্ট্রিংয়ের সংগ্রহের সাথে কাজ করবে না।


1

আমি যে এক্সটেনশন পদ্ধতিটি ব্যবহার করি তা এখানে ...

    /// <summary>
    /// Executes an Update statement block on all elements in an  IEnumerable of T
    /// sequence.
    /// </summary>
    /// <typeparam name="TSource">The source element type.</typeparam>
    /// <param name="source">The source sequence.</param>
    /// <param name="action">The action method to execute for each element.</param>
    /// <returns>The number of records affected.</returns>
    public static int Update<TSource>(this IEnumerable<TSource> source, Func<TSource> action)
    {
        if (source == null) throw new ArgumentNullException("source");
        if (action == null) throw new ArgumentNullException("action");
        if (typeof (TSource).IsValueType)
            throw new NotSupportedException("value type elements are not supported by update.");

        var count = 0;
        foreach (var element in source)
        {
            action(element);
            count++;
        }
        return count;
    }

কেন "মান ধরণের উপাদানগুলি আপডেট দ্বারা সমর্থিত হয় না" ?? কিছুই যে হস্তক্ষেপ!
abatishchev

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

এটি কমবেশি যা List<T>.ForEachকরে তা কিন্তু কেবল সবার জন্য IEnumerable
হিমব্র্যামবিয়ার

এখন এইটির দিকে ফিরে তাকালে আমি বলব যে কেবল একটি ফোরচ লুপ ব্যবহার করুন। এই জাতীয় কিছু ব্যবহারের একমাত্র উপকারিতা হ'ল যদি আপনি পদ্ধতিগুলি একসাথে চেইন করতে চান এবং ক্রিয়াটি কার্যকর করার পরে শৃঙ্খলা চালিয়ে যাওয়ার জন্য ফাংশন থেকে অগণিতকে ফিরিয়ে দিতে চান। অন্যথায় এটি কোনও সুবিধার জন্য কেবল একটি অতিরিক্ত পদ্ধতির কল।
বিল ফোর্নি

0

আমি ধরে নিয়েছি যে আপনি কোনও প্রশ্নের ভিতরে মান পরিবর্তন করতে চান যাতে আপনি এটির জন্য একটি ফাংশন লিখতে পারেন

void DoStuff()
{
    Func<string, Foo, bool> test = (y, x) => { x.Bar = y; return true; };
    List<Foo> mylist = new List<Foo>();
    var v = from x in mylist
            where test("value", x)
            select x;
}

class Foo
{
    string Bar { get; set; }
}

আপনি কি বলতে চান এটি তবে শুর করবেন না।


এটি সঠিক দিকের অনুসারে চলে যাচ্ছে এর জন্য v গণনার জন্য কিছু প্রয়োজন হবে, অন্যথায় এটি কিছুই করবে না।
অ্যান্থনিডব্লু জোনস


-3

ধরুন আমাদের কাছে নীচের মতো ডেটা রয়েছে,

var items = new List<string>({"123", "456", "789"});
// Like 123 value get updated to 123ABC ..

এবং যদি আমরা তালিকাটি সংশোধন করতে এবং তালিকার বিদ্যমান মানগুলিকে পরিবর্তিত মানগুলিতে প্রতিস্থাপন করতে চাই, তবে প্রথমে একটি নতুন খালি তালিকা তৈরি করুন, তারপরে প্রতিটি তালিকার আইটেমের পরিবর্তনের পদ্ধতিটি উপস্থাপন করে ডেটা তালিকার মধ্য দিয়ে লুপ করুন,

var modifiedItemsList = new List<string>();

items.ForEach(i => {
  var modifiedValue = ModifyingMethod(i);
  modifiedItemsList.Add(items.AsEnumerable().Where(w => w == i).Select(x => modifiedValue).ToList().FirstOrDefault()?.ToString()) 
});
// assign back the modified list
items = modifiedItemsList;

2
ও (এন) রানটাইম ওরে চালিত করতে পারে এমন কোনও কিছু আপনি কেন তৈরি করবেন (এন run 2) বা আরও খারাপ? আইএম কীভাবে লিনাকের কাজগুলি নির্দিষ্ট করে তা সম্পর্কে অসচেতন তবে আমি দেখতে পাচ্ছি এটি একটি এন সমস্যাটির জন্য কমপক্ষে একটি ^ 2 সমাধান ।
ফ্যালেনেরেপার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.