public static void DeclareOverride(MemberDefinitionBase memberOverride, MemberDefinitionBase overriddenMember)
{
ArgumentUtility.CheckNotNull("memberOverride", memberOverride);
ArgumentUtility.CheckNotNull("overriddenMember", overriddenMember);
typeof(MemberDefinitionBase).GetProperty("BaseAsMember").SetValue(memberOverride, overriddenMember, BindingFlags.NonPublic | BindingFlags.Instance, null, null, null);
var overridesCollection = PrivateInvoke.GetNonPublicField(overriddenMember.Overrides, "_items");
PrivateInvoke.InvokeNonPublicMethod(overridesCollection, "Add", memberOverride);
}
private void InitializeOverride(MemberDefinitionBase overrider, MemberDefinitionBase baseMember)
{
overrider.BaseAsMember = baseMember;
if (baseMember.Overrides.ContainsKey(overrider.DeclaringClass.Type))
{
string message = string.Format("Mixin {0} overrides method {1} twice: {2} and {3} both target the same method.",
overrider.DeclaringClass.FullName, baseMember.FullName, overrider.FullName, baseMember.Overrides[overrider.DeclaringClass.Type].FullName);
throw new ConfigurationException(message);
}
baseMember.AddOverride(overrider);
}
private static void DoSelection(MemberDefinitionBase definition, int startIndex, int endIndex)
{
int i = 0;
definition.SelectedItems.Clear();
foreach (var item in definition.ItemsSource)
{
if (startIndex <= i)
{
definition.SelectedItems.Add(item);
}
if (endIndex <= i)
{
break;
}
i++;
}
}
public void MixinAppliedToInterface()
{
TargetClassDefinition targetClass = DefinitionObjectMother.BuildUnvalidatedDefinition(typeof(IBaseType2), typeof(BT2Mixin1));
Assert.That(targetClass.IsInterface, Is.True);
MethodInfo method = typeof(IBaseType2).GetMethod("IfcMethod");
Assert.That(method, Is.Not.Null);
MemberDefinitionBase member = targetClass.Methods[method];
Assert.That(member, Is.Not.Null);
MixinDefinition mixin = targetClass.Mixins[typeof(BT2Mixin1)];
Assert.That(mixin, Is.Not.Null);
Assert.That(mixin.TargetClass, Is.SameAs(targetClass));
}
public void Methods()
{
TargetClassDefinition targetClass = DefinitionObjectMother.GetActiveTargetClassDefinition(typeof(BaseType1));
MethodInfo baseMethod1 = typeof(BaseType1).GetMethod("VirtualMethod", new Type[0]);
MethodInfo baseMethod2 = typeof(BaseType1).GetMethod("VirtualMethod", new[] { typeof(string) });
MethodInfo mixinMethod1 = typeof(BT1Mixin1).GetMethod("VirtualMethod", new Type[0]);
Assert.That(targetClass.Methods.ContainsKey(baseMethod1), Is.True);
Assert.That(targetClass.Methods.ContainsKey(mixinMethod1), Is.False);
MemberDefinitionBase member = targetClass.Methods[baseMethod1];
Assert.That(new List <MemberDefinitionBase> (targetClass.GetAllMembers()).Contains(member), Is.True);
Assert.That(new List <MemberDefinitionBase> (targetClass.Mixins[typeof(BT1Mixin1)].GetAllMembers()).Contains(member), Is.False);
Assert.That(member.Name, Is.EqualTo("VirtualMethod"));
Assert.That(member.FullName, Is.EqualTo(typeof(BaseType1).FullName + ".VirtualMethod"));
Assert.That(member.IsMethod, Is.True);
Assert.That(member.IsProperty, Is.False);
Assert.That(member.IsEvent, Is.False);
Assert.That(member.DeclaringClass, Is.SameAs(targetClass));
Assert.That(member.Parent, Is.SameAs(targetClass));
Assert.That(targetClass.Methods.ContainsKey(baseMethod2), Is.True);
Assert.That(targetClass.Methods[baseMethod2], Is.Not.SameAs(member));
MixinDefinition mixin1 = targetClass.Mixins[typeof(BT1Mixin1)];
Assert.That(mixin1.Methods.ContainsKey(baseMethod1), Is.False);
Assert.That(mixin1.Methods.ContainsKey(mixinMethod1), Is.True);
member = mixin1.Methods[mixinMethod1];
Assert.That(new List <MemberDefinitionBase> (mixin1.GetAllMembers()).Contains(member), Is.True);
Assert.That(member.Name, Is.EqualTo("VirtualMethod"));
Assert.That(member.FullName, Is.EqualTo(typeof(BT1Mixin1).FullName + ".VirtualMethod"));
Assert.That(member.IsMethod, Is.True);
Assert.That(member.IsProperty, Is.False);
Assert.That(member.IsEvent, Is.False);
Assert.That(member.DeclaringClass, Is.SameAs(mixin1));
}
private IMutableMember ImplementOverride(MemberDefinitionBase member)
{
var memberAsMethodDefinition = member as MethodDefinition;
if (memberAsMethodDefinition != null)
{
return(ImplementMethodOverride(memberAsMethodDefinition));
}
var memberAsPropertyDefinition = member as PropertyDefinition;
if (memberAsPropertyDefinition != null)
{
return(ImplementPropertyOverride(memberAsPropertyDefinition));
}
var memberAsEventDefinition = member as EventDefinition;
Assertion.IsNotNull(memberAsEventDefinition, "Only methods, properties, and events can be overridden.");
return(ImplementEventOverride(memberAsEventDefinition));
}
private static void DoSelection(MemberDefinitionBase definition, int startIndex, int endIndex)
{
int i = 0;
definition.SelectedItems.Clear();
foreach (var item in definition.ItemsSource)
{
if (startIndex <= i)
{
definition.SelectedItems.Add(item);
}
if (endIndex <= i)
{
break;
}
i++;
}
}
private void InitializeOverride(MemberDefinitionBase overrider, MemberDefinitionBase baseMember)
{
overrider.BaseAsMember = baseMember;
baseMember.AddOverride(overrider);
}
public void AddIntroducedMemberAttribute(IMutableMember member, MemberInfo interfaceMember, MemberDefinitionBase implementingMember)
{
ArgumentUtility.CheckNotNull("member", member);
ArgumentUtility.CheckNotNull("interfaceMember", interfaceMember);
ArgumentUtility.CheckNotNull("implementingMember", implementingMember);
var attribute = new CustomAttributeDeclaration(
s_introducedMemberAttributeConstructor,
new object[] { implementingMember.DeclaringClass.Type, implementingMember.Name, interfaceMember.DeclaringType, interfaceMember.Name });
member.AddCustomAttribute(attribute);
}
