จะส่งประเภทที่ไม่ระบุตัวตนเป็นพารามิเตอร์ได้อย่างไร

ฉันจะส่งประเภทที่ไม่ระบุชื่อเป็นพารามิเตอร์ไปยังฟังก์ชันอื่น ๆ ได้อย่างไร ลองพิจารณาตัวอย่างนี้:

var query = from employee in employees select new { Name = employee.Name, Id = employee.Id };
LogEmployees(query);

ตัวแปรqueryที่นี่ไม่มีประเภทที่แข็งแกร่ง ฉันจะกำหนดLogEmployeesฟังก์ชันให้ยอมรับได้อย่างไร?

public void LogEmployees (? list)
{
    foreach (? item in list)
    {

    }
}

กล่าวอีกนัยหนึ่งฉันควรใช้อะไรแทน?เครื่องหมาย

ฉันคิดว่าคุณควรสร้างคลาสสำหรับประเภทนิรนามนี้ นั่นเป็นสิ่งที่สมเหตุสมผลที่สุดที่จะทำในความคิดของฉัน แต่ถ้าคุณไม่ต้องการจริงๆคุณสามารถใช้การเปลี่ยนแปลง:

public void LogEmployees (IEnumerable<dynamic> list)
{
    foreach (dynamic item in list)
    {
        string name = item.Name;
        int id = item.Id;
    }
}

โปรดทราบว่าสิ่งนี้ไม่ได้พิมพ์อย่างรุนแรงดังนั้นหากชื่อเปลี่ยนเป็น EmployeeName คุณจะไม่รู้ว่ามีปัญหาจนกว่าจะรันไทม์

คุณสามารถทำได้ดังนี้:

public void LogEmployees<T>(List<T> list) // Or IEnumerable<T> list
{
    foreach (T item in list)
    {

    }
}

... แต่คุณจะไม่ได้ทำอะไรมากกับแต่ละรายการ คุณสามารถเรียก ToString ได้ แต่คุณจะไม่สามารถใช้ (พูด) NameและIdโดยตรงได้

น่าเสียดายที่สิ่งที่คุณพยายามทำนั้นเป็นไปไม่ได้ ภายใต้ฝากระโปรงตัวแปรการสืบค้นจะถูกพิมพ์ให้IEnumerableเป็นประเภทที่ไม่ระบุตัวตน ไม่สามารถแสดงชื่อชนิดที่ไม่ระบุตัวตนในรหัสผู้ใช้ได้ดังนั้นจึงไม่มีวิธีใดที่จะทำให้เป็นพารามิเตอร์อินพุตของฟังก์ชันได้

ทางออกที่ดีที่สุดของคุณคือการสร้างประเภทและใช้สิ่งนั้นเป็นผลตอบแทนจากแบบสอบถามจากนั้นจึงส่งต่อไปยังฟังก์ชัน ตัวอย่างเช่น,

struct Data {
  public string ColumnName; 
}

var query = (from name in some.Table
            select new Data { ColumnName = name });
MethodOp(query);
...
MethodOp(IEnumerable<Data> enumerable);

ในกรณีนี้คุณกำลังเลือกเพียงฟิลด์เดียวดังนั้นจึงอาจง่ายกว่าที่จะเลือกฟิลด์โดยตรง สิ่งนี้จะทำให้พิมพ์แบบสอบถามเป็นIEnumerableประเภทเขตข้อมูล ในกรณีนี้ชื่อคอลัมน์

var query = (from name in some.Table select name);  // IEnumerable<string>

objectคุณไม่สามารถส่งผ่านชนิดระบุชื่อให้กับฟังก์ชั่นทั่วไปที่ไม่เว้นแต่ประเภทพารามิเตอร์เป็น

public void LogEmployees (object obj)
{
    var list = obj as IEnumerable(); 
    if (list == null)
       return;

    foreach (var item in list)
    {

    }
}

ชนิดไม่ระบุชื่อมีไว้สำหรับการใช้งานระยะสั้นภายในวิธีการ

จาก MSDN - ประเภทที่ไม่ระบุตัวตน :

