UriTemplate und UriTemplateTableUriTemplate and UriTemplateTable

Webentwickler müssen in der Lage sein, die Form und das Layout der URIs zu beschreiben, auf die ihre Dienste reagieren.Web developers require the ability to describe the shape and layout of the URIs that their services respond to. Windows Communication Foundation (WCF) hinzugefügt, zwei neue Klassen zum Steuern der URIs Entwicklern.Windows Communication Foundation (WCF) added two new classes to give developers control over their URIs. UriTemplate und UriTemplateTable bilden die Grundlage für die URI-basierten dispatchmoduls in WCF.UriTemplate and UriTemplateTable form the basis of the URI-based dispatch engine in WCF. Diese Klassen können auch auf ihre eigenen, sodass Entwickler profitieren von Vorlagen und der URI-abbildungsmechanismus verwendet werden, ohne Sie zu implementieren eines WCF-Diensts.These classes can also be used on their own, allowing developers to take advantage of templates and the URI mapping mechanism without implementing a WCF service.

VorlagenTemplates

Eine Vorlage ist eine Möglichkeit, einen Satz relativer URIs zu beschreiben.A template is a way to describe a set of relative URIs. Der Satz von URI-Vorlagen in der folgenden Tabelle zeigt, wie ein System, das verschiedene Arten von Wetterdaten abruft, definiert werden könnte.The set of URI templates in the following table shows how a system that retrieves various types of weather information might be defined.

DatenData VorlageTemplate
Nationale VorhersageNational Forecast Wetter/nationalweather/national
BundeslandvorhersageState Forecast Wetter/{Staat}weather/{state}
OrtsvorhersageCity Forecast Wetter/{Bundesland}/{Stadt}weather/{state}/{city}
AktivitätsvorhersageActivity Forecast Wetter/{Bundesland}/{Stadt}/{Aktivität}weather/{state}/{city}/{activity}

In dieser Tabelle wird ein Satz strukturell ähnlicher URIs beschrieben.This table describes a set of structurally similar URIs. Jeder Eintrag ist eine URI-Vorlage.Each entry is a URI template. Die Segmente in geschweiften Klammern beschreiben Variablen.The segments in curly braces describe variables. Die Segmente, die nicht in geschweifte Klammern eingefasst sind, beschreiben Literalzeichenfolgen.The segments not in curly braces describe literal strings. Die WCF-Vorlagenklassen ermöglichen dem Entwickler einen eingehenden URI, z. B. "/ Wetter/BW/Mannheim/wechselhaft", und es mit einer Vorlage, die ihn beschreibt abzugleichen "/ Wetter / {Bundesland} / {Stadt} / {Aktivität}".The WCF template classes allow a developer to take an incoming URI, for example, "/weather/wa/seattle/cycling", and match it to a template that describes it, "/weather/{state}/{city}/{activity}".

UriTemplateUriTemplate

UriTemplate ist eine Klasse, die eine URI-Vorlage kapselt.UriTemplate is a class that encapsulates a URI template. Der Konstruktor nimmt einen Zeichenfolgenparameter, der die Vorlage definiert.The constructor takes a string parameter that defines the template. Diese Zeichenfolge enthält die Vorlage in dem im nächsten Abschnitt beschriebenen Format.This string contains the template in the format described in the next section. Die UriTemplate-Klasse bietet Methoden, die die Zuordnung eines eingehenden URI zu einer Vorlage, die Generierung eines URI aus einer Vorlage, das Abrufen einer Sammlung von Variablennamen, die in der Vorlage verwendet werden, die Bestimmung, ob zwei Vorlagen gleichwertig sind, und die Ausgabe der Zeichenfolge der Vorlage ermöglichen.The UriTemplate class provides methods that allow you match an incoming URI to a template, generate a URI from a template, retrieve a collection of variable names used in the template, determine whether two templates are equivalent, and return the template's string.

