Newsgroup: it.comp.lang.visual-basic
Titolo: Ora son serio invece: Riferimenti Assembly

Abbiate pazienza ma sto riprendendo un "vecchio" progetto (spippolato 
purtroppo anche da altri) e mi stanno saltando fuori errori su errori.
 
Progetto1 (Tipo libreria classi)definisce una serie di Tipi e Una 
interfaccia
 
Progetto2 (tipo libreria di classi) Implements Progetto1 e relativo 
codice accessorio
 
Progetto3 (tipo winform)  Consumatore di progetto2:
Referenzia Progetto 2
al primo uso di Dim pippo as OggettoProgetto2
PRRRRRRRRR
mi chiede di mettere nelle referenze anche progetto1 UH! UH!
Un mese fa non me lo chiedeva(perderebbe la sua ragione d'essere)! Che 
stracaz hanno spippolato?
 
Mi dichiara
 
Public Class frmMostraAnagrafica
    Dim myGESTDB As clSQLiteplugin
......
Errore	1	Necessario un riferimento all'assembly 'DBapi, 
Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' contenente 
l'interfaccia implementata 'DBapi.InterfaceAPI_db'. Aggiungerne uno al 
progetto.
 
E che cavolo....funzionava tutto!Maremma a macchie di bit!!!!
 
-- 
----- Italliaaaaa 3227! -----
Ti prego, ti prego, non ci uccidere. Ti prego baby, lo sai che ti amo. 
Non avrei mai voluto lasciarti, non è stata colpa mia. Davvero, sono 
sincero. Quel giorno finì la benzina. Si bucò un pneumatico. Non avevo 
i soldi per il taxi! Il mio smoking non era arrivato in tempo dalla 
tintoria! Era venuto a trovarmi da lontano un amico che non vedevo da 
anni! Qualcuno mi rubò la macchina! Ci fu un terremoto! Una tremenda 
inondazione! Un'invasione di cavallette!
John Belushi [da "Blues Brothers"]
 
 

 E che cavolo....funzionava tutto!Maremma a macchie di bit!!!!
 
Trovato....dll sbagliata....
avevo  usato ILMERGE per linkarle in un unica dll!
Che palle però
 
faccio una domanda ai guru allora per non sprecare il post
PREMETTO
 che MOOOOLTO probabilmente sparo cazzate data la mia ancora non 
approfondita conoscenza delle problematiche oop!
 
Esempio
Oggetto A implementa interfaccia1
Oggetto B implementa interfaccia2
Oggetto C implementa interfaccia3
Ognuno in un assembly diverso...in una dll addirittura diversa!
 
A richiama i metodi di B tramite interfaccia2
B richiama i metodi di C tramite interfaccia3
 
Perchè se in un programma USO l'oggetto A DEVO (come prima) istanziare 
nei riferimenti anche interfaccia 2 3 pena messaggio di errore???
 
Leggo nei vari post perchè DotNet NON implementa il linking statico.
ILMERGE parzialmente mi aiuta! Nel visualizzatore oggetti mi appaiono 
però tutte le interfacce ed anche nell'intellisense!
 
Però a me dal mio programma Winform me ne fregherebbe di conoscere 
Interfaccia1 per usare l'oggetto A...me ne impiperebbe proprio poco di 
cosa fa lui dietro le quinte e di quante interfacce usa!
Anzi nascondere interfaccia 2 e 3 mi farebbe proprio comodo da dentro 
il programma che usa Oggetto A!
 
Eppure non trovo doc (cercherò male di sicuro)!
Ma le classi derivate non si possono nascondere? non esiste uno shadow 
per le interfacce????(anche se qui la complicazione è che stanno in 
assembly diversi)
 
Grazie
e scusate se ho sparato cazzate! :P
 
-- 
----- Italliaaaaa 3227! -----
Guerrieriii....giochiamo a fare la guerraaa!.... 
Guerrieriii....giochiamo a fare la guerraaa!.... 
Guerrieriii....giochiamo a fare la guerraaa!....
 
I guerrieri della notte (1987)
 
 

 Ha detto: Wodka40°
...alla fin fine forse il mio problema è proprio di mancanza di basi 
teoriche.
Se considero le interfacce come mi ha detto più volte Mauro cone 
contratti con il quale interagire con l'oggetto...
 
Alla fin fine io vorrei un OGGETTO A che mi espone SOLO una interfaccia 
per usarlo.
Se per usare il metodo TrovaFattura deve istanziare un altro oggetto 
che ne deve richiamare un altro...ognuno tramite la sua interfaccia di 
"chiamata"...io vorrei che ciò fosse trasparente a chi usa OggettoA.
 
Non vorrei che nel progetto che usa OggettoA sia obbligatorio 
referenziare le interfacce di chiamata  do Oggetto1 2 3 4 ...n!
 
Mi sembra che in VB6 si faceva una cosa simile creando non dll ma 
oggetti EXEserver che esponevano dei metodi che si potecano richiamare.
 
In net mi vengono in mente un sacco di cose caotiche anche antitetiche!
 
a) La più semplice usare ILMERGE mettere tutto in una dll ed 
usarla....ma il programmatore vede anche le interfacce varie che non 
servono!
 
