public void LoadData()
{
BeanContext context = BeanContext.GetInstance();
Object ObjectInstance = null;
Object Data = null;
List <Type> Accessors = context.GetAccessorTypes();
foreach (Type Accessor in Accessors)
{
if (!Accessor.IsInterface)
{
ObjectInstance = null;
Data = null;
MethodInfo Method = Accessor.GetMethod("LoadData");
ObjectInstance = context.GetBean(Accessor);
Data = Method.Invoke(ObjectInstance, null);
if (Data != null)
{
PropertyInfo propertyInfo = Accessor.GetProperty("KeyName");
Object KeyName = propertyInfo.GetValue(ObjectInstance);
if (KeyName != null)
{
this.Put(KeyName.ToString(), Data);
}
}
}
}
}
public void performance()
{
using (IServiceContext childContext = BeanContext.CreateService(typeof(IocPerformanceTestModule)))
{
Assert.AssertEquals(50000, childContext.GetObjects <TestBean>().Count);
}
}
protected void MergePhase1(Object objectToMerge, Object objectToDelete, ProceedWithMergeHook proceedHook, MergeFinishedCallback mergeFinishedCallback, bool addNewEntitiesToCache)
{
ICUDResult cudResult;
MergeHandle mergeHandle;
IDisposableCache childCache = CacheFactory.Create(CacheFactoryDirective.NoDCE, false, false, "MergeProcess.ORIGINAL");
try
{
mergeHandle = BeanContext.RegisterBean <MergeHandle>() //
.PropertyValue("Cache", childCache) //
.Finish();
cudResult = MergeController.MergeDeep(objectToMerge, mergeHandle);
mergeHandle.Cache = null;
}
finally
{
childCache.Dispose();
childCache = null;
}
if (GuiThreadHelper.IsInGuiThread())
{
MergePhase2(objectToMerge, objectToDelete, mergeHandle, cudResult, proceedHook, mergeFinishedCallback, addNewEntitiesToCache);
}
else
{
GuiThreadHelper.InvokeInGui(delegate()
{
MergePhase2(objectToMerge, objectToDelete, mergeHandle, cudResult, proceedHook, mergeFinishedCallback, addNewEntitiesToCache);
});
}
}
public override IClassVisitor Extend(IClassVisitor visitor, IBytecodeBehaviorState state, IList <IBytecodeBehavior> remainingPendingBehaviors,
IList <IBytecodeBehavior> cascadePendingBehaviors)
{
if (state.GetContext <EntityEnhancementHint>() == null && state.GetContext <EmbeddedEnhancementHint>() == null)
{
// ensure LazyRelationsBehavior was invoked
return(visitor);
}
// DefaultPropertiesBehavior executes in this cascade
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(EntityUtil.GetEntityType(state.Context));
CascadeBehavior cascadeBehavior = BeanContext.RegisterBean <CascadeBehavior>().PropertyValue("MetaData", metaData).Finish();
cascadePendingBehaviors.Add(cascadeBehavior);
// // NotifyPropertyChangedBehavior executes in this cascade
// Type currentType = state.getCurrentType();
// if (!IPropertyChanged.class.isAssignableFrom(currentType))
// {
// if (!isAnnotationPresent(currentType, PropertyChangeAspect.class) && !isAnnotationPresent(currentType, DataObjectAspect.class))
// {
// // behavior not applied
// return visitor;
// }
//
// // add IPropertyChanged
// visitor = new InterfaceAdder(visitor, Type.getInternalName(IPropertyChanged.class));
// }
//
// IPropertyInfo[] propertyInfos = propertyInfoProvider.getProperties(currentType);
// visitor = new NotifyPropertyChangedMethodVisitor(visitor, propertyInfos, objectCollector);
// visitor = new PublicConstructorVisitor(visitor);
return(visitor);
}
public virtual IRevertChangesSavepoint CreateSavepoint(Object source)
{
if (source == null)
{
return(null);
}
List <Object> objList = new List <Object>();
List <IObjRef> objRefs = new List <IObjRef>();
FindAllObjectsToBackup(source, objList, objRefs, new IdentityHashSet <Object>());
IDictionary <Object, RevertChangesSavepoint.IBackup> originalToValueBackup = new IdentityDictionary <Object, RevertChangesSavepoint.IBackup>();
// Iterate manually through the list because the list itself should not be 'backuped'
for (int a = objList.Count; a-- > 0;)
{
BackupObjects(objList[a], originalToValueBackup);
}
WeakDictionary <Object, RevertChangesSavepoint.IBackup> weakObjectsToBackup = new WeakDictionary <Object, RevertChangesSavepoint.IBackup>(new IdentityEqualityComparer <Object>());
DictionaryExtension.Loop(originalToValueBackup, delegate(Object obj, RevertChangesSavepoint.IBackup backup)
{
if (backup != null)
{
weakObjectsToBackup.Add(obj, backup);
}
});
return(BeanContext.RegisterBean <RevertChangesSavepoint>().PropertyValue("Changes", weakObjectsToBackup).Finish());
}
private DiQueue()
{
context = BeanContext.GetInstance();
ScopeObjectList = new ConcurrentDictionary <string, List <InjectionObjects> >();
SingletonObjectList = new List <InjectionObjects>();
ScopedClassList = new List <string>();
}
public ReportsController(AttendenceService attendenceService, ReportService reportService)
{
this.attendenceService = attendenceService;
this.reportService = reportService;
this.context = BeanContext.GetInstance();
//this.objReportService.CurrentKey = CurrentRequestKey;
}
private BeanContext GetAnnotationContextObject()
{
if (context == null)
{
context = BeanContext.GetInstance();
}
return(context);
}
public void Cleanup()
{
if (BeanContext != null)
{
BeanContext.GetRoot().Dispose();
BeanContext = null;
}
}
public QuickRegistrationController(RegistrationService registrationService,
IHttpContextAccessor httpContext,
AuthenticationService authenticationService)
{
this.registrationService = registrationService;
this.authenticationService = authenticationService;
this.httpContext = httpContext.HttpContext;
this.context = BeanContext.GetInstance();
}
/// <summary>
/// Contruct a BeanContextMembershipEvent
/// </summary>
/// <param name="bc"> The BeanContext source </param>
/// <param name="changes"> The Children effected </param>
/// <exception cref="NullPointerException"> if changes associated with this
/// event are null. </exception>
public BeanContextMembershipEvent(BeanContext bc, Object[] changes) : base(bc)
{
if (changes == null)
{
throw new NullPointerException("BeanContextMembershipEvent: changes is null.");
}
Children = Arrays.AsList(changes);
}
public override IClassVisitor Extend(IClassVisitor visitor, IBytecodeBehaviorState state, IList <IBytecodeBehavior> remainingPendingBehaviors,
IList <IBytecodeBehavior> cascadePendingBehaviors)
{
// LazyRelationsBehavior executes in this cascade
CascadeBehavior2 cascadeBehavior2 = BeanContext.RegisterBean <CascadeBehavior2>().PropertyValue("MetaData", MetaData).Finish();
cascadePendingBehaviors.Add(cascadeBehavior2);
return(visitor);
}
/// <summary>
/// Contruct a BeanContextMembershipEvent
/// </summary>
/// <param name="bc"> The BeanContext source </param>
/// <param name="changes"> The Children affected </param>
/// <exception cref="NullPointerException"> if <CODE>changes</CODE> is <CODE>null</CODE> </exception>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("rawtypes") public BeanContextMembershipEvent(java.beans.beancontext.BeanContext bc, java.util.Collection changes)
public BeanContextMembershipEvent(BeanContext bc, ICollection changes) : base(bc)
{
if (changes == null)
{
throw new NullPointerException("BeanContextMembershipEvent constructor: changes is null.");
}
Children = changes;
}
public SyncInterface GetService <AsyncInterface, SyncInterface>(params ISecurityScope[] securityScopes)
where AsyncInterface : class, ICommunicationObject
where SyncInterface : class
{
AsyncInterface service = BeanContext.GetService <IServiceFactory>().GetService <AsyncInterface>(securityScopes);
SyncCallInterceptor synchronizedInterceptor = BeanContext.RegisterBean <SyncCallInterceptor>().PropertyValue("AsyncService", service).PropertyValue("AsyncServiceInterface", typeof(AsyncInterface)).Finish();
return((SyncInterface)ProxyFactory.CreateProxy(typeof(SyncInterface), synchronizedInterceptor));
}
public void testAutowired()
{
InitManually(GetType());
Bean1 bean1 = BeanContext.GetService <Bean1>(bean1Name);
Assert.AssertNull(bean1.bean2);
Assert.AssertNotNull(bean1.bean2Autowired);
Assert.AssertNull(bean1.bean3);
Assert.AssertNull(bean1.bean3Autowired);
}
public virtual void RegisterCommand(ICommand command, String parameterBean, int priority)
{
if (String.IsNullOrEmpty(parameterBean))
{
throw new Exception("Empty beanname is not allowed. Use ICommandStringParameterExtendable instead.");
}
Object parameter = BeanContext.GetService(parameterBean);
RegisterCommandIntern(command, parameter, priority, parameterBean);
}
public RegistrationService(IDb db, UserDetail userDetail, ValidateModalService validateModalService, FileService fileService, CurrentSession currentSession)
{
this.db = db;
this.beanContext = BeanContext.GetInstance();
this.userDetail = userDetail;
this.currentSession = currentSession;
this.fileService = fileService;
this.validateModalService = validateModalService;
this.userDetail = currentSession.CurrentUserDetail;
}
public override IClassVisitor Extend(IClassVisitor visitor, IBytecodeBehaviorState state, IList <IBytecodeBehavior> remainingPendingBehaviors,
IList <IBytecodeBehavior> cascadePendingBehaviors)
{
// NotifyPropertyChangedBehavior executes in this cascade
// add IPropertyChanged
visitor = new InterfaceAdder(visitor, typeof(INotifyPropertyChanged), typeof(INotifyPropertyChangedSource),
typeof(IPropertyChangedEventHandler), typeof(INotifyCollectionChangedListener), typeof(IPropertyChangeConfigurable));
visitor = BeanContext.RegisterWithLifecycle(new NotifyPropertyChangedClassVisitor(visitor, MetaData, null)).Finish();
return(visitor);
}
public IProgress StartProgress()
{
IBeanContextHolder <IProgressDispatcherIntern> childSP = progressDispatcherTL.Value;
if (childSP == null)
{
IBeanContextHolder <IProgressDispatcherIntern> progressDispatcher = BeanContext.CreateService <IProgressDispatcherIntern>(typeof(ProgressDispatcherModule));
progressDispatcherTL.Value = progressDispatcher;
}
return(((ProgressDispatcher)childSP.GetTypedValue()).StartProgress());
}
public void TestExtensionPoint()
{
InitManually(GetType());
ITestListenerExtendable testListenerExtendable = BeanContext.GetService <ITestListenerExtendable>("testExtensionPoint");
ITestListenerRegistry testListenerRegistry = BeanContext.GetService <ITestListenerRegistry>("testExtensionPoint");
testListenerExtendable.AddTestListener(new DummyListener());
ITestListener[] testListeners = testListenerRegistry.GetTestListeners();
Assert.IsNotNull(testListeners);
Assert.AreEqual(1, testListeners.Length);
}
public void TestExtensionPointByType()
{
InitManually(GetType());
ITestListenerExtendable2 testListenerExtendable = BeanContext.GetService <ITestListenerExtendable2>("testExtensionPoint2");
ITestListenerRegistry2 testListenerRegistry = BeanContext.GetService <ITestListenerRegistry2>("testExtensionPoint2");
testListenerExtendable.RegisterTestListener(new DummyListener(), typeof(IList));
ITestListener testListener = testListenerRegistry.GetTestListener(typeof(ArrayList));
Assert.IsNotNull(testListener);
}
protected virtual IServiceContext StartIntern(IBackgroundWorkerParamDelegate <IBeanContextFactory> content)
{
writeLock.Lock();
try
{
if (Log.DebugEnabled)
{
Log.Debug("Looking for existing child context...");
}
IServiceContext childContext = GetChildContext();
if (childContext == null || childContext.IsDisposed)
{
if (Log.DebugEnabled)
{
Log.Debug("No valid child context found. Creating new child context");
}
IBackgroundWorkerParamDelegate <IBeanContextFactory> rpd = new IBackgroundWorkerParamDelegate <IBeanContextFactory>(delegate(IBeanContextFactory beanContextFactory)
{
if (content != null)
{
content.Invoke(beanContextFactory);
}
beanContextFactory.RegisterBean <ChildContextFoot>().PropertyValue("ContextHandle", this);
});
if (ContextFactory != null)
{
childContext = ContextFactory.CreateChildContext(rpd);
}
else
{
childContext = BeanContext.CreateService(rpd);
}
SetChildContext(childContext);
childContexts.Add(childContext);
}
else if (Log.DebugEnabled)
{
Log.Debug("Existing child context found and valid");
}
IList <IUpwakingBean> upwakingBeans = childContext.GetImplementingObjects <IUpwakingBean>();
for (int a = 0, size = upwakingBeans.Count; a < size; a++)
{
upwakingBeans[a].WakeUp();
}
return(childContext);
}
finally
{
writeLock.Unlock();
}
}
public object CreateController(ControllerContext context)
{
try
{
BeanContext beanContext = BeanContext.GetInstance();
Type ClassType = context.ActionDescriptor.ControllerTypeInfo.AsType();
Object NewInstance = beanContext.GetBean(ClassType, context.HttpContext);
return(NewInstance);
}
catch (Exception ex)
{
throw ex;
}
}
public virtual void Execute(object parameter)
{
IServiceContext childContext = BeanContext.CreateService(delegate(IBeanContextFactory bcf)
{
if (SelectedItemContainerBean != null)
{
bcf.RegisterExternalBean(SelectedItemContainerBean, parameter);
}
}, EditModuleType);
bool success = false;
try
{
EventHandler eventHandler = new EventHandler(delegate(Object sender, EventArgs e)
{
ChildWindow childWindow = childContext.GetService <ChildWindow>(PopupWindowBean);
bool?dialogResult = childWindow.DialogResult;
if (!dialogResult.HasValue || !dialogResult.Value)
{
Object editedItem = null;
if (parameter is IModelMultiContainer <T> )
{
editedItem = ((IModelSingleContainer <T>)parameter).Value;
}
else
{
editedItem = parameter;
}
RevertChangesHelper.RevertChanges(editedItem);
return;
}
});
childContext.Link(eventHandler).To(PopupWindowBean, ChildWindowEvents.Closed);
success = true;
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
finally
{
if (!success)
{
childContext.Dispose();
}
}
}
public void autowiredVisibility()
{
AutowiredTestBean bean = BeanContext.GetService <AutowiredTestBean>();
Assert.AssertSame(BeanContext, bean.getBeanContextPrivate());
Assert.AssertNull(bean.getBeanContextPrivateSetter());
Assert.AssertSame(BeanContext, bean.getBeanContextPrivateSetterAutowired());
Assert.AssertSame(BeanContext, bean.getBeanContextProtected());
Assert.AssertNull(bean.getBeanContextProtectedSetter());
Assert.AssertSame(BeanContext, bean.getBeanContextProtectedSetterAutowired());
Assert.AssertSame(BeanContext, bean.getBeanContextPublic());
Assert.AssertSame(BeanContext, bean.getBeanContextPublicSetter());
}
public override IClassVisitor Extend(IClassVisitor visitor, IBytecodeBehaviorState state, IList <IBytecodeBehavior> remainingPendingBehaviors,
IList <IBytecodeBehavior> cascadePendingBehaviors)
{
visitor = new InterfaceAdder(visitor, typeof(IDataObject), typeof(INotifyCollectionChangedListener));
visitor = new DataObjectVisitor(visitor, metaData, PropertyInfoProvider);
visitor = new SetCacheModificationMethodCreator(visitor);
// ToBeUpdated & ToBeDeleted have to fire PropertyChange-Events by themselves
String[] properties = { DataObjectVisitor.template_p_toBeUpdated.Name, DataObjectVisitor.template_p_toBeDeleted.Name };
CascadeBehavior2 cascadeBehavior2 = BeanContext.RegisterWithLifecycle(new CascadeBehavior2(metaData, properties)).Finish();
cascadePendingBehaviors.Add(cascadeBehavior2);
return(visitor);
}
protected Object ResolveListener()
{
Object listener = this.Listener;
if (listener != null)
{
listener = ResolveListenerIntern(listener);
this.Listener = listener;
return(listener);
}
else if (ListenerBeanName != null)
{
listener = BeanContext.GetService(ListenerBeanName, !Optional);
if (listener == null)
{
return(null);
}
}
else if (ListenerBean != null)
{
ListenerBeanName = ListenerBean.GetName();
if (ListenerBeanName == null)
{
listener = ListenerBean.GetInstance();
if (listener == null)
{
throw new LinkException("No listener instance received from " + ListenerBean.GetType().FullName + ".getInstance()" + " to link to registry", this);
}
}
else
{
listener = BeanContext.GetService(ListenerBeanName, !Optional);
if (listener == null)
{
return(null);
}
}
}
else
{
throw new LinkException("Listener not found. Must never happen.", this);
}
listener = ResolveListenerIntern(listener);
this.Listener = listener;
return(listener);
}
protected Object[] GetConstructorArguments(ConstructorInfo constructor)
{
ParameterInfo[] parameterTypes = constructor.GetParameters();
Object[] beanArgs = new Object[parameterTypes.Length];
for (int a = parameterTypes.Length; a-- > 0;)
{
Type parameterType = parameterTypes[a].ParameterType;
if (typeof(IEntityFactory).Equals(parameterType))
{
beanArgs[a] = Self;
}
else
{
beanArgs[a] = BeanContext.GetService(parameterType);
}
}
return(beanArgs);
}
public Object ProcessWrite(IPostProcessWriter writer)
{
ISet <Object> substitutedEntities = writer.SubstitutedEntities;
if (substitutedEntities.Count == 0)
{
return(null);
}
IDisposableCache childCache = CacheFactory.Create(CacheFactoryDirective.NoDCE, "XmlMerge");
IServiceContext mergeContext = BeanContext.CreateService(delegate(IBeanContextFactory childContextFactory)
{
childContextFactory.RegisterBean(typeof(MergeHandle)).Autowireable <MergeHandle>().PropertyValue("Cache", childCache);
});
try
{
IDictionary <Object, Int32> mutableToIdMap = writer.MutableToIdMap;
IObjRefHelper objRefHelper = ObjRefHelper;
MergeHandle mergeHandle = mergeContext.GetService <MergeHandle>();
IList <Object> toMerge = new List <Object>(substitutedEntities.Count);
foreach (Object entity in substitutedEntities)
{
toMerge.Add(entity);
IObjRef ori = objRefHelper.EntityToObjRef(entity);
mergeHandle.objToOriDict.Add(entity, ori);
Int32 id = mutableToIdMap[entity];
mutableToIdMap.Add(ori, id);
}
ICUDResult cudResult = MergeController.MergeDeep(toMerge, mergeHandle);
if (cudResult.AllChanges.Count != 0)
{
return(cudResult);
}
else
{
return(null);
}
}
finally
{
mergeContext.Dispose();
}
}
protected Object resolveListener()
{
Object listener = Listener;
Object listenerTarget;
if (listener != null && !(listener is LateDelegate))
{
listenerTarget = listener;
}
else if (ListenerBeanName != null)
{
listenerTarget = BeanContext.GetService(ListenerBeanName);
}
else if (ListenerBean != null)
{
ListenerBeanName = ListenerBean.GetName();
if (ListenerBeanName == null)
{
listenerTarget = ListenerBean.GetInstance();
if (listenerTarget == null)
{
throw new System.Exception("No listener instance received from " + ListenerBean.GetType().FullName + ".getInstance()" + " to link to registry");
}
}
else
{
listenerTarget = BeanContext.GetService(ListenerBeanName);
}
}
else
{
throw new System.Exception("Listener not found. Must never happen.");
}
if (listener is LateDelegate)
{
listener = ((LateDelegate)listener).GetDelegate(listener.GetType(), listenerTarget);
}
else
{
listener = listenerTarget;
}
return(resolveListenerIntern(listener));
}
