[C#] Copiare oggetti da una classe all'altra

[liveforever]

Salve a tutti!

Ho un'API (il cui sorgente è a me oscuro) che ha delle proprietà e dei metodi.

Grazie ai vostri consigli ho wrappato tale classe, riducendo proprietà e metodi...lasciando solo la logica di quelli che mi servivano per l'implementazione.

Dovrei ora fare una cosa del genere:

un particolare metodo (chiamiamolo Open()) richiede che gli venga passato un oggeto della classe API originaria.
Poichè io creo e popolo l'oggetto della mia classe wrappata, come fare per "copiare" l'oggetto della mia classe in quello dell'API in modo da passarlo al metodo Open()?

E cosa succede ai metodi esistenti nell'API che però io non dichiaro neppure?

Spero d'esser stato chiaro...

[U235]

non è molto chiaro...

[liveforever]

Beh si, scusa...forse non mi sono spiegato.

Facciamo un esempio:

Ecco la mia API:

class API
{
  costruttore;

  proprietà1;
  proprietà2;

  MetodoAPI1;
  MetodoAPI2;
  MetodoAPI3;
}

Wrappo questa classe in modo da potermi gestire a modo mio tale classe:

classe Wrapper
{
  costruttore;

  proprietàw1;

  MetodoWrap1;   // fa le stesse cose del MetodoAPI1;
  MetodoWrap2;   // fal le stesse cose del MetodoAPI2;
}

Nella mia elaborazione uso, ovviamente, la mia classe...istanzio i miei metodi, uso le mie proprietà.
Arrivato ad un bel momento, però, devo usare un metodo (ad esempio Open()) di cui io non conosco il sorgente (fa parte dello stesso insieme di classi di class API) che accetta in ingresso un'istanza della classe API.
Dovrei quindi prendere il mio oggetto Wrapper e "copiarlo" in API in modo da passarlo ad Open() (che non accetterebbe un oggetto di Wrapper, ma solo di API).

Ora è più chiaro? (speriamoDiSi-speriamoDiSi-speriamoDiSi-speriamoDiSi-)

Grazie mille!

[U235]

immaginavo ma volevo essere certo...

ti faccio un esempio :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Mia_API miaApi = new Mia_API();
            miaApi.Proprieta1 = "QUELLOCHEVUOI";
            miaApi.Proprieta2 = "QUELLOCHETIPARE";
            miaApi.Metodo1();
            miaApi.Metodo2();

            ClasseLavoroAPI clAPI = new ClasseLavoroAPI();
            clAPI.MetodoLavoroAPI(miaApi.API);

            Console.ReadLine();
        }
    }

    public class Mia_API
    {
        API_COD_SCONOSCIUTO api;
        public API_COD_SCONOSCIUTO API { get { return this.api; } protected set { this.api = value; } }

        public Mia_API()
        {
            this.api = new API_COD_SCONOSCIUTO();
        }

        public void Metodo1()
        {
            // codice
            this.api.Metodo1();
        }

        public void Metodo2()
        {
            // codice
            this.api.Metodo2();
        }

        public string Proprieta1 { get { return this.api.Proprieta1; } internal set { this.api.Proprieta1 = value; } }

        public string Proprieta2 { get { return this.api.Proprieta2; } internal set { this.api.Proprieta2 = value; } }
    }

    public class API_COD_SCONOSCIUTO
    {
        public API_COD_SCONOSCIUTO() { }

        string proprieta1;
        public string Proprieta1 { get { return this.proprieta1; } set { this.proprieta1 = value; } }

        string proprieta2;
        public string Proprieta2 { get { return this.proprieta2; } set { this.proprieta2 = value; } }

        public void Metodo1() { }

        public void Metodo2() { }
    
    }

    public class ClasseLavoroAPI
    {
        public ClasseLavoroAPI() { }

        public void MetodoLavoroAPI(API_COD_SCONOSCIUTO api)
        {
            Console.WriteLine(api.Proprieta1);
            Console.WriteLine(api.Proprieta2);
        }
    }
}

praticamente nella classe wrapper crei un oggetto "base" che tieni in una proprietà di sola lettura in modo da averlo disponibile ma allo stesso tempo non modificabile direttamente.

visto cosi' non mi pare abbia molta logica wrappare in questo caso, pero' sicuramente avrai dei buoni motivi per farlo, quindi il suggerimento preciso posso dartelo solo se so effettivamente cosa vuoi fare e perchè lo fai (per nascondere, per semplificare ecc. ecc.) perchè ci sono un infinità di modi per fare cose del genere ed ognuno ha una sua logica.

[liveforever]

GRANDE!

Grazie mille!

[U235]

figurati

[U235]

leggendo un tuo post precedente ho provato a dedurre che cossa volessi fare...

vediamo se ho capito :

a te hanno chiesto di semplificare ad esempio il numero di proprietà oppure di aggiungere un nuovo metodo che sovrasrive uno della classe col cod. a te sconosciuto.

