বেনাম শ্রেণীর একটি জেনেরিক তালিকা

Question

সি # 3.0 এ আপনি নিম্নলিখিত সিনট্যাক্স সহ বেনাম শ্রেণি তৈরি করতে পারেন

var o = new { Id = 1, Name = "Foo" };

এই বেনাম শ্রেণিকে জেনেরিক তালিকায় যুক্ত করার কোনও উপায় আছে কি?

উদাহরণ:

var o = new { Id = 1, Name = "Foo" };
var o1 = new { Id = 2, Name = "Bar" };

List<var> list = new List<var>();
list.Add(o);
list.Add(o1);

আরেকটি উদাহরণ:

List<var> list = new List<var>();

while (....)
{
    ....
    list.Add(new {Id = x, Name = y});
    ....
}

Comments

নোট করুন যে সমস্ত বস্তু অ্যারেতে একই টাইপ করতে হবে। খুব কমই আপনাকে কাস্টের সাহায্যে বিশেষত new[] { new{ Id = (int?)null, Name = "Foo" }, new { Id = (int?)1, Name = "Foo" }}

— নালাগুলির

অজ্ঞাতনামা ধরণের অস্থায়ী স্টোরেজ হিসাবে ব্যবহার করার জন্য ডিজাইন করা হয়েছে, বেশিরভাগ ক্ষেত্রে আপনি সেগুলি নির্বাচন করুন (i => নতুন {i.ID, i.Name}) ব্যবহার করে লিনিকিউ নির্বাচন বিবরণীতে তৈরি করবেন; যদি আপনি আপনার লেনদেনের একটি ধারাটি একটি লিনকিউতে পুনরায় সংজ্ঞায়িত করেন তবে সঠিক ধরণের একটি অগণিত ফিরিয়ে আনতে পারে W যেখানে আপনার বিবৃতিটির কোনও দরকার নেই এবং যদি আপনি এটি করেন তবে কেবলমাত্র এটিতে টোললিস্ট কল করতে পারেন

— মাইকটি

Answer 1

আপনি করতে পারেন:

var list = new[] { o, o1 }.ToList();

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

public static List<T> CreateList<T>(params T[] elements)
{
     return new List<T>(elements);
}

var list = CreateList(o, o1);

আপনি ধারণা পেতে :)

Comments

@ ডিহর্নপাউট: এটি অ্যারে দেবে, একটি তালিকা <টি> নয়।

— জন স্কিটি

@ ডিহর্নপাউট: আপনি কি "সিস্টেম.লিনক ব্যবহার করছেন"; আপনার ফাইলের শীর্ষে? টোলিস্ট একটি লিনকিউ অপারেটর।

— জন স্কিটি

বুঝেছি .. "সিস্টেম.লিনক ব্যবহার করে" অন্তর্ভুক্ত করা দরকার। ধন্যবাদ।

— DHornpout

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

— লোস

এই ব্যক্তি সর্বত্রই রয়েছেন, আজ 8 টি প্রশ্ন অনুসন্ধান করেছেন, 7 তার উত্তর দিয়েছেন।

— কুগান কুমার

Answer 2

উত্তর এখানে।

string result = String.Empty;

var list = new[]
{ 
    new { Number = 10, Name = "Smith" },
    new { Number = 10, Name = "John" } 
}.ToList();

foreach (var item in list)
{
    result += String.Format("Name={0}, Number={1}\n", item.Name, item.Number);
}

MessageBox.Show(result);

Comments

দত্ত, আপনার কোডটি .ToList () শেষে না দিয়ে কাজ করা উচিত।

— DHornpout

ঠিক আছে দুর্দান্ত, এখন আমাদের একটি নতুন স্টেটমেন্টের সাথে নতুন}} লাইন প্রতিস্থাপনের উদাহরণ দরকার need var list = SourceList.Select (o => new {o.ModelId, o.PartNumber, o.Quantity})। ToList ();

