FeaturesResources.it.xlf

<?xml version="1.0" encoding="utf-8"?>
<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
  <file datatype="xml" source-language="en" target-language="it" original="../FeaturesResources.resx">
    <body>
      <trans-unit id="AM_PM_abbreviated">
        <source>AM/PM (abbreviated)</source>
        <target state="translated">AM/PM (abbreviato)</target>
        <note />
      </trans-unit>
      <trans-unit id="AM_PM_abbreviated_description">
        <source>The "t" custom format specifier represents the first character of the AM/PM designator. The appropriate localized designator is retrieved from the DateTimeFormatInfo.AMDesignator or DateTimeFormatInfo.PMDesignator property of the current or specific culture. The AM designator is used for all times from 0:00:00 (midnight) to 11:59:59.999. The PM designator is used for all times from 12:00:00 (noon) to 23:59:59.999.

If the "t" format specifier is used without other custom format specifiers, it's interpreted as the "t" standard date and time format specifier.</source>
        <target state="translated">L'identificatore di formato personalizzato "t" rappresenta il primo carattere dell'indicatore AM/PM. L'indicatore localizzato appropriato viene recuperato dalla proprietà DateTimeFormatInfo.AMDesignator o DateTimeFormatInfo.PMDesignator delle impostazioni cultura correnti o specificate. L'indicatore AM viene usato per tutti gli orari compresi tra 0:00:00 (mezzanotte) e 11:59:59.999. L'indicatore PM viene usato per tutti gli orari compresi tra 12:00:00 (mezzogiorno) e 23:59:59.999.

Se l'identificatore di formato "t" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato data e ora standard "t".</target>
        <note />
      </trans-unit>
      <trans-unit id="AM_PM_full">
        <source>AM/PM (full)</source>
        <target state="translated">AM/PM (esteso)</target>
        <note />
      </trans-unit>
      <trans-unit id="AM_PM_full_description">
        <source>The "tt" custom format specifier (plus any number of additional "t" specifiers) represents the entire AM/PM designator. The appropriate localized designator is retrieved from the DateTimeFormatInfo.AMDesignator or DateTimeFormatInfo.PMDesignator property of the current or specific culture. The AM designator is used for all times from 0:00:00 (midnight) to 11:59:59.999. The PM designator is used for all times from 12:00:00 (noon) to 23:59:59.999.

Make sure to use the "tt" specifier for languages for which it's necessary to maintain the distinction between AM and PM. An example is Japanese, for which the AM and PM designators differ in the second character instead of the first character.</source>
        <target state="translated">L'identificatore di formato personalizzato "tt" (più qualsiasi numero di identificatori "t" aggiuntivi) rappresenta l'indicatore AM/PM completo. L'indicatore localizzato appropriato viene recuperato dalla proprietà DateTimeFormatInfo.AMDesignator o DateTimeFormatInfo.PMDesignator delle impostazioni cultura correnti o specificate. L'indicatore AM viene usato per tutti gli orari compresi tra 0:00:00 (mezzanotte) e 11:59:59.999. L'indicatore PM viene usato per tutti gli orari compresi tra 12:00:00 (mezzogiorno) e 23:59:59.999.

Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessario mantenere la distinzione tra AM e PM. Un esempio è la lingua giapponese, in cui gli indicatori AM e PM sono diversi nel secondo carattere anziché nel primo.</target>
        <note />
      </trans-unit>
      <trans-unit id="A_subtraction_must_be_the_last_element_in_a_character_class">
        <source>A subtraction must be the last element in a character class</source>
        <target state="translated">L'ultimo elemento di una classe di caratteri deve essere una sottrazione</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c]</note>
      </trans-unit>
      <trans-unit id="Add_DebuggerDisplay_attribute">
        <source>Add 'DebuggerDisplay' attribute</source>
        <target state="translated">Aggiungi l'attributo 'DebuggerDisplay'</target>
        <note>{Locked="DebuggerDisplay"} "DebuggerDisplay" is a BCL class and should not be localized.</note>
      </trans-unit>
      <trans-unit id="Add_explicit_cast">
        <source>Add explicit cast</source>
        <target state="translated">Aggiungi cast esplicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_member_name">
        <source>Add member name</source>
        <target state="translated">Aggiungi nome del membro</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_null_checks_for_all_parameters">
        <source>Add null checks for all parameters</source>
        <target state="translated">Aggiungi controlli Null per tutti i parametri</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_optional_parameter_to_constructor">
        <source>Add optional parameter to constructor</source>
        <target state="translated">Aggiungi il parametro facoltativo al costruttore</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_parameter_to_0_and_overrides_implementations">
        <source>Add parameter to '{0}' (and overrides/implementations)</source>
        <target state="translated">Aggiungi il parametro a '{0}' (e override/implementazioni)</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_parameter_to_constructor">
        <source>Add parameter to constructor</source>
        <target state="translated">Aggiungi il parametro al costruttore</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_project_reference_to_0">
        <source>Add project reference to '{0}'.</source>
        <target state="translated">Aggiunge il riferimento al progetto a '{0}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_reference_to_0">
        <source>Add reference to '{0}'.</source>
        <target state="translated">Aggiunge il riferimento a '{0}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="Actions_can_not_be_empty">
        <source>Actions can not be empty.</source>
        <target state="translated">Il campo Azioni non può essere vuoto.</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_tuple_element_name_0">
        <source>Add tuple element name '{0}'</source>
        <target state="translated">Aggiungi il nome dell'elemento tupla '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_0_into_an_interface_method_will_prevent_the_debug_session_from_continuing">
        <source>Adding '{0}' into an interface method will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge '{0}' in un metodo di interfaccia, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_0_into_an_interface_will_prevent_the_debug_session_from_continuing">
        <source>Adding '{0}' into an interface will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge '{0}' in un'interfaccia, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_method_with_explicit_interface_specifier_will_prevernt_the_debug_session_from_continuing">
        <source>Adding a method with an explicit interface specifier will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un metodo con identificatore di interfaccia esplicita, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Align_wrapped_arguments">
        <source>Align wrapped arguments</source>
        <target state="translated">Allinea gli argomenti con ritorno a capo</target>
        <note />
      </trans-unit>
      <trans-unit id="Align_wrapped_parameters">
        <source>Align wrapped parameters</source>
        <target state="translated">Allinea i parametri con ritorno a capo</target>
        <note />
      </trans-unit>
      <trans-unit id="Alternation_conditions_cannot_be_comments">
        <source>Alternation conditions cannot be comments</source>
        <target state="translated">Le condizioni di alternanza non possono essere commenti</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b)</note>
      </trans-unit>
      <trans-unit id="Alternation_conditions_do_not_capture_and_cannot_be_named">
        <source>Alternation conditions do not capture and cannot be named</source>
        <target state="translated">Le condizioni di alternanza non consentono l'acquisizione e non possono essere denominate</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x'))</note>
      </trans-unit>
      <trans-unit id="Awaited_task_returns_0">
        <source>Awaited task returns '{0}'</source>
        <target state="translated">L'attività attesa restituisce '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Awaited_task_returns_no_value">
        <source>Awaited task returns no value</source>
        <target state="translated">L'attività attesa non restituisce alcun valore</target>
        <note />
      </trans-unit>
      <trans-unit id="Base_classes_contain_inaccessible_unimplemented_members">
        <source>Base classes contain inaccessible unimplemented members</source>
        <target state="translated">Le classi di base contengono membri non implementati inaccessibili</target>
        <note />
      </trans-unit>
      <trans-unit id="CannotApplyChangesUnexpectedError">
        <source>Cannot apply changes -- unexpected error: '{0}'</source>
        <target state="translated">Non è possibile applicare le modifiche. Errore imprevisto: '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Cannot_include_class_0_in_character_range">
        <source>Cannot include class \{0} in character range</source>
        <target state="translated">Non è possibile includere la classe \{0} nell'intervallo di caratteri</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here)</note>
      </trans-unit>
      <trans-unit id="Capture_group_numbers_must_be_less_than_or_equal_to_Int32_MaxValue">
        <source>Capture group numbers must be less than or equal to Int32.MaxValue</source>
        <target state="translated">I numeri del gruppo Capture devono essere minori o uguali a Int32.MaxValue</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648}</note>
      </trans-unit>
      <trans-unit id="Capture_number_cannot_be_zero">
        <source>Capture number cannot be zero</source>
        <target state="translated">Il numero di acquisizioni non può essere zero</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?&lt;0&gt;a)</note>
      </trans-unit>
      <trans-unit id="ChangeSignature_NewParameterInferValue">
        <source>&lt;infer&gt;</source>
        <target state="translated">&lt;deduci&gt;</target>
        <note />
      </trans-unit>
      <trans-unit id="ChangeSignature_NewParameterIntroduceTODOVariable">
        <source>TODO</source>
        <target state="translated">TODO</target>
        <note>"TODO" is an indication that there is work still to be done.</note>
      </trans-unit>
      <trans-unit id="ChangeSignature_NewParameterOmitValue">
        <source>&lt;omit&gt;</source>
        <target state="translated">&lt;ometti&gt;</target>
        <note />
      </trans-unit>
      <trans-unit id="Change_namespace_to_0">
        <source>Change namespace to '{0}'</source>
        <target state="translated">Modifica lo spazio dei nomi in '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Change_to_global_namespace">
        <source>Change to global namespace</source>
        <target state="translated">Passa allo spazio dei nomi globale</target>
        <note />
      </trans-unit>
      <trans-unit id="ChangesDisallowedWhileStoppedAtException">
        <source>Changes are not allowed while stopped at exception</source>
        <target state="translated">Le modifiche non sono consentite in caso di arresto in corrispondenza dell'eccezione</target>
        <note />
      </trans-unit>
      <trans-unit id="ChangesNotAppliedWhileRunning">
        <source>Changes made in project '{0}' will not be applied while the application is running</source>
        <target state="translated">Le modifiche apportate al progetto '{0}' non verranno applicate mentre l'applicazione è in esecuzione</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_0_from_asynchronous_to_synchronous_will_prevent_the_debug_session_from_continuing">
        <source>Changing '{0}' from asynchronous to synchronous will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica '{0}' da asincrono a sincrono, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_0_to_1_will_prevent_the_debug_session_from_continuing_because_it_changes_the_shape_of_the_state_machine">
        <source>Changing '{0}' to '{1}' will prevent the debug session from continuing because it changes the shape of the state machine.</source>
        <target state="translated">Se si modifica '{0}' in '{1}', la sessione di debug non potrà continuare perché modifica la forma della macchina a stati.</target>
        <note />
      </trans-unit>
      <trans-unit id="Configure_0_code_style">
        <source>Configure {0} code style</source>
        <target state="translated">Configura lo stile del codice di {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Configure_0_severity">
        <source>Configure {0} severity</source>
        <target state="translated">Configura la gravità di {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Configure_severity_for_all_0_analyzers">
        <source>Configure severity for all '{0}' analyzers</source>
        <target state="translated">Configura la gravità per tutti gli analizzatori di '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Configure_severity_for_all_analyzers">
        <source>Configure severity for all analyzers</source>
        <target state="translated">Configura la gravità per tutti gli analizzatori</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_linq">
        <source>Convert to LINQ</source>
        <target state="translated">Converti in LINQ</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_to_0">
        <source>Add to '{0}'</source>
        <target state="translated">Aggiungi a '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_class">
        <source>Convert to class</source>
        <target state="translated">Converti in classe</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_linq_call_form">
        <source>Convert to LINQ (call form)</source>
        <target state="translated">Converti in LINQ (form di chiamata)</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_struct">
        <source>Convert to struct</source>
        <target state="translated">Converti in struct</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_type_to_0">
        <source>Convert type to '{0}'</source>
        <target state="translated">Converti il tipo in '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Create_and_assign_field_0">
        <source>Create and assign field '{0}'</source>
        <target state="translated">Crea e assegna il campo '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Create_and_assign_property_0">
        <source>Create and assign property '{0}'</source>
        <target state="translated">Crea e assegna la proprietà '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Create_and_assign_remaining_as_fields">
        <source>Create and assign remaining as fields</source>
        <target state="translated">Crea e assegna rimanenti come campi</target>
        <note />
      </trans-unit>
      <trans-unit id="Create_and_assign_remaining_as_properties">
        <source>Create and assign remaining as properties</source>
        <target state="translated">Crea e assegna rimanenti come proprietà</target>
        <note />
      </trans-unit>
      <trans-unit id="DisposableFieldsShouldBeDisposedDescription">
        <source>A type that implements System.IDisposable declares fields that are of types that also implement IDisposable. The Dispose method of the field is not called by the Dispose method of the declaring type. To fix a violation of this rule, call Dispose on fields that are of types that implement IDisposable if you are responsible for allocating and releasing the unmanaged resources held by the field.</source>
        <target state="translated">Un tipo che implementa System.IDisposable dichiara i campi di tipi che implementano anch'essi IDisposable. Il metodo Dispose del campo non viene chiamato dal metodo Dispose del tipo dichiarante. Per correggere una violazione di questa regola, chiamare Dispose su campi di tipi che implementano IDisposable se si è responsabile dell'allocazione e del rilascio delle risorse non gestite utilizzate dal campo.</target>
        <note />
      </trans-unit>
      <trans-unit id="Disposable_field_0_is_never_disposed">
        <source>Disposable field '{0}' is never disposed</source>
        <target state="translated">Il campo eliminabile '{0}' non viene mai eliminato</target>
        <note />
      </trans-unit>
      <trans-unit id="Disposable_fields_should_be_disposed">
        <source>Disposable fields should be disposed</source>
        <target state="translated">I campi eliminabili devono essere eliminati</target>
        <note />
      </trans-unit>
      <trans-unit id="Disposable_object_created_by_0_is_never_disposed">
        <source>Disposable object created by '{0}' is never disposed</source>
        <target state="translated">L'oggetto eliminabile creato da '{0}' non viene mai eliminato</target>
        <note />
      </trans-unit>
      <trans-unit id="Dispose_objects_before_losing_scope">
        <source>Dispose objects before losing scope</source>
        <target state="translated">Elimina gli oggetti prima che siano esterni all'ambito</target>
        <note />
      </trans-unit>
      <trans-unit id="Do_not_change_this_code_Put_cleanup_code_in_0_method">
        <source>Do not change this code. Put cleanup code in '{0}' method</source>
        <target state="translated">Non modificare questo codice. Inserire il codice di pulizia nel metodo '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="DocumentIsOutOfSyncWithDebuggee">
        <source>The current content of source file '{0}' does not match the built source. Any changes made to this file while debugging won't be applied until its content matches the built source.</source>
        <target state="translated">Il contenuto corrente del file di origine '{0}' non corrisponde al codice sorgente compilato. Tutte le modifiche apportate a questo file durante il debug non verranno applicate finché il relativo contenuto non corrisponde al codice sorgente compilato.</target>
        <note />
      </trans-unit>
      <trans-unit id="Document_must_be_contained_in_the_workspace_that_created_this_service">
        <source>Document must be contained in the workspace that created this service</source>
        <target state="translated">Il documento deve essere contenuto nell'area di lavoro che ha creato il servizio</target>
        <note />
      </trans-unit>
      <trans-unit id="EditAndContinue">
        <source>Edit and Continue</source>
        <target state="translated">Modifica e continuazione</target>
        <note />
      </trans-unit>
      <trans-unit id="EditAndContinueDisallowedByModule">
        <source>Edit and Continue disallowed by module</source>
        <target state="translated">Modifica e continuazione non consentito dal modulo</target>
        <note />
      </trans-unit>
      <trans-unit id="EditAndContinueDisallowedByProject">
        <source>Changes made in project '{0}' will prevent the debug session from continuing: {1}</source>
        <target state="translated">Le modifiche apportate al progetto '{0}' impediranno la continuazione della sessione di debug: {1}</target>
        <note />
      </trans-unit>
      <trans-unit id="ErrorReadingFile">
        <source>Error while reading file '{0}': {1}</source>
        <target state="translated">Si è verificato un errore durante la lettura del file '{0}': {1}</target>
        <note />
      </trans-unit>
      <trans-unit id="Error_creating_instance_of_CodeFixProvider">
        <source>Error creating instance of CodeFixProvider</source>
        <target state="new">Error creating instance of CodeFixProvider</target>
        <note />
      </trans-unit>
      <trans-unit id="Error_creating_instance_of_CodeFixProvider_0">
        <source>Error creating instance of CodeFixProvider '{0}'</source>
        <target state="new">Error creating instance of CodeFixProvider '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Example">
        <source>Example:</source>
        <target state="translated">Esempio:</target>
        <note>Singular form when we want to show an example, but only have one to show.</note>
      </trans-unit>
      <trans-unit id="Examples">
        <source>Examples:</source>
        <target state="translated">Esempi:</target>
        <note>Plural form when we have multiple examples to show.</note>
      </trans-unit>
      <trans-unit id="Extract_base_class">
        <source>Extract base class...</source>
        <target state="translated">Estrai classe di base...</target>
        <note />
      </trans-unit>
      <trans-unit id="Extract_interface">
        <source>Extract interface...</source>
        <target state="translated">Estrai interfaccia...</target>
        <note />
      </trans-unit>
      <trans-unit id="Extract_local_function">
        <source>Extract local function</source>
        <target state="translated">Estrai funzione locale</target>
        <note />
      </trans-unit>
      <trans-unit id="Extract_method">
        <source>Extract method</source>
        <target state="translated">Estrai il metodo</target>
        <note />
      </trans-unit>
      <trans-unit id="Failed_to_analyze_data_flow_for_0">
        <source>Failed to analyze data-flow for: {0}</source>
        <target state="translated">Non è stato possibile analizzare il flusso di dati per: {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Fix_formatting">
        <source>Fix formatting</source>
        <target state="translated">Correggi formattazione</target>
        <note />
      </trans-unit>
      <trans-unit id="Fix_typo_0">
        <source>Fix typo '{0}'</source>
        <target state="translated">Correggi l'errore di ortografia '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Formatting_document">
        <source>Formatting document</source>
        <target state="translated">Formattazione del documento</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_comparison_operators">
        <source>Generate comparison operators</source>
        <target state="translated">Genera gli operatori di confronto</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_constructor_in_0_with_fields">
        <source>Generate constructor in '{0}' (with fields)</source>
        <target state="translated">Genera il costruttore in '{0}' (con campi)</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_constructor_in_0_with_properties">
        <source>Generate constructor in '{0}' (with properties)</source>
        <target state="translated">Genera il costruttore in '{0}' (con proprietà)</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_for_0">
        <source>Generate for '{0}'</source>
        <target state="translated">Genera per '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_parameter_0">
        <source>Generate parameter '{0}'</source>
        <target state="translated">Generare il parametro '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_parameter_0_and_overrides_implementations">
        <source>Generate parameter '{0}' (and overrides/implementations)</source>
        <target state="translated">Generare il parametro '{0}' (e override/implementazioni)</target>
        <note />
      </trans-unit>
      <trans-unit id="Illegal_backslash_at_end_of_pattern">
        <source>Illegal \ at end of pattern</source>
        <target state="translated">Carattere \ non valido alla fine del criterio</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \</note>
      </trans-unit>
      <trans-unit id="Illegal_x_y_with_x_less_than_y">
        <source>Illegal {x,y} with x &gt; y</source>
        <target state="translated">{x,y} non valido con x &gt; y</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0}</note>
      </trans-unit>
      <trans-unit id="Implement_0_explicitly">
        <source>Implement '{0}' explicitly</source>
        <target state="translated">Implementa '{0}' in modo esplicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_0_implicitly">
        <source>Implement '{0}' implicitly</source>
        <target state="translated">Implementa '{0}' in modo implicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_abstract_class">
        <source>Implement abstract class</source>
        <target state="translated">Implementa la classe astratta</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_all_interfaces_explicitly">
        <source>Implement all interfaces explicitly</source>
        <target state="translated">Implementa tutte le interfacce in modo esplicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_all_interfaces_implicitly">
        <source>Implement all interfaces implicitly</source>
        <target state="translated">Implementa tutte le interfacce in modo implicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_all_members_explicitly">
        <source>Implement all members explicitly</source>
        <target state="translated">Implementare tutti i membri in modo esplicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_explicitly">
        <source>Implement explicitly</source>
        <target state="translated">Implementa in modo esplicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_implicitly">
        <source>Implement implicitly</source>
        <target state="translated">Implementa in modo implicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_remaining_members_explicitly">
        <source>Implement remaining members explicitly</source>
        <target state="translated">Implementare i membri rimanenti in modo esplicito</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_through_0">
        <source>Implement through '{0}'</source>
        <target state="translated">Implementa tramite '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Incomplete_character_escape">
        <source>Incomplete \p{X} character escape</source>
        <target state="translated">Sequenza di caratteri di escape \p{X} incompleta</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc }</note>
      </trans-unit>
      <trans-unit id="Indent_all_arguments">
        <source>Indent all arguments</source>
        <target state="translated">Imposta rientro per tutti gli argomenti</target>
        <note />
      </trans-unit>
      <trans-unit id="Indent_all_parameters">
        <source>Indent all parameters</source>
        <target state="translated">Imposta rientro per tutti i parametri</target>
        <note />
      </trans-unit>
      <trans-unit id="Indent_wrapped_arguments">
        <source>Indent wrapped arguments</source>
        <target state="translated">Imposta rientro per argomenti con ritorno a capo</target>
        <note />
      </trans-unit>
      <trans-unit id="Indent_wrapped_parameters">
        <source>Indent wrapped parameters</source>
        <target state="translated">Imposta rientro per parametri con ritorno a capo</target>
        <note />
      </trans-unit>
      <trans-unit id="Inline_0">
        <source>Inline '{0}'</source>
        <target state="translated">Imposta '{0}' come inline</target>
        <note />
      </trans-unit>
      <trans-unit id="Inline_and_keep_0">
        <source>Inline and keep '{0}'</source>
        <target state="translated">Imposta come inline e mantieni '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Insufficient_hexadecimal_digits">
        <source>Insufficient hexadecimal digits</source>
        <target state="translated">Cifre esadecimali insufficienti</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \x</note>
      </trans-unit>
      <trans-unit id="Introduce_constant">
        <source>Introduce constant</source>
        <target state="translated">Introduci costante</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_field">
        <source>Introduce field</source>
        <target state="translated">Introduci campo</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_local">
        <source>Introduce local</source>
        <target state="translated">Introduci variabile locale</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_query_variable">
        <source>Introduce query variable</source>
        <target state="translated">Introduci la variabile di query</target>
        <note />
      </trans-unit>
      <trans-unit id="Invalid_group_name_Group_names_must_begin_with_a_word_character">
        <source>Invalid group name: Group names must begin with a word character</source>
        <target state="translated">Nome di gruppo non valido: i nomi di gruppo devono iniziare con un carattere alfanumerico</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?&lt;a &gt;a)</note>
      </trans-unit>
      <trans-unit id="Make_class_abstract">
        <source>Make class 'abstract'</source>
        <target state="translated">Rendi la classe 'abstract'</target>
        <note />
      </trans-unit>
      <trans-unit id="Make_member_static">
        <source>Make static</source>
        <target state="translated">Imposta come statici</target>
        <note />
      </trans-unit>
      <trans-unit id="Invert_conditional">
        <source>Invert conditional</source>
        <target state="translated">Inverti espressione condizionale</target>
        <note />
      </trans-unit>
      <trans-unit id="Malformed">
        <source>malformed</source>
        <target state="translated">non valido</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0</note>
      </trans-unit>
      <trans-unit id="Malformed_character_escape">
        <source>Malformed \p{X} character escape</source>
        <target state="translated">Sequenza di caratteri di escape \\p{X} non valida</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc}</note>
      </trans-unit>
      <trans-unit id="Malformed_named_back_reference">
        <source>Malformed \k&lt;...&gt; named back reference</source>
        <target state="translated">Backreference denominato \k&lt;...&gt; in formato non corretto</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \k'</note>
      </trans-unit>
      <trans-unit id="Merge_with_nested_0_statement">
        <source>Merge with nested '{0}' statement</source>
        <target state="translated">Unisci con istruzione '{0}' nidificata</target>
        <note />
      </trans-unit>
      <trans-unit id="Merge_with_next_0_statement">
        <source>Merge with next '{0}' statement</source>
        <target state="translated">Unisci con istruzione '{0}' successiva</target>
        <note />
      </trans-unit>
      <trans-unit id="Merge_with_outer_0_statement">
        <source>Merge with outer '{0}' statement</source>
        <target state="translated">Unisci con istruzione '{0}' esterna</target>
        <note />
      </trans-unit>
      <trans-unit id="Merge_with_previous_0_statement">
        <source>Merge with previous '{0}' statement</source>
        <target state="translated">Unisci con istruzione '{0}' precedente</target>
        <note />
      </trans-unit>
      <trans-unit id="MethodMustReturnStreamThatSupportsReadAndSeek">
        <source>{0} must return a stream that supports read and seek operations.</source>
        <target state="translated">{0} deve restituire un flusso che supporta operazioni di lettura e ricerca.</target>
        <note />
      </trans-unit>
      <trans-unit id="Missing_control_character">
        <source>Missing control character</source>
        <target state="translated">Carattere di controllo mancante</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \c</note>
      </trans-unit>
      <trans-unit id="Modifying_0_which_contains_a_switch_expression_will_prevent_the_debug_session_from_continuing">
        <source>Modifying '{0}' which contains a switch expression will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica '{0}' che contiene un'espressione switch, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_body_of_member_will_prevent_the_debug_session_from_continuing_because_the_body_has_too_many_statements">
        <source>Modifying the body of '{0}' will prevent the debug session from continuing because the body has too many statements.</source>
        <target state="translated">Se si modifica il corpo di '{0}', la sessione di debug non potrà continuare perché il corpo contiene troppe istruzioni.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_body_of_member_will_prevent_the_debug_session_from_continuing_due_to_internal_error">
        <source>Modifying the body of '{0}' will prevent the debug session from continuing due to internal error: {1}</source>
        <target state="translated">Se si modifica il corpo di '{0}', la sessione di debug non potrà continuare a causa dell'errore interno {1}</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_source_file_will_prevent_the_debug_session_from_continuing_because_the_file_is_too_big">
        <source>Modifying source file '{0}' will prevent the debug session from continuing because the file is too big.</source>
        <target state="translated">Se si modifica il file di origine '{0}', la sessione di debug non potrà continuare perché le dimensioni del file sono eccessive.</target>
        <note />
      </trans-unit>
      <trans-unit id="Move_contents_to_namespace">
        <source>Move contents to namespace...</source>
        <target state="translated">Sposta contenuto nello spazio dei nomi...</target>
        <note />
      </trans-unit>
      <trans-unit id="Move_file_to_0">
        <source>Move file to '{0}'</source>
        <target state="translated">Sposta il file in '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Move_file_to_project_root_folder">
        <source>Move file to project root folder</source>
        <target state="translated">Sposta il file nella cartella radice del progetto</target>
        <note />
      </trans-unit>
      <trans-unit id="Move_to_namespace">
        <source>Move to namespace...</source>
        <target state="translated">Sposta nello spazio dei nomi...</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_source_file_will_prevent_the_debug_session_from_continuing_due_to_internal_error">
        <source>Modifying source file '{0}' will prevent the debug session from continuing due to internal error: {1}</source>
        <target state="translated">Se si modifica il file di origine '{0}', la sessione di debug non potrà continuare a causa dell'errore interno {1}</target>
        <note />
      </trans-unit>
      <trans-unit id="Nested_quantifier_0">
        <source>Nested quantifier {0}</source>
        <target state="translated">Quantificatore nidificato {0}</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier.</note>
      </trans-unit>
      <trans-unit id="No_valid_location_to_insert_method_call">
        <source>No valid location to insert method call.</source>
        <target state="translated">Non ci sono posizioni valide per inserire la chiamata a un metodo.</target>
        <note />
      </trans-unit>
      <trans-unit id="Not_enough_close_parens">
        <source>Not enough )'s</source>
        <target state="translated">Parentesi chiuse insufficienti</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (a</note>
      </trans-unit>
      <trans-unit id="Property_reference_cannot_be_updated">
        <source>Property reference cannot be updated</source>
        <target state="translated">Non è possibile aggiornare il riferimento alla proprietà</target>
        <note />
      </trans-unit>
      <trans-unit id="Pull_0_up">
        <source>Pull '{0}' up</source>
        <target state="translated">Esegui pull '{0}' al livello superiore</target>
        <note />
      </trans-unit>
      <trans-unit id="Pull_0_up_to_1">
        <source>Pull '{0}' up to '{1}'</source>
        <target state="translated">Esegui pull di '{0}' fino a '{1}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Pull_members_up_to_base_type">
        <source>Pull members up to base type...</source>
        <target state="translated">Esegui pull dei membri fino al tipo di base...</target>
        <note />
      </trans-unit>
      <trans-unit id="Pull_members_up_to_new_base_class">
        <source>Pull member(s) up to new base class...</source>
        <target state="translated">Esegui pull dei membri fino alla nuova classe di base...</target>
        <note />
      </trans-unit>
      <trans-unit id="Quantifier_x_y_following_nothing">
        <source>Quantifier {x,y} following nothing</source>
        <target state="translated">Il quantificatore {x,y} non segue alcun elemento</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: *</note>
      </trans-unit>
      <trans-unit id="Reference_to_undefined_group">
        <source>reference to undefined group</source>
        <target state="translated">riferimento a gruppo indefinito</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1))</note>
      </trans-unit>
      <trans-unit id="Reference_to_undefined_group_name_0">
        <source>Reference to undefined group name {0}</source>
        <target state="translated">Riferimento a nome di gruppo indefinito: {0}</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \k&lt;a&gt;. Here, {0} will be the name of the undefined group ('a')</note>
      </trans-unit>
      <trans-unit id="Reference_to_undefined_group_number_0">
        <source>Reference to undefined group number {0}</source>
        <target state="translated">Riferimento a numero di gruppo indefinito: {0}</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?&lt;-1&gt;). Here, {0} will be the number of the undefined group ('1')</note>
      </trans-unit>
      <trans-unit id="Regex_all_control_characters_long">
        <source>All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories.</source>
        <target state="translated">Tutti i caratteri di controllo. Sono incluse le categorie Cc, Cf, Cs, Co e Cn.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_control_characters_short">
        <source>all control characters</source>
        <target state="translated">tutti i caratteri di controllo</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_diacritic_marks_long">
        <source>All diacritic marks. This includes the Mn, Mc, and Me categories.</source>
        <target state="translated">Tutti i contrassegni diacritici. Sono incluse le categorie Mn, Mc e Me.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_diacritic_marks_short">
        <source>all diacritic marks</source>
        <target state="translated">tutti i contrassegni diacritici</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_letter_characters_long">
        <source>All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters.</source>
        <target state="translated">Tutti i caratteri alfanumerici. Sono incluse le categorie Lu, Ll, Lt, Lm e Lo.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_letter_characters_short">
        <source>all letter characters</source>
        <target state="translated">tutti i caratteri alfanumerici</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_numbers_long">
        <source>All numbers. This includes the Nd, Nl, and No categories.</source>
        <target state="translated">Tutti i numeri. Sono incluse le categorie Nd, Nl e No.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_numbers_short">
        <source>all numbers</source>
        <target state="translated">tutti i numeri</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_punctuation_characters_long">
        <source>All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.</source>
        <target state="translated">Tutti i caratteri di punteggiatura. Sono incluse le categorie Pc, Pd, Ps, Pe, Pi, Pf e Po.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_punctuation_characters_short">
        <source>all punctuation characters</source>
        <target state="translated">tutti i caratteri di punteggiatura</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_separator_characters_long">
        <source>All separator characters. This includes the Zs, Zl, and Zp categories.</source>
        <target state="translated">Tutti i caratteri separatori. Sono incluse le categorie Zs, Zl e Zp.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_separator_characters_short">
        <source>all separator characters</source>
        <target state="translated">tutti i caratteri separatori</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_symbols_long">
        <source>All symbols. This includes the Sm, Sc, Sk, and So categories.</source>
        <target state="translated">Tutti i simboli. Sono incluse le categorie Sm, Sc, Sk e So.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_all_symbols_short">
        <source>all symbols</source>
        <target state="translated">tutti i simboli</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_alternation_long">
        <source>You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern.</source>
        <target state="translated">È possibile usare la barra verticale (|) per trovare la corrispondenza con uno qualsiasi di una serie di criteri, dove i singoli criteri sono separati dal carattere |.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_alternation_short">
        <source>alternation</source>
        <target state="translated">alternanza</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_any_character_group_long">
        <source>The period character (.) matches any character except \n (the newline character, \u000A).  If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character.</source>
        <target state="translated">Il carattere punto (.) corrisponde a qualsiasi carattere tranne \n (carattere di nuova riga \u000A).  Se un criterio di ricerca di espressioni regolari viene modificato dall'opzione RegexOptions.Singleline o se la parte del criterio contenente la classe di caratteri . viene modificata dall'opzione 's', . corrisponde a qualsiasi carattere.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_any_character_group_short">
        <source>any character</source>
        <target state="translated">qualsiasi carattere</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_atomic_group_long">
        <source>Atomic groups (known in some other regular expression engines as a nonbacktracking subexpression, an atomic subexpression, or a once-only subexpression) disable backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.)

