Jak zaimplementowałbyś "cechę" wzorca projektowego w C#?

C# Język (przynajmniej do wersji 5) nie ma wsparcia dla cech.

Jednak Scala ma cechy i Scala działa na JVM (i CLR). Dlatego nie jest to kwestia czasu pracy, ale po prostu języka.

Rozważ, że cechy, przynajmniej w sensie Scali, mogą być uważane za "dość magiczne do kompilacji w metodach proxy" (nie wpływają one , a nie na MRO, które różni się od Mixinów w Ruby). W C# sposobem na uzyskanie takiego zachowania byłoby użycie interfejsy i " wiele ręcznych metod proxy "(np. skład).

Ten żmudny proces można by wykonać za pomocą hipotetycznego procesora (może automatyczne generowanie kodu dla częściowej klasy za pomocą szablonów?), ale to nie C#.

Szczęśliwe kodowanie.

Istnieje projekt akademicki, opracowany przez Stefana Reicharta z Software Composition Group na Uniwersytecie w Bernie (Szwajcaria), który zapewnia prawdziwą implementację cech do języka C#.

Oto przykład tego, co można napisać:

trait TCircle
{
    public int Radius { get; set; }
    public int Surface { get { ... } }
}

trait TColor { ... }

class MyCircle
{
    uses { TCircle; TColor }
}

Chciałbym wskazać NRoles , eksperyment z rolami W C#, gdzie role są podobne do cechy.

Nroles używa post-kompilatora do przepisywania IL i wprowadzania metod do klasy. Pozwala to na pisanie kodu w ten sposób:

public class RSwitchable : Role
{
    private bool on = false;
    public void TurnOn() { on = true; }
    public void TurnOff() { on = false; }
    public bool IsOn { get { return on; } }
    public bool IsOff { get { return !on; } }
}

public class RTunable : Role
{
    public int Channel { get; private set; }
    public void Seek(int step) { Channel += step; }
}

public class Radio : Does<RSwitchable>, Does<RTunable> { }

Gdzie klasa Radio implementuje RSwitchable i RTunable. Za kulisami, Does<R> jest interfejsem bez członków, więc zasadniczo Radio kompiluje się do pustej klasy. The post-compilation IL przepisywanie wtryskuje metody RSwitchable i RTunable do Radio, które mogą być następnie użyte tak, jakby naprawdę wywodziły się z dwóch ról (z innego zgromadzenia):

var radio = new Radio();
radio.TurnOn();
radio.Seek(42);

Aby użyć radio bezpośrednio przed przepisaniem (czyli w tym samym zestawie, w którym deklarowany jest typ Radio), musisz użyć metod rozszerzeń As<R>():

radio.As<RSwitchable>().TurnOn();
radio.As<RTunable>().Seek(42);

Ponieważ kompilator nie pozwala na wywołanie TurnOn lub Seek bezpośrednio na klasie Radio.

Jest to naprawdę sugerowane rozszerzenie do odpowiedzi Lucero, gdzie cała pamięć była w klasie bazowej.

Może użyjesz do tego właściwości zależności?

Spowodowałoby to, że klasy klienckie byłyby lekkie w czasie uruchamiania, gdy masz wiele właściwości, które nie zawsze są ustawiane przez każdego potomka. Dzieje się tak, ponieważ wartości są przechowywane w statycznym elemencie.

using System.Windows;

public class Client : DependencyObject
{
    public string Name { get; set; }

    public Client(string name)
    {
        Name = name;
    }

    //add to descendant to use
    //public double Weight
    //{
    //    get { return (double)GetValue(WeightProperty); }
    //    set { SetValue(WeightProperty, value); }
    //}

    public static readonly DependencyProperty WeightProperty =
        DependencyProperty.Register("Weight", typeof(double), typeof(Client), new PropertyMetadata());


    //add to descendant to use
    //public double Height
    //{
    //    get { return (double)GetValue(HeightProperty); }
    //    set { SetValue(HeightProperty, value); }
    //}

