public override void Validate(T item) { ArgumentNullException.ThrowIfNull(item); }
public GotoExpressionProxy(GotoExpression node) { ArgumentNullException.ThrowIfNull(node); _node = node; }
public InvocationExpressionProxy(InvocationExpression node) { ArgumentNullException.ThrowIfNull(node); _node = node; }
public override int GetHashCode(string obj) { ArgumentNullException.ThrowIfNull(obj); return(_compareInfo.GetHashCode(obj, _options)); }
/// <summary> /// Updates the localized gamestrings to the selected <see cref="Localization"/>. /// </summary> /// <param name="boost">The data to be updated.</param> /// <param name="gameStringDocument">Instance of a <see cref="GameStringDocument"/>.</param> /// <exception cref="ArgumentNullException"><paramref name="gameStringDocument"/> is null.</exception> public static void UpdateGameStrings(this Boost boost, GameStringDocument gameStringDocument) { ArgumentNullException.ThrowIfNull(gameStringDocument, nameof(gameStringDocument)); gameStringDocument.UpdateGameStrings(boost); }
/// <inheritdoc/> static void IEndpointMetadataProvider.PopulateMetadata(EndpointMetadataContext context) { ArgumentNullException.ThrowIfNull(context); context.EndpointMetadata.Add(new ProducesResponseTypeMetadata(typeof(TValue), StatusCodes.Status202Accepted, "application/json")); }
private Dictionary <LazyMemberInfo, MemberInfo[]> BuildMembersTable(List <LazyMemberInfo> members) { ArgumentNullException.ThrowIfNull(members); Dictionary <LazyMemberInfo, MemberInfo[]> membersTable = new Dictionary <LazyMemberInfo, MemberInfo[]>(); Dictionary <int, MemberInfo> specializedPartMembers = new Dictionary <int, MemberInfo>(); Type closedGenericPartType = GetPartType(); specializedPartMembers[closedGenericPartType.MetadataToken] = closedGenericPartType; foreach (MethodInfo method in closedGenericPartType.GetAllMethods()) { specializedPartMembers[method.MetadataToken] = method; } foreach (FieldInfo field in closedGenericPartType.GetAllFields()) { specializedPartMembers[field.MetadataToken] = field; } foreach (var iface in closedGenericPartType.GetInterfaces()) { specializedPartMembers[iface.MetadataToken] = iface; } foreach (var type in closedGenericPartType.GetNestedTypes()) { specializedPartMembers[type.MetadataToken] = type; } //Walk the base class list var baseType = closedGenericPartType.BaseType; while (baseType != null && baseType != typeof(object)) { specializedPartMembers[baseType.MetadataToken] = baseType; baseType = baseType.BaseType; } // // Now go through the members table and resolve them into the new closed type based on the tokens // foreach (LazyMemberInfo lazyMemberInfo in members) { MemberInfo[] genericAccessors = lazyMemberInfo.GetAccessors(); MemberInfo[] accessors = new MemberInfo[genericAccessors.Length]; for (int i = 0; i < genericAccessors.Length; i++) { if (genericAccessors[i] != null) { specializedPartMembers.TryGetValue(genericAccessors[i].MetadataToken, out accessors[i] !); if (accessors[i] == null) { throw new Exception(SR.Diagnostic_InternalExceptionMessage); } } } membersTable[lazyMemberInfo] = accessors; } return(membersTable); }
/// <summary> /// Updates the localized gamestrings to the selected <see cref="Localization"/>. /// </summary> /// <param name="spray">The data to be updated.</param> /// <param name="gameStringDocument">Instance of a <see cref="GameStringDocument"/>.</param> /// <exception cref="ArgumentNullException"><paramref name="gameStringDocument"/> is null.</exception> public static void UpdateGameStrings(this Spray spray, GameStringDocument gameStringDocument) { ArgumentNullException.ThrowIfNull(gameStringDocument, nameof(gameStringDocument)); gameStringDocument.UpdateGameStrings(spray); }
public UpdaterStartup(ISerializer serializer) { ArgumentNullException.ThrowIfNull(serializer); _serializer = serializer; }
public void LogGenericException(Exception exception, [CallerMemberName] string?previousMethodName = null) { ArgumentNullException.ThrowIfNull(exception); Logger.Error(exception, $"{previousMethodName}()"); }
public ServerObjectCollectionNode(ServerNode serverNode) { ArgumentNullException.ThrowIfNull(serverNode); _server = serverNode; }
public unsafe DCMapping(Gdi32.HDC hdc, Rectangle bounds) { ArgumentNullException.ThrowIfNull(hdc); _hdc = hdc; _savedState = Gdi32.SaveDC(hdc); // Retrieve the x-coordinates and y-coordinates of the viewport origin for the specified device context. bool success = Gdi32.GetViewportOrgEx(hdc, out Point viewportOrg).IsTrue(); Debug.Assert(success, "GetViewportOrgEx() failed."); // Create a new rectangular clipping region based off of the bounds specified, shifted over by the x & y specified in the viewport origin. var hClippingRegion = new Gdi32.RegionScope( viewportOrg.X + bounds.Left, viewportOrg.Y + bounds.Top, viewportOrg.X + bounds.Right, viewportOrg.Y + bounds.Bottom); Debug.Assert(!hClippingRegion.IsNull, "CreateRectRgn() failed."); try { var hOriginalClippingRegion = new Gdi32.RegionScope(hdc); // Shift the viewpoint origin by coordinates specified in "bounds". var lastViewPort = new Point(); success = Gdi32.SetViewportOrgEx( hdc, viewportOrg.X + bounds.Left, viewportOrg.Y + bounds.Top, &lastViewPort).IsTrue(); Debug.Assert(success, "SetViewportOrgEx() failed."); RegionType originalRegionType; if (!hOriginalClippingRegion.IsNull) { // Get the original clipping region so we can determine its type (we'll check later if we've restored the region back properly.) RECT originalClipRect = new RECT(); originalRegionType = Gdi32.GetRgnBox(hOriginalClippingRegion, ref originalClipRect); Debug.Assert( originalRegionType != RegionType.ERROR, "ERROR returned from SelectClipRgn while selecting the original clipping region.."); if (originalRegionType == RegionType.SIMPLEREGION) { // Find the intersection of our clipping region and the current clipping region (our parent's) RegionType combineResult = Gdi32.CombineRgn( hClippingRegion, hClippingRegion, hOriginalClippingRegion, Gdi32.RGN.AND); Debug.Assert( (combineResult == RegionType.SIMPLEREGION) || (combineResult == RegionType.NULLREGION), "SIMPLEREGION or NULLREGION expected."); } } else { // If there was no clipping region, then the result is a simple region. originalRegionType = RegionType.SIMPLEREGION; } // Select the new clipping region; make sure it's a SIMPLEREGION or NULLREGION RegionType selectResult = Gdi32.SelectClipRgn(hdc, hClippingRegion); Debug.Assert( selectResult == RegionType.SIMPLEREGION || selectResult == RegionType.NULLREGION, "SIMPLEREGION or NULLLREGION expected."); } catch (Exception ex) when(!ClientUtils.IsCriticalException(ex)) { } }
/// <summary> /// Returns an enumerable collection of annotations of the specified type /// for this <see cref="XObject"/>. /// </summary> /// <param name="type">The type of the annotations to retrieve.</param> /// <returns>An enumerable collection of annotations for this XObject.</returns> public IEnumerable <object> Annotations(Type type) { ArgumentNullException.ThrowIfNull(type); return(AnnotationsIterator(type)); }
/// <summary> /// Describes how to clear the repository configuration or the specified repository from tenant /// properties in form suitable for passing as the <c>propertiesToRemove</c> argument to /// <see cref="ITenantStore.UpdateTenantAsync(string, string?, IEnumerable{KeyValuePair{string, object}}?, IEnumerable{string}?)"/>. /// </summary> /// <param name="definition">The definition of the repository for which to remove the configuration.</param> /// <returns> /// A single-entry list of properties that can be passed to /// <see cref="ITenantStore.UpdateTenantAsync(string, string?, IEnumerable{KeyValuePair{string, object}}?, IEnumerable{string}?)"/> /// to remove the storage configuration. /// </returns> public static IEnumerable <string> RemoveBlobStorageConfiguration(this BlobStorageContainerDefinition definition) { ArgumentNullException.ThrowIfNull(definition); return(new string[] { GetConfigurationKey(definition) }); }
public StackDebugView(Stack stack) { ArgumentNullException.ThrowIfNull(stack); _stack = stack; }
/// <summary> /// Gets an <see cref="XNamespace"/> created from the specified namespace name. /// </summary> /// <remarks> /// The returned <see cref="XNamespace"/> object is guaranteed to be atomic /// (i.e. the only one in the system for that particular namespace name). /// </remarks> public static XNamespace Get(string namespaceName) { ArgumentNullException.ThrowIfNull(namespaceName); return(Get(namespaceName, 0, namespaceName.Length)); }
public QueueDebugView(Queue <T> queue) { ArgumentNullException.ThrowIfNull(queue); _queue = queue; }
/// <summary> /// Combines an <see cref="XNamespace"/> object with a local name to create an <see cref="XName"/>. /// </summary> /// <param name="ns">The namespace for the expanded name.</param> /// <param name="localName">The local name for the expanded name.</param> /// <returns>The new XName constructed from the namespace and local name.</returns> public static XName operator +(XNamespace ns, string localName) { ArgumentNullException.ThrowIfNull(ns); return(ns.GetName(localName)); }
public static IEnumerable <IEnumerable <T> > Permutations <T>(this IEnumerable <T> source) { ArgumentNullException.ThrowIfNull(source); return(PermutationsImpl(source));
/// <summary> /// Returns an <see cref="XName"/> object created from the current instance and the specified local name. /// </summary> /// <remarks> /// The returned <see cref="XName"/> object is guaranteed to be atomic (i.e. the only one in the system for this /// particular expanded name). /// </remarks> public XName GetName(string localName) { ArgumentNullException.ThrowIfNull(localName); return(GetName(localName, 0, localName.Length)); }
public void DumpMissingHashes() { ArgumentNullException.ThrowIfNull(s_bm); var parsers = _host.Services.GetRequiredService <Red4ParserService>(); var _hashService = _host.Services.GetRequiredService <IHashService>(); var resultDir = Path.Combine(Environment.CurrentDirectory, s_testResultsDirectory); Directory.CreateDirectory(resultDir); // load new hashes var newHashesPath = Path.Combine(s_testResultsDirectory, "new_hashes.txt"); var newHashes = new Dictionary <ulong, string>(); if (File.Exists(newHashesPath)) { var lines = File.ReadAllLines(newHashesPath); foreach (var line in lines) { var hash = FNV1A64HashAlgorithm.HashString(line); if (!_hashService.Contains(hash)) { if (!newHashes.ContainsKey(hash)) { newHashes.Add(hash, line); } } } Console.WriteLine($"Loaded {newHashes.Count} new hashes from {newHashesPath}"); } { List <ulong> newAdded = new(); List <ulong> used = new(); List <ulong> missing = new(); var info_missing = new Dictionary <string, List <ulong> >(); var archives = s_bm.Archives.KeyValues.Select(_ => _.Value).ToList(); for (var i = 0; i < archives.Count; i++) { var ar = archives[i]; var hashes = new List <ulong>(); info_missing.Add(ar.Name, new List <ulong>()); foreach (var(hash, fileInfoEntry) in ar.Files) { if (hash == 6507781686736237035) { } hashes.Add(hash); if (fileInfoEntry is FileEntry fe && fe.NameOrHash == hash.ToString()) { if (newHashes.ContainsKey(hash)) { used.Add(hash); newAdded.Add(hash); } else { missing.Add(hash); info_missing[ar.Name].Add(hash); } }
/// <summary> /// Create a serializer that uses the JSON.net serializer. /// </summary> /// <param name="jsonSerializerSettings">The Json serializer settings.</param> /// <remarks> /// This is internal to reduce exposure of JSON.net types so /// it is easier to convert to System.Text.Json. /// </remarks> internal CorvusJsonDotNetCosmosSerializer(JsonSerializerSettings jsonSerializerSettings) { ArgumentNullException.ThrowIfNull(jsonSerializerSettings); this.serializer = JsonSerializer.Create(jsonSerializerSettings); }
// Helper to return AssemblyName corresponding to the path of an IL assembly public static AssemblyName GetAssemblyName(string assemblyPath) { ArgumentNullException.ThrowIfNull(assemblyPath); return(AssemblyName.GetAssemblyName(assemblyPath)); }
public LoggedDbConnection(IDbConnection connection) { ArgumentNullException.ThrowIfNull(connection); _connection = connection; }
public DefaultExpressionProxy(DefaultExpression node) { ArgumentNullException.ThrowIfNull(node); _node = node; }
public ReflectionComposablePartDefinition(IReflectionPartCreationInfo creationInfo) { ArgumentNullException.ThrowIfNull(creationInfo); _creationInfo = creationInfo; }
public BinaryExpressionProxy(BinaryExpression node) { ArgumentNullException.ThrowIfNull(node); _node = node; }
// Returns a synchronized Stack. // public static Stack Synchronized(Stack stack) { ArgumentNullException.ThrowIfNull(stack); return(new SyncStack(stack)); }
public LambdaExpressionProxy(LambdaExpression node) { ArgumentNullException.ThrowIfNull(node); _node = node; }
/// <summary> /// Throws an ArgumentException of the validation context is null /// </summary> /// <param name="validationContext">The context to check</param> private static void EnsureValidationContext(ValidationContext validationContext) { ArgumentNullException.ThrowIfNull(validationContext); }