Come creare un'istanza Uri analizzata con GenericUriParserOptions.DontCompressPath

Question

Quando la classe .NET System.Uri analizza le stringhe, esegue alcune operazioni di normalizzazione sull'input, ad esempio lo svuotamento dello schema e il nome host. Taglia inoltre i periodi finali da ogni segmento di percorso. Quest'ultima caratteristica è fatale per le applicazioni OpenID perché alcuni OpenID (come quelli emessi da Yahoo) includono segmenti di percorso codificati base64 che possono terminare con un punto.

Come disabilitare questo comportamento di taglio periodico della classe Uri?

Registrazione mio sistema utilizzando UriParser.Register con un parser inizializzato con GenericUriParserOptions.DontCompressPath evita il periodo rifilatura, e alcune altre operazioni che sono anche indesiderabile per OpenID. Ma non posso registrare un nuovo parser per schemi esistenti come HTTP e HTTPS, che devo fare per OpenIDs.

Un altro approccio che ho provato era registrando il mio nuovo schema, e la programmazione del parser personalizzato per cambiare lo schema di nuovo alla standard HTTP (s) schemi come parte di analisi:

public class MyUriParser : GenericUriParser 
{ 
    private string actualScheme; 

    public MyUriParser(string actualScheme) 
     : base(GenericUriParserOptions.DontCompressPath) 
    { 
     this.actualScheme = actualScheme.ToLowerInvariant(); 
    } 

    protected override string GetComponents(Uri uri, UriComponents components, UriFormat format) 
    { 
     string result = base.GetComponents(uri, components, format); 

     // Substitute our actual desired scheme in the string if it's in there. 
     if ((components & UriComponents.Scheme) != 0) 
     { 
      string registeredScheme = base.GetComponents(uri, UriComponents.Scheme, format); 
      result = this.actualScheme + result.Substring(registeredScheme.Length); 
     } 

     return result; 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     UriParser.Register(new MyUriParser("http"), "httpx", 80); 
     UriParser.Register(new MyUriParser("https"), "httpsx", 443); 
     Uri z = new Uri("httpsx://me.yahoo.com/b./c.#adf"); 
     var req = (HttpWebRequest)WebRequest.Create(z); 
     req.GetResponse(); 
    } 
} 

Questo in realtà quasi lavori. L'istanza Uri segnala https anziché httpsx ovunque, tranne la proprietà Uri.Scheme stessa. Questo è un problema quando si passa questa istanza Uri allo HttpWebRequest per inviare una richiesta a questo indirizzo. Apparentemente controlla la proprietà Scheme e non la riconosce come 'https' perché invia semplicemente testo in chiaro alla porta 443 anziché SSL.

Sono contento per qualsiasi soluzione che:

1. Conserva punti finali in segmenti di percorso in Uri.Path
2. include questi periodi di richieste HTTP in uscita.
3. Idealmente funziona con il supporto medio ASP.NET (ma non assolutamente necessario).

Answer 1

Microsoft dice che verrà risolto in .NET 4.0 (anche se sembra dai commenti che non è stato ancora fissato)

https://connect.microsoft.com/VisualStudio/feedback/details/386695/system-uri-incorrectly-strips-trailing-dots?wa=wsignin1.0#tabs

C'è una soluzione alternativa su quella pagina, comunque. Implica l'uso della riflessione per modificare le opzioni, quindi potrebbe non soddisfare il requisito di affidabilità medio. Basta scorrere fino in fondo e fare clic sulla scheda "Workaround".

Grazie a jxdavis e Google per questa risposta:

http://social.msdn.microsoft.com/Forums/en-US/netfxbcl/thread/5206beca-071f-485d-a2bd-657d635239c9

Answer 2

Dovresti riuscire a evitare la "." usando '% 2E', ma questa è la via d'uscita poco costosa e sporca.

Si potrebbe provare a giocare con l'opzione dontEscape un po 'e potrebbe cambiare il modo in cui Uri sta trattando quei personaggi.

Maggiori informazioni qui: http://msdn.microsoft.com/en-us/library/system.uri.aspx