    public static readonly DependencyProperty HeightProperty =
        DependencyProperty.Register("Height", typeof(double), typeof(Client), new PropertyMetadata());
}

public interface IWeight
{
    double Weight { get; set; }
}

public interface IHeight
{
    double Height { get; set; }
}

public class ClientA : Client, IWeight
{
    public double Weight
    {
        get { return (double)GetValue(WeightProperty); }
        set { SetValue(WeightProperty, value); }
    }

    public ClientA(string name, double weight)
        : base(name)
    {
        Weight = weight;
    }
}

public class ClientB : Client, IHeight
{
    public double Height
    {
        get { return (double)GetValue(HeightProperty); }
        set { SetValue(HeightProperty, value); }
    }

    public ClientB(string name, double height)
        : base(name)
    {
        Height = height;
    }
}

public class ClientC : Client, IHeight, IWeight
{
    public double Height
    {
        get { return (double)GetValue(HeightProperty); }
        set { SetValue(HeightProperty, value); }
    }

    public double Weight
    {
        get { return (double)GetValue(WeightProperty); }
        set { SetValue(WeightProperty, value); }
    }

    public ClientC(string name, double weight, double height)
        : base(name)
    {
        Weight = weight;
        Height = height;
    }

}

public static class ClientExt
{
    public static double HeightInches(this IHeight client)
    {
        return client.Height * 39.3700787;
    }

    public static double WeightPounds(this IWeight client)
    {
        return client.Weight * 2.20462262;
    }
}

Bazując na co zasugerował Lucero , wpadłem na to:

internal class Program
{
    private static void Main(string[] args)
    {
        var a = new ClientA("Adam", 68);
        var b = new ClientB("Bob", 1.75);
        var c = new ClientC("Cheryl", 54.4, 1.65);

        Console.WriteLine("{0} is {1:0.0} lbs.", a.Name, a.WeightPounds());
        Console.WriteLine("{0} is {1:0.0} inches tall.", b.Name, b.HeightInches());
        Console.WriteLine("{0} is {1:0.0} lbs and {2:0.0} inches.", c.Name, c.WeightPounds(), c.HeightInches());
        Console.ReadLine();
    }
}

public class Client
{
    public string Name { get; set; }

    public Client(string name)
    {
        Name = name;
    }
}

public interface IWeight
{
    double Weight { get; set; }
}

public interface IHeight
{
    double Height { get; set; }
}

public class ClientA : Client, IWeight
{
    public double Weight { get; set; }
    public ClientA(string name, double weight) : base(name)
    {
        Weight = weight;
    }
}

public class ClientB : Client, IHeight
{
    public double Height { get; set; }
    public ClientB(string name, double height) : base(name)
    {
        Height = height;
    }
}

public class ClientC : Client, IWeight, IHeight
{
    public double Weight { get; set; }
    public double Height { get; set; }
    public ClientC(string name, double weight, double height) : base(name)
    {
        Weight = weight;
        Height = height;
    }
}

public static class ClientExt
{
    public static double HeightInches(this IHeight client)
    {
        return client.Height * 39.3700787;
    }

    public static double WeightPounds(this IWeight client)
    {
        return client.Weight * 2.20462262;
    }
}

Wyjście:

Adam is 149.9 lbs.
Bob is 68.9 inches tall.
Cheryl is 119.9 lbs and 65.0 inches.

To brzmi jak PHP w wersji Aspect Oriented Programming. Istnieją narzędzia do pomocy, takie jak PostSharp lub MS Unity w niektórych przypadkach. Jeśli chcesz, aby roll-your-own, code-injection przy użyciu atrybutów C# jest jednym z podejść, lub jak sugerowane metody rozszerzenia dla ograniczonych przypadków.

Naprawdę zależy, jak skomplikowane chcesz się dostać. Jeśli próbujesz zbudować coś złożonego, poszukam niektórych z tych narzędzi, które pomogą.