[ninject-contrib commit] r20 - Saving current state. Added a lot of documentation and refactoring.

[codesite...@google.com]

Author: Ian.F.Davis
Date: Sun Mar 15 10:13:04 2009
New Revision: 20

Added:

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Activation/SynchronizationActivationStrategy.cs
(contents, props changed)
- copied, changed from r18,
/trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Activation/SynchronizationActivator.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/StandardSynchronizationInterceptor.cs
Removed:

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Activation/SynchronizationActivator.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/SynchronizationContextInterceptor.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/SynchronizeInvokeInterceptor.cs
Modified:
trunk/Synchronization/build/ (props changed)
trunk/Synchronization/build/Extensions.Synchronization.sln
trunk/Synchronization/source/NinjectContrib.Synchronization/ (props
changed)

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Behavior/BehaviorContextDecorator.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/ContextScope.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/SynchronizationInterceptorBase.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Planning/Directives/SynchronizationDirective.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Planning/MethodSynchronizationRegistrationStrategy.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationExtension.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationMetaData.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationMetaDataStore.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizeAttribute.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/NinjectContrib.Synchronization.csproj

trunk/Synchronization/source/NinjectContrib.Synchronization/Properties/Resources.Designer.cs

trunk/Synchronization/source/NinjectContrib.Synchronization/Properties/Resources.resx

trunk/Synchronization/source/NinjectContrib.Synchronization/SynchronizationModule.cs

Log:
Saving current state. Added a lot of documentation and refactoring.

Modified: trunk/Synchronization/build/Extensions.Synchronization.sln
==============================================================================
--- trunk/Synchronization/build/Extensions.Synchronization.sln (original)
+++ trunk/Synchronization/build/Extensions.Synchronization.sln Sun Mar 15
10:13:04 2009
@@ -3,6 +3,8 @@
# Visual Studio 2008
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}")
= "NinjectContrib.Synchronization", "..\source\NinjectContrib.Synchronization\NinjectContrib.Synchronization.csproj", "{71233C88-69B6-4997-BAA1-093471514399}"
EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}")
= "NinjectContrib.Synchronization.Tests", "..\source\NinjectContrib.Synchronization.Tests\NinjectContrib.Synchronization.Tests.csproj", "{4E2DDF80-1422-4833-B9B0-E3BD265CE019}"
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Analysis|Any CPU = Analysis|Any CPU
@@ -16,6 +18,12 @@
{71233C88-69B6-4997-BAA1-093471514399}.Debug|Any CPU.Build.0 = Debug|Any
CPU
{71233C88-69B6-4997-BAA1-093471514399}.Release|Any CPU.ActiveCfg =
Release|Any CPU
{71233C88-69B6-4997-BAA1-093471514399}.Release|Any CPU.Build.0 = Release|
Any CPU
+ {4E2DDF80-1422-4833-B9B0-E3BD265CE019}.Analysis|Any CPU.ActiveCfg =
Analysis|Any CPU
+ {4E2DDF80-1422-4833-B9B0-E3BD265CE019}.Analysis|Any CPU.Build.0 =
Analysis|Any CPU
+ {4E2DDF80-1422-4833-B9B0-E3BD265CE019}.Debug|Any CPU.ActiveCfg = Debug|
Any CPU
+ {4E2DDF80-1422-4833-B9B0-E3BD265CE019}.Debug|Any CPU.Build.0 = Debug|Any
CPU
+ {4E2DDF80-1422-4833-B9B0-E3BD265CE019}.Release|Any CPU.ActiveCfg =
Release|Any CPU
+ {4E2DDF80-1422-4833-B9B0-E3BD265CE019}.Release|Any CPU.Build.0 = Release|
Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

Copied:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Activation/SynchronizationActivationStrategy.cs
(from r18,
/trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Activation/SynchronizationActivator.cs)
==============================================================================
---
/trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Activation/SynchronizationActivator.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Activation/SynchronizationActivationStrategy.cs
Sun Mar 15 10:13:04 2009
@@ -29,8 +29,17 @@

