C # Tipo conversione

Question

Ho due oggetti. Oggetto A e B oggetto.

L'oggetto A è un'istanza di una classe che è stato generato da diversi file XSD. xsd.exe Usato / c e compilati. Ora ho il mio nuovo oggetto.

Ho anche un servizio web, restituendo qualcosa di molto simile ad oggetto A. Così adesso ho qualcosa sulla falsariga di questo:

WebService.foo myResponseObj = MyService.GetObject(inData);
MyFramework.foo myClientObj = new MyFramework.foo();

Quello che voglio fare è questo

myClientObj = (MyFramework.foo)myResponseObj

Tuttavia, non è davvero i gusti di questa. Dice "Impossibile convertire implicitamente MyFramework.foo [] per WebService.foo []

Tutte le idee su come risolvere questo? L'oggetto è abbastanza grande e sono sostanzialmente identiche.

Answer 1

Come sull'estrazione di interfaccia (tasto destro del mouse su una classe, selezionare Refactor-> Estrai Interface), e applicare questa interfaccia per entrambe le classi?

Così sarà simile a:

namespace WebService
{
   public class foo : IExtractedInterface
}

e

namespace MyFramework
{
   public class foo : IExtractedInterface
}

Si dovrebbe quindi essere in grado di fare:

IExtractedInterface myClientObj = (IExtractedInterface)myResponseObj;

Answer 2

Entrambi gli oggetti avrebbe bisogno di ereditare dalla stessa interfaccia, al fine di eseguire correttamente il cast è stato specificato. Si potrebbe guardare tirando fuori il metodo comune (s) è necessario in un'interfaccia che può essere implementato in entrambe le classi, in questo modo si può semplicemente lanciare il tipo di interfaccia e quindi avere accesso a solo quei metodi, piuttosto che l'intero oggetto.

Enjoy!

Answer 3

È necessario un metodo che converte una classe nell'altro copiando manualmente tutte le proprietà.

È quindi possibile chiamare quel metodo Array.ConvertAll.

Answer 4

Loro essere "sostanzialmente identico" è insufficiente. Si può lanciare solo tra due oggetti se sono di tipo-compatibili, il che significa che essi condividono un discendente comune e i tipi effettivi sono validi per la fusione.

Ad esempio, le seguenti opere se Circle è un discendente di Shape:

Shape x = new Circle();
Circle y = (Circle)x;

Tuttavia, i seguenti non evento di lavoro se ClassA e ClassB hanno gli stessi campi esatte, ma non sono in realtà discendono l'una dall'altra:

ClassA a = new ClassA();
ClassB b = (ClassA)a;

Può essere utile per farli entrambi implementare un'interfaccia comune, allora si potrebbe lanciare a tale interfaccia e usarli nel modo desiderato.

Answer 5

Questo è fondamentalmente risposto già . Si noti, tuttavia, che, oltre a ciò che è stato risposto qui, c'è un piccolo barlume di speranza fornito dalla funzionalità di .NET di 4 nuovi "Tipo di equivalenza":

Si noti tuttavia che C # 4 sosterrà un forma limitata di battitura strutturale interfacce. Vedere http :. //blogs.msdn.com/samng/archive/2010/01/24/the-pain-of-deploying-primary-interop-assemblies.aspx per i dettagli

Questo è abbastanza avanzata NET-foo, però.

Answer 6

Se si utilizza lo strumento WSDL.exe standard per creare il proxy e classi di supporto, quindi credo che genera il codice come classi parziali. Se questa è la vostra situazione, allora si potrebbe inserire il proprio operatore di conversione implicita a uno dei tipi. Per esempio, diciamo che avete la vostra classe MyService.foo definito nel file "MyService \ foo.cs", come di seguito:

namespace MyService
{
    public partial class foo
    {
        public string PropertyA { get; set; }
        public string PropertyB { get; set; }
        public string PropertyC { get; set; }
        // ...
    }
}

e si ha la classe MyFramework.foo definita nel file "MyFramework \ foo.cs", come di seguito:

namespace MyFramework
{
    public class foo
    {
        public string PropertyA { get; set; }
        public string PropertyB { get; set; }
        public string PropertyC { get; set; }
        // ...
    }
}

Quindi è possibile creare un file separato, diciamo "MyService \ foo.conversion.cs", come di seguito:

namespace MyService
{
    partial class foo
    {
        public static implicit operator MyFramework.foo(foo input)
        {
            return new MyFramework.foo
            {
                PropertyA = input.PropertyA,
                PropertyB = input.PropertyB,
                PropertyC = input.PropertyC,
                // ...
            };
        }
    }
}

E che permetterebbe di scrivere la maggior parte del codice utilizzando un oggetto MyService.foo come se fosse un oggetto MyFramework.foo. I seguenti compila codice con la messa a punto di cui sopra:

        MyService.foo x = new MyService.foo();

        MyFramework.foo y = x;

Answer 7

Se si tratta di un array, che la citazione che hai dato suggerisce, allora dovete scorrere l'insieme di risposta e aggiungere gli oggetti membro nella collezione cliente.