This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance.</source>
        <target state="translated">I gruppi atomici (noti in alcuni motori delle espressioni regolari come sottoespressione di non backtracking, sottoespressione atomica o sottoespressione once-only) disabilitano il backtracking. Il motore delle espressioni regolari troverà la corrispondenza con il numero massimo possibile di caratteri nella stringa di input. Quando non sarà più possibile trovare altre corrispondenze, non eseguirà il backtracking per trovare corrispondenze alternative con i criteri. Viene quindi trovata la corrispondenza della sottoespressione solo con stringhe corrispondenti esclusivamente alla sottoespressione; non viene effettuato alcun tentativo per trovare la corrispondenza per una stringa in base alla sottoespressione e a qualsiasi sottoespressione successiva.

Questa opzione è consigliata solo se si è certi che il backtracking avrà esito negativo. Impedendo al motore delle espressioni regolari di eseguire ricerche non necessarie è possibile notare un miglioramento delle prestazioni.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_atomic_group_short">
        <source>atomic group</source>
        <target state="translated">gruppo atomico</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_backspace_character_long">
        <source>Matches a backspace character, \u0008</source>
        <target state="translated">Trova la corrispondenza di un carattere backspace \u0008</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_backspace_character_short">
        <source>backspace character</source>
        <target state="translated">carattere backspace</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_balancing_group_long">
        <source>A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group.
    
'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.

The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty.</source>
        <target state="translated">Una definizione di gruppo di bilanciamento elimina la definizione di un gruppo precedentemente definito e archivia nel gruppo corrente l'intervallo tra il gruppo precedentemente definito e il gruppo corrente.
    
'name1' è il gruppo corrente (facoltativo), 'name2' è un gruppo precedentemente definito e 'subexpression' è qualsiasi criterio di ricerca di espressioni regolari valido. La definizione di gruppo di bilanciamento elimina la definizione di name2 e archivia l'intervallo tra name2 e name1 in name1. Se non è definito alcun gruppo name2, viene eseguito il backtracking della corrispondenza. Dal momento che l'eliminazione dell'ultima definizione di name2 rivela la definizione precedente di name2, questo costrutto consente di usare lo stack di acquisizioni per il gruppo name2 come contatore per tenere traccia dei costrutti annidati, come ad esempio le parentesi o le parentesi quadre di apertura e chiusura.

La definizione del gruppo di bilanciamento usa 'name2' come uno stack. Il carattere iniziale di ogni costrutto annidato viene posizionato nel gruppo e nella relativa raccolta Group.Captures. Quando viene trovata la corrispondenza con il carattere di chiusura, il carattere di apertura associato viene rimosso dal gruppo e la raccolta Captures viene ridotta di uno. Dopo che la corrispondenza dei caratteri di apertura e chiusura di tutti i costrutti annidati è stata trovata, 'name1' è vuoto.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_balancing_group_short">
        <source>balancing group</source>
        <target state="translated">gruppo di bilanciamento</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_base_group">
        <source>base-group</source>
        <target state="translated">gruppo di base</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_bell_character_long">
        <source>Matches a bell (alarm) character, \u0007</source>
        <target state="translated">Trova la corrispondenza di un carattere di controllo del segnale acustico di avviso \u0007</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_bell_character_short">
        <source>bell character</source>
        <target state="translated">carattere di controllo del segnale acustico di avviso</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_carriage_return_character_long">
        <source>Matches a carriage-return character, \u000D.  Note that \r is not equivalent to the newline character, \n.</source>
        <target state="translated">Trova la corrispondenza di un carattere di ritorno a capo \u000D.  Si noti che \r non equivale al carattere di nuova riga \n.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_carriage_return_character_short">
        <source>carriage-return character</source>
        <target state="translated">carattere di ritorno a capo</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_character_class_subtraction_long">
        <source>Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.

'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).</source>
        <target state="translated">La sottrazione di classi di caratteri produce un set di caratteri che è il risultato dell'esclusione dei caratteri di una classe di caratteri da un'altra classe di caratteri.

'base_group' è un gruppo o un intervallo di caratteri positivi o negativi. Il componente 'excluded_group' è un altro gruppo di caratteri positivi o negativi o un'altra espressione di sottrazione di classi di caratteri, ovvero è possibile annidare espressioni di sottrazione di classi di caratteri.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_character_class_subtraction_short">
        <source>character class subtraction</source>
        <target state="translated">sottrazione di classi di caratteri</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_character_group">
        <source>character-group</source>
        <target state="translated">gruppo di caratteri</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_comment">
        <source>comment</source>
        <target state="translated">commento</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_conditional_expression_match_long">
        <source>This language element attempts to match one of two patterns depending on whether it can match an initial pattern.

'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched.</source>
        <target state="translated">Questo elemento del linguaggio effettua un tentativo per trovare una corrispondenza con uno di due criteri, a seconda della possibilità di trovare una corrispondenza con un criterio iniziale.

dove 'expression' è il criterio iniziale per la corrispondenza, 'yes' è il criterio di corrispondenza se viene trovata una corrispondenza per l'espressione e 'no' è il criterio facoltativo di corrispondenza se non viene trovata una corrispondenza per l'espressione.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_conditional_expression_match_short">
        <source>conditional expression match</source>
        <target state="translated">corrispondenza di espressione condizionale</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_conditional_group_match_long">
        <source>This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group.

'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not.</source>
        <target state="translated">Questo elemento del linguaggio effettua un tentativo per trovare una corrispondenza con uno di due criteri, a seconda dell'effettiva corrispondenza con un gruppo di acquisizione specificato.

'name' è il nome (o il numero) di un gruppo di acquisizione, 'yes' è l'espressione di cui trovare la corrispondenza se per 'name' (o 'number') è disponibile una corrispondenza e 'no' è l'espressione facoltativa di cui trovare la corrispondenza in caso contrario.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_conditional_group_match_short">
        <source>conditional group match</source>
        <target state="translated">corrispondenza di gruppo condizionale</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_contiguous_matches_long">
        <source>The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous.</source>
        <target state="translated">L'ancoraggio \G specifica che la corrispondenza deve verificarsi nel punto in cui è terminata la corrispondenza precedente. Se usato con il metodo Regex.Matches o Match.NextMatch, questo ancoraggio garantisce che tutte le corrispondenze siano contigue.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_contiguous_matches_short">
        <source>contiguous matches</source>
        <target state="translated">corrispondenze contigue</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_control_character_long">
        <source>Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C.</source>
        <target state="translated">Trova la corrispondenza di un carattere di controllo ASCII, dove X è la lettera del carattere di controllo. Ad esempio, \cC corrisponde a CTRL+C.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_control_character_short">
        <source>control character</source>
        <target state="translated">carattere di controllo</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_decimal_digit_character_long">
        <source>\d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.

If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9]</source>
        <target state="translated">\d trova la corrispondenza di qualsiasi cifra decimale. Equivale al criterio di ricerca di espressioni regolari \p{Nd}, che include le cifre decimali standard da 0 a 9 e le cifre decimali di altri set di caratteri.

Se viene specificato il comportamento conforme a ECMAScript, \d equivale a [0-9]</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_decimal_digit_character_short">
        <source>decimal-digit character</source>
        <target state="translated">carattere di cifra decimale</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_end_of_line_comment_long">
        <source>A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method.</source>
        <target state="translated">Un cancelletto (#) contrassegna un commento in modalità x, che inizia in corrispondenza del carattere senza escape # alla fine del criterio di ricerca di espressioni regolari e continua fino alla fine della riga. Per usare questo costrutto, è necessario abilitare l'opzione x (con opzioni inline) o specificare il valore RegexOptions.IgnorePatternWhitespace per il parametro option quando si crea l'istanza dell'oggetto Regex o si chiama un metodo statico Regex.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_end_of_line_comment_short">
        <source>end-of-line comment</source>
        <target state="translated">commento di fine riga</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_end_of_string_only_long">
        <source>The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string.</source>
        <target state="translated">L'ancoraggio \z specifica che la corrispondenza deve verificarsi alla fine della stringa di input. Come per l'elemento del linguaggio $, \z ignora l'opzione RegexOptions.Multiline. Diversamente dall'elemento del linguaggio \Z, \z non trova un carattere \n alla fine di una stringa. Di conseguenza, può trovare solo l'ultima riga della stringa di input.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_end_of_string_only_short">
        <source>end of string only</source>
        <target state="translated">solo fine di stringa</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_end_of_string_or_before_ending_newline_long">
        <source>The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n.

The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern.</source>
        <target state="translated">L'ancoraggio \Z specifica che la corrispondenza deve verificarsi alla fine della stringa di input oppure prima di \n alla fine della stringa di input. L'ancoraggio è identico a $, ad eccezione del fatto che \Z ignora l'opzione RegexOptions.Multiline. Di conseguenza, in una stringa con più righe può trovare solo la fine dell'ultima riga oppure l'ultima riga prima di \n.

L'ancoraggio \Z corrisponde a \n, ma non a \r\n (combinazione di caratteri CR/LF). Per trovare la combinazione di caratteri CR/LF, includere \r?\Z nel criterio di ricerca di espressioni regolari.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_end_of_string_or_before_ending_newline_short">
        <source>end of string or before ending newline</source>
        <target state="translated">fine di stringa o prima di terminare una nuova riga</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_end_of_string_or_line_long">
        <source>The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line.

The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern.</source>
        <target state="translated">L'ancoraggio $ specifica che il criterio precedente deve verificarsi alla fine della stringa di input oppure prima di \n alla fine della stringa di input. Se si usa $ con l'opzione RegexOptions.Multiline, la corrispondenza può verificarsi anche alla fine di una riga.

L'ancoraggio $ corrisponde a \n, ma non a \r\n (combinazione di ritorno a capo e caratteri di nuova riga o CR/LF). Per trovare la combinazione di caratteri CR/LF, includere \r?$ nel criterio di ricerca di espressioni regolari.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_end_of_string_or_line_short">
        <source>end of string or line</source>
        <target state="translated">fine di stringa o riga</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_escape_character_long">
        <source>Matches an escape character, \u001B</source>
        <target state="translated">Trova la corrispondenza di un carattere di escape \u001B</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_escape_character_short">
        <source>escape character</source>
        <target state="translated">carattere di escape</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_excluded_group">
        <source>excluded-group</source>
        <target state="translated">gruppo escluso</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_expression">
        <source>expression</source>
        <target state="translated">espressione</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_form_feed_character_long">
        <source>Matches a form-feed character, \u000C</source>
        <target state="translated">Trova la corrispondenza di un carattere di avanzamento carta \u000C</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_form_feed_character_short">
        <source>form-feed character</source>
        <target state="translated">carattere di avanzamento carta</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_group_options_long">
        <source>This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are:

    i	Use case-insensitive matching.
    m	Use multiline mode, where ^ and $ match the beginning and end of each line
	(instead of the beginning and end of the input string).
    s	Use single-line mode, where the period (.) matches every character
	(instead of every character except \n).
    n	Do not capture unnamed groups. The only valid captures are explicitly
	named or numbered groups of the form (?&lt;name&gt; subexpression).
    x	Exclude unescaped white space from the pattern, and enable comments
	after a number sign (#).</source>
        <target state="translated">Questo costrutto di raggruppamento applica o disabilita le opzioni specificate all'interno di una sottoespressione. Le opzioni da abilitare vengono specificate dopo il punto interrogativo, mentre quelle da disabilitare vengono specificate dopo il segno meno. Le opzioni consentite sono:

    i	Usa la corrispondenza che non fa distinzione tra maiuscole e minuscole.
    m	Usa la modalità multiriga, in cui ^ e $ corrispondono all'inizio e alla fine di ogni riga
	anziché all'inizio e alla fine della stringa di input.
    s	Usa la modalità a riga singola, in cui il punto (.) corrisponde a qualsiasi carattere
	anziché a ogni carattere eccetto \n.
    n	Non acquisisce gruppi senza nome. Le uniche acquisizioni valide sono i gruppi
	denominati o numerati in modo esplicito in formato (?&lt;nome&gt; sottoespressione).
    x	Esclude gli spazi vuoti senza caratteri di escape nel criterio e abilita i commenti
	dopo un simbolo di cancelletto (#).</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_group_options_short">
        <source>group options</source>
        <target state="translated">opzioni di raggruppamento</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_hexadecimal_escape_long">
        <source>Matches an ASCII character, where ## is a two-digit hexadecimal character code.</source>
        <target state="translated">Trova la corrispondenza di un carattere ASCII dove nn è un codice carattere esadecimale a due cifre.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_hexadecimal_escape_short">
        <source>hexadecimal escape</source>
        <target state="translated">carattere di escape esadecimale</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_inline_comment_long">
        <source>The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis.</source>
        <target state="translated">Il costrutto (?# comment) consente di includere un commento inline in un'espressione regolare. Il motore delle espressioni regolari non usa una parte del commento nei criteri di ricerca, anche se il commento è incluso nella stringa restituita dal metodo Regex.ToString. Il commento termina in corrispondenza della prima parentesi chiusa.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_inline_comment_short">
        <source>inline comment</source>
        <target state="translated">commento inline</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_inline_options_long">
        <source>Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are:

    i	Use case-insensitive matching.
    m	Use multiline mode, where ^ and $ match the beginning and end of each line
	(instead of the beginning and end of the input string).
    s	Use single-line mode, where the period (.) matches every character
	(instead of every character except \n).
    n	Do not capture unnamed groups. The only valid captures are explicitly named
	or numbered groups of the form (?&lt;name&gt; subexpression).
    x	Exclude unescaped white space from the pattern, and enable comments
	after a number sign (#).</source>
        <target state="translated">Abilita o disabilita opzioni specifiche dei criteri di ricerca per il resto di un'espressione regolare. Le opzioni da abilitare vengono specificate dopo il punto interrogativo, mentre quelle da disabilitare vengono specificate dopo il segno meno. Le opzioni consentite sono:

    i	Usa la corrispondenza che non fa distinzione tra maiuscole e minuscole.
    m	Usa la modalità multiriga, in cui ^ e $ corrispondono all'inizio e alla fine di ogni riga
	anziché all'inizio e alla fine della stringa di input.
    s	Usa la modalità a riga singola, in cui il punto (.) corrisponde a qualsiasi carattere
	anziché a ogni carattere eccetto \n.
    n	Non acquisisce gruppi senza nome. Le uniche acquisizioni valide sono gruppi
	denominati o numerati in modo esplicito nel formato (?&lt;nome&gt; sottoespressione).
    x	Esclude gli spazi vuoti senza caratteri di escape nel criterio e abilita i commenti
	dopo un simbolo di cancelletto (#).</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_inline_options_short">
        <source>inline options</source>
        <target state="translated">opzioni inline</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_issue_0">
        <source>Regex issue: {0}</source>
        <target state="translated">Problema di regex: {0}</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. {0} will be the actual text of one of the above Regular Expression errors.</note>
      </trans-unit>
      <trans-unit id="Regex_letter_lowercase">
        <source>letter, lowercase</source>
        <target state="translated">alfanumerico, minuscolo</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_letter_modifier">
        <source>letter, modifier</source>
        <target state="translated">alfanumerico, modificatore</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_letter_other">
        <source>letter, other</source>
        <target state="translated">alfanumerico, altro</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_letter_titlecase">
        <source>letter, titlecase</source>
        <target state="translated">alfanumerico, titolo</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_letter_uppercase">
        <source>letter, uppercase</source>
        <target state="translated">alfanumerico, maiuscolo</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_mark_enclosing">
        <source>mark, enclosing</source>
        <target state="translated">contrassegno, chiusura</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_mark_nonspacing">
        <source>mark, nonspacing</source>
        <target state="translated">contrassegno, non spaziatura</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_mark_spacing_combining">
        <source>mark, spacing combining</source>
        <target state="translated">contrassegno, spaziatura combinata</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_at_least_n_times_lazy_long">
        <source>The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,}</source>
        <target state="translated">Il quantificatore {n,}? trova la corrispondenza con l'elemento precedente almeno n volte, dove n è qualsiasi numero intero, ma il minor numero di volte possibile. Si tratta della controparte lazy del quantificatore greedy {n,}</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_at_least_n_times_lazy_short">
        <source>match at least 'n' times (lazy)</source>
        <target state="translated">trova la corrispondenza almeno 'n' volte (corrispondenza lazy)</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_at_least_n_times_long">
        <source>The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}?</source>
        <target state="translated">Il quantificatore {n,} trova la corrispondenza con l'elemento precedente almeno n volte, dove n è qualsiasi numero intero. {n,} è un quantificatore greedy il cui equivalente lazy è {n,}?</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_at_least_n_times_short">
        <source>match at least 'n' times</source>
        <target state="translated">trova la corrispondenza almeno 'n' volte</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_between_m_and_n_times_lazy_long">
        <source>The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m}</source>
        <target state="translated">Il quantificatore {n,m}? trova la corrispondenza con l'elemento precedente tra n e m volte, dove n e m sono numeri interi, ma il minor numero di volte possibile. Si tratta della controparte lazy del quantificatore greedy {n,m}</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_between_m_and_n_times_lazy_short">
        <source>match at least 'n' times (lazy)</source>
        <target state="translated">trova la corrispondenza almeno 'n' volte (corrispondenza lazy)</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_between_m_and_n_times_long">
        <source>The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}?</source>
        <target state="translated">Il quantificatore {n,m} trova la corrispondenza con l'elemento precedente almeno n volte, ma non più di m volte, dove n e m sono numeri interi. {n,m} è un quantificatore greedy il cui equivalente lazy è {n,m}?</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_between_m_and_n_times_short">
        <source>match between 'm' and 'n' times</source>
        <target state="translated">trova la corrispondenza tra 'n' e 'm' volte</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_exactly_n_times_lazy_long">
        <source>The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+</source>
        <target state="translated">Il quantificatore {n}? trova la corrispondenza con l'elemento precedente esattamente n volte, dove n è qualsiasi numero intero. Si tratta della controparte lazy del quantificatore greedy {n}+</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_exactly_n_times_lazy_short">
        <source>match exactly 'n' times (lazy)</source>
        <target state="translated">trova la corrispondenza esatta 'n' volte (corrispondenza lazy)</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_exactly_n_times_long">
        <source>The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}?</source>
        <target state="translated">Il quantificatore {n} trova la corrispondenza con l'elemento precedente esattamente n volte, dove n è qualsiasi numero intero. {n} è un quantificatore greedy il cui equivalente lazy è {n}?</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_exactly_n_times_short">
        <source>match exactly 'n' times</source>
        <target state="translated">trova la corrispondenza esatta 'n' volte</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_one_or_more_times_lazy_long">
        <source>The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier +</source>
        <target state="translated">Il quantificatore +? trova la corrispondenza con l'elemento precedente una o più volte, ma il minor numero di volte possibile. Si tratta della controparte lazy del quantificatore greedy +</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_one_or_more_times_lazy_short">
        <source>match one or more times (lazy)</source>
        <target state="translated">trova la corrispondenza una o più volte (corrispondenza lazy)</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_one_or_more_times_long">
        <source>The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?.</source>
        <target state="translated">Il quantificatore + trova la corrispondenza con l'elemento precedente una o più volte. Equivale al quantificatore {1,}. + è un quantificatore greedy il cui equivalente lazy è +?.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_one_or_more_times_short">
        <source>match one or more times</source>
        <target state="translated">trova la corrispondenza una o più volte</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_zero_or_more_times_lazy_long">
        <source>The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier *</source>
        <target state="translated">Il quantificatore *? trova la corrispondenza con l'elemento precedente zero o più volte, ma il minor numero di volte possibile. Si tratta della controparte lazy del quantificatore greedy *</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_zero_or_more_times_lazy_short">
        <source>match zero or more times (lazy)</source>
        <target state="translated">trova la corrispondenza zero o più volte (corrispondenza lazy)</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_zero_or_more_times_long">
        <source>The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?.</source>
        <target state="translated">Il quantificatore * trova la corrispondenza con l'elemento precedente zero o più volte. Equivale al quantificatore {0,}. * è un quantificatore greedy il cui equivalente lazy è *?.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_zero_or_more_times_short">
        <source>match zero or more times</source>
        <target state="translated">trova la corrispondenza zero o più volte</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_zero_or_one_time_lazy_long">
        <source>The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ?</source>
        <target state="translated">Il quantificatore ?? trova la corrispondenza con l'elemento precedente zero o una volta, ma il minor numero di volte possibile. Si tratta della controparte lazy del quantificatore greedy ?</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_zero_or_one_time_lazy_short">
        <source>match zero or one time (lazy)</source>
        <target state="translated">trova la corrispondenza zero o una volta (corrispondenza lazy)</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_zero_or_one_time_long">
        <source>The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??.</source>
        <target state="translated">Il quantificatore ? trova la corrispondenza con l'elemento precedente zero o una volta. Equivale al quantificatore {0,1}. ? è un quantificatore greedy il cui equivalente lazy è ??.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_match_zero_or_one_time_short">
        <source>match zero or one time</source>
        <target state="translated">trova la corrispondenza zero o una volta</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_matched_subexpression_long">
        <source>This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern.</source>
        <target state="translated">Questo costrutto di raggruppamento acquisisce una 'subexpression' corrispondente, in cui 'subexpression' è qualsiasi criterio di ricerca di espressioni regolari valido. Le acquisizioni che usano parentesi sono numerate automaticamente da sinistra verso destra in base all'ordine delle parentesi di apertura nell'espressione regolare, a partire da uno. L'acquisizione che viene numerata zero è il testo corrispondente all'intero criterio di ricerca di espressioni regolari.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_matched_subexpression_short">
        <source>matched subexpression</source>
        <target state="translated">sottoespressione corrispondente</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_name">
        <source>name</source>
        <target state="translated">nome</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_name1">
        <source>name1</source>
        <target state="translated">name1</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_name2">
        <source>name2</source>
        <target state="translated">name2</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_name_or_number">
        <source>name-or-number</source>
        <target state="translated">nome o numero</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_named_backreference_long">
        <source>A named or numbered backreference.

'name' is the name of a capturing group defined in the regular expression pattern.</source>
        <target state="translated">Backreference denominato o numerato.

'name' è il nome di un gruppo di acquisizione definito nel criterio di ricerca di espressioni regolari.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_named_backreference_short">
        <source>named backreference</source>
        <target state="translated">backreference denominato</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_named_matched_subexpression_long">
        <source>Captures a matched subexpression and lets you access it by name or by number.

'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number.

If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups.</source>
        <target state="translated">Acquisisce una sottoespressione corrispondente e consente di accedervi tramite nome o numero.

'name' è un nome di gruppo valido e 'subexpression' è un qualsiasi criterio di ricerca di espressioni regolari valido. 'name' non deve contenere alcun simbolo di punteggiatura e non può iniziare con un numero.

Se il parametro RegexOptions di un criterio di ricerca di espressioni regolari include il flag RegexOptions.ExplicitCapture o se l'opzione n viene applicata a questa sottoespressione, l'unico modo per acquisire una sottoespressione consiste nell'assegnare esplicitamente un nome ai gruppi di acquisizione.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_named_matched_subexpression_short">
        <source>named matched subexpression</source>
        <target state="translated">sottoespressione corrispondente denominate</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_negative_character_group_long">
        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually.

Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].</source>
        <target state="translated">Un gruppo di caratteri negativi specifica un elenco di caratteri che non devono essere presenti in una stringa di input per trovare una corrispondenza. L'elenco di caratteri viene specificato singolarmente.