b) Usare reflection caricare la dll e trovare l'interfaccia che espone
ma non sempre mi riesce farlo funzionare!
 
c) fare programmi separati e richiamarli pramite wcf....ho fatto dei 
test ma è lento!
 
LO SCOPO?
lo scopo è costruire mattoni lego a prova di fesso
ad es.
 
Un mattoncino si occupa di gestire le query per access/sqlite/quel che 
è
Lo usi solo con l'interfaccia dbAPI es. dbPostgres.dll
 
Un mattoncino si occupa di decodificare una richiesta fatta attraverso 
una interfaccia di interrogazione generica e passarla in maniera 
corretta al mattoncino del database es. GestDB.dll
 
Un mattoncino riceve una richiesta dall'utente e lo parserizza valida 
trasforma e lo passa al mattoncino Validareq.dll
 
Un mattoncino riceve la risposta e la "tratta" e se desiderato la 
visualizza stampa es. GUI.dll
 
Un mattoncino generale per chiamate risposte es logicaBusiness.dll
 
Nella mia mente esiste uno schema cosi fatto allora
 
APPLICAZIONE
|........................................................|
RIFERIMENTI: solo logicaBusiness.dll
 form input
 
      Oggetto LogicaBusiness espone una interfaccia per INPUT /OUTPUT
es.
try
  if LogicaBusiness.InputDati(Lista,Azione) then
     Display LogicaBusiness.OutputDati
  end if
 
catch eventoLogicaBusiness
 
end try
 
Una cosa del genere suppergiù mi riesce....con reflection e caricamento 
di plugin...
Il rovescio della medaglia è che ho nel progetto principale...TUTTE le 
interfacce esposte! se non le referenzio....mi scoppia l'app 
principale!
 
Una cosa del genere non mi soddisfa al 100%: finchè sono io a 
spippolare va bene. In mano a  terzi meno "occasioni di spippolamento" 
fornisco meglio è!...ma anche per me....fra 3 mesi un anno...se mi 
capita di rimetterci mano...vorrei cambiare solo il mattoncino che mi 
interessa (ad esempio ottimizzare il metodo di chiamata di una 
query...o cambiare una formula di calcolo di un indice...oppure 
lasciare l'interfaccia intatta ma riscrivere ex novo un modulo...)
 
Dove sto sbagliando a ragionare in questo modo?.....insegnatemi se 
volete!


 e scusate se ho sparato cazzate! :P
 
.m
 
-- 
blog @ //
milestone.topics.it
 
 
 

 Dove sto sbagliando a ragionare in questo modo?.....insegnatemi se volete!
 
facciamo un esempio in cui il concetto di composizione è vitale, io e 
te lavoriamo insieme e in quei pochi momenti in cui non spariamo 
cazzate ci rendiamo conto che abbiamo un problema vero: io sono a 
Bergamo e tu a Prato...ora...io sono quello che nel progetto gestisce 
lo strato di presentazione, la UI, mentre tu ti occupi della logica di 
business e di tutto lo strato di persistenza.
 
come facciamo a lavorare a distanza? composition.
 
Ci sediamo davanti a skype un giorno intero, a webcam rigorosamente 
spenta, e decidiamo (sto semplificando al massimo) quali sono i 
comportamenti che vogliamo che l'applicazione esponga (in C# per 
semplicità/comodità mia):
 