— topwik

@ এটি সম্পর্কে কোন সমাধান?

— কিকিনেট

@ দত্ত, আমি যদি কোনও তালিকা (টি ফাংশন) ব্যবহার করি যা কোনও তালিকা <T> ফেরত দেয় তবে কোনও নমুনা?

— কিকিনেট

এখন সেখানে পদ্ধতি string.Joinএবং স্ট্রিং ইন্টারপোলেশন রয়েছে, তাই ব্যবহার করার দরকার নেই foreachএবং Format।

— রিয়েলসোনিক

Answer 3

এটি করার অনেকগুলি উপায় রয়েছে তবে এখানে কিছু প্রতিক্রিয়া একটি তালিকা তৈরি করছে যাতে আবর্জনা উপাদান রয়েছে, যার জন্য আপনাকে তালিকাটি সাফ করা দরকার।

আপনি যদি জেনেরিক ধরণের একটি খালি তালিকা খুঁজছেন, খালি তালিকা তৈরি করতে টিপলসের তালিকার বিরুদ্ধে একটি নির্বাচন ব্যবহার করুন Select কোনও উপাদান তাত্ক্ষণিক করা হবে না।

খালি তালিকা তৈরি করতে এখানে ওয়ান-লাইনার দেওয়া হয়েছে:

 var emptyList = new List<Tuple<int, string>>()
          .Select(t => new { Id = t.Item1, Name = t.Item2 }).ToList();

তারপরে আপনি নিজের জেনেরিক প্রকারটি ব্যবহার করে এতে যুক্ত করতে পারেন:

 emptyList.Add(new { Id = 1, Name = "foo" });
 emptyList.Add(new { Id = 2, Name = "bar" });

বিকল্প হিসাবে, আপনি খালি তালিকা তৈরি করতে নীচের মতো কিছু করতে পারেন (তবে, আমি প্রথম উদাহরণটি পছন্দ করি কারণ আপনি এটি টিপলসের জনবহুল সংগ্রহের জন্যও ব্যবহার করতে পারেন):

 var emptyList = new List<object>()
          .Select(t => new { Id = default(int), Name = default(string) }).ToList();   

Comments

আমি এইভাবে অনেক পছন্দ করি। ধন্যবাদ পল! আপনি যখন টিপলস ব্যবহার করতে পারেন তখন এটি সর্বদা একটি ভাল দিন! এক্সডি

— ব্র্যাডি লাইলস

আমি এই পছন্দ। আমি যে বস্তুটি পাস করতে চলেছি তার কোনও ধরণের কংক্রিটের ঘোষণা পেয়ে খুব ভাল

— লাগল

চমৎকার আমি স্রেফ কোডটি লেখার কাজটি শেষ করেছি যার মধ্যে আমার

— লিখিত সময়টিকে

ধারণার জন্য ধন্যবাদ। একটি পরামর্শ, আপনি যদি ব্যবহার করেন তবে ডামি তালিকা বরাদ্দ এড়াতে পারবেনEnumerable.Empty<object>().Select(o=>definition).ToList()

— BrainStorm.exe

Answer 4

ঠিক নয়, তবে আপনি বলতে পারেন List<object>এবং জিনিসগুলি কাজ করবে। যাহোক,list[0].Id কাজ করবে না।

এটি সি # ৪.০ তে রানটাইমের সময় কাজ করবে List<dynamic>, এটি হ'ল আপনি ইন্টেলিজেন্স পাবেন না।

Comments

এটি দৃ strongly়ভাবে টাইপ করা হয়নি, তবে এই অর্থে যে তালিকার আইটেমগুলির জন্য আপনার কাছে কোনও সংকলক ইন্টেলিজেন্স সহায়তা নেই।

— জোয়েল কোহোর্ন

লোকেরা ডায়নামিকের সাথে এই ধরনের জিনিসগুলি করবে বলে আমি ভয় করি।

— এরিক্কল্লান

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

