void IContainerPolicyCreator.CreatePolicies(
IPolicyList policyList,
string instanceName,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource)
{
CacheManagerData castConfigurationObject = (CacheManagerData)configurationObject;
var cacheManagerName = instanceName;
var cacheStorageName = castConfigurationObject.CacheStorage;
var maximumElementsInCacheBeforeScavenging = castConfigurationObject.MaximumElementsInCacheBeforeScavenging;
var numberToRemoveWhenScavenging = castConfigurationObject.NumberToRemoveWhenScavenging;
var expirationPollFrequencyInSeconds = castConfigurationObject.ExpirationPollFrequencyInSeconds;
policyList.Set <IBuildPlanPolicy>(
new DelegateBuildPlanPolicy(
context =>
{
IBuilderContext backingStoreContext
= context.CloneForNewBuild(NamedTypeBuildKey.Make <IBackingStore>(cacheStorageName), null);
IBackingStore backingStore = (IBackingStore)context.Strategies.ExecuteBuildUp(backingStoreContext);
CachingInstrumentationProvider instrumentationProvider
= CreateInstrumentationProvider(cacheManagerName, configurationSource);
return(new CacheManagerFactoryHelper().BuildCacheManager(
cacheManagerName,
backingStore,
maximumElementsInCacheBeforeScavenging,
numberToRemoveWhenScavenging,
expirationPollFrequencyInSeconds,
instrumentationProvider));
}),
NamedTypeBuildKey.Make <CacheManager>(cacheManagerName));
}
public void ConfiguredObjectStrategyThrowsIfFactoryAttributesIsNotPresent()
{
BuilderContext context =
new BuilderContext(strategyChain, null, null, policyList, NamedTypeBuildKey.Make <object>(name), null);
context.Strategies.ExecuteBuildUp(context);
}
/// <summary>
/// Returns a default instance of type <typeparamref name="T"/> based on configuration information
/// from <paramref name="configurationSource"/>.
/// </summary>
/// <typeparam name="T">The type to build.</typeparam>
/// <param name="locator">The locator to be used for this build operation.</param>
/// <param name="lifetimeContainer">The lifetime container to be used for this build operation.</param>
/// <param name="configurationSource">The source for configuration information.</param>
/// <returns>A new instance of <typeparamref name="T"/> or any of it subtypes, or an existing instance
/// if type <typeparamref name="T"/> is a singleton that is already present in the <paramref name="locator"/>.
/// </returns>
public static T BuildUp <T>(IReadWriteLocator locator,
ILifetimeContainer lifetimeContainer,
IConfigurationSource configurationSource)
{
if (configurationSource == null)
{
throw new ArgumentNullException("configurationSource");
}
try
{
return(GetObjectBuilder()
.BuildUp <T>(locator,
lifetimeContainer,
GetPolicies(configurationSource),
strategyChain,
NamedTypeBuildKey.Make <T>(),
null));
}
catch (BuildFailedException e)
{
// look for the wrapped ConfigurationErrorsException, if any, and throw it
ConfigurationErrorsException cee = GetConfigurationErrorsException(e);
if (cee != null)
{
throw cee;
}
// unknown exception, bubble it up
throw;
}
}
protected override void Initialize()
{
DatabaseConfigurationView configurationView = new DatabaseConfigurationView(ConfigurationSource);
string defaultDatabaseName = configurationView.DefaultName;
foreach (ConnectionStringSettings connectionStringSettings
in configurationView.GetConnectionStringSettingsCollection())
{
if (IsValidProviderName(connectionStringSettings.ProviderName))
{
DbProviderMapping mapping
= configurationView.GetProviderMapping(
connectionStringSettings.Name,
connectionStringSettings.ProviderName);
Type databaseType = mapping.DatabaseType;
this.Context.Policies.Set <IBuildKeyMappingPolicy>(
new BuildKeyMappingPolicy(new NamedTypeBuildKey(databaseType, connectionStringSettings.Name)),
NamedTypeBuildKey.Make <Database>(connectionStringSettings.Name));
if (connectionStringSettings.Name == defaultDatabaseName)
{
this.Context.Policies.Set <IBuildKeyMappingPolicy>(
new BuildKeyMappingPolicy(new NamedTypeBuildKey(databaseType, connectionStringSettings.Name)),
NamedTypeBuildKey.Make <Database>());
}
IContainerPolicyCreator policyCreator = GetContainerPolicyCreator(databaseType, null);
policyCreator.CreatePolicies(
this.Context.Policies,
connectionStringSettings.Name,
connectionStringSettings,
this.ConfigurationSource);
}
}
}
public void ResolverReturnsProperNamedObject()
{
string expected = "We want this one";
string notExpected = "Not this one";
var expectedKey = NamedTypeBuildKey.Make <string>("expected");
var notExpectedKey = NamedTypeBuildKey.Make <string>();
var mainContext = new MockContext();
mainContext.NewBuildupCallback = (k) =>
{
if (k == expectedKey)
{
return(expected);
}
if (k == notExpectedKey)
{
return(notExpected);
}
return(null);
};
var resolver = new OptionalDependencyResolverPolicy(typeof(string), "expected");
object result = resolver.Resolve(mainContext);
Assert.Same(expected, result);
}
/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Builds an <see cref="LoggingExceptionHandler"/> based on an instance of <see cref="LoggingExceptionHandlerData"/>.
/// </summary>
/// <seealso cref="ExceptionHandlerCustomFactory"/>
/// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
/// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="LoggingExceptionHandlerData"/>.</param>
/// <param name="configurationSource">The source for configuration objects.</param>
/// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
/// <returns>A fully initialized instance of <see cref="LoggingExceptionHandler"/>.</returns>
public IExceptionHandler Assemble(IBuilderContext context,
ExceptionHandlerData objectConfiguration,
IConfigurationSource configurationSource,
ConfigurationReflectionCache reflectionCache)
{
LoggingExceptionHandlerData castedObjectConfiguration
= (LoggingExceptionHandlerData)objectConfiguration;
LogWriter writer;
if (castedObjectConfiguration.UseDefaultLogger)
{
writer = Logger.Writer;
}
else
{
IBuilderContext logWriterContext = context.CloneForNewBuild(NamedTypeBuildKey.Make <LogWriter>(), null);
writer = (LogWriter)logWriterContext.Strategies.ExecuteBuildUp(logWriterContext);
}
LoggingExceptionHandler createdObject
= new LoggingExceptionHandler(
castedObjectConfiguration.LogCategory,
castedObjectConfiguration.EventId,
castedObjectConfiguration.Severity,
castedObjectConfiguration.Title,
castedObjectConfiguration.Priority,
castedObjectConfiguration.FormatterType,
writer);
return(createdObject);
}
protected override IDependencyResolverPolicy CreateDependencyResolverPolicy(ParameterInfo parameterInfo, object value)
{
if (parameterInfo.ParameterType == typeof(ILogFormatter))
{
if (value != null)
{
if (value is string)
{
string stringValue = (string)value;
if (!string.IsNullOrEmpty(stringValue))
{
return(new ReferenceResolverPolicy(NamedTypeBuildKey.Make <ILogFormatter>(stringValue)));
}
else
{
value = null;
}
}
else
{
Debug.Fail("This shouldn't happen. When matching the parameter and the property type compatibility should have been ensured.");
}
}
else
{
}
}
return(base.CreateDependencyResolverPolicy(parameterInfo, value));
}
public override void PreBuildUp(IBuilderContext context)
{
if ((NamedTypeBuildKey)context.BuildKey == NamedTypeBuildKey.Make <IUnityContainer>())
{
context.Existing = container;
context.BuildComplete = true;
}
}
public void ConfiguredObjectStrategyCallsCustomFactoryIfFactoryAttributeIsPresent()
{
BuilderContext context =
new BuilderContext(strategyChain, null, null, policyList, NamedTypeBuildKey.Make <MockObjectWithFactory>(name), null);
object createdObject = context.Strategies.ExecuteBuildUp(context);
Assert.IsNotNull(createdObject);
Assert.AreSame(MockFactory.MockObject, createdObject);
}
/// <summary>
/// Register the given factory delegate to be called when the container is
/// asked to resolve <typeparamref name="=TTypeToBuild"/> and <paramref name="name"/>.
/// </summary>
/// <typeparam name="TTypeToBuild">Type that will be requested from the container.</typeparam>
/// <param name="name">The name that will be used when requesting to resolve this type.</param>
/// <param name="factoryMethod">Delegate to invoke to create the instance.</param>
/// <returns>The container extension object this method was invoked on.</returns>
public IStaticFactoryConfiguration RegisterFactory <TTypeToBuild>(
string name, FactoryDelegate factoryMethod)
{
FactoryBuildPlanDelegate planDelegate = delegate { return(factoryMethod(Container)); };
Context.Policies.Set <IBuildPlanPolicy>(
new FactoryDelegateBuildPlanPolicy(planDelegate),
NamedTypeBuildKey.Make <TTypeToBuild>(name));
return(this);
}
public void ChainForNonNullIdOnTypeWithNameMappingDoesNotInvokeMappper()
{
builder.BuildUp(null,
null,
new PolicyList(),
strategies.MakeStrategyChain(),
NamedTypeBuildKey.Make <TypeWithNameMappingAttribute>("id"),
null);
Assert.IsFalse(MockNameMapper.invoked);
}
public override object PreBuildUp(IBuilderContext context)
{
if ((NamedTypeBuildKey)context.BuildKey == NamedTypeBuildKey.Make <IUnityContainer>())
{
context.Existing = this.container;
context.BuildComplete = true;
}
return(null);
}
private static IValidationInstrumentationProvider GetInstrumentationProvider(IBuilderContext context)
{
var mapping = context.Policies.Get <IBuildKeyMappingPolicy>(
NamedTypeBuildKey.Make <IValidationInstrumentationProvider>());
if (mapping != null)
{
return(context.NewBuildUp <IValidationInstrumentationProvider>());
}
return(null);
}
private void CreateExceptionManagerPolicy(
IPolicyList policyList,
ExceptionHandlingSettings settings)
{
new PolicyBuilder <ExceptionManagerImpl, ExceptionHandlingSettings>(
NamedTypeBuildKey.Make <ExceptionManagerImpl>(),
settings,
c => new ExceptionManagerImpl(
Resolve.ReferenceDictionary <Dictionary <string, ExceptionPolicyImpl>, ExceptionPolicyImpl, string>(
from p in c.ExceptionPolicies select new KeyValuePair <string, string>(p.Name, p.Name))))
.AddPoliciesToPolicyList(policyList);
}
object IDependencyResolverPolicy.Resolve(IBuilderContext context)
{
TDictionary dictionary = new TDictionary();
foreach (KeyValuePair <string, TKey> keyPair in dependencyKeys)
{
IBuilderContext buildContext = context.CloneForNewBuild(NamedTypeBuildKey.Make <T>(keyPair.Key), null);
T createdElement = (T)buildContext.Strategies.ExecuteBuildUp(buildContext);
dictionary.Add(keyPair.Value, createdElement);
}
return(dictionary);
}
public void NoExceptionIfExistingObjectDoesntAndNoBroker()
{
MockBuilderContext context = CreateContext();
NamedTypeBuildKey buildKey = NamedTypeBuildKey.Make <OneEventPublisher>();
EventBrokerInfoPolicy policy = new EventBrokerInfoPolicy();
policy.AddPublication("paste", "Pasting");
context.Policies.Set <IEventBrokerInfoPolicy>(policy, buildKey);
context.ExecuteBuildUp(buildKey, null);
// No assert needed, if we got here, we're ok
}
void IContainerPolicyCreator.CreatePolicies(
IPolicyList policyList,
string instanceName,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource)
{
new PolicyBuilder <TestClass, TestSettingWithPolicyCreatorAttribute>(
NamedTypeBuildKey.Make <TestClass>(instanceName),
(TestSettingWithPolicyCreatorAttribute)configurationObject,
c => new TestClass("test " + c.Property2, 10 + c.Property1))
.AddPoliciesToPolicyList(policyList);
}
public void CanCreateInterceptedObjectInOBChain()
{
Builder builder = new Builder();
InterceptableClass instance
= (InterceptableClass)builder.BuildUp(null,
null,
CreatePolicyList(GetInjectionSettings(), true),
baseStrategyChain.MakeStrategyChain(),
NamedTypeBuildKey.Make <InterceptableClass>(string.Empty),
null);
Assert.IsNotNull(instance);
Assert.IsTrue(RemotingServices.IsTransparentProxy(instance));
}
public void RegularInstanceIsReturnedWhenInterceptionIsSwitchedOf()
{
Builder builder = new Builder();
InterceptableClass instance
= (InterceptableClass)builder.BuildUp(null,
null,
CreatePolicyList(new PolicyInjectionSettings(), true),
baseStrategyChain.MakeStrategyChain(),
NamedTypeBuildKey.Make <InterceptableClass>(string.Empty),
null);
Assert.IsNotNull(instance);
Assert.IsFalse(RemotingServices.IsTransparentProxy(instance));
}
/// <summary>
/// API to configure the default interception settings for a type.
/// </summary>
/// <param name="typeToIntercept">Type the interception is being configured for.</param>
/// <param name="interceptor">The interceptor to use by default.</param>
/// <returns>This extension object.</returns>
public Interception SetDefaultInterceptorFor(Type typeToIntercept, IInstanceInterceptor interceptor)
{
Guard.ArgumentNotNull(typeToIntercept, "typeToIntercept");
Guard.ArgumentNotNull(interceptor, "interceptor");
GuardTypeInterceptable(typeToIntercept, interceptor);
Context.Policies.Set <IInstanceInterceptionPolicy>(new FixedInstanceInterceptionPolicy(interceptor), typeToIntercept);
// add policy injection behavior if using this configuration API to set the interceptor
var interceptionBehaviorsPolicy = new InterceptionBehaviorsPolicy();
interceptionBehaviorsPolicy.AddBehaviorKey(NamedTypeBuildKey.Make <PolicyInjectionBehavior>());
Context.Policies.Set <IInterceptionBehaviorsPolicy>(interceptionBehaviorsPolicy, typeToIntercept);
return(this);
}
public void StrategyDoesntOverwriteAnExistingPolicy()
{
MockBuilderContext context = CreateContext();
NamedTypeBuildKey buildKey = NamedTypeBuildKey.Make <object>();
EventBrokerInfoPolicy policy = new EventBrokerInfoPolicy();
context.Policies.Set <IEventBrokerInfoPolicy>(policy, buildKey);
context.ExecuteBuildUp(buildKey, null);
IEventBrokerInfoPolicy setPolicy =
context.Policies.Get <IEventBrokerInfoPolicy>(buildKey);
Assert.AreSame(policy, setPolicy);
}
private void CreateExceptionPoliciesPolicies(
IPolicyList policyList,
IEnumerable <ExceptionPolicyData> policies)
{
foreach (ExceptionPolicyData policyData in policies)
{
NamedTypeBuildKey instanceKey = NamedTypeBuildKey.Make <ExceptionPolicyImpl>(policyData.Name);
string parentPrefix = Guid.NewGuid().ToString();
new PolicyBuilder <ExceptionPolicyImpl, ExceptionPolicyData>(instanceKey, policyData,
c => new ExceptionPolicyImpl(
c.Name,
Resolve.ReferenceDictionary <Dictionary <Type, ExceptionPolicyEntry>, ExceptionPolicyEntry, Type>(
from t in c.ExceptionTypes select new KeyValuePair <string, Type>(parentPrefix + t.Name, t.Type))))
.AddPoliciesToPolicyList(policyList);
CreateExceptionTypePolicies(policyList, policyData.ExceptionTypes, parentPrefix);
}
}
public void ReflectingOverObjectWithoutSubscriptionResultsInEmptyPolicy()
{
MockBuilderContext context = CreateContext();
NamedTypeBuildKey buildKey = NamedTypeBuildKey.Make <object>();
context.ExecuteBuildUp(buildKey, null);
IEventBrokerInfoPolicy policy = context.Policies.Get <IEventBrokerInfoPolicy>(buildKey);
Assert.IsNotNull(policy);
List <PublicationInfo> publications = new List <PublicationInfo>(policy.Publications);
List <SubscriptionInfo> subscriptions = new List <SubscriptionInfo>(policy.Subscriptions);
Assert.AreEqual(0, publications.Count);
Assert.AreEqual(0, subscriptions.Count);
}
private BuilderContext CreateContext(IReadWriteLocator locator, ILifetimeContainer container, IConfigurationSource configurationSource)
{
BuilderContext context
= new BuilderContext(
new StrategyChain(
new object[] {
new LocatorLookupStrategy(),
new MockFactoryStrategy(new LogWriterCustomFactory(), configurationSource, new ConfigurationReflectionCache())
}),
locator,
container,
new PolicyList(),
NamedTypeBuildKey.Make <LogWriter>(),
null);
return(context);
}
void IContainerPolicyCreator.CreatePolicies(
IPolicyList policyList,
string instanceName,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource)
{
FaultContractExceptionHandlerData castConfigurationObject = (FaultContractExceptionHandlerData)configurationObject;
new PolicyBuilder <FaultContractExceptionHandler, FaultContractExceptionHandlerData>(
NamedTypeBuildKey.Make <FaultContractExceptionHandler>(instanceName),
castConfigurationObject,
c => new FaultContractExceptionHandler(
Type.GetType(castConfigurationObject.FaultContractType),
castConfigurationObject.ExceptionMessage,
castConfigurationObject.Attributes))
.AddPoliciesToPolicyList(policyList);
}
public void CreateDatabaseForInvalidNameThrows()
{
BuilderContext context
= new BuilderContext(
new StrategyChain(new object[] {
new MockFactoryStrategy(
new DatabaseCustomFactory(),
new SystemConfigurationSource(),
new ConfigurationReflectionCache())
}),
null,
null,
new PolicyList(),
NamedTypeBuildKey.Make <Database>("a bad name"),
null);
context.Strategies.ExecuteBuildUp(context);
}
public void ReflectingOverSubscribingTypeResultsInCorrectPolicy()
{
MockBuilderContext context = CreateContext();
NamedTypeBuildKey buildKey = NamedTypeBuildKey.Make <OneEventSubscriber>();
context.ExecuteBuildUp(buildKey, null);
IEventBrokerInfoPolicy policy = context.Policies.Get <IEventBrokerInfoPolicy>(buildKey);
Assert.IsNotNull(policy);
List <PublicationInfo> publications = new List <PublicationInfo>(policy.Publications);
List <SubscriptionInfo> subscriptions = new List <SubscriptionInfo>(policy.Subscriptions);
Assert.AreEqual(0, publications.Count);
CollectionAssert.AreEqual(new SubscriptionInfo[] { new SubscriptionInfo("copy", typeof(OneEventSubscriber).GetMethod("OnCopy")) }, subscriptions);
}
public void ReflectingOverPublishingTypeResultsInCorrectPolicy()
{
MockBuilderContext context = CreateContext();
NamedTypeBuildKey buildKey = NamedTypeBuildKey.Make <OneEventPublisher>();
context.ExecuteBuildUp(buildKey, null);
IEventBrokerInfoPolicy policy = context.Policies.Get <IEventBrokerInfoPolicy>(buildKey);
Assert.IsNotNull(policy);
List <PublicationInfo> publications = new List <PublicationInfo>(policy.Publications);
List <SubscriptionInfo> subscriptions = new List <SubscriptionInfo>(policy.Subscriptions);
Assert.AreEqual(0, subscriptions.Count);
CollectionAssert.AreEqual(new PublicationInfo[] { new PublicationInfo("paste", "Pasting") }, publications);
}
public void OneTypeCanPublishAndSubscribeMultipleTimes()
{
MockBuilderContext context = CreateContext();
NamedTypeBuildKey buildKey = NamedTypeBuildKey.Make <ClipboardManager>();
context.ExecuteBuildUp(buildKey, null);
IEventBrokerInfoPolicy policy = context.Policies.Get <IEventBrokerInfoPolicy>(buildKey);
Assert.IsNotNull(policy);
List <PublicationInfo> publications = new List <PublicationInfo>(policy.Publications);
List <SubscriptionInfo> subscriptions = new List <SubscriptionInfo>(policy.Subscriptions);
publications.Sort(
delegate(PublicationInfo a, PublicationInfo b)
{
return(a.PublishedEventName.CompareTo(b.PublishedEventName));
});
subscriptions.Sort(
delegate(SubscriptionInfo a, SubscriptionInfo b)
{
return(a.PublishedEventName.CompareTo(b.PublishedEventName));
});
CollectionAssert.AreEqual(
new PublicationInfo[]
{
new PublicationInfo("copy", "Copy"),
new PublicationInfo("cut", "Cut"),
new PublicationInfo("paste", "Paste"),
},
publications);
CollectionAssert.AreEqual(
new SubscriptionInfo[]
{
new SubscriptionInfo("clipboard data available", typeof(ClipboardManager).GetMethod("OnClipboardDataAvailable")),
new SubscriptionInfo("copy", typeof(ClipboardManager).GetMethod("OnCopy")),
},
subscriptions);
}
public void StrategyProperlyWiresEvents()
{
MockBuilderContext context = CreateContext();
NamedTypeBuildKey buildKey = NamedTypeBuildKey.Make <ClipboardManager>();
EventBroker broker = new EventBroker();
var brokerLifetime = new ExternallyControlledLifetimeManager();
brokerLifetime.SetValue(broker);
context.Policies.Set <ILifetimePolicy>(brokerLifetime, NamedTypeBuildKey.Make <EventBroker>());
EventBrokerInfoPolicy policy = new EventBrokerInfoPolicy();
policy.AddPublication("cut", "Cut");
policy.AddPublication("copy", "Copy");
policy.AddPublication("paste", "Paste");
policy.AddSubscription("copy", typeof(ClipboardManager).GetMethod("OnCopy"));
policy.AddSubscription("clipboard data available",
typeof(ClipboardManager).GetMethod("OnClipboardDataAvailable"));
context.Policies.Set <IEventBrokerInfoPolicy>(policy, buildKey);
ClipboardManager existing = new ClipboardManager();
context.ExecuteBuildUp(buildKey, existing);
List <string> registeredEvents = new List <string>(broker.RegisteredEvents);
registeredEvents.Sort();
List <string> expectedEvents = new List <string>(new string[]
{
"cut",
"copy",
"paste",
"clipboard data available"
});
expectedEvents.Sort();
CollectionAssert.AreEqual(expectedEvents, registeredEvents);
}