/// <summary> /// Registers a given instance for a given service type and a given name. /// </summary> /// <typeparam name="TInterface">The type that is being registered.</typeparam> /// <param name="factory">The factory method able to create the instance that /// must be returned when the given type is resolved.</param> /// <param name="name">The name for which the given instance is registered.</param> public void Register <TInterface>(Func <TInterface> factory, string name) where TInterface : class { if (factory == null) { throw new ArgumentNullException(nameof(factory)); } var serviceType = typeof(TInterface); var key = new InstanceKey(serviceType, name); if (_factories.ContainsKey(key)) { throw new ServiceAlreadyRegisteredException(serviceType, null); } _factories.Add(key, factory); if (name == null) { return; } if (!_namedInstances.TryGetValue(serviceType, out List <string> instances)) { instances = new List <string>(); _namedInstances.Add(serviceType, instances); } instances.Add(name); }
protected override int CountInstancesInternal(InstanceKey classInstanceKey) { InstanceHandle ihClass = GetInstance(classInstanceKey); InstanceHandle[] insts = GetRelatedInstances(GetInstance(classInstanceKey), GetInstance(KnownRelationshipGuids.Class__has__Instance)); return(insts.Length); }
/// <summary> /// Factory method you should use instead of the constructor for this class. /// This will construct a new instance if and only if there isn't already /// an instance made for this particular kOSProcessor, for the given body /// (Uniqueness determinied by the Body's text name. If someone makes /// a modded solar system with two bodies having the same name, that /// will be a problem (but who would do that??) ). /// If an instance already exists it will return a reference to that instead of making /// a new one. /// The reason this enforcement is needed is because BodyTarget has callback hooks /// that prevent orphaning and garbage collection. (The delegate inserted /// into KSP's GameEvents counts as a reference to the BodyTarget.) /// Using this factory method instead of a constructor prevents having multiple /// instances of BodyTarget. /// </summary> /// <returns>The or get.</returns> /// <param name="body">celestial body to make the wrapper for</param> /// <param name="Shared">kOS shared objects reference</param> public static BodyTarget CreateOrGetExisting(CelestialBody body, SharedObjects shared) { if (instanceCache == null) { instanceCache = new Dictionary <InstanceKey, WeakReference>(); } InstanceKey key = new InstanceKey { ProcessorId = shared.Processor.KOSCoreId, BodyName = body.name }; if (instanceCache.ContainsKey(key)) { WeakReference weakRef = instanceCache[key]; if (weakRef.IsAlive) { return((BodyTarget)weakRef.Target); } else { instanceCache.Remove(key); } } // If it either wasn't in the cache, or it was but the GC destroyed it by now, make a new one: BodyTarget newlyConstructed = new BodyTarget(body, shared); instanceCache.Add(key, new WeakReference(newlyConstructed)); return(newlyConstructed); }
public BaseFormParent() { InitializeComponent(); this.Key = InstanceKey.Generate(this); RegisterForm(); PerformAction(); }
/// <summary> /// This method resolves a service object request /// </summary> /// <param name="serviceType">Service object type</param> /// <param name="name">Service instance name</param> /// <returns>Service instance, if found; otherwise, null</returns> private object ObtainService(Type serviceType, string name = null) { var key = new InstanceKey(serviceType, name); return(_factories.TryGetValue(key, out Func <object> factory) ? factory() : null); }
protected override InstanceHandle GetInstanceInternal(InstanceKey key) { if (GetDefaultTenant()._instsByKey.ContainsKey(key)) { return(GetDefaultTenant()._instsByKey[key]); } return(InstanceHandle.Empty); }
public LoadOrCreateAsyncResult(PersistenceProviderDirectory ppd, InstanceKey key, Guid suggestedIdOrId, bool canCreateInstance, ICollection <InstanceKey> associatedKeys, Transaction transaction, bool loadAny, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { bool flag; this.ppd = ppd; this.key = key; this.suggestedIdOrId = suggestedIdOrId; this.canCreateInstance = canCreateInstance; this.associatedKeys = associatedKeys; this.transaction = transaction; this.loadAny = loadAny; this.timeoutHelper = new TimeoutHelper(timeout); if ((this.associatedKeys != null) && (this.associatedKeys.Count == 0)) { this.associatedKeys = null; } base.OnCompleting = onComplete; if (this.transaction != null) { TransactionInterop.GetDtcTransaction(this.transaction); } Exception exception = null; try { this.result = this.loadAny ? null : this.ppd.LoadFromCache(this.key, this.suggestedIdOrId, this.canCreateInstance); if (this.result != null) { flag = true; } else { if ((this.ppd.store == null) && !this.canCreateInstance) { if (this.key != null) { throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InstanceKeyNotReadyException(null, this.key)); } throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InstanceNotReadyException(null, this.suggestedIdOrId)); } IAsyncResult result = this.ppd.BeginReserveThrottle(this.timeoutHelper.RemainingTime(), base.PrepareAsyncCompletion(handleReserveThrottle), this); flag = base.SyncContinue(result); } } catch (Exception exception2) { if (Fx.IsFatal(exception2)) { throw; } exception = exception2; flag = true; } if (flag) { base.Complete(true, exception); } }
/// <summary> /// Computes a key for storing and identifying an instance in the cache. /// </summary> /// <param name="type">Type of instance to get</param> /// <param name="properties">List of properties and values</param> /// <param name="parentInstance">Parent instance. Can be NULL if this is the root instance.</param> /// <returns> /// InstanceKey that will be unique for given set of identifiers values for the type. If the type isn't associated with any /// identifier, the return value is made unique by generating a Guid. /// ASSUMES GetIdentifiers(type) ALWAYS RETURN IDENTIFIERS IN THE SAME ORDER FOR A GIVEN TYPE. /// This is certainly the case as long as GetIdentifiers caches its result for a given type (which it does by 2016-11-25). /// </returns> private static InstanceKey GetCacheKey(Type type, IDictionary <string, object> properties, object parentInstance) { var identifierValues = GetIdentifiers(type)?.Select(id => properties[id]).DefaultIfEmpty(Guid.NewGuid()).ToArray() ?? new object[] { Guid.NewGuid() }; var key = new InstanceKey(type, identifierValues, parentInstance); return(key); }
private InstancePersistenceCommand CreateLoadCommandHelper(InstanceKey key, out InstanceHandle handle, bool canCreateInstance, Guid suggestedIdOrId, ICollection <InstanceKey> associatedKeys, bool loadAny) { if (loadAny) { handle = this.store.CreateInstanceHandle(this.owner); return(new TryLoadRunnableWorkflowCommand()); } if (key != null) { LoadWorkflowByInstanceKeyCommand command; handle = this.store.CreateInstanceHandle(this.owner); if (canCreateInstance) { command = new LoadWorkflowByInstanceKeyCommand { LookupInstanceKey = key.Value, AssociateInstanceKeyToInstanceId = (suggestedIdOrId == Guid.Empty) ? Guid.NewGuid() : suggestedIdOrId, AcceptUninitializedInstance = true }; } else { command = new LoadWorkflowByInstanceKeyCommand { LookupInstanceKey = key.Value }; } InstanceKey keyToAdd = ((canCreateInstance && (key.Metadata != null)) && (key.Metadata.Count > 0)) ? key : null; if (associatedKeys != null) { foreach (InstanceKey key3 in associatedKeys) { if (key3 == key) { if (!canCreateInstance) { continue; } keyToAdd = null; } TryAddKeyToInstanceKeysCollection(command.InstanceKeysToAssociate, key3); } } if (keyToAdd != null) { TryAddKeyToInstanceKeysCollection(command.InstanceKeysToAssociate, keyToAdd); } return(command); } if (associatedKeys != null) { throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.NoAdditionalKeysOnInstanceIdLoad)); } handle = this.store.CreateInstanceHandle(this.owner, (suggestedIdOrId == Guid.Empty) ? Guid.NewGuid() : suggestedIdOrId); return(new LoadWorkflowCommand { AcceptUninitializedInstance = canCreateInstance }); }
public bool CalculateKeys(Message message, out InstanceKey instanceKey, out ICollection <InstanceKey> additionalKeys) { MessageCalculator messageCalculator = this.messageCalculator; if (messageCalculator == null) { messageCalculator = this.messageCalculator = new MessageCalculator(this); } return(messageCalculator.CalculateKeys(message, null, out instanceKey, out additionalKeys)); }
void TraceCorrelationKeys(InstanceKey instanceKey, Dictionary <string, string> values) { StringBuilder keyValueAsString = new StringBuilder(); foreach (KeyValuePair <string, string> pair in values) { keyValueAsString.Append(pair.Key).Append(":").Append(pair.Value).Append(','); } TD.TraceCorrelationKeys(instanceKey.Value, keyValueAsString.ToString(), this.parent.scopeName.ToString()); }
public CorrelationMessageProperty(InstanceKey correlationKey, IEnumerable <InstanceKey> additionalKeys, IEnumerable <InstanceKey> transientCorrelations) { if (correlationKey == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("correlationKey"); } if (additionalKeys == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("additionalKeys"); } this.correlationKey = correlationKey; ICollection <InstanceKey> additionalKeysCollection = additionalKeys as ICollection <InstanceKey>; if (additionalKeysCollection != null && additionalKeysCollection.Count == 0) { this.additionalKeys = emptyInstanceKeyList; } else { this.additionalKeys = additionalKeys as ReadOnlyCollection <InstanceKey>; if (this.additionalKeys == null) { IList <InstanceKey> additionalKeysList = additionalKeys as IList <InstanceKey>; if (additionalKeysList == null) { additionalKeysList = new List <InstanceKey>(additionalKeys); } this.additionalKeys = new ReadOnlyCollection <InstanceKey>(additionalKeysList); } } ICollection <InstanceKey> transientCorrelationsCollection = transientCorrelations as ICollection <InstanceKey>; if (transientCorrelations == null || (transientCorrelationsCollection != null && transientCorrelationsCollection.Count == 0)) { this.transientCorrelations = emptyInstanceKeyList; } else { this.transientCorrelations = transientCorrelations as ReadOnlyCollection <InstanceKey>; if (this.transientCorrelations == null) { IList <InstanceKey> transientCorrelationsList = transientCorrelations as IList <InstanceKey>; if (transientCorrelationsList == null) { transientCorrelationsList = new List <InstanceKey>(transientCorrelations); } this.transientCorrelations = new ReadOnlyCollection <InstanceKey>(transientCorrelationsList); } } }
private void TraceCorrelationKeys(InstanceKey instanceKey, Dictionary <string, string> values) { StringBuilder builder = new StringBuilder(); foreach (KeyValuePair <string, string> pair in values) { StringBuilder introduced3 = builder.Append(pair.Key).Append(":"); introduced3.Append(pair.Value).Append(','); } TD.TraceCorrelationKeys(instanceKey.Value, builder.ToString(), this.parent.scopeName.ToString()); }
public SerializableInstanceKey(InstanceKey instanceKey) { this.value = instanceKey.Value; if (instanceKey.Metadata != null) { this.metadata = new Dictionary <XName, SerializableInstanceValue>(instanceKey.Metadata.Count); foreach (KeyValuePair <XName, InstanceValue> pair in instanceKey.Metadata) { this.metadata.Add(pair.Key, new SerializableInstanceValue(pair.Value)); } } }
public IAsyncResult BeginLoad(InstanceKey key, ICollection <InstanceKey> associatedKeys, Transaction transaction, TimeSpan timeout, AsyncCallback callback, object state) { if (key == null) { throw System.ServiceModel.Activities.FxTrace.Exception.ArgumentNull("key"); } if (key.Value == Guid.Empty) { throw System.ServiceModel.Activities.FxTrace.Exception.Argument("key", System.ServiceModel.Activities.SR.InvalidKey); } return(new LoadOrCreateAsyncResult(this, key, Guid.Empty, false, associatedKeys, transaction, false, timeout, callback, state)); }
public static void Main(string[] args) { Oms oms = new MemoryOms(); oms.InitializeTenants("System/Tenants"); oms.Load("System/Snapshots"); oms.DefaultTenant = oms.GetTenant("archalos1"); TestExisting(oms); oms.BeginTransaction(); InstanceHandle ihInventoryItem = oms.CreateClass(LocalInstanceGuids.Classes.InventoryItem, "InventoryItem", "Inventory Item"); InstanceHandle ihCharacter = oms.CreateClass(LocalInstanceGuids.Classes.Character, "Character", "Character"); InstanceHandle ihGender = oms.CreateClass(LocalInstanceGuids.Classes.Character, "Gender", "Gender"); oms.CommitTransaction(); oms.BeginTransaction(); InstanceHandle ikCharacter__has__Gender = oms.CreateRelationshipInstance(ihCharacter, "has", ihGender, LocalRelationshipGuids.Character__has__Gender); InstanceHandle ihGender1 = oms.CreateInstance(ihGender); oms.CommitTransaction(); oms.BeginTransaction(); InstanceHandle ikCharacter__Ashlyn = oms.CreateInstance(LocalInstanceGuids.Characters.Ashlyn, LocalInstanceGuids.Classes.Character); oms.CreateRelationship(ikCharacter__Ashlyn, ikCharacter__has__Gender, ihGender1); oms.CommitTransaction(); InstanceHandle ihClass = oms.GetInstance(InstanceKey.Parse("1$1")); ihClass = oms.GetInstance(KnownInstanceGuids.Classes.Class); Guid id = Guid.Empty; bool verified = oms.Transactions.Verify(); InstanceHandle ihGndr = oms.GetRelatedInstance(ikCharacter__Ashlyn, ikCharacter__has__Gender); // InstanceKey key = oms.GetInstanceKey(ihGndr); InstanceHandle ihGnd2 = oms.GetRelatedInstance(ikCharacter__Ashlyn, ikCharacter__has__Gender); oms.Save("System/Snapshots"); Console.WriteLine(ikCharacter__Ashlyn.ToString()); }
public CorrelationMessageProperty(InstanceKey correlationKey, IEnumerable <InstanceKey> additionalKeys, IEnumerable <InstanceKey> transientCorrelations) { if (correlationKey == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("correlationKey"); } if (additionalKeys == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("additionalKeys"); } this.correlationKey = correlationKey; ICollection <InstanceKey> is2 = additionalKeys as ICollection <InstanceKey>; if ((is2 != null) && (is2.Count == 0)) { this.additionalKeys = emptyInstanceKeyList; } else { this.additionalKeys = additionalKeys as ReadOnlyCollection <InstanceKey>; if (this.additionalKeys == null) { IList <InstanceKey> list = additionalKeys as IList <InstanceKey>; if (list == null) { list = new List <InstanceKey>(additionalKeys); } this.additionalKeys = new ReadOnlyCollection <InstanceKey>(list); } } ICollection <InstanceKey> is3 = transientCorrelations as ICollection <InstanceKey>; if ((transientCorrelations == null) || ((is3 != null) && (is3.Count == 0))) { this.transientCorrelations = emptyInstanceKeyList; } else { this.transientCorrelations = transientCorrelations as ReadOnlyCollection <InstanceKey>; if (this.transientCorrelations == null) { IList <InstanceKey> list2 = transientCorrelations as IList <InstanceKey>; if (list2 == null) { list2 = new List <InstanceKey>(transientCorrelations); } this.transientCorrelations = new ReadOnlyCollection <InstanceKey>(list2); } } }
internal ReadOnlyCollection <BookmarkInfo> GetBookmarksForInstance(InstanceKey instanceKey) { ReadOnlyCollection <BookmarkInfo> bookmarks = null; lock (this.ThisLock) { PersistenceContext context; if (this.keyMap.TryGetValue(instanceKey.Value, out context)) { bookmarks = context.Bookmarks; } } return(bookmarks); }
public RpcObjectRef <TService>?GetPublishedInstance <TService>(TService serviceInstance) where TService : class { var connectionInfo = this.RetrieveConnectionInfo(); lock (this.syncRoot) { var key = new InstanceKey(serviceInstance); if (this.serviceImplToId.TryGetValue(key, out var objectId)) { return(new RpcObjectRef <TService>(connectionInfo, objectId, this.GetPublishedServices(objectId).ToArray())); } } return(null); }
protected void GetInstanceKeys(OperationContext operationContext, out InstanceKey instanceKey, out ICollection <InstanceKey> additionalKeys) { CorrelationMessageProperty property = null; instanceKey = InstanceKey.InvalidKey; additionalKeys = new ReadOnlyCollection <InstanceKey>(new InstanceKey[0]); if (!CorrelationMessageProperty.TryGet(operationContext.IncomingMessageProperties, out property)) { if (this.keyCalculator != null) { InstanceKey key; ICollection <InstanceKey> is2; MessageBuffer buffer; bool flag; if (operationContext.IncomingMessageProperties.TryGetValue <MessageBuffer>("_RequestMessageBuffer_", out buffer)) { flag = this.keyCalculator.CalculateKeys(buffer, operationContext.IncomingMessage, out key, out is2); } else { flag = this.keyCalculator.CalculateKeys(operationContext.IncomingMessage, out key, out is2); } if (flag) { if (key != null) { instanceKey = key; } if (is2 != null) { additionalKeys = is2; } property = new CorrelationMessageProperty(instanceKey, additionalKeys); operationContext.IncomingMessageProperties.Add(CorrelationMessageProperty.Name, property); } } } else { instanceKey = property.CorrelationKey; additionalKeys = property.AdditionalKeys; } if (((instanceKey == null) || !instanceKey.IsValid) && !this.CanCreateInstance) { this.host.RaiseUnknownMessageReceived(operationContext.IncomingMessage); throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new FaultException(new DurableDispatcherAddressingFault())); } }
public BaseFormParent InstanceOf <T>() where T : BaseFormParent { BaseFormParent result = null; var type = typeof(T); //if typeInstance dict contains form with specific type if (typeInstanceDict.ContainsKey(type)) { //Get Instance Key by Type if (typeInstanceDict.TryGetValue(type, out var instanceKey)) { //Get Frm by InstanceKey if (ActiveForms.ContainsKey(instanceKey)) { result = ActiveForms[instanceKey]; } else { throw new Exception("Форма отсутствует в списке активных форм, хотя тип и ключ формы зарегистрирован"); } } else { throw new Exception("Ключ формы не зарегистрирован"); } } //If typeInstance dict doesn't contains InstanceKey of Form with Specific Type //Create Element in typeInstance dict else { //Instance of Form var form = (T)Activator.CreateInstance(type); var instanceKey = InstanceKey.Generate(form); typeInstanceDict.Add(type, instanceKey); if (ActiveForms.ContainsKey(instanceKey)) { ActiveForms[instanceKey] = form; } else { ActiveForms.Add(instanceKey, form); } result = ActiveForms[instanceKey]; } return(result); }
bool TryGetMessageVersion(InstanceKey instanceKey, out MessageVersion version) { Fx.Assert(instanceKey != null, "Expect a valid instanceKey here"); version = MessageVersion.None; if (instanceKey != null) { InstanceValue messageVersionValue; if (instanceKey.Metadata.TryGetValue(WorkflowServiceNamespace.MessageVersionForReplies, out messageVersionValue)) { version = (MessageVersion)messageVersionValue.Value; return(true); } } return(false); }
public ConstructorInstance ToInstance(IPluginFactory factory, Type pluginType) { var plugin = factory.PluginFor(PluggedType()); var instance = new ConstructorInstance(plugin); if (InstanceKey.IsNotEmpty()) { instance.Name = InstanceKey; } var reader = new InstanceMementoPropertyReader(instance, this, factory); plugin.VisitArguments(reader); return(instance); }
public ControlOperationAsyncResult(ControlOperationInvoker invoker, object[] inputs, IInvokeReceivedNotification notification, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.instanceKey = InstanceKey.InvalidKey; this.additionalKeys = emptyKeyCollection; this.outputs = ControlOperationInvoker.emptyObjectArray; this.invoker = invoker; this.inputs = inputs; this.timeoutHelper = new TimeoutHelper(timeout); this.transaction = Transaction.Current; this.operationContext = OperationContext.Current; base.OnCompleting = onCompleting; bool flag = false; bool flag2 = false; try { if (notification != null) { if (this.operationContext.SessionId == null) { notification.NotifyInvokeReceived(); } else { this.notification = notification; } } if (invoker.BufferedReceiveManager != null) { ReceiveContext.TryGet(this.operationContext.IncomingMessageProperties, out this.receiveContext); } flag = this.Process(); flag2 = true; } finally { if (!flag2) { Finally(this, null); } } if (flag) { base.Complete(true); } }
public Transaction GetTransactionForInstance(InstanceKey instanceKey) { Transaction lockingTransaction = null; lock (this.ThisLock) { PersistenceContext context; if (this.keyMap.TryGetValue(instanceKey.Value, out context)) { lockingTransaction = context.LockingTransaction; if (lockingTransaction != null) { lockingTransaction = lockingTransaction.Clone(); } } } return(lockingTransaction); }
private PersistenceContext LoadFromCache(InstanceKey key, Guid suggestedIdOrId, bool canCreateInstance) { PersistenceContext context = null; if ((key != null) || (suggestedIdOrId != Guid.Empty)) { lock (this.ThisLock) { this.ThrowIfClosedOrAborted(); if (key == null) { this.instanceCache.TryGetValue(suggestedIdOrId, out context); return(context); } this.keyMap.TryGetValue(key.Value, out context); } } return(context); }
internal void InitializeBookmarkScope(NativeActivityContext context, InstanceKey instanceKey) { if (this.Scope == null) { this.bookmarkScopeHandle.CreateBookmarkScope(context, instanceKey.Value); this.Scope = this.bookmarkScopeHandle.BookmarkScope; } else if (this.Scope.IsInitialized) { if (this.Scope.Id != instanceKey.Value) { throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.CorrelationHandleInUse(this.Scope.Id, instanceKey.Value))); } } else { this.Scope.Initialize(context, instanceKey.Value); } }
public RpcObjectRef <TService> GetOrPublishInstance <TService>(TService serviceInstance) where TService : class { if (serviceInstance is null) { throw new ArgumentNullException(nameof(serviceInstance)); } InstanceKey key; lock (this.syncRoot) { key = new InstanceKey(serviceInstance); if (this.serviceImplToId.TryGetValue(key, out var instanceId)) { return(new RpcObjectRef <TService>(this.connectionInfo, instanceId, this.GetPublishedServices(instanceId).ToArray())); } } // Not published, so we try to register the serviceInstance's service definitions // and then publish it. var allServices = RpcBuilderUtil.GetAllServices(serviceInstance.GetType(), true); this.TryRegisterServiceDefinitions(allServices, null); var connectionInfo = this.RetrieveConnectionInfo(); lock (this.syncRoot) { // Let's try again. if (this.serviceImplToId.TryGetValue(key, out var instanceId)) { // Somebody beat us to it. return(new RpcObjectRef <TService>(this.connectionInfo, instanceId, this.GetPublishedServices(instanceId).ToArray())); } var objectId = RpcObjectId.NewId(); var newPublishedServices = this.PublishInstanceCore_Locked(allServices, OwnedObject.CreateUnowned(serviceInstance), objectId, true); return(new RpcObjectRef <TService>(connectionInfo, objectId, newPublishedServices.ToArray())); } }
/// <summary> /// Removes the instance corresponding to the given name from the cache. /// The service itself remains registered and can be used to create other instances. /// </summary> /// <typeparam name="TInterface">The type of the instance to be removed.</typeparam> /// <param name="name">The name corresponding to the instance that must be removed.</param> public void Unregister <TInterface>(string name) where TInterface : class { var serviceType = typeof(TInterface); var key = new InstanceKey(serviceType, name); _factories.Remove(key); if (name == null) { return; } if (!_namedInstances.TryGetValue(serviceType, out List <string> instances)) { return; } instances.Remove(name); if (instances.Count == 0) { _namedInstances.Remove(serviceType); } }
public IOwned <RpcSingletonRef <TService> > PublishSingleton <TService>(IOwned <TService> singletonService) where TService : class { if (singletonService == null) { throw new ArgumentNullException(nameof(singletonService)); } var allServices = RpcBuilderUtil.GetAllServices(typeof(TService), false); this.TryRegisterServiceDefinitions(allServices, null); var publishedServices = this.VerifyPublishedServices(allServices); var connectionInfo = this.RetrieveConnectionInfo(); lock (this.syncRoot) { var instanceKey = new InstanceKey(singletonService.Value); foreach (var serviceType in publishedServices.ServiceTypes) { if (this.singletonServiceTypeToServiceImpl.ContainsKey(serviceType) || this.singletonServiceTypeToFactory.ContainsKey(serviceType)) { throw new RpcDefinitionException($"A singleton for the type '{serviceType}' has already been published."); } } this.singletonTypeToPublishedServices.Add(typeof(TService), publishedServices); var publishedInstance = new PublishedInstance(singletonService); foreach (var serviceType in publishedServices.ServiceTypes) { this.singletonServiceTypeToServiceImpl.Add(serviceType, publishedInstance); } } return(OwnedObject.Create(new RpcSingletonRef <TService>( connectionInfo), () => this.UnpublishSingletonAsync <TService>())); }