public PreparedArrayContainsComparison(IContext context, ArrayHandler arrayHandler
, ITypeHandler4 typeHandler, object obj)
{
_arrayHandler = arrayHandler;
_preparedComparison = Handlers4.PrepareComparisonFor(typeHandler, context, obj);
_container = context.Transaction().Container();
}
public static object[] CollectionToArray(ObjectContainerBase stream, object obj)
{
Collection4 col = FlattenCollection(stream, obj);
object[] ret = new object[col.Size()];
col.ToArray(ret);
return ret;
}
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
private DatabaseIdentityIDAndUUID ReadDatabaseIdentityIDAndUUID
(ObjectContainerBase container, ClassMetadata classMetadata, Slot oldSlot, bool
checkClass)
{
if (DTrace.enabled)
{
DTrace.RereadOldUuid.LogLength(oldSlot.Address(), oldSlot.Length());
}
var reader = container.DecryptedBufferByAddress(oldSlot.Address(), oldSlot
.Length());
if (checkClass)
{
var realClass = ClassMetadata.ReadClass(container, reader);
if (realClass != classMetadata)
{
return null;
}
}
if (classMetadata.SeekToField(container.Transaction, reader, this) == HandlerVersion
.Invalid)
{
return null;
}
return new DatabaseIdentityIDAndUUID(reader.ReadInt(), reader.ReadLong
());
}
public virtual void InitOnUp(Transaction systemTrans, FieldMetadata fieldMetadata
)
{
ObjectContainerBase anyStream = systemTrans.Container();
if (!anyStream.MaintainsIndices())
{
return;
}
if (!fieldMetadata.SupportsIndex())
{
Indexed(false);
}
TernaryBool indexedFlag = _config.GetAsTernaryBool(IndexedKey);
if (indexedFlag.DefiniteNo())
{
fieldMetadata.DropIndex((LocalTransaction)systemTrans);
return;
}
if (UseExistingIndex(systemTrans, fieldMetadata))
{
return;
}
if (!indexedFlag.DefiniteYes())
{
return;
}
fieldMetadata.CreateIndex();
}
public virtual bool Dispatch(Transaction trans, object obj, int eventID)
{
if (methods[eventID] == null)
{
return(true);
}
object[] parameters = new object[] { trans.ObjectContainer() };
ObjectContainerBase container = trans.Container();
int stackDepth = container.StackDepth();
int topLevelCallId = container.TopLevelCallId();
container.StackDepth(0);
try
{
object res = methods[eventID].Invoke(obj, parameters);
if (res is bool)
{
return((bool)res);
}
}
finally
{
container.StackDepth(stackDepth);
container.TopLevelCallId(topLevelCallId);
}
return(true);
}
public PrimitiveTypeMetadata(ObjectContainerBase container, ITypeHandler4 handler
, int id, IReflectClass classReflector) : base(container, classReflector)
{
_aspects = FieldMetadata.EmptyArray;
_typeHandler = handler;
_id = id;
}
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
private UUIDFieldMetadata.DatabaseIdentityIDAndUUID ReadDatabaseIdentityIDAndUUID
(ObjectContainerBase container, ClassMetadata classMetadata, Slot oldSlot, bool
checkClass)
{
if (DTrace.enabled)
{
DTrace.RereadOldUuid.LogLength(oldSlot.Address(), oldSlot.Length());
}
ByteArrayBuffer reader = container.DecryptedBufferByAddress(oldSlot.Address(), oldSlot
.Length());
if (checkClass)
{
ClassMetadata realClass = ClassMetadata.ReadClass(container, reader);
if (realClass != classMetadata)
{
return(null);
}
}
if (classMetadata.SeekToField(container.Transaction, reader, this) == HandlerVersion
.Invalid)
{
return(null);
}
return(new UUIDFieldMetadata.DatabaseIdentityIDAndUUID(reader.ReadInt(), reader.ReadLong
()));
}
private void Marshall(Transaction trans, ObjectReference @ref, IWriteBuffer buffer
, bool isNew)
{
if (!trans.SupportsVirtualFields())
{
MarshallIgnore(buffer);
return;
}
ObjectContainerBase stream = trans.Container();
HandlerRegistry handlers = stream._handlers;
bool migrating = false;
if (stream._replicationCallState == Const4.New)
{
IDb4oReplicationReferenceProvider provider = handlers._replicationReferenceProvider;
object parentObject = @ref.GetObject();
IDb4oReplicationReference replicationReference = provider.ReferenceFor(parentObject
);
if (replicationReference != null)
{
migrating = true;
VirtualAttributes va = @ref.ProduceVirtualAttributes();
va.i_version = replicationReference.Version();
va.i_uuid = replicationReference.LongPart();
va.i_database = replicationReference.SignaturePart();
}
}
if (@ref.VirtualAttributes() == null)
{
@ref.ProduceVirtualAttributes();
migrating = false;
}
Marshall(trans, @ref, buffer, migrating, isNew);
}
private void LogEvent(ObjectContainerBase container, string @event, int level)
{
if (container.ConfigImpl.MessageLevel() > level)
{
container.Message(string.Empty + GetID() + " " + @event + " " + _class.GetName());
}
}
public PreparedArrayContainsComparison(IContext context, ArrayHandler arrayHandler
, ITypeHandler4 typeHandler, object obj)
{
_arrayHandler = arrayHandler;
_preparedComparison = Handlers4.PrepareComparisonFor(typeHandler, context, obj);
_container = context.Transaction().Container();
}
public PrimitiveTypeMetadata(ObjectContainerBase container, ITypeHandler4 handler
, int id, IReflectClass classReflector) : base(container, classReflector)
{
_aspects = FieldMetadata.EmptyArray;
_typeHandler = handler;
_id = id;
}
internal virtual void ActivateInternal(IActivationContext context)
{
if (null == context)
{
throw new ArgumentNullException();
}
if (!context.Depth().RequiresActivation())
{
return;
}
ObjectContainerBase container = context.Container();
if (context.Depth().Mode().IsRefresh())
{
LogActivation(container, "refresh");
}
else
{
if (IsActive())
{
_class.CascadeActivation(context);
return;
}
LogActivation(container, "activate");
}
ReadForActivation(context);
}
internal static Collection4 FlattenCollection(ObjectContainerBase stream, Object obj)
{
Collection4 collection41 = new Collection4();
FlattenCollection1(stream, obj, collection41);
return(collection41);
}
public override IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container
, ArrayInfo info, int classID)
{
if (classID == Const4.IgnoreId)
{
// TODO: Here is a low-frequency mistake, extremely unlikely.
// If classID == 99999 by accident then we will get ignore.
return null;
}
info.Primitive(false);
if (UseJavaHandling())
{
if (classID < Const4.Primitive)
{
info.Primitive(true);
classID -= Const4.Primitive;
}
}
classID = -classID;
ClassMetadata classMetadata = container.ClassMetadataForID(classID);
if (classMetadata != null)
{
return ClassReflector(container.Reflector(), classMetadata, info.Primitive());
}
return null;
}
public LocalTransaction(ObjectContainerBase container, Transaction parentTransaction
, ITransactionalIdSystem idSystem, IReferenceSystem referenceSystem) : base(container
, parentTransaction, referenceSystem)
{
_file = (LocalObjectContainer)container;
_committedCallbackDispatcher = new _ICommittedCallbackDispatcher_39(this);
_idSystem = idSystem;
}
public static object[] CollectionToArray(ObjectContainerBase stream, object obj)
{
Collection4 col = FlattenCollection(stream, obj);
object[] ret = new object[col.Size()];
col.ToArray(ret);
return(ret);
}
public Transaction(ObjectContainerBase container, Transaction
systemTransaction, IReferenceSystem referenceSystem)
{
// contains DeleteInfo nodes
_container = container;
_systemTransaction = systemTransaction;
_referenceSystem = referenceSystem;
}
public static ClassMetadata ErasedFieldType(ObjectContainerBase container, IReflectClass
fieldType)
{
return(fieldType.IsInterface()
? container.ClassMetadataForID(UntypedId)
: container
.ProduceClassMetadata(BaseType(fieldType)));
}
public LocalTransaction(ObjectContainerBase container, Transaction parentTransaction
, ITransactionalIdSystem idSystem, IReferenceSystem referenceSystem) : base(container
, parentTransaction, referenceSystem)
{
_file = (LocalObjectContainer) container;
_committedCallbackDispatcher = new _ICommittedCallbackDispatcher_39(this);
_idSystem = idSystem;
}
protected virtual bool ObjectCanUpdate(Db4objects.Db4o.Internal.Transaction transaction
, object obj)
{
ObjectContainerBase container = transaction.Container();
return(container.Callbacks().ObjectCanUpdate(transaction, this) && _class.DispatchEvent
(transaction, obj, EventDispatchers.CanUpdate));
}
public virtual void SetObjectWeak(ObjectContainerBase container, object obj)
{
if (_object != null)
{
Platform4.KillYapRef(_object);
}
_object = container.NewWeakReference(this, obj);
}
public virtual void SetTransaction(Transaction trans)
{
if (trans != null)
{
_trans = trans;
_stream = trans.Container();
}
}
private void ObjectOnNew(Db4objects.Db4o.Internal.Transaction transaction, object
obj)
{
ObjectContainerBase container = transaction.Container();
container.Callbacks().ObjectOnNew(transaction, this);
_class.DispatchEvent(transaction, obj, EventDispatchers.New);
}
public virtual void Activate(Db4objects.Db4o.Internal.Transaction ta, object obj,
IActivationDepth depth)
{
ObjectContainerBase container = ta.Container();
ActivateInternal(container.ActivationContextFor(ta, obj, depth));
container.ActivatePending(ta);
}
private static TransportObjectContainer NewTransportObjectContainer(ObjectContainerBase
serviceProvider, MemoryBin memoryBin)
{
TransportObjectContainer container = new TransportObjectContainer(serviceProvider
, memoryBin);
container.DeferredOpen();
return container;
}
public Transaction(ObjectContainerBase container, Db4objects.Db4o.Internal.Transaction
systemTransaction, IReferenceSystem referenceSystem)
{
// contains DeleteInfo nodes
_container = container;
_systemTransaction = systemTransaction;
_referenceSystem = referenceSystem;
}
private static TransportObjectContainer NewTransportObjectContainer(ObjectContainerBase
serviceProvider, MemoryBin memoryBin)
{
TransportObjectContainer container = new TransportObjectContainer(serviceProvider
, memoryBin);
container.DeferredOpen();
return(container);
}
public TransportObjectContainer(ObjectContainerBase parent, MemoryBin memoryFile)
: base(parent.Config())
{
_memoryBin = memoryFile;
_parent = parent;
_lock = parent.Lock();
_showInternalClasses = parent._showInternalClasses;
Open();
}
private void CreateBTreeIndex(ObjectContainerBase stream, int btreeID)
{
if (stream.IsClient)
{
return;
}
_btreeIndex = ((LocalObjectContainer)stream).CreateBTreeClassIndex(btreeID);
_btreeIndex.SetRemoveListener(new _IVisitor4_61(this));
}
public virtual int ClassIDFromInfo(ObjectContainerBase container, ArrayInfo info)
{
ClassMetadata classMetadata = container.ProduceClassMetadata(info.ReflectClass());
if (classMetadata == null)
{
return 0;
}
return classMetadata.GetID();
}
public TransportObjectContainer(ObjectContainerBase parent, MemoryBin memoryFile)
: base(parent.Config())
{
_memoryBin = memoryFile;
_parent = parent;
_lock = parent.Lock();
_showInternalClasses = parent._showInternalClasses;
Open();
}
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz
, ByteArrayBuffer reader)
{
int indexID = reader.ReadInt();
if (indexID == 0)
{
return;
}
clazz.Index().Read(stream, indexID);
}
public virtual GenericReflector Reflector()
{
ObjectContainerBase container = Container();
if (container == null)
{
return(null);
}
return(container.Reflector());
}
internal static void RemoveShutDownHook(ObjectContainerBase container)
{
lock (_shutdownStreamsLock)
{
if (_containersToBeShutdown != null)
{
_containersToBeShutdown.Remove(container);
}
}
}
internal override void Marshall(Transaction trans, ObjectReference @ref, IWriteBuffer
buffer, bool isMigrating, bool isNew)
{
VirtualAttributes attr = @ref.VirtualAttributes();
ObjectContainerBase container = trans.Container();
bool doAddIndexEntry = isNew && container.MaintainsIndices();
int dbID = 0;
bool linkToDatabase = (attr != null && attr.i_database == null) ? true : !isMigrating;
if (linkToDatabase)
{
Db4oDatabase db = ((IInternalObjectContainer)container).Identity();
if (db == null)
{
// can happen on early classes like Metaxxx, no problem
attr = null;
}
else
{
if (attr.i_database == null)
{
attr.i_database = db;
// TODO: Should be check for ! client instead of instanceof
if (container is LocalObjectContainer)
{
attr.i_uuid = container.GenerateTimeStampId();
doAddIndexEntry = true;
}
}
db = attr.i_database;
if (db != null)
{
dbID = db.GetID(trans);
}
}
}
else
{
if (attr != null)
{
dbID = attr.i_database.GetID(trans);
}
}
buffer.WriteInt(dbID);
if (attr == null)
{
buffer.WriteLong(0);
return;
}
buffer.WriteLong(attr.i_uuid);
if (doAddIndexEntry)
{
AddIndexEntry(trans, @ref.GetID(), attr.i_uuid);
}
}
protected BTree NewBTree(Transaction systemTrans, int id)
{
ObjectContainerBase stream = systemTrans.Container();
IIndexable4 indexHandler = IndexHandler(stream);
if (indexHandler == null)
{
return(null);
}
return(new BTree(systemTrans, id, new FieldIndexKeyHandler(indexHandler)));
}
protected ClassMetadata(ObjectContainerBase container)
{
if (null == container)
{
throw new ArgumentNullException();
}
_container = container;
_index = CreateIndexStrategy();
_classIndexed = true;
_fieldAccessor = new StrictFieldAccessor();
}
public override IPreparedComparison PrepareComparison(ObjectContainerBase container
, object constraint)
{
Db4objects.Db4o.Internal.ClassMetadata classMetadata = ClassMetadata();
if (classMetadata == null)
{
return null;
}
return classMetadata.PrepareComparison(container.Transaction.Context(), constraint
);
}
public static SerializedGraph Marshall(ObjectContainerBase serviceProvider, object
obj)
{
MemoryBin memoryBin = new MemoryBin(223, GrowthStrategy());
TransportObjectContainer carrier = NewTransportObjectContainer(serviceProvider, memoryBin
);
carrier.ProduceClassMetadata(carrier.Reflector().ForObject(obj));
carrier.Store(obj);
int id = (int)carrier.GetID(obj);
carrier.Close();
return new SerializedGraph(id, memoryBin.Data());
}
public virtual void WriteUpdate(Db4objects.Db4o.Internal.Transaction transaction,
IUpdateDepth updatedepth)
{
ContinueSet(transaction, updatedepth);
// make sure, a concurrent new, possibly triggered by objectOnNew
// is written to the file
// preventing recursive
if (!BeginProcessing())
{
return;
}
object obj = GetObject();
if (!ObjectCanUpdate(transaction, obj) || !IsActive() || obj == null || !ClassMetadata
().IsModified(obj))
{
EndProcessing();
return;
}
MarshallingContext context = new MarshallingContext(transaction, this, updatedepth
, false);
if (context.UpdateDepth().Negative())
{
EndProcessing();
return;
}
ObjectContainerBase container = transaction.Container();
LogEvent(container, "update", Const4.State);
SetStateClean();
context.PurgeFieldIndexEntriesOnUpdate(transaction, container._handlers.ArrayType
(obj));
Handlers4.Write(_class.TypeHandler(), context, obj);
if (context.UpdateDepth().CanSkip(this))
{
EndProcessing();
return;
}
Pointer4 pointer = context.AllocateSlot();
ByteArrayBuffer buffer = context.ToWriteBuffer(pointer);
container.WriteUpdate(transaction, pointer, _class, container._handlers.ArrayType
(obj), buffer);
if (IsActive())
{
SetStateClean();
}
EndProcessing();
container.Callbacks().ObjectOnUpdate(transaction, this);
ClassMetadata().DispatchEvent(transaction, obj, EventDispatchers.Update);
}
public static IWeakReferenceSupport ForObjectContainer(ObjectContainerBase container
)
{
if (!Platform4.HasWeakReferences())
{
return DisabledWeakReferenceSupport();
}
if (!container.ConfigImpl.WeakReferences())
{
return DisabledWeakReferenceSupport();
}
return new EnabledWeakReferenceSupport(container);
}
public override int ClassIDFromInfo(ObjectContainerBase container, ArrayInfo info
)
{
ClassMetadata classMetadata = container.ProduceClassMetadata(info.ReflectClass());
if (classMetadata == null)
{
// TODO: This one is a terrible low-frequency blunder !!!
// If YapClass-ID == 99999 then we will get IGNORE back.
// Discovered on adding the primitives
return Const4.IgnoreId;
}
return classMetadata.GetID();
}
protected virtual ITypeHandler4 TypeHandlerForClass(ObjectContainerBase container
, IReflectClass fieldType)
{
container.ShowInternalClasses(true);
try
{
return(container.TypeHandlerForClass(Handlers4.BaseType(fieldType)));
}
finally
{
container.ShowInternalClasses(false);
}
}
private ObjectHeader(ObjectContainerBase container, Db4objects.Db4o.Internal.ClassMetadata
classMetadata, IReadWriteBuffer reader)
{
int classID = reader.ReadInt();
_marshallerFamily = ReadMarshallerFamily(reader, classID);
classID = NormalizeID(classID);
_classMetadata = (classMetadata != null ? classMetadata : container.ClassMetadataForID
(classID));
// This check has been added to cope with defragment in debug mode: SlotDefragment#setIdentity()
// will trigger calling this constructor with a source db class metadata and a target db stream,
// thus _classMetadata==null. There may be a better solution, since this call is just meant to
// skip the object header.
_headerAttributes = SlotFormat().ReadHeaderAttributes((ByteArrayBuffer)reader);
}
public static SerializedGraph Marshall(ObjectContainerBase serviceProvider, object
obj)
{
MemoryBin memoryBin = new MemoryBin(223, GrowthStrategy());
TransportObjectContainer carrier = NewTransportObjectContainer(serviceProvider, memoryBin
);
carrier.ProduceClassMetadata(carrier.Reflector().ForObject(obj));
carrier.Store(obj);
int id = (int)carrier.GetID(obj);
carrier.Close();
return(new SerializedGraph(id, memoryBin.Data()));
}
public virtual IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container
, ArrayInfo info, int classID)
{
if (classID == 0)
{
return null;
}
ClassMetadata classMetadata = container.ClassMetadataForID(classID);
if (classMetadata == null)
{
return null;
}
return ClassReflector(container.Reflector(), classMetadata, info.Primitive());
}
private static int EventCountFor(ObjectContainerBase container)
{
CallBackMode callbackMode = container.ConfigImpl.CallbackMode();
if (callbackMode == CallBackMode.All)
{
return(Count);
}
if (callbackMode == CallBackMode.DeleteOnly)
{
return(DeleteCount);
}
return(0);
}
protected override FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase
stream, ClassMetadata containingClass)
{
FieldMetadata actualField = base.FromSpec(spec, stream, containingClass);
if (spec == null)
{
return null;
}
if (spec.IndexID() != 0)
{
actualField.InitIndex(stream.SystemTransaction(), spec.IndexID());
}
return actualField;
}
internal static void AddShutDownHook(ObjectContainerBase container)
{
lock (_shutdownStreamsLock)
{
if (_containersToBeShutdown == null)
{
_containersToBeShutdown = new List<ObjectContainerBase>();
#if !CF && !SILVERLIGHT
AppDomain.CurrentDomain.ProcessExit += OnShutDown;
AppDomain.CurrentDomain.DomainUnload += OnShutDown;
#endif
}
_containersToBeShutdown.Add(container);
}
}
protected virtual IIndexable4 IndexHandler(ObjectContainerBase stream)
{
if (_reflectField == null)
{
return(null);
}
IReflectClass indexType = _reflectField.IndexType();
ITypeHandler4 classHandler = TypeHandlerForClass(stream, indexType);
if (!(classHandler is IIndexable4))
{
return(null);
}
return((IIndexable4)classHandler);
}
// FIXME: needs test case
public virtual void Rename(string newName)
{
ObjectContainerBase container = Container();
if (!container.IsClient)
{
_name = newName;
_containingClass.SetStateDirty();
_containingClass.Write(container.SystemTransaction());
}
else
{
Exceptions4.ThrowRuntimeException(58);
}
}
public override int MarshalledLength(ObjectContainerBase stream, ClassAspect aspect
)
{
int len = base.MarshalledLength(stream, aspect);
if (!(aspect is FieldMetadata))
{
return len;
}
FieldMetadata field = (FieldMetadata)aspect;
if (!HasBTreeIndex(field))
{
return len;
}
return len + Const4.IdLength;
}
public static object Unmarshall(ObjectContainerBase serviceProvider, byte[] bytes
, int id)
{
if (id <= 0)
{
return null;
}
MemoryBin memoryBin = new MemoryBin(bytes, GrowthStrategy());
TransportObjectContainer carrier = NewTransportObjectContainer(serviceProvider, memoryBin
);
object obj = carrier.GetByID(id);
carrier.Activate(carrier.Transaction, obj, new FullActivationDepth());
carrier.Close();
return obj;
}
public virtual void Store(ObjectContainerBase container)
{
container.ShowInternalClasses(true);
try
{
Transaction trans = container.CheckTransaction();
container.StoreAfterReplication(trans, this, container.UpdateDepthProvider().ForDepth
(1), false);
container.Commit(trans);
}
finally
{
container.ShowInternalClasses(false);
}
}
internal static void AddShutDownHook(ObjectContainerBase container)
{
lock (_shutdownStreamsLock)
{
if (_containersToBeShutdown == null)
{
_containersToBeShutdown = new List <ObjectContainerBase>();
#if !CF && !SILVERLIGHT
AppDomain.CurrentDomain.ProcessExit += OnShutDown;
AppDomain.CurrentDomain.DomainUnload += OnShutDown;
#endif
}
_containersToBeShutdown.Add(container);
}
}
protected override RawFieldSpec ReadSpec(AspectType aspectType, ObjectContainerBase
stream, ByteArrayBuffer reader)
{
RawFieldSpec spec = base.ReadSpec(aspectType, stream, reader);
if (spec == null)
{
return null;
}
if (spec.IsVirtual())
{
return spec;
}
int indexID = reader.ReadInt();
spec.IndexID(indexID);
return spec;
}
public override int MarshalledLength(ObjectContainerBase stream, ClassAspect aspect
)
{
int len = stream.StringIO().ShortLength(aspect.GetName());
if (aspect is FieldMetadata)
{
FieldMetadata field = (FieldMetadata)aspect;
if (field.NeedsArrayAndPrimitiveInfo())
{
len += 1;
}
if (!(field is VirtualFieldMetadata))
{
len += Const4.IdLength;
}
}
return len;
}
protected override RawFieldSpec ReadSpec(AspectType aspectType, ObjectContainerBase
stream, ByteArrayBuffer reader)
{
string name = StringHandler.ReadStringNoDebug(stream.Transaction.Context(), reader
);
if (!aspectType.IsFieldMetadata())
{
return new RawFieldSpec(aspectType, name);
}
if (name.IndexOf(Const4.VirtualFieldPrefix) == 0)
{
if (stream._handlers.VirtualFieldByName(name) != null)
{
return new RawFieldSpec(aspectType, name);
}
}
int fieldTypeID = reader.ReadInt();
byte attribs = reader.ReadByte();
return new RawFieldSpec(aspectType, name, fieldTypeID, attribs);
}
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz
, ByteArrayBuffer reader)
{
int indexID = reader.ReadInt();
if (!stream.MaintainsIndices() || !(stream is LocalObjectContainer))
{
return;
}
if (Btree(clazz) != null)
{
return;
}
clazz.Index().Read(stream, ValidIndexId(indexID));
if (IsOldClassIndex(indexID))
{
new ClassIndexesToBTrees_5_5().Convert((LocalObjectContainer)stream, indexID, Btree
(clazz));
stream.SetDirtyInSystemTransaction(clazz);
}
}
private static IReflectMethod[] EventHandlerTableFor(ObjectContainerBase container
, IReflectClass classReflector)
{
IReflectClass[] parameterClasses =
{
container._handlers.IclassObjectcontainer
};
var methods = new IReflectMethod[Count];
for (var i = Count - 1; i >= 0; i--)
{
var method = classReflector.GetMethod(events[i], parameterClasses);
if (null == method)
{
method = classReflector.GetMethod(ToPascalCase(events[i]), parameterClasses);
}
if (method != null)
{
methods[i] = method;
}
}
return methods;
}
