Apa manfaat sebenarnya dari ExpandoObject?

Kelas ExpandoObject yang ditambahkan ke .NET 4 memungkinkan Anda untuk secara sewenang-wenang mengatur properti ke objek saat runtime.

Apakah ada kelebihan untuk ini daripada menggunakan Dictionary<string, object>, atau benar-benar bahkan Hashtable ? Sejauh yang saya tahu, ini hanyalah tabel hash yang dapat Anda akses dengan sintaks yang sedikit lebih ringkas.

Misalnya, mengapa ini:

dynamic obj = new ExpandoObject();
obj.MyInt = 3;
obj.MyString = "Foo";
Console.WriteLine(obj.MyString);

Benar-benar lebih baik, atau sangat berbeda, dari:

var obj = new Dictionary<string, object>();
obj["MyInt"] = 3;
obj["MyString"] = "Foo";

Console.WriteLine(obj["MyString"]);

Apa keuntungan nyata yang diperoleh dengan menggunakan ExpandoObject alih-alih hanya menggunakan jenis kamus arbitrer, selain tidak jelas bahwa Anda menggunakan jenis yang akan ditentukan saat runtime.

Karena saya menulis artikel MSDN yang Anda maksud, saya kira saya harus menjawab yang ini.

Pertama, saya mengantisipasi pertanyaan ini dan itulah sebabnya saya menulis posting blog yang menunjukkan kasus penggunaan yang kurang lebih nyata untuk ExpandoObject: Dynamic di C # 4.0: Memperkenalkan ExpandoObject .

Singkatnya, ExpandoObject dapat membantu Anda membuat objek hierarkis yang kompleks. Misalnya, bayangkan Anda memiliki kamus di dalam kamus:

Dictionary<String, object> dict = new Dictionary<string, object>();
Dictionary<String, object> address = new Dictionary<string,object>();
dict["Address"] = address;
address["State"] = "WA";
Console.WriteLine(((Dictionary<string,object>)dict["Address"])["State"]);

Semakin dalam adalah hierarki, yang lebih buruk adalah kode. Dengan ExpandoObject tetap elegan dan mudah dibaca.

dynamic expando = new ExpandoObject();
expando.Address = new ExpandoObject();
expando.Address.State = "WA";
Console.WriteLine(expando.Address.State);

Kedua, seperti yang sudah ditunjukkan, ExpandoObject mengimplementasikan antarmuka INotifyPropertyChanged yang memberi Anda lebih banyak kontrol atas properti daripada kamus.

Akhirnya, Anda dapat menambahkan acara ke ExpandoObject seperti di sini:

class Program
{
   static void Main(string[] args)
   {
       dynamic d = new ExpandoObject();

       // Initialize the event to null (meaning no handlers)
       d.MyEvent = null;

       // Add some handlers
       d.MyEvent += new EventHandler(OnMyEvent);
       d.MyEvent += new EventHandler(OnMyEvent2);

       // Fire the event
       EventHandler e = d.MyEvent;

       e?.Invoke(d, new EventArgs());
   }

   static void OnMyEvent(object sender, EventArgs e)
   {
       Console.WriteLine("OnMyEvent fired by: {0}", sender);
   }

   static void OnMyEvent2(object sender, EventArgs e)
   {
       Console.WriteLine("OnMyEvent2 fired by: {0}", sender);
   }
}

Juga, ingatlah bahwa tidak ada yang menghalangi Anda untuk menerima argumen peristiwa secara dinamis. Dengan kata lain, alih-alih menggunakan EventHandler, Anda dapat menggunakan EventHandler<dynamic>yang akan menyebabkan argumen kedua dari pawang menjadi dynamic.

Satu keuntungan adalah untuk skenario yang mengikat. Kisi data dan kisi properti akan mengambil properti dinamis melalui sistem TypeDescriptor. Selain itu, pengikatan data WPF akan memahami properti dinamis, sehingga kontrol WPF dapat berikatan dengan ExpandoObject lebih mudah daripada kamus.

Interoperabilitas dengan bahasa dinamis, yang akan mengharapkan properti DLR daripada entri kamus, juga dapat menjadi pertimbangan dalam beberapa skenario.

Manfaat nyata bagi saya adalah pengikatan data yang benar-benar mudah dari XAML:

public dynamic SomeData { get; set; }

...

SomeData.WhatEver = "Yo Man!";

...

 <TextBlock Text="{Binding SomeData.WhatEver}" />

Interop dengan bahasa lain yang ditemukan pada DLRalasan # 1 itu bisa saya pikirkan. Anda tidak dapat melewati mereka Dictionary<string, object>karena ini bukan IDynamicMetaObjectProvider. Manfaat tambahan lainnya adalah mengimplementasikannya INotifyPropertyChangedyang berarti dalam dunia penyatuan data WPF, ia juga memiliki manfaat tambahan di luar apa yang Dictionary<K,V>dapat Anda berikan.

Ini semua tentang kenyamanan programmer. Saya bisa membayangkan menulis program cepat dan kotor dengan objek ini.

Saya pikir ini akan memiliki manfaat sintaksis, karena Anda tidak akan lagi "memalsukan" properti yang ditambahkan secara dinamis dengan menggunakan kamus.

Itu, dan interop dengan bahasa dinamis saya akan berpikir.

