Wat is die ware voordele van ExpandoObject?

StackOverflow https://stackoverflow.com/questions/1653046

  •  22-07-2019
  •  | 
  •  

Vra

Die ExpandoObject die klas word bygevoeg aan .NETTO 4 kan jy arbitrêr stel eienskappe op'n voorwerp by runtime.

Is daar enige voordele om hierdie oor die gebruik van'n Dictionary<string, object>, of eintlik selfs'n Hashtable?So ver as wat ek kan vertel, is dit niks anders as'n hash tafel wat jy kan toegang met effens meer bondige sintaksis.

Byvoorbeeld, hoekom is dit:

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

Regtig beter, of wesenlik anders, as:

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

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

Wat real voordele is verkry deur gebruik te maak van ExpandoObject in plaas van net die gebruik van'n arbitrêre woordeboek tipe, ander as dit nie voor die hand liggend dat jy met behulp van'n tipe wat gaan bepaal word by runtime.

Was dit nuttig?

Oplossing

Sedert ek die MSDN artikel waarna jy verwys het, ek dink ek moet hierdie een te beantwoord.

In die eerste plek het ek verwag hierdie vraag en dit is hoekom ek geskryf het 'n blog post wat 'n min of meer werklike gebruik geval vir ExpandoObject toon: Dynamic in C # 4,0: bekendstelling van die ExpandoObject .

Kort, ExpandoObject kan jou help om komplekse hiërargiese voorwerpe te skep. Byvoorbeeld, dink dat jy 'n woordeboek in 'n woordeboek: 

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"]);

Die dieper is die hiërargie, die leliker is die kode. Met ExpandoObject dit bly elegante en leesbaar. 

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

In die tweede plek as dit reeds uitgewys, ExpandoObject implemente INotifyPropertyChanged koppelvlak wat jou meer beheer oor eienskappe as 'n woordeboek gee.

Ten slotte, kan jy gebeurtenisse by te voeg om ExpandoObject soos hier: 

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;

       if (e != null)
       {
           e(d, new EventArgs());
       }

       // We could also fire it with...
       //      d.MyEvent(d, new EventArgs());

       // ...if we knew for sure that the event is non-null.
   }

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

Ander wenke

Een voordeel is vir die binding van scenario's.Data roosters en eiendom roosters sal haal die dinamiese eienskappe via die TypeDescriptor stelsel.Daarbenewens, WPF data bindend sal verstaan dinamiese eienskappe, so WPF beheer kan bind aan'n ExpandoObject meer geredelik as'n woordeboek.

Interoperabiliteit met dinamiese tale, wat sal verwag word om DLR eienskappe eerder as woordeboek inskrywings, kan ook'n oorweging in sommige scenario's.

Die werklike voordeel vir my is die totaal moeiteloos data bindend van XAML: 

public dynamic SomeData { get; set; }

... 

SomeData.WhatEver = "Yo Man!";

... 

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

Interop met ander tale wat gebaseer is op die DLR is # 1 rede waaraan ek kan dink. Jy kan hulle nie slaag 'n Dictionary<string, object> as dit is nie 'n IDynamicMetaObjectProvider. Nog 'n bykomende voordeel is dat dit implemente INotifyPropertyChanged wat beteken in die databinding wêreld van WPF dit het ook bykomende voordele as wat Dictionary<K,V> jy kan verskaf.

Dit gaan alles oor programmeerder gerief. Ek kan my voorstel skryf vinnige en vuil programme met hierdie voorwerp.

Ek dink dit sal 'n sintaktiese voordeel hê, want jy sal nie meer dinamies bygevoeg eienskappe "vervalsen" deur die gebruik van 'n woordeboek.

Dit, en interop met dinamiese tale sou ek dink.

Dit is byvoorbeeld uit 'n groot MSDN artikel oor die gebruik van ExpandoObject vir die skep van dinamiese ad hoc tipes vir inkomende gestruktureerde data (dws XML, into).

Ons kan ook toewys aan ExpandoObject se dinamiese eiendom: 

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

