Protected Methods

[joe.garro]

I am unable to Proxy a protected virtual or protected internal virtual
or internal virtual?

I tried making internals visible to LinFu.Core, but with no success.

Here are my tests cases I was working with:

public struct Messages
{
public const string InterceptorMessage = "From the Interceptor";
public const string DoingSomething = "Doing Something";
public const string DidntSeeThis = "Didn't See This did You!";
public const string ProtectedMessage = "Protected, but
Overrideable!";
public const string DoingSomethingElse = "Doing Something Else";
}

[TestClass]
public class LoggingInterceptorTests
{
[TestMethod]
public void DoSomething()
{
Logger.Current.Messages.Clear();

var factory = new ProxyFactory();
var actualLogMe = new LogMe();
var interceptor = new LoggerInterceptor(actualLogMe);
var logMe = factory.CreateProxy<LogMe>(interceptor);

logMe.DoSomething();

Assert.AreEqual(2, Logger.Current.Messages.Count);
Assert.AreEqual(Messages.InterceptorMessage, Logger.Current.Messages
[0]);
Assert.AreEqual(Messages.DoingSomething, Logger.Current.Messages
[1]);

Console.WriteLine(typeof(IInterceptor).Assembly.FullName);
}

[TestMethod]
public void DoSomethingWeCantSee()
{
Logger.Current.Messages.Clear();

var factory = new ProxyFactory();
var actualLogMe = new LogMe();
var interceptor = new LoggerInterceptor(actualLogMe);
var logMe = factory.CreateProxy<LogMe>(interceptor);

logMe.DoSomethingTheLoggerCantSee();

Assert.AreEqual(1, Logger.Current.Messages.Count);
Assert.AreEqual(Messages.DidntSeeThis, Logger.Current.Messages[0]);
}

[TestMethod]
public void DoSomethingProtected()
{
Logger.Current.Messages.Clear();

var factory = new ProxyFactory();
var actualLogMe = new LogMe();
var interceptor = new LoggerInterceptor(actualLogMe);
var logMe = factory.CreateProxy<LogMe>(interceptor);

logMe.ProtectedAndLoggable();

Assert.AreEqual(2, Logger.Current.Messages.Count);
Assert.AreEqual(Messages.InterceptorMessage, Logger.Current.Messages
[0]);
Assert.AreEqual(Messages.ProtectedMessage, Logger.Current.Messages
[1]);
}

[TestMethod]
public void DoSomethingElse()
{
Logger.Current.Messages.Clear();

var factory = new ProxyFactory();
var actualLogMe = new LogMe2();
var interceptor = new LoggerInterceptor(actualLogMe);
var logMe = factory.CreateProxy<LogMe2>(interceptor);

logMe.DoSomethingElse();

Assert.AreEqual(2, Logger.Current.Messages.Count);
Assert.AreEqual(Messages.InterceptorMessage, Logger.Current.Messages
[0]);
Assert.AreEqual(Messages.DoingSomethingElse, Logger.Current.Messages
[1]);
}
}

public class LogMe
{
public virtual void DoSomething()
{
Logger.Current.Messages.Add(Messages.DoingSomething);
}

public void DoSomethingTheLoggerCantSee()
{
Logger.Current.Messages.Add(Messages.DidntSeeThis);
}

internal virtual void ProtectedAndLoggable()
{
Logger.Current.Messages.Add(Messages.ProtectedMessage);
}
}

public class LogMe2 : LogMe
{
public virtual void DoSomethingElse()
{
Logger.Current.Messages.Add(Messages.DoingSomethingElse);
}
}

public class Logger
{
private Logger()
{
Messages = new List<string>();
}

public static Logger Current
{
get { return Nested.Logger; }
}

private class Nested
{
internal static readonly Logger Logger =
new Logger();
}

public IList<string> Messages { get; private set; }
}

public class LoggerInterceptor : IInterceptor
{
private readonly object _target;

public LoggerInterceptor(object target)
{
_target = target;
}

#region Implementation of IInterceptor

public object Intercept(IInvocationInfo info)
{
Logger.Current.Messages.Add(Messages.InterceptorMessage);
return info.TargetMethod.Invoke(_target, info.Arguments);
}

#endregion
}

[Philip_L]

Hi Joe,

I went ahead and patched LinFu.Proxy to support intercepting protected/
protected internal methods. Try out revision 415 in the trunk--it
should be fixed now.

Regards,

Philip Laureano

[joe.garro]

Awesome,

Thanks Philip.