/
MicrosoftCodeQualityAnalyzersResources.es.xlf
2047 lines (2047 loc) · 168 KB
/
MicrosoftCodeQualityAnalyzersResources.es.xlf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?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="es" original="../MicrosoftCodeQualityAnalyzersResources.resx">
<body>
<trans-unit id="AppendConfigureAwaitTrue">
<source>Append .ConfigureAwait(true)</source>
<target state="translated">Anexar .ConfigureAwait(true)</target>
<note />
</trans-unit>
<trans-unit id="AssigningSymbolAndItsMemberInSameStatementDescription">
<source>Assigning to a symbol and its member (field/property) in the same statement is not recommended. It is not clear if the member access was intended to use symbol's old value prior to the assignment or new value from the assignment in this statement. For clarity, consider splitting the assignments into separate statements.</source>
<target state="new">Assigning to a symbol and its member (field/property) in the same statement is not recommended. It is not clear if the member access was intended to use symbol's old value prior to the assignment or new value from the assignment in this statement. For clarity, consider splitting the assignments into separate statements.</target>
<note />
</trans-unit>
<trans-unit id="AssigningSymbolAndItsMemberInSameStatementMessage">
<source>Symbol '{0}' and its member '{1}' are both assigned in the same statement. You are at risk of assigning the member of an unintended object.</source>
<target state="new">Symbol '{0}' and its member '{1}' are both assigned in the same statement. You are at risk of assigning the member of an unintended object.</target>
<note />
</trans-unit>
<trans-unit id="AssigningSymbolAndItsMemberInSameStatementTitle">
<source>Assigning symbol and its member in the same statement.</source>
<target state="new">Assigning symbol and its member in the same statement.</target>
<note />
</trans-unit>
<trans-unit id="AvoidAsyncVoidTitle">
<source>Avoid Async Void</source>
<target state="translated">Evitar async void</target>
<note />
</trans-unit>
<trans-unit id="AvoidAsyncVoidDescription">
<source>#N/A</source>
<target state="translated">#N/D</target>
<note />
</trans-unit>
<trans-unit id="AvoidAsyncVoidMessage">
<source>Avoid Async Void</source>
<target state="translated">Evitar async void</target>
<note />
</trans-unit>
<trans-unit id="AsyncMethodNamesShouldEndInAsyncTitle">
<source>Async Method Names Should End in Async</source>
<target state="translated">Los nombres de métodos asincrónicos deben terminar en Async</target>
<note />
</trans-unit>
<trans-unit id="AsyncMethodNamesShouldEndInAsyncDescription">
<source>#N/A</source>
<target state="translated">#N/D</target>
<note />
</trans-unit>
<trans-unit id="AsyncMethodNamesShouldEndInAsyncMessage">
<source>Async Method Names Should End in Async</source>
<target state="translated">Los nombres de métodos asincrónicos deben terminar en Async</target>
<note />
</trans-unit>
<trans-unit id="DoNotCatchGeneralExceptionTypesDescription">
<source>A general exception such as System.Exception or System.SystemException or a disallowed exception type is caught in a catch statement, or a general catch clause is used. General and disallowed exceptions should not be caught.</source>
<target state="needs-review-translation">Una excepción general como System.Exception o System.SystemException se captura con una instrucción catch, o bien se utiliza una cláusula catch general. No deben capturarse excepciones generales.</target>
<note />
</trans-unit>
<trans-unit id="DoNotCatchGeneralExceptionTypesMessage">
<source>Modify '{0}' to catch a more specific allowed exception type, or rethrow the exception.</source>
<target state="needs-review-translation">Modifique "{0}" para capturar un tipo de excepción más específico, o bien reinicie la excepción.</target>
<note />
</trans-unit>
<trans-unit id="DoNotCatchGeneralExceptionTypesTitle">
<source>Do not catch general exception types</source>
<target state="translated">No capture tipos de excepción generales.</target>
<note />
</trans-unit>
<trans-unit id="DoNotPassAsyncLambdasAsVoidReturningDelegateTypesTitle">
<source>Don't Pass Async Lambdas as Void Returning Delegate Types</source>
<target state="translated">No pasar expresiones lambda asincrónicas como void que devuelve tipos de delegado</target>
<note />
</trans-unit>
<trans-unit id="DoNotPassAsyncLambdasAsVoidReturningDelegateTypesDescription">
<source>#N/A</source>
<target state="translated">#N/D</target>
<note />
</trans-unit>
<trans-unit id="DoNotPassAsyncLambdasAsVoidReturningDelegateTypesMessage">
<source>Don't Pass Async Lambdas as Void Returning Delegate Types</source>
<target state="translated">No pasar expresiones lambda asincrónicas como void que devuelve tipos de delegado</target>
<note />
</trans-unit>
<trans-unit id="DoNotPrefixEnumValuesWithTypeNameDescription">
<source>An enumeration's values should not start with the type name of the enumeration.</source>
<target state="translated">Los valores de una enumeración no deben comenzar con el nombre del tipo de la enumeración.</target>
<note />
</trans-unit>
<trans-unit id="DoNotPrefixEnumValuesWithTypeNameMessage">
<source>Do not prefix enum values with the name of the enum type '{0}'. </source>
<target state="translated">Los valores de una enumeración no deben usar como prefijo el nombre del tipo de la enumeración "{0}".</target>
<note />
</trans-unit>
<trans-unit id="DoNotPrefixEnumValuesWithTypeNameTitle">
<source>Do not prefix enum values with type name</source>
<target state="translated">No utilizar como prefijo el nombre del tipo en valores de la enumeración</target>
<note />
</trans-unit>
<trans-unit id="DoNotStoreAsyncLambdasAsVoidReturningDelegateTypesTitle">
<source>Don't Store Async Lambdas as Void Returning Delegate Types</source>
<target state="translated">No almacenar expresiones lambda asincrónicas como void que devuelve tipos de delegado</target>
<note />
</trans-unit>
<trans-unit id="DoNotStoreAsyncLambdasAsVoidReturningDelegateTypesDescription">
<source>#N/A</source>
<target state="translated">#N/D</target>
<note />
</trans-unit>
<trans-unit id="DoNotStoreAsyncLambdasAsVoidReturningDelegateTypesMessage">
<source>Don't Store Async Lambdas as Void Returning Delegate Types</source>
<target state="translated">No almacenar expresiones lambda asincrónicas como void que devuelve tipos de delegado</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageFinalizeOverride">
<source>Remove the finalizer from type '{0}', override Dispose(bool disposing), and put the finalization logic in the code path where 'disposing' is false. Otherwise, it might lead to duplicate Dispose invocations as the Base type '{1}' also provides a finalizer.</source>
<target state="translated">Elimine el finalizador del tipo "{0}", reemplace el valor de "Dispose(bool disposing)" y coloque la lógica de finalización en la ruta de código de manera que el valor de "disposing" se establezca como falso. De lo contrario, se duplicarían las invocaciones de "Dispose" ya que el tipo Base "{1}" también ofrece un finalizador.</target>
<note />
</trans-unit>
<trans-unit id="PropagateCancellationTokensWhenPossibleTitle">
<source>Propagate CancellationTokens When Possible</source>
<target state="translated">Propagar elementos CancellationToken cuando sea posible</target>
<note />
</trans-unit>
<trans-unit id="PropagateCancellationTokensWhenPossibleDescription">
<source>#N/A</source>
<target state="translated">#N/D</target>
<note />
</trans-unit>
<trans-unit id="PropagateCancellationTokensWhenPossibleMessage">
<source>Propagate CancellationTokens When Possible</source>
<target state="translated">Propagar elementos CancellationToken cuando sea posible</target>
<note />
</trans-unit>
<trans-unit id="DoNotMixBlockingAndAsyncTitle">
<source>Don't Mix Blocking and Async</source>
<target state="translated">No mezclar código de bloqueo y asincrónico</target>
<note />
</trans-unit>
<trans-unit id="DoNotMixBlockingAndAsyncDescription">
<source>#N/A</source>
<target state="translated">#N/D</target>
<note />
</trans-unit>
<trans-unit id="DoNotMixBlockingAndAsyncMessage">
<source>Don't Mix Blocking and Async</source>
<target state="translated">No mezclar código de bloqueo y asincrónico</target>
<note />
</trans-unit>
<trans-unit id="TypesThatOwnDisposableFieldsShouldBeDisposableTitle">
<source>Types that own disposable fields should be disposable</source>
<target state="translated">Los tipos que poseen campos descartables deben ser descartables</target>
<note />
</trans-unit>
<trans-unit id="TypesThatOwnDisposableFieldsShouldBeDisposableDescription">
<source>A class declares and implements an instance field that is a System.IDisposable type, and the class does not implement IDisposable. A class that declares an IDisposable field indirectly owns an unmanaged resource and should implement the IDisposable interface.</source>
<target state="translated">Una clase declara e implementa un campo de instancia que es un tipo System.IDisposable y la clase no implementa IDisposable. Una clase que declara un campo IDisposable indirectamente tiene un recurso no administrado y debe implementar la interfaz IDisposable.</target>
<note />
</trans-unit>
<trans-unit id="TypesThatOwnDisposableFieldsShouldBeDisposableMessageNonBreaking">
<source>Type '{0}' owns disposable field(s) '{1}' but is not disposable</source>
<target state="translated">El tipo "{0}" tiene campos descartables "{1}" pero no es descartable</target>
<note />
</trans-unit>
<trans-unit id="UseGenericEventHandlerInstancesTitle">
<source>Use generic event handler instances</source>
<target state="translated">Usar instancias genéricas del controlador de eventos</target>
<note />
</trans-unit>
<trans-unit id="EnumsShouldHaveZeroValueTitle">
<source>Enums should have zero value</source>
<target state="translated">Las enumeraciones deben tener un valor igual a cero</target>
<note />
</trans-unit>
<trans-unit id="EnumsShouldHaveZeroValueDescription">
<source>The default value of an uninitialized enumeration, just as other value types, is zero. A nonflags-attributed enumeration should define a member by using the value of zero so that the default value is a valid value of the enumeration. If an enumeration that has the FlagsAttribute attribute applied defines a zero-valued member, its name should be ""None"" to indicate that no values have been set in the enumeration.</source>
<target state="translated">El valor predeterminado de una enumeración no inicializada, al igual que otros tipos de valor, es cero. Una enumeración con atributo y sin marcas debe definir un miembro con el valor de cero, de modo que el valor predeterminado es un valor válido de la enumeración. Si una enumeración a la que se le haya aplicado el atributo FlagsAttribute define un miembro con valor cero, su nombre debe ser "None" para indicar que no se han establecido valores en la enumeración.</target>
<note />
</trans-unit>
<trans-unit id="EnumsShouldHaveZeroValueMessageFlagsRename">
<source>In enum {0}, change the name of {1} to 'None'.</source>
<target state="translated">En la enumeración {0}, cambie el nombre de {1} a “None”.</target>
<note />
</trans-unit>
<trans-unit id="EnumsShouldHaveZeroValueMessageFlagsMultipleZeros">
<source>Remove all members that have the value zero from {0} except for one member that is named 'None'.</source>
<target state="translated">Quite todos los miembros que tienen valor cero de {0} excepto uno denominado “None”.</target>
<note />
</trans-unit>
<trans-unit id="EnumsShouldHaveZeroValueMessageNotFlagsNoZeroValue">
<source>Add a member to {0} that has a value of zero with a suggested name of 'None'.</source>
<target state="translated">Agregue un miembro a {0} que tenga valor cero con el nombre sugerido “None”.</target>
<note />
</trans-unit>
<trans-unit id="AbstractTypesShouldNotHaveConstructorsTitle">
<source>Abstract types should not have constructors</source>
<target state="translated">Los tipos abstractos no deben tener constructores</target>
<note />
</trans-unit>
<trans-unit id="AbstractTypesShouldNotHaveConstructorsDescription">
<source>Constructors on abstract types can be called only by derived types. Because public constructors create instances of a type, and you cannot create instances of an abstract type, an abstract type that has a public constructor is incorrectly designed.</source>
<target state="translated">Solo los tipos derivados pueden llamar a los constructores de tipos abstractos. Puesto que los constructores públicos crean instancias de un tipo y no se pueden crear instancias de un tipo abstracto, no es correcto diseñar un tipo abstracto con un constructor público.</target>
<note />
</trans-unit>
<trans-unit id="AbstractTypesShouldNotHaveConstructorsMessage">
<source>Abstract type {0} should not have constructors</source>
<target state="translated">El tipo abstracto {0} no debe tener constructores</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithClsCompliantTitle">
<source>Mark assemblies with CLSCompliant</source>
<target state="translated">Marcar los ensamblados con CLSCompliant</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithClsCompliantDescription">
<source>The Common Language Specification (CLS) defines naming restrictions, data types, and rules to which assemblies must conform if they will be used across programming languages. Good design dictates that all assemblies explicitly indicate CLS compliance by using CLSCompliantAttribute . If this attribute is not present on an assembly, the assembly is not compliant.</source>
<target state="translated">Common Language Specification (CLS) define las restricciones de nomenclatura, los tipos de datos y las reglas a las que los ensamblados deben ajustarse si se van a usar en los lenguajes de programación. Los procedimientos de diseño recomendados dictan que se use CLSCompliantAttribute para indicar explícitamente el cumplimiento de CLS. Si el atributo no está presente en un ensamblado, este no se considera conforme.</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithClsCompliantMessage">
<source>Mark assemblies with CLSCompliant</source>
<target state="translated">Marcar los ensamblados con CLSCompliant</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithAssemblyVersionTitle">
<source>Mark assemblies with assembly version</source>
<target state="translated">Marcar los ensamblados con la versión de ensamblado</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithAssemblyVersionDescription">
<source>The .NET Framework uses the version number to uniquely identify an assembly, and to bind to types in strongly named assemblies. The version number is used together with version and publisher policy. By default, applications run only with the assembly version with which they were built.</source>
<target state="translated">.NET Framework usa el número de versión para identificar de forma única un ensamblado y para enlazarse a los tipos de ensamblados con nombre seguro. El número de versión se usa junto con la versión y la directiva del publicador. De forma predeterminada, las aplicaciones solo se ejecutan con la versión de ensamblado con la que se compilaron.</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithAssemblyVersionMessage">
<source>Mark assemblies with assembly version</source>
<target state="translated">Marcar los ensamblados con la versión de ensamblado</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithComVisibleTitle">
<source>Mark assemblies with ComVisible</source>
<target state="translated">Marcar los ensamblados con ComVisible</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithComVisibleDescription">
<source>ComVisibleAttribute determines how COM clients access managed code. Good design dictates that assemblies explicitly indicate COM visibility. COM visibility can be set for the whole assembly and then overridden for individual types and type members. If this attribute is not present, the contents of the assembly are visible to COM clients.</source>
<target state="translated">El atributo ComVisibleAttribute determina cómo acceden los clientes COM al código administrado. Los procedimientos de diseño recomendados dictan que los ensamblados indiquen explícitamente la visibilidad COM. La visibilidad COM se puede establecer para un ensamblado completo y, después, invalidarse para miembros de tipo y tipos individuales. Si este atributo no está presente, el contenido del ensamblado es visible para los clientes COM.</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithComVisibleMessageNoAttribute">
<source>Because {0} exposes externally visible types, mark it with ComVisible(false) at the assembly level and then mark all types within the assembly that should be exposed to COM clients with ComVisible(true).</source>
<target state="translated">Puesto que {0} expone tipos visibles externamente, márquelo con ComVisible(false) en el nivel de ensamblado y, después, marque todos los tipos del ensamblado que se deben exponer a clientes COM con ComVisible(true).</target>
<note />
</trans-unit>
<trans-unit id="MarkAssembliesWithComVisibleMessageAttributeTrue">
<source>Consider changing the ComVisible attribute on {0} to false, and opting in at the type level.</source>
<target state="translated">Considere cambiar el atributo ComVisible de {0} a false e incluirlo en el nivel de tipo.</target>
<note />
</trans-unit>
<trans-unit id="MarkAttributesWithAttributeUsageTitle">
<source>Mark attributes with AttributeUsageAttribute</source>
<target state="translated">Marcar atributos con AttributeUsageAttribute</target>
<note />
</trans-unit>
<trans-unit id="MarkAttributesWithAttributeUsageDescription">
<source>When you define a custom attribute, mark it by using AttributeUsageAttribute to indicate where in the source code the custom attribute can be applied. The meaning and intended usage of an attribute will determine its valid locations in code.</source>
<target state="translated">Al definir un atributo personalizado, márquelo con AttributeUsageAttribute para indicar dónde se puede aplicar el atributo personalizado en el código fuente. El significado de un atributo y el uso que se le va a dar determinará sus ubicaciones válidas en el código.</target>
<note />
</trans-unit>
<trans-unit id="MarkAttributesWithAttributeUsageMessageDefault">
<source>Specify AttributeUsage on {0}.</source>
<target state="translated">Especifique AttributeUsage en {0}.</target>
<note />
</trans-unit>
<trans-unit id="MarkAttributesWithAttributeUsageMessageInherited">
<source>Even though attribute {0} inherits AttributeUsage from its base type, you should consider explicitly specifying AttributeUsage on the type to improve code readability and documentation.</source>
<target state="translated">Aunque el atributo {0} hereda AttributeUsage del tipo base, debe considerar especificar de forma explícita AttributeUsage en el tipo para mejorar la legibilidad del código y la documentación.</target>
<note />
</trans-unit>
<trans-unit id="DefineAccessorsForAttributeArgumentsTitle">
<source>Define accessors for attribute arguments</source>
<target state="translated">Definir descriptores de acceso para los argumentos de atributo</target>
<note />
</trans-unit>
<trans-unit id="DefineAccessorsForAttributeArgumentsDescription">
<source>Attributes can define mandatory arguments that must be specified when you apply the attribute to a target. These are also known as positional arguments because they are supplied to attribute constructors as positional parameters. For every mandatory argument, the attribute should also provide a corresponding read-only property so that the value of the argument can be retrieved at execution time. Attributes can also define optional arguments, which are also known as named arguments. These arguments are supplied to attribute constructors by name and should have a corresponding read/write property.</source>
<target state="translated">Los atributos pueden definir argumentos obligatorios que deben especificarse al aplicar el atributo a un destino. Estos también se conocen como argumentos posicionales porque se proporcionan a los constructores de atributos como parámetros posicionales. Para cada argumento obligatorio, el atributo debe proporcionar también una propiedad de solo lectura correspondiente, de modo que el valor del argumento se pueda recuperar en tiempo de ejecución. Los atributos pueden definir además argumentos opcionales, también conocidos como argumentos con nombre. Estos argumentos se proporcionan a los constructores de atributos por nombre y deben tener una propiedad de lectura/escritura correspondiente.</target>
<note />
</trans-unit>
<trans-unit id="DefineAccessorsForAttributeArgumentsMessageDefault">
<source>Add a public read-only property accessor for positional argument {0} of Attribute {1}.</source>
<target state="translated">Agregue un descriptor de acceso de propiedades público de solo lectura para el argumento posicional {0} del atributo {1}.</target>
<note />
</trans-unit>
<trans-unit id="DefineAccessorsForAttributeArgumentsMessageRemoveSetter">
<source>Remove the property setter from {0} or reduce its accessibility because it corresponds to positional argument {1}.</source>
<target state="translated">Quite el establecedor de propiedad de {0} o reduzca su accesibilidad, dado que corresponde al argumento posicional {1}.</target>
<note />
</trans-unit>
<trans-unit id="DefineAccessorsForAttributeArgumentsMessageIncreaseVisibility">
<source>If {0} is the property accessor for positional argument {1}, make it public.</source>
<target state="translated">Si {0} es el descriptor de acceso de propiedades para el argumento posicional {1}, hágalo público.</target>
<note />
</trans-unit>
<trans-unit id="UsePropertiesWhereAppropriateTitle">
<source>Use properties where appropriate</source>
<target state="translated">Usar propiedades donde corresponda</target>
<note />
</trans-unit>
<trans-unit id="UsePropertiesWhereAppropriateDescription">
<source>A public or protected method has a name that starts with ""Get"", takes no parameters, and returns a value that is not an array. The method might be a good candidate to become a property.</source>
<target state="translated">Un método público o protegido tiene un nombre que comienza por “Get”, no toma ningún parámetro y devuelve un valor que no es una matriz. El método puede ser un buen candidato para convertirse en propiedad.</target>
<note />
</trans-unit>
<trans-unit id="UsePropertiesWhereAppropriateMessage">
<source>Use properties where appropriate</source>
<target state="translated">Usar propiedades donde corresponda</target>
<note />
</trans-unit>
<trans-unit id="MarkEnumsWithFlagsTitle">
<source>Mark enums with FlagsAttribute</source>
<target state="translated">Marcar las enumeraciones con FlagsAttribute</target>
<note />
</trans-unit>
<trans-unit id="MarkEnumsWithFlagsDescription">
<source>An enumeration is a value type that defines a set of related named constants. Apply FlagsAttribute to an enumeration when its named constants can be meaningfully combined.</source>
<target state="translated">Una enumeración es un tipo de valor que define un conjunto de constantes con nombre relacionadas. Aplique FlagsAttribute a una enumeración cuando sus constantes con nombre se pueden combinar con sentido.</target>
<note />
</trans-unit>
<trans-unit id="MarkEnumsWithFlagsMessage">
<source>Mark enums with FlagsAttribute</source>
<target state="translated">Marcar las enumeraciones con FlagsAttribute</target>
<note />
</trans-unit>
<trans-unit id="InterfaceMethodsShouldBeCallableByChildTypesTitle">
<source>Interface methods should be callable by child types</source>
<target state="translated">Los tipos secundarios deben poder llamar a los métodos de interfaz</target>
<note />
</trans-unit>
<trans-unit id="InterfaceMethodsShouldBeCallableByChildTypesDescription">
<source>An unsealed externally visible type provides an explicit method implementation of a public interface and does not provide an alternative externally visible method that has the same name.</source>
<target state="translated">Un tipo no sellado visible externamente proporciona un método explícito de implementación de una interfaz pública, pero no proporciona un método visible externamente alternativo con el mismo nombre.</target>
<note />
</trans-unit>
<trans-unit id="InterfaceMethodsShouldBeCallableByChildTypesMessage">
<source>Make '{0}' sealed (a breaking change if this class has previously shipped), implement the method non-explicitly, or implement a new method that exposes the functionality of '{1}' and is visible to derived classes.</source>
<target state="translated">Selle "{0}" (un cambio sustancial si se ha enviado previamente esta clase), implemente el método de manera no explícita o implemente un método nuevo que exponga la funcionalidad de "{1}" y sea visible para las clases derivadas.</target>
<note />
</trans-unit>
<trans-unit id="OverrideMethodsOnComparableTypesTitle">
<source>Override methods on comparable types</source>
<target state="translated">Invalidar métodos en tipos comparables</target>
<note />
</trans-unit>
<trans-unit id="OverrideMethodsOnComparableTypesDescription">
<source>A public or protected type implements the System.IComparable interface. It does not override Object.Equals nor does it overload the language-specific operator for equality, inequality, less than, less than or equal, greater than or greater than or equal.</source>
<target state="translated">Un tipo público o protegido implementa la interfaz System.IComparable. No invalida Object.Equals ni sobrecarga el operador específico del lenguaje por un operador de igualdad, desigualdad, menor que, menor o igual que, mayor que o bien mayor o igual que.</target>
<note />
</trans-unit>
<trans-unit id="OverrideMethodsOnComparableTypesMessageEquals">
<source>{0} should override Equals since it implements IComparable.</source>
<target state="translated">{0} debe invalidar Equals, ya que este implementa IComparable.</target>
<note />
</trans-unit>
<trans-unit id="OverrideMethodsOnComparableTypesMessageOperator">
<source>{0} should define operator(s) '{1}' since it implements IComparable.</source>
<target state="translated">{0} debe definir los operadores “{1}”, porque implementan IComparable.</target>
<note>1 is a comma-separated list</note>
</trans-unit>
<trans-unit id="MovePInvokesToNativeMethodsClassTitle">
<source>Move pinvokes to native methods class</source>
<target state="translated">Mover elementos PInvoke a clases de métodos nativos</target>
<note />
</trans-unit>
<trans-unit id="MovePInvokesToNativeMethodsClassDescription">
<source>Platform Invocation methods, such as those that are marked by using the System.Runtime.InteropServices.DllImportAttribute attribute, or methods that are defined by using the Declare keyword in Visual Basic, access unmanaged code. These methods should be of the NativeMethods, SafeNativeMethods, or UnsafeNativeMethods class.</source>
<target state="translated">Los métodos de invocación de plataforma, como aquellos marcados con el atributo System.Runtime.InteropServices.DllImportAttribute o los métodos definidos con la palabra clave Declare en Visual Basic, tienen acceso al código no administrado. Estos métodos deben ser de la clase NativeMethods, UnsafeNativeMethods o SafeNativeMethods.</target>
<note />
</trans-unit>
<trans-unit id="MovePInvokesToNativeMethodsClassMessage">
<source>Move pinvokes to native methods class</source>
<target state="translated">Mover elementos PInvoke a clases de métodos nativos</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldDifferByMoreThanCaseTitle">
<source>Identifiers should differ by more than case</source>
<target state="translated">Los identificadores se deberían diferenciar en algo más que en el uso de mayúsculas y minúsculas</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldDifferByMoreThanCaseDescription">
<source>Identifiers for namespaces, types, members, and parameters cannot differ only by case because languages that target the common language runtime are not required to be case-sensitive.</source>
<target state="translated">Los identificadores de los espacios de nombres, tipos, miembros y parámetros no puede distinguirse solo por el uso de mayúsculas o minúsculas, ya que los lenguajes destinados al Common Language Runtime no necesitan distinguir entre mayúsculas y minúsculas.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldDifferByMoreThanCaseMessage">
<source>Names of '{0}' and '{1}' should differ by more than case.</source>
<target state="translated">Los nombres de “{0}” y “{1}” se deberían diferenciar en algo más que en el uso de mayúsculas y minúsculas.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldHaveCorrectPrefixTitle">
<source>Identifiers should have correct prefix</source>
<target state="translated">Los identificadores deben tener el prefijo correcto</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldHaveCorrectPrefixDescription">
<source>The name of an externally visible interface does not start with an uppercase ""I"". The name of a generic type parameter on an externally visible type or method does not start with an uppercase ""T"".</source>
<target state="translated">El nombre de una interfaz visible externamente no empieza por "I" mayúscula. El nombre de un parámetro de tipo genérico en un tipo o método visible externamente no empieza por "T" mayúscula.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldHaveCorrectPrefixMessageInterface">
<source>Prefix interface name {0} with 'I'.</source>
<target state="translated">Agregue el prefijo “I” al nombre de la interfaz {0}.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldHaveCorrectPrefixMessageTypeParameter">
<source>Prefix generic type parameter name {0} with 'T'.</source>
<target state="translated">Agregue el prefijo “T” al nombre del parámetro de tipo genérico {0}.</target>
<note />
</trans-unit>
<trans-unit id="NonConstantFieldsShouldNotBeVisibleTitle">
<source>Non-constant fields should not be visible</source>
<target state="translated">Los campos no constantes no deben ser visibles</target>
<note />
</trans-unit>
<trans-unit id="NonConstantFieldsShouldNotBeVisibleDescription">
<source>Static fields that are neither constants nor read-only are not thread-safe. Access to such a field must be carefully controlled and requires advanced programming techniques to synchronize access to the class object.</source>
<target state="translated">Los campos estáticos que no son constantes ni de solo lectura no son seguros para los subprocesos. El acceso a campos de este tipo se debe controlar atentamente y requiere técnicas de programación avanzadas para sincronizar el acceso al objeto de clase.</target>
<note />
</trans-unit>
<trans-unit id="NonConstantFieldsShouldNotBeVisibleMessage">
<source>Non-constant fields should not be visible</source>
<target state="translated">Los campos no constantes no deben ser visibles</target>
<note />
</trans-unit>
<trans-unit id="DoNotMarkEnumsWithFlagsTitle">
<source>Do not mark enums with FlagsAttribute</source>
<target state="translated">No marcar las enumeraciones con FlagsAttribute</target>
<note />
</trans-unit>
<trans-unit id="DoNotMarkEnumsWithFlagsDescription">
<source>An externally visible enumeration is marked by using FlagsAttribute, and it has one or more values that are not powers of two or a combination of the other defined values on the enumeration.</source>
<target state="translated">Una enumeración visible externamente está marcada con FlagsAttribute y tiene uno o varios valores que no son potencias de dos o una combinación de los otros valores definidos en la enumeración.</target>
<note />
</trans-unit>
<trans-unit id="DoNotMarkEnumsWithFlagsMessage">
<source>Do not mark enums with FlagsAttribute</source>
<target state="translated">No marcar las enumeraciones con FlagsAttribute</target>
<note />
</trans-unit>
<trans-unit id="OperatorOverloadsHaveNamedAlternatesTitle">
<source>Operator overloads have named alternates</source>
<target state="translated">Las sobrecargas del operador tienen alternativas con nombre</target>
<note />
</trans-unit>
<trans-unit id="OperatorOverloadsHaveNamedAlternatesDescription">
<source>An operator overload was detected, and the expected named alternative method was not found. The named alternative member provides access to the same functionality as the operator and is provided for developers who program in languages that do not support overloaded operators.</source>
<target state="translated">Se detectó una sobrecarga del operador y no se encontró el método alternativo con nombre esperado. El miembro alternativo con nombre proporciona acceso a la misma funcionalidad que el operador. Esto se ofrece para los desarrolladores que programan en lenguajes que no admiten operadores sobrecargados.</target>
<note />
</trans-unit>
<trans-unit id="OperatorOverloadsHaveNamedAlternatesMessageDefault">
<source>Provide a method named '{0}' as a friendly alternate for operator {1}.</source>
<target state="translated">Proporcione un método con el nombre “{0}” como texto alternativo descriptivo para el operador {1}.</target>
<note />
</trans-unit>
<trans-unit id="OperatorOverloadsHaveNamedAlternatesMessageProperty">
<source>Provide a property named '{0}' as a friendly alternate for operator {1}.</source>
<target state="translated">Proporcione una propiedad con el nombre “{0}” como texto alternativo descriptivo para el operador {1}.</target>
<note />
</trans-unit>
<trans-unit id="OperatorOverloadsHaveNamedAlternatesMessageMultiple">
<source>Provide a method named '{0}' or '{1}' as an alternate for operator {2}.</source>
<target state="translated">Proporcione un método con el nombre “{0}” o “{1}” como texto alternativo para el operador {2}.</target>
<note />
</trans-unit>
<trans-unit id="OperatorOverloadsHaveNamedAlternatesMessageVisibility">
<source>Mark {0} as public because it is a friendly alternate for operator {1}.</source>
<target state="translated">Marque {0} como public porque es texto alternativo descriptivo para el operador {1}.</target>
<note />
</trans-unit>
<trans-unit id="OperatorsShouldHaveSymmetricalOverloadsTitle">
<source>Operators should have symmetrical overloads</source>
<target state="translated">Los operadores deben tener sobrecargas simétricas</target>
<note />
</trans-unit>
<trans-unit id="OperatorsShouldHaveSymmetricalOverloadsDescription">
<source>A type implements the equality or inequality operator and does not implement the opposite operator.</source>
<target state="translated">Un tipo implementa el operador de igualdad o de desigualdad y no implementa el operador opuesto.</target>
<note />
</trans-unit>
<trans-unit id="OperatorsShouldHaveSymmetricalOverloadsMessage">
<source>Operators should have symmetrical overloads</source>
<target state="translated">Los operadores deben tener sobrecargas simétricas</target>
<note />
</trans-unit>
<trans-unit id="CollectionPropertiesShouldBeReadOnlyTitle">
<source>Collection properties should be read only</source>
<target state="translated">Las propiedades de colección deben ser de solo lectura</target>
<note />
</trans-unit>
<trans-unit id="CollectionPropertiesShouldBeReadOnlyDescription">
<source>A writable collection property allows a user to replace the collection with a different collection. A read-only property stops the collection from being replaced but still allows the individual members to be set.</source>
<target state="translated">Una propiedad de colección de escritura permite al usuario reemplazar la colección por otra distinta. Una propiedad de solo lectura impide que la colección se reemplace, pero sí permite establecer miembros individuales.</target>
<note />
</trans-unit>
<trans-unit id="CollectionPropertiesShouldBeReadOnlyMessage">
<source>Change '{0}' to be read-only by removing the property setter.</source>
<target state="translated">Cambie "{0}" para que sea de solo lectura quitando el establecedor de propiedad.</target>
<note />
</trans-unit>
<trans-unit id="OverloadOperatorEqualsOnOverridingValueTypeEqualsTitle">
<source>Overload operator equals on overriding value type Equals</source>
<target state="translated">Sobrecargar el operador de igualdad al reemplazar el tipo de valor Equals</target>
<note />
</trans-unit>
<trans-unit id="OverloadOperatorEqualsOnOverridingValueTypeEqualsDescription">
<source>In most programming languages there is no default implementation of the equality operator (==) for value types. If your programming language supports operator overloads, you should consider implementing the equality operator. Its behavior should be identical to that of Equals</source>
<target state="translated">En la mayoría de los lenguajes de programación no hay una implementación predeterminada del operador de igualdad (==) para los tipos de valor. Si su lenguaje de programación admite las sobrecargas de operador, considere implementar el operador de igualdad. Su comportamiento debe ser idéntico al de Equals.</target>
<note />
</trans-unit>
<trans-unit id="OverloadOperatorEqualsOnOverridingValueTypeEqualsMessage">
<source>Overload operator equals on overriding value type Equals</source>
<target state="translated">Sobrecargar el operador de igualdad al reemplazar el tipo de valor Equals</target>
<note />
</trans-unit>
<trans-unit id="PassSystemUriObjectsInsteadOfStringsTitle">
<source>Pass system uri objects instead of strings</source>
<target state="translated">Pasar objetos URI de sistema en lugar de cadenas</target>
<note />
</trans-unit>
<trans-unit id="PassSystemUriObjectsInsteadOfStringsDescription">
<source>A call is made to a method that has a string parameter whose name contains "uri", "URI", "urn", "URN", "url", or "URL". The declaring type of the method contains a corresponding method overload that has a System.Uri parameter.</source>
<target state="translated">Se realiza una llamada a un método que tiene un parámetro de cadena cuyo nombre contiene "uri", "URI", "urn", "URN", "url" o "URL". El tipo declarativo del método contiene una sobrecarga del método correspondiente que tiene un parámetro System.Uri.</target>
<note />
</trans-unit>
<trans-unit id="PassSystemUriObjectsInsteadOfStringsMessage">
<source>Modify '{0}' to call '{1}' instead of '{2}'.</source>
<target state="translated">Modifique “{0}” para llamar a “{1}” en lugar de a “{2}”.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIEquatableWhenOverridingObjectEqualsTitle">
<source>Type {0} should implement IEquatable<T> because it overrides Equals</source>
<target state="translated">El tipo {0} debe implementar IEquatable<T> porque reemplaza a Equals</target>
<note />
</trans-unit>
<trans-unit id="ImplementIEquatableWhenOverridingObjectEqualsMessage">
<source>Implement IEquatable when overriding Object.Equals</source>
<target state="translated">Implementar IEquatable al invalidar Object.Equals</target>
<note />
</trans-unit>
<trans-unit id="CancellationTokenParametersMustComeLastTitle">
<source>CancellationToken parameters must come last</source>
<target state="translated">Los parámetros CancellationToken deben aparecer en último lugar</target>
<note />
</trans-unit>
<trans-unit id="CancellationTokenParametersMustComeLastMessage">
<source>Method '{0}' should take CancellationToken as the last parameter</source>
<target state="translated">El método “{0}” debe tomar CancellationToken como último parámetro.</target>
<note />
</trans-unit>
<trans-unit id="ConstructorMakeNoninheritableBaseClassInheritableTitle">
<source>Constructor make noninheritable base class inheritable</source>
<target state="translated">El constructor convierte en heredable su clase base no heredable</target>
<note />
</trans-unit>
<trans-unit id="ConstructorMakeNoninheritableBaseClassInheritableDescription">
<source>When a base class is noninheritable because its constructor is internal, a derived class should not make it inheritable by having a public or protected constructor.</source>
<target state="translated">Cuando una clase base no es heredable porque su constructor es interno, una clase derivada no debe hacerlo heredable al tener un constructor público o protegido.</target>
<note />
</trans-unit>
<trans-unit id="ConstructorMakeNoninheritableBaseClassInheritableMessage">
<source>Constructor make noninheritable base class inheritable</source>
<target state="translated">El constructor convierte en heredable su clase base no heredable</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainTypeNamesTitle">
<source>Identifier contains type name</source>
<target state="translated">El identificador contiene el nombre de tipo</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainTypeNamesDescription">
<source>Names of parameters and members are better used to communicate their meaning than to describe their type, which is expected to be provided by development tools. For names of members, if a data type name must be used, use a language-independent name instead of a language-specific one.</source>
<target state="translated">Es mejor usar los nombres de parámetros y miembros para comunicar su significado que para describir el tipo al que pertenecen, ya que esta información suelen proporcionarla las herramientas de desarrollo. En los nombres de miembros, si es necesario usar un nombre de tipo de datos, utilice un nombre independiente del lenguaje en lugar de uno específico de este.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainTypeNamesMessage">
<source>Identifier '{0}' contains type name</source>
<target state="translated">El identificador “{0}” contiene el nombre de tipo.</target>
<note />
</trans-unit>
<trans-unit id="CreatePropertyAccessorForParameter">
<source>Create a property accessor.</source>
<target state="translated">Cree un descriptor de acceso de propiedades.</target>
<note />
</trans-unit>
<trans-unit id="MakeGetterPublic">
<source>Make the getter of the property public</source>
<target state="translated">Convertir el captador de la propiedad en público</target>
<note />
</trans-unit>
<trans-unit id="MakeSetterNonPublic">
<source>Make the setter of the property non-public</source>
<target state="translated">Convertir el establecedor de la propiedad en no público</target>
<note />
</trans-unit>
<trans-unit id="AddAssemblyLevelComVisibleFalse">
<source>Because {0} exposes externally visible types, mark it with ComVisible(false) at the assembly level and then mark all types within the assembly that should be exposed to COM clients with ComVisible(true).</source>
<target state="translated">Puesto que {0} expone tipos visibles externamente, márquelo con ComVisible(false) en el nivel de ensamblado y, después, marque todos los tipos del ensamblado que se deben exponer a clientes COM con ComVisible(true).</target>
<note />
</trans-unit>
<trans-unit id="ChangeAssemblyLevelComVisibleToFalse">
<source>Consider changing the ComVisible attribute on {0} to false, and opting in at the type level.</source>
<target state="translated">Considere cambiar el atributo ComVisible de {0} a false e incluirlo en el nivel de tipo.</target>
<note />
</trans-unit>
<trans-unit id="ImplementComparable">
<source>Implement Equality and Comparison methods and operators</source>
<target state="translated">Implementar operadores y métodos de igualdad y comparación</target>
<note />
</trans-unit>
<trans-unit id="ImplementEquatable">
<source>Implement IEquatable</source>
<target state="translated">Implementar IEquatable</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableInterface">
<source>Implement IDisposable Interface</source>
<target state="translated">Implementar la interfaz IDisposable</target>
<note />
</trans-unit>
<trans-unit id="DoNotMarkEnumsWithFlagsCodeFix">
<source>Remove FlagsAttribute from enum.</source>
<target state="translated">Quite FlagsAttribute de la enumeración.</target>
<note />
</trans-unit>
<trans-unit id="MarkEnumsWithFlagsCodeFix">
<source>Apply FlagsAttribute to enum.</source>
<target state="translated">Aplique FlagsAttribute a la enumeración.</target>
<note />
</trans-unit>
<trans-unit id="EnumsShouldZeroValueFlagsMultipleZeroCodeFix">
<source>Remove all members that have the value zero except for one member that is named 'None'.</source>
<target state="translated">Quite todos los miembros que tienen valor cero, excepto uno denominado “None”.</target>
<note />
</trans-unit>
<trans-unit id="EnumsShouldZeroValueFlagsRenameCodeFix">
<source>Rename zero-valued enum field to 'None'.</source>
<target state="translated">Cambie el nombre del campo de enumeración de valor cero a “None”.</target>
<note />
</trans-unit>
<trans-unit id="EnumsShouldZeroValueNotFlagsNoZeroValueCodeFix">
<source>Add a zero-valued member 'None' to enum.</source>
<target state="translated">Agregue un miembro “None” de valor cero a la enumeración.</target>
<note />
</trans-unit>
<trans-unit id="AbstractTypesShouldNotHavePublicConstructorsCodeFix">
<source>Change the accessibility of public constructors to protected.</source>
<target state="translated">Cambie la accesibilidad de los constructores públicos a protegida.</target>
<note />
</trans-unit>
<trans-unit id="DoNotDeclareStaticMembersOnGenericTypesTitle">
<source>Do not declare static members on generic types</source>
<target state="translated">No declarar miembros estáticos en tipos genéricos</target>
<note />
</trans-unit>
<trans-unit id="DoNotDeclareStaticMembersOnGenericTypesDescription">
<source>When a static member of a generic type is called, the type argument must be specified for the type. When a generic instance member that does not support inference is called, the type argument must be specified for the member. In these two cases, the syntax for specifying the type argument is different and easily confused.</source>
<target state="translated">Cuando se llama a un miembro static de un tipo genérico, se debe especificar el argumento de tipo correspondiente a ese tipo. Cuando se llama a un miembro de instancia genérico que no admite la inferencia, se debe especificar el argumento de tipo para el miembro. La sintaxis para especificar el argumento de tipo en ambos casos es diferente y resulta fácil confundirse.</target>
<note />
</trans-unit>
<trans-unit id="DoNotDeclareStaticMembersOnGenericTypesMessage">
<source>Do not declare static members on generic types</source>
<target state="translated">No declarar miembros estáticos en tipos genéricos</target>
<note />
</trans-unit>
<trans-unit id="CollectionsShouldImplementGenericInterfaceTitle">
<source>Collections should implement generic interface</source>
<target state="translated">Las colecciones deben implementar la interfaz genérica</target>
<note />
</trans-unit>
<trans-unit id="CollectionsShouldImplementGenericInterfaceDescription">
<source>To broaden the usability of a collection, implement one of the generic collection interfaces. Then the collection can be used to populate generic collection types.</source>
<target state="translated">Para ampliar la utilidad de una colección, implemente una de las interfaces de colección genéricas. Después, la colección se puede usar para rellenar los tipos de colecciones genéricas.</target>
<note />
</trans-unit>
<trans-unit id="CollectionsShouldImplementGenericInterfaceMessage">
<source>Collection '{0}' directly or indirectly inherits '{1}' without implementing '{2}'. Publicly-visible collections should implement the generic version to broaden usability.</source>
<target state="translated">La colección "{0}" hereda de manera directa o indirecta "{1}" sin implementar "{2}". Las colecciones visibles públicamente deben implementar la versión genérica para ampliar la facilidad de uso.</target>
<note />
</trans-unit>
<trans-unit id="EnumStorageShouldBeInt32Title">
<source>Enum Storage should be Int32</source>
<target state="translated">El almacenamiento de la enumeración debe ser de tipo Int32</target>
<note />
</trans-unit>
<trans-unit id="EnumStorageShouldBeInt32Description">
<source>An enumeration is a value type that defines a set of related named constants. By default, the System.Int32 data type is used to store the constant value. Although you can change this underlying type, it is not required or recommended for most scenarios.</source>
<target state="translated">Una enumeración es un tipo de valor que define un conjunto de constantes con nombre relacionadas. De forma predeterminada, el tipo de datos System.Int32 se usa para almacenar el valor constante. Aunque puede cambiar este tipo subyacente, no es necesario ni se recomienda en la mayoría de los escenarios.</target>
<note />
</trans-unit>
<trans-unit id="EnumStorageShouldBeInt32Message">
<source>If possible, make the underlying type of {0} System.Int32 instead of {1}.</source>
<target state="translated">Si es posible, convierta el tipo subyacente de {0} en System.Int32 en lugar de {1}.</target>
<note />
</trans-unit>
<trans-unit id="UseEventsWhereAppropriateTitle">
<source>Use events where appropriate</source>
<target state="translated">Usar eventos cuando resulte apropiado</target>
<note />
</trans-unit>
<trans-unit id="UseEventsWhereAppropriateDescription">
<source>This rule detects methods that have names that ordinarily would be used for events. If a method is called in response to a clearly defined state change, the method should be invoked by an event handler. Objects that call the method should raise events instead of calling the method directly.</source>
<target state="translated">Esta regla detecta métodos que tienen nombres que normalmente se usarían para eventos. Si se llama a un método en respuesta a un cambio de estado claramente definido, un controlador de eventos debe invocar al método. Los objetos que llaman al método deben generar eventos en lugar de llamar al método directamente.</target>
<note />
</trans-unit>
<trans-unit id="UseEventsWhereAppropriateMessage">
<source>Consider making '{0}' an event.</source>
<target state="translated">Considere convertir “{0}” en un evento.</target>
<note />
</trans-unit>
<trans-unit id="ImplementStandardExceptionConstructorsTitle">
<source>Implement standard exception constructors</source>
<target state="translated">Implementar constructores de excepción estándar</target>
<note />
</trans-unit>
<trans-unit id="ImplementStandardExceptionConstructorsDescription">
<source>Failure to provide the full set of constructors can make it difficult to correctly handle exceptions.</source>
<target state="translated">No proporcionar el conjunto completo de constructores puede dificultar el control correcto de las excepciones.</target>
<note />
</trans-unit>
<trans-unit id="ImplementStandardExceptionConstructorsMessageMissingConstructor">
<source>Add the following constructor to {0}: {1}.</source>
<target state="translated">Agregue el constructor siguiente a {0}: {1}.</target>
<note />
</trans-unit>
<trans-unit id="ImplementStandardExceptionConstructorsMessageAccessibility">
<source>Change the accessibility of {0} to {1}.</source>
<target state="translated">Cambie la accesibilidad de {0} a {1}.</target>
<note />
</trans-unit>
<trans-unit id="NestedTypesShouldNotBeVisibleTitle">
<source>Nested types should not be visible</source>
<target state="translated">Los tipos anidados no deben ser visibles</target>
<note />
</trans-unit>
<trans-unit id="NestedTypesShouldNotBeVisibleDescription">
<source>A nested type is a type that is declared in the scope of another type. Nested types are useful to encapsulate private implementation details of the containing type. Used for this purpose, nested types should not be externally visible.</source>
<target state="translated">Un tipo anidado es un tipo declarado dentro del ámbito de otro tipo. Los tipos anidados son útiles para encapsular los detalles de la implementación privada del tipo contenedor. Si se usan para este fin, los tipos anidados no deben ser visibles externamente.</target>
<note />
</trans-unit>
<trans-unit id="NestedTypesShouldNotBeVisibleMessageDefault">
<source>Do not nest type {0}. Alternatively, change its accessibility so that it is not externally visible.</source>
<target state="translated">No anide el tipo {0}. Como alternativa, cambie su accesibilidad para que no esté visible externamente.</target>
<note />
</trans-unit>
<trans-unit id="NestedTypesShouldNotBeVisibleMessageVisualBasicModule">
<source>Do not nest type {0}. Alternatively, change its accessibility so that it is not externally visible. If this type is defined in a Visual Basic Module, it will be considered a nested type to other .NET languages. In that case, consider moving the type outside of the Module.</source>
<target state="translated">No anide el tipo {0}. Como alternativa, cambie su accesibilidad para que no esté visible externamente. Si este tipo está definido en un módulo de Visual Basic, se considerará un tipo anidado en otros lenguajes .NET. En ese caso, considere sacar el tipo del módulo.</target>
<note />
</trans-unit>
<trans-unit id="AvoidEmptyInterfacesTitle">
<source>Avoid empty interfaces</source>
<target state="translated">Evitar interfaces vacías</target>
<note />
</trans-unit>
<trans-unit id="AvoidEmptyInterfacesDescription">
<source>Interfaces define members that provide a behavior or usage contract. The functionality that is described by the interface can be adopted by any type, regardless of where the type appears in the inheritance hierarchy. A type implements an interface by providing implementations for the members of the interface. An empty interface does not define any members; therefore, it does not define a contract that can be implemented.</source>
<target state="translated">Las interfaces definen miembros que proporcionan un contrato de uso o comportamiento. Cualquier tipo puede adoptar la funcionalidad descrita por la interfaz, sin tener en cuenta dónde aparece el tipo en la jerarquía de herencia. Para implementar una interfaz, un tipo proporciona implementaciones para los miembros de la interfaz. Una interfaz vacía no define ningún miembro, por lo tanto, no define ningún contrato que pueda implementarse.</target>
<note />
</trans-unit>
<trans-unit id="AvoidEmptyInterfacesMessage">
<source>Avoid empty interfaces</source>
<target state="translated">Evitar interfaces vacías</target>
<note />
</trans-unit>
<trans-unit id="ProvideObsoleteAttributeMessageTitle">
<source>Provide ObsoleteAttribute message</source>
<target state="translated">Proporcionar un mensaje ObsoleteAttribute</target>
<note />
</trans-unit>
<trans-unit id="ProvideObsoleteAttributeMessageDescription">
<source>A type or member is marked by using a System.ObsoleteAttribute attribute that does not have its ObsoleteAttribute.Message property specified. When a type or member that is marked by using ObsoleteAttribute is compiled, the Message property of the attribute is displayed. This gives the user information about the obsolete type or member.</source>
<target state="translated">Un tipo o miembro se marca mediante un atributo System.ObsoleteAttribute para el que no se ha especificado la propiedad ObsoleteAttribute.Message. Cuando se compila un tipo o un miembro marcado con ObsoleteAttribute, se muestra la propiedad Message del atributo. Esto proporciona información al usuario sobre el miembro o tipo obsoleto.</target>
<note />
</trans-unit>
<trans-unit id="ProvideObsoleteAttributeMessageMessage">
<source>Provide a message for the ObsoleteAttribute that marks {0} as Obsolete</source>
<target state="translated">Proporcione un mensaje para ObsoleteAttribute que marque {0} como Obsolete.</target>
<note />
</trans-unit>
<trans-unit id="PropertiesShouldNotBeWriteOnlyTitle">
<source>Properties should not be write only</source>
<target state="translated">Las propiedades no deben ser de solo escritura</target>
<note />
</trans-unit>
<trans-unit id="PropertiesShouldNotBeWriteOnlyDescription">
<source>Although it is acceptable and often necessary to have a read-only property, the design guidelines prohibit the use of write-only properties. This is because letting a user set a value, and then preventing the user from viewing that value, does not provide any security. Also, without read access, the state of shared objects cannot be viewed, which limits their usefulness.</source>
<target state="translated">Aunque es aceptable, y a menudo necesario, tener una propiedad de solo lectura, las directrices de diseño prohíben el uso de propiedades de solo escritura. Esto se debe a que permitir que un usuario establezca un valor y, después, impedir que lo vea no ofrece seguridad alguna. Además, sin acceso de lectura, no se puede ver el estado de los objetos compartidos, lo que limita su utilidad.</target>
<note />
</trans-unit>
<trans-unit id="PropertiesShouldNotBeWriteOnlyMessageAddGetter">
<source>Because property {0} is write-only, either add a property getter with an accessibility that is greater than or equal to its setter or convert this property into a method.</source>
<target state="translated">Puesto que la propiedad {0} es de solo escritura, agregue un captador de propiedad con una accesibilidad que sea mayor o igual que su establecedor o convierta la propiedad en un método.</target>
<note />
</trans-unit>
<trans-unit id="PropertiesShouldNotBeWriteOnlyMessageMakeMoreAccessible">
<source>Because the property getter for {0} is less visible than its setter, either increase the accessibility of its getter or decrease the accessibility of its setter.</source>
<target state="translated">Puesto que el captador de propiedad de {0} es menos visible que su establecedor, aumente la accesibilidad de su captador o reduzca la de su establecedor.</target>
<note />
</trans-unit>
<trans-unit id="DeclareTypesInNamespacesTitle">
<source>Declare types in namespaces</source>
<target state="translated">Declarar tipos en espacios de nombres</target>
<note />
</trans-unit>
<trans-unit id="DeclareTypesInNamespacesDescription">
<source>Types are declared in namespaces to prevent name collisions and as a way to organize related types in an object hierarchy.</source>
<target state="translated">Los tipos se declaran en los espacios de nombres para evitar conflictos de nombre y como forma de organizar los tipos relacionados en una jerarquía de objetos.</target>
<note />
</trans-unit>
<trans-unit id="DeclareTypesInNamespacesMessage">
<source>Declare types in namespaces</source>
<target state="translated">Declarar tipos en espacios de nombres</target>
<note />
</trans-unit>
<trans-unit id="DoNotDeclareVisibleInstanceFieldsTitle">
<source>Do not declare visible instance fields</source>
<target state="translated">No declarar campos de instancia visibles</target>
<note />
</trans-unit>
<trans-unit id="DoNotDeclareVisibleInstanceFieldsDescription">
<source>The primary use of a field should be as an implementation detail. Fields should be private or internal and should be exposed by using properties.</source>
<target state="translated">El uso principal de un campo debe ser como un detalle de implementación. Los campos deben ser private o internal y deben exponerse mediante propiedades.</target>
<note />
</trans-unit>
<trans-unit id="DoNotDeclareVisibleInstanceFieldsMessage">
<source>Do not declare visible instance fields</source>
<target state="translated">No declarar campos de instancia visibles</target>
<note />
</trans-unit>
<trans-unit id="UriParametersShouldNotBeStringsTitle">
<source>Uri parameters should not be strings</source>
<target state="translated">Los parámetros de URI no deben ser cadenas</target>
<note />
</trans-unit>
<trans-unit id="UriParametersShouldNotBeStringsDescription">
<source>If a method takes a string representation of a URI, a corresponding overload should be provided that takes an instance of the URI class, which provides these services in a safe and secure manner.</source>
<target state="translated">Si un método toma una representación de cadena de un URI, debe proporcionarse la sobrecarga correspondiente que toma una instancia de la clase URI que proporciona estos servicios de forma segura.</target>
<note />
</trans-unit>
<trans-unit id="UriParametersShouldNotBeStringsMessage">
<source>Change the type of parameter {0} of method {1} from string to System.Uri, or provide an overload to {1} that allows {0} to be passed as a System.Uri object.</source>
<target state="translated">Cambie el tipo de parámetro {0} del método {1} de string a System.Uri o proporcione una sobrecarga de {1} que permita pasar {0} como un objeto System.Uri.</target>
<note />
</trans-unit>
<trans-unit id="UriReturnValuesShouldNotBeStringsTitle">
<source>Uri return values should not be strings</source>
<target state="translated">Los valores devueltos URI no deben ser cadenas</target>
<note />
</trans-unit>
<trans-unit id="UriReturnValuesShouldNotBeStringsDescription">
<source>This rule assumes that the method returns a URI. A string representation of a URI is prone to parsing and encoding errors, and can lead to security vulnerabilities. The System.Uri class provides these services in a safe and secure manner.</source>
<target state="translated">Esta regla supone que el método devuelve un URI. La representación de cadena de un URI tiende a analizar y codificar los errores, lo que puede crear puntos vulnerables en la seguridad. La clase System.Uri proporciona estos servicios de manera segura.</target>
<note />
</trans-unit>
<trans-unit id="UriReturnValuesShouldNotBeStringsMessage">
<source>Change the return type of method {0} from string to System.Uri.</source>
<target state="translated">Cambie el tipo de valor devuelto del método {0} de string a System.Uri.</target>
<note />
</trans-unit>
<trans-unit id="UriPropertiesShouldNotBeStringsTitle">
<source>Uri properties should not be strings</source>
<target state="translated">Las propiedades URI no deben ser cadenas</target>
<note />
</trans-unit>
<trans-unit id="UriPropertiesShouldNotBeStringsDescription">
<source>This rule assumes that the property represents a Uniform Resource Identifier (URI). A string representation of a URI is prone to parsing and encoding errors, and can lead to security vulnerabilities. The System.Uri class provides these services in a safe and secure manner.</source>
<target state="translated">Esta regla supone que la propiedad representa un identificador uniforme de recursos (URI). La representación de cadena de un URI tiende a analizar y codificar los errores, lo que puede crear puntos vulnerables en la seguridad. La clase System.Uri proporciona estos servicios de manera segura.</target>
<note />
</trans-unit>
<trans-unit id="UriPropertiesShouldNotBeStringsMessage">
<source>Change the type of property {0} from string to System.Uri.</source>
<target state="translated">Cambie el tipo de la propiedad {0} de string a System.Uri.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyTitle">
<source>Implement IDisposable Correctly</source>
<target state="translated">Implementar IDisposable correctamente</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyDescription">
<source>All IDisposable types should implement the Dispose pattern correctly.</source>
<target state="translated">Todos los tipos IDisposable deben implementar el patrón Dispose correctamente.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageIDisposableReimplementation">
<source>Remove IDisposable from the list of interfaces implemented by '{0}' as it is already implemented by base type '{1}'.</source>
<target state="translated">Elimine IDisposable de la lista de interfaces implementadas por "{0}" puesto que ya está implementado por el tipo base "{1}".</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageDisposeOverride">
<source>Remove '{0}', override Dispose(bool disposing), and put the dispose logic in the code path where 'disposing' is true.</source>
<target state="translated">Elimine "{0}", reemplace Dispose(bool disposing) y coloque la lógica de eliminación en la ruta de acceso al código de manera que "disposing" se establezca en verdadero.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageDisposeSignature">
<source>Ensure that '{0}' is declared as public and sealed.</source>
<target state="translated">Asegúrese de que "{0}" se declara como público y con sello.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageRenameDispose">
<source>Rename '{0}' to 'Dispose' and ensure that it is declared as public and sealed.</source>
<target state="translated">Cambie el nombre de "{0}" a "Dispose" y asegúrese de que se declara como público y con sello.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageDisposeBoolSignature">
<source>Ensure that '{0}' is declared as protected, virtual, and unsealed.</source>
<target state="translated">Asegúrese de que "{0}" se declara como protegido, virtual y no sellado.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageDisposeImplementation">
<source>Modify '{0}' so that it calls Dispose(true), then calls GC.SuppressFinalize on the current object instance ('this' or 'Me' in Visual Basic), and then returns.</source>
<target state="translated">Modifique "{0}" de manera que llame a Dispose(true), seguidamente llame a GC.SuppressFinalize en la instancia actual del objeto ("this" o "Me" en Visual Basic) y finalmente devuelva un valor.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageFinalizeImplementation">
<source>Modify '{0}' so that it calls Dispose(false) and then returns.</source>
<target state="translated">Modifique "{0}" para que llame a Dispose(false) y luego devuelva un valor.</target>
<note />
</trans-unit>
<trans-unit id="ImplementIDisposableCorrectlyMessageProvideDisposeBool">
<source>Provide an overridable implementation of Dispose(bool) on '{0}' or mark the type as sealed. A call to Dispose(false) should only clean up native resources. A call to Dispose(true) should clean up both managed and native resources.</source>
<target state="translated">Proporcione una implementación reemplazable de Dispose(bool) en "{0}" o marque el tipo como sellado. Una llamada a Dispose(false) solo debería limpiar recursos nativos. Una llamada a Dispose(true) debería limpiar tanto recursos administrados como nativos.</target>
<note />
</trans-unit>
<trans-unit id="ExceptionsShouldBePublicTitle">
<source>Exceptions should be public</source>
<target state="translated">Las excepciones deben ser públicas</target>
<note />
</trans-unit>
<trans-unit id="ExceptionsShouldBePublicDescription">
<source>An internal exception is visible only inside its own internal scope. After the exception falls outside the internal scope, only the base exception can be used to catch the exception. If the internal exception is inherited from T:System.Exception, T:System.SystemException, or T:System.ApplicationException, the external code will not have sufficient information to know what to do with the exception.</source>
<target state="translated">Una excepción interna solo se ve dentro de su propio ámbito interno. Cuando la excepción está fuera del ámbito interno, solo se puede usar la excepción base para capturarla. Si la excepción interna se hereda de T:System.Exception, T:System.SystemException o T:System.ApplicationException, el código externo no tendrá información suficiente para saber qué hacer con ella.</target>
<note />
</trans-unit>
<trans-unit id="ExceptionsShouldBePublicMessage">
<source>Exceptions should be public</source>
<target state="translated">Las excepciones deben ser públicas</target>
<note />
</trans-unit>
<trans-unit id="DoNotRaiseExceptionsInUnexpectedLocationsTitle">
<source>Do not raise exceptions in unexpected locations</source>
<target state="translated">No producir excepciones en ubicaciones inesperadas</target>
<note />
</trans-unit>
<trans-unit id="DoNotRaiseExceptionsInUnexpectedLocationsDescription">
<source>A method that is not expected to throw exceptions throws an exception.</source>
<target state="translated">Un método que no se espera que produzca excepciones inicia una excepción.</target>
<note />
</trans-unit>
<trans-unit id="DoNotRaiseExceptionsInUnexpectedLocationsMessagePropertyGetter">
<source>{0} creates an exception of type {1}, an exception type that should not be raised in a property. If this exception instance might be raised, use a different exception type, convert this property into a method, or change this property's logic so that it no longer raises an exception.</source>
<target state="translated">{0} crea una excepción de tipo {1}, que no debe producirse en una propiedad. Si puede producirse esta instancia de excepción, use un tipo de excepción diferente, convierta esta propiedad en un método o cambie la lógica de la propiedad para que deje de producir una excepción.</target>
<note />
</trans-unit>
<trans-unit id="DoNotRaiseExceptionsInUnexpectedLocationsMessageHasAllowedExceptions">
<source>{0} creates an exception of type {1}, an exception type that should not be raised in this type of method. If this exception instance might be raised, either use a different exception type or change this method's logic so that it no longer raises an exception.</source>
<target state="translated">{0} crea una excepción de tipo {1}, que no debe producirse en este tipo de método. Si puede producirse esta instancia de excepción, use un tipo de excepción diferente o cambie la lógica de este método para que deje de producir una excepción.</target>
<note />
</trans-unit>
<trans-unit id="DoNotRaiseExceptionsInUnexpectedLocationsMessageNoAllowedExceptions">
<source>{0} creates an exception of type {1}. Exceptions should not be raised in this type of method. If this exception instance might be raised, change this method's logic so it no longer raises an exception.</source>
<target state="translated">{0} crea una excepción de tipo {1}. No se deben producir excepciones en este tipo de método. Si puede producirse esta instancia de excepción, cambie la lógica de este método para que deje de producir una excepción.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainUnderscoresTitle">
<source>Identifiers should not contain underscores</source>
<target state="translated">Los identificadores no deben contener caracteres de subrayado</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainUnderscoresDescription">
<source>By convention, identifier names do not contain the underscore (_) character. This rule checks namespaces, types, members, and parameters.</source>
<target state="translated">Por convención, los nombres de identificador no contienen el carácter de subrayado (_). La regla comprueba espacios de nombres, tipos, miembros y parámetros.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainUnderscoresMessageAssembly">
<source>Remove the underscores from assembly name {0}.</source>
<target state="translated">Quite los caracteres de subrayado del nombre de ensamblado {0}.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainUnderscoresMessageNamespace">
<source>Remove the underscores from namespace name '{0}'.</source>
<target state="translated">Quite los caracteres de subrayado del nombre “{0}” de espacio de nombres.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainUnderscoresMessageType">
<source>Remove the underscores from type name {0}.</source>
<target state="translated">Quite los caracteres de subrayado del nombre de tipo {0}.</target>
<note />
</trans-unit>
<trans-unit id="IdentifiersShouldNotContainUnderscoresMessageMember">