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 :
codice:
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???