diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.cs.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.cs.xlf index 802072c166..214d271e05 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.cs.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.cs.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + Nepoužívat zakázaná rozhraní API diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.de.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.de.xlf index f080fec48d..4f7f38e641 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.de.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.de.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + Gesperrte APIs nicht verwenden diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.es.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.es.xlf index 55a302f197..83ed254ec1 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.es.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.es.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + No usar API prohibidas diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.fr.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.fr.xlf index 70708a7f6d..f38e7d0cbb 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.fr.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.fr.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + Ne pas utiliser d’API interdites diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.it.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.it.xlf index a29096e928..469a884008 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.it.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.it.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + Non usare API vietate diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ja.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ja.xlf index 660575819c..27353a109f 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ja.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ja.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + 禁止 API を使用しない diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ko.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ko.xlf index 8413024cb0..d59be1226f 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ko.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ko.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + 금지된 API를 사용하지 마세요. diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.pl.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.pl.xlf index 0540184cf4..e03885ad78 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.pl.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.pl.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + Nie używaj zablokowanych interfejsów API diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.pt-BR.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.pt-BR.xlf index 345f56f0aa..6af075bc05 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.pt-BR.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.pt-BR.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + Não use APIs banidas diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ru.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ru.xlf index a3cb0ca4b3..7620e61e1b 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ru.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.ru.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + Не использовать запрещенные API diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.tr.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.tr.xlf index 6d428887d3..4d57262b86 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.tr.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.tr.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + Yasaklanmış API'leri kullanmayın diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.zh-Hans.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.zh-Hans.xlf index ad36c0f83b..f65aac3943 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.zh-Hans.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.zh-Hans.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + 请勿使用禁止的 API diff --git a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.zh-Hant.xlf b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.zh-Hant.xlf index 863672de24..7754ebba7e 100644 --- a/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.zh-Hant.xlf +++ b/src/Microsoft.CodeAnalysis.BannedApiAnalyzers/Core/xlf/BannedApiAnalyzerResources.zh-Hant.xlf @@ -44,7 +44,7 @@ Do not use banned APIs - Do not use banned APIs + 請勿使用禁止的 API diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.cs.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.cs.xlf index 86fdb12950..a70fbc9a1a 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.cs.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.cs.xlf @@ -1877,21 +1877,6 @@ Člen {0} nemá přístup k datům instance a je možné ho označit jako statický. - - Review visible event handlers - Kontrola viditelných obslužných rutin událostí - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - Zjistila se veřejná nebo chráněná metoda zpracování událostí. Metody zpracování událostí by neměly být vystaveny, pokud to není nezbytně nutné. - - - - Consider making '{0}' not externally visible - Nastavte metodu {0} tak, aby nebyla externě viditelná. - - Seal methods that satisfy private interfaces Zapečetění metod, které vyhovují privátním rozhraním @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Externě viditelná metoda přistupuje přes ukazatel k datům jednoho ze svých atributů odkazů bez ověření, jestli argument není null (Nothing v jazyce Visual Basic). Ve všech argumentech odkazů, které se předávají externě viditelným metodám, by se měla kontrolovat hodnota null. V případě potřeby vyvolejte ArgumentNullException, když je argument null. Pokud je metoda navržená tak, že ji budou volat jen známá sestavení, měli byste ji převést na interní metodu. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + Dříve, než v externě viditelné metodě {0} použijete parametr {1}, ověřte, že tento parametr není null. V případě potřeby vyvolejte ArgumentNullException, když je argument null. diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.de.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.de.xlf index f198632829..c08c1acd32 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.de.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.de.xlf @@ -1877,21 +1877,6 @@ Der Member "{0}" greift nicht auf Instanzdaten zu und kann als "static" markiert werden. - - Review visible event handlers - Sichtbare Ereignishandler überprüfen - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - Es wurde eine öffentliche oder geschützte Methode zum Ereignishandling ermittelt. Methoden zum Ereignishandling dürfen nur verfügbar gemacht werden, wenn es absolut erforderlich ist. - - - - Consider making '{0}' not externally visible - Ziehen Sie in Betracht, "{0}" nicht extern sichtbar zu machen. - - Seal methods that satisfy private interfaces Methoden versiegeln, die die Bedingungen privater Schnittstellen erfüllen @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Eine extern sichtbare Methode dereferenziert eines ihrer Verweisargumente, ohne zu verifizieren, ob das Argument NULL ist („Nothing“ in Visual Basic). Alle Verweisargumente, die an extern sichtbare Methoden übergeben werden, müssen mit NULL überprüft werden. Lösen Sie gegebenenfalls eine „ArgumentNullException“ aus, wenn das Argument NULL ist. Wenn die Methode so konzipiert ist, dass sie nur von bekannten Assemblys aufgerufen wird, müssen Sie die Methode als intern festlegen. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + Validieren Sie in der extern sichtbaren Methode „{0}“, dass der Parameter "{1}" ungleich NULL ist, bevor Sie ihn verwenden. Lösen Sie gegebenenfalls eine „ArgumentNullException“ aus, wenn das Argument NULL ist. diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.es.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.es.xlf index 10e247bf34..363d384a75 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.es.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.es.xlf @@ -1877,21 +1877,6 @@ El miembro "{0}" no tiene acceso a los datos de la instancia y se puede marcar como static. - - Review visible event handlers - Revisar los controladores de eventos visibles - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - Se detectó un método de control de eventos público o protegido. No se deberían exponer los métodos de control de eventos a menos que sea absolutamente necesario. - - - - Consider making '{0}' not externally visible - Podría hacer que "{0}" no fuera externamente visible. - - Seal methods that satisfy private interfaces Sellar los métodos que cumplan las interfaces privadas @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Un método visible externamente anula la referencia de uno de sus argumentos de referencia sin comprobar si ese argumento es nulo ("Nothing" en Visual Basic). Todos los argumentos de referencia pasados a métodos visibles externamente deben comprobarse para ver si son nulos. Si procede, inicie una excepción "ArgumentNullException" cuando el argumento sea nulo. Si el método está diseñado para que solo lo llamen ensamblados conocidos, debería convertirlo en interno. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + En el método "{0}" visible externamente, valide que el parámetro "{1}" no sea nulo antes de usarlo. Si procede, inicie una excepción "ArgumentNullException" cuando el argumento sea "nulo". diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.fr.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.fr.xlf index 50b0453f37..cf5a6d7a60 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.fr.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.fr.xlf @@ -1877,21 +1877,6 @@ Le membre '{0}' n'accède pas aux données d'instance et peut être marqué comme étant static - - Review visible event handlers - Passer en revue les gestionnaires d'événements visibles - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - Une méthode publique ou protégée de gestion des événements a été détectée. Les méthodes de gestion des événements ne doivent pas être exposées sauf en cas d'absolue nécessité. - - - - Consider making '{0}' not externally visible - Rendre '{0}' non visible de manière externe - - Seal methods that satisfy private interfaces Sceller les méthodes qui satisfont les interfaces privées @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Une méthode visible de manière externe déréférence un de ses arguments de référence sans vérifier si cet argument a une valeur « null » (« Nothing en Visual Basic »). Tous les arguments de référence passés à des méthodes visibles de manière externe doivent faire l'objet d'une vérification permettant de déterminer s'ils ont une valeur « null ». Le cas échéant, « ArgumentNullException » doit être levé quand l'argument a une valeur « null », ou vous devez ajouter une condition préalable au contrat de code pour garantir que l'argument a une valeur non « null ». Si la méthode est conçue pour être appelée uniquement par des assemblys connus, rendez la méthode interne. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + Dans la méthode « {0} » visible de manière externe, vérifiez que le paramètre '{1}' a une valeur non null avant de l'utiliser. Le cas échéant, ArgumentNullException doit être levé quand l'argument a une valeur « null ». diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.it.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.it.xlf index ec4334f30f..479ed27b77 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.it.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.it.xlf @@ -1877,21 +1877,6 @@ Il membro {0} non accede ai dati di istanza e può essere contrassegnato come static - - Review visible event handlers - Esaminare i gestori eventi visibili - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - È stato rilevato un metodo di gestione eventi public o protected. I metodi di gestione eventi devono essere esposti solo se assolutamente necessario. - - - - Consider making '{0}' not externally visible - Provare a rendere '{0}' non visibile esternamente - - Seal methods that satisfy private interfaces Impostare come sealed i metodi che soddisfano interfacce private @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Un metodo visibile esternamente risolve i riferimenti a uno dei relativi argomenti di riferimento senza verificare se tale argomento è 'null' ('Nothing' in Visual Basic). Tutti gli argomenti di riferimento passati a metodi visibili esternamente devono essere verificati in base a valori 'null'. Se appropriato, generare un'eccezione 'ArgumentNullException' quando l'argomento è 'null'. Se il metodo è concepito per essere chiamato solo da assembly noti, è necessario impostare il metodo come interno. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + Nel metodo visibile esternamente '{0}' convalidare il parametro '{1}' in modo che non sia Null prima di usarlo. Se appropriato, generare un'eccezione 'ArgumentNullException' quando l'argomento è 'null'. diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ja.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ja.xlf index de8b6c14b7..a376e27e26 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ja.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ja.xlf @@ -1877,21 +1877,6 @@ メンバー '{0}' はインスタンス データにアクセスしないため、static にマークできます - - Review visible event handlers - 表示するイベント ハンドラーを確認します - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - パブリックまたは保護されたイベント処理メソッドが検出されました。イベント処理メソッドは、どうしても必要な場合を除いて公開しないでください。 - - - - Consider making '{0}' not externally visible - '{0}' の外部からの参照を不可能に設定することを検討してください - - Seal methods that satisfy private interfaces プライベート インターフェイスを満たすメソッドをシールします @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + 外部から参照できるメソッドが、引数が null (Visual Basic では Nothing) であるかどうかを確認せずに参照引数の 1 つを逆参照しています。外部から参照できるメソッドに渡されるすべての参照引数は、null でないかどうかを確認する必要があります。適切であれば、引数が null の場合は ArgumentNullException をスローします。メソッドが既知のアセンブリからのみ呼び出されるように設計されている場合、メソッドを internal にします。 In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + 外部から参照できるメソッド '{0}' において、検証パラメーター '{1}' が使用前に非 null です。適切であれば、引数が null の場合に ArgumentNullException をスローします。 diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ko.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ko.xlf index 5cb3a7ac87..308bb64755 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ko.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ko.xlf @@ -1877,21 +1877,6 @@ '{0}' 멤버는 인스턴스 데이터에 액세스하지 않으며 static으로 표시할 수 있습니다. - - Review visible event handlers - 표시되는 이벤트 처리기를 검토하세요. - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - public 또는 protected 이벤트 처리 메서드가 검색되었습니다. 이벤트 처리 메서드는 필요한 경우에만 표시해야 합니다. - - - - Consider making '{0}' not externally visible - '{0}'이(가) 외부에 표시되지 않도록 하세요. - - Seal methods that satisfy private interfaces private 인터페이스를 만족하는 메서드를 봉인하세요. @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + 외부에 표시되는 메서드는 인수가 'null'(Visual Basic의 'Nothing')인지 확인하지 않고 참조 인수 중 하나를 역참조합니다. 외부에 표시되는 메서드에 전달되는 모든 참조 인수가 null인지 확인해야 합니다. 해당하는 경우 인수가 'null'이면 'ArgumentNullException'을 throw합니다. 메서드가 알려진 어셈블리에서만 호출되도록 설계되어 있으면 메서드를 internal로 설정해야 합니다. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + 외부에 표시되는 메서드 '{0}'에서 사용 전에 '{1}' 매개 변수가 null이 아닌지 확인합니다. 해당하는 경우 인수가 'null'이면 'ArgumentNullException'을 throw합니다. diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pl.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pl.xlf index 49a2fc025e..fcaa9c2969 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pl.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pl.xlf @@ -1877,21 +1877,6 @@ Składowa „{0}” nie uzyskuje dostępu do danych wystąpienia i może zostać oznaczona jako statyczna - - Review visible event handlers - Przejrzyj widoczne procedury obsługi zdarzeń - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - Wykryto publiczną lub chronioną metodą obsługi zdarzeń. Nie należy ujawniać metod obsługi zdarzeń, o ile nie jest to absolutnie konieczne. - - - - Consider making '{0}' not externally visible - Rozważ przekształcenie elementu „{0}” w zewnętrznie niewidoczny - - Seal methods that satisfy private interfaces Pieczętuj metody, które spełniają wymagania interfejsów prywatnych @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Zewnętrznie widoczna metoda wyłuszcza jeden z argumentów odwołania bez sprawdzania, czy ten argument ma wartość „null” („Nothing” w języku Visual Basic). Wszystkie argumenty odwołania przekazywane do metod widocznych zewnętrznie powinny być sprawdzane pod kątem wartości „null”. W razie potrzeby zgłoś wyjątek „ArgumentNullException”, gdy argument ma wartość „null”. Jeśli metoda została zaprojektowana tak, aby była wywoływana tylko przez znane zestawy, należy ustawić metodę jako wewnętrzną. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + W widocznej zewnętrznie metodzie „{0}” przed użyciem sprawdź, czy parametr „{1}” nie ma wartości null. W razie potrzeby zgłoś wyjątek „ArgumentNullException”, gdy argument ma wartość „null”. diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pt-BR.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pt-BR.xlf index d8112f54a6..cb02e49551 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pt-BR.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.pt-BR.xlf @@ -1877,21 +1877,6 @@ O membro '{0}' não acessa os dados da instância e pode ser marcado como estático - - Review visible event handlers - Examinar manipuladores de eventos visíveis - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - Foi detectado um método de manipulação de eventos público ou protegido. Os métodos de manipulação de eventos não devem ser expostos, a menos que absolutamente necessário. - - - - Consider making '{0}' not externally visible - Considere tornar {0} não visível externamente - - Seal methods that satisfy private interfaces Métodos de lacre que satisfazem interfaces privadas @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Um método visível externamente desreferencia um de seus argumentos de referência sem verificar se esse argumento é 'nulo' ('Nada' no Visual Basic). Todos os argumentos de referência que são passados para métodos visíveis externamente devem ser verificados contra 'null'. Se apropriado, lance um 'ArgumentNullException' quando o argumento for 'nulo'. Se o método for projetado para ser chamado apenas por assemblies conhecidos, você deverá tornar o método interno. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + No método visível externamente '{0}', validar o parâmetro '{1}' é não nulo antes de usá-lo. Se apropriado, lance um 'ArgumentNullException' quando o argumento for 'nulo'. diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ru.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ru.xlf index 448210d28e..37ee1ede25 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ru.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.ru.xlf @@ -1877,21 +1877,6 @@ Член "{0}" не обращается к данным экземпляров, поэтому его можно пометить как статический. - - Review visible event handlers - Проверьте видимые обработчики событий - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - Обнаружен общий или защищенный метод обработки событий. Такие методы следует предоставлять только в крайнем случае. - - - - Consider making '{0}' not externally visible - Рекомендуется сделать "{0}" недоступным извне. - - Seal methods that satisfy private interfaces Запечатайте методы, соответствующие частным интерфейсам @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Видимый извне метод разыменовывает один из своих аргументов ссылки, не проверяя, имеет ли этот аргумент значение NULL (Nothing в Visual Basic). Все аргументы ссылки, передаваемые в видимые извне методы, следует проверять на значение NULL. При необходимости следует вызвать исключение ArgumentNullException, если аргумент равен NULL. Если метод предназначен для вызова только известными сборками, следует сделать его внутренним. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + В видимом извне методе "{0}" перед использованием параметра "{1}" нужно убедиться, что его значение отличается от NULL. При необходимости следует вызвать исключение ArgumentNullException, если аргумент равен NULL. diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.tr.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.tr.xlf index 4cae26ed1d..71d317618d 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.tr.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.tr.xlf @@ -1877,21 +1877,6 @@ '{0}' adlı üye örnek verilerine erişmiyor ve statik olarak işaretlenebilir - - Review visible event handlers - Görünür olay işleyicilerini gözden geçirin - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - Genel veya korumalı bir olay işleme yöntemi algılandı. Olay işleme yöntemleri kesinlikle gerekli olmadıkça kullanıma sunulmamalıdır. - - - - Consider making '{0}' not externally visible - '{0}' öğesini dışarıdan görünmez yapmayı deneyin - - Seal methods that satisfy private interfaces Özel arabirimleri karşılayan mühürleme yöntemleri @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + Dışarıdan görünen metot, bağımsız değişkenin null (Visual Basic’te ‘Nothing’) olup olmadığını doğrulamadan başvuru bağımsız değişkenlerinden birine başvurur. Dışarıdan görünen metotlara geçirilen tüm başvuru bağımsız değişkenlerinin null olup olmadığı denetlenmelidir. Uygunsa, bağımsız değişken null olduğunda bir ArgumentNullException oluşturun. Metot yalnızca bilinen derlemeler tarafından çağrılacak şekilde tasarlanmışsa metodu içeriden görünen hale getirmeniz gerekir. In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + Dışarıdan görünen '{0}' metodunda '{1}' parametresini kullanmadan önce parametrenin null olmadığını doğrulayın. Uygunsa bağımsız değişken null olduğunda bir ‘ArgumentNullException’ oluşturun. diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hans.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hans.xlf index bc0d05d550..8a247c7a70 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hans.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hans.xlf @@ -1877,21 +1877,6 @@ 成员“{0}”不访问实例数据，可标记为 static - - Review visible event handlers - 检查可见的事件处理程序 - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - 检测到公共或受保护的事件处理方法。除非绝对必要，否则不应公开事件处理方法。 - - - - Consider making '{0}' not externally visible - 请考虑将“{0}”设为对外部不可见 - - Seal methods that satisfy private interfaces 密封满足私有接口的方法 @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + 外部可见方法会在不验证该参数是否为 "null" (Visual Basic 中为 "Nothing")的情况下取消引用其某个引用参数。应检查传递给外部可见方法的所有引用参数中是否有参数为 "null"。如果适用，在参数为 "null" 时引发 "ArgumentNullException"。如果该方法应仅由已知程序集调用，则应将该方法设置为在内部。 In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + 在外部可见的方法 "{0}" 中，在使用验证参数 "{1}" 之前，它为非 null。如果适用，请在参数为 "null" 时引发 "ArgumentNullException"。 diff --git a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hant.xlf b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hant.xlf index 48f76e8961..8d6276b1ff 100644 --- a/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hant.xlf +++ b/src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/xlf/MicrosoftCodeQualityAnalyzersResources.zh-Hant.xlf @@ -1877,21 +1877,6 @@ 成員 '{0}' 不會存取執行個體資料，因而可標記為靜態 - - Review visible event handlers - 檢閱可見的事件處理常式 - - - - A public or protected event-handling method was detected. Event-handling methods should not be exposed unless absolutely necessary. - 已偵測到公用或受保護的事件處理方法。除非絕對必要，否則不應公開事件處理方法。 - - - - Consider making '{0}' not externally visible - 請考慮對外隱藏 '{0}' - - Seal methods that satisfy private interfaces 密封滿足私用介面的方法 @@ -1989,12 +1974,12 @@ An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. - An externally visible method dereferences one of its reference arguments without verifying whether that argument is 'null' ('Nothing' in Visual Basic). All reference arguments that are passed to externally visible methods should be checked against 'null'. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. If the method is designed to be called only by known assemblies, you should make the method internal. + 外部可見的方法，會解除參照其中一個它的參考引數，而會不確認該引數是否為 'null' (Visual Basic 中的 'Nothing')。但所有傳遞到外部可見方法的參考引數，都應檢查是否為 'null'。若可行的話，當引數為 'null' 時請擲回 'ArgumentNullException'。若該方法設計為只可由已知組件呼叫，則應將該方法設為內部方法。 In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. - In externally visible method '{0}', validate parameter '{1}' is non-null before using it. If appropriate, throw an 'ArgumentNullException' when the argument is 'null'. + 在外部可見方法 '{0}' 中，驗證參數 '{1}' 在使用前會是非 null。若可行的話，當引數為 'null' 時請擲回 'ArgumentNullException'。 diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.cs.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.cs.xlf index 374f4f46cf..463c232cfc 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.cs.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.cs.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + Některé předdefinované operátory přidané v rozhraní .NET 7 se při přetečení chovají jinak než odpovídající uživatelem definované operátory v rozhraní .NET 6 a starších verzích. Některé operátory, které dříve vyvolaly nezkontrolovaný kontext, teď nevyvolají výjimku, pokud nejsou zabalené ve zkontrolovaném kontextu. Kromě toho některé operátory, které dříve nevyvolaly zkontrolovaný kontext, teď vyvolávají výjimku, pokud nejsou zabalené v nezkontrolovaném kontextu. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Prevence změny chování @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + Použití pomocné rutiny vyvolání ArgumentException Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + Použití pomocné rutiny vyvolání ArgumentNullException Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + Použití pomocné rutiny vyvolání ArgumentOutOfRangeException @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + Použití pomocné rutiny vyvolání ObjectDisposedException @@ -3007,6 +3007,26 @@ Preferovat možnost Vymazat před možností Fill + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' Použít string.Equals @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Pomocné rutiny vyvolání jsou jednodušší a efektivnější než blok if vytvářející novou instanci výjimky. Use '{0}.{1}' - Use '{0}.{1}' + Použít {0}.{1} Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Místo explicitního vyvolání nové instance výjimky použijte {0}.{1}. diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.de.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.de.xlf index e2cb9eef18..e3cb170861 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.de.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.de.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + Einige integrierte Operatoren, die in .NET 7 hinzugefügt wurden, verhalten sich beim Überlauf anders als die entsprechenden benutzerdefinierten Operatoren in .NET 6 und früheren Versionen. Einige Operatoren, die zuvor einen nicht überprüften Kontext ausgelöst haben, lösen jetzt keine Auslösung aus, es sei denn, sie werden innerhalb eines überprüften Kontexts umschlossen. Außerdem lösen einige Operatoren, die zuvor nicht in einem überprüften Kontext ausgelöst wurden, jetzt aus, es sei denn, sie werden in einen nicht markierten Kontext eingeschlossen. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Verhaltensänderungen verhindern @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + ArgumentException-Throw-Hilfsprogramm verwenden Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + ArgumentNullException-Throw-Hilfsprogramm verwenden Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + ArgumentOutOfRangeException-Throw-Hilfsprogramm verwenden @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + ObjectDisposedException-Throw-Hilfsprogramm verwenden @@ -3007,6 +3007,26 @@ „Clear“ vor „Fill“ bevorzugen + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' "string.Equals" verwenden @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Throw-Hilfsprogramme sind einfacher und effizienter als If-Blöcke, die eine neue Ausnahmeinstanz erstellen. Use '{0}.{1}' - Use '{0}.{1}' + "{0}.{1}" verwenden Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Verwenden Sie "{0}.{1}", anstatt explizit eine neue Ausnahmeinstanz auszulösen. diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.es.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.es.xlf index dedfb8505e..42e2bf8748 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.es.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.es.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + Algunos operadores integrados agregados en .NET 7 se comportan de forma diferente al desbordarse que los operadores definidos por el usuario correspondientes en .NET 6 y versiones anteriores. Algunos operadores que anteriormente se iniciaban en un contexto desactivado ahora no se inician a menos que se ajusten dentro de un contexto activado. Además, algunos operadores que no se iniciaban anteriormente en un contexto activado ahora se inician a menos que se ajusten en un contexto no activado. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Evitar cambios de comportamiento @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + Uso del asistente de inicio ArgumentException Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + Uso del asistente de inicio ArgumentNullException Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + Uso del asistente de inicio ArgumentOutOfRangeException @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + Uso del asistente de inicio ObjectDisposedException @@ -3007,6 +3007,26 @@ Preferir "Clear" en lugar de "Fill" + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' Use 'string.Equals' @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Los asistentes de inicio son más sencillos y eficaces que un bloque if que construye una nueva instancia de excepción. Use '{0}.{1}' - Use '{0}.{1}' + Use '{0}.{1}' Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Use '{0}.{1}' en lugar de iniciar explícitamente una nueva instancia de excepción diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.fr.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.fr.xlf index 1a2935cb80..f5cba463e9 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.fr.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.fr.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + Certains opérateurs intégrés ajoutés dans .NET 7 se comportent différemment lors d’un dépassement de capacité que les opérateurs définis par l’utilisateur correspondants dans .NET 6 et les versions antérieures. Certains opérateurs qui ont levé précédemment dans un contexte désactivé ne lèvent plus, sauf s’ils sont inclus dans un contexte activé. De même, certains opérateurs qui n’étaient pas lancés dans un contexte vérifié le sont désormais à moins d’être enveloppés dans un contexte non vérifié. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Empêcher le changement de comportement @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + Utilisation de l’assistant de levée ArgumentException Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + Utilisation de l’assistant de levée ArgumentNullException Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + Utiliser l’assistance de levée ArgumentOutOfRangeException @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + Utiliser l’assistance de levée ObjectDisposedException @@ -3007,6 +3007,26 @@ Préférer 'Effacer' à 'Remplissage' + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' Utilisez ’String. Equals @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Les assistants de levée sont plus simples et plus efficaces qu’un bloc if construisant une nouvelle instance d’exception. Use '{0}.{1}' - Use '{0}.{1}' + Utiliser « {0}.{1} » Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Utilisez « {0}.{1} » au lieu de lever explicitement une nouvelle instance d’exception diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.it.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.it.xlf index 4f6e20d388..231b5a844e 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.it.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.it.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + Alcuni operatori predefiniti aggiunti in .NET 7 si comportano in modo diverso in caso di overflow rispetto ai corrispondenti operatori definiti dall'utente in .NET 6 e versioni precedenti. Alcuni operatori che in precedenza generavano in un contesto non controllato ora non generano a meno che non venga eseguito il wrapping all’interno di un contesto controllato. Inoltre, alcuni operatori che in precedenza non generavano in un contesto controllato ora generano a meno che non venga eseguito il wrapping in un contesto non controllato. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Prevenire la modifica funzionale @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + Usare l'helper throw ArgumentException Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + Usare ArgumentNullException per generare l'helper Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + Usare ArgumentOutOfRangeException per generare l'helper @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + Usare ObjectDisposedException per generare l'helper @@ -3007,6 +3007,26 @@ Preferisci 'Cancella' a 'Riempimento' + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' Usare 'string.Equals' @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Gli helper throw sono più semplici ed efficienti di un blocco if che costruisce una nuova istanza di eccezione. Use '{0}.{1}' - Use '{0}.{1}' + Usare '{0}.{1}' Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Usare '{0}.{1}' anziché generare in modo esplicito una nuova istanza di eccezione diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ja.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ja.xlf index de4a2c8be7..615574f654 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ja.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ja.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + .NET 7 に追加された組み込み演算子の一部は、オーバーフロー時に .NET 6 以前のバージョンの対応するユーザー定義演算子と異なる動作をします。以前にチェックされていないコンテキストでスローした演算子の一部は、チェックされたコンテキスト内でラップされていない限り、スローされません。また、チェックされたコンテキストで以前にスローされなかった演算子の一部は、チェックされていないコンテキストでラップされていない限り、スローされるようになりました。 @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + 動作の変更を防ぐ @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + ArgumentException スロー ヘルパーを使用する Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + ArgumentNullException スロー ヘルパーを使用する Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + ArgumentOutOfRangeException スロー ヘルパーを使用する @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + ObjectDisposedException スロー ヘルパーを使用する @@ -3007,6 +3007,26 @@ '塗りつぶし' よりも 'クリア' を優先する + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' 'string.Equals' を使用します。 @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + スロー ヘルパーは、if ブロックが新しい例外インスタンスを構築する場合よりもシンプルで効率的です。 Use '{0}.{1}' - Use '{0}.{1}' + '{0}.{1}' を使用します Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + 新しい例外インスタンスを明示的にスローするのではなく、'{0}.{1}' を使用してください diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ko.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ko.xlf index 541498c383..f9af4de2c4 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ko.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ko.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + .NET 7에 추가된 일부 기본 제공 연산자는 오버플로 시 .NET 6 및 이전 버전에서 해당 사용자 정의 연산자와 다르게 동작합니다. 이전에 선택되지 않은 컨텍스트에서 throw한 일부 연산자는 이제 선택한 컨텍스트 내에서 래핑되지 않는 한 throw되지 않습니다. 또한 이전에 선택한 컨텍스트에서 throw하지 않은 일부 연산자는 선택되지 않은 컨텍스트에서 래핑되지 않은 한 지금 throw합니다. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + 동작 변경 방지 @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + ArgumentException throw 도우미 사용 Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + ArgumentNullException throw 도우미 사용 Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + ArgumentOutOfRangeException throw 도우미 사용 @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + ObjectDisposedException throw 도우미 사용 @@ -3007,6 +3007,26 @@ '채우기'보다 '지우기' 선호 + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' 'string.Equals' 사용 @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + throw 도우미는 새로운 예외 인스턴스를 구성하는 if 블록보다 간단하고 효율적입니다. Use '{0}.{1}' - Use '{0}.{1}' + '{0}.{1}' 사용 Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + 새 예외 인스턴스를 명시적으로 throw하는 대신 '{0}.{1}' 사용 diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pl.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pl.xlf index f2a4ffacb9..63f409a9a3 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pl.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pl.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + Niektóre wbudowane operatory dodane w programie .NET 7 działają inaczej w przypadku przepełnienia niż odpowiednie operatory zdefiniowane przez użytkownika w programie .NET 6 i we wcześniejszych wersjach. Niektóre operatory, które wcześniej zgłosiły niezaznaczony kontekst, teraz ich nie zgłaszają, chyba że zostaną opakowane w zaznaczony kontekst. Ponadto niektóre operatory, które nie zgłosiły wcześniej zaznaczonego kontekstu, teraz zgłaszają wyjątek, chyba że jest zawinięty w niezaznaczony kontekst. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Zapobiegaj zmianie zachowania @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + Użyj pomocnika zgłaszania ArgumentException Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + Użyj pomocnika zgłaszania ArgumentNullException Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + Użyj pomocnika zgłaszania ArgumentOutOfRangeException @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + Użyj pomocnika zgłaszania ObjectDisposedException @@ -3007,6 +3007,26 @@ Preferuj opcję „Wyczyść” niż „Wypełnij” + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' Użyj ciągu „string. Equals” @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Pomocnicy zgłaszania są prostsi i wydajniejsi niż blok if konstruujący nowe wystąpienie wyjątku. Use '{0}.{1}' - Use '{0}.{1}' + Użyj „{0}.{1}” Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Użyj „{0}.{1}” zamiast jawnego zgłaszania nowego wystąpienia wyjątku diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pt-BR.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pt-BR.xlf index eacc76591f..e5b6ac382e 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pt-BR.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pt-BR.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + Alguns operadores integrados adicionados no .NET 7 se comportam de maneira diferente durante o estouro do que os operadores correspondentes definidos pelo usuário no .NET 6 e versões anteriores. Alguns operadores que anteriormente lançavam um contexto não verificado agora não lançam, a menos que estejam agrupados em um contexto verificado. Além disso, alguns operadores que não lançaram anteriormente em um contexto verificado agora lançam, a menos que estejam agrupados em um contexto não verificado. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Impedir alterações de comportamento @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + Usar o auxiliar de lançamento ArgumentException Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + Usar o auxiliar de lançamento de ArgumentNullException Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + Usar o auxiliar de lançamento ArgumentOutOfRangeException @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + Usar o auxiliar de lançamento ObjectDisposedException @@ -3007,6 +3007,26 @@ Preferir 'Clear' ao invés de 'Fill' + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' Use 'string. Igual a' @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Auxiliares de lançamento são mais simples e eficientes do que um bloco if que constrói uma nova instância de exceção. Use '{0}.{1}' - Use '{0}.{1}' + Usar '{0}.{1}' Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Use '{0}.{1}' em vez de lançar explicitamente uma nova instância de exceção diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ru.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ru.xlf index 4edf160973..0b273728fc 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ru.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ru.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + Некоторые встроенные операторы, добавленные в .NET 7, при переполнении выполняют действия, которые отличаются от пользовательских операторов в .NET 6 и более ранних версиях. Некоторые операторы, которые ранее обеспечивали вызов в непроверенном контексте, теперь не делают этого, если они не упакованы в проверенный контекст. Кроме того, некоторые операторы, которые ранее не обеспечивали вызов в проверенном контексте, теперь делают это, если они не упакованы в непроверенный контекст. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Запретить изменение в поведении @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + Использовать вспомогательное приложение по вызову ArgumentException Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + Использовать вспомогательное приложение по вызову ArgumentNullException Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + Использовать вспомогательное приложение по вызову ArgumentOutOfRangeException @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + Использовать вспомогательное приложение по вызову ObjectDisposedException @@ -3007,6 +3007,26 @@ Предпочитать "Clear" вместо "Fill" + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' Использовать "string.Equals" @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Помощники по вызову являются более простыми и эффективными, чем блок if, создающий новый экземпляр исключения. Use '{0}.{1}' - Use '{0}.{1}' + Использовать "{0}.{1}" Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Используйте "{0}.{1}" вместо явного вызова нового экземпляра исключения diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.tr.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.tr.xlf index 497936e666..b3892dc09d 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.tr.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.tr.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + .NET 7'ye eklenen bazı yerleşik işleçler, .NET 6 ve önceki sürümlerde karşılık gelen kullanıcı tanımlı işleçlerde taşma olduğunda farklı davranır. Daha önce işaretlenmemiş bir bağlamda oluşturulan bazı işleçler, işaretli bir bağlam içinde kaydırılana kadar artık oluşturmaz. Ayrıca, daha önce denetlenmiş bir bağlamda oluşturulmamış bazı işleçler şimdi işaretsiz bir bağlamda sarmalanmadıysa oluşturulur. @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + Davranış değişikliğini önle @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + ArgumentException oluşturma yardımcısı kullan Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + ArgumentNullException oluşturma yardımcısını kullan Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + ArgumentOutOfRangeException oluşturma yardımcısı kullan @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + ObjectDisposedException oluşturma yardımcısı kullan @@ -3007,6 +3007,26 @@ 'Fill' yerine 'Clear' tercih et + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' 'string.Equals' kullanın @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + Oluşturma yardımcıları, yeni bir özel durum örneği oluşturan bir if bloğundan daha basit ve daha verimlidir. Use '{0}.{1}' - Use '{0}.{1}' + '{0}.{1}' kullan Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + Açıkça yeni bir özel durum örneği oluşturmak yerine '{0}.{1}' kullanın diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.zh-Hans.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.zh-Hans.xlf index f71adae4d4..2fdd5a89ac 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.zh-Hans.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.zh-Hans.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + 在 .NET 7 中添加的某些内置运算符在溢出时的行为与 .NET 6 和早期版本中相应的用户定义运算符的行为不同。之前在未检查的上下文中引发的一些运算符现在只有在经检查的上下文中被包装时才会引发。此外，一些之前在经检查的上下文中不引发的运算符现在会引发，除非在未检查的上下文中被包装。 @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + 防止行为变更 @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + 使用 ArgumentException 引发帮助程序 Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + 使用 ArgumentNullException 引发帮助程序 Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + 使用 ArgumentOutOfRangeException 引发帮助程序 @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + 使用 ObjectDisposedException 引发帮助程序 @@ -3007,6 +3007,26 @@ 首选“清除”而不是“填充” + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' 使用 “string.Equals” @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + 在构造新的异常实例方面，引发帮助程序比 if 块更简单、更高效。 Use '{0}.{1}' - Use '{0}.{1}' + 使用 "{0}.{1}" Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + 使用 "{0}.{1}"，而不是显式引发新的异常实例 diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.zh-Hant.xlf b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.zh-Hant.xlf index a6b9aa3d42..c780e85b4b 100644 --- a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.zh-Hant.xlf +++ b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.zh-Hant.xlf @@ -2179,7 +2179,7 @@ Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. - Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within a checked context. Also, some operators that did not previously throw in a checked context now throw unless wrapped in an unchecked context. + 在 .NET 7 中新增的某些內建運算子在溢位時的行為不同於 .NET 6 和較舊版本中對應的使用者定義運算子。某些先前擲回未核取內容的運算子現在不會擲回，除非包裝在核取的內容中。此外，某些先前未擲回核取內容的運算子現在會擲回，除非包裝在未選取的內容中。 @@ -2189,7 +2189,7 @@ Prevent behavioral change - Prevent behavioral change + 防止行為變更 @@ -2684,17 +2684,17 @@ Use ArgumentException throw helper - Use ArgumentException throw helper + 使用 ArgumentException 擲回協助程式 Use ArgumentNullException throw helper - Use ArgumentNullException throw helper + 使用 ArgumentNullException 擲回協助程式 Use ArgumentOutOfRangeException throw helper - Use ArgumentOutOfRangeException throw helper + 使用 ArgumentOutOfRangeException 擲回協助程式 @@ -2914,7 +2914,7 @@ Use ObjectDisposedException throw helper - Use ObjectDisposedException throw helper + 使用 ObjectDisposedException 擲回協助程式 @@ -3007,6 +3007,26 @@ 優先使用 'Clear' 而不是 'Fill' + + Use 'StartsWith' + Use 'StartsWith' + + + + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero. + + + + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0 + + + + Use 'StartsWith' instead of 'IndexOf' + Use 'StartsWith' instead of 'IndexOf' + + Use 'string.Equals' 請使用 'string.Equals' @@ -3064,17 +3084,17 @@ Throw helpers are simpler and more efficient than an if block constructing a new exception instance. - Throw helpers are simpler and more efficient than an if block constructing a new exception instance. + 擲回協助程式比建構新例外狀況執行個體的 if 區塊更簡單且更有效率。 Use '{0}.{1}' - Use '{0}.{1}' + 使用 '{0}.{1}' Use '{0}.{1}' instead of explicitly throwing a new exception instance - Use '{0}.{1}' instead of explicitly throwing a new exception instance + 使用 '{0}.{1}'，而不是明確擲回新的例外狀況執行個體