Due o più intervalli di caratteri possono essere concatenati. Ad esempio, per specificare l'intervallo di cifre decimali comprese tra "0" e "9", l'intervallo di lettere minuscole comprese tra "a" e "f" e l'intervallo di lettere maiuscole comprese tra "A" e "F", usare [0-9a-fA-F].</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_negative_character_group_short">
        <source>negative character group</source>
        <target state="translated">gruppo di caratteri negativi</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_negative_character_range_long">
        <source>A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range.

Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].</source>
        <target state="translated">Un intervallo di caratteri negativi specifica un elenco di caratteri che non devono essere presenti in una stringa di input per trovare una corrispondenza. 'firstCharacter' è il carattere che inizia l'intervallo e 'lastCharacter' è il carattere che lo termina.

Due o più intervalli di caratteri possono essere concatenati. Ad esempio, per specificare l'intervallo di cifre decimali comprese tra "0" e "9", l'intervallo di lettere minuscole comprese tra "a" e "f" e l'intervallo di lettere maiuscole comprese tra "A" e "F", usare [0-9a-fA-F].</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_negative_character_range_short">
        <source>negative character range</source>
        <target state="translated">intervallo di caratteri negativi</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_negative_unicode_category_long">
        <source>The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name.</source>
        <target state="translated">Il costrutto di espressione regolare \P{ name } corrisponde a qualsiasi carattere non appartenente a una categoria generale Unicode o a un blocco denominato, dove name è l'abbreviazione della categoria o il nome del blocco denominato.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_negative_unicode_category_short">
        <source>negative unicode category</source>
        <target state="translated">categoria Unicode negativa</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_new_line_character_long">
        <source>Matches a new-line character, \u000A</source>
        <target state="translated">Trova la corrispondenza di un carattere di nuova riga \u000A</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_new_line_character_short">
        <source>new-line character</source>
        <target state="translated">carattere di nuova riga</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_no">
        <source>no</source>
        <target state="translated">no</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_non_digit_character_long">
        <source>\D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern.

If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9]</source>
        <target state="translated">\D trova la corrispondenza con qualsiasi carattere non numerico. Equivale al criterio di ricerca di espressioni regolari \P{Nd}.

Se viene specificato il comportamento conforme a ECMAScript, \D equivale a [^0-9]</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_non_digit_character_short">
        <source>non-digit character</source>
        <target state="translated">carattere non numerico</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_non_white_space_character_long">
        <source>\S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters.

If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v]</source>
        <target state="translated">\S trova la corrispondenza di qualsiasi carattere diverso da uno spazio. Equivale al criterio di ricerca di espressioni regolari [^\f\n\r\t\v\x85\p{Z}] o è il contrario del criterio di ricerca di espressioni regolari equivalente a \s, che corrisponde a spazi vuoti.

Se viene specificato il comportamento conforme a ECMAScript, \S equivale a [^ \f\n\r\t\v]</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_non_white_space_character_short">
        <source>non-white-space character</source>
        <target state="translated">carattere diverso da uno spazio vuoto</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_non_word_boundary_long">
        <source>The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor.</source>
        <target state="translated">L'ancoraggio \B specifica che la corrispondenza non deve verificarsi in un confine di parola. Si tratta dell'effetto contrario rispetto all'ancoraggio \b.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_non_word_boundary_short">
        <source>non-word boundary</source>
        <target state="translated">carattere che non costituisce un confine di parola</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_non_word_character_long">
        <source>\W matches any non-word character. It matches any character except for those in the following Unicode categories:

    Ll	Letter, Lowercase
    Lu	Letter, Uppercase
    Lt	Letter, Titlecase
    Lo	Letter, Other
    Lm	Letter, Modifier
    Mn	Mark, Nonspacing
    Nd	Number, Decimal Digit
    Pc	Punctuation, Connector

If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9]</source>
        <target state="translated">\W trova la corrispondenza di qualsiasi carattere non alfabetico. Corrisponde a tutti i caratteri, ad eccezione di quelli inclusi nelle categorie Unicode seguenti:

    Ll	Letter, Lowercase
    Lu	Letter, Uppercase
    Lt	Letter, Titlecase
    Lo	Letter, Other
    Lm	Letter, Modifier
    Mn	Mark, Nonspacing
    Nd	Number, Decimal Digit
    Pc	Punctuation, Connector

Se viene specificato il comportamento conforme a ECMAScript, \W equivale a [^a-zA-Z_0-9]</target>
        <note>Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. </note>
      </trans-unit>
      <trans-unit id="Regex_non_word_character_short">
        <source>non-word character</source>
        <target state="translated">carattere non alfanumerico</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_noncapturing_group_long">
        <source>This construct does not capture the substring that is matched by a subexpression:

The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest.

If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs.</source>
        <target state="translated">Questo costrutto non acquisisce la sottostringa corrispondente a una sottoespressione:

Il costrutto del gruppo non di acquisizione viene generalmente usato quando un quantificatore è applicato a un gruppo, ma le sottostringhe acquisite dal gruppo non sono di alcun interesse.

Se un'espressione regolare include costrutti di raggruppamento annidati, un costrutto del gruppo di non acquisizione esterno non si applica ai costrutti del gruppo annidati interni.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_noncapturing_group_short">
        <source>noncapturing group</source>
        <target state="translated">gruppo di non acquisizione</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_number_decimal_digit">
        <source>number, decimal digit</source>
        <target state="translated">numerico, cifra decimale</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_number_letter">
        <source>number, letter</source>
        <target state="translated">numerico, alfanumerico</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_number_other">
        <source>number, other</source>
        <target state="translated">numerico, altro</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_numbered_backreference_long">
        <source>A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group.

There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k&lt;name&gt; notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences.</source>
        <target state="translated">Backreference numerato, in cui 'number' è la posizione ordinale del gruppo di acquisizione nell'espressione regolare. Ad esempio, \4 corrisponde al contenuto del quarto gruppo di acquisizione.

È presente un'ambiguità tra i codici di escape ottale, ad esempio \16, e i backreference \number che usano la stessa notazione. Se il problema è dovuto all'ambiguità, è possibile usare la notazione \k&lt;name&gt; che, non essendo ambigua, non può essere confusa con codici di caratteri ottali. Analogamente, i codici esadecimale come \xdd non sono ambigui e non possono essere confusi con backreference.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_numbered_backreference_short">
        <source>numbered backreference</source>
        <target state="translated">backreference numerato</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_other_control">
        <source>other, control</source>
        <target state="translated">altro, controllo</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_other_format">
        <source>other, format</source>
        <target state="translated">altro, formato</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_other_not_assigned">
        <source>other, not assigned</source>
        <target state="translated">altro, non assegnato</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_other_private_use">
        <source>other, private use</source>
        <target state="translated">altro, uso privato</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_other_surrogate">
        <source>other, surrogate</source>
        <target state="translated">altro, surrogato</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_positive_character_group_long">
        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur.</source>
        <target state="translated">Un gruppo di caratteri positivi specifica un elenco di caratteri che possono essere presenti in una stringa di input per trovare una corrispondenza.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_positive_character_group_short">
        <source>positive character group</source>
        <target state="translated">gruppo di caratteri positivi</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_positive_character_range_long">
        <source>A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur.  'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. </source>
        <target state="translated">Un intervallo di caratteri positivi specifica un intervallo di caratteri che possono essere presenti in una stringa di input per trovare una corrispondenza.  'firstCharacter' è il carattere che inizia l'intervallo e 'lastCharacter' è il carattere che lo termina. </target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_positive_character_range_short">
        <source>positive character range</source>
        <target state="translated">intervallo di caratteri positivi</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_punctuation_close">
        <source>punctuation, close</source>
        <target state="translated">punteggiatura, chiusura</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_punctuation_connector">
        <source>punctuation, connector</source>
        <target state="translated">punteggiatura, connettore</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_punctuation_dash">
        <source>punctuation, dash</source>
        <target state="translated">punteggiatura, trattino</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_punctuation_final_quote">
        <source>punctuation, final quote</source>
        <target state="translated">punteggiatura, virgoletta finale</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_punctuation_initial_quote">
        <source>punctuation, initial quote</source>
        <target state="translated">punteggiatura, virgoletta iniziale</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_punctuation_open">
        <source>punctuation, open</source>
        <target state="translated">punteggiatura, apertura</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_punctuation_other">
        <source>punctuation, other</source>
        <target state="translated">punteggiatura, altro</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_separator_line">
        <source>separator, line</source>
        <target state="translated">separatore, riga</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_separator_paragraph">
        <source>separator, paragraph</source>
        <target state="translated">separatore, paragrafo</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_separator_space">
        <source>separator, space</source>
        <target state="translated">separatore, spazio</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_start_of_string_only_long">
        <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
        <target state="translated">L'ancoraggio \A specifica che la corrispondenza deve verificarsi all'inizio della stringa di input. L'ancoraggio è identico a ^, ad eccezione del fatto che \A ignora l'opzione RegexOptions.Multiline. Di conseguenza, può trovare solo l'inizio della prima riga in una stringa di input con più righe.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_start_of_string_only_short">
        <source>start of string only</source>
        <target state="translated">solo inizio di stringa</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_start_of_string_or_line_long">
        <source>The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line.</source>
        <target state="translated">L'ancoraggio ^ specifica che il criterio seguente deve iniziare in corrispondenza della posizione del primo carattere della stringa. Se si usa ^ con l'opzione RegexOptions.Multiline, la corrispondenza deve verificarsi all'inizio di ogni riga.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_start_of_string_or_line_short">
        <source>start of string or line</source>
        <target state="translated">inizio di stringa o riga</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_subexpression">
        <source>subexpression</source>
        <target state="translated">sottoespressione</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_symbol_currency">
        <source>symbol, currency</source>
        <target state="translated">simbolo, valuta</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_symbol_math">
        <source>symbol, math</source>
        <target state="translated">simbolo, matematica</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_symbol_modifier">
        <source>symbol, modifier</source>
        <target state="translated">simbolo, modificatore</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_symbol_other">
        <source>symbol, other</source>
        <target state="translated">simbolo, altro</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_tab_character_long">
        <source>Matches a tab character, \u0009</source>
        <target state="translated">Trova la corrispondenza di un carattere di tabulazione \u0009</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_tab_character_short">
        <source>tab character</source>
        <target state="translated">carattere di tabulazione</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_unicode_category_long">
        <source>The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name.</source>
        <target state="translated">Il costrutto di espressione regolare \p{ name } corrisponde a qualsiasi carattere appartenente a una categoria generale Unicode o a un blocco denominato, dove name è l'abbreviazione della categoria o il nome del blocco denominato.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_unicode_category_short">
        <source>unicode category</source>
        <target state="translated">categoria Unicode</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_unicode_escape_long">
        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
        <target state="translated">Trova la corrispondenza di un'unità di codice UTF-16 il cui valore è l'esadecimale ####.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_unicode_escape_short">
        <source>unicode escape</source>
        <target state="translated">carattere di escape Unicode</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_unicode_general_category_0">
        <source>Unicode General Category: {0}</source>
        <target state="translated">Categoria generale Unicode: {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_vertical_tab_character_long">
        <source>Matches a vertical-tab character, \u000B</source>
        <target state="translated">Trova la corrispondenza di un carattere di tabulazione verticale \u000B</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_vertical_tab_character_short">
        <source>vertical-tab character</source>
        <target state="translated">carattere di tabulazione verticale</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_white_space_character_long">
        <source>\s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories:

    \f	The form feed character, \u000C
    \n	The newline character, \u000A
    \r	The carriage return character, \u000D
    \t	The tab character, \u0009
    \v	The vertical tab character, \u000B
    \x85	The ellipsis or NEXT LINE (NEL) character (…), \u0085
    \p{Z}	Matches any separator character

If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v]</source>
        <target state="translated">\s trova la corrispondenza di qualsiasi carattere di spazio. Equivale alle sequenze di escape e alle categorie Unicode seguenti:

    \f	Carattere di avanzamento modulo \u000C
    \n	Carattere di nuova riga \u000A
    \r	Carattere di ritorno a capo \u000D
    \t	Carattere di tabulazione \u0009
    \v	Carattere di tabulazione verticale \u000B
    \x85	Puntini di sospensione o carattere NEXT LINE (NEL) (…) \u0085
    \p{Z}	Trova la corrispondenza di un qualsiasi carattere separatore

Se viene specificato il comportamento conforme a ECMAScript, \s equivale a [ \f\n\r\t\v]</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_white_space_character_short">
        <source>white-space character</source>
        <target state="translated">spazio vuoto</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_word_boundary_long">
        <source>The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string.

The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word.</source>
        <target state="translated">L'ancoraggio \b specifica che la corrispondenza deve verificarsi in un confine tra un carattere alfanumerico (elemento del linguaggio \w) e uno non alfanumerico (elemento del linguaggio \W). I caratteri alfanumerici sono costituiti da lettere, cifre e caratteri di sottolineatura. Un carattere non alfanumerico è qualsiasi carattere diverso da lettere, cifre e carattere di sottolineatura. La corrispondenza può verificarsi anche in un confine di parola all'inizio o alla fine della stringa.

L'ancoraggio \b viene usato di frequente per garantire che una sottoespressione corrisponda a un'intera parola anziché solo all'inizio o alla fine di una parola.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_word_boundary_short">
        <source>word boundary</source>
        <target state="translated">confine di parola</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_word_character_long">
        <source>\w matches any word character. A word character is a member of any of the following Unicode categories:

    Ll	Letter, Lowercase
    Lu	Letter, Uppercase
    Lt	Letter, Titlecase
    Lo	Letter, Other
    Lm	Letter, Modifier
    Mn	Mark, Nonspacing
    Nd	Number, Decimal Digit
    Pc	Punctuation, Connector

If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9]</source>
        <target state="translated">\w trova la corrispondenza di qualsiasi carattere alfanumerico. Un carattere alfanumerico è un membro di una delle categorie Unicode seguenti:

    Ll	Letter, Lowercase
    Lu	Letter, Uppercase
    Lt	Letter, Titlecase
    Lo	Letter, Other
    Lm	Letter, Modifier
    Mn	Mark, Nonspacing
    Nd	Number, Decimal Digit
    Pc	Punctuation, Connector

Se viene specificato il comportamento conforme a ECMAScript, \w equivale a [a-zA-Z_0-9]</target>
        <note>Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized.</note>
      </trans-unit>
      <trans-unit id="Regex_word_character_short">
        <source>word character</source>
        <target state="translated">carattere alfanumerico</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_yes">
        <source>yes</source>
        <target state="translated">sì</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_zero_width_negative_lookahead_assertion_long">
        <source>A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result.

A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match.</source>
        <target state="translated">Asserzione lookahead negativa di larghezza zero, in cui per trovare una corrispondenza, la stringa di input non deve corrispondere al criterio di ricerca di espressioni regolari in subexpression. La stringa corrispondente non è inclusa nei risultati della corrispondenza.

Un'asserzione lookahead negativa di larghezza zero viene usata in genere all'inizio o alla fine di un'espressione regolare. All'inizio di un'espressione regolare, può definire un criterio specifico per il quale non deve essere trovata una corrispondenza quando l'inizio dell'espressione regolare definisce un criterio simile, ma più generale, per cui stabilire la corrispondenza. In questo caso, viene spesso usata per limitare il backtracking. Alla fine di un'espressione regolare, può definire una sottoespressione che non può verificarsi alla fine di una corrispondenza.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_zero_width_negative_lookahead_assertion_short">
        <source>zero-width negative lookahead assertion</source>
        <target state="translated">asserzione lookahead negativa di larghezza zero</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_zero_width_negative_lookbehind_assertion_long">
        <source>A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result.

Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern.</source>
        <target state="translated">Asserzione lookbehind negativa di larghezza zero, in cui per trovare una corrispondenza, 'subexpression' non deve trovarsi nella stringa di input a sinistra della posizione corrente. Qualsiasi sottostringa che non corrisponde a 'subexpression' non viene inclusa nel risultato della corrispondenza.

Le asserzioni lookbehind negative di larghezza zero vengono usate in genere all'inizio delle espressioni regolari. Il criterio definito preclude una corrispondenza nella stringa che segue. Queste asserzioni vengono usate anche per limitare il backtracking quando l'ultimo carattere o gli ultimi caratteri in un gruppo acquisito non devono essere costituiti da uno o più caratteri corrispondenti al criterio di ricerca di espressioni regolari di tale gruppo.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_zero_width_negative_lookbehind_assertion_short">
        <source>zero-width negative lookbehind assertion</source>
        <target state="translated">asserzione lookbehind negativa di larghezza zero</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_zero_width_positive_lookahead_assertion_long">
        <source>A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack.

Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group.</source>
        <target state="translated">Asserzione lookahead positiva di larghezza zero, in cui per trovare una corrispondenza, la stringa di input deve corrispondere al criterio di ricerca di espressioni regolari in 'subexpression'. La sottostringa corrispondente non è inclusa nei risultati della corrispondenza. Un'asserzione lookahead positiva di larghezza zero non esegue il backtracking.

In genere, un'asserzione lookahead positiva di larghezza zero viene trovata alla fine di un criterio di ricerca di espressioni regolari. Definisce una sottostringa che deve trovarsi alla fine di una stringa per stabilire una corrispondenza, ma che non deve essere inclusa nella corrispondenza. È anche utile per impedire un backtracking eccessivo. È possibile usare un'asserzione lookahead positiva di larghezza zero per assicurarsi che un particolare gruppo acquisito inizi con il testo che corrisponde a un subset del criterio definito per tale gruppo acquisito.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_zero_width_positive_lookahead_assertion_short">
        <source>zero-width positive lookahead assertion</source>
        <target state="translated">asserzione lookahead positiva di larghezza zero</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_zero_width_positive_lookbehind_assertion_long">
        <source>A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack.

Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result.</source>
        <target state="translated">Asserzione lookbehind positiva di larghezza zero, in cui per trovare una corrispondenza, 'subexpression' deve trovarsi nella stringa di input a sinistra della posizione corrente. 'subexpression' non è incluso nei risultati della corrispondenza. Un'asserzione lookbehind positiva di larghezza zero non esegue il backtracking.