— জেফ

তবে সেই ক্ষেত্রে উত্সের ধরণ সর্বোপরি গতিশীল, বেনামি ধরণের জন্য << নামিক> কোনও তালিকা ব্যবহার করার কোনও মানে হয় না।

— ডায়কাম

খুব উপকারী. বিশেষত যদি তালিকাটি বেনামে আইটেম যুক্ত করার আগে সংজ্ঞায়িত করতে হয়।

— কার্ল্থ

Answer 5

আমি অনুমান করি

List<T> CreateEmptyGenericList<T>(T example) {
    return new List<T>();
}

void something() {
    var o = new { Id = 1, Name = "foo" };
    var emptyListOfAnonymousType = CreateEmptyGenericList(o);
}

কাজ করবে.

আপনি এটি লিখতেও বিবেচনা করতে পারেন:

void something() {
    var String = string.Emtpy;
    var Integer = int.MinValue;
    var emptyListOfAnonymousType = CreateEmptyGenericList(new { Id = Integer, Name = String });
}

Comments

হ্যাঁ এই সমাধানটি বেনামে অ্যারে শুরু করতে সহায়তা করবে। ধন্যবাদ।

— DHornpout

পদ্ধতির নামের পরে একটু <T> রাখুন।

— মার্টিন

Answer 6

আমি সাধারণত নিম্নলিখিত ব্যবহার করি; মূলত কারণ আপনি খালি খালি একটি তালিকা দিয়ে "শুরু" করেন।

var list = Enumerable.Range(0, 0).Select(e => new { ID = 1, Name = ""}).ToList();
list.Add(new {ID = 753159, Name = "Lamont Cranston"} );
//etc.

ইদানীং, আমি পরিবর্তে এটি এইভাবে লিখছি:

var list = Enumerable.Repeat(new { ID = 1, Name = "" }, 0).ToList();
list.Add(new {ID = 753159, Name = "Lamont Cranston"} );

পুনরাবৃত্তি পদ্ধতি ব্যবহার করা আপনাকে এগুলি করতে দেয়:

var myObj = new { ID = 1, Name = "John" };
var list = Enumerable.Repeat(myObj, 1).ToList();
list.Add(new { ID = 2, Name = "Liana" });

.. যা আপনাকে ইতিমধ্যে যুক্ত করা প্রথম আইটেমের সাথে প্রাথমিক তালিকা দেয়।

Comments

আপনাকে খালি তালিকা দিয়ে শুরু করার দরকার নেই - আপনি রেঞ্জ (0,1) করতে পারেন এবং বাছাই বিবৃতিতে আপনার প্রথম অবজেক্টটি হতে পারেন .. প্রথম বস্তু।

— ম্যাথু এম।

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

— রোস্তভ

Answer 7

আপনি আপনার কোড এ এটি করতে পারেন।

var list = new[] { new { Id = 1, Name = "Foo" } }.ToList();
list.Add(new { Id = 2, Name = "Bar" });

Answer 8

সর্বশেষ সংস্করণ ৪.০-তে, নীচের মতো গতিশীল ব্যবহার করতে পারেন

var list = new List<dynamic>();
        list.Add(new {
            Name = "Damith"
    });
        foreach(var item in list){
            Console.WriteLine(item.Name);
        }
    }

Answer 9

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

    using System.Linq;
    …
    var list = new[]{new{Id = default(int), Name = default(string)}}.Skip(1).ToList();

Comments

আমার সম্পাদনা প্রত্যাখ্যান করার কোনও কারণ? উত্তরগুলি অনুসরণ করে IEnumerable, যেখানে আমার সংস্করণটি ফিরে আসে List, ঠিক কীভাবে ওপি জিজ্ঞাসা করেছিল।

— Necronomicron

আমি এই পদ্ধতির পছন্দ করি বা এই উত্তরটির আরও new object[] { }.Select(o => new { Id = default(int), Name = default(string) }).ToList()

