/// <summary> /// Convert the string to a valid URI. /// </summary> /// <param name="value">The value.</param> /// <param name="uriKind">The uri kind.</param> /// <returns>The <see cref="Uri"/>, or null if it is invalid URI.</returns> public static Uri ToUri(this string value, UriKind uriKind = UriKind.Absolute) { return (string.IsNullOrWhiteSpace(value) || !Uri.IsWellFormedUriString(value, uriKind)) ? null : new Uri(value, uriKind); }
private void ValidatePackageUri(string packageUri, UriKind allowedUriKind) { if (!_galleryUriValidator.IsValidUri(packageUri, allowedUriKind)) { throw new UriFormatException(packageUri); } }
internal static bool TryMakeUri(string path, bool isDirectory, UriKind kind, out Uri uri) { if (isDirectory && !string.IsNullOrEmpty(path) && !HasEndSeparator(path)) { path += Path.DirectorySeparatorChar; } return Uri.TryCreate(path, kind, out uri); }
public NetflixCatalog(Uri serviceRoot, UriKind absolute) : base(serviceRoot) { this.ResolveName = new global::System.Func<global::System.Type, string>(this.ResolveNameFromType); this.ResolveType = new global::System.Func<string, global::System.Type>(this.ResolveTypeFromName); this.OnContextCreated(); }
public static void ParseUriList(string listOfUrisAsString, Collection<Uri> uriCollection, UriKind uriKind) { Fx.Assert(listOfUrisAsString != null, "The listOfUrisAsString must be non null."); Fx.Assert(uriCollection != null, "The uriCollection must be non null."); string[] uriStrings = listOfUrisAsString.Split(whiteSpaceChars, StringSplitOptions.RemoveEmptyEntries); if (uriStrings.Length > 0) { for (int i = 0; i < uriStrings.Length; i++) { try { uriCollection.Add(new Uri(uriStrings[i], uriKind)); } catch (FormatException fe) { if (uriKind == UriKind.Absolute) { throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlAbsoluteUriFormatError(uriStrings[i]), fe)); } else { throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlUriFormatError(uriStrings[i]), fe)); } } } } }
public static Book GetBook(string url, UriKind urikind) { Book result = new Book(); string content = AtFile.GetContent(url, 4); MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(content)); StreamReader reader = null; try { reader = new StreamReader(stream); string str2 = null; while ((str2 = reader.ReadLine()) != null) { string[] strArray = str2.Replace("&&", "&").Split(new char[] { '&' }); if (strArray.Length >= 3) { Chapter item = new Chapter(); item.Title = strArray[0]; item.FileName = strArray[1]; item.Size = int.Parse(strArray[2]); result.Chapters.Add(item); } } reader.Close(); } catch (NullReferenceException ex) { } return result; }
public static Image GetImage(String uri, Style style, UriKind uriKind) { return new Image { Source = GetImageSource(uri, uriKind), Style = style, }; }
//获取Rich Content void GetRichContent(string uri, UriKind uk) { Container.Children.Clear(); ControlHtmlHost chtml = new ControlHtmlHost(); HtmlHost hh = chtml.FindName("htmlHost") as HtmlHost; hh.SourceUri = new Uri(uri, uk); Container.Children.Add(chtml); }
void LoadImage(string path, UriKind uriKind = UriKind.Absolute) { var bitmap = new BitmapImage(); bitmap.BeginInit(); bitmap.UriSource = new Uri(path, uriKind); bitmap.EndInit(); Model.ImageSource = bitmap; }
// MonoAndroid parses relative URI's and adds a "file://" protocol, which causes the matcher to fail public static bool TryParse(string url, UriKind kind, out Uri output) { bool systemResult = Uri.TryCreate(url, kind, out output); bool isAndroidFalsePositive = systemResult && output.Scheme == "file" && !url.StartsWith("file://", StringComparison.Ordinal); return systemResult && !isAndroidFalsePositive; }
public static Uri ToUri(string value, UriKind uriKind) { Uri uri; Uri.TryCreate(value, UriKind.RelativeOrAbsolute, out uri); return uri; }
/// <summary> /// 将图像文件(使用相对路径)转为BitmapSource对象 /// </summary> /// <param name="ImageFileFullName"></param> /// <returns></returns> public static BitmapSource GetBitmapSourceFromImageFileName(string ImageFileName, UriKind uriKind) { BitmapImage myBitmapImage = new BitmapImage(); myBitmapImage.BeginInit(); myBitmapImage.UriSource = new Uri(ImageFileName, uriKind); myBitmapImage.EndInit(); return myBitmapImage; }
public static Uri ToUri(this string target, UriKind uriKind) { if (target == null) { return null; } return new Uri(target, uriKind); }
/// <summary> /// Adds a thumbnail to the project type. /// </summary> /// <param name="location"></param> /// <param name="kind"></param> /// <param name="pt"></param> /// <returns></returns> public static ProjectType AddThumbnail(string location, UriKind kind, ProjectType pt) { BitmapImage logo = new BitmapImage(); logo.BeginInit(); logo.UriSource = new Uri(location, kind); logo.EndInit(); pt.Icon = logo; return pt; }
internal static Uri IsValidUri(out bool isValid, string url, UriKind kind = UriKind.RelativeOrAbsolute) { isValid = false; if(string.IsNullOrEmpty(url)) return null; Uri temp; isValid = Uri.TryCreate(url, kind, out temp); return temp; }
public static bool TryParseComponents(string uri, UriKind kind, out UriElements elements, out string error) { uri = uri.Trim(); ParserState state = new ParserState(uri, kind); elements = state.elements; error = null; if (uri.Length == 0 && (kind == UriKind.Relative || kind == UriKind.RelativeOrAbsolute)) { state.elements.isAbsoluteUri = false; return true; } if (uri.Length <= 1 && kind == UriKind.Absolute) { error = "Absolute URI is too short"; return false; } bool ok = ParseFilePath(state) && ParseScheme(state); var scheme = state.elements.scheme; UriParser parser = null; if (!StringUtilities.IsNullOrEmpty(scheme)) { parser = UriParser.GetParser(scheme); if (parser != null && !(parser is DefaultUriParser)) return true; } ok = ok && ParseAuthority(state) && ParsePath(state) && ParseQuery(state) && ParseFragment(state); if (StringUtilities.IsNullOrEmpty(state.elements.host) && (scheme == Uri.UriSchemeHttp || scheme == Uri.UriSchemeGopher || scheme == Uri.UriSchemeNntp || scheme == Uri.UriSchemeHttps || scheme == Uri.UriSchemeFtp)) state.error = "Invalid URI: The Authority/Host could not be parsed."; if (!StringUtilities.IsNullOrEmpty(state.elements.host) && Uri.CheckHostName(state.elements.host) == UriHostNameType.Unknown) state.error = "Invalid URI: The hostname could not be parsed."; if (!StringUtilities.IsNullOrEmpty(state.error)) { elements = null; error = state.error; return false; } return true; }
public static UriElements ParseComponents (string uri, UriKind kind) { UriElements elements; string error; if (!TryParseComponents (uri, kind, out elements, out error)) throw new UriFormatException (error); return elements; }
public Uri CreateUri(object parameters, UriKind kind = UriKind.Relative) { string href = this.Href; foreach (PropertyInfo substitution in parameters.GetType().GetProperties()) { string name = substitution.Name; object value = substitution.GetValue(parameters, null); string substituionValue = value == null ? null : Uri.EscapeDataString(value.ToString()); href = href.Replace(string.Format("{{{0}}}", name), substituionValue); } return new Uri(href, kind); }
public FastBitmap(string filename, UriKind uriKind = UriKind.Absolute) { // Use BitmapCacheOption.OnLoad to avoid file locks (thanks Mikhail-Fiadosenka). // http://social.msdn.microsoft.com/forums/en-US/wpf/thread/3738345b-a6cc-421d-a98f-d907292d6e35/ var image = new BitmapImage(); image.BeginInit(); image.CacheOption = BitmapCacheOption.OnLoad; image.UriSource = new Uri(filename, uriKind); image.EndInit(); InnerBitmap = new WriteableBitmap(ConvertFormat(image)); }
public NavigationItem(string containerRegisteredName, UriKind uriKind) { if (String.IsNullOrEmpty(containerRegisteredName)) { throw new ArgumentNullException("containerRegisteredName"); } ContainerRegisteredName = containerRegisteredName; Uri = new Uri(ContainerRegisteredName, UriKind.Relative); }
internal static Uri MakeUri(string path, bool isDirectory, UriKind kind, string throwParameterName = "path") { try { if (isDirectory && !string.IsNullOrEmpty(path) && !HasEndSeparator(path)) { path += Path.DirectorySeparatorChar; } return new Uri(path, kind); } catch (UriFormatException ex) { throw new ArgumentException("Path was invalid", throwParameterName, ex); } catch (ArgumentException ex) { throw new ArgumentException("Path was invalid", throwParameterName, ex); } }
public static byte[] GetBytes(string url, UriKind urikind) { Uri uriResource = new Uri(url, urikind); StreamResourceInfo resourceStream = Application.GetResourceStream(uriResource); MemoryStream stream = new MemoryStream(); int count = 0x800; byte[] buffer = new byte[count]; while (count > 0) { count = resourceStream.Stream.Read(buffer, 0, count); stream.Write(buffer, 0, count); } return stream.GetBuffer(); }
public Uri(string uriString, UriKind uriKind) : this(uriString) { switch (uriKind) { case UriKind.Absolute: if(!IsAbsolute) throw new UriFormatException(); break; case UriKind.Relative: if (IsAbsolute) throw new UriFormatException(); break; } }
private static IntPtr Ctor2 (string uri_string, UriKind uri_kind) { try { return ToGCHandlePtr (ToGCHandle (new Uri (uri_string, uri_kind))); } catch (Exception ex) { #if DEBUG try { Console.WriteLine ("UriHelper.Ctor2 ({0}, {2}): {1}", uri_string, ex.Message, uri_kind); } catch { } #endif return IntPtr.Zero; } }
private static Uri TryCreateUri(string value, UriKind kind) { if (string.IsNullOrEmpty(value)) return null; try { return new Uri(value, kind); } catch (UriFormatException) { return null; } }
public void AddImage(string path, TileMode tile = TileMode.None, Rect? targetArea = null, Stretch stretch = Stretch.Fill, Rectangle rect = null, UriKind kind = UriKind.Relative) { BitmapImage bm = new BitmapImage(new Uri(path, kind)); UIElement el = null; if (tile != TileMode.None && rect == null) { Rectangle r = new Rectangle(); if (targetArea.HasValue) { r.Width = targetArea.Value.Width; r.Height = targetArea.Value.Height; } else { r.Width = this.ActualWidth; r.Height = this.ActualHeight; } Rect rr = new Rect(); rr.Width = bm.PixelWidth; rr.Height = bm.PixelHeight; ImageDrawing d = new ImageDrawing(bm, rr); DrawingBrush brush = new DrawingBrush(d); brush.Viewport = rr; brush.ViewportUnits = BrushMappingMode.Absolute; brush.TileMode = tile; brush.Stretch = Stretch.Fill; r.Fill = brush; el = r; } else { Image img = new Image(); img.Width = bm.Width; img.Height = bm.Height; img.Source = bm; el = img; } RenderCanvas.Children.Add(el); if (targetArea.HasValue) { Canvas.SetLeft(el, targetArea.Value.X); Canvas.SetTop(el, targetArea.Value.Y); } else { Canvas.SetLeft(el, 0); Canvas.SetTop(el, 0); } }
public NodeUri(string uriString, UriKind uriKind) : base(uriString, uriKind) { if (IsAbsoluteUri) { if (Segments.Length == 0) { throw new UriFormatException("Node URI format invalid"); } if (!UriScheme.Equals(Scheme, StringComparison.InvariantCultureIgnoreCase)) { throw new UriFormatException("Node URI scheme invalid"); } } }
public bool IsValidUri(string uri, UriKind allowedUriKind) { if (string.IsNullOrWhiteSpace(uri)) { return true; } Uri checkedUri; if (!Uri.TryCreate(uri, allowedUriKind, out checkedUri)) { return false; } if (checkedUri.IsAbsoluteUri) { IEnumerable<string> validSchemes = new[] { "http", "https" }; return validSchemes.Any(s => s == checkedUri.Scheme); } return true; }
public static void SetupESRI.ArcGIS.Mapping.Controls.ArcGISOnline(string configFilePath, UriKind configFilePathUriKind) { Uri uri = new Uri(configFilePath, configFilePathUriKind); ESRI.ArcGIS.Mapping.Controls.ArcGISOnline.WebUtil.OpenReadAsync(uri, null, (sender2, e2) => { XDocument xml = XDocument.Load(e2.Result); var v = (from next in xml.Descendants("ArcGISOnline") select new { Url = next.Element("Url").Value, UrlSecure = next.Element("UrlSecure").Value }).SingleOrDefault(); ESRI.ArcGIS.Mapping.Controls.ArcGISOnline.ArcGISOnlineEnvironment.ArcGISOnline.Initialize(v.Url, v.UrlSecure); ESRI.ArcGIS.Mapping.Controls.ArcGISOnline.ArcGISOnlineEnvironment.ArcGISOnline.User.SignedInOut += User_SignedInOut; ESRI.ArcGIS.Mapping.Controls.ArcGISOnline.BasemapSupport.GetBasemaps(null); }); }
/// <summary> /// Create a Uri as entry or feed id /// </summary> /// <param name="value">Uri value</param> /// <param name="kind">UriKind</param> /// <param name="swallowEmpty">if swallowEmpty is true, an empty value will be parsed as null Uri, otherwise invalid Uri format exception will throw. </param> /// <returns>Created Uri from value</returns> internal static Uri CreateUriAsEntryOrFeedId(string value, UriKind kind, bool swallowEmpty = true) { if (swallowEmpty && value == string.Empty || value == null) { return null; } Uri uri; try { uri = new Uri(value, kind); } catch (FormatException) { throw new ODataException(Strings.ODataUriUtils_InvalidUriFormatForEntryIdOrFeedId(value)); } return uri; }
// // All public ctors go through here // private void CreateThis(string?uri, bool dontEscape, UriKind uriKind, in UriCreationOptions creationOptions = default)
public DerivedUri(string uri, UriKind kind) : base(uri, kind) { }
public UriCombine(string uriString, UriKind uriKind) : base(uriString, uriKind) { }
/// <summary> /// Create a UriRef from this string with a given kind /// </summary> /// <returns></returns> public static UriRef ToUriRef(this string uriString, UriKind uriKind) { return(new UriRef(uriString, uriKind)); }
public GalleryuriData(string uriString, UriKind uriKind,object ExternInfo) { _uri = new Uri(uriString,uriKind); _externInfo = ExternInfo; }
private ResourceIdentity(string uri, UriKind kind) : base(uri, kind) { }
static Uri \u202E([In] string obj0, [In] UriKind obj1) { return(new Uri(obj0, obj1)); }
[MethodImpl(MethodImplOptions.NoInlining)] // required private static void CreateThisPatched(Uri thisUri, string uri, bool dontEscape, UriKind uriKind) { uri = RemoveLongPathPrefix(uri); mStringUriFld.Value.SetValue(thisUri, uri); var flagsLong = (ulong)mFlagsUriFld.Value.GetValue(thisUri); if (dontEscape) { flagsLong |= 0x00080000; } var flags = Enum.Parse(mFlagsUriFld.Value.FieldType, flagsLong.ToString(CultureInfo.InvariantCulture)); var mSyntax = mSyntaxUriFld.Value.GetValue(thisUri); object[] args = { uri, flags, mSyntax }; var err = uriParseScheme.Value.Invoke(null, args); mFlagsUriFld.Value.SetValue(thisUri, args[1]); mSyntaxUriFld.Value.SetValue(thisUri, args[2]); args = new[] { err, uriKind, null }; uriInitializeUri.Value.Invoke(thisUri, args); if (args[2] is UriFormatException e) { throw e; } }
private void InitializeUri(ParsingError err, UriKind uriKind, out UriFormatException e) { if (err == ParsingError.None) { if (IsImplicitFile) { // V1 compat // A relative Uri wins over implicit UNC path unless the UNC path is of the form "\\something" and // uriKind != Absolute // A relative Uri wins over implicit Unix path unless uriKind == Absolute if (NotAny(Flags.DosPath) && uriKind != UriKind.Absolute && ((uriKind == UriKind.Relative || (_string.Length >= 2 && (_string[0] != '\\' || _string[1] != '\\'))) || (!IsWindowsSystem && InFact(Flags.UnixPath)))) { _syntax = null; //make it be relative Uri _flags &= Flags.UserEscaped; // the only flag that makes sense for a relative uri e = null; return; // Otherwise an absolute file Uri wins when it's of the form "\\something" } // // V1 compat issue // We should support relative Uris of the form c:\bla or c:/bla // else if (uriKind == UriKind.Relative && InFact(Flags.DosPath)) { _syntax = null; //make it be relative Uri _flags &= Flags.UserEscaped; // the only flag that makes sense for a relative uri e = null; return; // Otherwise an absolute file Uri wins when it's of the form "c:\something" } } } else if (err > ParsingError.LastRelativeUriOkErrIndex) { //This is a fatal error based solely on scheme name parsing _string = null; // make it be invalid Uri e = GetException(err); return; } bool hasUnicode = false; _iriParsing = (s_IriParsing && ((_syntax == null) || _syntax.InFact(UriSyntaxFlags.AllowIriParsing))); if (_iriParsing && (CheckForUnicode(_string) || CheckForEscapedUnreserved(_string))) { _flags |= Flags.HasUnicode; hasUnicode = true; // switch internal strings _originalUnicodeString = _string; // original string location changed } if (_syntax != null) { if (_syntax.IsSimple) { if ((err = PrivateParseMinimal()) != ParsingError.None) { if (uriKind != UriKind.Absolute && err <= ParsingError.LastRelativeUriOkErrIndex) { // RFC 3986 Section 5.4.2 - http:(relativeUri) may be considered a valid relative Uri. _syntax = null; // convert to relative uri e = null; _flags &= Flags.UserEscaped; // the only flag that makes sense for a relative uri return; } else { e = GetException(err); } } else if (uriKind == UriKind.Relative) { // Here we know that we can create an absolute Uri, but the user has requested only a relative one e = GetException(ParsingError.CannotCreateRelative); } else { e = null; } // will return from here if (_iriParsing && hasUnicode) { // In this scenario we need to parse the whole string EnsureParseRemaining(); } } else { // offer custom parser to create a parsing context _syntax = _syntax.InternalOnNewUri(); // in case they won't call us _flags |= Flags.UserDrivenParsing; // Ask a registered type to validate this uri _syntax.InternalValidate(this, out e); if (e != null) { // Can we still take it as a relative Uri? if (uriKind != UriKind.Absolute && err != ParsingError.None && err <= ParsingError.LastRelativeUriOkErrIndex) { _syntax = null; // convert it to relative e = null; _flags &= Flags.UserEscaped; // the only flag that makes sense for a relative uri } } else // e == null { if (err != ParsingError.None || InFact(Flags.ErrorOrParsingRecursion)) { // User parser took over on an invalid Uri SetUserDrivenParsing(); } else if (uriKind == UriKind.Relative) { // Here we know that custom parser can create an absolute Uri, but the user has requested only a // relative one e = GetException(ParsingError.CannotCreateRelative); } if (_iriParsing && hasUnicode) { // In this scenario we need to parse the whole string EnsureParseRemaining(); } } // will return from here } } // If we encountered any parsing errors that indicate this may be a relative Uri, // and we'll allow relative Uri's, then create one. else if (err != ParsingError.None && uriKind != UriKind.Absolute && err <= ParsingError.LastRelativeUriOkErrIndex) { e = null; _flags &= (Flags.UserEscaped | Flags.HasUnicode); // the only flags that makes sense for a relative uri if (_iriParsing && hasUnicode) { // Iri'ze and then normalize relative uris _string = EscapeUnescapeIri(_originalUnicodeString, 0, _originalUnicodeString.Length, (UriComponents)0); } } else { _string = null; // make it be invalid Uri e = GetException(err); } }
/// <summary> /// Creates an emissive image material. /// </summary> /// <param name="uri">The uri of the image.</param> /// <param name="diffuseBrush">The diffuse brush.</param> /// <param name="uriKind">Kind of the <paramref name="uri" />.</param> /// <param name="freeze">Freeze the material if set to <c>true</c>.</param> /// <returns>The image material.</returns> public static Material CreateEmissiveImageMaterial(string uri, Brush diffuseBrush, UriKind uriKind, bool freeze = true) { var image = GetImage(uri, uriKind); if (image == null) { return(null); } return(CreateEmissiveImageMaterial(image, diffuseBrush, freeze: freeze)); }
private static Uri ParseUri(string s) { UriKind uriKind = (s.StartsWith("http") || s.StartsWith("https")) ? UriKind.Absolute : UriKind.Relative; return(new Uri(s, uriKind)); }
public XmlUriData(string uriString, UriKind uriKind, XmlQualifiedName elementQualifiedName) { UriString = uriString; UriKind = uriKind; ElementQualifiedName = elementQualifiedName; }
public static Uri TryParseUri(this string str, UriKind uriKind = UriKind.RelativeOrAbsolute) { return(Uri.TryCreate(str, uriKind, out Uri value) ? value : null); }
#pragma warning restore CS0618 // Type or member is obsolete public ConvertUri(string uriString, UriKind uriKind) : base(uriString, uriKind) { }
public Uri ResolveUri(UriKind uriKind, IDictionary <string, object> variables) { return(new Uri(Resolve(variables), uriKind)); }
/// <summary> /// Same as "new Uri" except that it can handle UNIX style paths that start with '/' /// </summary> public static Uri CreateSourceUri(string source, UriKind kind = UriKind.Absolute) { source = FixSourceUri(source); return(new Uri(source, kind)); }
/// <summary>new Uri(string uriString, UriKind uriKind)</summary> /// <param name="value">value</param> /// <param name="kind">kind</param> /// <returns>new Uri(value, kind)</returns> internal static Uri CreateUri(string value, UriKind kind) { return(value == null ? null : new Uri(value, kind)); }
static Uri \u202D([In] string obj0, [In] UriKind obj1) { return(new Uri(obj0, obj1)); }
/// <summary> /// Creates an UriRef from a string with a given UriKind. /// </summary> /// <param name="uriString"></param> /// <param name="uriKind"></param> public UriRef(string uriString, UriKind uriKind) : base(uriString, uriKind) { }
public void IsWellFormedUriString(string uriString, UriKind uriKind, bool expected) { Assert.Equal(expected, Uri.IsWellFormedUriString(uriString, uriKind)); }
/// <summary> /// The <see cref="UriKind"/> to use when converting. /// This is used when doing <see cref="Uri"/> conversions. /// </summary> /// <param name="uriKind">Kind of the URI.</param> public virtual ParameterMap UriKind(UriKind uriKind) { parameterMap.Data.TypeConverterOptions.UriKind = uriKind; return(parameterMap); }
public void SetBackgroundVideo(string path, UriKind uriKind = UriKind.Relative) { mediaelement.Source = new Uri(path, uriKind); mediaelement.Play(); }
private UriHeaderParser(UriKind uriKind) : base(false) { _uriKind = uriKind; }
public void TryParse_should_return_true_for_valid_input(string uri, UriKind kind) { UriParser.TryParse(uri, out var res).Should().BeTrue(); res.Should().BeEquivalentTo(new Uri(uri, kind)); }
internal void Add(ThemeType type, string source, UriKind kind) { Add(type, new ResourceDictionary { Source = new Uri(source, kind) }); }
public MonoUri(string uriString, UriKind uriKind) : base(uriString, uriKind) { }
/// <summary> /// A new hyperlink with the specified URI and kind /// </summary> /// <param name="uriString">The URI</param> /// <param name="uriKind">Kind (absolute/relative or indeterminate)</param> public ExcelHyperLink(string uriString, UriKind uriKind) : base(uriString, uriKind) { OriginalUri = (Uri)this; }
public Href(string uriString, UriKind uriKind) { _value = new Uri(uriString, uriKind); }
public UriPlus(string uriString, UriKind uriKind) : base(uriString, uriKind) { }
internal RequestBuilder(IRequestObserver observer, HttpClient client, string path, UriKind kind = UriKind.Relative) { Observer = observer; _client = client; var uri = new Uri(path, kind); if (!uri.IsAbsoluteUri) { uri = new Uri(client.BaseAddress, uri); } _keyValue = HttpUtility.ParseQueryString(uri.Query); _uri = new Uri(uri.GetLeftPart(UriPartial.Path)); Message = new HttpRequestMessage(); }