/// <summary> /// Registers a custom resolver for the given service reference client type using a sequence of uri resolvers. /// If a resolver returns null, the next one will be used. If they all return null, then a null value will be returned for the dependency. /// </summary> /// <typeparam name="TClient">The service reference client type contract</typeparam> /// <param name="container">The dependency injection container</param> /// <param name="serviceUriResolvers">The uri resolvers to try</param> public static void RegisterServiceReference <TClient>(this DependencyInjectionContainer container, params Func <Uri>[] serviceUriResolvers) { ExceptionUtilities.CheckArgumentNotNull(container, "container"); ExceptionUtilities.CheckCollectionNotEmpty(serviceUriResolvers, "serviceUriResolvers"); ExceptionUtilities.CheckCollectionDoesNotContainNulls(serviceUriResolvers, "serviceUriResolvers"); var options = container.RegisterCustomResolver( typeof(TClient), t => { Uri serviceUri = null; foreach (var uriResolver in serviceUriResolvers) { serviceUri = uriResolver(); if (serviceUri != null) { break; } } if (serviceUri == null) { return(null); } var factory = container.Resolve <IServiceReferenceFactory>(); return(factory.CreateInstance <TClient>(serviceUri)); }); options.IsTransient = true; }
/// <summary> /// Resolves an assembly /// </summary> /// <param name="assemblyName">Assembly Name</param> /// <returns>Will return either the original result or a fully resolved assemblypath</returns> public string ResolveAssemblyLocation(string assemblyName) { ExceptionUtilities.CheckArgumentNotNull(assemblyName, "assemblyName"); if (Path.IsPathRooted(assemblyName)) { return(assemblyName); } List <string> foundFilePaths = FindFilePaths(this.GetDirectoryLookupLocations(), assemblyName); ExceptionUtilities.CheckCollectionDoesNotContainNulls <string>(foundFilePaths, "foundFilePaths"); ExceptionUtilities.Assert(foundFilePaths.Count < 2, "Found '{0}' in the following places '{1}'", assemblyName, string.Join(",", foundFilePaths)); string fullPath = foundFilePaths.SingleOrDefault(); if (fullPath != null) { return(fullPath); } else { return(assemblyName); } }
private static TChangeset Changeset <TChangeset, TOperation>(string boundary, string charset, Func <TChangeset> createChangeset, params IMimePart[] parts) where TChangeset : BatchChangeset <TOperation> where TOperation : class, IMimePart { ExceptionUtilities.CheckCollectionDoesNotContainNulls(parts, "parts"); var changeset = createChangeset(); changeset.Headers[HttpHeaders.ContentType] = HttpUtilities.BuildContentType(MimeTypes.MultipartMixed, charset, boundary); foreach (var part in parts) { var wrappedRequest = part as MimePartData <TOperation>; if (wrappedRequest != null) { changeset.Add(wrappedRequest); } else { var operation = part as TOperation; ExceptionUtilities.CheckObjectNotNull(operation, "Given part was of unexpected type '{0}'", part.GetType()); string contentId; if (operation.Headers.TryGetValue(HttpHeaders.ContentId, out contentId)) { operation.Headers.Remove(HttpHeaders.ContentId); } changeset.Add(operation.AsBatchFragment(contentId)); } } return(changeset); }
/// <summary> /// Initializes a new instance of the DelegatedRandomDataGenerator class. /// </summary> /// <param name="random">Random number generator.</param> /// <param name="generateDataDelegates">Delegates to use when generating data. Delegate is picked randomly each time if more than one delegate provided.</param> /// <param name="interestingData">Interesting data that should be generated randomly.</param> public DelegatedRandomDataGenerator(IRandomNumberGenerator random, IEnumerable <Func <IRandomNumberGenerator, TData> > generateDataDelegates, params TData[] interestingData) { ExceptionUtilities.CheckArgumentNotNull(random, "random"); ExceptionUtilities.CheckCollectionNotEmpty(generateDataDelegates, "generateDataDelegates"); ExceptionUtilities.CheckCollectionDoesNotContainNulls(generateDataDelegates, "generateDataDelegates"); ExceptionUtilities.CheckArgumentNotNull(interestingData, "interestingData"); this.random = random; this.generateDataDelegates = generateDataDelegates.ToArray(); this.interestingData = interestingData.ToArray(); }
/// <summary> /// Adds given methods to <see cref="Methods"/> collection. /// </summary> /// <param name="methods">methods to add.</param> /// <returns>This object (useful for chaining multiple calls).</returns> public SpatialDataType WithMethods(params Function[] methods) { ExceptionUtilities.CheckCollectionDoesNotContainNulls(methods, "methods"); ExceptionUtilities.Assert(this.Methods.Count == 0, "This method can only be called on spatial type without any methods defined."); foreach (var m in methods) { this.Methods.Add(m); } return(this); }
/// <summary> /// Adds given properties to <see cref="Properties"/> collection. /// </summary> /// <param name="properties">Properties to add.</param> /// <returns>This object (useful for chaining multiple calls).</returns> public SpatialDataType WithProperties(params MemberProperty[] properties) { ExceptionUtilities.CheckCollectionDoesNotContainNulls(properties, "properties"); ExceptionUtilities.Assert(this.Properties.Count == 0, "This method can only be called on spatial type without any properties defined."); foreach (var p in properties) { this.Properties.Add(p); } return(this); }
/// <summary> /// Adds given columns to <see cref="Columns"/> collection. /// </summary> /// <typeparam name="TConstraint">The type of the constraint.</typeparam> /// <param name="columns">Columns that participate in the constraint.</param> /// <returns>This object (useful for chaining multiple calls).</returns> protected TConstraint WithColumns <TConstraint>(params Column[] columns) where TConstraint : ColumnsConstraintBase { ExceptionUtilities.CheckCollectionDoesNotContainNulls(columns, "columns"); ExceptionUtilities.Assert(this.Columns.Count == 0, "This method can only be called on a constraint that doesn't have any columns defined."); foreach (Column c in columns) { this.Add(c); } return((TConstraint)this); }
public static string ConcatenateUriSegments(params string[] segments) { ExceptionUtilities.CheckCollectionDoesNotContainNulls(segments, "segments"); if (segments.Length == 0) { return(null); } if (segments.Length == 1) { return(segments[0]); } StringBuilder builder = new StringBuilder(); for (int i = 0; i < segments.Length; i++) { // if this is the first segment, then only trim trailing slashes if (i == 0) { builder.Append(segments[i].TrimEnd('/')); } else { // if this is not the first segment, then we need to add a slash before concatenating the next builder.Append('/'); // if we're not at the end, then trim slashes from both ends if (i < segments.Length - 1) { builder.Append(segments[i].Trim('/')); } else { // if we're at the end, then trim only the leading slashes builder.Append(segments[i].TrimStart('/')); } } } return(builder.ToString()); }
/// <summary> /// Calculates the key for an entity, which is used to build uris for link update and delete operations /// </summary> /// <param name="entity">The entity to build a key for</param> /// <returns>The key of the entity</returns> public string CalculateEntityKey(object entity) { var entityType = entity.GetType(); var keyProperties = entityType.GetCustomAttributes(typeof(KeyAttribute), true) .Cast <KeyAttribute>().SelectMany(att => att.KeyNames) .Concat(entityType.GetProperties().Select(p => p.Name).Where(p => p.EndsWith("ID", StringComparison.Ordinal))) .Distinct() .OrderBy(p => p, Comparer <string> .Default) .Select(p => entityType.GetProperty(p)) .ToList(); ExceptionUtilities.CheckCollectionNotEmpty(keyProperties, "keyProperties"); ExceptionUtilities.CheckCollectionDoesNotContainNulls(keyProperties, "keyProperties"); StringBuilder builder = new StringBuilder(); this.LiteralConverter.AppendKeyExpression(builder, keyProperties.Select(p => new NamedValue(p.Name, p.GetValue(entity, null)))); return(builder.ToString()); }
private static TItem WithDataGenerationHintsInternal <TItem>(this TItem annotatedItem, params DataGenerationHint[] hints) where TItem : AnnotatedItem { ExceptionUtilities.CheckCollectionDoesNotContainNulls(hints, "hints"); if (hints.Length == 0) { return(annotatedItem); } DataGenerationHintsAnnotation dataGenHintsAnnotation = annotatedItem.Annotations.OfType <DataGenerationHintsAnnotation>().SingleOrDefault(); if (dataGenHintsAnnotation == null) { dataGenHintsAnnotation = new DataGenerationHintsAnnotation(); annotatedItem.Annotations.Add(dataGenHintsAnnotation); } foreach (var hint in hints) { dataGenHintsAnnotation.Add(hint); } return(annotatedItem); }
/// <summary> /// Initializes a new instance of the CompositeEntityModelFixup class /// </summary> /// <param name="fixups">The initial set of fixups</param> public CompositeEntityModelFixup(IEnumerable <IEntityModelFixup> fixups) { ExceptionUtilities.CheckCollectionDoesNotContainNulls(fixups, "fixups"); this.Fixups = new List <IEntityModelFixup>(fixups); }