Can you provide full code that compiles and runs?
cheers,
Krzysztof
On 24/09/2010 11:53 AM, Kam wrote:
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.
