Anonim türleri parametre olarak nasıl iletebilirim?

Anonim türleri diğer işlevlere parametre olarak nasıl iletebilirim? Bu örneği düşünün:

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

Buradaki değişkenin querygüçlü türü yoktur. İşlevimi LogEmployeeskabul etmek için nasıl tanımlamalıyım ?

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

    }
}

Başka bir deyişle, ?işaretler yerine ne kullanmalıyım .

Sanırım bu anonim tip için bir sınıf yapmalısın. Bu benim görüşüme göre yapılacak en mantıklı şey olurdu. Ama gerçekten istemiyorsanız, dinamikleri kullanabilirsiniz:

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

Not Bu olduğunu değil kesinlikle yazılı, böylece örneğin, İsim EmployeeName şekilde değiştiren varsa, bir sorun çalışma zamanı kadar var bilemezsiniz.

Bunu şu şekilde yapabilirsiniz:

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

    }
}

... ama her eşya için fazla bir şey yapamazsın. ToString'i arayabilirsiniz, ancak doğrudan Nameve kullanamazsınız Id.

Ne yazık ki, yapmaya çalıştığınız şey imkansız. Kaputun altında, sorgu değişkeni IEnumerableanonim türden olacak şekilde yazılır . Anonim tür adları kullanıcı kodunda gösterilemez, bu nedenle onları bir işleve giriş parametresi yapmanın bir yolu yoktur.

En iyi seçeneğiniz bir tür oluşturmak ve bunu sorgudan dönüş olarak kullanmak ve daha sonra işleve aktarmaktır. Örneğin,

struct Data {
  public string ColumnName; 
}

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

Bu durumda, yalnızca tek bir alan seçersiniz, bu nedenle alanı doğrudan seçmek daha kolay olabilir. Bu, sorgunun IEnumerablealan türünden biri olarak yazılmasına neden olur . Bu durumda, sütun adı.

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

Parametre türü olmadıkça, anonim bir türü genel olmayan bir işleve geçiremezsiniz object.

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

    foreach (var item in list)
    {

    }
}

Anonim türler, bir yöntem içinde kısa süreli kullanım için tasarlanmıştır.

MSDN'den - Anonim Türler :

Bir alanı, özelliği, olayı veya yöntemin dönüş türünü anonim bir tür olarak bildiremezsiniz. Benzer şekilde, bir yöntem, özellik, yapıcı veya dizinleyicinin resmi bir parametresini anonim bir türe sahip olarak bildiremezsiniz. Adsız bir türü veya adsız türler içeren bir koleksiyonu bir yönteme bağımsız değişken olarak iletmek için, parametreyi tür nesnesi olarak bildirebilirsiniz . Ancak, bunu yapmak güçlü yazmanın amacını yener.

(benimkini vurgula)

Güncelleme

İstediğinizi başarmak için jenerik ilaçları kullanabilirsiniz:

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

    }
}

Normalde, bunu jeneriklerle yaparsınız, örneğin:

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

Derleyici Taradığınızda çıkarımda bulunmalıdır MapEntToObj(query). Yöntemin içinde ne yapmak istediğinizden tam olarak emin değilim, bu yüzden bunun yararlı olup olmadığını söyleyemem ... sorun şu ki, içinde MapEntToObjhala isim Tveremiyorsunuz - ya da şunları yapabilirsiniz:

• diğer genel yöntemleri T
• bir Tşeyler yapmak için yansımayı kullan

ama bunun dışında, isimsiz türleri manipüle etmek oldukça zordur - en azından değişmez oldukları için ;-p

Başka bir hile ( veri çıkarılırken ) aynı zamanda bir seçici geçirmektir - yani:

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

Jenerikleri aşağıdaki hile ile kullanabilirsiniz (anonim türe döküm):

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;
}

"dinamik" de bu amaçla kullanılabilir.

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)
   {

   }
}

Anonim bir tür iletmek yerine, dinamik türden bir Liste iletin:

1. var dynamicResult = anonymousQueryResult.ToList<dynamic>();
2. Yöntem imzası: DoSomething(List<dynamic> _dynamicResult)
3. Çağrı yöntemi: DoSomething(dynamicResult);
4. yapılır.

Petar Ivanov'a teşekkürler !

Sonuçlarınızın belirli bir arayüz uyguladığını biliyorsanız, arayüzü veri türü olarak kullanabilirsiniz:

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

    }
}

IEnumerable<object>Argüman için tip olarak kullanırım . Ancak kaçınılmaz açık kadro için büyük bir kazanç değil. Şerefe