Hi Krzysztof, thanks for lending a hand. Here's a quick snippet of the
failing test along with console output.
*************
class Program
{
static void Main(string[] args)
{
var tb = new TestB();
Type[] interfaces = tb.GetType().GetInterfaces();
var factory = new ProxyFactory();
var proxy =
factory.CreateInterfaceProxyWithTarget<IInterfaceB>(tb, new[]
{ InterceptorType.Validator },
ProxyGenerationHookType.Selective, interfaces);
((IInterfaceA)proxy).TestA1();
((IInterfaceA)proxy).TestA2();
((IInterfaceB)proxy).TestB1();
((IInterfaceB)proxy).TestB2();
((ICommon)proxy).Common1();
// Stepping in will not go anywhere. The target method is never
reached since there's no console output.
((ICommon)proxy).Common2();
}
}
public interface ICommon
{
void Common1();
[NonProxied] // This one doesn't work, it doesn't seem to do
anything for the call.
void Common2();
}
public interface IInterfaceA
{
void TestA1();
void TestA2();
}
public interface IInterfaceB
{
void TestB1();
[NonProxied] // This one works, the call to TestB2 is not
intercepted but reaches target.
void TestB2();
}
public abstract class TestA : IInterfaceA, ICommon
{
void ICommon.Common1()
{
Console.WriteLine(" - Reached target Common1()\n");
}
void ICommon.Common2()
{
Console.WriteLine(" - Reached target Common2()\n");
}
void IInterfaceA.TestA1()
{
Console.WriteLine(" - Reached target TestA1()\n");
}
void IInterfaceA.TestA2()
{
Console.WriteLine(" - Reached target TestA2()\n");
}
}
public class TestB : TestA, IInterfaceB
{
void IInterfaceB.TestB1()
{
Console.WriteLine(" - Reached target TestB1()\n");
}
void IInterfaceB.TestB2()
{
Console.WriteLine(" - Reached target TestB2()\n");
}
}
public class ActiveObjectInterceptor : StandardInterceptor
{
protected override void PerformProceed(IInvocation invocation)
{
Console.WriteLine(String.Format("Intercepted call to {0}\n",
invocation.Method.Name));
base.PerformProceed(invocation);
}
}
public class NonProxiedGenerationHook : ProxyGenerationHookBase
{
public override bool ShouldInterceptMethod(Type type, MethodInfo
methodInfo)
{
bool intercept = true;
if (methodInfo.IsDefined(typeof(NonProxiedAttribute), true))
{
intercept = false;
}
return intercept;
}
#region Equality
...
#endregion
}
***************
Output:
Intercepted call to TestA1
- Reached target TestA1()
Intercepted call to TestA2
- Reached target TestA2()
Intercepted call to TestB1
- Reached target TestB1()
- Reached target TestB2()
Intercepted call to Common1
- Reached target Common1()
*********************
As you can see, I expected to see the line "- Reached target
Common2()" without the line "Intercepted call to Common2()" much like
the non-proxied call to TestB2(). I made sure the supplied list of
additional interfaces to proxy does include ICommon.
Thanks
On Sep 23, 8:19 pm, Krzysztof Koźmic <[email protected]>
wrote:
> can you provide a failing test?
>
> I'm not sure I understand the scenario 2 here
>
> 2010/9/24 Kam <[email protected]>
>
> > Hi,
>
> > I'm currently using IProxyGenerationHook to control which methods to
> > exclude for proxy generation for a given interface. My current
> > hierarchy of classes and interfaces is the following:
>
> > Class_A implements interfaces Interface_A and Interface_Z
> > Class_B inherits Class_A and also implements interfaces Interface_B
> > Interface_B inherits Interface_Z.
>
> > I created a proxy to interface Interface_B with a target instance of
> > Class_B, and gave it Interface_Z as additional interface to include in
> > the proxy generation process.
>
> > I use custom attributes on methods/properties to mark for exclusion.
> > i.e. [NonProxied].
>
> > Scenario 1:
> > If I mark a method belonging to Interface_B, the hook will exclude it
> > and any calls through the proxy to that marked method will reach the
> > target object's method without interception. (Behaviour I expected).
>
> > Scenario 2:
> > If I mark a method belonging to Interface_Z and cast my proxy instance
> > to (Interface_Z) to make a call to the marked method, the call will
> > not reach its target object. From a debugger point of view, attempting
> > to step-in won't do anything. The execution proceeds to the next line
> > without interception nor forwarding to the real implementation. I get
> > this behaviour even without attaching the debugger. (Expected the call
> > to reach the target instance's method implementation without
> > interceptors).
>
> > To summarize, using proxy generation hook to exclude seems to work
> > only for first level interface methods and properties but not for
> > inherited interfaces with marked methods or properties.
>
> > Perhaps this is not supported or I'm just missing something? Has
> > anyone else experienced a similar scenario?
>
> > Thanks in advance!
>
> > --
> > You received this message because you are subscribed to the Google Groups
> > "Castle Project Users" group.
> > To post to this group, send email to [email protected]
> > .
> > To unsubscribe from this group, send email to
> > [email protected]<castle-project-users%[email protected]>
> > .
> > For more options, visit this group at
> >http://groups.google.com/group/castle-project-users?hl=en.
--
You received this message because you are subscribed to the Google Groups
"Castle Project Users" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/castle-project-users?hl=en.