— নিকটেই

Answer 10

আমার চেষ্টা এখানে।

List<object> list = new List<object> { new { Id = 10, Name = "Testing1" }, new {Id =2, Name ="Testing2" }}; 

আমি কাস্টম ধরণের জন্য একটি বেনাম তালিকা তৈরির জন্য অনুরূপ কিছু লিখেছিলাম যখন আমি এই সাথে এসেছি।

Answer 11

আপনি গতিশীল একটি তালিকা তৈরি করতে পারেন।

List<dynamic> anons=new List<dynamic>();
foreach (Model model in models)
{
   var anon= new
   {
      Id = model.Id,
      Name=model.Name
   };
   anons.Add(anon);
}

"গতিশীল" প্রথম মান যুক্ত হয়ে আরম্ভ হয়।

Answer 12

এর পরিবর্তে:

var o = new { Id = 1, Name = "Foo" }; 
var o1 = new { Id = 2, Name = "Bar" }; 

List <var> list = new List<var>(); 
list.Add(o); 
list.Add(o1);

আপনি এটি করতে পারেন:

var o = new { Id = 1, Name = "Foo" }; 
var o1 = new { Id = 2, Name = "Bar" }; 

List<object> list = new List<object>(); 
list.Add(o); 
list.Add(o1);

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

private List<object> GetList()
{ 
    List<object> list = new List<object>();
    var o = new { Id = 1, Name = "Foo" }; 
    var o1 = new { Id = 2, Name = "Bar" }; 
    list.Add(o); 
    list.Add(o1);
    return list;
}

private void WriteList()
{
    foreach (var item in GetList()) 
    { 
        Console.WriteLine("Name={0}{1}", item.Name, Environment.NewLine); 
    }
}

সমস্যাটি হ'ল কেবলমাত্র অবজেক্টের সদস্যরা রানটাইমের সময় উপলব্ধ, যদিও ইন্টেলিসেন্স বৈশিষ্ট্যগুলি আইডি এবং নাম দেখায় ।

.NET 4.0 এ একটি সমাধান হ'ল উপরের কোডে অবজেক্টের কীওয়ার্ড ডায়নামিক আইস্টেড ব্যবহার করা ।

আর একটি সমাধান বৈশিষ্ট্য পেতে প্রতিবিম্ব ব্যবহার করা হয়

using System;
using System.Collections.Generic;
using System.Reflection;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();
            var anonymous = p.GetList(new[]{
                new { Id = 1, Name = "Foo" },       
                new { Id = 2, Name = "Bar" }
            });

            p.WriteList(anonymous);
        }

        private List<T> GetList<T>(params T[] elements)
        {
            var a = TypeGenerator(elements);
            return a;
        }

        public static List<T> TypeGenerator<T>(T[] at)
        {
            return new List<T>(at);
        }

        private void WriteList<T>(List<T> elements)
        {
            PropertyInfo[] pi = typeof(T).GetProperties();
            foreach (var el in elements)
            {
                foreach (var p in pi)
                {
                    Console.WriteLine("{0}", p.GetValue(el, null));
                }
            }
            Console.ReadLine();
        }
    }
}

Answer 13

এখানে বেনামে প্রকারের তালিকা তৈরির একটি অন্য পদ্ধতি যা আপনাকে খালি তালিকা দিয়ে শুরু করতে দেয়, তবে তবুও ইন্টেলিজেন্সে অ্যাক্সেস রয়েছে।

var items = "".Select( t => new {Id = 1, Name = "foo"} ).ToList();

আপনি যদি প্রথম আইটেমটি রাখতে চান, কেবল একটি অক্ষরে স্ট্রিং দিন।

var items = "1".Select( t => new {Id = 1, Name = "foo"} ).ToList();

Comments

অ্যারে ইনিশিয়ালাইজার হিসাবে স্ট্রিং ব্যবহার করা কার্যকর হতে পারে তবে এটি খুব খারাপ অনুশীলন

