È possibile evitare molte dichiarazioni usando?

Question

È possibile evitare molte dichiarazioni usando?

#1 da (4 voti)

1

Diciamo che ho un codice semplice come questo ( fiddleLink ):

using System;

public class Program
{
    public static void Main()
    {
        //Dependency register logic here
        var service = new DataServiceAdapter();
        var client = new Client(service);
        Foo(client);
    }

    //Work class
    public static void Foo(Client client)
    {
        client.ClientMethod();
    }
}

public class Client
{
    private readonly IDataService _service;
    public Client(IDataService service)
    {
        _service = service;
    }

    public void ClientMethod()
    {
        Console.WriteLine(_service.Method());
        Console.WriteLine(_service.Method2("Hello"));
    }
}

internal class DataServiceAdapter : IDataService
{
    public bool Method()
    {
        using (var something = new SpecifiDataService())
        {
            return something.Method();
        }
    }

    public int Method2(string arg)
    {
        using (var something = new SpecifiDataService())
        {
            return something.Method2(arg);
        }
    }
}

public class SpecifiDataService : IDataService, IDisposable
{
    public bool Method()
    {
        return true;
    }

    public int Method2(string arg)
    {
        return arg.Length;
    }

    public void Dispose()
    {
        //Dispose logic here
    }
}

public interface IDataService
{
    bool Method();
    int Method2(string arg);
}

L'obiettivo che voglio raggiungere è incapsulare using logic dal client da qualche altra parte (in particolare in DataServiceAdapter class).

C'è un modo per scrivere l'istruzione using solo una volta e non ripeterlo in ogni singolo metodo?

P.S. SpecifiDataService può essere un servizio client WCF o DbContext di EntityFramework. Entrambi dovrebbero avere una vita breve, quindi non posso semplicemente aprire una connessione e lavorare con essa.

P.P.S Non riesco a riutilizzare SpecificDataService perché in questo caso sarà l'implementazione WCF proxy-client o EntityFramework DbContext . Entrambi i casi contengono dozzine di chiamate di metodo, quindi devo scrivere using dichiarazioni ovunque. Prima di tutto voglio liberare la mia classe cliente dall'implementazione del servizio. Dovrebbe funzionare sia con servizi di breve durata che con soggiorni di lunga durata. Un'altra cosa che ho cercato di raggiungere - scrivere metodi senza using perché la noiosa copia-incolla in ogni singolo metodo

object-oriented c# adapter

posta Szer 07.08.2015 - 10:31

fonte

1 risposta

Leggi altre domande sui tag object-oriented c# adapter

è un attacco DoS una buona analogia con Dining Philosophers? Passa dati in un costruttore o crea invece metodi virtuali?

score 4 · Accepted Answer

C # 3 +:

internal class DataServiceAdapter : IDataService
{
    public bool Method()
    {
        return Using(s => s.Method());
    }

    public int Method2(string arg)
    {
        return Using(s => s.Method2(arg));
    }

    private static TRes Using<TRes>(Func<SpecifiDataService, TRes> func)
    {
        using (var something = new SpecifiDataService())
        {
            return func(something);
        }
    }
}

C # 6:

internal class DataServiceAdapter : IDataService
{
    public bool Method() => Using(s => s.Method());

    public int Method2(string arg) => Using(s => s.Method2(arg));

    private static TRes Using<TRes>(Func<SpecifiDataService, TRes> func)
    {
        using (var something = new SpecifiDataService())
            return func(something);
    }
}

Spiegazione: estrai una funzione simile a un modello di comando e riduci la sua arità tramite un'applicazione parziale.

link