/// <exception cref="System.Exception"></exception>
public virtual void TestCommittedCallbacks()
{
Lock4 lockObject = new Lock4();
BooleanByRef ownEvent = new BooleanByRef(false);
BooleanByRef gotEvent = new BooleanByRef(false);
BooleanByRef shallListen = new BooleanByRef(false);
OwnCommittedCallbacksFixture.IContainerFactory factory = ((OwnCommittedCallbacksFixture.IContainerFactory
)Factory.Value);
OwnCommittedCallbacksFixture.CommitAction action = ((OwnCommittedCallbacksFixture.CommitAction
)Action.Value);
factory.Open();
IObjectContainer clientA = factory.OpenClient();
IObjectContainer clientB = factory.OpenClient();
IEventRegistry registry = EventRegistryFactory.ForObjectContainer(clientA);
registry.Committed += new System.EventHandler <Db4objects.Db4o.Events.CommitEventArgs>
(new _IEventListener4_153(shallListen, gotEvent, ownEvent, lockObject).OnEvent);
lockObject.Run(new _IClosure4_170(shallListen, action, clientA, clientB, lockObject
));
shallListen.value = false;
clientB.Close();
clientA.Close();
factory.Close();
Assert.IsTrue(gotEvent.value);
Assert.AreEqual(action.SelectsFirstClient(), ownEvent.value);
}
/// <exception cref="System.Exception"></exception>
public virtual void TestExceptionInUpdateCallback()
{
var doThrow = new BooleanByRef();
EventRegistryFactory.ForObjectContainer(Db()).Updated += new _IEventListener4_42(doThrow).OnEvent;
var holder = new Holder
();
var item = new Item();
Store(holder);
Store(item);
Commit();
doThrow.value = true;
holder.list = new ArrayList();
holder.list.Add(item);
try
{
Db().Store(holder, int.MaxValue);
}
catch (Exception)
{
}
// rex.printStackTrace();
Checkdb();
Commit();
Checkdb();
Reopen();
Checkdb();
}
public static void Main(string[] args)
{
using (IObjectContainer container = Db4oEmbedded.OpenFile("database.db4"))
{
// #example: Register validation for the create and update event
IEventRegistry events = EventRegistryFactory.ForObjectContainer(container);
events.Creating += ValidateObject;
events.Updating += ValidateObject;
// #end example
// #example: Storing a valid pilot
var pilot = new Pilot {
Name = "Joe"
};
container.Store(pilot);
// #end example
// #example: Storing a invalid pilot throws exception
var otherPilot = new Pilot {
Name = ""
};
try
{
container.Store(otherPilot);
}
catch (EventException e)
{
ValidationException cause = (ValidationException)e.InnerException;
Console.WriteLine(cause.ValidationResult.ErrorMessage);
}
// #end example
}
}
public void Apply(IInternalObjectContainer container)
{
My <LinqQueryMonitor> .Instance.Initialize();
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(container);
PerformanceCounter unoptimizedNativeQueriesPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.UnoptimizedNativeQueriesPerSec, false);
PerformanceCounter nativeQueriesPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.NativeQueriesPerSec, false);
container.GetNativeQueryHandler().QueryExecution += delegate(object sender, QueryExecutionEventArgs args)
{
if (args.ExecutionKind == QueryExecutionKind.Unoptimized)
{
unoptimizedNativeQueriesPerSec.Increment();
}
nativeQueriesPerSec.Increment();
};
eventRegistry.Closing += delegate
{
nativeQueriesPerSec.RemoveInstance();
nativeQueriesPerSec.Dispose();
unoptimizedNativeQueriesPerSec.Dispose();
container.WithEnvironment(delegate
{
My <LinqQueryMonitor> .Instance.Dispose();
});
};
}
public ClientSlotCacheImpl(ClientObjectContainer clientObjectContainer)
{
var eventRegistry = EventRegistryFactory.ForObjectContainer(clientObjectContainer
);
eventRegistry.Activated += new _IEventListener4_29(this).OnEvent;
}
/// <exception cref="System.Exception"></exception>
public virtual void TestExceptionInUpdateCallback()
{
BooleanByRef doThrow = new BooleanByRef();
EventRegistryFactory.ForObjectContainer(Db()).Updated += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs>
(new _IEventListener4_42(doThrow).OnEvent);
ExceptionsInCallbackTestCase.Holder holder = new ExceptionsInCallbackTestCase.Holder
();
ExceptionsInCallbackTestCase.Item item = new ExceptionsInCallbackTestCase.Item();
Store(holder);
Store(item);
Commit();
doThrow.value = true;
holder.list = new ArrayList();
holder.list.Add(item);
try
{
Db().Store(holder, int.MaxValue);
}
catch (Exception)
{
}
// rex.printStackTrace();
Checkdb();
Commit();
Checkdb();
Reopen();
Checkdb();
}
private void RegisterEventHandlers()
{
IObjectContainer deletionEventSource = Db();
if (Fixture() is IDb4oClientServerFixture)
{
IDb4oClientServerFixture clientServerFixture = (IDb4oClientServerFixture)Fixture(
);
deletionEventSource = clientServerFixture.Server().Ext().ObjectContainer();
}
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(Db());
IEventRegistry deletionEventRegistry = EventRegistryFactory.ForObjectContainer(deletionEventSource
);
// No dedicated IncrementListener class due to sharpen event semantics
deletionEventRegistry.Deleted += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs>
(new _IEventListener4_91(this).OnEvent);
eventRegistry.Activated += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs>
(new _IEventListener4_96(this).OnEvent);
eventRegistry.Committed += new System.EventHandler <Db4objects.Db4o.Events.CommitEventArgs>
(new _IEventListener4_101(this).OnEvent);
eventRegistry.Created += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs>
(new _IEventListener4_106(this).OnEvent);
eventRegistry.Updated += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs>
(new _IEventListener4_111(this).OnEvent);
}
private void RegisterPushedUpdates(IExtObjectContainer client)
{
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(client);
eventRegistry.Committed += new System.EventHandler <Db4objects.Db4o.Events.CommitEventArgs>
(new _IEventListener4_120(this, client).OnEvent);
}
private void FlushOnQueryStarted(IInternalObjectContainer container)
{
IEventRegistry registry = EventRegistryFactory.ForObjectContainer(container);
registry.QueryStarted += new System.EventHandler <Db4objects.Db4o.Events.QueryEventArgs>
(new _IEventListener4_46(this).OnEvent);
}
private static void BindContainerEvents(IObjectContainer container, DB4ODatabaseElement dataBaseData)
{
Debug.WriteLine(String.Format("BindingContainerEvents (database: {0})", dataBaseData.Alias));
var eventRegistry = EventRegistryFactory.ForObjectContainer(container);
eventRegistry.Activated += (sender, e) =>
{
if (e.Object == null || !dataBaseData.FillIDB4OEntityInfo)
{
return;
}
var entityInfo = e.Object as IDB4OEntityInfo;
if (entityInfo == null)
{
return;
}
if (entityInfo.HasDB4OEntityInfo())
{
return;
}
entityInfo.FillDB4OInfo(e.ObjectContainer(), dataBaseData.FillMode);
Debug.WriteLine(String.Format("FilledDB4OInfo (database {0})", dataBaseData.Alias));
};
}
public void Apply(IInternalObjectContainer container)
{
IEventRegistry registry = EventRegistryFactory.ForObjectContainer(container);
registry.Creating += new CancellableObjectEventHandler(registry_Creating);
registry.Updating += new CancellableObjectEventHandler(registry_Updating);
}
/// <exception cref="System.Exception"></exception>
public virtual void TestCommittedCallbacks()
{
var lockObject = new Lock4();
var ownEvent = new BooleanByRef(false);
var gotEvent = new BooleanByRef(false);
var shallListen = new BooleanByRef(false);
var factory = ((IContainerFactory
)Factory.Value);
var action = ((CommitAction
)Action.Value);
factory.Open();
var clientA = factory.OpenClient();
var clientB = factory.OpenClient();
var registry = EventRegistryFactory.ForObjectContainer(clientA);
registry.Committed += new _IEventListener4_153(shallListen, gotEvent, ownEvent, lockObject).OnEvent;
lockObject.Run(new _IClosure4_170(shallListen, action, clientA, clientB, lockObject
));
shallListen.value = false;
clientB.Close();
clientA.Close();
factory.Close();
Assert.IsTrue(gotEvent.value);
Assert.AreEqual(action.SelectsFirstClient(), ownEvent.value);
}
private static void EventsClientServer()
{
CleanUp();
StoreJoe();
using (IObjectServer server = OpenServer())
{
IEventRegistry eventsOnServer = EventRegistryFactory.ForObjectContainer(server.Ext().ObjectContainer());
RegisterAFewEvents(eventsOnServer, "db4o server");
IObjectContainer client1 = OpenClient();
IEventRegistry eventsOnClient1 = EventRegistryFactory.ForObjectContainer(client1);
RegisterAFewEvents(eventsOnClient1, "db4o client 1");
RunOperations(client1);
IObjectContainer client2 = OpenClient();
IEventRegistry eventsOnClient2 = EventRegistryFactory.ForObjectContainer(client2);
RegisterAFewEvents(eventsOnClient2, "db4o client 2");
SleepForAWhile();
client1.Dispose();
client2.Dispose();
}
CleanUp();
}
public void Apply(IInternalObjectContainer container)
{
PerformanceCounter queriesPerSec = null;
PerformanceCounter classIndexScansPerSec = null;
container.WithEnvironment(delegate
{
queriesPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.QueriesPerSec, false);
classIndexScansPerSec = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ClassIndexScansPerSec, false);
});
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(container);
eventRegistry.QueryFinished += delegate
{
queriesPerSec.Increment();
};
container.Configure().Diagnostic().AddListener(new DiagnosticListener(classIndexScansPerSec));
eventRegistry.Closing += delegate
{
queriesPerSec.RemoveInstance();
classIndexScansPerSec.RemoveInstance();
queriesPerSec.Dispose();
classIndexScansPerSec.Dispose();
};
}
private static void CancelInEvent()
{
CleanUp();
StoreJoe();
using (IObjectContainer container = OpenEmbedded())
{
// #example: Cancel store operation
IEventRegistry events = EventRegistryFactory.ForObjectContainer(container);
events.Creating +=
delegate(object sender, CancellableObjectEventArgs args)
{
if (args.Object is Person)
{
Person p = (Person)args.Object;
if (p.Name.Equals("Joe Junior"))
{
args.Cancel();
}
}
};
// #end example
container.Store(new Person("Joe Junior"));
int personCount = container.Query <Person>().Count;
Console.WriteLine("Only " + personCount + " because store was cancelled");
}
CleanUp();
}
private static void CommitEvents()
{
CleanUp();
StoreJoe();
using (IObjectContainer container = OpenEmbedded())
{
// #example: Commit-info
IEventRegistry events = EventRegistryFactory.ForObjectContainer(container);
events.Committed +=
delegate(object sender, CommitEventArgs args)
{
foreach (LazyObjectReference reference in args.Added)
{
Console.WriteLine("Added " + reference.GetObject());
}
foreach (LazyObjectReference reference in args.Updated)
{
Console.WriteLine("Updated " + reference.GetObject());
}
foreach (FrozenObjectInfo reference in args.Deleted)
{
//the deleted info might doesn't contain the object anymore and
//return the null.
Console.WriteLine("Deleted " + reference.GetObject());
}
};
// #end example
RunOperations(container);
}
CleanUp();
}
static void Main()
{
var config = Db4oEmbedded.NewConfiguration();
config.File.Storage = new MemoryStorage();
var container = Db4oEmbedded.OpenFile(config, "IN-MEMORY");
var client = container.Ext().OpenSession();
var clientEvents = EventRegistryFactory.ForObjectContainer(client);
clientEvents.Committed += (s, a) =>
{
foreach (IObjectInfo added in a.Added)
{
System.Console.WriteLine(added.GetObject());
}
};
container.Store(new Item {
Value = 1
});
container.Commit();
container.Store(new Item {
Value = 2
});
container.Commit();
container.Store(new Item {
Value = 3
});
container.Commit();
client.Close();
container.Close();
}
private static MutableInteger ActivationCounter(IObjectContainer container)
{
var activationCounter = new MutableInteger();
EventRegistryFactory.ForObjectContainer(container)
.Activating += (sender, args) => activationCounter.Increment();
return(activationCounter);
}
public ClientSlotCacheImpl(ClientObjectContainer clientObjectContainer)
{
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(clientObjectContainer
);
eventRegistry.Activated += new System.EventHandler <Db4objects.Db4o.Events.ObjectInfoEventArgs>
(new _IEventListener4_29(this).OnEvent);
}
protected override void ConfigureSession(IObjectContainer session)
{
base.ConfigureSession(session);
var registry = EventRegistryFactory.ForObjectContainer(session);
registry.Activated += new EventHandler <ObjectInfoEventArgs>(ActivateThing);
registry.Created += new EventHandler <ObjectInfoEventArgs>(ThingCreated);
}
private static void RegisterForEventsOnTheServer()
{
// #example: register for events on the server
IObjectServer server =
Db4oClientServer.OpenServer(DatabaseFileName, PortNumber);
IEventRegistry eventsOnServer =
EventRegistryFactory.ForObjectContainer(server.Ext().ObjectContainer());
// #end example
}
private void AssertEventThrows(string eventName, ICodeBlock codeBlock, IProcedure4
listenerSetter)
{
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(Db());
listenerSetter.Apply(eventRegistry);
Assert.Expect(typeof(EventException), typeof(NotImplementedException), codeBlock,
eventName);
}
public virtual void TestClassRegistrationEvents()
{
var eventFlag = new EventFlag
();
var registry = EventRegistryFactory.ForObjectContainer(Db());
registry.ClassRegistered += new _IEventListener4_23(eventFlag).OnEvent;
Store(new Data());
Assert.IsTrue(eventFlag.eventOccurred);
}
public static void Install(IObjectContainer installOn)
{
var events = EventRegistryFactory.ForObjectContainer(installOn);
var support = new AutoIncrementSupport();
events.Creating += (sender, args)
=> support.IncrementIdsFor(args.Object, installOn);
events.Committing += (sender, args)
=> support.StoreState(installOn);
}
// Nothing to do...
/// <summary>internal method, public for implementation reasons.</summary>
/// <remarks>internal method, public for implementation reasons.</remarks>
public virtual void Apply(IInternalObjectContainer objectContainer)
{
if (objectContainer.IsClient)
{
throw new InvalidOperationException(GetType().FullName + " should be configured on the server."
);
}
EventRegistryFactory.ForObjectContainer(objectContainer).Committing += new System.EventHandler <Db4objects.Db4o.Events.CommitEventArgs>
(new _IEventListener4_46(this, objectContainer).OnEvent);
}
public static void Open()
{
Db4oFactory.Configure().Queries().EvaluationMode(QueryEvaluationMode.Snapshot);
_Current = Db4oFactory.OpenFile("yapFile.yap");
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(_Current);
eventRegistry.Creating += eventRegistry_Validate;
eventRegistry.Updating += eventRegistry_Validate;
eventRegistry.Committing += eventRegistry_Committing;
_Validators = new Dictionary <Type, ObjectValidator>();
}
public virtual void TestClassRegistrationEvents()
{
ClassRegistrationEventsTestCase.EventFlag eventFlag = new ClassRegistrationEventsTestCase.EventFlag
();
IEventRegistry registry = EventRegistryFactory.ForObjectContainer(Db());
registry.ClassRegistered += new System.EventHandler <Db4objects.Db4o.Events.ClassEventArgs>
(new _IEventListener4_23(eventFlag).OnEvent);
Store(new ClassRegistrationEventsTestCase.Data());
Assert.IsTrue(eventFlag.eventOccurred);
}
public void Apply(IInternalObjectContainer container)
{
PerformanceCounter storedObjectsPerSec =
Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsStoredPerSec, false);
PerformanceCounter activatedObjectsPerSec =
Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsActivatedPerSec, false);
PerformanceCounter deactivatedObjectsPerSec =
Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsDeactivatedPerSec, false);
IEventRegistry eventRegistry = EventRegistryFactory.ForObjectContainer(container);
EventHandler <ObjectInfoEventArgs> eventHandler = delegate
{
storedObjectsPerSec.Increment();
};
eventRegistry.Created += eventHandler;
eventRegistry.Updated += eventHandler;
eventRegistry.Activated += delegate
{
activatedObjectsPerSec.Increment();
};
eventRegistry.Deactivated += delegate
{
deactivatedObjectsPerSec.Increment();
};
eventRegistry.Closing += delegate
{
storedObjectsPerSec.Dispose();
activatedObjectsPerSec.Dispose();
deactivatedObjectsPerSec.Dispose();
storedObjectsPerSec.RemoveInstance();
};
if (container.IsClient)
{
return;
}
PerformanceCounter deletedObjectsPerSec =
Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectsDeletedPerSec, false);
eventRegistry.Deleted += delegate
{
deletedObjectsPerSec.Increment();
};
eventRegistry.Closing += delegate
{
deletedObjectsPerSec.Dispose();
};
}
private void AssertQueryEvents(IRunnable query)
{
var events = new ArrayList();
var eventRegistry = EventRegistryFactory.ForObjectContainer(FileSession
());
eventRegistry.QueryStarted += new _IEventListener4_40(events).OnEvent;
eventRegistry.QueryFinished += new _IEventListener4_45(events).OnEvent;
query.Run();
string[] expected = { QueryStarted, QueryFinished };
Iterator4Assert.AreEqual(expected, Iterators.Iterator(events));
}
public virtual void TestTransactionInEventArgs()
{
var factory = EventRegistryFactory.ForObjectContainer(Db());
var called = new BooleanByRef();
var foundTrans = new ObjectByRef();
factory.Creating += new _IEventListener4_20(called, foundTrans).OnEvent;
Db().Store(new Item());
Db().Commit();
Assert.IsTrue(called.value);
Assert.AreSame(Trans(), foundTrans.value);
}
