Perché a volte (a volte) devo fare riferimento agli assiemi a cui fa riferimento l'assieme riferimento?

Question

Ho un assembly A, che definisce un'interfaccia con alcuni sovraccarichi:

public interface ITransform 
{ 
    Point InverseTransform(Point point); 
    Rect InverseTransform(Rect value); 
    System.Drawing.Point InverseTransform(System.Drawing.Point point); 
} 

... e un gruppo B che fa riferimento A (binario, non il progetto) e chiama uno dei sovraccarichi:

var transform = 
    (other.Source.TransformToDisplay != null && 
    other.Source.TransformToDisplay.Valid) ? 
    other.Source.TransformToDisplay : null; 
if (transform != null) 
{ 
    e.Location = transform.InverseTransform(e.Location); 
} 

Per essere precisi, chiama il System.Windows.Point overload del metodo InverseTransform, perché questo è il tipo di proprietà Location in e.

Ma quando ho costruire B nell'IDE ottengo:

errore CS0012: Il tipo 'System.Drawing.Point' è definito in un assembly che non viene fatto riferimento. È necessario aggiungere un riferimento all'assembly 'System.Drawing, Version = 4.0.0.0, Culture = neutral, PublicKeyToken = b03f5f7f11d50a3a'.

anche se questo non è nemmeno il sovraccarico che sto chiamando. Quando commento la riga in cui viene chiamato il metodo sovraccarico InverseTransform, esso funziona bene anche se sto ancora creando un'istanza di un oggetto di tipo ITransform.

Perché? E c'è un modo per risolvere questo problema senza dover aggiungere un riferimento a System.Drawing ovunque?

Answer 1

Il compilatore deve sapere cos'è un System.Drawing.Point per dimostrare che non è il sovraccarico corretto (ad esempio, se ha una conversione implicita).

Answer 2

Questo metodo utilizza qualcosa definito in System.Drawing. Se si disapprova, tale assembly non tenterà più di utilizzare System.Drawing; quindi, nessun requisito.

Pensateci in questo modo, quando andrete a svolgere la vostra azione. NET dice ok Sto facendo una chiamata a questo tizio definito in questo assembly e cerco il codice appropriato da eseguire. Non riesce a trovarlo, quindi getta le sue mani e dice che mi arrendo e dimmi dov'è.

Basta prendere l'abitudine di fare riferimento a tutte le DLL che si potrebbero potenzialmente utilizzare.

Answer 3

namespace ClassLibrary1 
{ 
    public interface ITransform 
    { 
     dynamic InverseTransform(dynamic point); 
    } 
} 

using ClassLibrary1; 
using Moq; 
namespace ConsoleApplication9 
{ 
    interface IPoint { } 
    class Point : IPoint { } 

    class Program 
    { 
     static void Main(string[] args) 
     { 
     var transform = new Mock<ITransform>(); 
     IPoint x = transform.Object.InverseTransform(new Point()); 
     } 
    } 
} 

Invece di ciò che non si può fare dicendo ...

Un modo per risolvere questo comporterebbe l'introduzione di IPoint Transform (IPoint x) come l'unico metodo nell'interfaccia, insieme all'interfaccia IPoint . Ciò significherebbe che System.Drawing dovrebbe essere conforme anche al tuo IPoint.

Se si desidera tale livello di disaccoppiamento, viene in mente una parola chiave dinamica, poiché non è possibile ottenere Drawing.Point per implementare un'interfaccia dopo il fatto. Assicurati solo di avere una copertura di test unitaria davvero eccezionale su questa parte di codice, e aspettati che funzioni un po 'più lentamente.

In questo modo, è sufficiente fare riferimento a System.Drawing solo negli assiemi in cui lo si sta effettivamente utilizzando.

EDIT Riflettore che indica la firma di System.Drawing.Point è

[Serializable, StructLayout(LayoutKind.Sequential), TypeConverter(typeof(PointConverter)), ComVisible(true)] 
public struct Point { } 

Answer 4

Per risolvere questo (e fornendo non avete troppo chiamate per avvolgere ecc)
si può semplicemente definire un involucro estensione per che 'Point' chiamata si sta utilizzando solo per esempio

public static Point MyInverseTransform(this ITransform mytransform, Point point) 
{ 
    return mytransform.InverseTransform(point); 
} 

... alimentare che lib (dove l'estensione è) il riferimento System.Drawing
(e per evitare di dover aggiungere la 'involucro lib' dappertutto come sarebbe vanificato l'obiettivo, appena messo in un po 'di libbia comune a cui hai già fatto riferimento, correlata al problema. La migliore è se parte della lib' sorgente 'ma dicendo nel caso non sia possibile cambiarla ...

e chiamarlo poi tramite MyInverseTransform.

Answer 5

L'unica differenza tra i sovraccarichi sono i tipi. Questo è il motivo per cui il compilatore non può distinguere quale sovraccarico stai usando senza guardare il tipo.

Poiché il tipo non fa riferimento all'assembly in esecuzione, il compilatore non conosce il tipo e richiede un riferimento diretto all'assembly che contiene la definizione del tipo.

Ho eseguito personalmente questo problema e non desideravo aggiungere un riferimento diretto all'assembly che contiene il tipo. Ho semplicemente aggiunto un argomento (booleano) a uno dei metodi in modo che non siano più sovraccarichi l'uno dell'altro. Il compilatore ha quindi compreso la differenza tra i metodi, anche se hanno lo stesso nome, perché hanno una quantità diversa di argomenti. Non è più necessario un riferimento all'assembly che contiene il tipo. So che non è una soluzione ideale, ma non sono riuscito a trovare un'altra soluzione in quanto il mio metodo era un costruttore quindi non potevo cambiare la sua firma in nessun altro modo.