public static NotNull ( object? value, string parameterName, string? field = null ) : void | ||
value | object? | |
parameterName | string | |
field | string? | |
return | void |
public async Task <object> InsertAsync(NsDatabase database, string tableName, string json, object id, ObjectIdType typeOfObjectId) { Validate.NotNull(database, nameof(database)); Validate.NotNullOrEmptyOrWhiteSpace(tableName, nameof(tableName)); Validate.NotNull(json, nameof(json)); if (id != null || typeOfObjectId == ObjectIdType.Guid) { await ExecuteNonQueryAsync(new[] { $"INSERT INTO \"{database.Name}\".\"{tableName}\"", $" (\"_id\"", $" ,\"_document\")", $" VALUES", $" (@id", $" ,@document)" }, new Dictionary <string, object>() { { "@id", id ?? Guid.NewGuid() }, { "@document", json } }, executeAsScalar : false); return(id); } return(await ExecuteNonQueryAsync(new[] { $"INSERT INTO \"{database.Name}\".\"{tableName}\"", $" (\"_document\")" + $" VALUES", $" (@document)", $"RETURNING _id" }, new Dictionary <string, object>() { { "@document", json } }, executeAsScalar : true)); }
public bool Add(StackSnapshotsBufferSegment segment) { if (_isReadonly) { return(false); } Validate.NotNull(segment, nameof(segment)); lock (_updateLock) { if (_isReadonly) { return(false); } if (_segments.Count == 0) { _totalTimeRangeStart = segment.TimeRangeStart; _totalTimeRangeEnd = segment.TimeRangeEnd; } else { if (segment.TimeRangeStart < _totalTimeRangeStart) { _totalTimeRangeStart = segment.TimeRangeStart; } if (segment.TimeRangeEnd > _totalTimeRangeEnd) { _totalTimeRangeEnd = segment.TimeRangeEnd; } } _totalByteCount += segment.SegmentByteCount; _totalSnapshotsCount += segment.SnapshotsCount; _segments.Add(segment); return(true); } }
private Task <AvailabilityTestInfo> CreateAvailabilityTestInfo(AvailabilityTestInfoAttribute attribute, ValueBindingContext valueBindingContext) { // A function is an Availability Test iff is has a return value marked with [AvailabilityTestResult]; // whereas a [AvailabilityTestInfo] is OPTIONAL to get test information at runtime. // User could have marked a parameter with [AvailabilityTestInfo] but no return value with [AvailabilityTestResult]: // That does not make sense, but we need to do something graceful. // There is no telling what will run first: this method, or CreateAvailabilityTelemetryAsyncCollector(..) above. // From here we cannot call _availabilityTestRegistry.Functions.Register(..), becasue the attribute type we get // here does not contain any configuration. // We will attach a raw test info object to this invocation. // If a test-RESULT-attribute is attached to this function later, it will supply configuration eventually. // If not, the test info will remain raw and we must remember to clear the invocation from the registry in the post-function filter. Validate.NotNull(attribute, nameof(attribute)); Validate.NotNull(valueBindingContext, nameof(valueBindingContext)); string functionName = valueBindingContext.FunctionContext.MethodName; using (_log.BeginScope(LogMonikers.Scopes.CreateForTestInvocation(functionName))) { // Register this particular invocation of this function: Guid functionInstanceId = valueBindingContext.FunctionInstanceId; AvailabilityTestInvocationState invocationState = _availabilityTestRegistry.Invocations.GetOrRegister(functionInstanceId, _log); // Create the test info: var testInfo = new AvailabilityTestInfo(); // If the test scope is already set (out-of-proc function), then use it to initialize the test info: bool isTestScopeInitialized = invocationState.TryGetTestScope(out AvailabilityTestScope testScope); if (isTestScopeInitialized) { testInfo.CopyFrom(testScope.CreateAvailabilityTestInfo()); } // Attach the test info to the invocation state bag: invocationState.AttachTestInfo(testInfo); // Done: return(Task.FromResult(testInfo)); } }
public static async Task <ResourceGroup> Load(this ResourceGroup resourceGroup, CsmWrapper <CsmResourceGroup> csmResourceGroup = null, IEnumerable <CsmWrapper <object> > resources = null, bool loadSubResources = true) { Validate.ValidateCsmResourceGroup(resourceGroup); if (csmResourceGroup == null) { var csmResourceGroupResponse = await csmClient.HttpInvoke(HttpMethod.Get, ArmUriTemplates.ResourceGroup.Bind(resourceGroup)); await csmResourceGroupResponse.EnsureSuccessStatusCodeWithFullError(); csmResourceGroup = await csmResourceGroupResponse.Content.ReadAsAsync <CsmWrapper <CsmResourceGroup> >(); } //Not sure what to do at this point TODO Validate.NotNull(csmResourceGroup.tags, "csmResorucegroup.tags"); resourceGroup.Tags = csmResourceGroup.tags; if (resources == null) { var csmResourceGroupResourcesResponse = await csmClient.HttpInvoke(HttpMethod.Get, ArmUriTemplates.ResourceGroupResources.Bind(resourceGroup)); await csmResourceGroupResourcesResponse.EnsureSuccessStatusCodeWithFullError(); resources = (await csmResourceGroupResourcesResponse.Content.ReadAsAsync <CsmArrayWrapper <object> >()).value; } if (loadSubResources) { await Task.WhenAll(LoadSites(resourceGroup, resources.Where(r => r.type.Equals("Microsoft.Web/sites", StringComparison.OrdinalIgnoreCase))), LoadApiApps(resourceGroup, resources.Where(r => r.type.Equals("Microsoft.AppService/apiapps", StringComparison.OrdinalIgnoreCase))), LoadGateways(resourceGroup, resources.Where(r => r.type.Equals("Microsoft.AppService/gateways", StringComparison.OrdinalIgnoreCase))), LoadLogicApps(resourceGroup, resources.Where(r => r.type.Equals("Microsoft.Logic/workflows", StringComparison.OrdinalIgnoreCase))), LoadServerFarms(resourceGroup, resources.Where(r => r.type.Equals("Microsoft.Web/serverFarms", StringComparison.OrdinalIgnoreCase))), LoadStorageAccounts(resourceGroup, resources.Where(r => r.type.Equals("Microsoft.Storage/storageAccounts", StringComparison.OrdinalIgnoreCase)))); } return(resourceGroup); }
public static IEnumerable <CodeInstruction> Transpiler(MethodBase original, IEnumerable <CodeInstruction> instructions) { Validate.NotNull(INJECTION_OPERAND); List <CodeInstruction> instructionList = instructions.ToList(); bool shouldInject = false; /** * When placing some modules in multiplayer it throws an exception because it tries to validate * that the current player is in the subroot. We want to skip over this code if we are placing * a multiplayer piece: * * if (main == null || main.currentSub == null || !main.currentSub.isBase) * * Injected code: * * if (!MultiplayerBuilder.isPlacing && (main == null || main.currentSub == null || !main.currentSub.isBase)) * */ for (int i = 0; i < instructionList.Count; i++) { CodeInstruction instruction = instructionList[i]; yield return(instruction); if (shouldInject) { shouldInject = false; // First fetch the place we want to jump... this will be the same place as !main.currentSub.isBase CodeInstruction jumpInstruction = GetJumpInstruction(instructionList, i); yield return(new CodeInstruction(OpCodes.Call, typeof(MultiplayerBuilder).GetMethod("get_isPlacing", BindingFlags.Public | BindingFlags.Static))); yield return(new CodeInstruction(OpCodes.Brtrue_S, jumpInstruction.operand)); // copy the jump location } // We want to inject just after Player main = Player.main... if this is that instruction then we'll inject after the next opcode (stfld) shouldInject = (instruction.opcode.Equals(INJECTION_OPCODE) && instruction.operand.Equals(INJECTION_OPERAND)); } }
private static void SetupListening() { ConsoleWrite.LineLine("Starting setting up DiagnosticSource listening."); if (!DiagnosticSourceSafeExtensions.SubscribeToAllSourcesSafe(ObserverAdapter.OnNextHandler( (DiagnosticListenerStub diagnosticListener) => { diagnosticListener.GetNameSafe(out string diagnosticListenerName, out _); ConsoleWrite.Line($"Subscriber called: diagnosticSourceObserver(diagnosticListener.Name: \"{diagnosticListenerName}\")"); if (diagnosticListenerName.Equals("DemoXxx.UseDiagnosticSource.Name1", StringComparison.Ordinal)) { if (!diagnosticListener.SubscribeToEventsSafe( ObserverAdapter.OnNextHandler((KeyValuePair <string, object> eventInfo) => { ConsoleWrite.Line($"Event Handler called: eventObserver(eventName: \"{eventInfo.Key}\", payloadValue: {(eventInfo.Value ?? "<null>")})"); }), (string eventName, object arg1, object arg2) => { Validate.NotNull(eventName, nameof(eventName)); bool res = eventName.StartsWith("EventXyzName", StringComparison.OrdinalIgnoreCase) && (arg1 == null || !(arg1 is Int32 arg1Val) || arg1Val >= 0); ConsoleWrite.Line($"Filter called: isEventEnabledFilter(eventName: \"{eventName}\", arg1: {(arg1 ?? "<null>")}, arg2: {(arg2 ?? "<null>")})." + $" Returning: {res}."); return(res); }, out IDisposable eventSubscription, out _)) { ConsoleWrite.LineLine("Could not set up an events subscription. Likely no events will be received. Error has been logged."); } } }), out IDisposable listenerSubscription, out _)) { ConsoleWrite.LineLine("Could not set up an all-sources-subscription. Likely no events will be received. Error has been logged."); } ConsoleWrite.Line("Finished setting up DiagnosticSource listening."); }
/// <summary>Remove a list of allowed attributes from a tag.</summary> /// <remarks> /// Remove a list of allowed attributes from a tag. (If an attribute is not allowed on an element, it will be removed.) /// <para /> /// E.g.: <code>removeAttributes("a", "href", "class")</code> disallows <code>href</code> and <code>class</code> /// attributes on <code>a</code> tags. /// <para /> /// To make an attribute invalid for <b>all tags</b>, use the pseudo tag <code>:all</code>, e.g. /// <code>removeAttributes(":all", "class")</code>. /// </remarks> /// <param name="tag">The tag the attributes are for.</param> /// <param name="keys">List of invalid attributes for the tag</param> /// <returns>this (for chaining)</returns> public virtual iText.StyledXmlParser.Jsoup.Safety.Whitelist RemoveAttributes(String tag, params String[] keys ) { Validate.NotEmpty(tag); Validate.NotNull(keys); Validate.IsTrue(keys.Length > 0, "No attributes supplied."); Whitelist.TagName tagName = Whitelist.TagName.ValueOf(tag); ICollection <Whitelist.AttributeKey> attributeSet = new HashSet <Whitelist.AttributeKey>(); foreach (String key in keys) { Validate.NotEmpty(key); attributeSet.Add(Whitelist.AttributeKey.ValueOf(key)); } if (tagNames.Contains(tagName) && attributes.ContainsKey(tagName)) { // Only look in sub-maps if tag was allowed ICollection <Whitelist.AttributeKey> currentSet = attributes.Get(tagName); currentSet.RemoveAll(attributeSet); if (currentSet.IsEmpty()) { // Remove tag from attribute map if no attributes are allowed for tag attributes.JRemove(tagName); } } if (tag.Equals(":all")) { // Attribute needs to be removed from all individually set tags foreach (Whitelist.TagName name in attributes.Keys) { ICollection <Whitelist.AttributeKey> currentSet = attributes.Get(name); currentSet.RemoveAll(attributeSet); if (currentSet.IsEmpty()) { // Remove tag from attribute map if no attributes are allowed for tag attributes.JRemove(name); } } } return(this); }
public int Add(IncomeParam param) { int id = 0; Validate.NotNull(param.IncomeName, "Income name is required."); var budget = _budgetRepository.Get(param.BudgetId); Validate.NotNull(budget, "Budget name is not found."); isExist(param.IncomeName, param.IncomeDate); using (_unitOfWork) { Income model = new Income(param.IncomeName, param.Definition, param.IncomeDate, param.Amount, budget, param.CreatedBy, param.CreatedDate); _incomeRepository.Insert(model); _unitOfWork.Commit(); id = model.Id; } return(id); }
private ProfilerEngine(IProductConfiguration config) { Validate.NotNull(config, nameof(config)); _versionInfo = ProfilerEngineVersionInfo.CreateNewInstance(); _profiledThreadInfoProvider = new ProfiledThreadInfoProvider(); _profiledAppDomainProvider = new ProfiledAppDomainProvider(); _enqueueStackSnapshotBufferSegmentForExport = NativeCallback_EnqueueStackSnapshotBufferSegmentForExport; _tryShutdownCurrentManagedProfilerEngine = NativeCallback_TryShutdownCurrentManagedProfilerEngine; _completedStackSnapshots = new StackSnapshotsBufferSegmentCollection(); _pprofBuilder = new PProfBuilder(); RegisterReversePInvokeCallbacks(); _resolveAndExportStacksBackgroundLoop = new ResolveAndExportStacksBackgroundLoop(this, config); _resolveAndExportStacksBackgroundLoop.Start(); }
public static IEnumerable <CodeInstruction> Transpiler(MethodBase original, IEnumerable <CodeInstruction> instructions) { Validate.NotNull(INJECTION_OPERAND); foreach (CodeInstruction instruction in instructions) { yield return(instruction); if (instruction.opcode.Equals(INJECTION_OPCODE) && instruction.operand.Equals(INJECTION_OPERAND)) { /* * ArmsController.Reconfigure(null); */ yield return(new ValidatedCodeInstruction(OpCodes.Ldarg_0)); yield return(new ValidatedCodeInstruction(OpCodes.Ldnull)); yield return(new ValidatedCodeInstruction(OpCodes.Call, TARGET_CLASS.GetMethod("Reconfigure", BindingFlags.NonPublic | BindingFlags.Instance))); } } }
public void CreateVehicle(TechType techType, NitroxId id, Vector3 position, Quaternion rotation, IEnumerable <InteractiveChildObjectIdentifier> interactiveChildIdentifiers, Optional <NitroxId> dockingBayId, string name, Vector3[] hsb, Vector3[] colours, float health) { try { if (techType == TechType.Cyclops) { LightmappedPrefabs.main.RequestScenePrefab("cyclops", (go) => OnVehiclePrefabLoaded(techType, go, id, position, rotation, interactiveChildIdentifiers, dockingBayId, name, hsb, colours, health)); } else { GameObject techPrefab = CraftData.GetPrefabForTechType(techType, false); Validate.NotNull(techPrefab, $"{nameof(Vehicles)}: No prefab for tech type: {techType}"); OnVehiclePrefabLoaded(techType, techPrefab, id, position, rotation, interactiveChildIdentifiers, dockingBayId, name, hsb, colours, health); } } catch (Exception ex) { Log.Error($"{nameof(Vehicles)}: Error while creating a vehicle {techType} {id}", ex); } }
/// <summary> /// Gets the named property value of type <typeparamref name="T"/>. /// </summary> /// <typeparam name="T">The type of the property value to get.</typeparam> /// <param name="object">The <see cref="PSObject"/> that may contain the named property.</param> /// <param name="propertyName">The name of the property to get.</param> /// <param name="default"> /// Optional default value to return if the property is not defined. /// The default parameter value is the default value of type <typeparamref name="T"/>. /// </param> /// <returns>The value of the named property if defined; otherwise, the <paramref name="default"/> value.</returns> /// <exception cref="ArgumentException"><paramref name="propertyName"/> is an empty string.</exception> /// <exception cref="ArgumentNullException"><paramref name="object"/> or <paramref name="propertyName"/> is null.</exception> public static T GetPropertyValue <T>(this PSObject @object, string propertyName, T @default = default(T)) { Validate.NotNull(@object, nameof(@object)); Validate.NotNullOrEmpty(propertyName, nameof(propertyName)); var property = @object.Properties.Match(propertyName, PSMemberTypes.Properties).FirstOrDefault(); if (property != null) { if (property.Value is T) { return((T)property.Value); } else { return((T)LanguagePrimitives.ConvertTo(property.Value, typeof(T))); } } return(@default); }
private static void SpawnBabiesIfSimulating(IncubatorEgg egg) { SimulationOwnership simulationOwnership = NitroxServiceLocator.LocateService <SimulationOwnership>(); NitroxEntity serverKnownParent = egg.GetComponentInParent <NitroxEntity>(); Validate.NotNull(serverKnownParent, "Could not find a server known parent for incubator egg"); // Only spawn the babies if we are simulating the main incubator platform. if (simulationOwnership.HasAnyLockType(serverKnownParent.Id)) { GameObject baby = UnityEngine.Object.Instantiate <GameObject>(egg.seaEmperorBabyPrefab); baby.transform.position = egg.attachPoint.transform.position; baby.transform.localRotation = Quaternion.identity; NitroxId babyId = NitroxEntity.GetId(baby); Entity entity = new(baby.transform.position.ToDto(), baby.transform.rotation.ToDto(), baby.transform.localScale.ToDto(), TechType.SeaEmperorBaby.ToDto(), 3, "09883a6c-9e78-4bbf-9561-9fa6e49ce766", true, babyId, null); NitroxServiceLocator.LocateService <Entities>().BroadcastEntitySpawnedByClient(entity); } }
/// <summary> /// Initializes a new instance of the <see cref="LinguisticVariable"/> class. /// </summary> /// <param name="label"> /// The label. /// </param> /// <param name="inputSets"> /// The input sets. /// </param> /// <param name="lowerBound"> /// The lower bound for the <see cref="LinguisticVariable"/>. /// </param> /// <param name="upperBound"> /// The upper bound for the <see cref="LinguisticVariable"/>. /// </param> public LinguisticVariable( string label, IList <FuzzySet> inputSets, double lowerBound = double.MinValue, double upperBound = double.MaxValue) { Validate.NotNull(label, nameof(label)); Validate.CollectionNotNullOrEmpty(inputSets, nameof(inputSets)); Validate.NotOutOfRange(lowerBound, nameof(lowerBound)); Validate.NotOutOfRange(upperBound, nameof(upperBound)); Validate.FuzzySetCollection(inputSets, lowerBound, upperBound); this.Subject = Label.Create(label); this.LowerBound = lowerBound; this.UpperBound = upperBound; foreach (var set in inputSets) { this.fuzzySets.Add(set.State, set); } }
public MultipartFormPostRequest(HttpClient httpPoster, string url, MemoryStream reuseableContent, Action <MemoryStream> releaseReuseableContent) { Validate.NotNull(httpPoster, nameof(httpPoster)); Validate.NotNull(releaseReuseableContent, nameof(releaseReuseableContent)); _httpPoster = httpPoster; _url = url; _releaseContentBufferStreamForReuseDelegate = releaseReuseableContent; if (reuseableContent != null) { reuseableContent.Position = 0; _content = reuseableContent; } else if (reuseableContent == null) { _content = new MemoryStream(); } InitHttpPosterAgnosticData(); }
public static IEnumerable <CodeInstruction> Transpiler(MethodBase original, IEnumerable <CodeInstruction> instructions) { Validate.NotNull(INJECTION_OPERAND); foreach (CodeInstruction instruction in instructions) { yield return(instruction); if (instruction.opcode.Equals(INJECTION_OPCODE) && instruction.operand.Equals(INJECTION_OPERAND)) { /* * TransientLocalObjectManager.Add(TransientLocalObjectManager.TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT, gameObject); */ yield return(new CodeInstruction(OpCodes.Ldc_I4_0)); yield return(original.Ldloc <GameObject>(0)); yield return(new CodeInstruction(OpCodes.Call, Reflect.Method(() => Add(default(TransientObjectType), default(object))))); } } }
public static IEnumerable <CodeInstruction> Transpiler(MethodBase original, IEnumerable <CodeInstruction> instructions) { Validate.NotNull(INJECTION_OPERAND); foreach (CodeInstruction instruction in instructions) { yield return(instruction); if (instruction.opcode.Equals(INJECTION_OPCODE) && instruction.operand.Equals(INJECTION_OPERAND)) { /* * TransientLocalObjectManager.Add(TransientLocalObjectManager.TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT, gameObject); */ yield return(new ValidatedCodeInstruction(OpCodes.Ldc_I4_0)); yield return(original.Ldloc <GameObject>(0)); yield return(new ValidatedCodeInstruction(OpCodes.Call, typeof(TransientLocalObjectManager).GetMethod("Add", BindingFlags.Static | BindingFlags.Public, null, new Type[] { TransientObjectType.CONSTRUCTOR_INPUT_CRAFTED_GAMEOBJECT.GetType(), typeof(object) }, null))); } } }
/// <summary> /// Determines if the results of the <paramref name="selector"/> applied to the <paramref name="source"/> enumerable /// contain all the elements from the <paramref name="keys"/>. /// </summary> /// <typeparam name="T">The type of the source enumerable.</typeparam> /// <typeparam name="TKey">The type of the keys.</typeparam> /// <param name="source">The source enumerable to check.</param> /// <param name="selector">The selector to apply to the <paramref name="source"/> enumerable.</param> /// <param name="keys">The keys to check if all are in the <paramref name="source"/> enumerable.</param> /// <param name="comparer">The comparer to use. The default is <see cref="EqualityComparer{T}.Default"/>.</param> /// <returns> /// True if the results of the <paramref name="selector"/> applied to the <paramref name="source"/> enumerable /// contain all the elements from the <paramref name="keys"/>. /// </returns> /// <exception cref="ArgumentNullException">One or more parameters are null.</exception> public static bool ContainsAll <T, TKey>(this IEnumerable <T> source, Func <T, TKey> selector, IEnumerable <TKey> keys, IEqualityComparer <TKey> comparer = null) { Validate.NotNull(source, nameof(source)); Validate.NotNull(selector, nameof(selector)); Validate.NotNull(keys, nameof(keys)); comparer = comparer ?? EqualityComparer <TKey> .Default; var e = source.Select(selector); var items = new HashSet <TKey>(e, comparer); foreach (var key in keys) { if (!items.Contains(key)) { return(false); } } return(true); }
public Player PlayerConnected(NitroxConnection connection, string reservationKey, out bool wasBrandNewPlayer) { PlayerContext playerContext = reservations[reservationKey]; Validate.NotNull(playerContext); ConnectionAssets assetPackage = assetsByConnection[connection]; Validate.NotNull(assetPackage); wasBrandNewPlayer = playerContext.WasBrandNewPlayer; Player player; if (!allPlayersByName.TryGetValue(playerContext.PlayerName, out player)) { player = new Player(playerContext.PlayerId, playerContext.PlayerName, false, playerContext, connection, NitroxVector3.Zero, new NitroxId(), Optional.Empty, Perms.PLAYER, defaultPlayerStats, new List <EquippedItemData>(), new List <EquippedItemData>()); allPlayersByName[playerContext.PlayerName] = player; } // TODO: make a ConnectedPlayer wrapper so this is not stateful player.PlayerContext = playerContext; player.connection = connection; assetPackage.Player = player; assetPackage.ReservationKey = null; reservations.Remove(reservationKey); return(player); }
public static IEnumerable <CodeInstruction> Transpiler(MethodBase original, IEnumerable <CodeInstruction> instructions) { Validate.NotNull(INJECTION_OPCODE); Validate.NotNull(INJECTION_OPERAND); foreach (CodeInstruction instruction in instructions) { yield return(instruction); if (instruction.opcode.Equals(INJECTION_OPCODE) && instruction.operand.Equals(INJECTION_OPERAND)) { /* * Multiplayer.PacketSender.BuildItem(Enum.GetName(typeof(TechType), CraftData.GetTechType(Builder.prefab)), Builder.ghostModel.transform.position, Builder.placeRotation); */ yield return(new ValidatedCodeInstruction(OpCodes.Ldsfld, typeof(Multiplayer).GetField("PacketSender", BindingFlags.Static | BindingFlags.Public))); yield return(new ValidatedCodeInstruction(OpCodes.Ldtoken, typeof(TechType))); yield return(new ValidatedCodeInstruction(OpCodes.Call, typeof(System.Type).GetMethod("GetTypeFromHandle", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(RuntimeTypeHandle) }, null))); yield return(new ValidatedCodeInstruction(OpCodes.Ldsfld, typeof(Builder).GetField("prefab", BindingFlags.Static | BindingFlags.NonPublic))); yield return(new ValidatedCodeInstruction(OpCodes.Call, typeof(CraftData).GetMethod("GetTechType", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(GameObject) }, null))); yield return(new ValidatedCodeInstruction(OpCodes.Box, typeof(TechType))); yield return(new ValidatedCodeInstruction(OpCodes.Call, typeof(System.Enum).GetMethod("GetName"))); yield return(new ValidatedCodeInstruction(OpCodes.Ldsfld, typeof(Builder).GetField("ghostModel", BindingFlags.Static | BindingFlags.NonPublic))); yield return(new ValidatedCodeInstruction(OpCodes.Callvirt, typeof(GameObject).GetMethod("get_transform"))); yield return(new ValidatedCodeInstruction(OpCodes.Callvirt, typeof(Transform).GetMethod("get_position"))); yield return(new ValidatedCodeInstruction(OpCodes.Ldsfld, typeof(Builder).GetField("placeRotation", BindingFlags.Static | BindingFlags.NonPublic))); yield return(new ValidatedCodeInstruction(OpCodes.Callvirt, typeof(PacketSender).GetMethod("BuildItem"))); } } }
/// <summary> /// In addition to forwarding all calls from the underlying Diagnostic Listener to the specified <c>eventObserver</c>, /// the <c>eventObserver</c>'s <c>OnCompleted()</c> handler will be called if the DiagnosticSource-assembly is unloaded /// or dynamically swapped for another version. This allows subscribers to know that no more events are coming. /// To handle such case, it is recommended to give up on the existing subscription and to schedule a from-scratch /// re-subscription on a timer after a short time period. Such delay ensures that the new assembly version is loaded by then. /// Notably, a few events will be lost. This is an explicit design decision in the context of the fact that assembly /// unloads are extremely rare. /// If the IDisposable returned by this method is disposed, then the above-described notification will not be delivered. /// </summary> /// <remarks> /// Consider using <c>Datadog.Util.ObserverAdapter</c> in shared sources to conveniently create observers suitable for this API. /// </remarks> public IDisposable SubscribeToEvents(IObserver <KeyValuePair <string, object> > eventObserver, Func <string, object, object, bool> isEventEnabledFilter) { if (_diagnosticListenerInstance == null) { return(NoOpSingeltons.EventSubscription); } Validate.NotNull(eventObserver, nameof(eventObserver)); // isEventEnabledFilter may be null DynamicInvoker_DiagnosticListener invoker = null; try { invoker = _dynamicInvokerHandle.GetInvoker(); IDisposable eventsSubscription = invoker.Call.Subscribe(_diagnosticListenerInstance, eventObserver, isEventEnabledFilter); Action <DiagnosticSourceAssembly.IDynamicInvoker> invokerInvalidatedAction = (invkr) => { // DiagnosticListener does NOT call OnCompleted when the subscription is disposed. So we DO need to call it here: eventObserver.OnCompleted(); eventsSubscription.Dispose(); }; DynamicInvokerHandle <DynamicInvoker_DiagnosticListener> invokerHandle = _dynamicInvokerHandle; IDisposable invokerInvalidatedActionSub = invokerHandle.SubscribeInvalidatedListener(invokerInvalidatedAction); IDisposable eventsSubscriptionWrapper = new Disposables.Action(() => { invokerInvalidatedActionSub.Dispose(); eventsSubscription.Dispose(); }); return(eventsSubscriptionWrapper); } catch (Exception ex) { throw LogAndRethrowStubInvocationError(ex, nameof(DynamicInvoker_DiagnosticListener.StubbedApis.Subscribe), isStaticApi: false, invoker?.TargetType); } }
public RemotePlayer Create(PlayerContext playerContext, Optional <NitroxId> subRootId, List <TechType> equippedTechTypes, List <Pickupable> inventoryItems) { Validate.NotNull(playerContext); if (playersById.ContainsKey(playerContext.PlayerId)) { throw new Exception("The playerId has already been used."); } GameObject remotePlayerBody = CloneLocalPlayerBodyPrototype(); RemotePlayer remotePlayer; using (packetSender.Suppress <ItemContainerAdd>()) { remotePlayer = new RemotePlayer(remotePlayerBody, playerContext, equippedTechTypes, inventoryItems, playerModelManager); } if (subRootId.HasValue) { Optional <GameObject> sub = NitroxEntity.GetObjectFrom(subRootId.Value); if (sub.HasValue && sub.Value.TryGetComponent(out SubRoot subRoot)) { Log.Debug($"Found sub root for {playerContext.PlayerName}. Will add him and update animation."); remotePlayer.SetSubRoot(subRoot); } else if (sub.HasValue && sub.Value.TryGetComponent(out EscapePod escapePod)) { Log.Debug($"Found EscapePod for {playerContext.PlayerName}."); remotePlayer.SetEscapePod(escapePod); } else { Log.Error($"Found neither SubRoot component nor EscapePod on {subRootId.Value} for {playerContext.PlayerName}."); } } playersById.Add(remotePlayer.PlayerId, remotePlayer); return(remotePlayer); }
/// <summary>Execute a query agains a database.</summary> /// <param name="database">The name of the database.</param> /// <param name="query">The query to execute. For language specification please see /// <a href="https://influxdb.com/docs/v0.9/concepts/reading_and_writing_data.html">InfluxDb documentation</a>.</param> /// <returns>A list of Series which matched the query.</returns> /// <exception cref="InfluxDbApiException"></exception> public async Task <List <Serie> > QueryAsync(string database, string query) { InfluxDbApiResponse response = await _influxDbClient.Query(NoErrorHandlers, database, query); var queryResult = response.ReadAs <QueryResult>(); Validate.NotNull(queryResult, "queryResult"); Validate.NotNull(queryResult.Results, "queryResult.Results"); // Apparently a 200 OK can return an error in the results // https://github.com/influxdb/influxdb/pull/1813 var error = queryResult.Results.Single().Error; if (error != null) { throw new InfluxDbApiException(System.Net.HttpStatusCode.BadRequest, error); } var result = queryResult.Results.Single().Series; return(result != null?result.ToList() : new List <Serie>()); }
/// <summary> /// Returns an <c>XContainer</c> containing the same elements and attributes as the specified <c>XContainer</c> but with all namespaces removed. /// </summary> /// <param name="xContainer">An <c>XElement</c> or <c>XDocument</c> containing the namespaces to be removed.</param> /// <returns>An instance of the same type as <see cref="xContainer"/>.</returns> public static T RemoveAllNamespaces <T>(this T xContainer) where T : XContainer { Validate.NotNull(xContainer, nameof(xContainer)); XElement RemoveAllNamespacesRecursive(XElement xmlDocument) { object value = null; if (xmlDocument.HasElements) { value = xmlDocument.Elements().Select(RemoveAllNamespacesRecursive); } else if (!String.IsNullOrWhiteSpace(xmlDocument.Value)) { value = xmlDocument.Value; } return(new XElement(xmlDocument.Name.LocalName, xmlDocument.Attributes().Where(attr => !attr.IsNamespaceDeclaration), value)); } var container = xContainer as XDocument; if (container != null) { return(new XDocument(container.Declaration, RemoveAllNamespacesRecursive(container.Root)) as T); } var element = xContainer as XElement; if (element != null) { return(RemoveAllNamespacesRecursive(element) as T); } throw new ArgumentException($"Unhandled implementation of XContainer: {xContainer.GetType().Name}", nameof(xContainer)); }
public static bool TryCreateAndStart(IProductConfiguration config, out ProfilerEngine runningProfilerEngine) { Validate.NotNull(config, nameof(config)); runningProfilerEngine = _currentEngine; if (runningProfilerEngine != null) { return(false); } lock (_singletonAccessLock) { runningProfilerEngine = _currentEngine; if (runningProfilerEngine != null) { return(false); } CreateAndStart(config, out runningProfilerEngine); return(runningProfilerEngine != null); } }
public bool TryGetInvokerHandleForInstance(object diagnosticSourceInstance, out DynamicInvokerHandle <DynamicInvoker_DiagnosticSource> handle) { Validate.NotNull(diagnosticSourceInstance, nameof(diagnosticSourceInstance)); Type actualType = diagnosticSourceInstance.GetType(); if (_diagnosticSourceType == actualType || _diagnosticSourceType.Equals(actualType)) { handle = _handle; return(true); } // Is IsSubclassOf(..) too restrictive? Consider using 'if (_diagnosticSourceType.IsAssignableFrom(actualType)) {..}' instead. if (actualType.IsSubclassOf(_diagnosticSourceType)) { handle = _handle; return(true); } handle = null; return(false); }
public Player CreatePlayer(Connection connection, string reservationKey, out bool wasBrandNewPlayer) { lock (assetsByConnection) { ConnectionAssets assetPackage = assetsByConnection[connection]; PlayerContext playerContext = reservations[reservationKey]; Validate.NotNull(playerContext); wasBrandNewPlayer = playerContext.WasBrandNewPlayer; // Load previously persisted data for this player. Vector3 position = playerData.GetPosition(playerContext.PlayerName); Optional <string> subRootGuid = playerData.GetSubRootGuid(playerContext.PlayerName); Player player = new Player(playerContext, connection, position, subRootGuid); assetPackage.Player = player; assetPackage.ReservationKey = null; reservations.Remove(reservationKey); return(player); } }
public IDisposable SubscribeListener(TAction action, object state) { Validate.NotNull(action, nameof(action)); var subscription = new Subscription(action, state, this); AddSubscriptionToList(subscription); try { if (GetMustImmediatelyInvokeNewSubscription(subscription, out TSource source)) { InvokeOne(subscription, source); } } catch (Exception ex) { Log.Error(_logComponentMoniker, ex); } return(subscription); }
public void Create(PlayerContext playerContext) { Validate.NotNull(playerContext); if (playersById.ContainsKey(playerContext.PlayerId)) { throw new Exception("The playerId has already been used."); } GameObject remotePlayerBody = CloneLocalPlayerBodyPrototype(); RemotePlayer player = new RemotePlayer(remotePlayerBody, playerContext); PlayerModelDirector playerModelDirector = new PlayerModelDirector(player); playerModelDirector .AddPing() .AddDiveSuit(); playerModelDirector.Construct(); playersById.Add(player.PlayerId, player); }
public async Task GenerateRandomizedDataForGenericBank(GenerateDataDTO dto) { var bankAccount = await _bankAccountRepository.GetById(dto.BankAccountId); Validate.NotNull(bankAccount); Validate.IsTrue(bankAccount.Code == BankCode.GENERICBANK.Value, "Access Denied"); Validate.IsTrue(bankAccount.UserId == dto.UserId, "Access Denied"); var fakeTransactions = new Faker <Transaction>() .RuleFor(t => t.BankAccountId, dto.BankAccountId) .RuleFor(t => t.Date, f => new DateTime(dto.Year, dto.Month, f.Random.Int(1, 27))) .RuleFor(t => t.Category, f => f.PickRandom <Category>()) .RuleFor(t => t.Amount, f => f.Finance.Amount()) .RuleFor(t => t.Origin, f => f.Company.CompanyName()) .RuleFor(t => t.Metadata, f => $"GenericBank_{Guid.NewGuid()}") .Generate(dto.Quantity); _transactionRepository.InsertRange(fakeTransactions); Validate.IsTrue(await _uow.CommitAsync(), "Ocorreu um problema na criação das transações"); }