Verificate anche i seguenti (vedi DontUnescapePathDotsAndSlashes): http: // msdn.microsoft.com/en-us/library/system.genericuriparseroptions.aspx

Answer 3

Sono curioso di sapere se una parte del problema è che si sta accounting solo per "non comprimere il percorso", invece di tutti i default del parser HTTP di base: (compresi UnEscapeDotsAndSlashes)

private const UriSyntaxFlags HttpSyntaxFlags = (UriSyntaxFlags.AllowIriParsing | UriSyntaxFlags.AllowIdn | UriSyntaxFlags.UnEscapeDotsAndSlashes | UriSyntaxFlags.CanonicalizeAsFilePath | UriSyntaxFlags.CompressPath | UriSyntaxFlags.ConvertPathSlashes | UriSyntaxFlags.PathIsRooted | UriSyntaxFlags.AllowAnInternetHost | UriSyntaxFlags.AllowUncHost | UriSyntaxFlags.MayHaveFragment | UriSyntaxFlags.MayHaveQuery | UriSyntaxFlags.MayHavePath | UriSyntaxFlags.MayHavePort | UriSyntaxFlags.MayHaveUserInfo | UriSyntaxFlags.MustHaveAuthority); 

Questo è in contrasto con la notizia che ha bandiere (per esempio):

private const UriSyntaxFlags NewsSyntaxFlags = (UriSyntaxFlags.AllowIriParsing | UriSyntaxFlags.MayHaveFragment | UriSyntaxFlags.MayHavePath); 

Dang, Brandon Nero mi ha battuto ad esso, mentre stavo lavorando a digitare le cose ...

Questo può aiutare con la leggibilità del codice:

namespace System 
{ 
    [Flags] 
    internal enum UriSyntaxFlags 
    { 
     AllowAnInternetHost = 0xe00, 
     AllowAnyOtherHost = 0x1000, 
     AllowDnsHost = 0x200, 
     AllowDOSPath = 0x100000, 
     AllowEmptyHost = 0x80, 
     AllowIdn = 0x4000000, 
     AllowIPv4Host = 0x400, 
     AllowIPv6Host = 0x800, 
     AllowIriParsing = 0x10000000, 
     AllowUncHost = 0x100, 
     BuiltInSyntax = 0x40000, 
     CanonicalizeAsFilePath = 0x1000000, 
     CompressPath = 0x800000, 
     ConvertPathSlashes = 0x400000, 
     FileLikeUri = 0x2000, 
     MailToLikeUri = 0x4000, 
     MayHaveFragment = 0x40, 
     MayHavePath = 0x10, 
     MayHavePort = 8, 
     MayHaveQuery = 0x20, 
     MayHaveUserInfo = 4, 
     MustHaveAuthority = 1, 
     OptionalAuthority = 2, 
     ParserSchemeOnly = 0x80000, 
     PathIsRooted = 0x200000, 
     SimpleUserSyntax = 0x20000, 
     UnEscapeDotsAndSlashes = 0x2000000, 
     V1_UnknownUri = 0x10000 
    } 
} 

Answer 4

funziona?

public class MyUriParser : UriParser 
{ 
private string actualScheme; 

public MyUriParser(string actualScheme) 
{ 
    Type type = this.GetType(); 
    FieldInfo fInfo = type.BaseType.GetField("m_Flags", BindingFlags.Instance | BindingFlags.NonPublic); 
    fInfo.SetValue(this, GenericUriParserOptions.DontCompressPath); 
    this.actualScheme = actualScheme.ToLowerInvariant(); 
} 

protected override string GetComponents(Uri uri, UriComponents components, UriFormat format) 
{ 
    string result = base.GetComponents(uri, components, format); 

    // Substitute our actual desired scheme in the string if it's in there. 
    if ((components & UriComponents.Scheme) != 0) 
    { 
     string registeredScheme = base.GetComponents(uri, UriComponents.Scheme, format); 
     result = this.actualScheme + result.Substring(registeredScheme.Length); 
    } 

    return result; 
}}