Match(Uri, Uri) nimmt eine Basisadresse und einen möglichen URI und versucht, den URI der Vorlage zuzuweisen.Match(Uri, Uri) takes a base address and a candidate URI and attempts to match the URI to the template. Wenn die Zuordnung erfolgreich ist, wird eine UriTemplateMatch-Instanz zurückgegeben.If the match is successful, a UriTemplateMatch instance is returned. Das UriTemplateMatch-Objekt enthält einen Basis-URI, den möglichen URI, eine Name-Wert-Sammlung der Abfrageparameter, eine Matrix der Segmente des relativen Pfads, eine Name-Wert-Sammlung der Variablen, die zugeordnet wurden, die UriTemplate-Instanz, die zum Durchführen der Zuordnung verwendet wurde, eine Zeichenfolge, die jeden nicht zugeordneten Teil des Kandidaten-URI enthält (wird verwendet, wenn die Vorlage über einen Platzhalter verfügt), und ein Objekt, das der Vorlage zugewiesen ist.The UriTemplateMatch object contains a base URI, the candidate URI, a name/value collection of the query parameters, an array of the relative path segments, a name/value collection of variables that were matched, the UriTemplate instance used to perform the match, a string that contains any unmatched portion of the candidate URI (used when the template has a wildcard), and an object that is associated with the template.

Hinweis

Beim Vergleichen eines möglichen URIs mit einer Vorlage ignoriert die UriTemplate-Klasse das Schema und die Portnummer.The UriTemplate class ignores the scheme and port number when matching a candidate URI to a template.

Zum Generieren eines URI aus einer Vorlage stehen zwei Methoden zur Verfügung: BindByName(Uri, NameValueCollection) und BindByPosition(Uri, String[]).There are two methods that allow you to generate a URI from a template, BindByName(Uri, NameValueCollection) and BindByPosition(Uri, String[]). BindByName(Uri, NameValueCollection) akzeptiert eine Basisadresse und eine Name-Wert-Auflistung der Parameter.BindByName(Uri, NameValueCollection) takes a base address and a name/value collection of parameters. Wenn die Vorlage gebunden ist, werden diese Parameter durch Variablen ersetzt.These parameters are substituted for variables when the template is bound. BindByPosition(Uri, String[]) akzeptiert die Name-Wert-Paare und ersetzt sie von links nach rechts.BindByPosition(Uri, String[]) takes the name/value pairs and substitutes them left to right.

ToString() gibt die Vorlagenzeichenfolge zurück,ToString() returns the template string.

Die PathSegmentVariableNames-Eigenschaft enthält eine Sammlung der Namen der Variablen, die innerhalb der Pfadsegmente in der Vorlagenzeichenfolge verwendet werden.The PathSegmentVariableNames property contains a collection of the names of the variables used within path segments in the template string.

IsEquivalentTo(UriTemplate) akzeptiert UriTemplate als Parameter und gibt einen booleschen Wert zurück, der angibt, ob die beiden Vorlagen gleichwertig sind.IsEquivalentTo(UriTemplate) takes a UriTemplate as a parameter and returns a Boolean value that specifies whether the two templates are equivalent. Weitere Informationen finden Sie unter dem Abschnitt "Vorlagenäquivalenz" weiter unten in diesem Thema.For more information, see the Template Equivalence section later in this topic.

UriTemplate wurde für die Zusammenarbeit mit einem URI-Schema entwickelt, das der HTTP URI-Grammatik entspricht.UriTemplate is designed to work with any URI scheme that conforms to the HTTP URI grammar. Im Folgenden finden Sie Beispiele für unterstützte URI-Schemas:The following are examples of supported URI schemes.

  • http://http://

  • https://https://

  • net.tcp://net.tcp://

  • net.pipe://net.pipe://

  • sb://sb://

Schemas wie "file://" und "urn://" entsprechen nicht der HTTP-URI-Grammatik und führen bei der Verwendung mit URI-Vorlagen zu unvorhersehbaren Ergebnissen.Schemes like file:// and urn:// do not conform to the HTTP URI grammar and cause unpredictable results when used with URI templates.

