それは本当にあなたが「ミックスイン」によって何を意味するかに依存します-誰もがわずかに異なる考えを持っているようです。 likeで確認したいミックスインの種類（ただし、C＃では使用できません）により、構成による実装が単純になります。
public class Mixin : ISomeInterface
{
private SomeImplementation impl implements ISomeInterface;
public void OneMethod()
{
// Specialise just this method
}
}
コンパイラは、クラスに直接別の実装がない限り、すべてのメンバーを "impl"にプロキシするだけでISomeInterfaceを実装します。
ただし、現時点ではこれは不可能です。
C＃を介してミックスインを実装できるオープンソースフレームワークがあります。 http://remix.codeplex.com/ をご覧ください。
このフレームワークでミックスインを実装するのは非常に簡単です。サンプルとページにある「追加情報」リンクをご覧ください。
私は通常このパターンを採用しています：
public interface IColor
{
byte Red {get;}
byte Green {get;}
byte Blue {get;}
}
public static class ColorExtensions
{
public static byte Luminance(this IColor c)
{
return (byte)(c.Red*0.3 + c.Green*0.59+ c.Blue*0.11);
}
}
同じソースファイル/名前空間に2つの定義があります。そうすることで、インターフェイスを使用するときに（ 'using'を使用して）拡張機能を常に使用できます。
これにより、CMSの最初のリンクで説明されているように、制限されたミックスインが得られます。
制限：
- データフィールドなし
- プロパティなし（括弧でmyColor.Luminance（）を呼び出す必要があります 拡張プロパティ 誰ですか？）
それでも多くの状況で十分です。
彼ら（MS）が拡張機能クラスを自動生成するためのコンパイラーマジックを追加できるといいですね。
public interface IColor
{
byte Red {get;}
byte Green {get;}
byte Blue {get;}
// compiler generates anonymous extension class
public static byte Luminance(this IColor c)
{
return (byte)(c.Red*0.3 + c.Green*0.59+ c.Blue*0.11);
}
}
Jonが提案したコンパイラトリックはさらに優れていますが。
LinF および Castle's DynamicProxy はミックスインを実装します。 COP（コンポジット指向プログラミング）は、ミックスインからパラダイム全体を作成するものと考えることができます。 Anders Norasからのこの投稿 には役立つ情報とリンクがあります。
編集：これは拡張メソッドなしでC＃2.0ですべて可能です
また、拡張メソッドアプローチを拡張して、WPFの添付プロパティとは異なるパターンで状態を組み込むこともできます。
以下は、ボイラープレートを最小限にした例です。ターゲットクラスを多態的に扱う必要がない限り、インターフェイスの追加を含め、ターゲットクラスの変更は必要ありません。その場合、実際の多重継承に非常に近いものになります。
// Mixin class: mixin infrastructure and mixin component definitions
public static class Mixin
{
// =====================================
// ComponentFoo: Sample mixin component
// =====================================
// ComponentFooState: ComponentFoo contents
class ComponentFooState
{
public ComponentFooState() {
// initialize as you like
this.Name = "default name";
}
public string Name { get; set; }
}
// ComponentFoo methods
// if you like, replace T with some interface
// implemented by your target class(es)
public static void
SetName<T>(this T obj, string name) {
var state = GetState(component_foo_states, obj);
// do something with "obj" and "state"
// for example:
state.Name = name + " the " + obj.GetType();
}
public static string
GetName<T>(this T obj) {
var state = GetState(component_foo_states, obj);
return state.Name;
}
// =====================================
// boilerplate
// =====================================
// instances of ComponentFoo's state container class,
// indexed by target object
static readonly Dictionary<object, ComponentFooState>
component_foo_states = new Dictionary<object, ComponentFooState>();
// get a target class object's associated state
// note lazy instantiation
static TState
GetState<TState>(Dictionary<object, TState> dict, object obj)
where TState : new() {
TState ret;
if(!dict.TryGet(obj, out ret))
dict[obj] = ret = new TState();
return ret;
}
}
使用法：
var some_obj = new SomeClass();
some_obj.SetName("Johny");
Console.WriteLine(some_obj.GetName()); // "Johny the SomeClass"
拡張メソッドは自然に機能するため、nullインスタンスでも機能することに注意してください。
また、WeakDictionary実装を使用して、コレクションがターゲットクラス参照をキーとして保持していることによるメモリリークを回避することも検討してください。
同様のものが必要だったので、Reflection.Emitを使用して次のことを思いつきました。次のコードでは、タイプ 'mixin'のプライベートメンバーを持つ新しいタイプが動的に生成されます。 'mixin'インターフェイスのメソッドへのすべての呼び出しは、このプライベートメンバーに転送されます。 'mixin'インターフェースを実装するインスタンスを取る単一のパラメーターコンストラクターが定義されています。基本的には、特定の具象型TとインターフェースIに対して次のコードを書くことと同じです。
class Z : T, I
{
I impl;
public Z(I impl)
{
this.impl = impl;
}
// Implement all methods of I by proxying them through this.impl
// as follows:
//
// I.Foo()
// {
// return this.impl.Foo();
// }
}
これはクラスです：
public class MixinGenerator
{
public static Type CreateMixin(Type @base, Type mixin)
{
// Mixin must be an interface
if (!mixin.IsInterface)
throw new ArgumentException("mixin not an interface");
TypeBuilder typeBuilder = DefineType(@base, new Type[]{mixin});
FieldBuilder fb = typeBuilder.DefineField("impl", mixin, FieldAttributes.Private);
DefineConstructor(typeBuilder, fb);
DefineInterfaceMethods(typeBuilder, mixin, fb);
Type t = typeBuilder.CreateType();
return t;
}
static AssemblyBuilder assemblyBuilder;
private static TypeBuilder DefineType(Type @base, Type [] interfaces)
{
assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName(Guid.NewGuid().ToString()), AssemblyBuilderAccess.RunAndSave);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(Guid.NewGuid().ToString());
TypeBuilder b = moduleBuilder.DefineType(Guid.NewGuid().ToString(),
@base.Attributes,
@base,
interfaces);
return b;
}
private static void DefineConstructor(TypeBuilder typeBuilder, FieldBuilder fieldBuilder)
{
ConstructorBuilder ctor = typeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard, new Type[] { fieldBuilder.FieldType });
ILGenerator il = ctor.GetILGenerator();
// Call base constructor
ConstructorInfo baseCtorInfo = typeBuilder.BaseType.GetConstructor(new Type[]{});
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, typeBuilder.BaseType.GetConstructor(new Type[0]));
// Store type parameter in private field
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, fieldBuilder);
il.Emit(OpCodes.Ret);
}
private static void DefineInterfaceMethods(TypeBuilder typeBuilder, Type mixin, FieldInfo instanceField)
{
MethodInfo[] methods = mixin.GetMethods();
foreach (MethodInfo method in methods)
{
MethodInfo fwdMethod = instanceField.FieldType.GetMethod(method.Name,
method.GetParameters().Select((pi) => { return pi.ParameterType; }).ToArray<Type>());
MethodBuilder methodBuilder = typeBuilder.DefineMethod(
fwdMethod.Name,
// Could not call absract method, so remove flag
fwdMethod.Attributes & (~MethodAttributes.Abstract),
fwdMethod.ReturnType,
fwdMethod.GetParameters().Select(p => p.ParameterType).ToArray());
methodBuilder.SetReturnType(method.ReturnType);
typeBuilder.DefineMethodOverride(methodBuilder, method);
// Emit method body
ILGenerator il = methodBuilder.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, instanceField);
// Call with same parameters
for (int i = 0; i < method.GetParameters().Length; i++)
{
il.Emit(OpCodes.Ldarg, i + 1);
}
il.Emit(OpCodes.Call, fwdMethod);
il.Emit(OpCodes.Ret);
}
}
}
これは使い方です：
public interface ISum
{
int Sum(int x, int y);
}
public class SumImpl : ISum
{
public int Sum(int x, int y)
{
return x + y;
}
}
public class Multiply
{
public int Mul(int x, int y)
{
return x * y;
}
}
// Generate a type that does multiply and sum
Type newType = MixinGenerator.CreateMixin(typeof(Multiply), typeof(ISum));
object instance = Activator.CreateInstance(newType, new object[] { new SumImpl() });
int res = ((Multiply)instance).Mul(2, 4);
Console.WriteLine(res);
res = ((ISum)instance).Sum(1, 4);
Console.WriteLine(res);
データを格納できる基本クラスがある場合は、コンパイラの安全性を強化し、マーカーインターフェイスを使用できます。それは多かれ少なかれ、受け入れられた答えからの「C＃3.0の混合」が提案するものです。
public static class ModelBaseMixins
{
public interface IHasStuff{ }
public static void AddStuff<TObjectBase>(this TObjectBase objectBase, Stuff stuff) where TObjectBase: ObjectBase, IHasStuff
{
var stuffStore = objectBase.Get<IList<Stuff>>("stuffStore");
stuffStore.Add(stuff);
}
}
ObjectBase：
public abstract class ObjectBase
{
protected ModelBase()
{
_objects = new Dictionary<string, object>();
}
private readonly Dictionary<string, object> _objects;
internal void Add<T>(T thing, string name)
{
_objects[name] = thing;
}
internal T Get<T>(string name)
{
T thing = null;
_objects.TryGetValue(name, out thing);
return (T) thing;
}
したがって、「ObjectBase」から継承してIHasStuffで装飾できるクラスがある場合は、今すぐsutffを追加できます
回避策 here を見つけました。完全にエレガントではありませんが、完全に観察可能なミックスイン動作を実現できます。さらに、IntelliSenseは引き続き機能します！
using System;
using System.Runtime.CompilerServices; //needed for ConditionalWeakTable
public interface MAgeProvider // use 'M' prefix to indicate mixin interface
{
// nothing needed in here, it's just a 'marker' interface
}
public static class AgeProvider // implements the mixin using extensions methods
{
static ConditionalWeakTable<MAgeProvider, Fields> table;
static AgeProvider()
{
table = new ConditionalWeakTable<MAgeProvider, Fields>();
}
private sealed class Fields // mixin's fields held in private nested class
{
internal DateTime BirthDate = DateTime.UtcNow;
}
public static int GetAge(this MAgeProvider map)
{
DateTime dtNow = DateTime.UtcNow;
DateTime dtBorn = table.GetOrCreateValue(map).BirthDate;
int age = ((dtNow.Year - dtBorn.Year) * 372
+ (dtNow.Month - dtBorn.Month) * 31
+ (dtNow.Day - dtBorn.Day)) / 372;
return age;
}
public static void SetBirthDate(this MAgeProvider map, DateTime birthDate)
{
table.GetOrCreateValue(map).BirthDate = birthDate;
}
}
public abstract class Animal
{
// contents unimportant
}
public class Human : Animal, MAgeProvider
{
public string Name;
public Human(string name)
{
Name = name;
}
// nothing needed in here to implement MAgeProvider
}
static class Test
{
static void Main()
{
Human h = new Human("Jim");
h.SetBirthDate(new DateTime(1980, 1, 1));
Console.WriteLine("Name {0}, Age = {1}", h.Name, h.GetAge());
Human h2 = new Human("Fred");
h2.SetBirthDate(new DateTime(1960, 6, 1));
Console.WriteLine("Name {0}, Age = {1}", h2.Name, h2.GetAge());
Console.ReadKey();
}
}
これが私が思いついたミックスインの実装です。おそらく 私のライブラリ で使用します。
それはおそらくどこかで以前に行われたことでしょう。
すべて静的に型付けされており、辞書などはありません。タイプごとに少し余分なコードが必要です。インスタンスごとにストレージは必要ありません。一方、必要に応じてミックスインの実装をオンザフライで変更できる柔軟性も備えています。ビルド後、ビルド前、ビルド中のツールはありません。
これにはいくつかの制限がありますが、オーバーライドなどのことが可能です。
まず、マーカーインターフェイスを定義します。後で何かが追加される可能性があります。
public interface Mixin {}
このインターフェースはミックスインによって実装されます。ミックスインは通常のクラスです。タイプはミックスインを直接継承または実装しません。代わりに、インターフェイスを使用してミックスインのインスタンスを公開します。
public interface HasMixins {}
public interface Has<TMixin> : HasMixins
where TMixin : Mixin {
TMixin Mixin { get; }
}
このインターフェースを実装することは、ミックスインをサポートすることを意味します。型ごとにいくつかあるので、明示的に実装することが重要です。
次に、拡張メソッドを使用するちょっとしたトリックについて説明します。以下を定義します。
public static class MixinUtils {
public static TMixin Mixout<TMixin>(this Has<TMixin> what)
where TMixin : Mixin {
return what.Mixin;
}
}
Mixoutは適切なタイプのミックスインを公開します。これをテストするために、定義しましょう：
public abstract class Mixin1 : Mixin {}
public abstract class Mixin2 : Mixin {}
public abstract class Mixin3 : Mixin {}
public class Test : Has<Mixin1>, Has<Mixin2> {
private class Mixin1Impl : Mixin1 {
public static readonly Mixin1Impl Instance = new Mixin1Impl();
}
private class Mixin2Impl : Mixin2 {
public static readonly Mixin2Impl Instance = new Mixin2Impl();
}
Mixin1 Has<Mixin1>.Mixin => Mixin1Impl.Instance;
Mixin2 Has<Mixin2>.Mixin => Mixin2Impl.Instance;
}
static class TestThis {
public static void run() {
var t = new Test();
var a = t.Mixout<Mixin1>();
var b = t.Mixout<Mixin2>();
}
}
面白いことに（振り返ってみると意味がありますが）、IntelliSenseは拡張メソッドMixoutがTestに適用されることを検出しませんが、Testには実際にミックスインがあります。やってみると
t.Mixout<Mixin3>();
コンパイルエラーが発生します。
少し凝った方法で、次のメソッドも定義できます。
[Obsolete("The object does not have this mixin.", true)]
public static TSome Mixout<TSome>(this HasMixins something) where TSome : Mixin {
return default(TSome);
}
これは、a）IntelliSenseでMixoutというメソッドを表示して、その存在を思い出させ、b）もう少し説明的なエラーメッセージ（Obsolete属性によって生成される）を提供します。