Quindi immaginiamo di applicarlo all'esempio precedente dove noi ora sappiamo che per l'uso personalizzato che dobbiamo farne ha le due proprierà che devono essere uguali e che i due metodi devono restituire lo stesso valore (cosa che nel codice a te sconosciuto non è possibile), quindi concettualmente se hai fatto tutto corretto ci sarà una proprietà che restituisce un boleano e vengono eliminati i due metodi a favore di uno unico, idem per le proprietà.

vediamo come :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Mia_API miaApi = new Mia_API();
            miaApi.Proprieta = "QUELLOCHEVUOI";
            
            ClasseLavoroTuaAPI clTuaAPI = new ClasseLavoroTuaAPI();
            clTuaAPI.MetodoLavoroAPI(miaApi);
            ///potrei ancora chiamare i due metodi di API_COD_SCONOSCIUTO cosi:
            ///clTuaAPI.MetodoLavoroAPI(miaApi.API);
            
            Console.ReadLine();
        }
    }

    public class Mia_API
    {
        API_COD_SCONOSCIUTO api;
        public API_COD_SCONOSCIUTO API { get { return this.api; } protected set { this.api = value; } }
        public bool Correct 
        {
            get 
            {
               return (this.proprieta!=null&&this.api.Proprieta1.CompareTo(this.api.Proprieta2) == 0); 
            }
        }

        public Mia_API()
        {
            this.api = new API_COD_SCONOSCIUTO();
        }

        void setAPI(string value)
        {
            this.api.Proprieta1 = value;
            this.api.Proprieta2 = value;
            this.proprieta = value;
        }
        string proprieta;
        public string Proprieta 
        { 
            get 
            {
                return this.proprieta; 
            } 
            internal set { this.setAPI(value); } 
        }

        public void Metodo()
        {
            if (this.Correct)
            {
                Console.WriteLine("-------------");
                Console.WriteLine("Proprietà unica");
                Console.WriteLine(this.Proprieta);
                Console.WriteLine("-------------");
                Console.WriteLine("Chiamate ai Metodo1 e Metodo2");
                this.api.Metodo1();
                this.api.Metodo2();
                Console.WriteLine("-------------");
            }
            else
            {
                throw new Exception("Impostare la proprietà 'Proprieta'");
            }
        }
    }

    public class API_COD_SCONOSCIUTO
    {
        public API_COD_SCONOSCIUTO() { }

        string proprieta1;
        public string Proprieta1 { get { return this.proprieta1; } set { this.proprieta1 = value; } }

        string proprieta2;
        public string Proprieta2 { get { return this.proprieta2; } set { this.proprieta2 = value; } }

        public void Metodo1() { Console.WriteLine(this.Proprieta1); }

        public void Metodo2() { Console.WriteLine(this.Proprieta2); }

    }

    public class ClasseLavoroAPI
    {
        public ClasseLavoroAPI() { }

        public void MetodoLavoroAPI(API_COD_SCONOSCIUTO api)
        {
            api.Metodo1();
            api.Metodo2();
        }
    }

    public class ClasseLavoroTuaAPI : ClasseLavoroAPI
    {
        public void MetodoLavoroAPI(Mia_API api)
        {
            api.Metodo();
        }
    }
}

in sostanza la classe con la tua api imposta le proprietà della classe api sconosciuta in maniera identica e richiama i due metodi da uno unico controllando che le due proprietà siano uguali.
dopo viene ereditata la classe di lavoro che ha il metodo che richiede il parametro col tipo APi sconosciuta e viene aggiunto un overload che accetta un parametro del tuo tipo api,
in questo modo potrai utilizzare sia l'uno che l'altro con la differenza che se uso il tuo tipo
sarà stato piu' semplice instanziarlo perche avrai settato solo una proprietà e comunque verrà richiamato un solo metodo.


Ho capito bene cosa volevi???

[liveforever]

...meravigliosamente si!

Grazie

[U235]

cerco di essere sempre utile a chi a voglia di imparare (nel mio piccolo ovviamente perchè io stesso ho ancora molto da imparare).

credo che sia questo lo spirito del forum, e non quello di fornire codice a chi non ha voglia nemmeno di modificare un campo e che spesso chiede di fare delle cose enormi senza capire la differenza tra un costruttore e un metodo!!!

[peppebozzo]

Salve, avrei bisogno di aiuto per creare una classe wrapper.. è ancora attiva la discussione?
Il mio problema è abbastanza simile a quello proposto da liveforever, ossia:
Ho necessità di sganciare la reference di una dll da un progetto e inserirne una nuova. Lo scopo è quello di usare i metodi forniti dalla nuova dll senza intervenire su tutta l'applicazione, quindi ho pensato di wrappare la nuova dll inserendo un metodo con lo stesso nome di quello in uso ma che richiama i nuovi metodi: Provo a spiegarmi con un esempio:

namespace OLD_REFERENCE
{     
public class Pippo()
{           
  public static string var1; 
  public static string var2;
  public Pippo();         
  public static void metodo_old (string var1, string var2);         
}
}

namespace NEW_REFERENCE
{     
public static class Pippo()
{                
  public static void metodo_new (string message);         
}
}

Quindi avrei necessità sia di utilizzare la nuova dll ma che a sua volta dovrebbe esporre il metodo_old che richiama il metodo_new.