// *no* check version private static void InternalRegister(Hashtable table, UriParser uriParser, string schemeName, int defaultPort) { uriParser.SchemeName = schemeName; uriParser.DefaultPort = defaultPort; DefaultUriParser parser = new DefaultUriParser(); parser.SchemeName = schemeName; parser.DefaultPort = defaultPort; table.Add(schemeName, parser); // note: we cannot set schemeName and defaultPort inside OnRegister uriParser.OnRegister(schemeName, defaultPort); }
public static void RegisterPackUriParser() { if (UriParser.IsKnownScheme(PackUriScheme)) { return; } UriParser.Register(new GenericUriParser(GenericUriParserOptions.GenericAuthority), PackUriScheme, -1); }
public void Initialize() { // Required to register bourgeoise XAML URI schemes if (!UriParser.IsKnownScheme("pack")) { new Application(); } _accent = ThemeManager.TryGetAccent("Blue"); }
public void FixtureSetup() { if (!UriParser.IsKnownScheme("pack")) { new System.Windows.Application(); } this.tester = new ServiceTester <DirectoryWatch>(); }
public void TestInit() { if (!UriParser.IsKnownScheme("pack")) { // ReSharper disable ObjectCreationAsStatement new System.Windows.Application(); } // ReSharper restore ObjectCreationAsStatement }
//------------------------------------------------------ // // Internal Events // //------------------------------------------------------ // None //------------------------------------------------------ // // Private Constructors // //------------------------------------------------------ #region Private Constructor static PackUriHelper() { // indicate that we want "basic" parsing if (!UriParser.IsKnownScheme(System.IO.Packaging.PackUriHelper.UriSchemePack)) { // Indicate that we want a default hierarchical parser with a registry based authority UriParser.Register(new GenericUriParser(GenericUriParserOptions.GenericAuthority), System.IO.Packaging.PackUriHelper.UriSchemePack, -1); } }
/// <summary> /// Registers the URI. /// </summary> public static void RegisterUri() { if (!UriParser.IsKnownScheme("rtsp")) { UriParser.Register(new HttpStyleUriParser(), "rtsp", 554); } UriParser.Register(new HttpStyleUriParser(), "rtsp", 8080); }
public void Setup() { if (!UriParser.IsKnownScheme("pack")) { new System.Windows.Application(); } this.iconProvider = new IconProvider(); this.testFileName = Path.GetTempFileName(); File.Create(testFileName).Close(); }
/// <summary> /// Ensures the <see cref="UriParser"/> is registered. /// </summary> public static void Register() { if (!registered) { UriParser.Register(new DynamicUriParser(), DynamicUriHelper.UriSchemeDynamic, -1); registered = true; } DynamicWebRequestFactory.Register(); }
/** * By default the RTSP uses {@link UriParser} to parse the URI requested by the client * but you can change that behavior by override this method. * @param uri The uri that the client has requested * @param client The socket associated to the client * @return A proper session */ protected Session handleRequest(System.String uri, Socket client) { //TODO Session session = UriParser.parse(uri); session.setOrigin(client.LocalAddress.HostAddress); if (session.getDestination()==null) { session.setDestination(client.InetAddress.HostAddress); } return session; }
private EquipmentData(Options options) { if (!UriParser.IsKnownScheme("pack")) { // Necessary for unit tests. Accessing PackUriHelper triggers static initialization. // Without it, creating resource URIs from unit tests would throw UriFormatExceptions. var _ = System.IO.Packaging.PackUriHelper.UriSchemePack; } _itemImageService = new ItemImageService(options); }
public void InitializeAndValidate() { Assert.IsTrue(UriParser.IsKnownScheme("httpx"), "premise1"); Uri uri = new Uri("httpx://localhost"); UriFormatException error; parser._InitializeAndValidate(uri, out error); Assert.AreEqual(null, error); }
public static Uri ToPackUri(string url) { if (!UriParser.IsKnownScheme("pack")) { // Register the pack scheme. new Application(); } return(new Uri(url)); }
public void DontCheckHostWithCustomParsers() { UriParser.Register(new TolerantUriParser(), "assembly", 0); try { new Uri("assembly://Spring.Core, Version=1.2.0.20001, Culture=neutral, " + "PublicKeyToken=null/Spring.Objects.Factory.Xml/spring-objects-1.1.xsd"); } catch (UriFormatException) { Assert.Fail("Spring Uri is expected to work."); } }
public void SendTest() { Publication pub = storageManager.getEntityByID <Publication>(11); Assert.IsNotNull(pub); UriParser.Register(new GoogleDocsUriParser(), "gdocs", -1); Assert.IsTrue(serviceManager.Send(pub)); }
public static IEnumerable <CoapOption> DecomposeCoapUri(this Uri resource) { List <CoapOption> options = new List <CoapOption>(); GenericUriParser gup = new GenericUriParser(GenericUriParserOptions.NoFragment); if (!UriParser.IsKnownScheme("coap")) { UriParser.Register(gup, "coap", -1); } if (!resource.IsWellFormedOriginalString()) { throw new UriFormatException("Not well formed URI."); } if (!resource.IsAbsoluteUri) { throw new UriFormatException("Not absolute URI."); } if (resource.Scheme != "coap" && resource.Scheme != "coaps") { throw new UriFormatException(String.Format("Invalid scheme '{0}'", resource.Scheme)); } options.Add(new CoapOption(OptionType.UriHost, resource.Host)); if (resource.Port > 0) { options.Add(new CoapOption(OptionType.UriPort, (uint)resource.Port)); } if (resource.AbsolutePath != "/") { string[] parts = resource.AbsolutePath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); foreach (string part in parts) { options.Add(new CoapOption(OptionType.UriPath, part)); } } if (!string.IsNullOrEmpty(resource.Query)) { NameValueCollection nvc = HttpUtility.ParseQueryString(resource.Query); int index = 0; while (index < nvc.Count) { options.Add(new CoapOption(OptionType.UriQuery, nvc.GetKey(index) + "=" + nvc[index])); index++; } } return(options.ToArray()); }
/// <summary> /// Ensures that the pack URI is allowed. Sometimes, when no application object is instantiated /// yet, the pack URI is not allowed. This method takes care of that. /// </summary> internal static void EnsurePackUriIsAllowed() { #if !NETFX_CORE if (!UriParser.IsKnownScheme("pack")) { Log.Debug("Pack uri is not yet allowed, adding it as known scheme"); UriParser.Register(new GenericUriParser(GenericUriParserOptions.GenericAuthority), "pack", -1); } #endif }
private void RegisterPackScheme() { if (UriParser.IsKnownScheme("pack")) { return; } var packParser = new PackParser(); UriParser.Register(packParser, "pack", 0); }
public static void ReRegister() { string scheme = Prefix + "re.register.mono"; Assert.False(UriParser.IsKnownScheme(scheme), "IsKnownScheme-false"); TestUriParser parser = new TestUriParser(); UriParser.Register(parser, scheme, 2005); Assert.True(UriParser.IsKnownScheme(scheme), "IsKnownScheme-true"); Assert.Throws <InvalidOperationException>(() => UriParser.Register(parser, scheme, 2006)); }
public void ReRegister() { string scheme = prefix + "re.register.mono"; Assert.IsFalse(UriParser.IsKnownScheme(scheme), "IsKnownScheme-false"); UnitTestUriParser p = new UnitTestUriParser(); UriParser.Register(p, scheme, 2005); Assert.IsTrue(UriParser.IsKnownScheme(scheme), "IsKnownScheme-true"); UriParser.Register(p, scheme, 2006); }
static ColorizeShaderEffect() { if (!UriParser.IsKnownScheme("pack")) { new FlowDocument(); } _pixelShader = new PixelShader() { UriSource = new Uri("pack://application:,,,/Snoop;component/Shaders/Compiled/colorizeshader.ps", UriKind.RelativeOrAbsolute) }; }
public MyUriParser(UriParser originalParser) : base() { if (_originalParser == null) { _originalParser = originalParser; _getComponentsMethod = typeof(UriParser).GetMethod("GetComponents", BindingFlags.NonPublic | BindingFlags.Instance); if (_getComponentsMethod == null) { throw new MissingMethodException("UriParser", "GetComponents"); } } }
public void InitializeAndValidate2() { Assert.IsTrue(UriParser.IsKnownScheme("httpx"), "premise1"); Uri uri = new Uri("file:///usr/local/bin"); // It results in UriFormatException since it tries // to parse file URI with http Uri parser. UriFormatException error; parser._InitializeAndValidate(uri, out error); Assert.IsNotNull(error); }
public void FixtureSetUp() { parser = new UnitTestNewsStyleUriParser(); // unit tests are being reused in CAS tests if (!UriParser.IsKnownScheme("newsx")) { UriParser.Register(parser, "newsx", 2); } Assert.IsTrue(UnitTestNewsStyleUriParser.Registered, "Registered"); // our parser code was called }
public static void ReRegister() { prefix = "unit.test."; string scheme = prefix + "re.register.mono"; Assert.False(UriParser.IsKnownScheme(scheme), "IsKnownScheme-false"); TestUriParser parser = new TestUriParser(); UriParser.Register(parser, scheme, 2005); Assert.True(UriParser.IsKnownScheme(scheme), "IsKnownScheme-true"); Assert.Throws <System.InvalidOperationException>(() => { UriParser.Register(parser, scheme, 2006); }); }
public void FixtureSetUp() { parser = new UnitTestGenericUriParser(); // unit tests are being reused in CAS tests if (!UriParser.IsKnownScheme("generic")) { UriParser.Register(parser, "generic", 1); } Assert.IsTrue(UnitTestGenericUriParser.Registered, "Registered"); // our parser code was called }
/// <summary> /// Registers the parsers. /// </summary> public static void RegisterParsers() { if (!UriParser.IsKnownScheme(SvnUri.UriSchemeSvn)) { UriParser.Register(new SvnUriParser(), SvnUri.UriSchemeSvn, 3980); } if (!UriParser.IsKnownScheme(SvnUri.UriSchemeSvnSsh)) { UriParser.Register(new SvnUriParser(), SvnUri.UriSchemeSvnSsh, 22); } }
static SipMessage() { if (false == UriParser.IsKnownScheme(SipMessage.TransportScheme)) { UriParser.Register(new HttpStyleUriParser(), SipMessage.TransportScheme, SipMessage.TransportDefaultPort); } if (false == UriParser.IsKnownScheme(SipMessage.SecureTransportScheme)) { UriParser.Register(new HttpStyleUriParser(), SipMessage.SecureTransportScheme, SipMessage.SecureTransportDefaultPort); } }
public static void RegisterResUriParsers() { if (!UriParser.IsKnownScheme("avares")) { UriParser.Register(new GenericUriParser( GenericUriParserOptions.GenericAuthority | GenericUriParserOptions.NoUserInfo | GenericUriParserOptions.NoPort | GenericUriParserOptions.NoQuery | GenericUriParserOptions.NoFragment), "avares", -1); } }
/** * 下载文件 */ protected bool downloadfile(string url, string savefullpath, ProgressDelegate progress = null) { //处理下载url不符合rfc规范的情况 MethodInfo getSyntax = typeof(UriParser).GetMethod("GetSyntax", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic); FieldInfo flagsField = typeof(UriParser).GetField("m_Flags", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic); if (getSyntax != null && flagsField != null) { foreach (string scheme in new[] { "http", "https" }) { UriParser parser = (UriParser)getSyntax.Invoke(null, new object[] { scheme }); if (parser != null) { int flagsValue = (int)flagsField.GetValue(parser); // Clear the CanonicalizeAsFilePath attribute if ((flagsValue & 0x1000000) != 0) { flagsField.SetValue(parser, flagsValue & ~0x1000000); } } } } NSPLog.log(LogMsgType.NSP_LOG_NOTICE, "请求下载 " + url); //文件下载 WebRequest req = WebRequest.Create(url); WebResponse pos = req.GetResponse(); long totalbytes = pos.ContentLength; Stream s = pos.GetResponseStream(); FileStream fs = new FileStream(savefullpath, FileMode.OpenOrCreate, FileAccess.Write); byte[] buffer = new byte[1024]; int bytesRead = s.Read(buffer, 0, buffer.Length); long donebytes = 0; while (bytesRead > 0) { fs.Write(buffer, 0, bytesRead); bytesRead = s.Read(buffer, 0, buffer.Length); if (progress != null) { donebytes += bytesRead; progress(donebytes, totalbytes); } } fs.Close(); s.Close(); pos.Close(); return(true); }
public static void AnyValidPort_CanBeRegistered() { for (int i = -1; i <= 65535; i++) { string scheme = $"custom-port-scheme-{i:X2}"; UriParser.Register(new HttpStyleUriParser(), scheme, defaultPort: i); var uri = new Uri($"{scheme}://host/path"); Assert.Equal(i, uri.Port); } Assert.Throws <ArgumentOutOfRangeException>(() => UriParser.Register(new HttpStyleUriParser(), "invalid-port", -2)); Assert.Throws <ArgumentOutOfRangeException>(() => UriParser.Register(new HttpStyleUriParser(), "invalid-port", 65536)); }
public static void Register(UriParser uriParser, string schemeName, int defaultPort) { if (uriParser == null) throw new ArgumentNullException("uriParser"); if (schemeName == null) throw new ArgumentNullException("schemeName"); if ((defaultPort < -1) || (defaultPort >= UInt16.MaxValue)) throw new ArgumentOutOfRangeException("defaultPort"); CreateDefaults(); string lc = schemeName.ToLower(); if (table[lc] != null) { string msg = "Scheme is already registred."; throw new InvalidOperationException(msg); } InternalRegister(table, uriParser, lc, defaultPort); }
internal static bool IriParsingStatic(UriParser syntax) { throw new NotImplementedException(); }
// Methods public static void Register(UriParser uriParser, string schemeName, int defaultPort) { }