/// <summary> /// This class is used to place type information on the wire. Since the wire protocol is Provider independent, /// only interface types are stored. Usually this is used to declare the type of the following IPersistenceObject. /// </summary> /// <remarks> /// Since the <see cref="InterfaceType.Factory"/> cannot be serialiezed, this class cannot provide full dehydration. /// Use <see cref="GetSystemType"/> and your own factory to retrieve <see cref="InterfaceType"/>.</remarks> /// <param name="ifType">System.Type to serialize</param> /// <param name="iftFactory"></param> internal SerializableType(InterfaceType ifType, InterfaceType.Factory iftFactory) { var type = ifType.Type; if (type.IsGenericType) { Type genericType = type.GetGenericTypeDefinition(); TypeName = genericType.FullName; AssemblyQualifiedName = genericType.AssemblyQualifiedName; GenericTypeParameter = type.GetGenericArguments() .Select(t => new SerializableType(iftFactory(t), iftFactory)) .ToArray(); } else { TypeName = type.FullName; AssemblyQualifiedName = type.AssemblyQualifiedName; GenericTypeParameter = new SerializableType[] { }; } // This is null if the Type is e.g. a Generic Parameter - not supported if (string.IsNullOrEmpty(AssemblyQualifiedName)) throw new NotSupportedException("AssemblyQualifiedName must not be null or empty - maybe this Type is a Generic Parameter or something similarily strange."); }
public static string InheritanceAssociationName(InterfaceType parentClass, InterfaceType childClass) { //if (parentClass == null) { throw new ArgumentNullException("parentClass"); } //if (childClass == null) { throw new ArgumentNullException("childClass"); } return InheritanceAssociationName(parentClass.Type.Name, childClass.Type.Name); }
public void DecrementQuery(InterfaceType ifType, int objectCount, long startTicks) { var endTicks = Stopwatch.GetTimestamp(); foreach (var a in _appender) { a.DecrementQuery(ifType, objectCount, startTicks, endTicks); } }
public void DecrementGetObjects(InterfaceType ifType, int resultSize, long startTicks) { var endTicks = Stopwatch.GetTimestamp(); foreach (var a in _appender) { a.DecrementGetObjects(ifType, resultSize, startTicks, endTicks); } }
public void DecrementFetchRelation(InterfaceType ifType, int resultSize, long startTicks, long endTicks) { lock (counterLock) { this.ObjectTotals.FetchRelation.Count(resultSize, startTicks, endTicks); Get(ifType).FetchRelation.Count(resultSize, startTicks, endTicks); Dump(false); } }
public override IServerCollectionHandler GetServerCollectionHandler( IReadOnlyZetboxContext ctx, InterfaceType aType, InterfaceType bType, RelationEndRole endRole) { if (ctx == null) throw new ArgumentNullException("ctx"); return GetServerCollectionHandlerHelper( typeof(ServerCollectionHandler<,,,>), ctx.ToImplementationType(aType), ctx.ToImplementationType(bType), endRole); }
public ZetboxService(IServerObjectHandlerFactory sohFactory, Func<IZetboxContext> ctxFactory, InterfaceType.Factory iftFactory, IPerfCounter perfCounter, ZetboxStreamReader.Factory readerFactory, ZetboxStreamWriter.Factory writerFactory) { if (readerFactory == null) throw new ArgumentNullException("readerFactory"); if (writerFactory == null) throw new ArgumentNullException("writerFactory"); Logging.Facade.Debug("Creating new ZetboxService instance"); _sohFactory = sohFactory; _ctxFactory = ctxFactory; _iftFactory = iftFactory; _perfCounter = perfCounter; _readerFactory = readerFactory; _writerFactory = writerFactory; }
public NHibernateImplementationType(Type type, InterfaceType.Factory iftFactory, INHibernateImplementationTypeChecker typeChecker) : base(// translate from NHibernate dynamic proxies if type is not in the generated assembly, but the BaseType is. (type != null && typeChecker != null && type.Assembly != typeChecker.GetType().Assembly && type.BaseType != null && type.BaseType.Assembly == typeChecker.GetType().Assembly) ? type.BaseType : type, iftFactory, typeChecker) { _typeChecker = typeChecker; }
public void DecrementFetchRelation(InterfaceType ifType, int resultSize, long startTicks) { lock (sync) { var duration = Stopwatch.GetTimestamp() - startTicks; FetchRelationTotal++; FetchRelationObjectsTotal += resultSize; FetchRelationSumDuration += duration; Get(ifType).FetchRelationTotal++; Get(ifType).FetchRelationObjectsTotal += resultSize; Get(ifType).FetchRelationSumDuration += duration; ShouldDump(); } }
public void DecrementQuery(InterfaceType ifType, int objectCount, long startTicks) { lock (sync) { var duration = Stopwatch.GetTimestamp() - startTicks; QueriesTotal++; QueriesObjectsTotal += objectCount; QueriesSumDuration += duration; Get(ifType).QueriesTotal++; Get(ifType).QueriesObjectsTotal += objectCount; Get(ifType).QueriesSumDuration += duration; ShouldDump(); } }
public void IncrementGetObjects(InterfaceType ifType) { }
public FrozenMemoryContext(InterfaceType.Factory iftFactory, Func<IFrozenContext> lazyCtx, MemoryImplementationType.MemoryFactory implTypeFactory) : base(iftFactory, lazyCtx, implTypeFactory) { }
private static IPersistenceObject FindObject(IZetboxContext ctx, Dictionary<Guid, IPersistenceObject> objects, Guid exportGuid, InterfaceType ifType) { if (!objects.ContainsKey(exportGuid)) { if (!ifType.Type.IsIDataObject() && !ifType.Type.IsIRelationEntry()) { throw new NotSupportedException(String.Format("Interfacetype {0} is not supported", ifType)); } IPersistenceObject obj = ctx.Internals().CreateUnattached(ifType); objects[exportGuid] = obj; ((Zetbox.App.Base.IExportable)obj).ExportGuid = exportGuid; ctx.Internals().AttachAsNew(obj); return obj; } else { return objects[exportGuid]; } }
public void DecrementGetListOf(InterfaceType ifType, int resultSize, long startTicks, long endTicks) { lock (counterLock) { this.ObjectTotals.GetListOf.Count(resultSize, startTicks, endTicks); Get(ifType).GetListOf.Count(resultSize, startTicks, endTicks); Dump(false); } }
private ObjectMemoryCounters Get(InterfaceType ifType) { var name = ifType.Type.FullName; ObjectMemoryCounters result; if (!Objects.TryGetValue(name, out result)) { result = new ObjectMemoryCounters(name); Objects[name] = result; } return result; }
public bool IsAssignableFrom(InterfaceType b) { return this.Type.IsAssignableFrom(b.Type); }
/// <summary> /// Wrap a given ImplementationType /// </summary> /// <param name="type">A valid ImplementationType</param> /// <param name="iftFactory"></param> /// <param name="implTypeChecker"></param> /// <exception cref="ArgumentOutOfRangeException">if <paramref name="type"/> doesn't /// fulfill all constraints</exception> /// <exception cref="ArgumentNullException">if <paramref name="type"/> is null</exception> protected ImplementationType(Type type, InterfaceType.Factory iftFactory, IImplementationTypeChecker implTypeChecker) { if (type == null) throw new ArgumentNullException("type"); if (iftFactory == null) throw new ArgumentNullException("iftFactory"); if (implTypeChecker == null) throw new ArgumentNullException("implTypeChecker"); if (!implTypeChecker.IsImplementationType(type)) { throw new ArgumentOutOfRangeException("type", String.Format("Type {0} is not an ImplementationType", type.AssemblyQualifiedName)); } this._type = type; this._iftFactory = iftFactory; }
public override IServerObjectHandler GetServerObjectHandler(InterfaceType type) { return GetServerObjectHandlerHelper(typeof(NHibernateServerObjectHandler<>), type); }
public void DecrementGetListOf(InterfaceType ifType, int resultSize, long startTicks) { lock (sync) { var duration = Stopwatch.GetTimestamp() - startTicks; GetListOfTotal++; GetListOfObjectsTotal += resultSize; GetListOfSumDuration += duration; Get(ifType).GetListOfTotal++; Get(ifType).GetListOfObjectsTotal += resultSize; Get(ifType).GetListOfSumDuration += duration; ShouldDump(); } }
public long IncrementFetchRelation(InterfaceType ifType) { foreach (var a in _appender) { a.IncrementFetchRelation(ifType); } return Stopwatch.GetTimestamp(); }
public long IncrementQuery(InterfaceType ifType) { foreach (var a in _appender ?? Empty) { a.IncrementQuery(ifType); } return Stopwatch.GetTimestamp(); }
public long IncrementGetObjects(InterfaceType ifType) { foreach (var a in _appender) { a.IncrementGetObjects(ifType); } return Stopwatch.GetTimestamp(); }
public ZetboxMockFactory(InterfaceType.Factory iftFactory) { }
public void IncrementFetchRelation(InterfaceType ifType) { }
// TODO: Mit david nochmals besprechen internal static InterfaceType Create(Type type, IInterfaceTypeChecker typeChecker) { lock (_lock) { if (type == null) return new InterfaceType(); // Possible, because a Type could be loaded from an XML File which does not exists in this Zetbox instance if (_cache.ContainsKey(type)) return _cache[type]; var ift = new InterfaceType(type, typeChecker); _cache[type] = ift; return ift; } }
public void IncrementGetListOf(InterfaceType ifType) { }
public ClientImplementationType(Type type, InterfaceType.Factory iftFactory, IClientImplementationTypeChecker typeChecker) : base(type, iftFactory, typeChecker) { _typeChecker = typeChecker; }
public void IncrementQuery(InterfaceType ifType) { }
private ObjectsPerfCounter Get(InterfaceType ifType) { var name = ifType.Type.FullName; ObjectsPerfCounter result; if (!_objects.TryGetValue(name, out result)) { result = new ObjectsPerfCounter(name); _objects[name] = result; } return result; }
public FrozenMemoryContext(InterfaceType.Factory iftFactory, Func<IFrozenContext> lazyCtx, MemoryImplementationType.MemoryFactory implTypeFactory, IEnumerable<IZetboxContextEventListener> eventListeners) : base(iftFactory, lazyCtx, implTypeFactory, eventListeners) { }