— মাইকটি

আমি বলব যে উপরের উত্তরগুলির বেশিরভাগটি বিশেষভাবে "ভাল" অনুশীলন নয়, তবে প্রশ্নের প্রকৃতির কারণে এটি একটি ধরণের দেওয়া ছিল। বেনামে ধরণগুলি এইভাবে কাজ করার জন্য ডিজাইন করা হয়নি। আমি আগ্রহী যদিও আমার পদ্ধতিটি অন্যের চেয়ে "খারাপ" কেন? কিছু মিস করছি?

— ব্র্যাকাস

আপনি ঠিক বলেছেন যে প্রশ্নটি এমন কিছু জিজ্ঞাসা করছে যা নিজেই খারাপ অনুশীলনের একটি ভাল অনুশীলনের উত্তর হতে পারে না, তবে আপনি চরগুলি তৈরি করতে একটি স্ট্রিং ব্যবহার করছেন এবং তারপরে ব্যবহারকারীকে যা চান তার অ্যারেতে রূপান্তর করছেন , যা অপ্রয়োজনীয়

— প্রযোজনীয়

Answer 14

var list = new[]{
new{
FirstField = default(string),
SecondField = default(int),
ThirdField = default(double)
}
}.ToList();
list.RemoveAt(0);

Answer 15

এটি একটি পুরানো প্রশ্ন, তবে আমি ভেবেছিলাম আমার সি # 6 উত্তরটি রেখে দেব। আমাকে প্রায়শই টেপ ডেটা সেটআপ করতে হয় যা টিপলসের তালিকা হিসাবে সহজেই কোড-এ প্রবেশ করা হয়। বেশ কয়েকটি এক্সটেনশন ফাংশন সহ প্রতিটি এন্ট্রিতে নামগুলি পুনরাবৃত্তি না করে এই সুন্দর, কমপ্যাক্ট ফর্ম্যাটটি পাওয়া সম্ভব।

var people= new List<Tuple<int, int, string>>() {
    {1, 11, "Adam"},
    {2, 22, "Bill"},
    {3, 33, "Carol"}
}.Select(t => new { Id = t.Item1, Age = t.Item2, Name = t.Item3 });

এটি একটি মূলনাম দেয় - আপনি যদি এমন একটি তালিকা চান যা আপনি যোগ করতে পারেন তবে কেবলমাত্র টোলিস্ট () যুক্ত করুন।

যাদুটি কাস্টম এক্সটেনশান থেকে আসে টিউপলগুলির জন্য পদ্ধতিগুলি জুড়ুন, https://stackoverflow.com/a/27455822/4536527 এ বর্ণিত ।

public static class TupleListExtensions    {
    public static void Add<T1, T2>(this IList<Tuple<T1, T2>> list,
            T1 item1, T2 item2)       {
        list.Add(Tuple.Create(item1, item2));
    }

    public static void Add<T1, T2, T3>(this IList<Tuple<T1, T2, T3>> list,
            T1 item1, T2 item2, T3 item3) {
        list.Add(Tuple.Create(item1, item2, item3));
    }

// and so on...

}

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

Answer 16

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

var list = new List<dynamic>() 
{ 
    new { Id = 1, Name = "Foo" }, 
    new { Id = 2, Name = "Bar" } 
};

আপনি সর্বদা এর objectপরিবর্তে ব্যবহার করতে পারেন dynamicতবে এটি সত্যিকারের জেনেরিক উপায়ে রাখার চেষ্টা করার পরে dynamicআরও অর্থবোধ তৈরি হয়।

Answer 17

আপনি এটি এইভাবে করতে পারেন:

var o = new { Id = 1, Name = "Foo" };
var o1 = new { Id = 2, Name = "Bar" };

var array = new[] { o, o1 };
var list = array.ToList();

list.Add(new { Id = 3, Name = "Yeah" });