Vorlagenzeichenfolgen-SyntaxTemplate String Syntax

Eine Vorlage besteht aus drei Teilen: einem Pfad, einer optionalen Abfrage und einem optionalen Fragment.A template has three parts: a path, an optional query, and an optional fragment. Ein Beispiel finden Sie in der folgenden Vorlage:For an example, see the following template:

"/weather/{state}/{city}?forecast={length)#frag1  

Der Pfad besteht aus "/Wetter/{Bundesland}/{Ort}", die Abfrage besteht aus "?forecast={Länge}, und das Fragment besteht aus "#frag1."The path consists of "/weather/{state}/{city}", the query consists of "?forecast={length}, and the fragment consists of "#frag1".

Führende und nachstehende Schrägstriche sind im Pfadausdruck optional.Leading and trailing slashes are optional in the path expression. Sowohl der Abfrage- als auch der Fragmentausdruck kann vollständig weggelassen werden.Both the query and fragment expressions can be omitted entirely. Ein Pfad besteht aus einer Reihe von Segmenten, getrennt durch "/"; jedes Segment kann über einen Literalwert, einen Variablennamen (Schreiben in {geschweiften Klammern}) oder einen Platzhalter verfügen (geschrieben als*").A path consists of a series of segments delimited by '/', each segment can have a literal value, a variable name (written in {curly braces}), or a wildcard (written as '*'). In der vorherigen Vorlage ist das "\Wetter"-Segment ein Literalwert, während "{Bundesland}" und "{Ort}" Variablen sind.In the previous template the "\weather\ segment is a literal value while "{state}" and "{city}" are variables. Variablen erhalten ihren Namen aus den Inhalten der geschweiften Klammern und sie können später ersetzt durch einen bestimmten Wert zum Erstellen einer geschlossenen URI.Variables take their name from the contents of their curly braces and they can later be replaced with a concrete value to create a closed URI. Der Platzhalter kann ist optional, aber nur am Ende des URIS, wo er logisch "den Rest des Pfads" entspricht.The wildcard is optional, but can only appear at the end of the URI, where it logically matches "the rest of the path".

Der Abfrageausdruck gibt ggf. eine Reihe ungeordneter Name-Wert-Paare an, die durch "&" getrennt werden.The query expression, if present, specifies a series of unordered name/value pairs delimited by '&'. Bei den Elementen des Abfrageausdrucks kann es sich entweder um Literalpaare (x=2) oder ein Variablenpaar (x={var}) handeln.Elements of the query expression can either be literal pairs (x=2) or a variable pair (x={var}). Nur die rechte Seite der Abfrage kann einen variablen Ausdruck enthalten.Only the right side of the query can have a variable expression. ({someName} = {someValue} ist nicht zulässig.({someName} = {someValue} is not allowed. Ungepaarte Werte (?x) sind nicht zulässig.Unpaired values (?x) are not permitted. Es besteht kein Unterschied zwischen einem leeren Abfrageausdruck und einem Abfrageausdruck, der aus einem einzelnen "?" besteht (beide stehen für "jede Abfrage").There is no difference between an empty query expression and a query expression consisting of just a single '?' (both mean "any query").

Der Fragmentausdruck kann aus einem Literalwert bestehen, Variablen sind nicht zulässig.The fragment expression can consist of a literal value, no variables are allowed.

Alle Vorlagenvariablennamen innerhalb einer Vorlagenzeichenfolge müssen eindeutig sein.All template variable names within a template string must be unique. Bei Namen von Vorlagenvariablen wird die Groß- und Kleinschreibung nicht berücksichtigt.Template variable names are case-insensitive.

Beispiele für gültige Vorlagenzeichenfolgen:Examples of valid template strings:

  • """"

  • "/Schuh""/shoe"

  • "/Schuh/*""/shoe/*"

  • "{Schuh}/Boot""{shoe}/boat"

  • "{Schuh} / {Bereitschaftsboots /bed/ {Quilt}}""{shoe}/{boat}/bed/{quilt}"

  • "Schuh / {Bereitschaftsboots}""shoe/{boat}"

  • "Schuh / {Bereitschaftsboots} / *""shoe/{boat}/*"

  • "Schuh Boot /? X = 2""shoe/boat?x=2"

  • "Schuh / {Bereitschaftsboots}? x = {Bett}""shoe/{boat}?x={bed}"

  • "Schuh/{Boot}?x={Bett}&y=band""shoe/{boat}?x={bed}&y=band"

  • "? x = {Schuh}""?x={shoe}"

  • "Schuh?x=3&y={var}"shoe?x=3&y={var}

Beispiele für ungültige Vorlagenzeichenfolgen sind:Examples of invalid template strings:

  • "{Schuh} / {SCHUH} / x = 2" – doppelte Variablennamen."{shoe}/{SHOE}/x=2" – Duplicate variable names.

  • "{Schuh} Bett? Bett = {Schuh}" – doppelte Variablennamen."{shoe}/boat/?bed={shoe}" – Duplicate variable names.

  • "? X = 2 & X = 3" – Name/Wert-Paare innerhalb einer Abfragezeichenfolge müssen eindeutig sein, auch wenn sie Literale sind."?x=2&x=3" – Name/value pairs within a query string must be unique, even if they are literals.

  • "? X = 2 &" – Abfragezeichenfolge ist fehlerhaft."?x=2&" – Query string is malformed.

  • "? 2 & x = {Schuh}" – Abfragezeichenfolge muss Name/Wert-Paaren sein."?2&x={shoe}" – Query string must be name/value pairs.

  • "? y = 2 & & X = 3" – Abfragezeichenfolge muss Name-Wert-Paare, dürfen nicht mit beginnen "&"."?y=2&&X=3" – Query string must be name value pairs, names cannot start with '&'.

Zusammengesetzte PfadsegmenteCompound Path Segments

Bei zusammengesetzten Pfadsegmenten kann ein einzelnes URI-Pfadsegment mehrere Variablen sowie mit Literalwerten kombinierte Variablen enhalten.Compound path segments allow a single URI path segment to contain multiple variables as well as variables combined with literals. Im Folgenden finden Sie Beispiele für gültige zusammengesetzte Pfadsegmente:The following are examples of valid compound path segments.

  • /Dateiname.{Erw.}//filename.{ext}/

  • /{Dateiname}.jpg//{filename}.jpg/

  • /{Dateiname}.{Erw.}//{filename}.{ext}/

  • /{a}.{b}Literalwert{c}({d})//{a}.{b}someLiteral{c}({d})/

Im Folgenden finden Sie Beispiele für ungültige Pfadsegmente:The following are examples of invalid path segments.

  • /{} -Variablen müssen benannt sein./{} - Variables must be named.

  • /{Schuh}{Boot} – Variablen müssen durch einen Literalwert getrennt werden./{shoe}{boat} - Variables must be separated by a literal.

Zuordnung und zusammengesetzte PfadsegmenteMatching and Compound Path Segments

Zusammengesetzte Pfadsegmente ermöglichen Ihnen das Definieren einer UriTemplate mit mehreren Variablen in nur einem Pfadsegment.Compound path segments allow you to define a UriTemplate that has multiple variables within a single path segment. Beispielsweise ist in der Vorlagenzeichenfolge: "Adressen / {State}. {City} "sind zwei Variablen (State und City) in demselben Segment definiert.For example, in the following template string: "Addresses/{state}.{city}" two variables (state and city) are defined within the same segment. Diese Vorlage würde eine URL entsprechen, z. B. "http://example.com/Washington.Redmond"aber wird auch eine URL wie"http://example.com/Washington.Redmond.Microsoft".This template would match a URL such as "http://example.com/Washington.Redmond" but it will also match an URL like "http://example.com/Washington.Redmond.Microsoft". In letzterem Fall enthält die State-Variable "Washington" und die City-Variable "Redmond.Microsoft".In the latter case, the state variable will contain "Washington" and the city variable will contain "Redmond.Microsoft". In diesem Fall entspricht jeder Text (mit Ausnahme von "/") der {city}-Variable.In this case any text (except ‘/’) will match the {city} variable. Wenn Sie eine Vorlage erstellen möchten, die die "zusätzlichen" Text nicht zugeordnet wird, fügen Sie die Variable in einem separaten Vorlagensegment ein, z. B.: "Adressen / {Bundesland} / {Stadt}.If you want a template that will not match the "extra" text, place the variable in a separate template segment, for example: "Addresses/{state}/{city}.

Benannte PlatzhaltersegmenteNamed Wildcard Segments

Bei einem benannten Platzhaltersegment handelt es sich um ein beliebiges Pfadvariablensegment, dessen Variablenname mit dem Platzhalterzeichen "*" beginnt.A named wildcard segment is any path variable segment whose variable name begins with the wildcard character ‘*’. Die folgende Vorlagenzeichenfolge enthält ein benanntes Platzhaltersegment mit dem Namen "Schuh".The following template string contains a named wildcard segment named "shoe".

"literal/{*shoe}"  

Für Platzhaltersegmente gelten die folgenden Regeln:Wildcard segments must follow the following rules:

  • Für jede Vorlagenzeichenfolge kann höchstens ein benanntes Platzhaltersegment vorhanden sein.There can be at most one named wildcard segment for each template string.

  • Ein benanntes Platzhaltersegment muss sich im am weitesten rechts stehenden Segment des Pfads befinden.A named wildcard segment must appear at the right-most segment in the path.

  • Ein benanntes Platzhaltersegment kann nicht zusammen mit einem anonymen Platzhaltersegment innerhalb der gleichen Vorlagenzeichenfolge verwendet werden.A named wildcard segment cannot coexist with an anonymous wildcard segment within the same template string.

  • Der Name eines benannten Platzhaltersegments muss eindeutig sein.The name of a named wildcard segment must be unique.

  • Benannte Platzhaltersegmente können keine Standardwerte besitzen.Named wildcard segments cannot have default values.

  • Benannte platzhaltersegmente darf nicht mit enden "/".Named wildcard segments cannot end with "/".

StandardvariablenwerteDefault Variable Values

Standardvariablenwerte ermöglichen das Angeben von Standardwerten für Variablen innerhalb einer Vorlage.Default variable values allow you to specify default values for variables within a template. Standardvariablen können mit den geschweiften Klammern, durch die die Variable deklariert wird, oder durch eine an den UriTemplate-Konstruktor weitergegebene Sammlung angegeben werden.Default variables can be specified with the curly braces that declare the variable or as a collection passed to the UriTemplate constructor. Die folgende Vorlage zeigt zwei Möglichkeiten, eine UriTemplate mit Variablen mit Standardwerten anzugeben:The following template shows two ways to specify a UriTemplate with variables with default values.

UriTemplate t = new UriTemplate("/test/{a=1}/{b=5}");  

In dieser Vorlage werden die Variable a mit dem Standardwert 1 und die Variable b mit dem Standardwert 5 deklariert.This template declares a variable named a with a default value of 1 and a variable named b with a default value of 5.

Hinweis

Nur Pfadsegmentvariablen können Standardwerte besitzen.Only path segment variables are allowed to have default values. Bei Abfragezeichenfolgenvariablen, zusammengesetzten Segmentvariablen sowie bei benannten Platzhaltervariablen sind Standardwerte nicht zulässig.Query string variables, compound segment variables, and named wildcard variables are not permitted to have default values.

Im folgenden Code wird die Behandlung von Standardvariablenwerten beim Abgleichen eines möglichen URI gezeigt:The following code shows how default variable values are handled when matching a candidate URI.

Uri baseAddress = new Uri("http://localhost:800   
Dictionary<string,string> defVals = new Dictionary<string,string> {{"a","1"}, {"b", "5"}};  
UriTemplate t = new UriTemplate("/test/{a}/{b}", defVals);0");  
UriTemplate t = new UriTemplate("/{state=WA}/{city=Redmond}/", true);  
Uri candidate = new Uri("http://localhost:8000/OR");  

UriTemplateMatch m1 = t.Match(baseAddress, candidate);  

// Display contents of BoundVariables  
foreach (string key in m1.BoundVariables.AllKeys)  
{  
    Console.WriteLine("\t\t{0}={1}", key, m1.BoundVariables[key]);  
}  
// The output of the above code is  
// Template: /{state=WA}/{city=Redmond}/  
// Candidate URI: http://localhost:8000/OR  
// BoundVariables:  
//      STATE=OR  
//       CITY=Redmond  

Hinweis

Ein URI, z. B. http://localhost:8000/// entspricht nicht die Vorlage, die im vorangehenden Code aufgeführt sind, jedoch einen URI wie z. B. http://localhost:8000/ ist.A URI such as http://localhost:8000/// does not match the template listed in the preceding code, however a URI such as http://localhost:8000/ does.

Im folgenden Code wird die Behandlung von Standardvariablenwerten beim Erstellen eines URI mit einer Vorlage veranschaulicht:The following code shows how default variable values are handled when creating a URI with a template.

Uri baseAddress = new Uri("http://localhost:8000/");  
Dictionary<string,string> defVals = new Dictionary<string,string> {{"a","1"}, {"b", "5"}};  
UriTemplate t = new UriTemplate("/test/{a}/{b}", defVals);  
NameValueCollection vals = new NameValueCollection();  
vals.Add("a", "10");  

Uri boundUri = t.BindByName(baseAddress, vals);  
Console.WriteLine("BaseAddress: {0}", baseAddress);  
Console.WriteLine("Template: {0}", t.ToString());  

Console.WriteLine("Values: ");  
foreach (string key in vals.AllKeys)  
{  
    Console.WriteLine("\tKey = {0}, Value = {1}", key, vals[key]);  
}  
Console.WriteLine("Bound URI: {0}", boundUri);  

// The output of the preceding code is  
// BaseAddress: http://localhost:8000/  
// Template: /test/{a}/{b}  
// Values:  
//     Key = a, Value = 10  
// Bound URI: http://localhost:8000/test/10/5  

Erhält eine Variable den Standardwert null, gelten einige zusätzliche Einschränkungen.When a variable is given a default value of null there are some additional constraints. Eine Variable kann den Standardwert null besitzen, wenn sich die Variable im am weitesten rechts befindlichen Segment der Vorlagenzeichenfolge befindet oder wenn alle Segmente rechts des Segments jeweils den Standardwert null besitzen.A variable can have a default value of null if the variable is contained within the right most segment of the template string or if all segments to the right of the segment have default values of null. Im Folgenden finden Sie gültige Vorlagenzeichenfolgen mit dem Standardwert null:The following are valid template strings with default values of null:

  • UriTemplate t = new UriTemplate("shoe/{boat=null}");  
    
  • UriTemplate t = new UriTemplate("{shoe=null}/{boat=null}");  
    
  • UriTemplate t = new UriTemplate("{shoe=1}/{boat=null}");  
    

    Im Folgenden finden Sie ungültige Vorlagenzeichenfolgen mit dem Standardwert null:The following are invalid template strings with default values of null:

  • UriTemplate t = new UriTemplate("{shoe=null}/boat"); // null default must be in the right most path segment  
    
  • UriTemplate t = new UriTemplate("{shoe=null}/{boat=x}/{bed=null}"); // shoe cannot have a null default because boat does not have a default null value  
    

Standardwerte und VergleichDefault Values and Matching

Beim Vergleichen eines möglichen URI mit einer Vorlage mit Standardwerten werden die Standardwerte in der BoundVariables-Sammlung platziert, wenn im möglichen URI keine Werte angegeben sind.When matching a candidate URI with a template that has default values, the default values are placed in the BoundVariables collection if values are not specified in the candidate URI.

VorlagenäquivalenzTemplate Equivalence

Zwei Vorlagen gelten als strukturell Äquivalent Wenn alle Literalwerte der Vorlagen übereinstimmen und sie die Variablen in den gleichen Segmenten verfügen.Two templates are said to be structurally equivalent when all of the templates' literals match and they have variables in the same segments. Beispielsweise sind die folgenden Vorlagen strukturell äquivalent:For example the following templates are structurally equivalent:

  • /a/{var1}/b b/{var2}?x=1&y=2/a/{var1}/b b/{var2}?x=1&y=2

  • a/{x}/b%20b/{var1}?y=2&x=1a/{x}/b%20b/{var1}?y=2&x=1

  • a/{y}/B%20B/{z}/?y=2&x=1a/{y}/B%20B/{z}/?y=2&x=1

Hierbei müssen noch einige Punkte beachtet werden:A few things to notice:

  • Wenn eine Vorlage führende Schrägstriche enthält, wird nur der erste ignoriert.If a template contains leading slashes, only the first one is ignored.

  • Wenn Vorlagenzeichenfolgen auf strukturelle Äquivalenz verglichen werden, wird die Groß-/Kleinschreibungen bei den Variablennamen und Pfadsegmenten ignoriert; bei den Abfragezeichenfolgen muss sie beachtet werden.When comparing template strings for structural equivalence, case is ignored for variable names and path segments, query strings are case sensitive.

  • Abfragezeichenfolgen sind unsortiert.Query strings are unordered.

UriTemplateTableUriTemplateTable

Die Klasse UriTemplateTable stellt eine assoziative Tabelle aus UriTemplate-Objekten dar, die an ein Objekt nach Wahl des Entwicklers gebunden sind.The UriTemplateTable class represents an associative table of UriTemplate objects bound to an object of the developer's choosing. UriTemplateTable muss vor Aufruf von UriTemplate mindestens eine MakeReadOnly(Boolean) enthalten.A UriTemplateTable must contain at least one UriTemplate prior to calling MakeReadOnly(Boolean). Der Inhalt einer UriTemplateTable kann geändert werden, bis MakeReadOnly(Boolean) aufgerufen wird.The contents of a UriTemplateTable can be changed until MakeReadOnly(Boolean) is called. Die Überprüfung wird ausgeführt, wenn MakeReadOnly(Boolean) aufgerufen wird.Validation is performed when MakeReadOnly(Boolean) is called. Der Typ der ausgeführten Prüfung hängt vom Wert des Parameters allowMultiple zur MakeReadOnly(Boolean) ab.The type of validation performed depends upon the value of the allowMultiple parameter to MakeReadOnly(Boolean).

Wenn MakeReadOnly(Boolean) bei Übergabe in false aufgerufen wird, überprüft die UriTemplateTable, dass sich keine Vorlagen in der Tabelle befinden.When MakeReadOnly(Boolean) is called passing in false, the UriTemplateTable checks to make sure there are no templates in the table. Wenn strukturell äquivalente Vorlagen gefunden werden, wird eine Ausnahme ausgelöst.If it finds any structurally equivalent templates, it throws an exception. Dies wird zusammen mit MatchSingle(Uri) verwendet, wenn sichergestellt werden soll, dass nur eine Vorlage einem eingehenden URI entspricht.This is used in conjunction with MatchSingle(Uri) when you want to ensure only one template matches an incoming URI.

Wenn MakeReadOnly(Boolean) bei der Übergabe von true aufgerufen wird, lässt UriTemplateTable mehrere strukturell äquivalente Vorlagen in einer UriTemplateTable zu.When MakeReadOnly(Boolean) is called passing in true, UriTemplateTable allows multiple, structurally-equivalent templates to be contained within a UriTemplateTable.

Wenn ein Satz UriTemplate-Objekte, die einer UriTemplateTable hinzugefügt sind, Abfragezeichenfolgen enthält, dürfen sie nicht mehrdeutig sein.If a set of UriTemplate objects added to a UriTemplateTable contain query strings they must not be ambiguous. Identische Abfragezeichenfolgen sind zulässig.Identical query strings are allowed.

Hinweis

Zwar lässt die UriTemplateTable Basisadressen mit HTTP-fremden Schemas zu, Schema und Portnummer werden beim Vergleichen möglicher URIs mit Vorlagen jedoch ignoriert.While the UriTemplateTable allows base addresses that use schemes other than HTTP, the scheme and port number are ignored when matching candidate URIs to templates.

AbfragezeichenfolgenmehrdeutigkeitQuery String Ambiguity

Vorlagen, die einen äquivalenten Pfad teilen, enthalten mehrdeutige Abfragezeichenfolgen, wenn es einen URI gibt, der mehr als einer Vorlage entspricht.Templates that share an equivalent path contain ambiguous query strings if there is a URI that matches more than one template.

Die folgenden Sätze von Abfragezeichenfolgen sind in sich selbst eindeutig:The following sets of query strings are unambiguous within themselves:

  • ?x=1?x=1

  • ?x=2?x=2

  • ?x=3?x=3

  • ?x=1&y={var}?x=1&y={var}

  • ?x=2&z={var}?x=2&z={var}

  • ?x=3?x=3

  • ?x=1?x=1

  • ??

  • ?? x={var}x={var}

  • ??

  • ?m=get&c=rss?m=get&c=rss

  • ?m=put&c=rss?m=put&c=rss

  • ?m=get&c=atom?m=get&c=atom

  • ?m=put&c=atom?m=put&c=atom

Die folgenden Abfragezeichenfolgenvorlagen sind in sich selbst mehrdeutig:The following sets of query string templates are ambiguous within themselves:

  • ?x=1?x=1

  • ?x={var}?x={var}

"x=1" – passt zu beiden Vorlagen."x=1" - Matches both templates.

  • ?x=1?x=1

  • ?y=2?y=2

"x=1&y=2" passt zu beiden Vorlagen."x=1&y=2" matches both templates. Das liegt daran, dass eine Abfragezeichenfolge mehr Abfragezeichenfolgen-Variablen enthalten kann als die Vorlage, zu der sie passt.This is because a query string may contain more query string variables then the template it matches.

  • ?x=1?x=1

  • ?x=1&y={var}?x=1&y={var}

"x=1&y=3" passt zu beiden Vorlagen."x=1&y=3" matches both templates.

  • ?x=3&y=4?x=3&y=4

  • ?x=3&z=5?x=3&z=5

Hinweis

Die Zeichen "á" und "Á" gelten als unterschiedliche Zeichen, wenn sie als Teil eines URI-Pfads oder eines UriTemplate-Pfadsegmentliterals verwendet werden. (Die Zeichen "a" und "A" gelten hingegen als gleich.)The characters á and Á are considered to be different characters when they appear as part of a URI path or UriTemplate path segment literal (but the characters a and A are considered to be the same). Die Zeichen á und Á gelten als gleiche Zeichen, wenn sie als Teil einer UriTemplate {Variablenname} oder einer Abfragezeichenfolge erscheinen (a und A gelten ebenfalls als gleiche Zeichen).The characters á and Á are considered to be the same characters when they appear as part of a UriTemplate {variableName} or a query string (and a and A are also considered to be the same characters).

Siehe auchSee Also

Überblick über das WCF-Web-HTTP-ProgrammiermodellWCF Web HTTP Programming Model Overview
Objektmodell für WCF-Web-HTTP-ProgrammierungWCF Web HTTP Programming Object Model
UriTemplateUriTemplate
UriTemplate-TabelleUriTemplate Table
UriTemplate-TabellenverteilerUriTemplate Table Dispatcher