Le asserzioni lookbehind positive di larghezza zero vengono usate in genere all'inizio delle espressioni regolari. Il criterio definito è una precondizione per una corrispondenza, anche se non fa parte del risultato della corrispondenza.</target>
        <note />
      </trans-unit>
      <trans-unit id="Regex_zero_width_positive_lookbehind_assertion_short">
        <source>zero-width positive lookbehind assertion</source>
        <target state="translated">asserzione lookbehind positiva di larghezza zero</target>
        <note />
      </trans-unit>
      <trans-unit id="Related_method_signatures_found_in_metadata_will_not_be_updated">
        <source>Related method signatures found in metadata will not be updated.</source>
        <target state="translated">Le firme del metodo correlate trovate nei metadati non verranno aggiornate.</target>
        <note />
      </trans-unit>
      <trans-unit id="Removal_of_document_not_supported">
        <source>Removal of document not supported</source>
        <target state="new">Removal of document not supported</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_async_modifier">
        <source>Remove 'async' modifier</source>
        <target state="translated">Rimuovi il modificatore 'async'</target>
        <note />
      </trans-unit>
      <trans-unit id="Replace_0_with_1">
        <source>Replace '{0}' with '{1}' </source>
        <target state="translated">Sostituisci '{0}' con '{1}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Resolve_conflict_markers">
        <source>Resolve conflict markers</source>
        <target state="translated">Risolvi gli indicatori di conflitto</target>
        <note />
      </trans-unit>
      <trans-unit id="RudeEdit">
        <source>Rude edit</source>
        <target state="translated">Modifica non applicabile</target>
        <note />
      </trans-unit>
      <trans-unit id="Split_into_consecutive_0_statements">
        <source>Split into consecutive '{0}' statements</source>
        <target state="translated">Dividi in istruzioni '{0}' consecutive</target>
        <note />
      </trans-unit>
      <trans-unit id="Split_into_nested_0_statements">
        <source>Split into nested '{0}' statements</source>
        <target state="translated">Dividi in istruzioni '{0}' nidificate</target>
        <note />
      </trans-unit>
      <trans-unit id="StreamMustSupportReadAndSeek">
        <source>Stream must support read and seek operations.</source>
        <target state="translated">Il flusso deve supportare operazioni di lettura e ricerca.</target>
        <note />
      </trans-unit>
      <trans-unit id="Suppress_0">
        <source>Suppress {0}</source>
        <target state="translated">Elimina {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="TODO_colon_free_unmanaged_resources_unmanaged_objects_and_override_finalizer">
        <source>TODO: free unmanaged resources (unmanaged objects) and override finalizer</source>
        <target state="translated">TODO: liberare risorse non gestite (oggetti non gestiti) ed eseguire l'override del finalizzatore</target>
        <note />
      </trans-unit>
      <trans-unit id="TODO_colon_override_finalizer_only_if_0_has_code_to_free_unmanaged_resources">
        <source>TODO: override finalizer only if '{0}' has code to free unmanaged resources</source>
        <target state="translated">TODO: eseguire l'override del finalizzatore solo se '{0}' contiene codice per liberare risorse non gestite</target>
        <note />
      </trans-unit>
      <trans-unit id="Target_type_matches">
        <source>Target type matches</source>
        <target state="translated">Imposta destinazione per corrispondenze di tipo</target>
        <note />
      </trans-unit>
      <trans-unit id="The_assembly_0_containing_type_1_references_NET_Framework">
        <source>The assembly '{0}' containing type '{1}' references .NET Framework, which is not supported.</source>
        <target state="translated">L'assembly '{0}' che contiene il tipo '{1}' fa riferimento a .NET Framework, che non è supportato.</target>
        <note />
      </trans-unit>
      <trans-unit id="The_selection_contains_a_local_function_call_without_its_declaration">
        <source>The selection contains a local function call without its declaration.</source>
        <target state="translated">La selezione contiene una chiamata di funzione locale senza la relativa dichiarazione.</target>
        <note />
      </trans-unit>
      <trans-unit id="Too_many_bars_in_conditional_grouping">
        <source>Too many | in (?()|)</source>
        <target state="translated">Troppi | in (?()|)</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|)</note>
      </trans-unit>
      <trans-unit id="Too_many_close_parens">
        <source>Too many )'s</source>
        <target state="translated">Troppe parentesi di chiusura</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: )</note>
      </trans-unit>
      <trans-unit id="UnableToReadSourceFileOrPdb">
        <source>Unable to read source file '{0}' or the PDB built for the containing project. Any changes made to this file while debugging won't be applied until its content matches the built source.</source>
        <target state="translated">Non è possibile leggere il file di origine '{0}' o il file PDB compilato per il progetto contenitore. Tutte le modifiche apportate a questo file durante il debug non verranno applicate finché il relativo contenuto non corrisponde al codice sorgente compilato.</target>
        <note />
      </trans-unit>
      <trans-unit id="Unknown_property">
        <source>Unknown property</source>
        <target state="translated">Proprietà sconosciuta</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{}</note>
      </trans-unit>
      <trans-unit id="Unknown_property_0">
        <source>Unknown property '{0}'</source>
        <target state="translated">Proprietà sconosciuta '{0}'</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx')</note>
      </trans-unit>
      <trans-unit id="Unrecognized_control_character">
        <source>Unrecognized control character</source>
        <target state="translated">Carattere di controllo non riconosciuto</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c]</note>
      </trans-unit>
      <trans-unit id="Unrecognized_escape_sequence_0">
        <source>Unrecognized escape sequence \{0}</source>
        <target state="translated">Sequenza di escape non riconosciuta: \{0}</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m')</note>
      </trans-unit>
      <trans-unit id="Unrecognized_grouping_construct">
        <source>Unrecognized grouping construct</source>
        <target state="translated">Costrutto di raggruppamento non riconosciuto</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?&lt;</note>
      </trans-unit>
      <trans-unit id="Unterminated_character_class_set">
        <source>Unterminated [] set</source>
        <target state="translated">Set di [] senza terminazione</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: [</note>
      </trans-unit>
      <trans-unit id="Unterminated_regex_comment">
        <source>Unterminated (?#...) comment</source>
        <target state="translated">Commento (?#...) senza terminazione</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: (?#</note>
      </trans-unit>
      <trans-unit id="Unwrap_all_arguments">
        <source>Unwrap all arguments</source>
        <target state="translated">Annulla il ritorno a capo per tutti gli argomenti</target>
        <note />
      </trans-unit>
      <trans-unit id="Unwrap_all_parameters">
        <source>Unwrap all parameters</source>
        <target state="translated">Annulla il ritorno a capo per tutti i parametri</target>
        <note />
      </trans-unit>
      <trans-unit id="Unwrap_and_indent_all_arguments">
        <source>Unwrap and indent all arguments</source>
        <target state="translated">Annulla il ritorno a capo e imposta il rientro per tutti gli argomenti</target>
        <note />
      </trans-unit>
      <trans-unit id="Unwrap_and_indent_all_parameters">
        <source>Unwrap and indent all parameters</source>
        <target state="translated">Annulla il ritorno a capo e imposta rientro per tutti i parametri</target>
        <note />
      </trans-unit>
      <trans-unit id="Unwrap_argument_list">
        <source>Unwrap argument list</source>
        <target state="translated">Annulla il ritorno a capo per l'elenco di argomenti</target>
        <note />
      </trans-unit>
      <trans-unit id="Unwrap_call_chain">
        <source>Unwrap call chain</source>
        <target state="translated">Annulla il ritorno a capo per la catena di chiamate</target>
        <note />
      </trans-unit>
      <trans-unit id="Unwrap_expression">
        <source>Unwrap expression</source>
        <target state="translated">Annulla il ritorno a capo per l'espressione</target>
        <note />
      </trans-unit>
      <trans-unit id="Unwrap_parameter_list">
        <source>Unwrap parameter list</source>
        <target state="translated">Annulla il ritorno a capo per l'elenco di parametri</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_a_0_around_an_active_statement_will_prevent_the_debug_session_from_continuing">
        <source>Updating a '{0}' around an active statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna '{0}' in prossimità di un'istruzione attiva, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="UseRecommendedDisposePatternDescription">
        <source>Use recommended dispose pattern to ensure that locally scoped disposable objects are disposed on all paths. If possible, wrap the creation within a 'using' statement or a 'using' declaration. Otherwise, use a try-finally pattern, with a dedicated local variable declared before the try region and an unconditional Dispose invocation on non-null value in the 'finally' region, say 'x?.Dispose()'. If the object is explicitly disposed within the try region or the dispose ownership is transferred to another object or method, assign 'null' to the local variable just after such an operation to prevent double dispose in 'finally'</source>
        <target state="translated">Usare il criterio dispose consigliato per garantire che gli oggetti eliminabili con ambito locale vengano eliminati in tutti i percorsi. Se possibile, eseguire il wrapping della creazione in un'istruzione 'using' o una dichiarazione 'using'. In caso contrario, usare un criterio try-finally, con una variabile locale dedicata dichiarata prima dell'area try e una chiamata Dispose non condizionale al valore non Null nell'area 'finally', ad esempio 'x?.Dispose()'. Se l'oggetto viene eliminato in modo esplicito nell'area try oppure la proprietà di dispose viene trasferita a un altro oggetto o metodo, assegnare 'null' alla variabile locale subito dopo una tale operazione per evitare di raddoppiare dispose in 'finally'</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_block_body_for_lambda_expressions">
        <source>Use block body for lambda expressions</source>
        <target state="translated">Usa il corpo del blocco per le espressioni lambda</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_expression_body_for_lambda_expressions">
        <source>Use expression body for lambda expressions</source>
        <target state="translated">Usa il corpo dell'espressione per le espressioni lambda</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_interpolated_verbatim_string">
        <source>Use interpolated verbatim string</source>
        <target state="translated">Usa stringa verbatim interpolata</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_recommended_dispose_pattern">
        <source>Use recommended dispose pattern</source>
        <target state="translated">Usare il criterio dispose consigliato</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_recommended_dispose_pattern_to_ensure_that_object_created_by_0_is_disposed_on_all_paths_using_statement_declaration_or_try_finally">
        <source>Use recommended dispose pattern to ensure that object created by '{0}' is disposed on all paths: using statement/declaration or try/finally</source>
        <target state="translated">Usare il criterio dispose consigliato per garantire che l'oggetto creato da '{0}' venga eliminato in tutti i percorsi, ovvero istruzione/dichiarazione using o try/finally</target>
        <note>{Locked="using"}{Locked="try"}{Locked="finally"} "using", "try" and "finally" are C# keywords and should not be localized.</note>
      </trans-unit>
      <trans-unit id="Value_colon">
        <source>Value:</source>
        <target state="translated">Valore:</target>
        <note />
      </trans-unit>
      <trans-unit id="Warning_colon_changing_namespace_may_produce_invalid_code_and_change_code_meaning">
        <source>Warning: Changing namespace may produce invalid code and change code meaning.</source>
        <target state="translated">Avviso: la modifica dello spazio dei nomi può comportare la creazione di codice non valido e modificare il significato del codice.</target>
        <note />
      </trans-unit>
      <trans-unit id="Warning_colon_semantics_may_change_when_converting_statement">
        <source>Warning: Semantics may change when converting statement.</source>
        <target state="translated">Avviso: durante la conversione dell'istruzione la semantica può cambiare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_and_align_call_chain">
        <source>Wrap and align call chain</source>
        <target state="translated">Imposta il ritorno a capo e allinea la catena di chiamate</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_and_align_expression">
        <source>Wrap and align expression</source>
        <target state="translated">Imposta il ritorno a capo e allinea l'espressione</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_and_align_long_call_chain">
        <source>Wrap and align long call chain</source>
        <target state="translated">Imposta il ritorno a capo e allinea la catena di chiamate lunga</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_call_chain">
        <source>Wrap call chain</source>
        <target state="translated">Imposta il ritorno a capo alla catena di chiamate</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_every_argument">
        <source>Wrap every argument</source>
        <target state="translated">Imposta il ritorno a capo a ogni argomento</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_every_parameter">
        <source>Wrap every parameter</source>
        <target state="translated">Imposta il ritorno a capo a ogni parametro</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_expression">
        <source>Wrap expression</source>
        <target state="translated">Imposta il ritorno a capo all'espressione</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_long_argument_list">
        <source>Wrap long argument list</source>
        <target state="translated">Imposta il ritorno a capo all'elenco di argomenti lungo</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_long_call_chain">
        <source>Wrap long call chain</source>
        <target state="translated">Imposta il ritorno a capo alla catena di chiamate lunga</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrap_long_parameter_list">
        <source>Wrap long parameter list</source>
        <target state="translated">Imposta il ritorno a capo all'elenco di parametri lungo</target>
        <note />
      </trans-unit>
      <trans-unit id="Wrapping">
        <source>Wrapping</source>
        <target state="translated">Ritorno a capo</target>
        <note />
      </trans-unit>
      <trans-unit id="_0_cannot_be_null_or_empty">
        <source>'{0}' cannot be null or empty.</source>
        <target state="translated">'{0}' non può essere null o vuoto.</target>
        <note />
      </trans-unit>
      <trans-unit id="_0_cannot_be_null_or_whitespace">
        <source>'{0}' cannot be null or whitespace.</source>
        <target state="translated">'{0}' non può essere Null o uno spazio vuoto.</target>
        <note />
      </trans-unit>
      <trans-unit id="_0_is_not_null_here">
        <source>'{0}' is not null here.</source>
        <target state="translated">'{0}' non è Null in questo punto.</target>
        <note />
      </trans-unit>
      <trans-unit id="_0_may_be_null_here">
        <source>'{0}' may be null here.</source>
        <target state="translated">'{0}' può essere Null in questo punto.</target>
        <note />
      </trans-unit>
      <trans-unit id="_10000000ths_of_a_second">
        <source>10,000,000ths of a second</source>
        <target state="translated">Decimilionesimi di secondo</target>
        <note />
      </trans-unit>
      <trans-unit id="_10000000ths_of_a_second_description">
        <source>The "fffffff" custom format specifier represents the seven most significant digits of the seconds fraction; that is, it represents the ten millionths of a second in a date and time value.

Although it's possible to display the ten millionths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.</source>
        <target state="translated">L'identificatore di formato personalizzato "fffffff" rappresenta le sette cifre più significative della frazione di secondi, ovvero i decimilionesimi di secondo in un valore di data e ora.

Anche se è possibile visualizzare i decimilionesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.</target>
        <note />
      </trans-unit>
      <trans-unit id="_10000000ths_of_a_second_non_zero">
        <source>10,000,000ths of a second (non-zero)</source>
        <target state="translated">Decimilionesimi di secondo (diversi da zero)</target>
        <note />
      </trans-unit>
      <trans-unit id="_10000000ths_of_a_second_non_zero_description">
        <source>The "FFFFFFF" custom format specifier represents the seven most significant digits of the seconds fraction; that is, it represents the ten millionths of a second in a date and time value. However, trailing zeros or seven zero digits aren't displayed.

Although it's possible to display the ten millionths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.</source>
        <target state="translated">L'identificatore di formato personalizzato "FFFFFFF" rappresenta le sette cifre più significative della frazione di secondi, ovvero i decimilionesimi di secondo in un valore di data e ora. Gli zeri finali o le cifre con sette zeri non vengono tuttavia visualizzati.

Anche se è possibile visualizzare i decimilionesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.</target>
        <note />
      </trans-unit>
      <trans-unit id="_1000000ths_of_a_second">
        <source>1,000,000ths of a second</source>
        <target state="translated">Milionesimi di secondo</target>
        <note />
      </trans-unit>
      <trans-unit id="_1000000ths_of_a_second_description">
        <source>The "ffffff" custom format specifier represents the six most significant digits of the seconds fraction; that is, it represents the millionths of a second in a date and time value.

Although it's possible to display the millionths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.</source>
        <target state="translated">L'identificatore di formato personalizzato "ffffff" rappresenta le sei cifre più significative della frazione di secondi, ovvero i milionesimi di secondo in un valore di data e ora.

Anche se è possibile visualizzare i milionesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.</target>
        <note />
      </trans-unit>
      <trans-unit id="_1000000ths_of_a_second_non_zero">
        <source>1,000,000ths of a second (non-zero)</source>
        <target state="translated">Milionesimi di secondo (diversi da zero)</target>
        <note />
      </trans-unit>
      <trans-unit id="_1000000ths_of_a_second_non_zero_description">
        <source>The "FFFFFF" custom format specifier represents the six most significant digits of the seconds fraction; that is, it represents the millionths of a second in a date and time value. However, trailing zeros or six zero digits aren't displayed.

Although it's possible to display the millionths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.</source>
        <target state="translated">L'identificatore di formato personalizzato "FFFFFF" rappresenta le sei cifre più significative della frazione di secondi, ovvero i milionesimi di secondo in un valore di data e ora. Gli zeri finali o le cifre con sei zeri non vengono tuttavia visualizzati.

Anche se è possibile visualizzare i milionesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.</target>
        <note />
      </trans-unit>
      <trans-unit id="_100000ths_of_a_second">
        <source>100,000ths of a second</source>
        <target state="translated">Centomillesimi di secondo</target>
        <note />
      </trans-unit>
      <trans-unit id="_100000ths_of_a_second_description">
        <source>The "fffff" custom format specifier represents the five most significant digits of the seconds fraction; that is, it represents the hundred thousandths of a second in a date and time value.

Although it's possible to display the hundred thousandths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.</source>
        <target state="translated">L'identificatore di formato personalizzato "fffff" rappresenta le cinque cifre più significative della frazione di secondi, ovvero i centomillesimi di secondo in un valore di data e ora.

Anche se è possibile visualizzare i centomillesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.</target>
        <note />
      </trans-unit>
      <trans-unit id="_100000ths_of_a_second_non_zero">
        <source>100,000ths of a second (non-zero)</source>
        <target state="translated">Centomillesimi di secondo (diversi da zero)</target>
        <note />
      </trans-unit>
      <trans-unit id="_100000ths_of_a_second_non_zero_description">
        <source>The "FFFFF" custom format specifier represents the five most significant digits of the seconds fraction; that is, it represents the hundred thousandths of a second in a date and time value. However, trailing zeros or five zero digits aren't displayed.

Although it's possible to display the hundred thousandths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.</source>
        <target state="translated">L'identificatore di formato personalizzato "FFFFF" rappresenta le cinque cifre più significative della frazione di secondi, ovvero i centomillesimi di secondo in un valore di data e ora. Gli zeri finali o le cifre con cinque zeri non vengono tuttavia visualizzati.

Anche se è possibile visualizzare i centomillesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.</target>
        <note />
      </trans-unit>
      <trans-unit id="_10000ths_of_a_second">
        <source>10,000ths of a second</source>
        <target state="translated">Decimillesimi di secondo</target>
        <note />
      </trans-unit>
      <trans-unit id="_10000ths_of_a_second_description">
        <source>The "ffff" custom format specifier represents the four most significant digits of the seconds fraction; that is, it represents the ten thousandths of a second in a date and time value.

Although it's possible to display the ten thousandths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT version 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.</source>
        <target state="translated">L'identificatore di formato personalizzato "ffff" rappresenta le quattro cifre più significative della frazione di secondi, ovvero i decimillesimi di secondo in un valore di data e ora.

Anche se è possibile visualizzare i decimillesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.</target>
        <note />
      </trans-unit>
      <trans-unit id="_10000ths_of_a_second_non_zero">
        <source>10,000ths of a second (non-zero)</source>
        <target state="translated">Decimillesimi di secondo (diversi da zero)</target>
        <note />
      </trans-unit>
      <trans-unit id="_10000ths_of_a_second_non_zero_description">
        <source>The "FFFF" custom format specifier represents the four most significant digits of the seconds fraction; that is, it represents the ten thousandths of a second in a date and time value. However, trailing zeros or four zero digits aren't displayed.

Although it's possible to display the ten thousandths of a second component of a time value, that value may not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15 milliseconds.</source>
        <target state="translated">L'identificatore di formato personalizzato "FFFF" rappresenta le quattro cifre più significative della frazione di secondi, ovvero i decimillesimi di secondo in un valore di data e ora. Gli zeri finali o le cifre con quattro zeri non vengono tuttavia visualizzati.

Anche se è possibile visualizzare i decimillesimi di un componente relativo ai secondi di un valore di ora, tale valore potrebbe non essere significativo. La precisione dei valori di data e ora dipende dalla risoluzione del clock di sistema. Nei sistemi operativi Windows NT 3.5 e versioni successive e Windows Vista la risoluzione del clock è di circa 10-15 millisecondi.</target>
        <note />
      </trans-unit>
      <trans-unit id="_1000ths_of_a_second">
        <source>1,000ths of a second</source>
        <target state="translated">Millisecondi</target>
        <note />
      </trans-unit>
      <trans-unit id="_1000ths_of_a_second_description">
        <source>The "fff" custom format specifier represents the three most significant digits of the seconds fraction; that is, it represents the milliseconds in a date and time value.</source>
        <target state="translated">L'identificatore di formato personalizzato "fff" rappresenta le tre cifre più significative della frazione di secondi, ovvero i millisecondi in un valore di data e ora.</target>
        <note />
      </trans-unit>
      <trans-unit id="_1000ths_of_a_second_non_zero">
        <source>1,000ths of a second (non-zero)</source>
        <target state="translated">Millisecondi (diversi da zero)</target>
        <note />
      </trans-unit>
      <trans-unit id="_1000ths_of_a_second_non_zero_description">
        <source>The "FFF" custom format specifier represents the three most significant digits of the seconds fraction; that is, it represents the milliseconds in a date and time value. However, trailing zeros or three zero digits aren't displayed.</source>
        <target state="translated">L'identificatore di formato personalizzato "FFF" rappresenta le tre cifre più significative della frazione di secondi, ovvero i millisecondi in un valore di data e ora. Gli zeri finali o le cifre con tre zeri non vengono tuttavia visualizzati.</target>
        <note />
      </trans-unit>
      <trans-unit id="_100ths_of_a_second">
        <source>100ths of a second</source>
        <target state="translated">Centesimi di secondo</target>
        <note />
      </trans-unit>
      <trans-unit id="_100ths_of_a_second_description">
        <source>The "ff" custom format specifier represents the two most significant digits of the seconds fraction; that is, it represents the hundredths of a second in a date and time value.</source>
        <target state="translated">L'identificatore di formato personalizzato "ff" rappresenta le due cifre più significative della frazione di secondi, ovvero i centesimi di secondo in un valore di data e ora.</target>
        <note />
      </trans-unit>
      <trans-unit id="_100ths_of_a_second_non_zero">
        <source>100ths of a second (non-zero)</source>
        <target state="translated">Centesimi di secondo (diversi da zero)</target>
        <note />
      </trans-unit>
      <trans-unit id="_100ths_of_a_second_non_zero_description">
        <source>The "FF" custom format specifier represents the two most significant digits of the seconds fraction; that is, it represents the hundredths of a second in a date and time value. However, trailing zeros or two zero digits aren't displayed.</source>
        <target state="translated">L'identificatore di formato personalizzato "FF" rappresenta le due cifre più significative della frazione di secondi, ovvero i centesimi di secondo in un valore di data e ora. Gli zeri finali o le cifre con due zeri non vengono tuttavia visualizzati.</target>
        <note />
      </trans-unit>
      <trans-unit id="_10ths_of_a_second">
        <source>10ths of a second</source>
        <target state="translated">Decimi di secondo</target>
        <note />
      </trans-unit>
      <trans-unit id="_10ths_of_a_second_description">
        <source>The "f" custom format specifier represents the most significant digit of the seconds fraction; that is, it represents the tenths of a second in a date and time value.

If the "f" format specifier is used without other format specifiers, it's interpreted as the "f" standard date and time format specifier.

When you use "f" format specifiers as part of a format string supplied to the ParseExact, TryParseExact, ParseExact, or TryParseExact method, the number of "f" format specifiers indicates the number of most significant digits of the seconds fraction that must be present to successfully parse the string.</source>
        <target state="translated">L'identificatore di formato personalizzato "f" rappresenta la cifra più significativa della frazione di secondi, ovvero i decimi di secondo in un valore di data e ora.

Se l'identificatore di formato "f" viene usato senza altri identificatori di formato, viene interpretato come l'identificatore di formato di data e ora standard "f".

Quando si usano identificatori di formato "f" come parte di una stringa di formato fornita al metodo ParseExact, TryParseExact, ParseExact o TryParseExact, il numero di identificatori di formato "f" indica il numero di cifre più significative della frazione di secondi che deve essere presente per analizzare correttamente la stringa.</target>
        <note />
      </trans-unit>
      <trans-unit id="_10ths_of_a_second_non_zero">
        <source>10ths of a second (non-zero)</source>
        <target state="translated">Decimi di secondo (diversi da zero)</target>
        <note />
      </trans-unit>
      <trans-unit id="_10ths_of_a_second_non_zero_description">
        <source>The "F" custom format specifier represents the most significant digit of the seconds fraction; that is, it represents the tenths of a second in a date and time value. Nothing is displayed if the digit is zero.

If the "F" format specifier is used without other format specifiers, it's interpreted as the "F" standard date and time format specifier.

The number of "F" format specifiers used with the ParseExact, TryParseExact, ParseExact, or TryParseExact method indicates the maximum number of most significant digits of the seconds fraction that can be present to successfully parse the string.</source>
        <target state="translated">L'identificatore di formato personalizzato "F" rappresenta la cifra più significativa della frazione di secondi, ovvero i decimi di secondo in un valore di data e ora. Se la cifra è zero, non viene visualizzato nulla.

Se l'identificatore di formato "F" viene usato senza altri identificatori di formato, viene interpretato come l'identificatore di formato di data e ora standard "F".

Il numero di identificatoti di formato "F" usati con il metodo ParseExact, TryParseExact, ParseExact o TryParseExact indica il numero massimo di cifre più significative della frazione di secondi che possono essere presenti per analizzare correttamente la stringa.</target>
        <note />
      </trans-unit>
      <trans-unit id="_12_hour_clock_1_2_digits">
        <source>12 hour clock (1-2 digits)</source>
        <target state="translated">Orario in formato 12 ore (1-2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="_12_hour_clock_1_2_digits_description">
        <source>The "h" custom format specifier represents the hour as a number from 1 through 12; that is, the hour is represented by a 12-hour clock that counts the whole hours since midnight or noon. A particular hour after midnight is indistinguishable from the same hour after noon. The hour is not rounded, and a single-digit hour is formatted without a leading zero. For example, given a time of 5:43 in the morning or afternoon, this custom format specifier displays "5".

If the "h" format specifier is used without other custom format specifiers, it's interpreted as a standard date and time format specifier and throws a FormatException.</source>
        <target state="translated">L'identificatore di formato personalizzato "h" rappresenta l'ora come numero compreso tra 1 e 12, ovvero l'ora rappresentata nell'orario in formato 12 ore in base al quale il conteggio riparte da mezzanotte o da mezzogiorno. Una particolare ora dopo mezzanotte non è distinguibile dalla stessa ora dopo mezzogiorno. L'ora non viene arrotondata e se è costituita da una singola cifra viene formattata senza zero iniziale. Se viene, ad esempio, specificata un'ora equivalente alle 5:43 della mattina o del pomeriggio, tramite questo identificatore di formato personalizzato viene visualizzato "5".

Se l'identificatore di formato "h" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException.</target>
        <note />
      </trans-unit>
      <trans-unit id="_12_hour_clock_2_digits">
        <source>12 hour clock (2 digits)</source>
        <target state="translated">Orario in formato 12 ore (2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="_12_hour_clock_2_digits_description">
        <source>The "hh" custom format specifier (plus any number of additional "h" specifiers) represents the hour as a number from 01 through 12; that is, the hour is represented by a 12-hour clock that counts the whole hours since midnight or noon. A particular hour after midnight is indistinguishable from the same hour after noon. The hour is not rounded, and a single-digit hour is formatted with a leading zero. For example, given a time of 5:43 in the morning or afternoon, this format specifier displays "05".</source>
        <target state="translated">L'identificatore di formato personalizzato "hh" (più qualsiasi numero di identificatori "h" aggiuntivi) rappresenta l'ora come numero compreso tra 01 e 12, ovvero l'ora rappresentata nell'orario in formato 12 ore in base al quale il conteggio riparte da mezzanotte o da mezzogiorno. Una particolare ora dopo mezzanotte non è distinguibile dalla stessa ora dopo mezzogiorno. L'ora non viene arrotondata e se è costituita da una singola cifra viene formattata con uno zero iniziale. Se viene, ad esempio, specificata un'ora equivalente alle 5:43 della mattina o del pomeriggio, tramite questo identificatore di formato viene visualizzato "05".</target>
        <note />
      </trans-unit>
      <trans-unit id="_24_hour_clock_1_2_digits">
        <source>24 hour clock (1-2 digits)</source>
        <target state="translated">Orario in formato 24 ore (1-2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="_24_hour_clock_1_2_digits_description">
        <source>The "H" custom format specifier represents the hour as a number from 0 through 23; that is, the hour is represented by a zero-based 24-hour clock that counts the hours since midnight. A single-digit hour is formatted without a leading zero.

If the "H" format specifier is used without other custom format specifiers, it's interpreted as a standard date and time format specifier and throws a FormatException.</source>
        <target state="translated">L'identificatore di formato personalizzato "H" rappresenta l'ora come numero compreso tra 0 e 23, ovvero l'ora rappresentata nell'orario in formato 24 ore a base zero in base al quale il conteggio riparte da mezzanotte. Un'ora costituita da una singola cifra viene formattata senza zero iniziale.

Se l'identificatore di formato "H" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException.</target>
        <note />
      </trans-unit>
      <trans-unit id="_24_hour_clock_2_digits">
        <source>24 hour clock (2 digits)</source>
        <target state="translated">Orario in formato 24 ore (2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="_24_hour_clock_2_digits_description">
        <source>The "HH" custom format specifier (plus any number of additional "H" specifiers) represents the hour as a number from 00 through 23; that is, the hour is represented by a zero-based 24-hour clock that counts the hours since midnight. A single-digit hour is formatted with a leading zero.</source>
        <target state="translated">L'identificatore di formato personalizzato "HH" (più qualsiasi numero di identificatori "H" aggiuntivi) rappresenta l'ora come numero compreso tra 00 e 23, ovvero l'ora rappresentata nell'orario in formato 24 ore a base zero in base al quale il conteggio riparte da mezzanotte. Un'ora costituita da una singola cifra viene formattata con uno zero iniziale.</target>
        <note />
      </trans-unit>
      <trans-unit id="date_separator">
        <source>date separator</source>
        <target state="translated">Separatore di data</target>
        <note />
      </trans-unit>
      <trans-unit id="date_separator_description">
        <source>The "/" custom format specifier represents the date separator, which is used to differentiate years, months, and days. The appropriate localized date separator is retrieved from the DateTimeFormatInfo.DateSeparator property of the current or specified culture.

Note: To change the date separator for a particular date and time string, specify the separator character within a literal string delimiter. For example, the custom format string mm'/'dd'/'yyyy produces a result string in which "/" is always used as the date separator. To change the date separator for all dates for a culture, either change the value of the DateTimeFormatInfo.DateSeparator property of the current culture, or instantiate a DateTimeFormatInfo object, assign the character to its DateSeparator property, and call an overload of the formatting method that includes an IFormatProvider parameter.

If the "/" format specifier is used without other custom format specifiers, it's interpreted as a standard date and time format specifier and throws a FormatException.</source>
        <target state="translated">L'identificatore di formato personalizzato "/" rappresenta il separatore di data usato per distinguere anni, mesi e giorni. Il separatore di data localizzato appropriato viene recuperato dalla proprietà DateTimeFormatInfo.DateSeparator delle impostazioni cultura correnti o specificate.

Nota: per modificare il separatore di data per una particolare stringa di data e ora, specificare il carattere separatore all'interno di un delimitatore di stringa letterale. La stringa con formato personalizzato mm'/'dd'/'yyyy, ad esempio, produce una stringa in cui come separatore di data viene sempre usato "/". Per cambiare il separatore di data per tutte le date per le impostazioni cultura, modificare il valore della proprietà DateTimeFormatInfo.DateSeparator per le impostazioni cultura correnti oppure creare un'istanza di un oggetto DateTimeFormatInfo, assegnare il carattere alla relativa proprietà DateSeparator e chiamare un overload del metodo di formattazione che include un parametro IFormatProvider.

Se l'identificatore di formato "/" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException.</target>
        <note />
      </trans-unit>
      <trans-unit id="day_of_the_month_1_2_digits">
        <source>day of the month (1-2 digits)</source>
        <target state="translated">Giorno del mese (1-2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="day_of_the_month_1_2_digits_description">
        <source>The "d" custom format specifier represents the day of the month as a number from 1 through 31. A single-digit day is formatted without a leading zero.

If the "d" format specifier is used without other custom format specifiers, it's interpreted as the "d" standard date and time format specifier.</source>
        <target state="translated">L'identificatore di formato personalizzato "d" rappresenta il giorno del mese come numero compreso tra 1 e 31. Un giorno a una sola cifra viene formattato senza uno zero iniziale.

Se l'identificatore di formato "d" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "d".</target>
        <note />
      </trans-unit>
      <trans-unit id="day_of_the_month_2_digits">
        <source>day of the month (2 digits)</source>
        <target state="translated">Giorno del mese (2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="day_of_the_month_2_digits_description">
        <source>The "dd" custom format string represents the day of the month as a number from 01 through 31. A single-digit day is formatted with a leading zero.</source>
        <target state="translated">La stringa di formato personalizzata "dd" rappresenta il giorno del mese come numero compreso tra 01 e 31. Un giorno a una sola cifra viene formattato con uno zero iniziale.</target>
        <note />
      </trans-unit>
      <trans-unit id="day_of_the_week_abbreviated">
        <source>day of the week (abbreviated)</source>
        <target state="translated">Giorno della settimana (abbreviato)</target>
        <note />
      </trans-unit>
      <trans-unit id="day_of_the_week_abbreviated_description">
        <source>The "ddd" custom format specifier represents the abbreviated name of the day of the week. The localized abbreviated name of the day of the week is retrieved from the DateTimeFormatInfo.AbbreviatedDayNames property of the current or specified culture.</source>
        <target state="translated">L'identificatore di formato personalizzato "ddd" rappresenta il nome abbreviato del giorno della settimana. Il nome abbreviato localizzato del giorno della settimana viene recuperato dalla proprietà DateTimeFormatInfo.AbbreviatedDayNames delle impostazioni cultura correnti o specificate.</target>
        <note />
      </trans-unit>
      <trans-unit id="day_of_the_week_full">
        <source>day of the week (full)</source>
        <target state="translated">Giorno della settimana (esteso)</target>
        <note />
      </trans-unit>
      <trans-unit id="day_of_the_week_full_description">
        <source>The "dddd" custom format specifier (plus any number of additional "d" specifiers) represents the full name of the day of the week. The localized name of the day of the week is retrieved from the DateTimeFormatInfo.DayNames property of the current or specified culture.</source>
        <target state="translated">L'identificatore di formato personalizzato "dddd" (più qualsiasi numero di identificatori "d" aggiuntivi) rappresenta il nome esteso del giorno della settimana. Il nome localizzato del giorno della settimana viene recuperato dalla proprietà DateTimeFormatInfo.DayNames delle impostazioni cultura correnti o specificate.</target>
        <note />
      </trans-unit>
      <trans-unit id="discard">
        <source>discard</source>
        <target state="translated">variabile discard</target>
        <note />
      </trans-unit>
      <trans-unit id="from_metadata">
        <source>from metadata</source>
        <target state="translated">da metadati</target>
        <note />
      </trans-unit>
      <trans-unit id="full_long_date_time">
        <source>full long date/time</source>
        <target state="translated">Ora estesa e data completa</target>
        <note />
      </trans-unit>
      <trans-unit id="full_long_date_time_description">
        <source>The "F" standard format specifier represents a custom date and time format string that is defined by the current DateTimeFormatInfo.FullDateTimePattern property. For example, the custom format string for the invariant culture is "dddd, dd MMMM yyyy HH:mm:ss".</source>
        <target state="translated">L'identificatore di formato standard "F" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.FullDateTimePattern corrente. Ad esempio, la stringa di formato personalizzata per le impostazioni cultura inglese non dipendenti da paese/area geografica è "dddd, dd MMMM yyyy HH:mm:ss".</target>
        <note />
      </trans-unit>
      <trans-unit id="full_short_date_time">
        <source>full short date/time</source>
        <target state="translated">Ora breve e data estesa</target>
        <note />
      </trans-unit>
      <trans-unit id="full_short_date_time_description">
        <source>The Full Date Short Time ("f") Format Specifier

The "f" standard format specifier represents a combination of the long date ("D") and short time ("t") patterns, separated by a space.</source>
        <target state="translated">Identificatore di formato di ora breve e data estesa ("f")

L'identificatore di formato standard "f" rappresenta una combinazione degli schemi di data estesa ("D") e ora breve ("t"), separati da uno spazio.</target>
        <note />
      </trans-unit>
      <trans-unit id="general_long_date_time">
        <source>general long date/time</source>
        <target state="translated">Ora estesa e data generale</target>
        <note />
      </trans-unit>
      <trans-unit id="general_long_date_time_description">
        <source>The "G" standard format specifier represents a combination of the short date ("d") and long time ("T") patterns, separated by a space.</source>
        <target state="translated">L'identificatore di formato standard "G" rappresenta una combinazione degli schemi di data breve ("d") e ora estesa ("T"), separati da uno spazio.</target>
        <note />
      </trans-unit>
      <trans-unit id="general_short_date_time">
        <source>general short date/time</source>
        <target state="translated">Ora breve e data generale</target>
        <note />
      </trans-unit>
      <trans-unit id="general_short_date_time_description">
        <source>The "g" standard format specifier represents a combination of the short date ("d") and short time ("t") patterns, separated by a space.</source>
        <target state="translated">L'identificatore di formato standard "g" rappresenta una combinazione degli schemi di data breve ("d") e ora breve ("t"), separati da uno spazio.</target>
        <note />
      </trans-unit>
      <trans-unit id="generic_overload">
        <source>generic overload</source>
        <target state="translated">overload generico</target>
        <note />
      </trans-unit>
      <trans-unit id="generic_overloads">
        <source>generic overloads</source>
        <target state="translated">overload generici</target>
        <note />
      </trans-unit>
      <trans-unit id="in_Source_attribute">
        <source>in Source (attribute)</source>
        <target state="translated">nell'origine (attributo)</target>
        <note />
      </trans-unit>
      <trans-unit id="long_date">
        <source>long date</source>
        <target state="translated">Data estesa</target>
        <note />
      </trans-unit>
      <trans-unit id="long_date_description">
        <source>The "D" standard format specifier represents a custom date and time format string that is defined by the current DateTimeFormatInfo.LongDatePattern property. For example, the custom format string for the invariant culture is "dddd, dd MMMM yyyy".</source>
        <target state="translated">L'identificatore di formato standard "D" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.LongDatePattern corrente. Ad esempio, la stringa di formato personalizzata per le impostazioni cultura inglese non dipendenti da paese/area geografica è "dddd, dd MMMM yyyy".</target>
        <note />
      </trans-unit>
      <trans-unit id="long_time">
        <source>long time</source>
        <target state="translated">Ora estesa</target>
        <note />
      </trans-unit>
      <trans-unit id="long_time_description">
        <source>The "T" standard format specifier represents a custom date and time format string that is defined by a specific culture's DateTimeFormatInfo.LongTimePattern property. For example, the custom format string for the invariant culture is "HH:mm:ss".</source>
        <target state="translated">L'identificatore di formato standard "T" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.LongTimePattern di impostazioni cultura specifiche. Ad esempio, la stringa di formato personalizzata per le impostazioni cultura inglese non dipendenti da paese/area geografica è "HH:mm:ss".</target>
        <note />
      </trans-unit>
      <trans-unit id="minute_1_2_digits">
        <source>minute (1-2 digits)</source>
        <target state="translated">Minuto (1-2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="minute_1_2_digits_description">
        <source>The "m" custom format specifier represents the minute as a number from 0 through 59. The minute represents whole minutes that have passed since the last hour. A single-digit minute is formatted without a leading zero.

If the "m" format specifier is used without other custom format specifiers, it's interpreted as the "m" standard date and time format specifier.</source>
        <target state="translated">L'identificatore di formato personalizzato "m" rappresenta i minuti come numero compreso tra 0 e 59. Tali minuti rappresentano il numero intero di minuti passati dall'ultima ora. Un minuto costituito da una singola cifra viene formattato senza zero iniziale.

Se l'identificatore di formato "m" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "m".</target>
        <note />
      </trans-unit>
      <trans-unit id="minute_2_digits">
        <source>minute (2 digits)</source>
        <target state="translated">Minuto (2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="minute_2_digits_description">
        <source>The "mm" custom format specifier (plus any number of additional "m" specifiers) represents the minute as a number from 00 through 59. The minute represents whole minutes that have passed since the last hour. A single-digit minute is formatted with a leading zero.</source>
        <target state="translated">L'identificatore di formato personalizzato "mm" (più qualsiasi numero di identificatori "m" aggiuntivi) rappresenta i minuti come numero compreso tra 00 e 59. Tali minuti rappresentano il numero intero di minuti passati dall'ultima ora. Un minuto costituito da una singola cifra viene formattato con uno zero iniziale.</target>
        <note />
      </trans-unit>
      <trans-unit id="month_1_2_digits">
        <source>month (1-2 digits)</source>
        <target state="translated">Mese (1-2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="month_1_2_digits_description">
        <source>The "M" custom format specifier represents the month as a number from 1 through 12 (or from 1 through 13 for calendars that have 13 months). A single-digit month is formatted without a leading zero.

If the "M" format specifier is used without other custom format specifiers, it's interpreted as the "M" standard date and time format specifier.</source>
        <target state="translated">L'identificatore di formato personalizzato "M" rappresenta il mese come numero compreso tra 1 e 12 (o tra 1 e 13 per i calendari con 13 mesi). Un mese a una sola cifra viene formattato senza zero iniziale.

Se l'identificatore di formato "M" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "M".</target>
        <note />
      </trans-unit>
      <trans-unit id="month_2_digits">
        <source>month (2 digits)</source>
        <target state="translated">Mese (2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="month_2_digits_description">
        <source>The "MM" custom format specifier represents the month as a number from 01 through 12 (or from 1 through 13 for calendars that have 13 months). A single-digit month is formatted with a leading zero.</source>
        <target state="translated">L'identificatore di formato personalizzato "MM" rappresenta il mese come numero compreso tra 01 e 12 (o tra 1 e 13 per i calendari con 13 mesi). Un mese a una sola cifra viene formattato con uno zero iniziale.</target>
        <note />
      </trans-unit>
      <trans-unit id="month_abbreviated">
        <source>month (abbreviated)</source>
        <target state="translated">Mese (abbreviato)</target>
        <note />
      </trans-unit>
      <trans-unit id="month_abbreviated_description">
        <source>The "MMM" custom format specifier represents the abbreviated name of the month. The localized abbreviated name of the month is retrieved from the DateTimeFormatInfo.AbbreviatedMonthNames property of the current or specified culture.</source>
        <target state="translated">L'identificatore di formato personalizzato "MMM" rappresenta il nome abbreviato del mese. Il nome abbreviato localizzato del mese viene recuperato dalla proprietà DateTimeFormatInfo.AbbreviatedMonthNames delle impostazioni cultura correnti o specificate.</target>
        <note />
      </trans-unit>
      <trans-unit id="month_day">
        <source>month day</source>
        <target state="translated">Giorno del mese</target>
        <note />
      </trans-unit>
      <trans-unit id="month_day_description">
        <source>The "M" or "m" standard format specifier represents a custom date and time format string that is defined by the current DateTimeFormatInfo.MonthDayPattern property. For example, the custom format string for the invariant culture is "MMMM dd".</source>
        <target state="translated">L'identificatore di formato standard "M" o "m" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.MonthDayPattern corrente. Ad esempio, la stringa di formato personalizzata per le impostazioni cultura inglese non dipendenti da paese/area geografica è "MMMM dd".</target>
        <note />
      </trans-unit>
      <trans-unit id="month_full">
        <source>month (full)</source>
        <target state="translated">Mese (esteso)</target>
        <note />
      </trans-unit>
      <trans-unit id="month_full_description">
        <source>The "MMMM" custom format specifier represents the full name of the month. The localized name of the month is retrieved from the DateTimeFormatInfo.MonthNames property of the current or specified culture.</source>
        <target state="translated">L'identificatore di formato personalizzato "MMMM" rappresenta il nome esteso del mese. Il nome localizzato del mese viene recuperato dalla proprietà DateTimeFormatInfo.MonthNames delle impostazioni cultura correnti o specificate.</target>
        <note />
      </trans-unit>
      <trans-unit id="overload">
        <source>overload</source>
        <target state="translated">overload</target>
        <note />
      </trans-unit>
      <trans-unit id="overloads_">
        <source>overloads</source>
        <target state="translated">overload</target>
        <note />
      </trans-unit>
      <trans-unit id="_0_Keyword">
        <source>{0} Keyword</source>
        <target state="translated">Parola chiave di {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Encapsulate_field_colon_0_and_use_property">
        <source>Encapsulate field: '{0}' (and use property)</source>
        <target state="translated">Incapsula il campo '{0}' (e usa la proprietà)</target>
        <note />
      </trans-unit>
      <trans-unit id="Encapsulate_field_colon_0_but_still_use_field">
        <source>Encapsulate field: '{0}' (but still use field)</source>
        <target state="translated">Incapsula il campo '{0}' (ma continua a usarlo)</target>
        <note />
      </trans-unit>
      <trans-unit id="Encapsulate_fields_and_use_property">
        <source>Encapsulate fields (and use property)</source>
        <target state="translated">Incapsula i campi (e usa la proprietà)</target>
        <note />
      </trans-unit>
      <trans-unit id="Encapsulate_fields_but_still_use_field">
        <source>Encapsulate fields (but still use field)</source>
        <target state="translated">Incapsula i campi (ma continua a usarli)</target>
        <note />
      </trans-unit>
      <trans-unit id="Could_not_extract_interface_colon_The_selection_is_not_inside_a_class_interface_struct">
        <source>Could not extract interface: The selection is not inside a class/interface/struct.</source>
        <target state="translated">Non è possibile estrarre l'interfaccia: la selezione non si trova all'interno di una classe/interfaccia/struct.</target>
        <note />
      </trans-unit>
      <trans-unit id="Could_not_extract_interface_colon_The_type_does_not_contain_any_member_that_can_be_extracted_to_an_interface">
        <source>Could not extract interface: The type does not contain any member that can be extracted to an interface.</source>
        <target state="translated">Non è possibile estrarre l'interfaccia: il tipo non contiene membri che possono essere estratti in un'interfaccia.</target>
        <note />
      </trans-unit>
      <trans-unit id="can_t_not_construct_final_tree">
        <source>can't not construct final tree</source>
        <target state="translated">non è possibile costruire l'albero finale</target>
        <note />
      </trans-unit>
      <trans-unit id="Parameters_type_or_return_type_cannot_be_an_anonymous_type_colon_bracket_0_bracket">
        <source>Parameters' type or return type cannot be an anonymous type : [{0}]</source>
        <target state="translated">Il tipo o il tipo restituito dei parametri non può essere un tipo anonimo: [{0}]</target>
        <note />
      </trans-unit>
      <trans-unit id="The_selection_contains_no_active_statement">
        <source>The selection contains no active statement.</source>
        <target state="translated">La selezione non contiene istruzioni attive.</target>
        <note />
      </trans-unit>
      <trans-unit id="The_selection_contains_an_error_or_unknown_type">
        <source>The selection contains an error or unknown type.</source>
        <target state="translated">La selezione contiene un errore o un tipo sconosciuto.</target>
        <note />
      </trans-unit>
      <trans-unit id="Type_parameter_0_is_hidden_by_another_type_parameter_1">
        <source>Type parameter '{0}' is hidden by another type parameter '{1}'.</source>
        <target state="translated">Il parametro di tipo '{0}' è nascosto da un altro parametro di tipo '{1}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="The_address_of_a_variable_is_used_inside_the_selected_code">
        <source>The address of a variable is used inside the selected code.</source>
        <target state="translated">Nel codice selezionato viene usato l'indirizzo di una variabile.</target>
        <note />
      </trans-unit>
      <trans-unit id="Assigning_to_readonly_fields_must_be_done_in_a_constructor_colon_bracket_0_bracket">
        <source>Assigning to readonly fields must be done in a constructor : [{0}].</source>
        <target state="translated">L'assegnazione a campi di sola lettura deve essere effettuata in un costruttore: [{0}].</target>
        <note />
      </trans-unit>
      <trans-unit id="generated_code_is_overlapping_with_hidden_portion_of_the_code">
        <source>generated code is overlapping with hidden portion of the code</source>
        <target state="translated">il codice generato si sovrappone alla parte nascosta del codice</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_optional_parameters_to_0">
        <source>Add optional parameters to '{0}'</source>
        <target state="translated">Aggiungi i parametri facoltativi a '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_parameters_to_0">
        <source>Add parameters to '{0}'</source>
        <target state="translated">Aggiungi i parametri a '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_delegating_constructor_0_1">
        <source>Generate delegating constructor '{0}({1})'</source>
        <target state="translated">Genera il costruttore delegante '{0}({1})'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_constructor_0_1">
        <source>Generate constructor '{0}({1})'</source>
        <target state="translated">Genera il costruttore '{0}({1})'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_field_assigning_constructor_0_1">
        <source>Generate field assigning constructor '{0}({1})'</source>
        <target state="translated">Genera il costruttore per l'assegnazione dei campi '{0}({1})'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_Equals_and_GetHashCode">
        <source>Generate Equals and GetHashCode</source>
        <target state="translated">Genera Equals e GetHashCode</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_Equals_object">
        <source>Generate Equals(object)</source>
        <target state="translated">Genera Equals(oggetto)</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_GetHashCode">
        <source>Generate GetHashCode()</source>
        <target state="translated">Genera GetHashCode()</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_constructor_in_0">
        <source>Generate constructor in '{0}'</source>
        <target state="translated">Genera il costruttore in '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_all">
        <source>Generate all</source>
        <target state="translated">Genera tutto</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_enum_member_1_0">
        <source>Generate enum member '{1}.{0}'</source>
        <target state="translated">Genera il membro di enumerazione '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_constant_1_0">
        <source>Generate constant '{1}.{0}'</source>
        <target state="translated">Genera la costante '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_read_only_property_1_0">
        <source>Generate read-only property '{1}.{0}'</source>
        <target state="translated">Genera la proprietà di sola lettura '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_property_1_0">
        <source>Generate property '{1}.{0}'</source>
        <target state="translated">Genera la proprietà '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_read_only_field_1_0">
        <source>Generate read-only field '{1}.{0}'</source>
        <target state="translated">Genera il campo di sola lettura '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_field_1_0">
        <source>Generate field '{1}.{0}'</source>
        <target state="translated">Genera il campo '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_local_0">
        <source>Generate local '{0}'</source>
        <target state="translated">Genera l'elemento '{0}' locale</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_0_1_in_new_file">
        <source>Generate {0} '{1}' in new file</source>
        <target state="translated">Genera l'elemento {0} '{1}' nel nuovo file</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_nested_0_1">
        <source>Generate nested {0} '{1}'</source>
        <target state="translated">Genera l'elemento {0} '{1}' annidato</target>
        <note />
      </trans-unit>
      <trans-unit id="Global_Namespace">
        <source>Global Namespace</source>
        <target state="translated">Spazio dei nomi globale</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_interface_abstractly">
        <source>Implement interface abstractly</source>
        <target state="translated">Implementa l'interfaccia in modo astratto</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_interface_through_0">
        <source>Implement interface through '{0}'</source>
        <target state="translated">Implementa l'interfaccia tramite '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_interface">
        <source>Implement interface</source>
        <target state="translated">Implementa l'interfaccia</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_field_for_0">
        <source>Introduce field for '{0}'</source>
        <target state="translated">Introduce il campo per '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_local_for_0">
        <source>Introduce local for '{0}'</source>
        <target state="translated">Introduce l'elemento locale per '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_constant_for_0">
        <source>Introduce constant for '{0}'</source>
        <target state="translated">Introduce la costante per '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_local_constant_for_0">
        <source>Introduce local constant for '{0}'</source>
        <target state="translated">Introduce la costante locale per '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_field_for_all_occurrences_of_0">
        <source>Introduce field for all occurrences of '{0}'</source>
        <target state="translated">Introduce il campo per tutte le occorrenze di '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_local_for_all_occurrences_of_0">
        <source>Introduce local for all occurrences of '{0}'</source>
        <target state="translated">Introduce l'elemento locale per tutte le occorrenze di '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_constant_for_all_occurrences_of_0">
        <source>Introduce constant for all occurrences of '{0}'</source>
        <target state="translated">Introduce la costante per tutte le occorrenze di '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_local_constant_for_all_occurrences_of_0">
        <source>Introduce local constant for all occurrences of '{0}'</source>
        <target state="translated">Introduce la costante locale per tutte le occorrenze di '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_query_variable_for_all_occurrences_of_0">
        <source>Introduce query variable for all occurrences of '{0}'</source>
        <target state="translated">Introduce la variabile di query per tutte le occorrenze di '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Introduce_query_variable_for_0">
        <source>Introduce query variable for '{0}'</source>
        <target state="translated">Introduce la variabile di query per '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Anonymous_Types_colon">
        <source>Anonymous Types:</source>
        <target state="translated">Tipi anonimi:</target>
        <note />
      </trans-unit>
      <trans-unit id="is_">
        <source>is</source>
        <target state="translated">è</target>
        <note />
      </trans-unit>
      <trans-unit id="Represents_an_object_whose_operations_will_be_resolved_at_runtime">
        <source>Represents an object whose operations will be resolved at runtime.</source>
        <target state="translated">Rappresenta un oggetto le cui operazioni verranno risolte in fase di esecuzione.</target>
        <note />
      </trans-unit>
      <trans-unit id="constant">
        <source>constant</source>
        <target state="translated">costante</target>
        <note />
      </trans-unit>
      <trans-unit id="field">
        <source>field</source>
        <target state="translated">campo</target>
        <note />
      </trans-unit>
      <trans-unit id="local_constant">
        <source>local constant</source>
        <target state="translated">costante locale</target>
        <note />
      </trans-unit>
      <trans-unit id="local_variable">
        <source>local variable</source>
        <target state="translated">variabile locale</target>
        <note />
      </trans-unit>
      <trans-unit id="label">
        <source>label</source>
        <target state="translated">Etichetta</target>
        <note />
      </trans-unit>
      <trans-unit id="period_era">
        <source>period/era</source>
        <target state="translated">Periodo/era</target>
        <note />
      </trans-unit>
      <trans-unit id="period_era_description">
        <source>The "g" or "gg" custom format specifiers (plus any number of additional "g" specifiers) represents the period or era, such as A.D. The formatting operation ignores this specifier if the date to be formatted doesn't have an associated period or era string.

If the "g" format specifier is used without other custom format specifiers, it's interpreted as the "g" standard date and time format specifier.</source>
        <target state="translated">Gli identificatori di formato personalizzati "g" o "gg" (più qualsiasi numero di identificatori "g" aggiuntivi) rappresentano il periodo o l'era, ad esempio D.C. Questo identificatore viene ignorato dall'operazione di formattazione se la data da formattare non è associata a una stringa di periodo o di era.

Se l'identificatore di formato "g" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "g".</target>
        <note />
      </trans-unit>
      <trans-unit id="range_variable">
        <source>range variable</source>
        <target state="translated">variabile di intervallo</target>
        <note />
      </trans-unit>
      <trans-unit id="parameter">
        <source>parameter</source>
        <target state="translated">parametro</target>
        <note />
      </trans-unit>
      <trans-unit id="in_">
        <source>in</source>
        <target state="translated">in</target>
        <note />
      </trans-unit>
      <trans-unit id="Summary_colon">
        <source>Summary:</source>
        <target state="translated">Riepilogo:</target>
        <note />
      </trans-unit>
      <trans-unit id="Locals_and_parameters">
        <source>Locals and parameters</source>
        <target state="translated">Variabili locali e parametri</target>
        <note />
      </trans-unit>
      <trans-unit id="Type_parameters_colon">
        <source>Type parameters:</source>
        <target state="translated">Parametri di tipo:</target>
        <note />
      </trans-unit>
      <trans-unit id="Returns_colon">
        <source>Returns:</source>
        <target state="translated">Valori restituiti:</target>
        <note />
      </trans-unit>
      <trans-unit id="Exceptions_colon">
        <source>Exceptions:</source>
        <target state="translated">Eccezioni:</target>
        <note />
      </trans-unit>
      <trans-unit id="Remarks_colon">
        <source>Remarks:</source>
        <target state="translated">Commenti:</target>
        <note />
      </trans-unit>
      <trans-unit id="generating_source_for_symbols_of_this_type_is_not_supported">
        <source>generating source for symbols of this type is not supported</source>
        <target state="translated">la generazione dell'origine per i simboli di questo tipo non è supportata</target>
        <note />
      </trans-unit>
      <trans-unit id="Assembly">
        <source>Assembly</source>
        <target state="translated">assembly</target>
        <note />
      </trans-unit>
      <trans-unit id="location_unknown">
        <source>location unknown</source>
        <target state="translated">percorso sconosciuto</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_a_complex_statement_containing_an_await_expression_will_prevent_the_debug_session_from_continuing">
        <source>Updating a complex statement containing an await expression will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna un'istruzione complessa contenente un'espressione await, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_visibility_of_a_constructor_will_prevent_the_debug_session_from_continuing">
        <source>Changing visibility of a constructor will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica la visibilità di un costruttore, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Capturing_variable_0_that_hasn_t_been_captured_before_will_prevent_the_debug_session_from_continuing">
        <source>Capturing variable '{0}' that hasn't been captured before will prevent the debug session from continuing.</source>
        <target state="translated">Se si acquisisce la variabile '{0}' che non è stata ancora acquisita, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Ceasing_to_capture_variable_0_will_prevent_the_debug_session_from_continuing">
        <source>Ceasing to capture variable '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se non si accede più alla variabile di acquisizione '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Deleting_captured_variable_0_will_prevent_the_debug_session_from_continuing">
        <source>Deleting captured variable '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si elimina la variabile catturata '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_the_type_of_a_captured_variable_0_previously_of_type_1_will_prevent_the_debug_session_from_continuing">
        <source>Changing the type of a captured variable '{0}' previously of type '{1}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica il tipo di una variabile catturata '{0}', in precedenza di tipo '{1}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_the_parameters_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Changing the parameters of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si modificano i parametri di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_the_return_type_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Changing the return type of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica il tipo restituito di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_the_type_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Changing the type of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica il tipo di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_will_prevent_the_debug_session_from_continuing">
        <source>Changing the declaration scope of a captured variable '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica l'ambito di dichiarazione di una variabile catturata '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Accessing_captured_variable_0_that_hasn_t_been_accessed_before_in_1_will_prevent_the_debug_session_from_continuing">
        <source>Accessing captured variable '{0}' that hasn't been accessed before in {1} will prevent the debug session from continuing.</source>
        <target state="translated">Se si accede alla variabile catturata '{0}' a cui non è stato ancora eseguito l'accesso in {1}, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Ceasing_to_access_captured_variable_0_in_1_will_prevent_the_debug_session_from_continuing">
        <source>Ceasing to access captured variable '{0}' in {1} will prevent the debug session from continuing.</source>
        <target state="translated">Se non si accede più alla variabile catturata '{0}' in {1}, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_0_that_accesses_captured_variables_1_and_2_declared_in_different_scopes_will_prevent_the_debug_session_from_continuing">
        <source>Adding '{0}' that accesses captured variables '{1}' and '{2}' declared in different scopes will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge '{0}', che accede alle variabile catturate '{1}' e '{2}' dichiarate in ambiti diversi, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Removing_0_that_accessed_captured_variables_1_and_2_declared_in_different_scopes_will_prevent_the_debug_session_from_continuing">
        <source>Removing '{0}' that accessed captured variables '{1}' and '{2}' declared in different scopes will prevent the debug session from continuing.</source>
        <target state="translated">Se si rimuove '{0}', che ha effettuato l'accesso alle variabile catturate '{1}' e '{2}' dichiarate in ambiti diversi, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_0_into_a_1_will_prevent_the_debug_session_from_continuing">
        <source>Adding '{0}' into a '{1}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge '{0}' in un elemento '{1}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_0_into_a_class_with_explicit_or_sequential_layout_will_prevent_the_debug_session_from_continuing">
        <source>Adding '{0}' into a class with explicit or sequential layout will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge '{0}' in una classe con layout esplicito o sequenziale, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_modifiers_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the modifiers of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiornano i modificatori di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_Handles_clause_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the Handles clause of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna la clausola Handles di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_0_with_the_Handles_clause_will_prevent_the_debug_session_from_continuing">
        <source>Adding '{0}' with the Handles clause will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge '{0}' con la clausola Handles, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_Implements_clause_of_a_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the Implements clause of a '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna la clausola Implements di un elemento '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Changing_the_constraint_from_0_to_1_will_prevent_the_debug_session_from_continuing">
        <source>Changing the constraint from '{0}' to '{1}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica il vincolo da '{0}' a '{1}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_variance_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the variance of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna la varianza di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_type_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the type of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna il tipo di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_initializer_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the initializer of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna l'inizializzatore di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_size_of_a_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the size of a '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiornano le dimensioni di un elemento '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_underlying_type_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the underlying type of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna il tipo sottostante di '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_base_class_and_or_base_interface_s_of_0_will_prevent_the_debug_session_from_continuing">
        <source>Updating the base class and/or base interface(s) of '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiornano la classe di base e/o le interfacce di base dell'elemento '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_a_field_to_an_event_or_vice_versa_will_prevent_the_debug_session_from_continuing">
        <source>Updating a field to an event or vice versa will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna il campo in un evento o viceversa, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_kind_of_a_type_will_prevent_the_debug_session_from_continuing">
        <source>Updating the kind of a type will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna il tipo di un tipo, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_kind_of_an_property_event_accessor_will_prevent_the_debug_session_from_continuing">
        <source>Updating the kind of an property/event accessor will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna il tipo di una funzione di accesso a proprietà/eventi, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_kind_of_a_method_Sub_Function_will_prevent_the_debug_session_from_continuing">
        <source>Updating the kind of a method (Sub/Function) will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna il tipo di un metodo (Sub/Function), la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_library_name_of_Declare_Statement_will_prevent_the_debug_session_from_continuing">
        <source>Updating the library name of Declare Statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna il nome della libreria dell'istruzione Declare, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_the_alias_of_Declare_Statement_will_prevent_the_debug_session_from_continuing">
        <source>Updating the alias of Declare Statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna l'alias dell'istruzione Declare, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Renaming_0_will_prevent_the_debug_session_from_continuing">
        <source>Renaming '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si rinomina '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_0_will_prevent_the_debug_session_from_continuing">
        <source>Adding '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_an_abstract_0_or_overriding_an_inherited_0_will_prevent_the_debug_session_from_continuing">
        <source>Adding an abstract '{0}' or overriding an inherited '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un elemento '{0}' astratto o si esegue l'override di un elemento '{0}' ereditato, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_a_MustOverride_0_or_overriding_an_inherited_0_will_prevent_the_debug_session_from_continuing">
        <source>Adding a MustOverride '{0}' or overriding an inherited '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un elemento '{0}' MustOverride o si esegue l'override di un elemento '{0}' ereditato, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_an_extern_0_will_prevent_the_debug_session_from_continuing">
        <source>Adding an extern '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un elemento '{0}' extern, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_an_imported_method_will_prevent_the_debug_session_from_continuing">
        <source>Adding an imported method will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un metodo importato, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_a_user_defined_0_will_prevent_the_debug_session_from_continuing">
        <source>Adding a user defined '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un elemento '{0}' definito dall'utente, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_a_generic_0_will_prevent_the_debug_session_from_continuing">
        <source>Adding a generic '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un elemento '{0}' generico, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_0_around_an_active_statement_will_prevent_the_debug_session_from_continuing">
        <source>Adding '{0}' around an active statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge '{0}' in prossimità di un'istruzione attiva, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Moving_0_will_prevent_the_debug_session_from_continuing">
        <source>Moving '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si sposta '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Deleting_0_will_prevent_the_debug_session_from_continuing">
        <source>Deleting '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si elimina '{0}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Deleting_0_around_an_active_statement_will_prevent_the_debug_session_from_continuing">
        <source>Deleting '{0}' around an active statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si elimina '{0}' in prossimità di un'istruzione attiva, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_a_method_body_will_prevent_the_debug_session_from_continuing">
        <source>Adding a method body will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un corpo del metodo, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Deleting_a_method_body_will_prevent_the_debug_session_from_continuing">
        <source>Deleting a method body will prevent the debug session from continuing.</source>
        <target state="translated">Se si elimina un corpo del metodo, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="An_active_statement_has_been_removed_from_its_original_method_You_must_revert_your_changes_to_continue_or_restart_the_debugging_session">
        <source>An active statement has been removed from its original method. You must revert your changes to continue or restart the debugging session.</source>
        <target state="translated">Un'istruzione attiva è stata rimossa dal metodo originale. Annullare le modifiche per continuare oppure riavviare la sessione di debug.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_async_or_iterator_modifier_around_an_active_statement_will_prevent_the_debug_session_from_continuing">
        <source>Updating async or iterator modifier around an active statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna un modificatore iterator o async in prossimità di un'istruzione attiva, la sessione di debug non potrà continuare.</target>
        <note>{Locked="async"}{Locked="iterator"} "async" and "iterator" are C#/VB keywords and should not be localized.</note>
      </trans-unit>
      <trans-unit id="Modifying_a_generic_method_will_prevent_the_debug_session_from_continuing">
        <source>Modifying a generic method will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica un metodo generico, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_whitespace_or_comments_in_a_generic_0_will_prevent_the_debug_session_from_continuing">
        <source>Modifying whitespace or comments in a generic '{0}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si modificano spazi vuoti o commenti in un elemento '{0}' generico, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_a_method_inside_the_context_of_a_generic_type_will_prevent_the_debug_session_from_continuing">
        <source>Modifying a method inside the context of a generic type will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica un metodo all'interno del contesto di un tipo generico, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_whitespace_or_comments_in_0_inside_the_context_of_a_generic_type_will_prevent_the_debug_session_from_continuing">
        <source>Modifying whitespace or comments in '{0}' inside the context of a generic type will prevent the debug session from continuing.</source>
        <target state="translated">Se si modificano spazi vuoti o commenti in '{0}' all'interno del contesto di un tipo generico, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_the_initializer_of_0_in_a_generic_type_will_prevent_the_debug_session_from_continuing">
        <source>Modifying the initializer of '{0}' in a generic type will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica l'inizializzatore di '{0}' in un tipo generico, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_the_initializer_of_0_in_a_partial_type_will_prevent_the_debug_session_from_continuing">
        <source>Modifying the initializer of '{0}' in a partial type will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica l'inizializzatore di '{0}' in un tipo parziale, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_a_constructor_to_a_type_with_a_field_or_property_initializer_that_contains_an_anonymous_function_will_prevent_the_debug_session_from_continuing">
        <source>Adding a constructor to a type with a field or property initializer that contains an anonymous function will prevent the debug session from continuing.</source>
        <target state="translated">Se aggiunge un costruttore a un tipo con un inizializzatore di campo o proprietà che contiene una funzione anonima, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Renaming_a_captured_variable_from_0_to_1_will_prevent_the_debug_session_from_continuing">
        <source>Renaming a captured variable, from '{0}' to '{1}' will prevent the debug session from continuing.</source>
        <target state="translated">Se si rinomina una variabile catturata '{0}' in '{1}', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_a_catch_finally_handler_with_an_active_statement_in_the_try_block_will_prevent_the_debug_session_from_continuing">
        <source>Modifying a catch/finally handler with an active statement in the try block will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica un gestore catch/finally con un'istruzione attiva nel blocco try, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_a_try_catch_finally_statement_when_the_finally_block_is_active_will_prevent_the_debug_session_from_continuing">
        <source>Modifying a try/catch/finally statement when the finally block is active will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica un'istruzione try/catch/finally quando il blocco finally è attivo, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_a_catch_handler_around_an_active_statement_will_prevent_the_debug_session_from_continuing">
        <source>Modifying a catch handler around an active statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica un gestore catch in prossimità di un'istruzione attiva, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_0_which_contains_the_stackalloc_operator_will_prevent_the_debug_session_from_continuing">
        <source>Modifying '{0}' which contains the 'stackalloc' operator will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica '{0}', che contiene l'operatore 'stackalloc', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_an_active_0_which_contains_On_Error_or_Resume_statements_will_prevent_the_debug_session_from_continuing">
        <source>Modifying an active '{0}' which contains 'On Error' or 'Resume' statements will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica un elemento '{0}' attivo che contiene istruzioni 'On Error' o 'Resume', la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_0_which_contains_an_Aggregate_Group_By_or_Join_query_clauses_will_prevent_the_debug_session_from_continuing">
        <source>Modifying '{0}' which contains an Aggregate, Group By, or Join query clauses will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica '{0}', che contiene una clausola di query Aggregate, Group By o Join, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_source_with_experimental_language_features_enabled_will_prevent_the_debug_session_from_continuing">
        <source>Modifying source with experimental language features enabled will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica l'origine con funzionalità sperimentali del linguaggio abilitate, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Updating_an_active_statement_will_prevent_the_debug_session_from_continuing">
        <source>Updating an active statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiorna un'istruzione attiva, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Removing_0_that_contains_an_active_statement_will_prevent_the_debug_session_from_continuing">
        <source>Removing '{0}' that contains an active statement will prevent the debug session from continuing.</source>
        <target state="translated">Se si rimuove '{0}', che contiene un'istruzione attiva, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Adding_a_new_file_will_prevent_the_debug_session_from_continuing">
        <source>Adding a new file will prevent the debug session from continuing.</source>
        <target state="translated">Se si aggiunge un nuovo file, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Attribute_0_is_missing_Updating_an_async_method_or_an_iterator_will_prevent_the_debug_session_from_continuing">
        <source>Attribute '{0}' is missing. Updating an async method or an iterator will prevent the debug session from continuing.</source>
        <target state="translated">Manca l'attributo '{0}'. Se si aggiorna un metodo asincrono o un iteratore, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Unexpected_interface_member_kind_colon_0">
        <source>Unexpected interface member kind: {0}</source>
        <target state="translated">Tipo di membro di interfaccia imprevisto: {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Unknown_symbol_kind">
        <source>Unknown symbol kind</source>
        <target state="translated">Tipo di simbolo sconosciuto</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_abstract_property_1_0">
        <source>Generate abstract property '{1}.{0}'</source>
        <target state="translated">Genera la proprietà astratta '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_abstract_method_1_0">
        <source>Generate abstract method '{1}.{0}'</source>
        <target state="translated">Genera il metodo astratto '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_method_1_0">
        <source>Generate method '{1}.{0}'</source>
        <target state="translated">Genera il metodo '{1}.{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Requested_assembly_already_loaded_from_0">
        <source>Requested assembly already loaded from '{0}'.</source>
        <target state="translated">L'assembly richiesto è già stato caricato da '{0}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="The_symbol_does_not_have_an_icon">
        <source>The symbol does not have an icon.</source>
        <target state="translated">Per il simbolo non esiste un'icona.</target>
        <note />
      </trans-unit>
      <trans-unit id="Asynchronous_method_cannot_have_ref_out_parameters_colon_bracket_0_bracket">
        <source>Asynchronous method cannot have ref/out parameters : [{0}]</source>
        <target state="translated">Il metodo asincrono non può contenere parametri ref/out: [{0}]</target>
        <note />
      </trans-unit>
      <trans-unit id="The_member_is_defined_in_metadata">
        <source>The member is defined in metadata.</source>
        <target state="translated">Il membro è definito nei metadati.</target>
        <note />
      </trans-unit>
      <trans-unit id="You_can_only_change_the_signature_of_a_constructor_indexer_method_or_delegate">
        <source>You can only change the signature of a constructor, indexer, method or delegate.</source>
        <target state="translated">È possibile modificare solo la firma di un costruttore, un indicizzatore, un metodo o un delegato.</target>
        <note />
      </trans-unit>
      <trans-unit id="This_symbol_has_related_definitions_or_references_in_metadata_Changing_its_signature_may_result_in_build_errors_Do_you_want_to_continue">
        <source>This symbol has related definitions or references in metadata. Changing its signature may result in build errors.

Do you want to continue?</source>
        <target state="translated">Nei metadati di questo simbolo sono presenti definizioni o riferimenti correlati. Se si modifica la firma, potrebbero verificarsi errori di compilazione.

Continuare?</target>
        <note />
      </trans-unit>
      <trans-unit id="Change_signature">
        <source>Change signature...</source>
        <target state="translated">Modifica firma...</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_new_type">
        <source>Generate new type...</source>
        <target state="translated">Genera nuovo tipo...</target>
        <note />
      </trans-unit>
      <trans-unit id="User_Diagnostic_Analyzer_Failure">
        <source>User Diagnostic Analyzer Failure.</source>
        <target state="translated">Errore dell'analizzatore diagnostico utente.</target>
        <note />
      </trans-unit>
      <trans-unit id="Analyzer_0_threw_an_exception_of_type_1_with_message_2">
        <source>Analyzer '{0}' threw an exception of type '{1}' with message '{2}'.</source>
        <target state="translated">L'analizzatore '{0}' ha generato un'eccezione di tipo '{1}'. Messaggio: '{2}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="Analyzer_0_threw_the_following_exception_colon_1">
        <source>Analyzer '{0}' threw the following exception:
'{1}'.</source>
        <target state="translated">L'analizzatore '{0}' ha generato l'eccezione seguente:
'{1}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="Simplify_Names">
        <source>Simplify Names</source>
        <target state="translated">Semplifica nomi</target>
        <note />
      </trans-unit>
      <trans-unit id="Simplify_Member_Access">
        <source>Simplify Member Access</source>
        <target state="translated">Semplifica accesso membri</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_qualification">
        <source>Remove qualification</source>
        <target state="translated">Rimuovi qualificazione</target>
        <note />
      </trans-unit>
      <trans-unit id="Unknown_error_occurred">
        <source>Unknown error occurred</source>
        <target state="translated">Si è verificato un errore sconosciuto</target>
        <note />
      </trans-unit>
      <trans-unit id="Available">
        <source>Available</source>
        <target state="translated">Disponibile</target>
        <note />
      </trans-unit>
      <trans-unit id="Not_Available">
        <source>Not Available</source>
        <target state="translated">Non disponibile</target>
        <note />
      </trans-unit>
      <trans-unit id="_0_1">
        <source>    {0} - {1}</source>
        <target state="translated">    {0} - {1}</target>
        <note />
      </trans-unit>
      <trans-unit id="You_can_use_the_navigation_bar_to_switch_context">
        <source>You can use the navigation bar to switch context.</source>
        <target state="translated">Per cambiare contesto, si può usare la barra di spostamento.</target>
        <note />
      </trans-unit>
      <trans-unit id="in_Source">
        <source>in Source</source>
        <target state="translated">nell'origine</target>
        <note />
      </trans-unit>
      <trans-unit id="in_Suppression_File">
        <source>in Suppression File</source>
        <target state="translated">nel file di eliminazione</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_Suppression_0">
        <source>Remove Suppression {0}</source>
        <target state="translated">Rimuovi eliminazione {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_Suppression">
        <source>Remove Suppression</source>
        <target state="translated">Rimuovi eliminazione</target>
        <note />
      </trans-unit>
      <trans-unit id="Pending">
        <source>&lt;Pending&gt;</source>
        <target state="translated">&lt;In sospeso&gt;</target>
        <note />
      </trans-unit>
      <trans-unit id="Note_colon_Tab_twice_to_insert_the_0_snippet">
        <source>Note: Tab twice to insert the '{0}' snippet.</source>
        <target state="translated">Nota: premere due volte TAB per inserire il frammento di codice '{0}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_interface_explicitly_with_Dispose_pattern">
        <source>Implement interface explicitly with Dispose pattern</source>
        <target state="translated">Implementa l'interfaccia in modo esplicito con il criterio Dispose</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_interface_with_Dispose_pattern">
        <source>Implement interface with Dispose pattern</source>
        <target state="translated">Implementa l'interfaccia con il criterio Dispose</target>
        <note />
      </trans-unit>
      <trans-unit id="Re_triage_0_currently_1">
        <source>Re-triage {0}(currently '{1}')</source>
        <target state="translated">Valuta di nuovo {0} (attualmente '{1}')</target>
        <note />
      </trans-unit>
      <trans-unit id="Argument_cannot_have_a_null_element">
        <source>Argument cannot have a null element.</source>
        <target state="translated">L'argomento non può contenere un elemento Null.</target>
        <note />
      </trans-unit>
      <trans-unit id="Argument_cannot_be_empty">
        <source>Argument cannot be empty.</source>
        <target state="translated">L'argomento non può essere vuoto.</target>
        <note />
      </trans-unit>
      <trans-unit id="Reported_diagnostic_with_ID_0_is_not_supported_by_the_analyzer">
        <source>Reported diagnostic with ID '{0}' is not supported by the analyzer.</source>
        <target state="translated">La diagnostica restituita con ID '{0}' non è supportata dall'analizzatore.</target>
        <note />
      </trans-unit>
      <trans-unit id="Computing_fix_all_occurrences_code_fix">
        <source>Computing fix all occurrences code fix...</source>
        <target state="translated">Calcolo di tutte le occorrenze da correggere nel codice...</target>
        <note />
      </trans-unit>
      <trans-unit id="Fix_all_occurrences">
        <source>Fix all occurrences</source>
        <target state="translated">Correggi tutte le occorrenze</target>
        <note />
      </trans-unit>
      <trans-unit id="Document">
        <source>Document</source>
        <target state="translated">Documento</target>
        <note />
      </trans-unit>
      <trans-unit id="Project">
        <source>Project</source>
        <target state="translated">PROGETTO</target>
        <note />
      </trans-unit>
      <trans-unit id="Solution">
        <source>Solution</source>
        <target state="translated">Soluzione</target>
        <note />
      </trans-unit>
      <trans-unit id="TODO_colon_dispose_managed_state_managed_objects">
        <source>TODO: dispose managed state (managed objects)</source>
        <target state="translated">TODO: eliminare lo stato gestito (oggetti gestiti)</target>
        <note />
      </trans-unit>
      <trans-unit id="TODO_colon_set_large_fields_to_null">
        <source>TODO: set large fields to null</source>
        <target state="translated">TODO: impostare campi di grandi dimensioni su Null</target>
        <note />
      </trans-unit>
      <trans-unit id="Modifying_0_which_contains_a_static_variable_will_prevent_the_debug_session_from_continuing">
        <source>Modifying '{0}' which contains a static variable will prevent the debug session from continuing.</source>
        <target state="translated">Se si modifica '{0}', che contiene una variabile statica, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Compiler2">
        <source>Compiler</source>
        <target state="translated">Compilatore</target>
        <note />
      </trans-unit>
      <trans-unit id="Live">
        <source>Live</source>
        <target state="translated">In tempo reale</target>
        <note />
      </trans-unit>
      <trans-unit id="enum_value">
        <source>enum value</source>
        <target state="translated">valore di enumerazione</target>
        <note>{Locked="enum"} "enum" is a C#/VB keyword and should not be localized.</note>
      </trans-unit>
      <trans-unit id="const_field">
        <source>const field</source>
        <target state="translated">campo const</target>
        <note>{Locked="const"} "const" is a C#/VB keyword and should not be localized.</note>
      </trans-unit>
      <trans-unit id="method">
        <source>method</source>
        <target state="translated">metodo</target>
        <note />
      </trans-unit>
      <trans-unit id="operator_">
        <source>operator</source>
        <target state="translated">operatore</target>
        <note />
      </trans-unit>
      <trans-unit id="constructor">
        <source>constructor</source>
        <target state="translated">costruttore</target>
        <note />
      </trans-unit>
      <trans-unit id="auto_property">
        <source>auto-property</source>
        <target state="translated">proprietà automatica</target>
        <note />
      </trans-unit>
      <trans-unit id="property_">
        <source>property</source>
        <target state="translated">proprietà</target>
        <note />
      </trans-unit>
      <trans-unit id="event_accessor">
        <source>event accessor</source>
        <target state="translated">funzione di accesso eventi</target>
        <note />
      </trans-unit>
      <trans-unit id="rfc1123_date_time">
        <source>rfc1123 date/time</source>
        <target state="translated">Data/ora RFC 1123</target>
        <note />
      </trans-unit>
      <trans-unit id="rfc1123_date_time_description">
        <source>The "R" or "r" standard format specifier represents a custom date and time format string that is defined by the DateTimeFormatInfo.RFC1123Pattern property. The pattern reflects a defined standard, and the property is read-only. Therefore, it is always the same, regardless of the culture used or the format provider supplied. The custom format string is "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'". When this standard format specifier is used, the formatting or parsing operation always uses the invariant culture.</source>
        <target state="translated">L'identificatore di formato standard "R" o "r" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.RFC1123Pattern corrente. Lo schema rispecchia uno standard definito e la proprietà è di sola lettura. Sarà quindi sempre lo stesso, indipendentemente dalle impostazioni cultura usate o dal provider di formato specificato. La stringa di formato personalizzata è "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'". Quando si usa questo identificatore di formato standard, la formattazione o l'operazione di analisi usa sempre le impostazioni cultura inglese non dipendenti da paese/area geografica.</target>
        <note />
      </trans-unit>
      <trans-unit id="round_trip_date_time">
        <source>round-trip date/time</source>
        <target state="translated">Data/ora round trip</target>
        <note />
      </trans-unit>
      <trans-unit id="round_trip_date_time_description">
        <source>The "O" or "o" standard format specifier represents a custom date and time format string using a pattern that preserves time zone information and emits a result string that complies with ISO 8601. For DateTime values, this format specifier is designed to preserve date and time values along with the DateTime.Kind property in text. The formatted string can be parsed back by using the DateTime.Parse(String, IFormatProvider, DateTimeStyles) or DateTime.ParseExact method if the styles parameter is set to DateTimeStyles.RoundtripKind.

The "O" or "o" standard format specifier corresponds to the "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK" custom format string for DateTime values and to the "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffzzz" custom format string for DateTimeOffset values. In this string, the pairs of single quotation marks that delimit individual characters, such as the hyphens, the colons, and the letter "T", indicate that the individual character is a literal that cannot be changed. The apostrophes do not appear in the output string.

The "O" or "o" standard format specifier (and the "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK" custom format string) takes advantage of the three ways that ISO 8601 represents time zone information to preserve the Kind property of DateTime values:

    The time zone component of DateTimeKind.Local date and time values is an offset from UTC (for example, +01:00, -07:00). All DateTimeOffset values are also represented in this format.

    The time zone component of DateTimeKind.Utc date and time values uses "Z" (which stands for zero offset) to represent UTC.

    DateTimeKind.Unspecified date and time values have no time zone information.

Because the "O" or "o" standard format specifier conforms to an international standard, the formatting or parsing operation that uses the specifier always uses the invariant culture and the Gregorian calendar.

Strings that are passed to the Parse, TryParse, ParseExact, and TryParseExact methods of DateTime and DateTimeOffset can be parsed by using the "O" or "o" format specifier if they are in one of these formats. In the case of DateTime objects, the parsing overload that you call should also include a styles parameter with a value of DateTimeStyles.RoundtripKind. Note that if you call a parsing method with the custom format string that corresponds to the "O" or "o" format specifier, you won't get the same results as "O" or "o". This is because parsing methods that use a custom format string can't parse the string representation of date and time values that lack a time zone component or use "Z" to indicate UTC.</source>
        <target state="translated">L'identificatore di formato standard "O" o "o" rappresenta una stringa di formato di data e ora personalizzata con uno schema che mantiene le informazioni sul fuso orario e crea una stringa di risultato conforme allo standard ISO 8601. Per i valori DateTime, questo identificatore di formato è progettato in modo da mantenere i valori di data e ora insieme alla proprietà DateTime.Kind nel testo. È possibile analizzare di nuovo la stringa formattata usando il metodo DateTime.Parse(String, IFormatProvider, DateTimeStyles) o DateTime.ParseExact se il parametro styles è impostato su DateTimeStyles.RoundtripKind.

L'identificatore di formato standard "O" o "o" corrisponde alla stringa di formato personalizzata "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK" per valori DateTime e alla stringa di formato personalizzata "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffzzz" per valori DateTimeOffset. In questa stringa le coppie di virgolette singole che delimitano singoli caratteri, ad esempio trattini, due punti e la lettera "T", indicano che il singolo carattere è un valore letterale che non può essere modificato. Gli apostrofi non vengono visualizzati nella stringa di output.

L'identificatore di formato standard "O" o "o" (e la stringa di formato personalizzata "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK") sfrutta i tre modi in cui lo standard ISO 8601 rappresenta le informazioni sul fuso orario per mantenere la proprietà Kind dei valori DateTime:

    Il componente relativo al fuso orario dei valori di data e ora DateTimeKind.Local rappresenta la differenza dall'ora UTC (ad esempio +01:00, -07:00). Anche tutti i valori DateTimeOffset sono rappresentati in questo formato.

    Il componente relativo al fuso orario dei valori di data e ora DateTimeKind.Utc usa "Z" (che corrisponde alla differenza zero) per rappresentare l'ora UTC.

    I valori di data e ora DateTimeKind.Unspecified non includono informazioni sul fuso orario.

Dal momento che l'identificatore di formato standard "O" o "o" è conforme a uno standard internazionale, per l'operazione di formattazione o di analisi che usa l'identificatore vengono usate sempre le impostazioni cultura inglese non dipendenti da paese/area geografica e il calendario gregoriano.

Le stringhe passate ai metodi Parse, TryParse, ParseExact e TryParseExact di DateTime e DateTimeOffset possono essere analizzate usando l'identificatore di formato "O" o "o" se sono in uno di questi formati. Nel caso degli oggetti DateTime, l'overload di analisi chiamato deve anche includere un parametro styles con un valore DateTimeStyles.RoundtripKind. Tenere presente che se si chiama un metodo di analisi con la stringa di formato personalizzata che corrisponde all'identificatore di formato "O" o "o", non si otterranno gli stessi risultati di "O" o "o". Il motivo è che i metodi di analisi che usano una stringa di formato personalizzata non possono analizzare la rappresentazione in formato stringa di valori di data e ora in cui manca un componente di fuso orario o che usano "Z" per indicare l'ora UTC.</target>
        <note />
      </trans-unit>
      <trans-unit id="second_1_2_digits">
        <source>second (1-2 digits)</source>
        <target state="translated">Secondo (1-2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="second_1_2_digits_description">
        <source>The "s" custom format specifier represents the seconds as a number from 0 through 59. The result represents whole seconds that have passed since the last minute. A single-digit second is formatted without a leading zero.

If the "s" format specifier is used without other custom format specifiers, it's interpreted as the "s" standard date and time format specifier.</source>
        <target state="translated">L'identificatore di formato personalizzato "s" rappresenta i secondi come numero compreso tra 0 e 59. Il risultato rappresenta il numero intero di secondi passati dall'ultimo minuto. Un secondo costituito da una singola cifra viene formattato senza zero iniziale.

Se l'identificatore di formato "s" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "s".</target>
        <note />
      </trans-unit>
      <trans-unit id="second_2_digits">
        <source>second (2 digits)</source>
        <target state="translated">Secondo (2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="second_2_digits_description">
        <source>The "ss" custom format specifier (plus any number of additional "s" specifiers) represents the seconds as a number from 00 through 59. The result represents whole seconds that have passed since the last minute. A single-digit second is formatted with a leading zero.</source>
        <target state="translated">L'identificatore di formato personalizzato "ss" (più qualsiasi numero di identificatori "s" aggiuntivi) rappresenta i secondi come numero compreso tra 00 e 59. Il risultato rappresenta il numero intero di secondi passati dall'ultimo minuto. Un secondo costituito da una singola cifra viene formattato con uno zero iniziale.</target>
        <note />
      </trans-unit>
      <trans-unit id="short_date">
        <source>short date</source>
        <target state="translated">Data breve</target>
        <note />
      </trans-unit>
      <trans-unit id="short_date_description">
        <source>The "d" standard format specifier represents a custom date and time format string that is defined by a specific culture's DateTimeFormatInfo.ShortDatePattern property. For example, the custom format string that is returned by the ShortDatePattern property of the invariant culture is "MM/dd/yyyy".</source>
        <target state="translated">L'identificatore di formato standard "d" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.ShortDatePattern di impostazioni cultura specifiche. Ad esempio, la stringa di formato personalizzata restituita dalla proprietà ShortDatePattern delle impostazioni cultura inglese non dipendenti da paese/area geografica è "MM/dd/yyyy".</target>
        <note />
      </trans-unit>
      <trans-unit id="short_time">
        <source>short time</source>
        <target state="translated">Ora breve</target>
        <note />
      </trans-unit>
      <trans-unit id="short_time_description">
        <source>The "t" standard format specifier represents a custom date and time format string that is defined by the current DateTimeFormatInfo.ShortTimePattern property. For example, the custom format string for the invariant culture is "HH:mm".</source>
        <target state="translated">L'identificatore di formato standard "t" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.ShortTimePattern corrente. Ad esempio, la stringa di formato personalizzata per le impostazioni cultura inglese non dipendenti da paese/area geografica è "HH:mm".</target>
        <note />
      </trans-unit>
      <trans-unit id="sortable_date_time">
        <source>sortable date/time</source>
        <target state="translated">Data/ora ordinabile</target>
        <note />
      </trans-unit>
      <trans-unit id="sortable_date_time_description">
        <source>The "s" standard format specifier represents a custom date and time format string that is defined by the DateTimeFormatInfo.SortableDateTimePattern property. The pattern reflects a defined standard (ISO 8601), and the property is read-only. Therefore, it is always the same, regardless of the culture used or the format provider supplied. The custom format string is "yyyy'-'MM'-'dd'T'HH':'mm':'ss".

The purpose of the "s" format specifier is to produce result strings that sort consistently in ascending or descending order based on date and time values. As a result, although the "s" standard format specifier represents a date and time value in a consistent format, the formatting operation does not modify the value of the date and time object that is being formatted to reflect its DateTime.Kind property or its DateTimeOffset.Offset value. For example, the result strings produced by formatting the date and time values 2014-11-15T18:32:17+00:00 and 2014-11-15T18:32:17+08:00 are identical.

When this standard format specifier is used, the formatting or parsing operation always uses the invariant culture.</source>
        <target state="translated">L'identificatore di formato standard "s" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.SortableDateTimePattern corrente. Lo schema rispecchia uno standard definito (ISO 8601) e la proprietà è di sola lettura. Sarà quindi sempre lo stesso, indipendentemente dalle impostazioni cultura usate o dal provider di formato specificato. La stringa di formato personalizzata è "yyyy'-'MM'-'dd'T'HH':'mm':'ss".

L'identificatore di formato "s" ha lo scopo di produrre stringhe di risultati organizzate coerentemente in ordine crescente o decrescente, in base ai valori di data e ora. Di conseguenza, anche se l'identificatore di formato standard "s" rappresenta un valore di data e ora in un formato coerente, l'operazione di formattazione non modifica il valore dell'oggetto data e ora che viene formattato per rispecchiare la proprietà DateTime.Kind o il valore DateTimeOffset.Offset corrispondente. Ad esempio, le stringhe di risultati generate dalla formattazione dei valori di data e ora 2014-11-15T18:32:17+00:00 e 2014-11-15T18:32:17+08:00 sono identiche.

Quando si usa questo identificatore di formato standard, la formattazione o l'operazione di analisi usa sempre le impostazioni cultura inglese non dipendenti da paese/area geografica.</target>
        <note />
      </trans-unit>
      <trans-unit id="symbol_cannot_be_a_namespace">
        <source>'symbol' cannot be a namespace.</source>
        <target state="translated">'L'elemento 'symbol' non può essere uno spazio dei nomi.</target>
        <note />
      </trans-unit>
      <trans-unit id="time_separator">
        <source>time separator</source>
        <target state="translated">Separatore di ora</target>
        <note />
      </trans-unit>
      <trans-unit id="time_separator_description">
        <source>The ":" custom format specifier represents the time separator, which is used to differentiate hours, minutes, and seconds. The appropriate localized time separator is retrieved from the DateTimeFormatInfo.TimeSeparator property of the current or specified culture.

Note: To change the time separator for a particular date and time string, specify the separator character within a literal string delimiter. For example, the custom format string hh'_'dd'_'ss produces a result string in which "_" (an underscore) is always used as the time separator. To change the time separator for all dates for a culture, either change the value of the DateTimeFormatInfo.TimeSeparator property of the current culture, or instantiate a DateTimeFormatInfo object, assign the character to its TimeSeparator property, and call an overload of the formatting method that includes an IFormatProvider parameter.

If the ":" format specifier is used without other custom format specifiers, it's interpreted as a standard date and time format specifier and throws a FormatException.</source>
        <target state="translated">L'identificatore di formato personalizzato ":" rappresenta il separatore di ora che viene usato per distinguere ore, minuti e secondi. Il separatore di ora localizzato appropriato viene recuperato dalla proprietà DateTimeFormatInfo.TimeSeparator delle impostazioni cultura correnti o specificate.

Nota: per modificare il separatore di ora per una particolare stringa di data e ora, specificare il carattere separatore all'interno di un delimitatore di stringa letterale. La stringa con formato personalizzato hh'_'dd'_'ss, ad esempio, produce una stringa in cui come separatore di ora viene sempre usato "_" (carattere di sottolineatura). Per cambiare il separatore di ora per tutte le date per impostazioni cultura, modificare il valore della proprietà DateTimeFormatInfo.TimeSeparator per le impostazioni cultura correnti oppure creare un'istanza di un oggetto DateTimeFormatInfo, assegnare il carattere alla relativa proprietà TimeSeparator e chiamare un overload del metodo di formattazione che include un parametro IFormatProvider.

Se l'identificatore di formato ":" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException.</target>
        <note />
      </trans-unit>
      <trans-unit id="time_zone">
        <source>time zone</source>
        <target state="translated">Fuso orario</target>
        <note />
      </trans-unit>
      <trans-unit id="time_zone_description">
        <source>The "K" custom format specifier represents the time zone information of a date and time value. When this format specifier is used with DateTime values, the result string is defined by the value of the DateTime.Kind property:

    For the local time zone (a DateTime.Kind property value of DateTimeKind.Local), this specifier is equivalent to the "zzz" specifier and produces a result string containing the local offset from Coordinated Universal Time (UTC); for example, "-07:00".

    For a UTC time (a DateTime.Kind property value of DateTimeKind.Utc), the result string includes a "Z" character to represent a UTC date.

    For a time from an unspecified time zone (a time whose DateTime.Kind property equals DateTimeKind.Unspecified), the result is equivalent to String.Empty.

For DateTimeOffset values, the "K" format specifier is equivalent to the "zzz" format specifier, and produces a result string containing the DateTimeOffset value's offset from UTC.

If the "K" format specifier is used without other custom format specifiers, it's interpreted as a standard date and time format specifier and throws a FormatException.</source>
        <target state="translated">L'identificatore di formato personalizzato "K" rappresenta le informazioni sul fuso orario di un valore di data e ora. Quando questo identificatore di formato viene usato con valori DateTime, la stringa di risultato viene definita dal valore della proprietà DateTime.Kind:

    Per il fuso orario locale (un valore della proprietà DateTime.Kind uguale a DateTimeKind.Local) questo identificatore è equivalente all'identificatore "zzz" e genera una stringa di risultato che contiene la differenza locale dall'ora UTC (Coordinated Universal Time), ad esempio "-07.00".

    Per un'ora UTC (un valore della proprietà DateTime.Kind uguale a DateTimeKind.Utc) la stringa di risultato include un carattere "Z" per rappresentare una data UTC.

    Per un'ora di un fuso orario non specificato (un'ora la cui proprietà DateTime.Kind è uguale a DateTimeKind.Unspecified) il risultato è equivalente a String.Empty.

Per i valori DateTimeOffset, l'identificatore di formato "K" è equivalente all'identificatore di formato "zzz" e genera una stringa di risultato che contiene la diffenza dall'ora UTC del valore DateTimeOffset.

Se l'identificatore di formato "K" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException.</target>
        <note />
      </trans-unit>
      <trans-unit id="type_constraint">
        <source>type constraint</source>
        <target state="translated">vincolo di tipo</target>
        <note />
      </trans-unit>
      <trans-unit id="type_parameter">
        <source>type parameter</source>
        <target state="translated">parametro di tipo</target>
        <note />
      </trans-unit>
      <trans-unit id="attribute">
        <source>attribute</source>
        <target state="translated">attributo</target>
        <note />
      </trans-unit>
      <trans-unit id="Replace_0_and_1_with_property">
        <source>Replace '{0}' and '{1}' with property</source>
        <target state="translated">Sostituisci '{0}' e '{1}' con la proprietà</target>
        <note />
      </trans-unit>
      <trans-unit id="Replace_0_with_property">
        <source>Replace '{0}' with property</source>
        <target state="translated">Sostituisci '{0}' con la proprietà</target>
        <note />
      </trans-unit>
      <trans-unit id="Method_referenced_implicitly">
        <source>Method referenced implicitly</source>
        <target state="translated">Metodo con riferimenti impliciti</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_type_0">
        <source>Generate type '{0}'</source>
        <target state="translated">Genera il tipo '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_0_1">
        <source>Generate {0} '{1}'</source>
        <target state="translated">Genera l'elemento {0} '{1}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Change_0_to_1">
        <source>Change '{0}' to '{1}'.</source>
        <target state="translated">Cambia '{0}' in '{1}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="Non_invoked_method_cannot_be_replaced_with_property">
        <source>Non-invoked method cannot be replaced with property.</source>
        <target state="translated">Non è possibile sostituire il metodo non richiamato con la proprietà.</target>
        <note />
      </trans-unit>
      <trans-unit id="Only_methods_with_a_single_argument_which_is_not_an_out_variable_declaration_can_be_replaced_with_a_property">
        <source>Only methods with a single argument, which is not an out variable declaration, can be replaced with a property.</source>
        <target state="translated">È possibile sostituire con una proprietà solo i metodi con un singolo argomento non corrispondente a una dichiarazione di variabile out.</target>
        <note />
      </trans-unit>
      <trans-unit id="Roslyn_HostError">
        <source>Roslyn.HostError</source>
        <target state="translated">Roslyn.HostError</target>
        <note />
      </trans-unit>
      <trans-unit id="An_instance_of_analyzer_0_cannot_be_created_from_1_colon_2">
        <source>An instance of analyzer {0} cannot be created from {1}: {2}.</source>
        <target state="translated">Non è possibile creare un'istanza dell'analizzatore {0} da {1}: {2}.</target>
        <note />
      </trans-unit>
      <trans-unit id="The_assembly_0_does_not_contain_any_analyzers">
        <source>The assembly {0} does not contain any analyzers.</source>
        <target state="translated">L'assembly {0} non contiene analizzatori.</target>
        <note />
      </trans-unit>
      <trans-unit id="Unable_to_load_Analyzer_assembly_0_colon_1">
        <source>Unable to load Analyzer assembly {0}: {1}</source>
        <target state="translated">Non è possibile caricare l'assembly dell'analizzatore {0}: {1}</target>
        <note />
      </trans-unit>
      <trans-unit id="Make_method_synchronous">
        <source>Make method synchronous</source>
        <target state="translated">Imposta il metodo come sincrono</target>
        <note />
      </trans-unit>
      <trans-unit id="from_0">
        <source>from {0}</source>
        <target state="translated">da {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Find_and_install_latest_version">
        <source>Find and install latest version</source>
        <target state="translated">Trova e installa l'ultima versione</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_local_version_0">
        <source>Use local version '{0}'</source>
        <target state="translated">Usa la versione locale '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_locally_installed_0_version_1_This_version_used_in_colon_2">
        <source>Use locally installed '{0}' version '{1}'
This version used in: {2}</source>
        <target state="translated">Usa la versione '{1}' di '{0}' installata in locale
Questa versione è usata {2}</target>
        <note />
      </trans-unit>
      <trans-unit id="Find_and_install_latest_version_of_0">
        <source>Find and install latest version of '{0}'</source>
        <target state="translated">Trova e installa l'ultima versione di '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Install_with_package_manager">
        <source>Install with package manager...</source>
        <target state="translated">Installa con Gestione pacchetti...</target>
        <note />
      </trans-unit>
      <trans-unit id="Install_0_1">
        <source>Install '{0} {1}'</source>
        <target state="translated">Installa '{0} {1}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Install_version_0">
        <source>Install version '{0}'</source>
        <target state="translated">Installa la versione '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_variable_0">
        <source>Generate variable '{0}'</source>
        <target state="translated">Genera la variabile '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Classes">
        <source>Classes</source>
        <target state="translated">Classi</target>
        <note />
      </trans-unit>
      <trans-unit id="Constants">
        <source>Constants</source>
        <target state="translated">Costanti</target>
        <note />
      </trans-unit>
      <trans-unit id="Delegates">
        <source>Delegates</source>
        <target state="translated">Delegati</target>
        <note />
      </trans-unit>
      <trans-unit id="Enums">
        <source>Enums</source>
        <target state="translated">Enumerazioni</target>
        <note />
      </trans-unit>
      <trans-unit id="Events">
        <source>Events</source>
        <target state="translated">Eventi</target>
        <note />
      </trans-unit>
      <trans-unit id="Extension_methods">
        <source>Extension methods</source>
        <target state="translated">Metodi di estensione</target>
        <note />
      </trans-unit>
      <trans-unit id="Fields">
        <source>Fields</source>
        <target state="translated">Campi</target>
        <note />
      </trans-unit>
      <trans-unit id="Interfaces">
        <source>Interfaces</source>
        <target state="translated">Interfacce</target>
        <note />
      </trans-unit>
      <trans-unit id="Locals">
        <source>Locals</source>
        <target state="translated">Variabili locali</target>
        <note />
      </trans-unit>
      <trans-unit id="Methods">
        <source>Methods</source>
        <target state="translated">Metodi</target>
        <note />
      </trans-unit>
      <trans-unit id="Modules">
        <source>Modules</source>
        <target state="translated">Moduli</target>
        <note />
      </trans-unit>
      <trans-unit id="Namespaces">
        <source>Namespaces</source>
        <target state="translated">Spazi dei nomi</target>
        <note />
      </trans-unit>
      <trans-unit id="Properties">
        <source>Properties</source>
        <target state="translated">Proprietà</target>
        <note />
      </trans-unit>
      <trans-unit id="Structures">
        <source>Structures</source>
        <target state="translated">Strutture</target>
        <note />
      </trans-unit>
      <trans-unit id="Parameters_colon">
        <source>Parameters:</source>
        <target state="translated">Parametri:</target>
        <note />
      </trans-unit>
      <trans-unit id="Variadic_SignatureHelpItem_must_have_at_least_one_parameter">
        <source>Variadic SignatureHelpItem must have at least one parameter.</source>
        <target state="translated">L'elemento SignatureHelpItem variadic deve avere almeno un parametro.</target>
        <note />
      </trans-unit>
      <trans-unit id="Replace_0_with_method">
        <source>Replace '{0}' with method</source>
        <target state="translated">Sostituisci '{0}' con il metodo</target>
        <note />
      </trans-unit>
      <trans-unit id="Replace_0_with_methods">
        <source>Replace '{0}' with methods</source>
        <target state="translated">Sostituisci '{0}' con i metodi</target>
        <note />
      </trans-unit>
      <trans-unit id="Property_referenced_implicitly">
        <source>Property referenced implicitly</source>
        <target state="translated">Proprietà con riferimenti impliciti</target>
        <note />
      </trans-unit>
      <trans-unit id="Property_cannot_safely_be_replaced_with_a_method_call">
        <source>Property cannot safely be replaced with a method call</source>
        <target state="translated">Non è possibile sostituire in modo sicuro la proprietà con una chiamata a un metodo</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_interpolated_string">
        <source>Convert to interpolated string</source>
        <target state="translated">Converti in stringa interpolata</target>
        <note />
      </trans-unit>
      <trans-unit id="Move_type_to_0">
        <source>Move type to {0}</source>
        <target state="translated">Sposta il tipo in {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Rename_file_to_0">
        <source>Rename file to {0}</source>
        <target state="translated">Rinomina il file in {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Rename_type_to_0">
        <source>Rename type to {0}</source>
        <target state="translated">Rinomina il tipo in {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_tag">
        <source>Remove tag</source>
        <target state="translated">Rimuovi tag</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_missing_param_nodes">
        <source>Add missing param nodes</source>
        <target state="translated">Aggiungi nodi di parametro mancanti</target>
        <note />
      </trans-unit>
      <trans-unit id="Make_containing_scope_async">
        <source>Make containing scope async</source>
        <target state="translated">Rendi asincrono l'ambito contenitore</target>
        <note />
      </trans-unit>
      <trans-unit id="Make_containing_scope_async_return_Task">
        <source>Make containing scope async (return Task)</source>
        <target state="translated">Rendi asincrono l'ambito contenitore (restituisci Task)</target>
        <note />
      </trans-unit>
      <trans-unit id="paren_Unknown_paren">
        <source>(Unknown)</source>
        <target state="translated">(Sconosciuto)</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_framework_type">
        <source>Use framework type</source>
        <target state="translated">Usa il tipo di framework</target>
        <note />
      </trans-unit>
      <trans-unit id="Install_package_0">
        <source>Install package '{0}'</source>
        <target state="translated">Installa il pacchetto '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="project_0">
        <source>project {0}</source>
        <target state="translated">progetto {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Fully_qualify_0">
        <source>Fully qualify '{0}'</source>
        <target state="translated">Qualifica completamente '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_reference_to_0">
        <source>Remove reference to '{0}'.</source>
        <target state="translated">Rimuove il riferimento a '{0}'.</target>
        <note />
      </trans-unit>
      <trans-unit id="Keywords">
        <source>Keywords</source>
        <target state="translated">Parole chiave</target>
        <note />
      </trans-unit>
      <trans-unit id="Snippets">
        <source>Snippets</source>
        <target state="translated">Frammenti</target>
        <note />
      </trans-unit>
      <trans-unit id="All_lowercase">
        <source>All lowercase</source>
        <target state="translated">Tutto minuscole</target>
        <note />
      </trans-unit>
      <trans-unit id="All_uppercase">
        <source>All uppercase</source>
        <target state="translated">Tutto maiuscole</target>
        <note />
      </trans-unit>
      <trans-unit id="First_word_capitalized">
        <source>First word capitalized</source>
        <target state="translated">Prima lettera maiuscola</target>
        <note />
      </trans-unit>
      <trans-unit id="Pascal_Case">
        <source>Pascal Case</source>
        <target state="translated">Notazione Pascal</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_document_0">
        <source>Remove document '{0}'</source>
        <target state="translated">Rimuovi il documento '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_document_0">
        <source>Add document '{0}'</source>
        <target state="translated">Aggiungi il documento '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_argument_name_0">
        <source>Add argument name '{0}'</source>
        <target state="translated">Aggiungi il nome di argomento '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Take_0">
        <source>Take '{0}'</source>
        <target state="translated">Accetta '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Take_both">
        <source>Take both</source>
        <target state="translated">Accetta entrambi</target>
        <note />
      </trans-unit>
      <trans-unit id="Take_bottom">
        <source>Take bottom</source>
        <target state="translated">Accetta inferiore</target>
        <note />
      </trans-unit>
      <trans-unit id="Take_top">
        <source>Take top</source>
        <target state="translated">Accetta superiore</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_unused_variable">
        <source>Remove unused variable</source>
        <target state="translated">Rimuovi la variabile non usata</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_binary">
        <source>Convert to binary</source>
        <target state="translated">Converti in binario</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_decimal">
        <source>Convert to decimal</source>
        <target state="translated">Converti in decimale</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_hex">
        <source>Convert to hex</source>
        <target state="translated">Converti in hex</target>
        <note />
      </trans-unit>
      <trans-unit id="Separate_thousands">
        <source>Separate thousands</source>
        <target state="translated">Separa le migliaia</target>
        <note />
      </trans-unit>
      <trans-unit id="Separate_words">
        <source>Separate words</source>
        <target state="translated">Separa le parole</target>
        <note />
      </trans-unit>
      <trans-unit id="Separate_nibbles">
        <source>Separate nibbles</source>
        <target state="translated">Separa i nibble</target>
        <note />
      </trans-unit>
      <trans-unit id="Remove_separators">
        <source>Remove separators</source>
        <target state="translated">Rimuovi i separatori</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_parameter_to_0">
        <source>Add parameter to '{0}'</source>
        <target state="translated">Aggiungi il parametro a '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_constructor">
        <source>Generate constructor...</source>
        <target state="translated">Genera il costruttore...</target>
        <note />
      </trans-unit>
      <trans-unit id="Pick_members_to_be_used_as_constructor_parameters">
        <source>Pick members to be used as constructor parameters</source>
        <target state="translated">Selezionare i membri da usare come parametri del costruttore</target>
        <note />
      </trans-unit>
      <trans-unit id="Pick_members_to_be_used_in_Equals_GetHashCode">
        <source>Pick members to be used in Equals/GetHashCode</source>
        <target state="translated">Selezionare i membri da usare in Equals/GetHashCode</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_overrides">
        <source>Generate overrides...</source>
        <target state="translated">Genera gli override...</target>
        <note />
      </trans-unit>
      <trans-unit id="Pick_members_to_override">
        <source>Pick members to override</source>
        <target state="translated">Selezionare i membri di cui eseguire l'override</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_null_check">
        <source>Add null check</source>
        <target state="translated">Aggiungi il controllo Null</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_string_IsNullOrEmpty_check">
        <source>Add 'string.IsNullOrEmpty' check</source>
        <target state="translated">Aggiungi il controllo 'string.IsNullOrEmpty'</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_string_IsNullOrWhiteSpace_check">
        <source>Add 'string.IsNullOrWhiteSpace' check</source>
        <target state="translated">Aggiungi il controllo 'string.IsNullOrWhiteSpace'</target>
        <note />
      </trans-unit>
      <trans-unit id="Initialize_field_0">
        <source>Initialize field '{0}'</source>
        <target state="translated">Inizializza il campo '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Initialize_property_0">
        <source>Initialize property '{0}'</source>
        <target state="translated">Inizializza la proprietà '{0}'</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_null_checks">
        <source>Add null checks</source>
        <target state="translated">Aggiungi i controlli Null</target>
        <note />
      </trans-unit>
      <trans-unit id="Generate_operators">
        <source>Generate operators</source>
        <target state="translated">Genera gli operatori</target>
        <note />
      </trans-unit>
      <trans-unit id="Implement_0">
        <source>Implement {0}</source>
        <target state="translated">Implementa {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Reported_diagnostic_0_has_a_source_location_in_file_1_which_is_not_part_of_the_compilation_being_analyzed">
        <source>Reported diagnostic '{0}' has a source location in file '{1}', which is not part of the compilation being analyzed.</source>
        <target state="translated">Il percorso di origine della diagnostica restituita '{0}' è incluso nel file '{1}', che non fa parte della compilazione da analizzare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Reported_diagnostic_0_has_a_source_location_1_in_file_2_which_is_outside_of_the_given_file">
        <source>Reported diagnostic '{0}' has a source location '{1}' in file '{2}', which is outside of the given file.</source>
        <target state="translated">Il percorso di origine '{1}' della diagnostica restituita '{0}' è incluso nel file '{2}', che non è presente nel file specificato.</target>
        <note />
      </trans-unit>
      <trans-unit id="in_0_project_1">
        <source>in {0} (project {1})</source>
        <target state="translated">in {0} (progetto {1})</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_accessibility_modifiers">
        <source>Add accessibility modifiers</source>
        <target state="translated">Aggiungi i modificatori di accessibilità</target>
        <note />
      </trans-unit>
      <trans-unit id="Move_declaration_near_reference">
        <source>Move declaration near reference</source>
        <target state="translated">Sposta la dichiarazione accanto al riferimento</target>
        <note />
      </trans-unit>
      <trans-unit id="Convert_to_full_property">
        <source>Convert to full property</source>
        <target state="translated">Converti in proprietà completa</target>
        <note />
      </trans-unit>
      <trans-unit id="Warning_Method_overrides_symbol_from_metadata">
        <source>Warning: Method overrides symbol from metadata</source>
        <target state="translated">Avviso: il metodo esegue l'override del simbolo dei metadati</target>
        <note />
      </trans-unit>
      <trans-unit id="Use_0">
        <source>Use {0}</source>
        <target state="translated">Usa {0}</target>
        <note />
      </trans-unit>
      <trans-unit id="Switching_between_lambda_and_local_function_will_prevent_the_debug_session_from_continuing">
        <source>Switching between a lambda and a local function will prevent the debug session from continuing.</source>
        <target state="translated">Se si passa da un'espressione lambda a una funzione locale e viceversa, la sessione di debug non potrà continuare.</target>
        <note />
      </trans-unit>
      <trans-unit id="Add_argument_name_0_including_trailing_arguments">
        <source>Add argument name '{0}' (including trailing arguments)</source>
        <target state="translated">Aggiungi il nome di argomento '{0}' (inclusi gli argomenti finali)</target>
        <note />
      </trans-unit>
      <trans-unit id="local_function">
        <source>local function</source>
        <target state="translated">funzione locale</target>
        <note />
      </trans-unit>
      <trans-unit id="indexer_">
        <source>indexer</source>
        <target state="translated">indicizzatore</target>
        <note />
      </trans-unit>
      <trans-unit id="Alias_ambiguous_type_0">
        <source>Alias ambiguous type '{0}'</source>
        <target state="translated">Tipo di alias '{0}' ambiguo</target>
        <note />
      </trans-unit>
      <trans-unit id="Warning_colon_Collection_was_modified_during_iteration">
        <source>Warning: Collection was modified during iteration.</source>
        <target state="translated">Avviso: la raccolta è stata modificata durante l'iterazione.</target>
        <note />
      </trans-unit>
      <trans-unit id="Warning_colon_Iteration_variable_crossed_function_boundary">
        <source>Warning: Iteration variable crossed function boundary.</source>
        <target state="translated">Avviso: la variabile di iterazione ha superato il limite della funzione.</target>
        <note />
      </trans-unit>
      <trans-unit id="Warning_colon_Collection_may_be_modified_during_iteration">
        <source>Warning: Collection may be modified during iteration.</source>
        <target state="translated">Avviso: è possibile che la raccolta venga modificata durante l'iterazione.</target>
        <note />
      </trans-unit>
      <trans-unit id="universal_full_date_time">
        <source>universal full date/time</source>
        <target state="translated">Data/ora estesa universale</target>
        <note />
      </trans-unit>
      <trans-unit id="universal_full_date_time_description">
        <source>The "U" standard format specifier represents a custom date and time format string that is defined by a specified culture's DateTimeFormatInfo.FullDateTimePattern property. The pattern is the same as the "F" pattern. However, the DateTime value is automatically converted to UTC before it is formatted.</source>
        <target state="translated">L'identificatore di formato standard "U" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.FullDateTimePattern di impostazioni cultura specifiche. Lo schema è uguale a quello di "F". Il valore DateTime, tuttavia, viene convertito automaticamente in formato UTC prima di essere formattato.</target>
        <note />
      </trans-unit>
      <trans-unit id="universal_sortable_date_time">
        <source>universal sortable date/time</source>
        <target state="translated">Data/ora ordinabile universale</target>
        <note />
      </trans-unit>
      <trans-unit id="universal_sortable_date_time_description">
        <source>The "u" standard format specifier represents a custom date and time format string that is defined by the DateTimeFormatInfo.UniversalSortableDateTimePattern property. The pattern reflects a defined standard, and the property is read-only. Therefore, it is always the same, regardless of the culture used or the format provider supplied. The custom format string is "yyyy'-'MM'-'dd HH':'mm':'ss'Z'". When this standard format specifier is used, the formatting or parsing operation always uses the invariant culture.

Although the result string should express a time as Coordinated Universal Time (UTC), no conversion of the original DateTime value is performed during the formatting operation. Therefore, you must convert a DateTime value to UTC by calling the DateTime.ToUniversalTime method before formatting it.</source>
        <target state="translated">L'identificatore di formato standard "u" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.UniversalSortableDateTimePattern corrente. Lo schema rispecchia uno standard definito e la proprietà è di sola lettura. Sarà quindi sempre lo stesso, indipendentemente dalle impostazioni cultura usate o dal provider di formato specificato. La stringa di formato personalizzata è "yyyy'-'MM'-'dd HH':'mm':'ss'Z'". Quando si usa questo identificatore di formato standard, la formattazione o l'operazione di analisi usa sempre le impostazioni cultura inglese non dipendenti da paese/area geografica.

Anche se la stringa di risultato deve esprimere un'ora in formato UTC (Coordinated Universal Time), non viene eseguita alcuna conversione del valore DateTime originale durante l'operazione di formattazione. È quindi necessario convertire un valore DateTime in formato UTC chiamando il metodo DateTime.ToUniversalTime prima di eseguire l'operazione di formattazione.</target>
        <note />
      </trans-unit>
      <trans-unit id="updating_usages_in_containing_member">
        <source>updating usages in containing member</source>
        <target state="translated">aggiornamento degli utilizzi nel membro contenitore</target>
        <note />
      </trans-unit>
      <trans-unit id="updating_usages_in_containing_project">
        <source>updating usages in containing project</source>
        <target state="translated">aggiornamento degli utilizzi nel progetto contenitore</target>
        <note />
      </trans-unit>
      <trans-unit id="updating_usages_in_containing_type">
        <source>updating usages in containing type</source>
        <target state="translated">aggiornamento degli utilizzi nel tipo contenitore</target>
        <note />
      </trans-unit>
      <trans-unit id="updating_usages_in_dependent_projects">
        <source>updating usages in dependent projects</source>
        <target state="translated">aggiornamento degli utilizzi nei progetti dipendenti</target>
        <note />
      </trans-unit>
      <trans-unit id="utc_hour_and_minute_offset">
        <source>utc hour and minute offset</source>
        <target state="translated">Differenza dall'ora UTC in ore e minuti</target>
        <note />
      </trans-unit>
      <trans-unit id="utc_hour_and_minute_offset_description">
        <source>With DateTime values, the "zzz" custom format specifier represents the signed offset of the local operating system's time zone from UTC, measured in hours and minutes. It doesn't reflect the value of an instance's DateTime.Kind property. For this reason, the "zzz" format specifier is not recommended for use with DateTime values.

With DateTimeOffset values, this format specifier represents the DateTimeOffset value's offset from UTC in hours and minutes.

The offset is always displayed with a leading sign. A plus sign (+) indicates hours ahead of UTC, and a minus sign (-) indicates hours behind UTC. A single-digit offset is formatted with a leading zero.</source>
        <target state="translated">Con valori DateTime, l'identificatore di formato personalizzato "zzz" rappresenta la differenza dall'ora UTC con segno del fuso orario del sistema operativo locale, misurata in ore e minuti. Non rispecchia il valore della proprietà DateTime.Kind di un'istanza. Per questo motivo, non è consigliabile usare l'identificatore di formato "zzz" con valori DateTime.

Con valori DateTimeOffset, questo identificatore di formato rappresenta la differenza dall'ora UTC del valore DateTimeOffset in ore e minuti.

La differenza viene sempre visualizzata con un segno iniziale. Un segno più (+) indica le ore in più e un segno meno (-) le ore in meno rispetto all'ora UTC. Un valore di differenza a una sola cifra viene formattato con uno zero iniziale.</target>
        <note />
      </trans-unit>
      <trans-unit id="utc_hour_offset_1_2_digits">
        <source>utc hour offset (1-2 digits)</source>
        <target state="translated">Differenza dall'ora UTC in ore (1-2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="utc_hour_offset_1_2_digits_description">
        <source>With DateTime values, the "z" custom format specifier represents the signed offset of the local operating system's time zone from Coordinated Universal Time (UTC), measured in hours. It doesn't reflect the value of an instance's DateTime.Kind property. For this reason, the "z" format specifier is not recommended for use with DateTime values.

With DateTimeOffset values, this format specifier represents the DateTimeOffset value's offset from UTC in hours.

The offset is always displayed with a leading sign. A plus sign (+) indicates hours ahead of UTC, and a minus sign (-) indicates hours behind UTC. A single-digit offset is formatted without a leading zero.

If the "z" format specifier is used without other custom format specifiers, it's interpreted as a standard date and time format specifier and throws a FormatException.</source>
        <target state="translated">Con valori DateTime, l'identificatore di formato personalizzato "z" rappresenta la differenza dall'ora UTC (Coordinated Universal Time) con segno del fuso orario del sistema operativo locale, misurata in ore. Non rispecchia il valore della proprietà DateTime.Kind di un'istanza. Per questo motivo, non è consigliabile usare l'identificatore di formato "z" con valori DateTime.

Con valori DateTimeOffset, questo identificatore di formato rappresenta la differenza dall'ora UTC del valore DateTimeOffset in ore.

La differenza viene sempre visualizzata con un segno iniziale. Un segno più (+) indica le ore in più e un segno meno (-) le ore in meno rispetto all'ora UTC. Un valore di differenza a una sola cifra viene formattato senza zero iniziale.

Se l'identificatore di formato "z" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard e viene generato un evento FormatException.</target>
        <note />
      </trans-unit>
      <trans-unit id="utc_hour_offset_2_digits">
        <source>utc hour offset (2 digits)</source>
        <target state="translated">Differenza dall'ora UTC in ore (2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="utc_hour_offset_2_digits_description">
        <source>With DateTime values, the "zz" custom format specifier represents the signed offset of the local operating system's time zone from UTC, measured in hours. It doesn't reflect the value of an instance's DateTime.Kind property. For this reason, the "zz" format specifier is not recommended for use with DateTime values.

With DateTimeOffset values, this format specifier represents the DateTimeOffset value's offset from UTC in hours.

The offset is always displayed with a leading sign. A plus sign (+) indicates hours ahead of UTC, and a minus sign (-) indicates hours behind UTC. A single-digit offset is formatted with a leading zero.</source>
        <target state="translated">Con valori DateTime, l'identificatore di formato personalizzato "zz" rappresenta la differenza dall'ora UTC con segno del fuso orario del sistema operativo locale, misurata in ore. Non rispecchia il valore della proprietà DateTime.Kind di un'istanza. Per questo motivo, non è consigliabile usare l'identificatore di formato "zz" con valori DateTime.

Con valori DateTimeOffset, questo identificatore di formato rappresenta la differenza dall'ora UTC del valore DateTimeOffset in ore.

La differenza viene sempre visualizzata con un segno iniziale. Un segno più (+) indica le ore in più e un segno meno (-) le ore in meno rispetto all'ora UTC. Un valore di differenza a una sola cifra viene formattato con uno zero iniziale.</target>
        <note />
      </trans-unit>
      <trans-unit id="x_y_range_in_reverse_order">
        <source>[x-y] range in reverse order</source>
        <target state="translated">Intervallo [x-y] in ordine inverso</target>
        <note>This is an error message shown to the user when they write an invalid Regular Expression. Example: [b-a]</note>
      </trans-unit>
      <trans-unit id="year_1_2_digits">
        <source>year (1-2 digits)</source>
        <target state="translated">Anno (1-2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="year_1_2_digits_description">
        <source>The "y" custom format specifier represents the year as a one-digit or two-digit number. If the year has more than two digits, only the two low-order digits appear in the result. If the first digit of a two-digit year begins with a zero (for example, 2008), the number is formatted without a leading zero.

If the "y" format specifier is used without other custom format specifiers, it's interpreted as the "y" standard date and time format specifier.</source>
        <target state="translated">L'identificatore di formato personalizzato "y" rappresenta l'anno come numero a una cifra o a due cifre. Se l'anno ha più di due cifre, nel risultato vengono visualizzate solo le due cifre di ordine inferiore. Se la prima cifra di un anno a due cifre inizia con zero (ad esempio, 2008), il numero viene formattato senza zero iniziale.

Se l'identificatore di formato "y" viene usato senza altri identificatori di formato personalizzati, viene interpretato come l'identificatore di formato di data e ora standard "y".</target>
        <note />
      </trans-unit>
      <trans-unit id="year_2_digits">
        <source>year (2 digits)</source>
        <target state="translated">Anno (2 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="year_2_digits_description">
        <source>The "yy" custom format specifier represents the year as a two-digit number. If the year has more than two digits, only the two low-order digits appear in the result. If the two-digit year has fewer than two significant digits, the number is padded with leading zeros to produce two digits.

In a parsing operation, a two-digit year that is parsed using the "yy" custom format specifier is interpreted based on the Calendar.TwoDigitYearMax property of the format provider's current calendar. The following example parses the string representation of a date that has a two-digit year by using the default Gregorian calendar of the en-US culture, which, in this case, is the current culture. It then changes the current culture's CultureInfo object to use a GregorianCalendar object whose TwoDigitYearMax property has been modified.</source>
        <target state="translated">L'identificatore di formato personalizzato "yy" rappresenta l'anno come numero a due cifre. Se l'anno ha più di due cifre, nel risultato vengono visualizzate solo le due cifre di ordine inferiore. Se l'anno a due cifre ha meno di due cifre significative, prima del numero vengono aggiunti gli zeri necessari per ottenere due cifre.

In un'operazione di analisi un anno a due cifre analizzato usando l'identificatore di formato personalizzato "yy" viene interpretato in base alla proprietà Calendar.TwoDigitYearMax del calendario corrente del provider di formato. Nell'esempio seguente viene analizzata la rappresentazione di stringa di una data con un anno a due cifre usando il calendario gregoriano predefinito delle impostazioni cultura en-US, che, in questo caso, sono le impostazioni cultura correnti. Modifica quindi l'oggetto CultureInfo delle impostazioni cultura correnti per usare un oggetto GregorianCalendar la cui proprietà TwoDigitYearMax è stata modificata.</target>
        <note />
      </trans-unit>
      <trans-unit id="year_3_4_digits">
        <source>year (3-4 digits)</source>
        <target state="translated">Anno (3-4 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="year_3_4_digits_description">
        <source>The "yyy" custom format specifier represents the year with a minimum of three digits. If the year has more than three significant digits, they are included in the result string. If the year has fewer than three digits, the number is padded with leading zeros to produce three digits.</source>
        <target state="translated">L'identificatore di formato personalizzato "yyy" rappresenta l'anno con un minimo di tre cifre. Se l'anno ha più di tre cifre significative, queste vengono incluse nella stringa di risultato. Se l'anno ha meno di tre cifre, prima del numero vengono aggiunti gli zeri necessari per ottenere tre cifre.</target>
        <note />
      </trans-unit>
      <trans-unit id="year_4_digits">
        <source>year (4 digits)</source>
        <target state="translated">Anno (4 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="year_4_digits_description">
        <source>The "yyyy" custom format specifier represents the year with a minimum of four digits. If the year has more than four significant digits, they are included in the result string. If the year has fewer than four digits, the number is padded with leading zeros to produce four digits.</source>
        <target state="translated">L'identificatore di formato personalizzato "yyyy" rappresenta l'anno con un minimo di quattro cifre. Se l'anno ha più di quattro cifre significative, queste vengono incluse nella stringa di risultato. Se l'anno ha meno di quattro cifre, prima del numero vengono aggiunti gli zeri necessari per ottenere quattro cifre.</target>
        <note />
      </trans-unit>
      <trans-unit id="year_5_digits">
        <source>year (5 digits)</source>
        <target state="translated">Anno (5 cifre)</target>
        <note />
      </trans-unit>
      <trans-unit id="year_5_digits_description">
        <source>The "yyyyy" custom format specifier (plus any number of additional "y" specifiers) represents the year with a minimum of five digits. If the year has more than five significant digits, they are included in the result string. If the year has fewer than five digits, the number is padded with leading zeros to produce five digits.

If there are additional "y" specifiers, the number is padded with as many leading zeros as necessary to produce the number of "y" specifiers.</source>
        <target state="translated">L'identificatore di formato personalizzato "yyyyy" (più qualsiasi numero di identificatori "y" aggiuntivi) rappresenta l'anno con un minimo di cinque cifre. Se l'anno ha più di cinque cifre significative, queste vengono incluse nella stringa di risultato. Se l'anno ha meno di cinque cifre, prima del numero vengono aggiunti gli zeri necessari per ottenere cinque cifre.

Se sono presenti identificatori "y" aggiuntivi, prima del numero vengono aggiunti gli zeri necessari per ottenere il numero di identificatori "y".</target>
        <note />
      </trans-unit>
      <trans-unit id="year_month">
        <source>year month</source>
        <target state="translated">Anno e mese</target>
        <note />
      </trans-unit>
      <trans-unit id="year_month_description">
        <source>The "Y" or "y" standard format specifier represents a custom date and time format string that is defined by the DateTimeFormatInfo.YearMonthPattern property of a specified culture. For example, the custom format string for the invariant culture is "yyyy MMMM".</source>
        <target state="translated">L'identificatore di formato standard "Y" o "y" rappresenta una stringa di formato di data e ora personalizzata definita dalla proprietà DateTimeFormatInfo.YearMonthPattern di impostazioni cultura specifiche. Ad esempio, la stringa di formato personalizzata per le impostazioni cultura inglese non dipendenti da paese/area geografica è "yyyy MMMM".</target>
        <note />
      </trans-unit>
    </body>
  </file>
</xliff>