[c#] aiuto con attributi e assembly!!!

ciao a tutti, chiedo aiuto per due cose che credo per molti siano semplici.
primo attributi:
in particolare mi sono bloccato leggendo un libro sul metodo getcustomattributes, in particolare il libro riporta:
Attribute[] definedAttributes=Attribute.getcustomattributes(assembly1);
dove assembly1 è un oggetto.
il libro dice che tutti gli attributi ricavati vengono ricavati come riferimenti ad Attribute;se si vogliono chiamare metodi o proprietà definite nella classe attributo personalizzato si dovrà fare il cast esplicito a questa classe.
che significa? in questo caso che cast devo fare?? cioè supponiamo che definedattributes[1] valga pippo dove pippo è un oggetto attributo.
se devo usare pippo.metodo cosa devo scrivere?????
altra cosa: sempre nel libro mi sono ritrovato scritto Assembly.load
che carica nel processo l'assembly......però viene anche referenziato in fase di compilazione questo assembly cioè viene referenziata la dll nella stringa di compilazione. perchè portarlo in memoria due volte?
referenziare allora non significa importare e quindi portare in memoria??? confuso!!!!

[Kralizek]

E' molto semplice.

Il metodo in questione ritorna un array di Attribute, che è la classe base (e astratta) da cui derivano tutti gli Attribute. Diciamo che tu hai un attribute definito così (scrivo in C#)

public class PippoAttribute : Attribute
{
     public string MiaProperty { get; set; }
}

Quando userò il metodo Assembly.GetCustomAttributes(Assembly), come già detto avrò un array di Attribute ma, in realtà questi sono un'instanza del tipo effettivo.

Quindi potresti fare qualcosa tipo

Attribute[] attributes = Assembly.GetCustomAttributes(mioAssembly);
string miaProperty = null;
foreach (var attribute in attributes)
{
     if (attribute is PippoAttribute)
          miaProperty = ((PippoAttribute)attribute).MiaProperty;
}

spero di essere stato chiaro

ovviamente questo è solo un codice di esempio, non dovresti scorrerti l'elenco di tutti gli attributi per ottenere una stringa

PS: scusa se non ti ho risposto ancora al pm, ma non sono stato bene in questi giorni, nel w-e ti rispondo.

scusa ma non ho capito....
allora i cast che conosco sono:
cast tra classe base e derivate:
myderived derivedobject=new myderived();
mybase basecopy=derivedobject;
ovvero il polimorfismo
oppure
mybase derivedobject=new myderived();
mybase baseobject=new mybase();
myderived derivedcopy1=(myderived)derivedobject
che posso fare perchè derived object è un riferimento alla classe base che però punta ad una istanza della derivata.

Mentre il libro dice che il cast tra istanza base e istanza derivata non si può fare!!! cioè quello che fa quel maledettissimo attributo! quindi la sintassi che hai scritto tu che roba è? che tipo di cast è?

ragazzi ho capito!!!! la risposta sta nella teoria del polimorfismo....sobb che idiota......
allora se io faccio
Base someBase = new Derived();
Derived someDerived = (Derived)someBase;
questo cast esplicito funziona solo se somebase in effetti puntava ad una istanza della classe derivata! ed è vero, altrimenti lancerebbe una eccezione.
in effetti quelloche si casta nn è l'istanza che rimane tale ma il tipo!
cioè quello che conta nelle chiamata dei vari metodi.
mi spiego: nel caso in cui lancio un metodo di somebase, ad essere lanciato è il metodo della derivata se è stato fatto un override.
d'altra parte se lancio un metodo di derived() che non esiste nella classe base
esempio: somebase.metododiderived() ovviamente da errore....
quindi tornando all'esempio del grandissimo kralizek


Attribute[] attributes = Assembly.GetCustomAttributes(mioAssembly);
string miaProperty = null;
foreach (var attribute in attributes)
{
if (attribute is PippoAttribute)
miaProperty = ((PippoAttribute)attribute).MiaProperty;
}

in questo caso avremo una serie di tipi attributi (array) che puntano a istanze di Pippoattribute, e si può fare per il polimorfismo, che però per poter essere usate come pippoattribute (se lo erano in principio e lo erano) devono essere ricastate esplicitamente come pippoattribute.


A conclusione di tutto vi mostro un esempio della msdn:

DerivedClass B = new DerivedClass();
B.DoWork(); // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork(); // Also calls the new method.

dove si può notare che anche se si fa (BaseClass)B, essendo B tipoderivato, ad essere lanciato è il nuovo metodo di cui si è fatto override in precedenza.

in pratica è come se si fosse scritto

BaseClass A= new DerivedClass();



SPERODI ESSERE STATO CHIARO, se non lo sono stato o ho detto qualche fesseria spero che mi correggiate! da una buona teoria, si ottiene una solida pratica!!!!

[Kralizek]

tutto chiaro ma l'esempio che hai postato è "poco" pertinente perchè, dato il codice che hai postato,

DerivedClass B = new DerivedClass();
B.DoWork(); // Calls the new method.

BaseClass A = (BaseClass)B;
A.DoWork(); // Also calls the new method.

il problema non è quando il metodo DoWork() è un metodo della classe base eventualmente ridefinito (quindi virtual o abstract) nella classe derivata.
Il problema di cui si parlava è quando il metodo è un metodo presente solo nella classe derivata e per questo bisogna dire esplicitamente al compilatore il tipo dell'oggetto in modo da trattarlo come DerivedClass e non come BaseClass

Volendo fare un esempio di codice si potrebbe scrivere qualcosa tipo

public abstract class Canide
{
      public void Corri() { ... }
      public abstract void EmettiVerso();
}

public class Cane : Canide
{
      public override void EmettiVerso() { /* codice per abbaiare */ }

      public void InseguiBastone(Bastone bastone) { ... }
}

public class Lupo : Canide
{
      public override void EmettiVerso() { /* codice per ululare */ }

      public void AzzannaAgnello(Agnello agnello) { ... }
}

date le tre classi così definite, supponiamo ci sia un metodo GetCanidi() che ritorna un array di Canidi, naturalmente, essendo Canide una classe astratta, nell'array non ci sarà alcuna istanza della classe Canide bensì, istanze delle classi derivate da Canide

Canide[] canidi = CanidiHelper.GetCanidi();

public static Canide[] GetCanidi()
{
      return new[]
      {
            new Cane(),
            new Lupo()
       };
}

come puoi vedere in canidi abbiamo un cane ed un lupo. Nota bene: noi lo sappiamo, il compilatore no.

Se scriviamo qualcosa tipo

foreach (var canide in canidi)
{
     canide.EmettiVerso();
}

funziona perchè EmettiVerso è un metodo definito nella classe base ed reimplementato (come si traduce "overrided" in italiano?) nelle classi derivate perchè abstract.

Se invece proviamo ad invocare su canide i metodi delle classi derivate, riceveremo una sequele di maledizioni in aramaico antico da IntelliSense e csc (il compilatore).

Per invocare tali metodi occorre notificare il compilatore del tipo effettivo degli oggetti e per questo si usa il cast, dopo aver eventualmente controllato il tipo con l'operatore "is".

Forse sono stato un po' prolisso

prolisso ma chiaro come al solito!!!