18

May

Factory pattern Implicito :)

Ciao a tutti

 

non molti li usano, io incluso, ma esistono gli operatori in .NET (es. moltiplica, diviso, uguale, diverso, etc)

Un uso simpatico, è l’operatore implicito abbinato ai design pattern Factory, Strategy, o tutti quelli che si implementano in genere con un metodo unico.

 

Esempio:

[code language="csharp"]

static void Main(string[] args)
{
    Person antonio1 = new PersonByNameSurnameFactory(new { Name = "Antonio", Surname = "Esposito" }); //con parametro dynamic
    Person antonio2 = new PersonByParameter(new NameSurnameParameters { Name = "Antonio", Surname = "Esposito" }); //con parametro tipizzato
}

[/code]

Io ho due variabili di business, che inizializzo con delle factory, che anzicché utilizzare tramite un metodo, vengono implicitamente convertite (l’operatore implicito appunto) nell’oggetto di business che desidero.

Vediamo il resto del codice

[code language="csharp"]

///


/// Interfaccia base oggetti di business
///

public interface IBusinessObject
{
}

public class Person : IBusinessObject
{
    public string Name;
    public string Surname;
}


public class PersonByNameSurnameFactory : FactoryBase
{
    // Sfortunatamente il CLR non supporta il passaggio alla base di parametri dynamic.... mah
    public PersonByNameSurnameFactory(dynamic parameters) : base((object)parameters) { }

    public override Person CreateInstance()
    {
        return new Person()
        {
            Name = Parameters.Name, //qui hai il late-binding
            Surname = Parameters.Surname
        };
    }
}

///


/// Classe di parametri per la factory PersonByParameter
///

public class NameSurnameParameters { public string Name; public string Surname;}

public class PersonByParameter : FactoryBase
{
    public PersonByParameter(NameSurnameParameters parameter) : base(parameter) { }

    public override Person CreateInstance()
    {
        return new Person
        {
            Name = Parameters.Name, //qui hai il completamento automatico
            Surname = Parameters.Surname,
        };
    }
}

[/code]

Qui ho utilizzato un interfaccia di base per definire l’oggetto di business, ed ho implementato le mie due factory, una con parametro dynamic, l’altra con il parametro tipizzato.

Manca però un pezzo di codice, quello delle base factory che implementano l’operatore implicito:

[code language="csharp"]

///


/// Factory base con operatore implicito all'oggetto di business che si desidera realizzare
///

/// Parametri dynamic
public abstract class FactoryBase where T : IBusinessObject
{
    protected readonly dynamic Parameters;

    protected FactoryBase(dynamic parameters) { Parameters = parameters; }

    public static implicit operator T(FactoryBase f)
    {
        return f.CreateInstance();
    }

    public abstract T CreateInstance();
}

///


/// Factory base con operatore implicito e parametri generics
///

///
///
public abstract class FactoryBase where T : IBusinessObject
{
    protected readonly P Parameters;

    protected FactoryBase(P parameters) { Parameters = parameters; }

    public static implicit operator T(FactoryBase f)
    {
        return f.CreateInstance();
    }

    public abstract T CreateInstance();
}

[/code]

Queste due classi rendono il tutto funzionante. Di fatto è sempre possibile chiamare il metodo CreateInstance() su di una factory, ma è anche possibile sfruttare il comportamento dell’operatore per scrivere un codice più leggibile Smile

 

a presto

by Antonio Esposito on 5/18/2011