interface IInvoiceManagementService
{
   IEnumerable<Invoice> GetAllInvoices( String customerId );
   Invoice CreateNewInvoice( String customerId, 
IEnumerable<SoldProduct> products );
}
 
tutto in un assembly "AmazingApplication.Contracts.dll", punto solo 
contratti niente logica niente di niente. Contratti e oggetti di 
dominio.
 
Adesso sia io che te abbiamo un punto di riferimento. Io faccio un 
nuovo progetto WPF in cui referenzio AmazingApplication.Contracts.dll e 
scrivo tutta la mia UI a fronte di quei contratti, per fare i test 
faccio così:
 
- scrivo una AmazingApplication.Contracts.Fakes.dll in cui implemento i 
contratti cablando nel codice le risposte e le chiamate;
 
- utilizzo un framework per Inversion of Control per caricare da 
configurazione la dll "Fake" senza che l'applicazione sappia nulla;
 
Tu dal canto tuo crei l'implementazione per Sql Server 
AmazingApplication.Contracts.SqlServer.dll che implementa i contratti 
quando abbiamo finito me la dai, io la butto nella bin cambio la 
configurazione e l'applicazione parte e fa quello che deve fare.
 
Ovvio che questa semplificazione è effettivamente estrema, ma alla fine 
della fiera lo scopo è proprio quello non avere una dipendenza tra te e 
l'implementazione concreta di una certa cosa, tu dipendi dal contratto, 
tu conosci solo l'interfaccia e l'infrastruttura che usi ti garantisce 
che a runtime ci sarà effettivamente qualcuno che implementa 
quell'interfaccia.


zac
 
quello che mi riesce difficile da capire a livello teorico è questo
 
 interface IInvoiceManagementService
 {
    IEnumerable<Invoice> GetAllInvoices( String customerId );
 
se GetAllInvoices nella sua implementazione reale si appoggia su ad 
esempio ad un plugin che usa
Public interface InterfaceAPI_db
{
	System.Data.DataTable CaricaDataTable(string NomeTabella, string 
QuerySQL);
 
}
 
 
Il plugin lo carico al volo uso reflection...mi sembra di usare tutto 
quello che dici....mi è impazzito l'intellisense...o deve fare così?
Perchè quando creo una applicazione di test come hai detto...vuole che 
metta nei riferimenti anche la dll che contiene InterfaceAPI_db ???
Io invoco GetAllInvoices se la veda lui che richiamare e linkare
Forse il mio problema è questo...uso il termine linkare che in C ha 
senso ma forse qui non ha senso!
 
Non mi so spiegare...è un limite grave mio che è autodidatta e non ha 
studi a livello di ingegneria informatica...
Gradirei avere una "gerarchia di interfacce" ed un "linking 
dinamico"...una cosa del tipo...
 
In una applicazione referenzio o carico al volo una dll che contiene 
OggettoA
 
USO/CHIAMO OggettoA tramite la sua interfaccia che è quella comune su 
cui ci ci siamo messi d'accordo....
 
se  OggettoA per sodddisfare il metodo invocato richiama OGGETTOXX 
(caso mai pure in un altra dll) tramite un altra interfaccia...a me non 
me ne dovrebbe fregare: perchè sto usando una dll compilata...non 
conosco il codice di OggettoXX  che OggettoA chiama per soddisfare la 
mia richiesta...non mi interessa...non lo voglio tra i piedi!!!
 
Faccio un altro esempio WORD espone un interfaccia com (anche se 
deprecato) possiamo usarla! Ma al di la di quei metodi che mi fa vedere 
non conosco le infinite dll(e credo relative interfacce) che richiama 
per soddistare ad esempio il metodo che crea un nuovo documento.
 
Abuso della tua pazienza lo so...se passi da Prato una boccia di vino 
di quello buono te la offro!
 
-- 
----- Italliaaaaa 3227! -----
Io sono Attila:
A come atrocità,
doppia T come terremoto e tragedia,
I come ira di dio,
L come laco ti sangue
e A come adesso vengo e ti sfascio le corna!
(Diego Abatantuono "Attila Flagello di Dio")
 
 

 quello buono te la offro!
 
:-)
