  | 
                    הביטוי חייב להיות ניתן לכתיבה | 
                
                
                      | 
                    Expressie moet schrijfbaar zijn. | 
                
                
                      | 
                    A kifejezésnek írhatónak kell lennie. | 
                
                
                      | 
                    Lausekkeen on oltava kirjoitettavissa | 
                
                
                      | 
                    İfade yazılabilir olmalıdır | 
                
                
                      | 
                    表达式必须可写。 | 
                
                
                      | 
                    Выражение должно быть доступно для записи. | 
                
                
                      | 
                    L'espressione deve essere scrivibile | 
                
                
                      | 
                    Expression must be writeable | 
                
                
                      | 
                    يجب أن يكون التعبير قابلاً للكتابة. | 
                
                
                      | 
                    式は書き込み可能でなければなりません | 
                
                
                      | 
                    Der Ausdruck muss schreibbar sein. | 
                
                
                      | 
                    식은 쓸 수 있어야 합니다. | 
                
                
                      | 
                    Výraz musí být zapisovatelný. | 
                
                
                      | 
                    Η παράσταση πρέπει να έχει δυνατότητα εγγραφής | 
                
                
                      | 
                    La expresión debe ser grabable | 
                
                
                      | 
                    Der skal kunne skrives til udtrykket | 
                
                
                      | 
                    運算式必須為可寫入 | 
                
                
                      | 
                    Wyrażenie musi być możliwe do zapisu | 
                
                
                      | 
                    Uttrykk må kunne skrives | 
                
                
                      | 
                    Uttrycket måste vara skrivbart | 
                
                
                      | 
                    A expressão deve ser gravável | 
                
                
                      | 
                    שדה המופע '<var>X</var>' אינו מוגדר עבור הסוג '<var>Type Name</var>' | 
                
                
                      | 
                    Exemplaarveld <var>X</var> is niet gedefinieerd voor type <var>Type Name</var> | 
                
                
                      | 
                    A(z) „<var>X</var>” példánymező nincs definiálva a következő típushoz: „<var>Type Name</var>”. | 
                
                
                      | 
                    Esiintymäkenttää <var>X</var> ei ole määritetty tyypille <var>Type Name</var> | 
                
                
                      | 
                    '<var>Type Name</var>' türü için '<var>X</var>' örnek alanı tanımlanmadı | 
                
                
                      | 
                    没有为类型“<var>Type Name</var>”定义实例字段“<var>X</var>” | 
                
                
                      | 
                    Поле экземпляра "<var>X</var>" не определено для типа "<var>Type Name</var>" | 
                
                
                      | 
                    Instance field '<var>X</var>' is not defined for type '<var>Type Name</var>' | 
                
                
                      | 
                    حقل المثيلة '<var>X</var>' غير مُحدد للنوع '<var>Type Name</var>'. | 
                
                
                      | 
                    インスタンス フィールド '<var>X</var>' は、型 '<var>Type Name</var>' に対して定義されていません | 
                
                
                      | 
                    Das Instanzfeld "<var>X</var>" ist nicht für Typ "<var>Type Name</var>" definiert. | 
                
                
                      | 
                    Il campo dell'istanza '<var>X</var>' non è definito per il tipo '<var>Type Name</var>' | 
                
                
                      | 
                    인스턴스 필드 '<var>X</var>'이(가) '<var>Type Name</var>' 형식에 대해 정의되지 않았습니다. | 
                
                
                      | 
                    Pole instance <var>X</var> není definováno pro typ <var>Type Name</var>. | 
                
                
                      | 
                    Το πεδίο παρουσίας '<var>X</var>' δεν έχει οριστεί για τον τύπο '<var>Type Name</var>' | 
                
                
                      | 
                    El campo de instancia '<var>X</var>' no se ha definido para el tipo '<var>Type Name</var>' | 
                
                
                      | 
                    Forekomstfeltet '<var>X</var>' er ikke defineret for typen '<var>Type Name</var>' | 
                
                
                      | 
                    未對型別 '<var>Type Name</var>' 定義執行個體欄位 '<var>X</var>' | 
                
                
                      | 
                    Nie zdefiniowano pola wystąpienia „<var>X</var>” dla typu „<var>Type Name</var>” | 
                
                
                      | 
                    Forekomstfeltet <var>X</var> er ikke angitt for typen <var>Type Name</var> | 
                
                
                      | 
                    Instansfältet <var>X</var> har inte definierats för typen <var>Type Name</var> | 
                
                
                      | 
                    O campo de instância '<var>X</var>' não está definido para o tipo '<var>Type Name</var>' | 
                
                
                      | 
                    סוג המאפיין חייב להתאים לסוג הערך של הרכיב המגדיר | 
                
                
                      | 
                    Eigenschapstype moet overeenkomen met het waardetype van de setter | 
                
                
                      | 
                    A tulajdonság típusának meg kell egyeznie a beállító értéktípusával. | 
                
                
                      | 
                    Ominaisuuden tyypin on vastattava setter-kohteen arvotyyppiä | 
                
                
                      | 
                    Özellik türü, ayarlayıcının değer türüyle eşleşmelidir | 
                
                
                      | 
                    属性类型必须与 setter 的值类型匹配 | 
                
                
                      | 
                    Тип свойства должен совпадать с типом значения метода set | 
                
                
                      | 
                    Il tipo di proprietà deve corrispondere al tipo di valore della funzione Set | 
                
                
                      | 
                    Property type must match the value type of setter | 
                
                
                      | 
                    يجب أن يطابق نوع الخاصية  نوع القيمة setter | 
                
                
                      | 
                    プロパティの型は setter の値の型と一致する必要があります | 
                
                
                      | 
                    Der Eigenschaftstyp muss mit dem Werttyp des Setters übereinstimmen. | 
                
                
                      | 
                    속성 형식은 setter의 값 형식과 일치해야 합니다. | 
                
                
                      | 
                    Typ vlastnosti se musí shodovat s typem hodnoty metody setter. | 
                
                
                      | 
                    Ο τύπος ιδιότητας πρέπει να αντιστοιχεί στον τύπο τιμής της μεθόδου setter | 
                
                
                      | 
                    El tipo de propiedad debe coincidir con el tipo de valor del establecedor | 
                
                
                      | 
                    Egenskabstypen skal svare til værditypen for indstillingen (setter) | 
                
                
                      | 
                    屬性型別必須與 setter 的實值型別相符 | 
                
                
                      | 
                    Typ właściwości musi odpowiadać typowi wartości metody ustawiającej | 
                
                
                      | 
                    Egenskaptypen må stemme med verditypen for setteren | 
                
                
                      | 
                    Egenskapstypen måste matcha värdetypen för setter | 
                
                
                      | 
                    O tipo da propriedade deve corresponder ao tipo de valor de setter | 
                
                
                      | 
                    TryExpression אינו נתמך כארגומנט לפעולת השירות '<var>Method name</var>' מאחר שיש לו ארגומנט עם סוג by-ref. בנה את העץ כך ש- TryExpression אינו מקונן בתוך ביטוי זה. | 
                
                
                      | 
                    TryExpression wordt niet ondersteund als argument voor methode <var>Method name</var>, aangezien deze een argument met by-ref-type bevat. Maak de structuur zo dat de TryExpression niet is genest binnen deze expressie. | 
                
                
                      | 
                    A TryExpression nem támogatott a következő metódus argumentumaként, mert by-ref típusú argumentumot tartalmaz: „<var>Method name</var>”. Úgy hozza létre a fát, hogy a TryExpression ne legyen beágyazva ebbe a kifejezésbe. | 
                
                
                      | 
                    TryExpression-kohdetta ei tueta menetelmän <var>Method name</var> argumenttina, koska sillä on tyyppiä by-ref oleva argumentti. Muodosta puu niin, että TryExpression ei ole tämän lausekkeen sisällä. | 
                
                
                      | 
                    TryExpression, '<var>Method name</var>' yöntemi için bağımsız değişken olarak desteklenmiyor, çünkü byref türünde bir bağımsız değişkeni var. Ağacı, TryExpression bu ifadenin içinde yer almayacak şekilde oluşturun. | 
                
                
                      | 
                    不支持 TryExpression 作为方法“<var>Method name</var>”的参数,因为它具有一个 ByRef 类型的参数。请构造树,以使得不在此表达式内部嵌套 TryExpression。 | 
                
                
                      | 
                    TryExpression не поддерживается в качестве аргумента для метода "<var>Method name</var>", поскольку он имеет аргумент с типом ByRef. Постройте дерево таким образом, чтобы TryExpression не было вложено в это выражение. | 
                
                
                      | 
                    TryExpression non supportata come argomento per il metodo '<var>Method name</var>' perché contiene un argomento di tipo byref. Costruire la struttura ad albero in modo che TryExpression non sia annidata all'interno di questa espressione. | 
                
                
                      | 
                    TryExpression is not supported as an argument to method '<var>Method name</var>' because it has an argument with by-ref type. Construct the tree so the TryExpression is not nested inside of this expression. | 
                
                
                      | 
                    TryExpression غير معتمد كوسيطة للأسلوب '<var>Method name</var>' لأنه يحتوي على وسيطة من النوع by-ref. قم بإنشاء الشجرة بحيث لا يتداخل TryExpression في هذا التعبير. | 
                
                
                      | 
                    by-ref 型の引数を持つため、TryExpression はメソッド '<var>Method name</var>' への引数としてはサポートされていません。TryExpression がこの式の内部で入れ子にならないようにツリーを構築してください。 | 
                
                
                      | 
                    TryExpression wird als Argument für die Methode "<var>Method name</var>" nicht unterstützt, da er ein Argument vom Typ "by-ref" aufweist. Erstellen Sie die Struktur so, dass TryExpression nicht innerhalb dieses Ausdrucks geschachtelt ist. | 
                
                
                      | 
                    TryExpression은 by-ref 형식의 인수를 가지므로 '<var>Method name</var>' 메서드에 대한 인수로 지원되지 않습니다. TryExpression이 이 식 내에서 중첩되지 않도록 트리를 만드십시오. | 
                
                
                      | 
                    Objekt TryExpression není podporován jako argument pro metodu <var>Method name</var>, protože obsahuje argument s typem by-ref. Vytvořte strom tak, aby objekt TryExpression nebyl vnořen v tomto výrazu. | 
                
                
                      | 
                    Το TryExpression δεν υποστηρίζεται ως όρισμα για τη μέθοδο '<var>Method name</var>' γιατί διαθέτει όρισμα με τύπο by-ref. Δομήστε το δέντρο ώστε το TryExpression να μην είναι ένθετο εντός αυτής της παράστασης. | 
                
                
                      | 
                    TryExpression no se admite como argumento del método '<var>Method name</var>' porque tiene un argumento del tipo by-ref. Construya el árbol de forma que TryExpression no se anide en esta expresión. | 
                
                
                      | 
                    TryExpression understøttes ikke som et argument for metoden '<var>Method name</var>', fordi det har et argument af typen by-ref. Konstruer træet, så dette TryExpression ikke indlejres inden i dette udtryk. | 
                
                
                      | 
                    不支援以 TryExpression 當做方法 '<var>Method name</var>' 的引數,因為它有 by-ref 型別的引數。請將樹狀結構建構成不要讓 TryExpression 以巢狀方式位於此運算式之內。 | 
                
                
                      | 
                    Wyrażenie TryExpression jest nieobsługiwane jako argument metody „<var>Method name</var>”, ponieważ zawiera argument z typem by-ref. Skonstruuj drzewo tak, aby wyrażenie TryExpression nie było zagnieżdżone wewnątrz tego wyrażenia. | 
                
                
                      | 
                    TryExpression støttes ikke som et argument til metoden <var>Method name</var> fordi den har et argument av typen by-ref. Konstruer treet slik at TryExpression ikke er nestet inne i dette uttrykket. | 
                
                
                      | 
                    TryExpression stöds inte som argument för metoden <var>Method name</var> eftersom det innehåller ett argument av typen by-ref. Konstruera trädet så att aktuellt TryExpression inte kapslas inuti det här uttrycket. | 
                
                
                      | 
                    Não há suporte para TryExpression como um argumento do método '<var>Method name</var>', pois ele tem um argumento de tipo by-ref. Construa a árvore de forma que TryExpression não esteja aninhado nessa expressão. | 
                
                
                      | 
                    ל- MethodBuilder אין TypeBuilder חוקי | 
                
                
                      | 
                    MethodBuilder heeft geen geldige TypeBuilder | 
                
                
                      | 
                    A MethodBuilder objektumhoz nem tartozik érvényes TypeBuilder. | 
                
                
                      | 
                    MethodBuilder-kohteella ei ole kelvollista TypeBuilder-kohdetta | 
                
                
                      | 
                    MethodBuilder'da geçerli bir TypeBuilder yok | 
                
                
                      | 
                    MethodBuilder 不具有有效的 TypeBuilder | 
                
                
                      | 
                    MethodBuilder не содержит допустимого TypeBuilder | 
                
                
                      | 
                    MethodBuilder non dispone di un TypeBuilder valido | 
                
                
                      | 
                    MethodBuilder does not have a valid TypeBuilder | 
                
                
                      | 
                    MethodBuilder ليس به TypeBuilder صالحًا | 
                
                
                      | 
                    MethodBuilder に有効な TypeBuilder がありません | 
                
                
                      | 
                    MethodBuilder weist keinen gültigen TypeBuilder auf. | 
                
                
                      | 
                    MethodBuilder에 올바른 TypeBuilder가 없습니다. | 
                
                
                      | 
                    Objekt MethodBuilder nemá platný objekt TypeBuilder. | 
                
                
                      | 
                    Το MethodBuilder δεν διαθέτει έγκυρο TypeBuilder | 
                
                
                      | 
                    MethodBuilder no tiene un TypeBuilder válido | 
                
                
                      | 
                    MethodBuilder har ikke en gyldig TypeBuilder | 
                
                
                      | 
                    MethodBuilder 沒有有效的 TypeBuilder | 
                
                
                      | 
                    Klasa MethodBuilder nie ma prawidłowego obiektu TypeBuilder | 
                
                
                      | 
                    MethodBuilder har ikke en gyldig TypeBuilder | 
                
                
                      | 
                    MethodBuilder har ingen giltig TypeBuilder | 
                
                
                      | 
                    MethodBuilder não tem um TypeBuilder válido | 
                
                
                      | 
                    לא ניתן להשתמש בביטוי מסוג '<var>Type Name</var>' עבור תווית מסוג 'X' | 
                
                
                      | 
                    Expressie van het type <var>Type Name</var> kan niet worden gebruikt voor een label van het type X | 
                
                
                      | 
                    „<var>Type Name</var>” típusú kifejezés nem használható „X” típusú címkéhez. | 
                
                
                      | 
                    Tyypin <var>Type Name</var> lauseketta ei voi käyttää tyypin X otsikolle | 
                
                
                      | 
                    '<var>Type Name</var>' türündeki ifade 'X' türündeki etiket için kullanılamaz | 
                
                
                      | 
                    “<var>Type Name</var>”类型的表达式不能用于“X”类型的标签 | 
                
                
                      | 
                    Выражение типа "<var>Type Name</var>" не может использоваться для метки типа "X" | 
                
                
                      | 
                    Impossibile utilizzare l'espressione di tipo '<var>Type Name</var>' per l'etichetta di tipo 'X' | 
                
                
                      | 
                    Expression of type '<var>Type Name</var>' cannot be used for label of type 'X' | 
                
                
                      | 
                    لا يمكن استخدام التعبير من النوع '<var>Type Name</var>' لعلامة من النوع 'X' | 
                
                
                      | 
                    型 '<var>Type Name</var>' の式を型 'X' のラベルに使用することはできません | 
                
                
                      | 
                    Ein Ausdruck vom Typ "<var>Type Name</var>" kann nicht für eine Bezeichnung vom Typ "X" verwendet werden. | 
                
                
                      | 
                    '<var>Type Name</var>' 형식의 식은 'X' 형식의 레이블에 사용할 수 없습니다. | 
                
                
                      | 
                    Παράσταση του τύπου'<var>Type Name</var>' δεν μπορεί να χρησιμοποιηθεί για ετικέτα του τύπου 'X' | 
                
                
                      | 
                    No se puede usar una expresión del tipo '<var>Type Name</var>' para una etiqueta del tipo 'X' | 
                
                
                      | 
                    Udtrykket af typen '<var>Type Name</var>' kan ikke bruges til etiket af typen 'X' | 
                
                
                      | 
                    型別 '<var>Type Name</var>' 的運算式不可使用於型別 'X' 的標籤 | 
                
                
                      | 
                    Výraz typu <var>Type Name</var> nelze použít pro návěští typu X. | 
                
                
                      | 
                    Nie można użyć wyrażenia typu „<var>Type Name</var>” dla etykiety typu „X” | 
                
                
                      | 
                    Uttrykk av typen <var>Type Name</var> kan ikke brukes som etikett for typen X | 
                
                
                      | 
                    Det går inte att använda uttryck av typen <var>Type Name</var> för etiketter av typen X | 
                
                
                      | 
                    A expressão de tipo '<var>Type Name</var>' não pode ser usada como rótulo do tipo 'X' | 
                
                
                      | 
                    מאפיין המופע '<var>Property Name</var>' שאינו מקבל ארגומנטים לא מוגדר עבור הסוג '<var>Type Name</var>' | 
                
                
                      | 
                    Exemplaareigenschap <var>Property Name</var>die geen argument aanneemt, is niet gedefinieerd voor type <var>Type Name</var> | 
                
                
                      | 
                    Az argumentumot nem fogadó „<var>Property Name</var>” példánytulajdonság nincs definiálva a következő típushoz: „<var>Type Name</var>”. | 
                
                
                      | 
                    Esiintymäominaisuutta <var>Property Name</var>, joka ei hyväksy argumentteja, ei ole määritetty tyypille <var>Type Name</var> | 
                
                
                      | 
                    '<var>Type Name</var>' türü için bağımsız değişken almayan '<var>Property Name</var>' örnek özelliği tanımlanmadı | 
                
                
                      | 
                    没有为类型“<var>Type Name</var>”定义未采用任何参数的实例属性“<var>Property Name</var>” | 
                
                
                      | 
                    Свойство экземпляра "<var>Property Name</var>", не принимающее аргументов, не определено для типа "<var>Type Name</var>" | 
                
                
                      | 
                    La proprietà dell'istanza '<var>Property Name</var>' che non utilizza argomenti non è definita per il tipo '<var>Type Name</var>' | 
                
                
                      | 
                    Instance property '<var>Property Name</var>' that takes no argument is not defined for type '<var>Type Name</var>' | 
                
                
                      | 
                    خاصية المثيلة '<var>Property Name</var>' التي لا تتخذ أية وسيطة ليست محددة للنوع '<var>Type Name</var>'. | 
                
                
                      | 
                    引数を受け取らないインスタンス プロパティ '<var>Property Name</var>' は、型 '<var>Type Name</var>' に対して定義されていません | 
                
                
                      | 
                    Die Instanzeigenschaft "<var>Property Name</var>", die kein Argument hat, ist nicht für Typ "<var>Type Name</var>" definiert. | 
                
                
                      | 
                    인수를 사용하지 않는 인스턴스 속성 '<var>Property Name</var>'이(가) '<var>Type Name</var>' 형식에 대해 정의되지 않았습니다. | 
                
                
                      | 
                    Vlastnost instance <var>Property Name</var>, která nepřijímá žádný argument, není definována pro typ <var>Type Name</var>. | 
                
                
                      | 
                    Η ιδιότητα παρουσίας '<var>Property Name</var>' που δεν λαμβάνει κανένα όρισμα δεν έχει οριστεί για τον τύπο '<var>Type Name</var>' | 
                
                
                      | 
                    La propiedad de instancia '<var>Property Name</var>' que no toma argumentos no se ha definido para el tipo '<var>Type Name</var>' | 
                
                
                      | 
                    Forekomstegenskaben '<var>Property Name</var>', som ikke kræver nogen argumenter, er ikke defineret for typen '<var>Type Name</var>' | 
                
                
                      | 
                    未對型別 '<var>Type Name</var>' 定義不接受引數的執行個體屬性 '<var>Property Name</var>' | 
                
                
                      | 
                    Właściwość wystąpienia „<var>Property Name</var>”, które nie pobiera argumentów, nie jest zdefiniowana dla typu „<var>Type Name</var>” | 
                
                
                      | 
                    Forekomstegenskapen <var>Property Name</var> som ikke tar argument, er ikke angitt for typen <var>Type Name</var> | 
                
                
                      | 
                    Instansegenskapen <var>Property Name</var> som inte använder argument har inte definierats för typen <var>Type Name</var> | 
                
                
                      | 
                    A propriedade de instância '<var>Property Name</var>' que não aceita argumentos não está definida para o tipo '<var>Type Name</var>' | 
                
                
                      | 
                    arrayType חייב להיות סוג מערך | 
                
                
                      | 
                    arrayType moet een matrixtype zijn | 
                
                
                      | 
                    Az arrayType típusnak tömb típusúnak kell lennie. | 
                
                
                      | 
                    Kohteen arrayType on oltava taulukkotyyppi | 
                
                
                      | 
                    arrayType bir dizi türü olmalıdır | 
                
                
                      | 
                    arrayType 必须是数组类型 | 
                
                
                      | 
                    arrayType должен быть типом массива. | 
                
                
                      | 
                    arrayType deve essere un tipo di matrice | 
                
                
                      | 
                    arrayType must be an array type | 
                
                
                      | 
                    يجب أن يكون arrayType هو نوع مصفوفة. | 
                
                
                      | 
                    arrayType は配列型でなければなりません | 
                
                
                      | 
                    arrayType muss ein Arraytyp sein. | 
                
                
                      | 
                    arrayType은 배열 형식이어야 합니다. | 
                
                
                      | 
                    arrayType musí být typ pole. | 
                
                
                      | 
                    Το arrayType πρέπει να είναι τύπου πίνακα | 
                
                
                      | 
                    arrayType debe ser un tipo de matriz | 
                
                
                      | 
                    arrayType skal være en arraytype | 
                
                
                      | 
                    arrayType 必須是陣列型別 | 
                
                
                      | 
                    Element arrayType musi być typem tablicy | 
                
                
                      | 
                    arrayType må være en matrisetype | 
                
                
                      | 
                    arrayType måste vara en matristyp | 
                
                
                      | 
                    arrayType deve ser um tipo de matriz | 
                
                
                      | 
                    ניתן לבצע המרת unbox רק מתוך אובייקט או סוג ממשק לסוג ערך. | 
                
                
                      | 
                    Kan alleen samenstellen vanuit een object- of interfacetype naar een waardetype. | 
                
                
                      | 
                    Csak egy objektumból vagy illesztőfelületi típusból lehet értéktípusra kibontani. | 
                
                
                      | 
                    Objekti- tai liittymätyyppi voidaan muuttaa vain arvotyypiksi. | 
                
                
                      | 
                    Yalnızca nesne veya arabirim türü açılarak değer türü alınabilir. | 
                
                
                      | 
                    只能取消从对象或接口类型到值类型的装箱。 | 
                
                
                      | 
                    Распаковка возможна только из типа объекта или интерфейса в тип значения. | 
                
                
                      | 
                    È possibile eseguire la conversione unboxing solo da un tipo di interfaccia o oggetto a un tipo di valore. | 
                
                
                      | 
                    Can only unbox from an object or interface type to a value type. | 
                
                
                      | 
                    يتعذر التفريغ من نوع الكائن أو الواجهة إلى نوع القيمة. | 
                
                
                      | 
                    オブジェクトまたはインターフェイス型から値型にのみアンボックスできます。 | 
                
                
                      | 
                    Es kann nicht von einem Objekt- oder Schnittstellentyp in einen Werttyp mittels Unboxing konvertiert werden. | 
                
                
                      | 
                    개체 또는 인터페이스에서 값 형식으로만 unboxing할 수 있습니다. | 
                
                
                      | 
                    Lze vybalit pouze z typu objektu nebo typu rozhraní na typ hodnoty. | 
                
                
                      | 
                    Είναι δυνατή μόνο η μετατροπή από ένα αντικείμενο ή τύπο διασύνδεσης σε έναν τύπο τιμής. | 
                
                
                      | 
                    Solo se puede realizar la conversión unboxing de un tipo de objeto o interfaz a un tipo de valor. | 
                
                
                      | 
                    Kan kun pakke ud fra et objekt eller en grænseflade til en værditype. | 
                
                
                      | 
                    只能從物件或介面型別 Unbox 成為實值型別。 | 
                
                
                      | 
                    Nie można rozpakować z obiektu lub typu interfejsu do typu wartości. | 
                
                
                      | 
                    Kan bare pakke ut fra en objekt- eller grensesnittype til en verditype. | 
                
                
                      | 
                    Det går endast att avpaketera från ett objekt eller en gränssnittstyp till en värdetyp. | 
                
                
                      | 
                    Só é possível converter um tipo de objeto ou interface em um tipo de valor. | 
                
                
                      | 
                    ביטוי Try אינו מותר בתך גוף מסנן. | 
                
                
                      | 
                    Try-expressie is niet toegestaan binnen een filterhoofdcode. | 
                
                
                      | 
                    Try kifejezés nem engedélyezett egy szűrő törzsében. | 
                
                
                      | 
                    Try-lauseketta ei sallita suodatinrungon sisällä. | 
                
                
                      | 
                    Filtre gövdesi içinde try ifadesine izin verilmiyor. | 
                
                
                      | 
                    filter 体中不允许 try 表达式。 | 
                
                
                      | 
                    Выражение Try недопустимо в теле фильтра. | 
                
                
                      | 
                    Espressione try non consentita all'interno del corpo di un filtro. | 
                
                
                      | 
                    Try expression is not allowed inside a filter body. | 
                
                
                      | 
                    غير مسموح بتعبير عملية الالتقاط داخل نص عامل التصفية. | 
                
                
                      | 
                    フィルター本体の内部で Try 式を使用することはできません。 | 
                
                
                      | 
                    Ein Try-Ausdruck ist innerhalb eines Filtertexts nicht zulässig. | 
                
                
                      | 
                    필터 본문 내에서는 Try 식을 사용할 수 없습니다. | 
                
                
                      | 
                    Výraz try není povolen uvnitř obsahu filtru. | 
                
                
                      | 
                    Η παράσταση Try δεν επιτρέπεται εντός σώματος φίλτρου. | 
                
                
                      | 
                    La expresión try no se admite dentro de un cuerpo de filtro. | 
                
                
                      | 
                    Try-udtrykket er ikke tilladt i en filtertekst. | 
                
                
                      | 
                    篩選主體內不允許 Try 運算式。 | 
                
                
                      | 
                    Wyrażenie try expression jest niedozwolone wewnątrz treści filtru. | 
                
                
                      | 
                    "Try"-uttrykk er ikke tillatt inne i en filtertekst. | 
                
                
                      | 
                    Try-uttryck tillåts inte i en filtertext. | 
                
                
                      | 
                    A expressão try não é permitida no corpo de um filtro. |