এটি আমার কাছে কিছুটা "হ্যাকি" বলে মনে হচ্ছে তবে এটি কাজ করে - যদি আপনার সত্যিই একটি তালিকা থাকা প্রয়োজন এবং কেবল বেনামে অ্যারে ব্যবহার করতে না পারেন তবে।

Answer 18

আপনার দ্বিতীয় উদাহরণের জন্য, যেখানে আপনাকে একটি নতুন সূচনা করতে হবে List<T>, একটি ধারণা হ'ল বেনামে তালিকা তৈরি করা, এবং তারপরে এটি সাফ করা।

var list = new[] { o, o1 }.ToList();
list.Clear();

//and you can keep adding.
while (....)
{
    ....
    list.Add(new { Id = x, Name = y });
    ....
}

বা এক্সটেনশন পদ্ধতি হিসাবে, আরও সহজ হওয়া উচিত:

public static List<T> GetEmptyListOfThisType<T>(this T item)
{
    return new List<T>();
}

//so you can call:
var list = new { Id = 0, Name = "" }.GetEmptyListOfThisType();

বা সম্ভবত আরও ছোট,

var list = new int[0].Select(x => new { Id = 0, Name = "" }).Tolist();

Answer 19

আপনি যদি সি # 7 বা তদুর্ধ্বের ব্যবহার করে থাকেন তবে আপনি বেনামে প্রকারের পরিবর্তে টুপল প্রকারগুলি ব্যবহার করতে পারেন ।

var myList = new List<(int IntProp, string StrProp)>();
myList.Add((IntProp: 123, StrProp: "XYZ"));

Answer 20

এই উত্তরটি থেকে আবিষ্কার করে , আমি দুটি পদ্ধতি নিয়ে এসেছি যা কাজটি করতে পারে:

    /// <summary>
    /// Create a list of the given anonymous class. <paramref name="definition"/> isn't called, it is only used
    /// for the needed type inference. This overload is for when you don't have an instance of the anon class
    /// and don't want to make one to make the list.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="definition"></param>
    /// <returns></returns>
#pragma warning disable RECS0154 // Parameter is never used
    public static List<T> CreateListOfAnonType<T>(Func<T> definition)
#pragma warning restore RECS0154 // Parameter is never used
    {
        return new List<T>();
    }
    /// <summary>
    /// Create a list of the given anonymous class. <paramref name="definition"/> isn't added to the list, it is
    /// only used for the needed type inference. This overload is for when you do have an instance of the anon
    /// class and don't want the compiler to waste time making a temp class to define the type.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="definition"></param>
    /// <returns></returns>
#pragma warning disable RECS0154 // Parameter is never used
    public static List<T> CreateListOfAnonType<T>(T definition)
#pragma warning restore RECS0154 // Parameter is never used
    {
        return new List<T>();
    }

আপনি যেমন পদ্ধতি ব্যবহার করতে পারেন

var emptyList = CreateListOfAnonType(()=>new { Id = default(int), Name = default(string) });
//or
var existingAnonInstance = new { Id = 59, Name = "Joe" };
var otherEmptyList = CreateListOfAnonType(existingAnonInstance);

এই উত্তরের অনুরূপ ধারণা রয়েছে তবে আমি এই পদ্ধতিগুলি তৈরি করার আগে পর্যন্ত এটি দেখতে পেলাম না।

Answer 21

এটি দিয়ে চেষ্টা করুন:

var result = new List<object>();

foreach (var test in model.ToList()) {
   result.Add(new {Id = test.IdSoc,Nom = test.Nom});
}

Comments

নামহীন ধরণের তালিকা কোথায়?

— মিশা উইডেনম্যান

Answer 22

static void Main()
{
    List<int> list = new List<int>();
    list.Add(2);
    list.Add(3);
    list.Add(5);
    list.Add(7);
}

Comments

আমি এখানে কোনও বেনাম শ্রেণি নেই see

— অ্যান্ড্রু বার্বার