So dit stel ons in staat om 'n paar logika spuit in dinamiese voorwerp tydens looptyd. Daarom, saam met lambda uitdrukkings, sluitings, dinamiese navraag en DynamicObject klas , kan ons 'n paar elemente van funksionele programmering te voer in ons C # kode, wat ons weet van dinamiese tale as soos JavaScript of PHP.

Daar is 'n paar gevalle waar dit handig te pas kom. Ek sal dit gebruik vir 'n modulair dop byvoorbeeld. Elke module definieer sy eie Configuration Dialog databinded om dit instellings. Ek gee dit met 'n ExpandoObject as dit Datacontext en stoor die waardes in my opset berging. Op hierdie manier die opstelling dialoog skrywer het net om te verbind tot 'n Waarde en dit is outomaties geskep en gered. (En aan die module vir die gebruik van hierdie instellings natuurlik)

Dit net makliker om te gebruik as 'n woordeboek. Maar almal moet bewus wees dat intern dit is net 'n woordeboek.

Dit is soos LINQ net sintaktiese suiker, maar dit maak dinge soms makliker.

So om jou vraag direk beantwoord: Dis makliker om te skryf en makliker om te lees. Maar tegnies is dit in wese is 'n Dictionary<string,object> (Jy kan selfs gooi dit in een aan 'n lys van die waardes). 

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

Ek dink dat net werk, want alles het'n ToString(), anders sal jy het om te weet, die tipe wat was dit en gooi die voorwerp aan dat die tipe.

Sommige van hierdie is nuttig om meer dikwels as ander, ek probeer om te wees om deeglike.

  1. Dit kan wees baie meer natuurlike toegang tot'n versameling, in hierdie geval wat is effektief'n "woordeboek", met behulp van die meer direkte dot-notasie.

  2. Dit lyk asof dit kan gebruik word as'n baie mooi Tuple.Jy kan nog steeds noem jou lede "Item1", "Item2" ens...maar nou is jy hoef nie te, dit is ook wispelturig, in teenstelling met'n Tuple.Dit het wel die groot nadeel van die gebrek van intellisense ondersteuning.

  3. Jy kan ongemaklik wees met "lid name soos snare", soos die voel met die woordeboek, kan jy voel dit ook soos "die uitvoering van snare", en dit kan lei tot die benaming konvensies om gekodeer in, en die hantering van die werk met morphemes en lettergrepe toe kode is om te probeer verstaan hoe om te gebruik om lede :-P

  4. Kan jy ken'n waarde aan'n ExpandoObject self, of net dit se lede?Vergelyk en kontrasteer met dinamiese/dinamiese[], gebruik wat ook al die beste pas by jou behoeftes.

  5. Ek dink nie dinamiese/dinamiese[] werk in'n foreach lus, jy het om te gebruik var, maar dalk kan jy gebruik ExpandoObject.

  6. Jy kan dit nie gebruik as'n dinamiese data lid in'n klas, miskien, want dit is ten minste'n soort van soos'n navraag, hopelik kan jy met ExpandoObject.

  7. Ek verwag dat dit "is" 'n ExpandoObject, kan nuttig wees om die etiket baie generiese dinge uitmekaar, met'n kode wat'n onderskeid gebaseer op die tipe waar daar is baie van die dinamiese dinge wat gebruik word.

Lekker wees as jy kan boor af verskeie vlakke in'n keer.

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

Dis nie die beste moontlike voorbeeld, dink elegante gebruik soos toepaslik in jou eie projekte.

Dit is'n skande, jy kan nie die kode bou sommige van hierdie en die druk van die resultate te intellisense.Ek is nie seker hoe dit sou werk al.

Lekker wees as hulle kan'n waarde sowel as lede.

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

Na valueTuples, wat is die nut van ExpandoObject klas? hierdie 6 lyne kode met ExpandoObject: 

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

geskryf kan word in een lyn met tuples: 

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

behalwe met tuple sintaksis jy het 'n sterk tipe afleiding en intlisense ondersteuning

Gelisensieer onder: CC-BY-SA met toeskrywing
Nie verbonde aan StackOverflow
scroll top