Ini adalah contoh dari artikel MSDN yang hebat tentang penggunaan ExpandoObject untuk membuat tipe ad-hoc dinamis untuk data terstruktur yang masuk (yaitu XML, Json).

Kami juga dapat menetapkan delegasi ke properti dinamis ExpandoObject :

dynamic person = new ExpandoObject();
person.FirstName = "Dino";
person.LastName = "Esposito";

person.GetFullName = (Func<String>)(() => { 
  return String.Format("{0}, {1}", 
    person.LastName, person.FirstName); 
});

var name = person.GetFullName();
Console.WriteLine(name);

Dengan demikian memungkinkan kita untuk menyuntikkan beberapa logika ke objek dinamis saat runtime. Oleh karena itu, bersama dengan ekspresi lambda, penutupan, kata kunci dinamis, dan kelas DynamicObject , kami dapat memperkenalkan beberapa elemen pemrograman fungsional ke dalam kode C # kami, yang kami tahu dari bahasa dinamis seperti JavaScript atau PHP.

Ada beberapa kasus di mana ini berguna. Saya akan menggunakannya untuk shell Modularized misalnya. Setiap modul mendefinisikan Dialog Konfigurasi itu sendiri yang didasari oleh pengaturannya. Saya memberinya ExpandoObject karena Datacontext dan menyimpan nilai-nilai dalam Storage konfigurasi saya. Dengan cara ini penulis Dialog Konfigurasi hanya harus Mengikat ke Nilai dan secara otomatis dibuat dan disimpan. (Dan disediakan untuk modul untuk menggunakan pengaturan ini tentu saja)

Ini lebih mudah digunakan daripada Kamus. Tetapi semua orang harus sadar bahwa secara internal itu hanya sebuah Kamus.

Ini seperti LINQ hanya gula sintaksis, tetapi kadang-kadang membuatnya lebih mudah.

Jadi untuk menjawab pertanyaan Anda secara langsung: Lebih mudah untuk menulis dan lebih mudah dibaca. Tetapi secara teknis itu pada dasarnya adalah Dictionary<string,object>(Anda bahkan dapat memasukkannya ke dalam daftar nilai).

var obj = new Dictionary<string, object>;
...
Console.WriteLine(obj["MyString"]);

Saya pikir itu hanya berfungsi karena semuanya memiliki ToString (), jika tidak, Anda harus tahu tipe itu dan melemparkan 'objek' ke tipe itu.

Beberapa di antaranya bermanfaat lebih sering daripada yang lain, saya mencoba untuk teliti.

1. Mungkin jauh lebih alami untuk mengakses koleksi, dalam hal ini apa yang secara efektif "kamus", menggunakan notasi titik lebih langsung.

2. Sepertinya ini bisa digunakan sebagai Tuple yang sangat bagus. Anda masih dapat memanggil anggota Anda "Item1", "Item2" dll ... tetapi sekarang Anda tidak harus, itu juga bisa berubah, tidak seperti Tuple. Ini memang memiliki kelemahan besar dari kurangnya dukungan intellisense.

3. Anda mungkin merasa tidak nyaman dengan "nama anggota sebagai string", seperti halnya merasakan dengan kamus, Anda mungkin merasa itu terlalu seperti "mengeksekusi string", dan itu dapat menyebabkan konvensi penamaan dikodekan, dan berurusan dengan bekerja dengan morfem dan suku kata ketika kode mencoba memahami cara menggunakan anggota :-P

4. Bisakah Anda memberikan nilai pada ExpandoObject itu sendiri atau hanya anggotanya? Bandingkan dan kontras dengan dinamis / dinamis [], gunakan mana yang paling sesuai dengan kebutuhan Anda.

5. Saya tidak berpikir dynamic / dynamic [] bekerja dalam loop foreach, Anda harus menggunakan var, tetapi mungkin Anda dapat menggunakan ExpandoObject.

6. Anda tidak dapat menggunakan dinamis sebagai anggota data di kelas, mungkin karena itu setidaknya semacam kata kunci, semoga Anda bisa dengan ExpandoObject.

7. Saya berharap itu "adalah" sebuah ExpandoObject, mungkin berguna untuk melabeli hal-hal yang sangat umum, dengan kode yang membedakan berdasarkan jenis di mana ada banyak hal dinamis yang digunakan.

Bersikap baik jika Anda bisa menelusuri beberapa level sekaligus.

var e = new ExpandoObject();
e.position.x = 5;
etc...

Itu bukan contoh terbaik, bayangkan penggunaan elegan yang sesuai dalam proyek Anda sendiri.

Sayang sekali Anda tidak dapat membuat kode ini dan mendorong hasilnya ke intellisense. Saya tidak yakin bagaimana ini akan bekerja.

Bersikap baik jika mereka dapat memiliki nilai serta anggota.

var fifteen = new ExpandoObject();
fifteen = 15;
fifteen.tens = 1;
fifteen.units = 5;
fifteen.ToString() = "fifteen";
etc...

Setelah valueTuples, apa gunanya kelas ExpandoObject? kode 6 baris ini dengan ExpandoObject:

dynamic T = new ExpandoObject();
T.x = 1;
T.y = 2;
T.z = new ExpandoObject();
T.z.a = 3;
T.b= 4;

dapat ditulis dalam satu baris dengan tuple:

var T = (x: 1, y: 2, z: (a: 3, b: 4));

selain itu dengan sintaks tuple Anda memiliki inferensi tipe yang kuat dan dukungan intlisense