คุณไม่สามารถประกาศเขตข้อมูลคุณสมบัติเหตุการณ์หรือประเภทการส่งคืนของวิธีการเป็นประเภทที่ไม่ระบุตัวตน ในทำนองเดียวกันคุณไม่สามารถประกาศพารามิเตอร์ที่เป็นทางการของเมธอดคุณสมบัติตัวสร้างหรือตัวสร้างดัชนีว่ามีประเภทที่ไม่ระบุตัวตน ที่จะผ่านชนิดที่ไม่ระบุชื่อหรือคอลเลกชันที่มีประเภทที่ไม่ระบุชื่อเป็นอาร์กิวเมนต์วิธีหนึ่งที่คุณสามารถประกาศพารามิเตอร์ชนิดของวัตถุ อย่างไรก็ตามการทำเช่นนี้เอาชนะจุดประสงค์ของการพิมพ์ที่ชัดเจน

(เน้นเหมือง)

อัปเดต

คุณสามารถใช้ยาชื่อสามัญเพื่อบรรลุสิ่งที่คุณต้องการ:

public void LogEmployees<T>(IEnumerable<T> list)
{
    foreach (T item in list)
    {

    }
}

โดยปกติคุณทำสิ่งนี้กับยาชื่อสามัญเช่น:

MapEntToObj<T>(IQueryable<T> query) {...}

คอมไพเลอร์แล้วควรสรุปเมื่อคุณเรียกT MapEntToObj(query)ไม่ค่อยแน่ใจว่าคุณต้องการทำอะไรในวิธีการนี้ดังนั้นฉันไม่สามารถบอกได้ว่าสิ่งนี้มีประโยชน์หรือไม่ ... ปัญหาคือภายในMapEntToObjคุณยังไม่สามารถตั้งชื่อได้T- คุณสามารถ:

• เรียกวิธีการทั่วไปอื่น ๆ ด้วย T
• ใช้การไตร่ตรองในTการทำสิ่งต่างๆ

แต่นอกเหนือจากนั้นมันค่อนข้างยากที่จะจัดการกับประเภทนิรนาม - ไม่น้อยเพราะไม่เปลี่ยนรูป ;-p

เคล็ดลับอีกประการหนึ่ง (เมื่อดึงข้อมูล) คือการส่งตัวเลือกเช่น:

Foo<TSource, TValue>(IEnumerable<TSource> source,
        Func<TSource,string> name) {
    foreach(TSource item in source) Console.WriteLine(name(item));
}
...
Foo(query, x=>x.Title);

คุณสามารถใช้ยาชื่อสามัญได้ด้วยเคล็ดลับต่อไปนี้ (การแคสต์เป็นประเภทไม่ระบุตัวตน)

public void LogEmployees<T>(IEnumerable<T> list)
{
    foreach (T item in list)
    {
        var typedItem = Cast(item, new { Name = "", Id = 0 });
        // now you can use typedItem.Name, etc.
    }
}

static T Cast<T>(object obj, T type)
{
    return (T)obj;
}

"ไดนามิก" สามารถใช้เพื่อจุดประสงค์นี้ได้เช่นกัน

var anonymousType = new { Id = 1, Name = "A" };

var anonymousTypes = new[] { new { Id = 1, Name = "A" }, new { Id = 2, Name = "B" };

private void DisplayAnonymousType(dynamic anonymousType)
{
}

private void DisplayAnonymousTypes(IEnumerable<dynamic> anonymousTypes)
{
   foreach (var info in anonymousTypes)
   {

   }
}

แทนที่จะส่งประเภทที่ไม่ระบุตัวตนให้ส่งรายการประเภทไดนามิก:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. ลายเซ็นวิธี: DoSomething(List<dynamic> _dynamicResult)
3. วิธีการโทร: DoSomething(dynamicResult);
4. เสร็จแล้ว

ขอบคุณPetar Ivanov !

หากคุณทราบว่าผลลัพธ์ของคุณใช้อินเทอร์เฟซบางอย่างคุณสามารถใช้อินเทอร์เฟซเป็นประเภทข้อมูลได้:

public void LogEmployees<T>(IEnumerable<T> list)
{
    foreach (T item in list)
    {

    }
}

ฉันจะใช้IEnumerable<object>เป็นประเภทสำหรับอาร์กิวเมนต์ อย่างไรก็ตามไม่ใช่ผลประโยชน์ที่ดีสำหรับนักแสดงที่ไม่สามารถหลีกเลี่ยงได้ ไชโย