namespace NinjectContrib.Synchronization.Infrastructure.Activation
{
- public class SynchronizationActivator : ProxyStrategy
+ /// <summary>
+ /// An activation strategy that wraps the instance that is being
activated in a proxy which
+ /// will synchronize method calls and property access.
+ /// </summary>
+ internal class SynchronizationActivationStrategy : ProxyStrategy
{
+ /// <summary>
+ /// Returns a value indicating whether the instance in the
specified context should be proxied.
+ /// </summary>
+ /// <param name="context">The activation context.</param>
+ /// <returns><see langword="True"/> if the instance should be
proxied, otherwise <see langword="false"/>.</returns>
protected override bool ShouldProxy( IContext context )
{
// If dynamic interceptors have been defined, all types will
be proxied, regardless

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Behavior/BehaviorContextDecorator.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Behavior/BehaviorContextDecorator.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Behavior/BehaviorContextDecorator.cs
Sun Mar 15 10:13:04 2009
@@ -31,17 +31,27 @@

namespace NinjectContrib.Synchronization.Infrastructure.Behavior
{
+ /// <summary>
+ /// Wraps the default behavior using in object activation. To all
callers it is the same object,
+ /// but the Resolve and Release members change the creation context
befor sending the base behavior
+ /// on its way.
+ /// </summary>

[SuppressMessage( "Microsoft.Design", "CA1063:ImplementIDisposableCorrectly"
)]
- public class BehaviorContextDecorator : IBehavior
+ internal class BehaviorContextDecorator : IBehavior
{
- private readonly IBehavior _behavior;
+ private readonly IBehavior _baseBehavior;
private readonly SynchronizeAttribute _syncAttribute;

+ /// <summary>
+ /// Creates a new <see cref="BehaviorContextDecorator"/> instance.
+ /// </summary>
+ /// <param name="behavior">The base behavior to decorate.</param>
+ /// <param name="synchronizeAttribute">The creation context of the
base behavior.</param>
public BehaviorContextDecorator( IBehavior behavior,
SynchronizeAttribute synchronizeAttribute )
{
Ensure.ArgumentNotNull( behavior, "behavior" );
- Ensure.ArgumentNotNull( behavior, "synchronizeAttribute" );
- _behavior = behavior;
+
Ensure.ArgumentNotNull(synchronizeAttribute, "synchronizeAttribute");
+ _baseBehavior = behavior;
_syncAttribute = synchronizeAttribute;
}

@@ -55,7 +65,7 @@

[SuppressMessage( "Microsoft.Design", "CA1063:ImplementIDisposableCorrectly"
)]
public void Dispose()
{
- _behavior.Dispose();
+ _baseBehavior.Dispose();
}

#endregion
@@ -67,8 +77,8 @@
/// </summary>
public IKernel Kernel
{
- get { return _behavior.Kernel; }
- set { _behavior.Kernel = value; }
+ get { return _baseBehavior.Kernel; }
+ set { _baseBehavior.Kernel = value; }
}

/// <summary>
@@ -81,7 +91,7 @@
/// </remarks>
public bool SupportsEagerActivation
{
- get { return _behavior.SupportsEagerActivation; }
+ get { return _baseBehavior.SupportsEagerActivation; }
}

/// <summary>
@@ -95,7 +105,7 @@
/// </remarks>
public bool ShouldTrackInstances
{
- get { return _behavior.ShouldTrackInstances; }
+ get { return _baseBehavior.ShouldTrackInstances; }
}

/// <summary>
@@ -105,9 +115,12 @@
/// <returns>An instance of the type associated with the
behavior.</returns>
public object Resolve( IContext context )
{
- using ( new ContextScope(
_syncAttribute.SynchronizationContext, Kernel ) )
+ // We want to make sure that objects are created in the contex
which they have stated.
+ // For example, all controls, forms, etc will be created in
the WindowsformsSychronizationContext.
+ // This ensures that all calls are made on the same context in
which the object was created.
+ using (new ContextScope(_syncAttribute.SynchronizationContext,
context.Kernel))
{
- return _behavior.Resolve( context );
+ return _baseBehavior.Resolve( context );
}
}

@@ -117,9 +130,10 @@
/// <param name="context">The activation context.</param>
public void Release( IContext context )
{
- using ( new ContextScope(
_syncAttribute.SynchronizationContext, Kernel ) )
+ // We want to restore the context during teardown of the
object. This is mainly needed for controls.
+ using ( new ContextScope(
_syncAttribute.SynchronizationContext, context.Kernel ) )
{
- _behavior.Release( context );
+ _baseBehavior.Release( context );
}
}


Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/ContextScope.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/ContextScope.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/ContextScope.cs
Sun Mar 15 10:13:04 2009
@@ -32,44 +32,59 @@
{
internal class ContextScope : IDisposable
{
+ private IKernel _kernel;
+
public ContextScope( SynchronizationContext target, IKernel kernel
)
{
- OriginalContext = SetCreationContext( target, kernel );
+ _kernel = kernel;
+ OriginalContext = SetCreationContext( target );
}

private SynchronizationContext OriginalContext { get; set; }

- public static SynchronizationContext GetCurrentContext()
+ /// <summary>
+ /// Gets the current <see cref="SynchronizationContext"/>. If
there is no current context, a new context
+ /// will be created and set.
+ /// </summary>
+ /// <returns>The current <see
cref="SynchronizationContext"/>.</returns>
+ public static SynchronizationContext GetCurrentContext(IKernel
kernel)
{
- if ( SynchronizationContext.Current == null )
- {
- SynchronizationContext.SetSynchronizationContext( new
SynchronizationContext() );
- }
- Debug.Assert( SynchronizationContext.Current != null );
- return SynchronizationContext.Current;
+
+ if ( SynchronizationContext.Current == null )
+ {
+ SynchronizationContext.SetSynchronizationContext(
kernel.Get<SynchronizationContext>() );
+ }
+ Debug.Assert( SynchronizationContext.Current != null );
+ return SynchronizationContext.Current;
+
}

- public static void RestoreCreationContext( SynchronizationContext
original )
+ /// <summary>
+ /// Restores the current context to that of the target if the
current context is different than that of the target.
+ /// </summary>
+ /// <param name="target">The context desired to be current.</param>
+ public void RestoreCreationContext( SynchronizationContext target )
{
- if ( SynchronizationContext.Current != original )
+ if ( GetCurrentContext(_kernel) != target)
{
- SynchronizationContext.SetSynchronizationContext( original
);
+ SynchronizationContext.SetSynchronizationContext( target );
}
}

- public static SynchronizationContext SetCreationContext(
SynchronizationContext target, IKernel kernel )
+ /// <summary>
+ /// Sets the current <see cref="SynchronizationContext"/> to the
target <see cref="SynchronizationContext"/>
+ /// and returns the <see cref="SynchronizationContext"/> that was
active prior to the switch.
+ /// </summary>
+ /// <param name="target">The context desired to be current.</param>
+ /// <returns>The <see cref="SynchronizationContext"/> that was
active prior to the target being set.</returns>
+ public SynchronizationContext SetCreationContext(
SynchronizationContext target )
{
- // First, if there is no context, create one.
- SynchronizationContext original =
SynchronizationContext.Current;
- if ( original == null )
- {
- SynchronizationContext.SetSynchronizationContext(
kernel.Get<SynchronizationContext>() );
- original = SynchronizationContext.Current;
- }
+ // Get the current context, creating it if needed.
+ SynchronizationContext original = GetCurrentContext(_kernel);

- Debug.Assert( original != null );
+ bool hashesEqual = target.GetHashCode() ==
original.GetHashCode();
+ Console.WriteLine("Target: {0}\tOriginal: {1}",
target.GetHashCode(), original.GetHashCode());

- // Now that there is a context, see if we need to change
contexts.
if ( target != original )
{
SynchronizationContext.SetSynchronizationContext( target );
@@ -87,6 +102,7 @@
void IDisposable.Dispose()
{
RestoreCreationContext( OriginalContext );
+ _kernel = null;
GC.SuppressFinalize( this );
}


Added:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/StandardSynchronizationInterceptor.cs
==============================================================================
--- (empty file)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/StandardSynchronizationInterceptor.cs
Sun Mar 15 10:13:04 2009
@@ -0,0 +1,102 @@
+#region License
+
+//
+// Author: Ian Davis <ian.f...@gmail.com>
+// Copyright (c) 2007-2009, Ian Davis
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#endregion
+
+#region Using Directives
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Threading;
+using System.Windows.Forms;
+using Ninject.Core.Interception;
+using NinjectContrib.Synchronization.Properties;
+
+#endregion
+
+namespace NinjectContrib.Synchronization.Infrastructure.Interception
+{
+ internal class StandardSynchronizationInterceptor :
SynchronizationInterceptorBase
+ {
+ public StandardSynchronizationInterceptor( SynchronizeAttribute
attribute )
+ {
+ SynchronizationAttribute = attribute;
+ }
+
+ #region Overrides of SynchronizationInterceptorBase
+
+ protected override void MarshalInvoke( IInvocation invocation )
+ {
+ if ( !InvokeUsingSynchronizationContext( invocation ) &&
+ !InvokeUsingImplicitSynchronization( invocation ) )
+ {
+ invocation.Proceed();
+ }
+ }
+
+ #endregion
+
+ public SynchronizeAttribute SynchronizationAttribute { get; set; }
+
+ private bool InvokeUsingImplicitSynchronization( IInvocation
invocation )
+ {
+ if ( SynchronizationAttribute.SynchronizationProxyType !=
SynchronizationProxyType.ISynchronizeInvoke )
+ {
+ return false;
+ }
+
+ if ( !( invocation.Request.Target is ISynchronizeInvoke ) )
+ {
+ throw new InvalidOperationException(
Resources.ISyncInvokeMismatchError );
+ }
+
+ var target = invocation.Request.Target as ISynchronizeInvoke;
+ Debug.Assert( target != null );
+
+ if ( target.InvokeRequired )
+ {
+ target.Invoke( (MethodInvoker) ( () =>
invocation.Proceed() ), null );
+ }
+ else
+ {
+ invocation.Proceed();
+ }
+
+ return true;
+ }
+
+ private bool InvokeUsingSynchronizationContext( IInvocation
invocation )
+ {
+ if ( SynchronizationAttribute.SynchronizationProxyType !=
SynchronizationProxyType.SynchronizationContext )
+ {
+ return false;
+ }
+
+ // If we are already in the target context, the context will
not be switched.
+ // We don't need to do and check for current context and call
invocation.Proceed separately.
+ using ( new ContextScope(
SynchronizationAttribute.SynchronizationContext, invocation.Request.Kernel
) )
+ {
+ SynchronizationAttribute.SynchronizationContext.Send(state
=> invocation.Proceed(), null);
+ }
+
+ return true;
+ }
+ }
+}
\ No newline at end of file

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/SynchronizationInterceptorBase.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/SynchronizationInterceptorBase.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Interception/SynchronizationInterceptorBase.cs
Sun Mar 15 10:13:04 2009
@@ -21,9 +21,9 @@

#region Using Directives

-using System;
using Ninject.Core;
using Ninject.Core.Interception;
+using Ninject.Core.Logging;

#endregion

@@ -54,9 +54,18 @@
/// <param name="invocation">The invocation that is being
intercepted.</param>
protected virtual void BeforeInvoke( IInvocation invocation )
{
- Console.WriteLine( "Intercepting call for: {0}::{1}",
- invocation.Request.Target.GetType(),
- invocation.Request.Method );
+ if ( !invocation.Request.Kernel.Options.GenerateDebugInfo )
+ {
+ return;
+ }
+
+ ILogger logger =
invocation.Request.Kernel.Components.LoggerFactory.GetLogger( GetType() );
+ if ( logger.IsDebugEnabled )
+ {
+ logger.Debug( "Intercepting call for: {0}::{1}",
+ invocation.Request.Target.GetType(),
+ invocation.Request.Method );
+ }
}

/// <summary>
@@ -65,9 +74,18 @@
/// <param name="invocation">The invocation that is being
intercepted.</param>
protected virtual void AfterInvoke( IInvocation invocation )
{
- Console.WriteLine( "Intercepted call for: {0}::{1}",
- invocation.Request.Target.GetType(),
- invocation.Request.Method );
+ if ( !invocation.Request.Kernel.Options.GenerateDebugInfo )
+ {
+ return;
+ }
+
+ ILogger logger =
invocation.Request.Kernel.Components.LoggerFactory.GetLogger( GetType() );
+ if ( logger.IsDebugEnabled )
+ {
+ logger.Debug( "Intercepted call for: {0}::{1}",
+ invocation.Request.Target.GetType(),
+ invocation.Request.Method );
+ }
}
}
}

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Planning/Directives/SynchronizationDirective.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Planning/Directives/SynchronizationDirective.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Planning/Directives/SynchronizationDirective.cs
Sun Mar 15 10:13:04 2009
@@ -27,6 +27,9 @@

namespace NinjectContrib.Synchronization.Infrastructure.Planning.Directives
{
+ /// <summary>
+ /// Used to identify the need for synchronization in the activation
process.
+ /// </summary>
internal class SynchronizationDirective : DirectiveBase
{
/// <summary>

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Planning/MethodSynchronizationRegistrationStrategy.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Planning/MethodSynchronizationRegistrationStrategy.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/Planning/MethodSynchronizationRegistrationStrategy.cs
Sun Mar 15 10:13:04 2009
@@ -42,15 +42,15 @@

namespace NinjectContrib.Synchronization.Infrastructure.Planning
{
- public class MethodSynchronizationRegistrationStrategy :
InterceptorRegistrationStrategy
+ internal class MethodSynchronizationRegistrationStrategy :
InterceptorRegistrationStrategy
{
- private readonly SynchronizationMetaDataStore
_synchronizationStore;
+ private SynchronizationMetaDataStore _synchronizationStore;

- public MethodSynchronizationRegistrationStrategy()
+ protected override void OnConnected(EventArgs args)
{
- _synchronizationStore = new SynchronizationMetaDataStore();
+ _synchronizationStore = new
SynchronizationMetaDataStore(Kernel);
+ base.OnConnected(args);
}
-
/// <summary>
/// Executed to build the activation plan.
/// </summary>
@@ -70,8 +70,6 @@
// From here below is the same as the base, but with a
different attribute type.
IEnumerable<KeyValuePair<MethodInfo, SynchronizeAttribute>>
candidates = GetCandidateMethodData( type );

- //RegisterClassInterceptors(binding, type, plan, candidates);
-
foreach ( KeyValuePair<MethodInfo, SynchronizeAttribute>
candidate in candidates )
{
RegisterMethodInterceptors( binding, type, plan,
candidate.Key, new[] {candidate.Value} );
@@ -118,7 +116,7 @@
{
IAdvice advice = factory.Create( method );

- advice.Callback = CreateInterceptor;
//attribute.CreateInterceptor;
+ advice.Callback = CreateInterceptor;
advice.Order = attribute.Order;

registry.Register( advice );
@@ -130,28 +128,29 @@
Ensure.ArgumentNotNull( request, "request" );

SynchronizeAttribute attribute =
-
_synchronizationStore[request.Target.GetType()].GetSynchronizationAttributeForMethod(
request.Method );
-
- switch ( attribute.SynchronizationProxyType )
- {
- case SynchronizationProxyType.ISynchronizeInvoke:
- {
- if ( typeof (ISynchronizeInvoke).IsAssignableFrom(
request.Context.Implementation ) )
- {
- return new SynchronizeInvokeInterceptor();
- }
-
- throw new InvalidOperationException(
- "ISynchronizeInvoke interception can only be used
on types that implement ISynchronizeInvoke." );
- }
- case SynchronizationProxyType.SynchronizationContext:
- attribute.SynchronizationContext =
- request.Kernel.Get( attribute.ContextType ) as
SynchronizationContext;
- return new SynchronizationContextInterceptor(
attribute );
- default:
- throw new InvalidOperationException(
- "Attribute SynchronizationProxyType but be set
prior to interceptor creation." );
- }
+
_synchronizationStore[request.Target.GetType()][request.Method];
+
+ return new StandardSynchronizationInterceptor( attribute );
+ //switch ( attribute.SynchronizationProxyType )
+ //{
+ // case SynchronizationProxyType.ISynchronizeInvoke:
+ // {
+ // if ( typeof (ISynchronizeInvoke).IsAssignableFrom(
request.Context.Implementation ) )
+ // {
+ // return new SynchronizeInvokeInterceptor();
+ // }
+
+ // throw new InvalidOperationException(
+ // "ISynchronizeInvoke interception can only be
used on types that implement ISynchronizeInvoke." );
+ // }
+ // case SynchronizationProxyType.SynchronizationContext:
+ // attribute.SynchronizationContext =
+ // request.Kernel.Get( attribute.ContextType ) as
SynchronizationContext;
+ // return new SynchronizationContextInterceptor(
attribute );
+ // default:
+ // throw new InvalidOperationException(
+ // "Attribute SynchronizationProxyType but be set
prior to interceptor creation." );
+ //}
}

#region Bingind Behavior Manipulation

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationExtension.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationExtension.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationExtension.cs
Sun Mar 15 10:13:04 2009
@@ -54,7 +54,7 @@
protected override void OnConnected( EventArgs args )
{
Kernel.Components.Get<IPlanner>().Strategies.Append( new
MethodSynchronizationRegistrationStrategy() );
- Kernel.Components.Get<IActivator>().Strategies.Append( new
SynchronizationActivator() );
+ Kernel.Components.Get<IActivator>().Strategies.Append( new
SynchronizationActivationStrategy() );

base.OnConnected( args );
}
@@ -66,7 +66,7 @@
protected override void OnDisconnected( EventArgs args )
{

Kernel.Components.Get<IPlanner>().Strategies.RemoveAll<MethodSynchronizationRegistrationStrategy>();
-
Kernel.Components.Get<IActivator>().Strategies.RemoveAll<SynchronizationActivator>();
+
Kernel.Components.Get<IActivator>().Strategies.RemoveAll<SynchronizationActivationStrategy>();

base.OnDisconnected( args );
}

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationMetaData.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationMetaData.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationMetaData.cs
Sun Mar 15 10:13:04 2009
@@ -97,9 +97,12 @@
AttributeLookupTable.Add( method, attribute );
}

- public SynchronizeAttribute GetSynchronizationAttributeForMethod(
MethodInfo methodInfo )
+ public SynchronizeAttribute this[MethodInfo methodInfo]
{
- return AttributeLookupTable[methodInfo];
+ get
+ {
+ return AttributeLookupTable[methodInfo];
+ }
}

#region Implementation of ICloneable

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationMetaDataStore.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationMetaDataStore.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizationMetaDataStore.cs
Sun Mar 15 10:13:04 2009
@@ -25,6 +25,7 @@
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
+using System.Threading;
using Ninject.Core;
using Ninject.Core.Infrastructure;
using NinjectContrib.Synchronization.Extensions;
@@ -35,6 +36,8 @@
{
internal class SynchronizationMetaDataStore
{
+ private IKernel Kernel { get; set; }
+
private const BindingFlags _bindingFlags = BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance |
@@ -43,13 +46,15 @@
private readonly IDictionary<Type, SynchronizationMetaData>
_classMetaDataLookupTable;
private readonly IDictionary<Type, SynchronizationMetaData>
_compositeMetaDataLookupTable;

- public SynchronizationMetaDataStore()
- : this( true )
- {
+ public SynchronizationMetaDataStore(IKernel kernel)
+ : this( kernel, true )
+ {
}

- public SynchronizationMetaDataStore( bool
useImplicitSynchronization )
+ public SynchronizationMetaDataStore( IKernel kernel, bool
useImplicitSynchronization )
{
+ Ensure.ArgumentNotNull( kernel, "kernel" );
+ Kernel = kernel;
UseImplicitSynchronization = useImplicitSynchronization;
_classMetaDataLookupTable = new Dictionary<Type,
SynchronizationMetaData>();
_compositeMetaDataLookupTable = new Dictionary<Type,
SynchronizationMetaData>();
@@ -112,6 +117,7 @@
private void BuildMethodMetaData( Type type )
{
SynchronizationMetaData metaData =
_classMetaDataLookupTable[type];
+ SetSyncContext( metaData.DefaultAttribute );

MethodInfo[] methods = type.GetMethods( _bindingFlags );
foreach ( MethodInfo method in methods )
@@ -144,6 +150,7 @@
private SynchronizationMetaData
BuildHierarchichalSynchronizationMetaData( Type type )
{
var metaData = _classMetaDataLookupTable[type].Clone() as
SynchronizationMetaData;
+ SetSyncContext( metaData.DefaultAttribute );
MergeSynchronizationMetaData( metaData, type.BaseType );
_compositeMetaDataLookupTable.Add( type, metaData );
return metaData;
@@ -159,12 +166,29 @@
_classMetaDataLookupTable[type].MethodSynchronizationData;
foreach ( KeyValuePair<MethodInfo, SynchronizeAttribute>
keyValuePair in methodSynchronizationData )
{
- metaData.Add( keyValuePair.Key, keyValuePair.Value ??
metaData.DefaultAttribute );
+ SynchronizeAttribute attribute = keyValuePair.Value ??
metaData.DefaultAttribute;
+ SetSyncContext( attribute );
+ metaData.Add( keyValuePair.Key, attribute );
}

if ( type != typeof (object) )
{
MergeSynchronizationMetaData( metaData, type.BaseType );
+ }
+ }
+
+ private void SetSyncContext(SynchronizeAttribute candidate)
+ {
+ if (candidate != null)
+ if(candidate.ContextType != null &&
candidate.SynchronizationContext == null)
+ {
+ candidate.SynchronizationContext =
+ Kernel.Get(candidate.ContextType) as
SynchronizationContext;
+ Debug.Assert(candidate.SynchronizationContext != null);
+ }else if(candidate.ContextType == null)
+ {
+ candidate.SynchronizationContext =
Kernel.Get<SynchronizationContext>();
+ Debug.Assert(candidate.SynchronizationContext != null);
}
}
}

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizeAttribute.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizeAttribute.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Infrastructure/SynchronizeAttribute.cs
Sun Mar 15 10:13:04 2009
@@ -44,7 +44,7 @@
{
SynchronizationProxyType = synchronizationProxyType;
Order = 0;
- SynchronizationContext = ContextScope.GetCurrentContext();
+ //SynchronizationContext = ContextScope.CurrentContext;
ContextType = null;
}


Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/NinjectContrib.Synchronization.csproj
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/NinjectContrib.Synchronization.csproj
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/NinjectContrib.Synchronization.csproj
Sun Mar 15 10:13:04 2009
@@ -68,8 +68,9 @@
<ItemGroup>
<Compile Include="Infrastructure\Behavior\BehaviorContextDecorator.cs"
/>
<Compile Include="Extensions\AttributeExtension.cs" />
- <Compile
Include="Infrastructure\Activation\SynchronizationActivator.cs" />
+ <Compile
Include="Infrastructure\Activation\SynchronizationActivationStrategy.cs" />
<Compile Include="Infrastructure\ContextScope.cs" />
+ <Compile
Include="Infrastructure\Interception\StandardSynchronizationInterceptor.cs"
/>
<Compile
Include="Infrastructure\Interception\SynchronizationInterceptorBase.cs" />
<Compile Include="Infrastructure\MarshallingControl.cs">
<SubType>Component</SubType>
@@ -81,13 +82,11 @@
<Compile Include="Infrastructure\SynchronizationMetaDataStore.cs" />
<Compile Include="Infrastructure\SynchronizeAttribute.cs" />
<Compile Include="Infrastructure\SynchronizationExtension.cs" />
- <Compile
Include="Infrastructure\Interception\SynchronizeInvokeInterceptor.cs" />
<Compile Include="Properties\Resources.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
- <Compile
Include="Infrastructure\Interception\SynchronizationContextInterceptor.cs"
/>
<Compile Include="SynchronizationModule.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Properties/Resources.Designer.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Properties/Resources.Designer.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Properties/Resources.Designer.cs
Sun Mar 15 10:13:04 2009
@@ -61,6 +61,15 @@
}

/// <summary>
+ /// Looks up a localized string similar to Target must implement
ISynchronizeInvoke..
+ /// </summary>
+ internal static string ISyncInvokeMismatchError {
+ get {
+ return
ResourceManager.GetString("ISyncInvokeMismatchError", resourceCulture);
+ }
+ }
+
+ /// <summary>
/// Looks up a localized string similar to The {0} requires that
an implementation of {1} be registered as a kernel component prior to the
{1} being loaded..
/// </summary>
internal static string ModuleActivationErrorMessage01 {

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/Properties/Resources.resx
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/Properties/Resources.resx
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/Properties/Resources.resx
Sun Mar 15 10:13:04 2009
@@ -117,6 +117,9 @@
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms,
Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
+ <data name="ISyncInvokeMismatchError" xml:space="preserve">
+ <value>Target must implement ISynchronizeInvoke.</value>
+ </data>
<data name="ModuleActivationErrorMessage01" xml:space="preserve">
<value>The {0} requires that an implementation of {1} be registered as
a kernel component prior to the {1} being loaded.</value>
</data>

Modified:
trunk/Synchronization/source/NinjectContrib.Synchronization/SynchronizationModule.cs
==============================================================================
---
trunk/Synchronization/source/NinjectContrib.Synchronization/SynchronizationModule.cs
(original)
+++
trunk/Synchronization/source/NinjectContrib.Synchronization/SynchronizationModule.cs
Sun Mar 15 10:13:04 2009
@@ -57,7 +57,9 @@
// The WindowsFormsSynchronizationContext should have been
created by the auto install of the marshalling control.
SynchronizationContext current =
SynchronizationContext.Current;
Trace.Assert( current != null );
- Bind<WindowsFormsSynchronizationContext>().ToProvider( new
WinFormsContextProvider() );
+
+ Bind<WindowsFormsSynchronizationContext>().ToSelf().Using( new
SingletonBehavior() );
+ Kernel.Inject(WindowsFormsSynchronizationContext.Current, new
StandardContext( Kernel, typeof(WindowsFormsSynchronizationContext),
Kernel.Components.Tracker.GetScope( Kernel ) ));
Bind<SynchronizationContext>().ToSelf().Using( new
OnePerThreadBehavior() );
}

@@ -67,6 +69,8 @@

private class WinFormsContextProvider : IProvider
{
+ private static readonly SynchronizationContext _syncContext =
WindowsFormsSynchronizationContext.Current;
+
#region Implementation of IProvider

/// <summary>
@@ -102,7 +106,7 @@
/// </returns>
public object Create( IContext context )
{
- return SynchronizationContext.Current;
+ return _syncContext;
}

/// <summary>