From cd8ba3cda33351dc2de9558a40699d1529342770 Mon Sep 17 00:00:00 2001 From: Michal Buzik Date: Sat, 6 Dec 2025 12:49:58 +0100 Subject: [PATCH] Add System.Threading 4.3.0 package with support for multiple frameworks and localized XML documentation. --- .../System.Threading.4.3.0/.signature.p7s | Bin 0 -> 9482 bytes .../System.Threading.4.3.0.nupkg | Bin 0 -> 708088 bytes .../ThirdPartyNotices.txt | 31 + .../dotnet_library_license.txt | 128 ++ .../lib/MonoAndroid10/_._ | 0 .../lib/MonoTouch10/_._ | 0 packages/System.Threading.4.3.0/lib/net45/_._ | 0 .../lib/netcore50/System.Threading.dll | Bin 0 -> 50016 bytes .../lib/netstandard1.3/System.Threading.dll | Bin 0 -> 50016 bytes .../lib/portable-net45+win8+wp8+wpa81/_._ | 0 packages/System.Threading.4.3.0/lib/win8/_._ | 0 packages/System.Threading.4.3.0/lib/wp80/_._ | 0 packages/System.Threading.4.3.0/lib/wpa81/_._ | 0 .../lib/xamarinios10/_._ | 0 .../lib/xamarinmac20/_._ | 0 .../lib/xamarintvos10/_._ | 0 .../lib/xamarinwatchos10/_._ | 0 .../ref/MonoAndroid10/_._ | 0 .../ref/MonoTouch10/_._ | 0 packages/System.Threading.4.3.0/ref/net45/_._ | 0 .../ref/netcore50/System.Threading.dll | Bin 0 -> 32096 bytes .../ref/netcore50/System.Threading.xml | 1797 +++++++++++++++ .../ref/netcore50/de/System.Threading.xml | 1799 +++++++++++++++ .../ref/netcore50/es/System.Threading.xml | 1803 +++++++++++++++ .../ref/netcore50/fr/System.Threading.xml | 1833 ++++++++++++++++ .../ref/netcore50/it/System.Threading.xml | 1800 +++++++++++++++ .../ref/netcore50/ja/System.Threading.xml | 1950 ++++++++++++++++ .../ref/netcore50/ko/System.Threading.xml | 1952 +++++++++++++++++ .../ref/netcore50/ru/System.Threading.xml | 1761 +++++++++++++++ .../netcore50/zh-hans/System.Threading.xml | 1854 ++++++++++++++++ .../netcore50/zh-hant/System.Threading.xml | 1885 ++++++++++++++++ .../ref/netstandard1.0/System.Threading.dll | Bin 0 -> 32720 bytes .../ref/netstandard1.0/System.Threading.xml | 1797 +++++++++++++++ .../netstandard1.0/de/System.Threading.xml | 1799 +++++++++++++++ .../netstandard1.0/es/System.Threading.xml | 1803 +++++++++++++++ .../netstandard1.0/fr/System.Threading.xml | 1833 ++++++++++++++++ .../netstandard1.0/it/System.Threading.xml | 1800 +++++++++++++++ .../netstandard1.0/ja/System.Threading.xml | 1950 ++++++++++++++++ .../netstandard1.0/ko/System.Threading.xml | 1952 +++++++++++++++++ .../netstandard1.0/ru/System.Threading.xml | 1761 +++++++++++++++ .../zh-hans/System.Threading.xml | 1854 ++++++++++++++++ .../zh-hant/System.Threading.xml | 1885 ++++++++++++++++ .../ref/netstandard1.3/System.Threading.dll | Bin 0 -> 32096 bytes .../ref/netstandard1.3/System.Threading.xml | 1797 +++++++++++++++ .../netstandard1.3/de/System.Threading.xml | 1799 +++++++++++++++ .../netstandard1.3/es/System.Threading.xml | 1803 +++++++++++++++ .../netstandard1.3/fr/System.Threading.xml | 1833 ++++++++++++++++ .../netstandard1.3/it/System.Threading.xml | 1800 +++++++++++++++ .../netstandard1.3/ja/System.Threading.xml | 1950 ++++++++++++++++ .../netstandard1.3/ko/System.Threading.xml | 1952 +++++++++++++++++ .../netstandard1.3/ru/System.Threading.xml | 1761 +++++++++++++++ .../zh-hans/System.Threading.xml | 1854 ++++++++++++++++ .../zh-hant/System.Threading.xml | 1885 ++++++++++++++++ .../ref/portable-net45+win8+wp8+wpa81/_._ | 0 packages/System.Threading.4.3.0/ref/win8/_._ | 0 packages/System.Threading.4.3.0/ref/wp80/_._ | 0 packages/System.Threading.4.3.0/ref/wpa81/_._ | 0 .../ref/xamarinios10/_._ | 0 .../ref/xamarinmac20/_._ | 0 .../ref/xamarintvos10/_._ | 0 .../ref/xamarinwatchos10/_._ | 0 .../aot/lib/netcore50/System.Threading.dll | Bin 0 -> 23232 bytes 62 files changed, 55461 insertions(+) create mode 100644 packages/System.Threading.4.3.0/.signature.p7s create mode 100644 packages/System.Threading.4.3.0/System.Threading.4.3.0.nupkg create mode 100644 packages/System.Threading.4.3.0/ThirdPartyNotices.txt create mode 100644 packages/System.Threading.4.3.0/dotnet_library_license.txt create mode 100644 packages/System.Threading.4.3.0/lib/MonoAndroid10/_._ create mode 100644 packages/System.Threading.4.3.0/lib/MonoTouch10/_._ create mode 100644 packages/System.Threading.4.3.0/lib/net45/_._ create mode 100644 packages/System.Threading.4.3.0/lib/netcore50/System.Threading.dll create mode 100644 packages/System.Threading.4.3.0/lib/netstandard1.3/System.Threading.dll create mode 100644 packages/System.Threading.4.3.0/lib/portable-net45+win8+wp8+wpa81/_._ create mode 100644 packages/System.Threading.4.3.0/lib/win8/_._ create mode 100644 packages/System.Threading.4.3.0/lib/wp80/_._ create mode 100644 packages/System.Threading.4.3.0/lib/wpa81/_._ create mode 100644 packages/System.Threading.4.3.0/lib/xamarinios10/_._ create mode 100644 packages/System.Threading.4.3.0/lib/xamarinmac20/_._ create mode 100644 packages/System.Threading.4.3.0/lib/xamarintvos10/_._ create mode 100644 packages/System.Threading.4.3.0/lib/xamarinwatchos10/_._ create mode 100644 packages/System.Threading.4.3.0/ref/MonoAndroid10/_._ create mode 100644 packages/System.Threading.4.3.0/ref/MonoTouch10/_._ create mode 100644 packages/System.Threading.4.3.0/ref/net45/_._ create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/System.Threading.dll create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/de/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/es/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/fr/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/it/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/ja/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/ko/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/ru/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/zh-hans/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netcore50/zh-hant/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/System.Threading.dll create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/de/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/es/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/fr/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/it/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/ja/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/ko/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/ru/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/zh-hans/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.0/zh-hant/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/System.Threading.dll create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/de/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/es/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/fr/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/it/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/ja/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/ko/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/ru/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/zh-hans/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/netstandard1.3/zh-hant/System.Threading.xml create mode 100644 packages/System.Threading.4.3.0/ref/portable-net45+win8+wp8+wpa81/_._ create mode 100644 packages/System.Threading.4.3.0/ref/win8/_._ create mode 100644 packages/System.Threading.4.3.0/ref/wp80/_._ create mode 100644 packages/System.Threading.4.3.0/ref/wpa81/_._ create mode 100644 packages/System.Threading.4.3.0/ref/xamarinios10/_._ create mode 100644 packages/System.Threading.4.3.0/ref/xamarinmac20/_._ create mode 100644 packages/System.Threading.4.3.0/ref/xamarintvos10/_._ create mode 100644 packages/System.Threading.4.3.0/ref/xamarinwatchos10/_._ create mode 100644 packages/System.Threading.4.3.0/runtimes/aot/lib/netcore50/System.Threading.dll diff --git a/packages/System.Threading.4.3.0/.signature.p7s b/packages/System.Threading.4.3.0/.signature.p7s new file mode 100644 index 0000000000000000000000000000000000000000..ea08604a2d2411a358062424daf60a8eccf18db1 GIT binary patch literal 9482 zcmds-cUTkKy2eQ%^cs2%P3cS$x)tft6r{*TAOr|VPw1$afS`y13IYmSKokq26lEh# zq>G9ONUg!ky3*-FKgTp7T6sKll0%u9>ygteIKg?|Z*@0#Kw72nN|GgQz(c z2pu$oA~^?8B&VSe7@7@WK`=N*89-cMa43Y925|n~5t3mIx3qF0lH7f~HPMWW7)7+I zqPjAmh*m@cXhp1|vLbj$!2m~c(^OU?xgAu|3ii+eRNO2AZM2Mo2_dS+Apv^I?mDW$ zcxOC8&sE{2jDHu|4V}uro6hL%wMj7g$%zb?PQQBI72rmnuibkV>)ql3UELgC$ z(fn^Mg8~u%@d1D@21bFf(Et<(Ba{Mx(A;L_em0n({VZ_YgX zjM9*{ab%u9-hG2R34_~yFJC$`Cg$~JM&=0K(75>AnD-$TcIZgiS+*36YT%Q%Z?<30 z8bAC+Y|0$ha~ahk+Lzz8#OM5i^EZbD8$OjX{im6#3m)NZchz@R30B8qyE>KlmZaGV zb0S_=d+R*Jsa)V$I+%7k(5quI%ZNp8nTgo_yW{h-@hWw}meHup=0PvU2E!xh6s)KC z$LQx6+pGsj3dfiRZ+faGF>`1!yQ`fS9guh8sCeEkh+fpJbVx&f_kcBT%`qX?yG7@& zSrwKSB#+(9nJBKkzAK66`Eurk5qbx{ATuZoLIb&i2XFu@_)>-0AdqD^9Nb7z02{T9 zq_$}R82ASerXFC0^T4@uN3!nBoNJ<>751Ob$q`GR_G(}QM5(7G;Cukj@jvgdc^`tW z0Ya0-TGrDyHqlQcg*qoz&JkTZF#~%7obsYarrNvSS`}V?@{CKmgeBS0j?>s?pmj%t zp{`A`io3vd{b8%RkXxLc1af3gIK%eDp+C0Bqsn&_N}rl@SQhU~juidqG9LY|r;1=$ zcxa@6L3U)zSa8MBU2@aKTU5LpPC@P){&pEcd+F8=sj4UU!yirhMAa=iyN!?)5=ZtF zFUE?zahj~yM=16zpPm%;U{orB3ZrMq71ab;H;$g;@0qc# zl}HvY@9A(+JiEx^89^y8&$z3_I7t4BD_b(z{nBsuRWDSh?k|?3qkpD2w67p%kx^GE zYhntZ&;kGj&bJo2a0Wg>hxSs}01NGVK1uuNf84oD|JBe%W6=NxgT_#U7YtpD`VUQj z_@5F44Jd(|1tf^{20<(gv@ob2Frw|_?1HjzCwRMi6R0@(S8+VwS|}9G%5jGfMAyoM zHso)9{zW%6U-OmD=kUSn>8~&ye#3$3w2H-Xi|4c-UR^lVrpDiK|K>zm)YVR@T-Fe2 z&0`;12(5KrWVY6~hDjt2BuHF{527q&MoPGH9>DJN&zIg(D(U{{k@*xCA?B2Bn?mN5 zk0<3(NqIthqv?B?Klhn9@>SfdDai9hyJG!z=K5ycdKUiiNYlB@!EI=v=HV&E0qfGe z_dfa$$t`&{9rM>vWr-gjxM!MuWB4%Rt;p$Ig6X}Qx!4wzl*9%Ra0!7Gqq>g zsQJ+Vww5BE=ns&|)CGycLxEsG zGebQ?HA;DXDx#GgYrLU@Fz z3nPJ#;^*9`q`l9A`aIW0!hT?;ZB0p-EaR1{!+x-bjtdI2E&;4I{}wYr0IV=`=O~M< zWZ|@U3wMM35h%xbG6f^~D#sOT%F($`v)jQZ~?wtNMF582$RJ+?d+j1^|ZGVyX z)w8yJ_L5{%_Uuo){LbQ8kw&*W9CSjaRk;u`b7^{}cFXbkf^@72++QBtxwrq(8Oc1! zy85lMnKIG>ntsyI?TQIk9!hcarE%$JhPt`kxs+pvvg`88XO1hqK3~h}cDZ?X({7!s z$cZ6mW-0nTm;%)pN$8Ri@t9DDq3(qb2ZcW_`a63RjJRrd7v7C+|H$%Y7J_<~ipKAt z7vL)-UoxvZ&yM&?M_xSLy+ARXbMnr#SmaFPJE3?kVc5-62UFmh`JONPqVxW7keT~H zW~#3-la8a%)w<6&z;EAUHK&$soIf-3pMVvpebDNF@`l&}0g48j%4<9Y$g!IViUc^o zjR&VkGFpQY5G0L;}j(#n*@A z?(ahkK{Ox*EAACix&|9W58-{|`<*?K+LtLmj|%~GXSyMR^O#rw|Pscgt;{gC(* zCLBe3Z6NXoV|mTeZJugp*;=?rHw1Hg$Zn4@V&%;1qGr*PH7ax|e`w zN{S#TXS~@RXuy6u)bfdGnm?_^qZ19I`Kgz$E58sR4rON3vvR}|>>NV_Bj&%=dA@KK zDYV{wU|fW6q|UztxYnnV>{Lf1M4}K~X3iHe(MsL72^$c<%~LcUXU6g=`gPJS*X9Br zw`1MYMVCt+p}SqZB_G1ihT}@r3GAJOdtDQas51L)Rmhzl7vjvXi0Fi-FZIsZ7MI#w zk#!zkcZ1-Js9q(DG} zIQ9H>*iQ)kUxpd45>OY=2GmyT8IXW5$iD?ZdIW+%W`@8a06B79D38)=~>I^`=(RArzqb2@oqxovNyKgQ^$?hhYV(1f%pd z`#Qy=wDJtbY@WXzpH4 z>6Eembo+6XNy5QdPxIk@>|ss8+UNGSOUsu_>&CEIIZ38 zcK(sfQ2yv8ZXUIVJ#W1_1r&1BGo51Ob?6lfQ~{IHhFGC`G=)bIpzz3oh3s*zKi##P zi`xteqygaDs4E#@Xr_$@9Rv{CXfV*C*{Co?W6)R(s3tMWwtxtNX{{b*V284=6wcod zAfSLEf*I5!a0o^102Bg&qD259W;SOZe{UCmS0c{KCCG>9!OXCMI#5fl*S8FCv^X4f zvgWKBVSBhk`1=CoQpK9i3Kvaro9=UAG94V{aS5*u11g&?06|OfNUSGxoUgm0cK~4( zu1bMeC3kOUmte)iBp+{p-2UUjmC)o`fcyv`R|4cR0K9!_&R?nh;V4!I_0LDE${G-z zhGu5*U!J{5Ijt8+$I$etZbt0lHSVJTIR*&K_Wvh@G?e|X5++z4!zmD&ORc#3GV>4R zA_r?5#d$`|EeT&2oCr$$4edW!J6L;<4y%$ZfxTv1i@isk;=^6boMx~5u{h{({JfS( zeE>e1t<=ioWSd3X+aZ%+do)Lm3d?=@_brPVzD*;Rhyq-py+V3$sJ`RZh47<; zV~_cX$b9@z#6sw$Wx1H#-nyCxI$a5MT8QW3S*NEgd~e%N^L^|8RLGG@L5cztq~MS5 zn-xt#GJ*#;`#+qZ|HHZB|FCS@17N1W{xBK>2O~xte6%9q2?20dBbZhs;=C?|ju!@? zsZ83~Kj1q+%|CB=^iAS<*A}3@Cv+*VVLq~ywiVkTubg5et@8D{8E-$tjl4&stb^on=( zO-PFS3ulm{vdIwu`S@m8A`A$w>J2W75HFm!zY89v?L+kSA>#Z&BMU9MqHaNph-c&U z0b&5jA7$#|PmNK~>{&1KHabv2t)hxL;O^yO;g9q3rB-)TR=W^U3MhR{28GQ4)OIDH zrIop+?{*8+IExh`#bB(Z1Dpc2!av~~AeV1mG%vutx@cC=aC4{5El)MH6n|Lm`U%wL zW*J|b||gYIs8Lbd@@ig0xPBVO0kVq19c)AgH_Q` z(XjnLe}Dg~aIeRy+2=!)UpaMfUs|@Yjg^pi>3BAwBR(Y}bjXHZJ+^js(D_7Bmfx4L z@{;bSCNxD23Z$#`?tV$48rutW=+Zv0E}HDE5$ln`#bLy8l-g)f@7N;_JgEITExu;f z!~H`2PeMM~bh17w)II-D{{2N>xiA{FP%Uh5FSc)*T_8MKzGC+C+@8L{%4nxk4m3tR zwQmLjbTC?)B7WZPO-uoL^evBH$R#~*{!+5r!#UR4KA1PQHTSY5P5mtW;lvV$*YB{Ck&X+$ZRIHX z$}?4Jb@;f{nN@K~E&#}Pezn{-dvXZCYh4&YnBh3UA@fkiZ@@vo8nEPHaQDIyT$Bjz zu7DUI3eX{Fk>?wPY5)y>Bbw;Axshw&={YZ(u$U_E^ZK8oNzbti$5 zLbZ350!b^!s55<6viE})-3|0FTX42N8m7Yp(zPVh@&6QwD?)1T{QO9gpXc7PZY||3coU&g}VQa!2)Ne1BoTSfixI$8X%OdNYC?&rL{I zj_NJ!7`yJ^)Hb^ zlU4k@li;zDYjk~Y!|lCxtG6W}-fJBR5o&6>Em+x^lrTN<$#eep1r5dUs;z$nYt%+w z9UHq7efHUzdavOZDfcu*MKsc@XD(i!iR`UuIpSA`kSW?V5W%vgI*fj&$pT|B)^Pdp zwzkg&myCK(rV4z1_z}zXvZwy|tAtNWW#_DkK{HRUKUreEz+s*E9J>ZO=Y1 zBskoQ3{i;*&gI9%NmOC91P`*_*qQ%i;icSoapyq0uos8sx!LoLY5fMDN-bF1RFk8E zYcti>OWGh%kB~N(q!7fP+J~;-lLxIa2jCF!+h+A*3`neF3G~Kz*QK$zBg2pWzn_3@wBpY$vKiZBNpBxp9cSJyv+!I115f<*xXD61=A ze?a3M{L9BzOivKs<&lM(Y9;Z@Qj!nUvX|zIwG++&i(2TgyLSHJo+HCY z@Xd#4`p!;2jPHq)`OG(*SbT1<<8B6t{NW?xrM*WW%jt318ab@Px-;U;n!aNix~B(f z1??tu-Si}B@qw3wzW(khn{PE36K?L8H>J|9CxH-ZHc${QdiqCKpu}0B<(-wK2s?MW zYc8zw_IXDY$4v56#v40m_I#60V!eEbxQC&vx?AVP*c1K8fv=Aha&0Q|=JL99Sm=u% z1-%r|_HFToy){2q!%pwl^+4QmO0;b3Qu?+&dtu{<c2j{W z3fBPCe)8)4NeZBWrx>(Cxs|eOg`rf#PDNG0p9G%9tssntI)fDT3+;~|ap*VW9CR3i z))5LK)dO$`WY^muQbpEi30`#NyUtHn1-5PUg>HC|U|*a&?q4m?h4{B|s`3L)8SYgr zT_7gQXkTo62Yrw?|4r$^>?WN4DQ|!Hw!HqGgtw6K@^m-nMBQjg^WE~bTlZ7h{_ zyH#_vsQF5xXHHiQP1-5OpoAHdtS{(oQQosdqWfS`mnxg~+!_kJM6~6A#MF&n^+|gF zChx(JxXT3JK|zkjr^kysll4XS(9h@kiQd(-C~PZezjA9|fB`2j<#zKsEi=rqr%6JU z2{H6LvU3Q~3q6v?SD$M=q&QxQ;l&uWmNjP=#iA)tTkvNgR-oGekWc?(xP-F*0`ect zvJ7%IAn@J5gP~bA*(QHwC4%$;l33!I9OM%_wT8Sp<$S`fLx&sgVo^mQEl>ls zc|*|C{%$owmC&G|1i+uOz){ViRiV%IN87(uyNSaDIornRPW#9i+k0e-#!WRF-6l}Y zo%J8lK&Td(RjKlRPj%YT6BR|;+v_a04TtY9xhQd`sA%-I zYTK!>$SW+0 zkVZp+>2K_1%ExtW Oa2XfJV%Hj3-Q8U-?(XjH?(XicgX;hT4DRkQz~JuAFfjXn_g&v?wn=-E zrl%jy$w~YCnySb{!{9(bKp;S{&{%>I{|p>pK|(-${nwHIn>BW`bZ}>3{vTsz>a^W3 zD~8l-^!j42+Ge}wYM6~#Z<34f^Z!Y zRC)1I1Uh==Pz+UrkLT!0%8oSAJw&*PZ8l%A*7Lj>z=$9A*}*{ecp#^R$&`#igw7Hh zp@O&K&t=5JQQE&k!vu?T%u?a@kOoh6Xx$FJH1?(1WsW6ClXkdHNwlh+=F|F%$h*v= z*@sa=y{;dSD*w08nYb2r*+N4=>>)uw;QtpobzgT6OGjo68#hZ+3tJ~^W+zW~7fbV1 zty#BU+!+1#(zhY|WHj(A$y`}jawLiQow+T<$`vEsmON*^Cu_oTj>WUI1(m497sf z;u7&wA04D>W>r{huu4Yh+J}STEkv*pXse2=1D%(-*~Ufmd|7ztKV=Qrl@@3dnYt~sJdad5BZIf@kpyzFVEr1=}y ziq*BM$iyc1IPDB)2Dadvs1fAa-NH057cwD74KYCmH=K^}mR+={r}Nh>T~{O$vYm8h z=t>Cw4C4A7T=XEOjz)z5*FH)T0N9GE^&pDe^3f;I;FB~CCiu1Q-?do29S()}HTO@J zBKG?(w_A|(BL}Wi{&KNk$k#k@AkkCDQ!3iKXnDez7PW7%27JFmpT5;W%FS>a(mz=r z`cEtuZ#2a_zgalOfY-9ikHdb$m+Me&Vs{zv_^P~nq*XFQ()PL>|V4z^})rf$CfS#wJ#cS~juACE-6>9k*CxH~_l{w*N0T+zp6 zrSqcuN0PBoj1Z;4ffKDZVe%~WL89K!5^M~Pg^pT{a^G6rscWaW&B|R!UXPWlq>&UXZ`r9OTOKhJX+T)nNzXE>mg!&V=30lXzG0>rCuZsunOe#0 zc5iDsqNbOL^tbgl?UgVN?p%P1kf2(b4x-_~#;TmPUe;7l)SNgLv=i5?Jh37O5NyR!mKH z0oyM!9z8&+!OklFg}v9olk)QKUsBb7+Sh7Wecmq{S{pN3JwCX{T@>2K9M(j2Gte^* z{uO_*t8uCv))p>tXY`!f9anB+>E|;#%0e2ev_Rmv>m(Q!9$1uG`Hqf2%!cNM)8hBc z3d>@p{vP~zUCw^YM|{)p{GzU6MoCsc#4=xB4Q51JvHosjGP9FU}JOhKCrJHJa=;`$3Wb;@tx+9<{q z!d2WYBmND+04X*-l6(cK=(Zewib{cXILxf$I#QcOVp}ZOP6!><*fOgGV{AY3AUB9E zk4ypS!z}^h)0fM4Dp^d-{^Trjc=c^v+R@Eabck=7MfB(;)F~fk1{rAK%s75SrB{>j zx$wOvbSxHBo=K$N=NhGM$etOrxB+MsZpa0v1`43~VP||*qTMKSUhJzRn%6NG)tWtGY71a-2T3|^FP1$x1C=glHz<}!QhC}$QFsLm$bN|t-B^&^ZA&>d>HupHC1Ir^^%BfU>8Ck&j392i7qfq44}skftTE1e{&l02MU8g2o&=c3wTx$)0PhjLC*JZt=&uL~Xr z*Q$U1MVjiDy;bj~2|McOQBPyQAAH~0>f04d@A!!dE73MtN{n^T>DhcMLb> zB{7;3Qwf}`xT&2P?PMo&V@3loc$5qUTm);!|J?z3c{}XDx*7;#WOa-7$P#`N70Mor zMLDhI5tuM(lc3pmQz+7+QDt5Vvx%}>&-<;M#)RKPzj=hgeK}!riQyd2C7$v_L_+W6 zus4_Jk!C6b>mRw5$OP91R06qTXxK%zad0k}Bm^(+wPP-mov3a>-g;_SS+B0s;@=IM zkWP|#-g#c;J)=A#Elc22;h&rBwHah({u_e{!;YEuor0~@3*lr>Vt5v$13UCvTkM#v1EcFWh6{Io^H*vE)gRP%Vl5aD|jwDjzY}>zmK_+y|b3Qn!Vj zMsaoLKHH#ax2UG7be|-GBDqIMM1dbijcD^MZi+2J47J+Sv})SO8a=I(HJ-=(t^5bf z2ZYq}biN?RM?9A5x@}<(6GCKscj&AQ`tJ=&RaNSCDwvr|g*W7q3i|7=-KRm1$F>)( z7$fKH;zAJev7bS|f3LOwiZ&}2h=mm7zPL5u)=}8}*2WqX8vqe+R4d6J?fEB=ov8;X zD)x)Slht2S9q0H7UJ>}_;4*;rQhWM37k1E)bTsQGKJio+wq7kMR0m99Wihb*P#?hZ@C;Ye4e3aPE4bH z>lQ4F(U(u}QAI-~e87FnkEfBQ<e2>XLA2 zg5}8Rks>QRqbJ~KsPHl=>@ zZ}xaN^A7u0a?qWooP-HsXWR+3Mt#T!yny*s{2z}(n6nphUa~m2GeuHu!m2ol4~;{h zlVexTk0>nB9(M5vpw<)PRp;coBW;4g+)rK{BKgV_+q zIDZlKB8>59G%M>=->nuHDGk4I=gpUXrPI9d=S4Nam5*Y0FTb4O{f#ti=(GSKD6P+g z*V*9A-ufT#=Os_lt}jqvEQ5+y33m8CAl&ys#j_n$k-ck^2doE!@$_FwwziHi&g$Zky5<0P!5;Vs z^R(e&a+NKyE-BK}zz55J?~f-sZq9*jto`^ZSR(I^6W-=-M74@92tN%~=uxGG-hAO; zMzDPlr>&M<29nELegc>Wc5P&zcWP9}0v-A21_U+_0tQk^<))-hmoq!rY(!{6Cc1%d z?Gmpx1|rx7ik;>={K3d|eEZ#TA75z5sJ-@0TmA9l{rYp$LutzozUYLwECw2GhmXDW z?yY59FLe#UKTv@`=i&pEerM40Xvn}ibYM3q_0(=pc@`$VU#hQ1^C~am3@@>G2Cl7? zO1{e*?-Z)Iwx#`0ueJ(A@>DHE*2q@P*{*i-u zX{{F|^bXLco7ljH&YjkH*|r&EKwsB>(%mmJ^nP^Lj;?ZgQH*b_&E9ARu+7ebYTx8g zOj^wvup8K20~l>t^`~6|a9YC<#>cUN0S8)wUN#l7i~LAMGZ-&6Dnn8hmTnI|WyPi~ zO!T~@eQ0;yf5CRv>36FZ0e{K7P&iRW755OjSfq(JN!lX?5fChN|LNjkDqe~&W>uOqRu<5iSk-K^aaPnU! z**$nW2Uj@zMMa%!imOe;bvE)9w14~XUqN93FB+-})riC%-?NDbH=Zd;kXKagIXCv} zPHK*Eiz^cSO(*dc4gb#@05%RV8 zdXPhk5EW=NrF(|I^?KNDde-9WHXPm4&|ibulQ>Bk3VS8Ne!Sh5JNKC5nZ(=GZ z1QG;(8T`VI{&PwA(`lqd)V0j=If@`jkGs*s)?5WWy{ncNsl zF=Ia7axBO_lHB)}!Iw8>3&c8sk|=t7!zRbSR83K8M2{D?`Ht$WPa?s|!B#OaC) z%vF4j>vuOA^flG8^z0%X;fi#|I_ajds?#w$)}4?}vHz5N^&H~JO@$Nl^i)mWpXP`! zQmnhmQ(?a#KdwnP@`8C;X1E_!oN1c2?9jSv6?0d#<);V9@w^289bFvGPakY)l?zkMSly` zx3DLf(LHz)xs(2tyx;jNQNK|ZuoqF~Da~xt_>#j+ftD~M-rmap{XeLfrNv;W_kUDO z6%GOd_dngOVPorNpQr_B(Filafn)RUM}wE}?#zvxYFPfw#kUKuZ%VpbHDfk)=t)+&HME-k>iNip z7s$1xi&iUDUTFk@1kWIN>vNN*SOXec&Oa=hpe2S&3qm;m&CACtWQ!&OJ{?=WognDk zC@q5Ihkr0bArhxs69Nc)wn|>oxOVNTGF&S{7~{xA0y5!V6Kxvk4bg$^FNH&U+qG36 zOEVMF-;_7g3Nii-CFtv&pOqwDPRJivcZJ@nUuQ@kvI1yyhTr_oSlXNiwDOd#mR^s# zb*W_@ZZVr2f=kP5;oqbRIn_`x-P21PY|!VGDRMrTF~OHlyi+88VD~XyT|VS+*0;cy zd~f^G!Iy4#r*@H($8xuw_F}P_-c_d*rzFU!cVunBrD2nM*6VKH?wM6a(Vdj>SPYL4)#nhbD(7Z-&8DQ$N=+6b(M5)l- zA9|>EylU5{061CC-t^=}j_fVHotivUdryu+)(VEj@QeKi4)l-OUQNNiH|B;T%-TWc zp-GZ?@x&O@8cVP)NPWoc5Pblx!pKv-;_#)E}F7K=gAqb z*lnEnKNKDzoRWGZe_DDblIV?=T_t}=UiN)u{OcC~P8h+K@H5Ka-%`NnqOZ3*YVNM< zi+++7`mz}UX&pP5r2qJ574 zs?4H2krvOM=y07<@f-T~sHU1_LeCU(oGl@~X6r_!tJp8YmRWg7DEU1ra3}qOw1cG9 z>;fJemWXSK8*w$=D^j=*JS41og;f71ZQ6HFsY^jaBp74ZuF}JWu%JTn$>lO|USAFmX8spf!{kMk4H8Ok{VrZ9$+paP)Qc`gx zoRFggf?d!``)Idlm@S~Jn#B<#^(&z@97TuNJe{)GG0DU}dovbQ^Ob*B{ob&Yu_yTf zKY#xI_bAZkEAXT3f3}ZZfhB)sF`@_z{C*ZAP&<&VIO(iOgzL@|@ofe+@W_SLg(K68 zmG!%%by^l7>Zr75Zo5juI^oO`RKto+Y4*j_(#Q;vZLV0kCa*wzUYlTR8irgsuZ>q| zurl&*_nO+3R5fx=00s^9?P)GV#hsz33Qt-Uup6`0u#|n0ADxH9;N3|LDux{suX&`Cx8Dl8WmlQ zeGa6&M^T$86sz8U7v@A_gC-M(ma`ZK`JxD_sB@rhF>mNf>=NbJc6feEJ+87EB)sbuP4S!z7tL5OgzZ$XMEu=zN;YgxL+a4z*eREHV@ zL(<(s+znN4WPy{MQaHU7@>^tt(aKPMTg-yF8hpTK1lbc!MB)WT=iRr~#Yq7I>h znHGsZ8x$W`sWy$o>$fER~X?!t@9+QkJpu*GB;ZkwNL^Ul|l!gb_tJ{2{FR5 zH#F&pEIw0Bo>I%Xt5sOz{G}pxAhjLX-_4>S7iT;jY`IW?fku-<^9Yr|;692wuq2q# zKH3p;eoC^sfS^5+-4BRW>8Bu-GfJ32cVY0rLhy&}_>RFkDrWk`$|};Rkl-uDh9Gm2 z#J1!_>y+I-C?<6kP-@BAElC87v+T6I{ z2i$Xq?v?G67i6*8)(jm-@h)}c*>qvk0dJycb_Gd>g+#KaTVBZ4BSAIPA`ujbRlRLY zt^4nYim~00PO!aShcD2 zJntrxOzwbr*CUuRRT4Q8q)6b%u%`v0=;S?G!?H8F{ZHM7u2i)sdy2ATyX_VX(p(l3 z6s(&V&)Lq4q#}PvGAiJn4UmdP?`+QVwCmAAZo5KaUc`(E$DNp0XjCv4N%;k{oe`#y zB!EqM<`uZ0%)ZBmJBRxi4*5*7u&fF?VaSW|C7bi$B0-Tb-^1K4Z1id;r&GC@wt6$2 zKbax_>f)50N&jwfnYJX&C@xpHom!7bX;x;`>q7>S{*onS#_^!?u&7<4{zZDB;?P#8 zy^<-Vn$!-lBKgBTwk)DRMN7&_3m1{Ek4T*OzQR;jGzwmMCcUNt&CJNhTn`jV#HRgF zV3u(v5#QbFrQ@QvCmJW)za4sQbaw`_x-nJ9+!Hn}74^q4#!IY&T{I%n)tBu+A?K#= zTyS-WXz_YvNa_G<%i%%%g^zhNf*v9=A^+*a<_4kA>QP23QcsJYU#4S6oXu&uzpA32 z^)SYYW>4F?)^@ljH(lZ5<}>K>)P@>8U55_ebmPLijK&JUu|YzIw@)+(-Ny76i2piH z+{9WF$4z2a*01$e7W1LJ24UVcP++l%CnPdr=ojQv=)y(Kb>RvFnQlQ_klH64<;O7Y z(SUM-m5FR*pakj($H~=Twhsa&iMZa(sf%fdfEiz;b%4H~Kf;_(CyqPtt5nb#-IVon z`xONX`Pj~66X&wj$eLKzn#ps>C!i&K2$2`sIA-c?u%X4IPiIhkdo&D#rg!(DyUMC- zJPo9^vS;bh!JzdW+nuWes;qQZ37bm z;+-qN_)t^hj_^CgC~Y08+K4`>I{*Qs%kVNQ`tg!;8z!Izwi2rt!*M}OMEucqU@r{Q zL3-7D#W~1fotViUquj#9ik;7kl5E$DB*s&-0jy!}uFoiCABCT&hXqdAIFJv6y_z|} zsHXNd+uD11ASvk~8kwmRzTzh=!36J!(vR(;VWg4_ zOj&sH7*veVV)LTQ4i7jli0-GYOa5W!uLZ%OV;EQ&8;tRJ&>kPdr1|S|9&A74v z1M!zcw<0{{xe$>$3@%#+nbTOy1{c3+6w(Za3~6bOHuuhiJp{M1YD~(@$;6P072LJ` zB+i1cPdAQf@R*dHq?tF{&W76V&gr(h2!e49_Pn7K5ua`u@q2$O0`1Wc_0v0kP@0r! zLh0pZ1f4mX_Eu7a(~$&GEv>An9E`60T?D$HQ>?H!aUw@4VHJRS1;9+kjer@=qm*OT zvh%TLBYh*Q{hOsT}Qiu@(t(LV0da;L?A0NP=19Cjh`S|-OdzHy-G@Wvqh zV=qJB^5)w+ALdJW0>N;|pD!%Sag#C2z)^S<(Z3BUUXE8bqv#(REHo2b5EG{9ZG^yT zO*%c$O~Br9ErXx2FM#;Y+|F*f*280@%xvYCl9{wDe;o75_iS}tmL58pDDzt634UTVe{a#;c)XCLOsyjD1HAlJW3c(=F9Ngt4 zkk*lp8`d=ZIerBb0dLE2q`dy+_uSp-huZM?d36AhBRhec9FA{OX58m$k{zg*6(wQP zza6;<5iL)Y6GOT}n2gc6k0EpT+T|t?|6{-%<0NMN4x?VFY2VG^Owl&B9)hR8u&`ox zAIe2okuA1fq|^U)e-Ho!M!`1-6_xE%u2t84wxC02gSB}E>AZXRA&du;!JAlM6?`lBv%uvV4WwtKd-$~3wRa`PRj4APNt>V3RO93)Lo**`X_v8YM zEe=`GEBCQPYI#UAAPE_k3)2FXQZUNg3u*(?cT#SmMrM&{nNfDqqw5DC-*Gf=s2(to zfR4U15)Egem^5sMgoAmCR)okPV}x`)0pwvB&H5b*EN{`V#LCS|KwFHLge5sr z+}2QMAYK^_UvQ;BYtYAFzbzWRhqaR743|nL^GQccCOG;JQ)g0H9%NF2U zoGUzPr;hysAI#v$7XS3wC&1Lnu4j%1U>(5tL`k!*ns&}mNzfy@-QApDfe4ki?{%mN zR`$w9vy$NEE9)d$TJ@KnSPN1nqBhRVq6ZY(QpQk55G0h))A#AfQZ>b5(^b$Eb-z(= zYR3*DV9Lo}Rn#{Yo?ULl?wZlS#TRbF3%CYvD#c{RP%70IdhF|8Qx5Qd1$f2SIMZ}q z?n+Y2h{YHUBsFGrBrI+hFym8QM?sItZXzbZ1fLHpQ$A-A@_sxlT;86^&6TsG&bnDt?B7y zN41{mkv8IdGQ^>bZWN&PD&I$J{jlxX);jRiiS5~R>qlpJy&PD64HyZ2O&ICepIZXC zWpqpWI-2oTy84-PW~jYjjWhtC--ELmt1LPQ<7@MG5zezSJxRt5YE<@1f?`R+}*i^`3^jZdiB_LH-0Z`Gp%i(wJBUevZDY!Aqp zu8fY{>W%F9?Q02wU;*Wav~olp4WE7^2L^di4D?}Pp9ItA%lPNb#MJ~?-IOtMYWjfA zfAjqoi?Jn&C?MgN3LIK63Zd#-KDDK*>d8op z_ya2w64c1c+Zz*5ZP&3tx{}oX=q_Xv@mH`eQcf}9BRI*`j?JQG7m_C|m}%)$r*3aM zVQ*0|R)=A)Z-k8Z1(2PRWmyJJ+P6jB3!I2`-&*t^(BQEf2Mg<+9L4M*Gh=dIcpHf} ziMj~VT-2@G70h!~n+&4D1w(4-qlG*%IN-nClhfks9PmV;0Fqlf!&??Z?vHPn4Ojy< zS?isJmrv-HyaTG_%DE>Rke3bseLRN53I*Ao8FjH)%}FMxVpwGqy-v*}Op;^mRIyNq zEv*v0@51{e^&(WlJ1GgPSR=1!uWbw5I?S);{HEIV&A1#(`eVqqExoacsZKvyi1F6& zi)q0R1r%m0aPpwT>>~BSjFHsRgTwSx6?=K81bRnQZ!;l)Pdf2CZ~v^xbu8aBHMiyT zaDMn-KVQ-H7RVlA)CDkMiNN%d)Ml%}qbVtCJ+PAsaWgz}pe9M8QwXjfAMpdOrJe&( ziwG97Ooi>Y{xQ)W-QCTm{u-2iSTtyWOM^C*i^ghSvC+emL%Q^3`&a{G#SLW_Yt%yC zf^LRQ=1|3ZDeSu(&K{V;tH-Y zL`0;Y%sIrWG(^$a0$}~ib)#{BNXQQCV7eAuZCm*O<8?4%FX7yUbi0H74eI^Pk z)E*JXHR$(l0tKZc!U?tk1f#gpa9A0dC&aO*mYNl1FBav1dLPHpsRy_ha4WS8-`5<6 z6j%dL&6<3K*#$X_t^W!33N3p0FL^3cLt?9D#qm@Svnt=!9QoCK_2)ibc*YvI;sv&G zMJPZS&~?M5`gw3QE+7|+@!jQyvG&e`=z^L+cQPC1=D`be)$%k*q@V28&NeO);466eJ^jA#PK2&o+bE1%0e;UGOiHCkmffE%42z6II=^eL9on{q#hLBsEk$n!aa)4-C)3!u9r-oy(7#rIdJmsj z*Pw5UIagkIF_kD?#g24@HCCwthz~uI_wxsX(k)f<8uBnZ)NjfL7VP~XTVgg&ff*c9 z3Cp(aGi zxuR}ybP34iHtc)r$Bpk*WcuzJ2Ck-(h;%ZhG z?Jn(??eq(BR}7gCOXK{B%7wP1AF2z%)ae&OK?v)- zHzgp-|7ZL=hEpFOJa51kj!lcqEJXG#1RC6g%=#i$2yhn}@`akUXh3&YrgY6rnNhQz z<3we{7D^M`W{SFROf(ObHM$2zcFB*KyjJ>gTNjZRB1RziAhqYznk9GOo z1c_6=isRIR+eh?vOY;zX7(}!rjwAsc3WTA?07&k4vd8Xf@tOZ2PZ30pCbIdqAQgb- zHdXQVb*OQ4;0tVaQ{yHU@^FAH|6VjIF7!EwmZZzZ_d*$p$4G>jG8ES#MqXjXx*zcU zk_f-Ty2X4KP-n%)K}R@m=5LcQYtbS|Hip-t6UQ;O*0Mn>Jl5H|;e(%WZQi1w_CgWA zb7Xo&9{(%`_%Uoo2;Sttlc#Ek&tu=9*G}+l(_!7;EErwGQW!OZjxD%mdPZ2w92Gt= zsi%o|JT_C9HlwQWq=*+PW93d84WfRgZqZ?`<;fl$!*&41bCGRO;}J?-TwAmZhUJF@ z4x89~*Qa+AlhIYUOhXdLR)--xRi|=-X?tqL{W0z;@x4KZX=a&5ixIk;g2ye|rQojO z&^(F8ZrtprJZsjN*~d;0d_Df4H1hlpvPK$uC#(Hd(ia0OhOtAr1>CSi@!`UqF5!s= zzHmh^rw6ox)W;q?6zD@eYbR+R2IS>CK-SclieY&Z4AzcQO+Vn16Y3fW`-37Qwp6}!!Wi^!e+MtvoPQkT7fhzktGKJ zSnjeSkdt~0)kn$-9Y1R4AHF~mizK!6KZK5719p~PqdZyc~_^4WAj=&+U*hlJK zrYeF*NH&<0HF_XeU1p;(XoeX^6OxGD0wzwhir%P5lD-7W;oJ)1j)F?J!|rPU8k1&F zU<#agJDmiET%-*c`^}&MJe_GD93M>BaL=fF`}lzRji3QeMs9?utx`P(>cdV6_4=GJ z!sz}sGtBK5S%BT3kA@6oo7pc_K>`fBnmmmkDTd_sa~XRx{si7!Mfp z6^)hYYEm9dA=AsmQsi#%1UPnDx-`*<---R38hb;rt6c6(hng#uzS&h4|VSHi@tNl*YwL|0PPiC%f^*4|Iuodi} z>x`dZXvqdk=P%n_i_ugCg|{%r?e0gRD-eY>U$A@TD`1rr>noaAZ~(Xx#y9V0Tr0?! z)JZsf7f1u5z1*Ar8GjGy|c(S%@ zw!U227pmnTa>c6EoWU@X%=fuqi1(3L6!*szx0IK(*BDb^--AK9AZU6g>n7r&ijTHo zkcfFxUhS+4Fsv96zKuGpDTrLLS+MxVMo0P5DN11IIe7kBU@J@dQW1J;C+n`tLzbQ_ zD@^`Ak>`8}!A87)*ZCcG$ze{#8M*yPGPQ?Gsk1#EpE;1axpKPKRp0Plozo!*qSX3} z28k_^aGzVsj3H22jr1j0aq~zR;6&Nr0J;+@ZMadn?Fldv38p{aL15AES%H4V$#zrK zX7_@>_OsX@hEHaRXrc%pR>{l>izGL_oQcg%8a-^ju zZlr`B%m16~%q9UBu7|iC)_Kij?=l%tlL8fyRvB-PzyK)-$wAVM8)9XUu^ubC9PzBQ z1jq*fA5Gbw)N6vdPT$f%$dFt|BjX`6XJaMtjB_Vu{4H1VTw#B zd!jSt&HzzG!I5mcALK$B8jUC@w&x4ggzb|(Km()3>9ig?)`tiER0;)Fvd^;#8RKlB zBvxLkrM!k(Q&&JH^D=~6z;1v$3txkN3U5cKEJ-FSjOv7*5&r>kQq~6{zbF=ROc{*C z59I>K59fl$4|~UZ#9QJ%Fb-)behO(Mp$)Ms`V*oz{AQtHLCQ~{L6q-l9b@{r^e42A z>~A>UlpvG^Np~M44aGehsNZFTkOfLI5CzJoPzDOh5M6mi=q}iSh>sZMHWf8)`V%~Y|}fYnq?EE`ixuK})ntgzd0b%g%O`IE3E z=4#^gpo+cV1e%$}n?T$T88#Hmj$eRxx`h@zPu#~y+m$ijkclzPvPM_j zKCsTn0D{Dq&MVgRv{57wXQiP~Bj)v>c-&dHCr6tzR{Z2led3Q^Dc{o(9OU+N(nK_x z5%zS)kKcTz35Tbh>L5EQ&-DnFbUqnPRm320VSkq z&`&a@5cwg-6{S|ZL(Y_vP$&_+g;9knj008}B#X_~vCx17eh8FM1i%_n23a7)BG)CK5AbbOc*s!>X@VCki3sAMyRD#Efg?hJ3O{p z`&y=i{By2;(itek6-o zl~^lhoMT0+k^Q1wx{Xz?^&jQEkF+WjOUBm9Be_^Yauko%Gp=79A&gg4(LqD@{kBU) z5;e6S%xjnJw4jk;_p98jf$wMfmd%Q7;(P6%!3(uQ>NW#=4fCpZ#ET`h2I@^4+G)91 znL=!p>bI+_m5QqXQTMbobq+OmwKS|pb!=57EjwvFEAjQeM{fn&^>5o5M{g^f`l?0& zc1}UkYV!tR6;+kba*A>kl~nGI)BY{rPPze5JLLrqrB|GJmiLIQNxV% zjMVguVv^!z++(Ygv1+!-tBN zr#LI?H&?B;k(HNOQf7!PbM(q=-29xPqU?WWVpc4?CG7E0b;+b*x1ff*PBpi7!Gv)Y z7v$dG(u$F37NVK2V#*1n*rV4JHE1HutQr2mFcqI@mx%W&knVx@K%dC(UPv?pf`{uE zv01o`N+TN_1xp}x99sk|c~*IJbT>=ZO~Uol{;Uxg&a$N$Rr$7f9uLM${|_6udyM*d z+V&cySFhz7llWIfA@WqM+HldXW*Fv{ac5GV&yLZrb)`gVYsGF=D6XA*R$(c8w{G;kvqCrs|{rSWEIzQ=eDh!q*-*#sUhm1(5(X@E9K)sKT~21L=%_JbQmE3UGV2S}h}*Nb znVH$;tblGfL&M zuFMe4v1tIvJ_)dsG81Zx8n|p{_f$J-6ztgt6`D8}54iFeI~MC1Rx<0Jt<-~}#ELCh z&u2>Z0$k>CEeFWjh6;2u5@|FGzin=@51U;7ZZNdr2Kt>anbNF> z1X2SMIv?OT8o1@$5Tz?9Y?3+^42{Cn5ii`_VGU4WsT*9IwIl)<%?cRP$HH2XQPNY5 zZIX5APi&q;TBK0S$QOc2bdulJ)j^u*427!tHk~UAfG3MJyl=BjT;a0gWOi(}(@1i4 zOC44na9T?~ZJRX=H6d75kW*~X>Eim0J02aDUhCny=W!lBL|7&STXOZaH$Hk>4;<~d zR^>e_?7dZ-&0TT)II&w{aR+8Ii&^k^TN2hwtCMXWAZ_c;`8h^bpj?O5j{>4A2+xym zM4qYKkXZaND@M$L-6Kn)>>GCIOs=IY_*ED2C}Zqp&N2Tk)OB;LZ4)i|)rX0&I;zCW zlTg$oBBd_k)Bsk6TNVt8%$oT57dF)f*1CN1s}izPPwZ`s6eC5EC)vnYD94)8hOV)O zs^WTRR>;>Ev(E`7Un;hV8|3nNJ=Gha#t*Y7Y!2+G3P$8&Nr)F#G`Jxi1QE5&B|7Vfdmk!lXi7%q5&^x}`(hm#@^y z2FE$(P&r6O(DzNr4N*T%=P>1|*vr$(D|iGQU8nDb?HI%RbW0dO zNd!jS06OkJ^x`?{-&V7J-Nv@*P%tkL#2Pz-1jNjT=;hh9z2s!WEzO(JsAUVg5;k=R zug!Sn(FBkzya4nw8$fgzjd2IeX5Z%PgHM0F8Q6sC+UOxQq}^m*PYSg?3<6Mh#qhvB zgM)M1%ov=YFaz*%VA-^(l*1Mo)elu&Tu`!bo83QxwyCc3+mZ>)jM>#pSp`VnPQn)r z#)Dr+<^rEXzG>}Et=n?{eOXF2HNBxZYT(K)P5>e`15wvNLR{07uEfrqEruTT^tGRjy4zFACvswGM~n0A7n*UKEG9&50Vo=P8hfW;X}Q_tT~1=ZG zhNmJy1^YMq+dOaOuqT2zICzc*Q|pP;YjTEFwnJ8r^4Ikwtfv(NW#Cf zd@pj&(5aL{*Z8KL;{UN(}Ie?P6Z^RBsAe!>F5t&Ooral zPru#r_1~w3O1zcWb_T}s(krskIK23J7gp(63?(BYYmPDc-UD&}p?=Inc+{NO#@0=? zdC(Va(FXS#G0^i`WI0Ol0#5(@b^fBJ5r_7+_}FO?e=1mLXT#$zt|wUW%d_@Q@C~`) zAL^IRnl{Pmdi#9#ag#t2s{UN?)>v_psEKcQ(HLGeNZTMPFh2ARcjX((o!Wt=Vg(cQ z{V?@iqvx5yr62c-tjrab`>^mawD4M3^xgAb-uPRDlr}#bly9Fv}`Q&ci-ppUS0x*n}an zK~j5Tz(RyEYd~PPNevHSSv$x``7bY)%utwFV9K?g@nukUNVt?&a)h`ysX{3(g3We& z3JpYU2ZYoC`yTiaw*AM9AvK1}j^zOA8`6$tdx}>GQQ8org&@TL!rom4)zNhg0)`|= z(BQ!}Sa5fOySux)y99R<+zIaPcCg^??kmvUTsy~ z)xG!A?D&D3Kfgo0LWP7Rc2t@}ztU^kBMY;B@gE?7+Fs$lqJ{Y4_(Ll>KD2ah*eI-P zReo(4bpx^nsvzc30joUZg%k&^#+m8tx@$8{AC>%J)e_2Eci_G<$joQmwObdA)e3G zRBjM+r4@%!-1%y%XZL8qI)rf<6-SU~VBqCI+n<228!FVGcrbA2(CzP!(E-8VeFKc( zrOui^)`O4{uasQ{`@B#|dWE+T$rT+3r-x9}2OKiFQtAN@r@h;8SEBgV}`8a zlY4vlh)to)zcY?MRPpfeaEPCY9n9Kue{?(GA10g-t`9Ec^7UYz@YuQjxEsPo{2Fa3 zfSi7HDHr6>9+<8AD=wslI29E;e&nb0I)Sq(+t$x9IG0`(Ii&WyowFb`MwSI~qo|!S z%Dx6+iawXn9qI(WXS)bP?72}B{Uo@Y|pq+DgwZ~mR`cbL#7n@t(9TOl!Cv!MnD}X3|P!(T$0AZ zm1>(cEohh3v0_3Ir4AC#GpJ7D(9|JK9!yP<9`RF1#N;^J&*}O=${dI)=kM)RWnapt8l?mZS;fPPvs(|0r7ANF`O{0 z0otZIqtLpU+6gMgDb6qyBdMw&ZTncV{0|cMOt@Rsdxv=6Np#D-5{DFI zHDFDEtNkUs3|~zh$?co=mtC)7rTy4|rvMuGd+Rnn=&{&SsXT%X3|1O$fJ)?d$^xE9g4mm88+bDws$#+bcH zTrJ;#z-9T8zLv(#+hB~UtPiny{Qar2Hn@v zyee_b2B>!5N?O_`GdM3!AYBESbm#1gJ~OWg0@0>hUX|-Wx2OJ*A>JB7<5JB4qlK=1 z6`}~hR)g6=Jbl)+Jb?Xpw21$OHAl|zj54Dlg)3WtBC!hP80|d8M-ew|HXqoK-L)D{ ztzE>=-%NWpeaYO$UwwYT-tJ`dYR9AlK~d$c#Y+>DggNoLq(3BYOn>3UzH+<^tbh3x zZtx8PWvOHA0tX>Wdxn2tfaXK66oBE34xpVFf+n>X2K5hs)=1}Zx=;2a6qmQS2zvVO zxA+))Yof4UJWw#DFB5K$N}?=&QUG)Le7&KOeBOLYT$s$1;scHpohWNLUcpnZ6ozkF zZ@0ZRlpBF+Z<$BVV|l%=Z}-sb#KpePZ|8K31e(+aU`u~KRcQ#-1p*z6_{iJ1UDWp; z+JoG7k6FC#gIf?$Kc+B--`j)=I^x0oL&j;$g^f6vD>9o8)?Gw75}I_ z+Owvreu=+uJkT%?-0k7L32U4}^fq|~^f%l9Z}EBfLnGfpT2S8Bc6(%Ubn=rIeRAZr zMK{ZStDla4Q*P3?_JfiY62rLm#{X27;WsU(t!_jXfFd8Om7sxIxbLM2qlQ+~+xs@= zHUpWZ`PhB}#M_hUK>xYF`7;%p)U5=S5u2u*|TH*>9X9f~{MB--nZ`tdRFg^ByW=*&? z26D_LHBU!B)*1ZQG_IqCqyo<418=*!j8Zs{8d7p5$^QQQf_yAhlks^&FG&^c&n%er zQ{}X!DCZ(sOxCqlbm1I^B2nLM=;9TAUnEe)XbXvvDMI_-D)Xq?uu+$Kj_X-?nf?V3 zvg{x%U{TT=8FfnyB7a?8a>P`XtuBJG4X{4U!=Sm5MQx_)8oZbi($4Igr5ci9uEXp; zwh$beKezFS$?dI547dH-j!r*pRwsQ;^{tF!@hIW^0gZAQ7TFuaXk7lq+ilOz?Yk{% zYBzRtGY7W2Gr;&@`QlFJMMP}*Da`H9A9dv#eXs%+wb`c2U)IBKaRbxz7`PwVZ-hS* z`I1Gp&qHC+$^86T`LXqv8o7LVx_d0bDNnLR;}SppT4G-h~BFB4n*0{X2BzA}b<{{^P$(vgyRvQc6 zRFFFOB5Bwy;#W(N{F1>CC zyOML)xliuSjDO$Epz%^YQUZB1bsoI@?{e@xaJssIBl(wdyrZC;Q4HHQycKqbXfctNC1ltABiCv?k;}8SPLinB*6Gmrg7M*|EMhB zGMzeLY-9LwAplxf@7y1fhlumGu8ErT5!wP3UZjCE83F$W2|d%|kLh6zDBo^4pA|w^pONiG7Xgx8!1Q79K@n$F4Ry2uCO|T5v+DN*A5+jC7v9DPS_jchN;- zr$d?~G5r(Zfnvu@eh)r&_KEQW)-MB9tKh%C9JrmQ>n+5O8A1HJ3U~>cXDml@YJZT~ zcY*~^_UT3?-DzO!l@idc$yeIuy^K-ZNS!tJ2am8Ql{GX#Ot)(L*1=go&pVPe)0 zyOMlWh7|7fo8f2WKMPQ?c>58dt42Lq$W2kp4MJFjh}+sfxQs?Mw+T^_W`5v`Thrw6 zrOd~C14FHn!2Mz;(q=;Q!wS?d|5FsUuhyplS`xFo{)1&T;tuz1 z3iV~qzjPyDJNz}^F1-)pyc9e9)-CM2SrDJY^bq=IxL8q(UR=fOPmw&Bbum|DW!Tk) zJ?{+IGV{sD-Q#*Hwe%~C#hCP4d7%hXp{gZIGkTBI`jiH5=T_KxeWz= zii~7C&_xYuOi^%Ts_2ni8*RR*?LKj%A~b^$(;`VF9LYVfqqfr(>q!h;D%+&Pi`Jt^ z-m&G8v#3WAe0cs((paTPJqHA+#5&ymYBD({>Z!>x4d}bca-G>~N~4-)jkG*0lq~g} zf0*4%o#%@K#8@nf$Qe9tw~H;z%__8MbeJqL{DP_ph_NXSDWnpeSyn{{MMcLF3kp=P zBlaze%0ugM=g7NZef|oh7F8BytlFgQlFHK`AixSm9&1Ml=O&wR=-l|Y59YOe#C~pr z@Ex2$Z9!mAt1~s|3Ra0X6(KW0#Tu~p&rg!^>JnRr8|nV6$3~xOqHiA?fO>GQS9i;e zkg*{(f$#UeTz5{rJyi{agC3Y3cw8-p!@*f#=YDBD1;Vwiy*R~}!H7%?Vy?xf0Kna2 zj>oe<4|%y&ywcAOR54i}00W;9@IhQE-9N!dKhr%WH+>5i$djq;!&SUi1B&BvH=A5; z{E5cR8eZ};ee1b89Wk|)y;Lk#cwyM9aCV<7$JH=b3!ITak!yE-di0*?HwtodV7S5a z_lMDru+O!-wlYhX5FM|c6a?;t$I#_p0j$;W%F25y zbh}rP=ljkx6LAV~f*Y8f{u=v~8fFZX@Y}`TJ7`sKT=jpkG35QVWpKd2)3&5jOVS#Y zQnI8*q$e)zZ_7IvN6k(XuIiWcFNa1Y(=7TRnZ*AnoEFTN6PVv>HOerGiCA4Y)MSER zT3KmZ3SD)jz?GRyq`8T$OI0-7mq1?0Ny@z}-7f9b_E`e<>3qv(lOXr?pm$Dw3Qk^k z!LNVRiQZx{%#2E+Yerw7FYlzGs>FTEQ8IwmAWK=>SzvEAAF;}R`K=MSGAI|jb^!cH zwfR-z8!-s|>AcwIw(#gwtE^kxkE$a}#q)lEEqvm}G}a&DBlA1`v~ z%g3-$@HCcT6VeU3kxaoHp2O584OeKldIE zmc})xZ_75SQPum(c z>K03=e6{mIPrVUUH_Zoe(RyB-l*-Nn0TXjg9~HQ%9USbPn{S;`y*4aL&h0piRBF`G z*38R!y3f2zO-wa!Z_dE1sSgY*s!dJi{^5r%?!+7rrfciIeVLLA!nXS6W6Bn}?HDt! z5-utcfHj1S%U!ISa3eQYoufa#L3zPGKh_<_+;kP2$jPD_x80K7u9-5Y>|Q0p`brtjF8jaDH>Qo+37^e(QO7H z*kaYGridrJ_G)2jzloJm_|WXsp{DDUEBKIF*TA0{h3(C!tV589$2MD&7dcvYqYlys zsHD`Y$YmYrh-#mqQiI-m&e7A`& zIXL$(Vf9a)uF}H08}}0H&n#Hv?`^Ktti}f78F=Tpx`uh*W@a!Ho{F=M;vvpb7l&FR z#PXY*tNm8faYNk!)enPXuEfaWmUXAS_P?FP@8Ob9s!GN}Xh$L&yl+l7mRLGD#t*)k zKNJ^-RhG3knb;nF^*dTyizoK_u68u*ecNBOhRulrah#dGS1AMuKzjJ?Eo%@afVtT5 zgcyhNb067~=j)fbGwtaUic+erh$wBkcdPP$mE2y<$`a2#)Ve!QE)DzSSO_i5mASN;Y%49D zEEYZy>?U1|SU=NKw`*g-K_3U6&z)W2{P|_>k^wD{&BIaN>UmHQ55VmRKKeOjA+tW2 zZD&FRe6~6cs>NrV^j)DTSV0wcWnocZGkVjuIt}LiW;5F%uisu(e)i`v8%B`d#_7H* z>T0W+yDI9>Phyaxa=Ra;C^Crag^?PhOw zPh@}L;UTvd(p*mpMl^Xac{aZ-O@_JZ699VCHC&#edG&4-wpQ4L953yMf`~6z%giR5 z@+#WbWnMYj^~Rrx)$a99Utae=?s|APJ{!l12psuDBl>(~o7Fjq;tz%s>)O6fB4}N1 ztAXYJe6Rjmt;?Xf%~iy^^>ZW4Q%RS|2##-ClD0>-s%Kg|s?M0nQe@-n96%c@hZdex;ZMebjQNEx;Q&buuU?xO4j>&>p) z4Uh;qL;U!*aZ(juqUI&K_chjKZN3YpT;}cFd|WyxAD95(rm&Y#)^26APB%_rR~=tn z3|vof2Hduu?y2q-+zSrHuLo?7=y({ObSOVM#A$W-5F{C#JDb`(E?`YYbIJH*t?|{_ zY<8t*Z+7{--B(5LeIQ%4yI=;%%Qw^s$ymP>8>Eq5c6*TST@{8t*LcxoXVkS^{q~4q z4Tepg0Q;SLP#q2JI%EKj&jK803hk;m)Uoa*b?1TGiD%J1_gwtB^3q5X0he>D1x-dz zTdCu>t+&w^r=wz|Yhc)pHp{IXpX;6ct#ut9OB3^TLcHmNoBkso-Dmq@x?I3B*|*1% zlIIct{no3IX#N&GC!@hU$kjBrN5lo--pamcrfi-bEg`;MyGR4VL)~KBcpHel9`KsG z4x38r{NsdB0xodC!HFK1DXqFBi+2bz*;;DoK2!MY?K?&`M~?lSv$tSFMG8-d z_XqiPS#yF5K)GRA$Y~F+crz;T>V$%wxBHOM-y^w*Pacc+ptL%`Tx?8cCaeY_ju=%Xmi1ORPnHM;AL zSe8IvPr;#zzBUMSQkA``v9v#?Ty3Ff&S+urfaV8;oQ9?&f+oXJW4BsXjyQ4l_8GB< zstR~fJo7RI&w|zvTH^B?LIf|OR2Hvcw!0m4AT5O<5IvH8aQEfbsHIs5I-k2~D+~6s z1C~&K^4FIwAoy+6C!n_0wSOg%W-cfUS(S~a8`w9%@6y3O_H;RIl^b(d-Gag>n0240 zMT7N5_CV@UtZ^DMm|a|zJ*Tm9O~rPpeb;O||mb$!%v&_-No!$P62_Ba7) zu#-?QC@mJe_t?CAE_lQ*6OrpU1bFtX-4)Hx>~?7ci>JJ$gY6xubccL8R(u?Wg+`TJ zz8>*fM>)^$hi!oR`o5h8Z1CA^lnW%$o!1+lgj*Hopnf7k0KT#7za`&a{IO|S!SJ{{ zpb*anyv~FtQ=zK4$&_$Vj|V>`aeGw?Go29j~X4|yis zOC_-E4%)A`OIwV{=@pLt6s?MY1**NS7PzPwR!+tkzZOkEN#@uTj32M$VdpoXqtG_~ z{XV{0YHxX~VZq*J?%1Aw43<~ci*lj=^JLw`X18f4yR(AnC4RIAq~5L7q~x@Kd$31m z^d%Q{<{l{G70ss?2ifO7GU}igC!OU+uL3s9W956Wa{GCl6hHz3VnI!Bdmsv~Gea3p@fb~?!r`cKC zZEkbLcP9frg2%V{#k94DevD=_P4X8G4;OyjR@)w*mx5~oUP%rze-#Y%ThD647O_o% zUR>hW#wN%890KtBo0Y1@eXpu|fAStK`OnaT6OljeQqmDrzDjmao2z^&ov!=#$S7g1FRC-95$=wUE-;$jDq$qyV|=nZUq^0{UjHj zLdS9h{NhVE^*tdi(_mieb{W`<8%>C;+8U3J)*4T6G4(gumN&i5^~<(MAf^|zryfB~ z9qf6J688$RMDQn$aixR&M#j6onLkBj8Zi1+*F*g|5h$F5&((Y2Eq(6ixm}=&1qH1H zeQm{FAs)LL_bCwO5O2?5Q+F&pjTs#f`U^wIUVdZ;A4QX`kSve`R{CIHT@};!0E#?M zRm$F8EMd(EhB|8tZ(c@U*V(1+J+Fo+G#%(wymZ5Z#<3L zE;@8O=o>99v$C5!*)YHYAIugXVH&C{e`mWvq`@x3KU>2cJ~h2@V4KAzQcn=YhJo5y zRJLZ!o)r!QPn0ll7`eZqGrVr{n+&ZvCHk4#e9(_M2iF!Pc8E?dxhSpPG2kr~V672& z1D0_8+B^8n6OK+ObDM5EGQn#nV_WW7Za$Za@lam5;S<`vkjR>$RcKasx=K54H7yy= z7Gx#^H5nhFl(gmBwYP?^`8)V{?${d&CngS4am_wVm~8g+J7v08>DkgnF{dqTEEjf4>Rf5@?xwKb7w}BtUqV2(3w7MtX zQIVtWk<;1pyk(+k`dnV3WhvPJ5<(V7-+)h&Pj1g_^@p;MzP4CKI=n9~e$xek`F3{1 zsYMcTzvBQ@%b1=M6zyJhLz&U|#I`AnuWWWcz$ED1o-;`6$ukl77_a4Ea}G5LV--Hk z*UA073YcXivHocxxdVSJHBQUj;0m`tc3Rz1`YoUzkHVy;HXs z{kUkDY3P2C3TXM+%GTV0yW&DU9AD@qVNfQ$@ID>de@PQ;?jS8b;WHm>O}vU7HdqnG zdscG$^jjSAeUM(I*))cCJD#waP4+WoB&s2q+GuSW6Z|T9{;*TMvYFT$Be#4`^~1?S z^1X{ZoBP6kNzHNk#mfE6G;?Ox)&&7h(2?hw* z*>Ux3Thk)2La`1}PuV;9tpLYG$E7yD;RilnL?E^r0*VM9-gEh#u)*6!0Yh|TcfC2OvrYZG98ZFGtr0i;zT|cM<**!BKTc` zkE@JMUN*yPH?DRq!1j{ z@hB{-$9HL57fY}I)VK0vf>o``EHNguQ(hWTyB(ovCu`)X)XGQ4$D&Szrib}WBOJ%_ zKq-_t6m8~rd0#|ODNhMAjrYU>-6puHqO+hN(_gpQH~@zKCLUD9{*?#+pMDi=ErQ^I z!>st9y14WjgTIz_?Qk+ZG!B1E+17c@8gN|B&RmblrIE_l*=AdQE9dNx3K4h>N~G+4 zbKPo6T#d7Pz49RpSXXZ>R?y#%gj-rYm(4g!@xLyhNku`r;27PREIv6wC2BWVO_?2a zNfz?A-99cbps#s)dB%=S1fv!Yg;!0CzQo=XrmWs977OPxgr;)xfo;zk&z^nQGuN70 zHv{&vFLdO^+;>I-W^i!qW7h#qkBQkOH5Y&htBiw@=Z8#GfmNykf8fmsijnBwYt%Ik zKkbtjtLe1rk86i`sro8symDR^vvK8B{u&w+*UvrQr5CEDrXYtXz!WabPa(Xo59b}} za4dq)G`?d=5{cNYS&SKN#upeDF_Tz=z8t()ely8rL~h@%cgh^L(yQ3lTf3<&(%hZI zwt4*ya^*m-f({49SAFVw9d@s5PJ!2$$ zEzne)l_}ubU`9N|$QfLw;9{?`01j8bZF+HZWc5H982~f2oUtkc)R=ZxBNUJL8yGN- z&sO@;LiqD@eiAr$9f;Qk3Rg;n1#HZCHNpe&na}5v)XX%x^_w_(lp21lcxIyC(d(yS z(dl~f9R75fEYmhw9M3HAzbdUvEAc3KS{%ncA>~hbO04FpTpMul6Q5jv9OpH?J8XW` zX*%Le5vAkdwR|Mq5WjN3GTrQ!x1Uy_!R|%+%NB zOk;&*O&ungMf>yE4^ujqN(?c@Wb}f!8?}lQe=q(&SKdGRy`fy}@3OaI?ERxqtKZ#wf3D_>ZL6vHmkIaDe`6=-WXKQC3?`@5XAwtk!U+&aye}{9_q>}PE zFh*7dn?qdMOt;rbJ6L6_OaFTCcf*YfN0hL86>lAjCr~lmZOHs?b!#itqs#KLsrEeO zB2PmDu>r7=^kCJ!*MXH4weSs$nzZ3C=aIKBbZv2D%w}_&F-$s!joCih4dQya8esi! zMEs;qFK6es;Pw0=eiX>MYcJUKb$yMVq$}KZMse>S7BaUO-~>6G2q`O2P<5yzT6z$D zMoxUv%lySX2;S_Q)=w>NOs+u&wH?jfPxS+~{zk6VI&Czjp-F63eD+G4F|jr@jn=F4 zo*2%W+H`xVRcc^{Bk~=@<$P3n%?8zb$Yxv}E@uBc#C{a0R{&Uji?(8>YL=OA>F1Eu zIa{)Q9L>i+4TL^2D+3+GcTeYUfq&|)S%6--YD8Qnv-?G!LtdxPjlBey>_?I_i3)CX zmZqB?sXV;xRu>;E!POcjIPLllDeVguF1xjbG6v@?DEtJY1VWtCxuN(8a-z=P+Sd$tzah}Ru(1~1? zkx)C3nCkR;bYM_{!kPIc?|g#Jr52rr6{nE#n1|u6$^K7YXQ&op;zB$6!T0`~{=Q*j zaM*@%YSp;1`7*tGwmy*LRN)~rxj>+&Po}NF{JX@2VqAu`T0+oAqx|~dBJPZYkhg`^ za%RkoKNju(e6%gET`#0&PNm`1#+@FGpfpkr=#a3z88PW7+V5SY?UCJYp-LmnhYIgP8`#XeAc`&A}4hzxO8PPEe=1S!buV+4-y2n$ z#u&b~jCC_v-?ughZUp!$)H~`|+`y$yzFw$z_dP`WeF6biatuZU$F~&Gw%hcoULPjQ zYVcfIa%10C#oW(gIBo~e4RG$W-3VS zM@=o;WuJ-1vJse7Mmc7P)Y;LL}ebKa#dzHA{&m{7oxyOLzCpH6@t?Z(@xAyFY*Ah3AG^r>dA(UZ2W zetu=8?zQJLbw|7qYeK6MEQx*6YvH$F{_Kt~^Ax&fR+MN$OzpIHG@O7N2_i5aC?;V5iYu z!!>EQwoK=AFfo-D(r-F`liN_{wgc@%HNMWP6qe(00JY-Xfxb)Ub<#uA@6+rvjQ+lA z%u`%s9~*AhTo4v>mL>#Nzwz-)p0+_r+;6lH z3Sp&2zJ1Oocue^*^iRQG-%8`Z2$j>>bXQ`@f5EV$k)9oN|6cVYr1_Je2B9f}(WjRm zB&3PNdw&p}JUD(eVT~IQ1eZiD>D#O{yK*(;VOp~r5hI!RGCa1(@7c8VA^^frs5@c`@UqMn3kusYk0!&%0DlEFfd2vdNILm+{i^l(9%JL!% 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

u;h#d2cvP8 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 HXD0a%t!(s5 literal 0 HcmV?d00001 diff --git a/packages/System.Threading.4.3.0/lib/netstandard1.3/System.Threading.dll b/packages/System.Threading.4.3.0/lib/netstandard1.3/System.Threading.dll new file mode 100644 index 0000000000000000000000000000000000000000..7868cf0437d68a1c797a28b0f03a322bae41ffac GIT binary patch literal 50016 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 HXD0a%t!(s5 literal 0 HcmV?d00001 diff --git a/packages/System.Threading.4.3.0/lib/portable-net45+win8+wp8+wpa81/_._ b/packages/System.Threading.4.3.0/lib/portable-net45+win8+wp8+wpa81/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/lib/win8/_._ b/packages/System.Threading.4.3.0/lib/win8/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/lib/wp80/_._ b/packages/System.Threading.4.3.0/lib/wp80/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/lib/wpa81/_._ b/packages/System.Threading.4.3.0/lib/wpa81/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/lib/xamarinios10/_._ b/packages/System.Threading.4.3.0/lib/xamarinios10/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/lib/xamarinmac20/_._ b/packages/System.Threading.4.3.0/lib/xamarinmac20/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/lib/xamarintvos10/_._ b/packages/System.Threading.4.3.0/lib/xamarintvos10/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/lib/xamarinwatchos10/_._ b/packages/System.Threading.4.3.0/lib/xamarinwatchos10/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/MonoAndroid10/_._ b/packages/System.Threading.4.3.0/ref/MonoAndroid10/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/MonoTouch10/_._ b/packages/System.Threading.4.3.0/ref/MonoTouch10/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/net45/_._ b/packages/System.Threading.4.3.0/ref/net45/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/netcore50/System.Threading.dll b/packages/System.Threading.4.3.0/ref/netcore50/System.Threading.dll new file mode 100644 index 0000000000000000000000000000000000000000..c77b70bc08effbcb9425a01f6302730f1b3823a4 GIT binary patch literal 32096 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 + + + System.Threading + + + +

The exception that is thrown when one thread acquires a object that another thread has abandoned by exiting without releasing it. + 1 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified index for the abandoned mutex, if applicable, and a object that represents the mutex. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Initializes a new instance of the class with a specified error message. + An error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and inner exception. + An error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Initializes a new instance of the class with a specified error message, the inner exception, the index for the abandoned mutex, if applicable, and a object that represents the mutex. + An error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Initializes a new instance of the class with a specified error message, the index of the abandoned mutex, if applicable, and the abandoned mutex. + An error message that explains the reason for the exception. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Gets the abandoned mutex that caused the exception, if known. + A object that represents the abandoned mutex, or null if the abandoned mutex could not be identified. + 1 + + + Gets the index of the abandoned mutex that caused the exception, if known. + The index, in the array of wait handles passed to the method, of the object that represents the abandoned mutex, or –1 if the index of the abandoned mutex could not be determined. + 1 + + + Represents ambient data that is local to a given asynchronous control flow, such as an asynchronous method. + The type of the ambient data. + + + Instantiates an instance that does not receive change notifications. + + + Instantiates an local instance that receives change notifications. + The delegate that is called whenever the current value changes on any thread. + + + Gets or sets the value of the ambient data. + The value of the ambient data. + + + The class that provides data change information to instances that register for change notifications. + The type of the data. + + + Gets the data's current value. + The data's current value. + + + Gets the data's previous value. + The data's previous value. + + + Returns a value that indicates whether the value changes because of a change of execution context. + true if the value changed because of a change of execution context; otherwise, false. + + + Notifies a waiting thread that an event has occurred. This class cannot be inherited. + 2 + + + Initializes a new instance of the class with a Boolean value indicating whether to set the initial state to signaled. + true to set the initial state to signaled; false to set the initial state to non-signaled. + + + Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases. + + + Initializes a new instance of the class. + The number of participating threads. + + is less than 0 or greater than 32,767. + + + Initializes a new instance of the class. + The number of participating threads. + The to be executed after each phase. null (Nothing in Visual Basic) may be passed to indicate no action is taken. + + is less than 0 or greater than 32,767. + + + Notifies the that there will be an additional participant. + The phase number of the barrier in which the new participants will first participate. + The current instance has already been disposed. + Adding a participant would cause the barrier's participant count to exceed 32,767.-or-The method was invoked from within a post-phase action. + + + Notifies the that there will be additional participants. + The phase number of the barrier in which the new participants will first participate. + The number of additional participants to add to the barrier. + The current instance has already been disposed. + + is less than 0.-or-Adding participants would cause the barrier's participant count to exceed 32,767. + The method was invoked from within a post-phase action. + + + Gets the number of the barrier's current phase. + Returns the number of the barrier's current phase. + + + Releases all resources used by the current instance of the class. + The method was invoked from within a post-phase action. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the total number of participants in the barrier. + Returns the total number of participants in the barrier. + + + Gets the number of participants in the barrier that haven’t yet signaled in the current phase. + Returns the number of participants in the barrier that haven’t yet signaled in the current phase. + + + Notifies the that there will be one less participant. + The current instance has already been disposed. + The barrier already has 0 participants.-or-The method was invoked from within a post-phase action. + + + Notifies the that there will be fewer participants. + The number of additional participants to remove from the barrier. + The current instance has already been disposed. + + is less than 0. + The barrier already has 0 participants.-or-The method was invoked from within a post-phase action. -or-current participant count is less than the specified participantCount + The total participant count is less than the specified + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well. + The current instance has already been disposed. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + If an exception is thrown from the post phase action of a Barrier after all participating threads have called SignalAndWait, the exception will be wrapped in a BarrierPostPhaseException and be thrown on all participating threads. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the timeout. + if all participants reached the barrier within the specified time; otherwise false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + If an exception is thrown from the post phase action of a Barrier after all participating threads have called SignalAndWait, the exception will be wrapped in a BarrierPostPhaseException and be thrown on all participating threads. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the timeout, while observing a cancellation token. + if all participants reached the barrier within the specified time; otherwise false + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier, while observing a cancellation token. + The to observe. + + has been canceled. + The current instance has already been disposed. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a object to measure the time interval. + true if all other participants reached the barrier; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out, or it is greater than 32,767. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a object to measure the time interval, while observing a cancellation token. + true if all other participants reached the barrier; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + The exception that is thrown when the post-phase action of a fails + + + Initializes a new instance of the class with a system-supplied message that describes the error. + + + Initializes a new instance of the class with the specified inner exception. + The exception that is the cause of the current exception. + + + Initializes a new instance of the class with a specified message that describes the error. + The message that describes the exception. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The message that describes the exception. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Represents a method to be called within a new context. + An object containing information to be used by the callback method each time it executes. + 1 + + + Represents a synchronization primitive that is signaled when its count reaches zero. + + + Initializes a new instance of class with the specified count. + The number of signals initially required to set the . + + is less than 0. + + + Increments the 's current count by one. + The current instance has already been disposed. + The current instance is already set.-or- is equal to or greater than . + + + Increments the 's current count by a specified value. + The value by which to increase . + The current instance has already been disposed. + + is less than or equal to 0. + The current instance is already set.-or- is equal to or greater than after count is incremented by + + + Gets the number of remaining signals required to set the event. + The number of remaining signals required to set the event. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the numbers of signals initially required to set the event. + The number of signals initially required to set the event. + + + Determines whether the event is set. + true if the event is set; otherwise, false. + + + Resets the to the value of . + The current instance has already been disposed.. + + + Resets the property to a specified value. + The number of signals required to set the . + The current instance has alread been disposed. + + is less than 0. + + + Registers a signal with the , decrementing the value of . + true if the signal caused the count to reach zero and the event was set; otherwise, false. + The current instance has already been disposed. + The current instance is already set. + + + Registers multiple signals with the , decrementing the value of by the specified amount. + true if the signals caused the count to reach zero and the event was set; otherwise, false. + The number of signals to register. + The current instance has already been disposed. + + is less than 1. + The current instance is already set. -or- Or is greater than . + + + Attempts to increment by one. + true if the increment succeeded; otherwise, false. If is already at zero, this method will return false. + The current instance has already been disposed. + + is equal to . + + + Attempts to increment by a specified value. + true if the increment succeeded; otherwise, false. If is already at zero this will return false. + The value by which to increase . + The current instance has already been disposed. + + is less than or equal to 0. + The current instance is already set.-or- + is equal to or greater than . + + + Blocks the current thread until the is set. + The current instance has already been disposed. + + + Blocks the current thread until the is set, using a 32-bit signed integer to measure the timeout. + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until the is set, using a 32-bit signed integer to measure the timeout, while observing a . + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until the is set, while observing a . + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + + Blocks the current thread until the is set, using a to measure the timeout. + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Blocks the current thread until the is set, using a to measure the timeout, while observing a . + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Gets a that is used to wait for the event to be set. + A that is used to wait for the event to be set. + The current instance has already been disposed. + + + Indicates whether an is reset automatically or manually after receiving a signal. + 2 + + + When signaled, the resets automatically after releasing a single thread. If no threads are waiting, the remains signaled until a thread blocks, and resets after releasing the thread. + + + When signaled, the releases all waiting threads and remains signaled until it is manually reset. + + + Represents a thread synchronization event. + 2 + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled, and whether it resets automatically or manually. + true to set the initial state to signaled; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled if created as a result of this call, whether it resets automatically or manually, and the name of a system synchronization event. + true to set the initial state to signaled if the named event is created as a result of this call; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + The name of a system-wide synchronization event. + A Win32 error occurred. + The named event exists and has access control security, but the user does not have . + The named event cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled if created as a result of this call, whether it resets automatically or manually, the name of a system synchronization event, and a Boolean variable whose value after the call indicates whether the named system event was created. + true to set the initial state to signaled if the named event is created as a result of this call; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + The name of a system-wide synchronization event. + When this method returns, contains true if a local event was created (that is, if is null or an empty string) or if the specified named system event was created; false if the specified named system event already existed. This parameter is passed uninitialized. + A Win32 error occurred. + The named event exists and has access control security, but the user does not have . + The named event cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Opens the specified named synchronization event, if it already exists. + An object that represents the named system event. + The name of the system synchronization event to open. + + is an empty string. -or- is longer than 260 characters. + + is null. + The named system event does not exist. + A Win32 error occurred. + The named event exists, but the user does not have the security access required to use it. + 1 + + + + + + Sets the state of the event to nonsignaled, causing threads to block. + true if the operation succeeds; otherwise, false. + The method was previously called on this . + 2 + + + Sets the state of the event to signaled, allowing one or more waiting threads to proceed. + true if the operation succeeds; otherwise, false. + The method was previously called on this . + 2 + + + Opens the specified named synchronization event, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named synchronization event was opened successfully; otherwise, false. + The name of the system synchronization event to open. + When this method returns, contains a object that represents the named synchronization event if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named event exists, but the user does not have the desired security access. + + + Manages the execution context for the current thread. This class cannot be inherited. + 2 + + + Captures the execution context from the current thread. + An object representing the execution context for the current thread. + 1 + + + Runs a method in a specified execution context on the current thread. + The to set. + A delegate that represents the method to be run in the provided execution context. + The object to pass to the callback method. + + is null.-or- was not acquired through a capture operation. -or- has already been used as the argument to a call. + 1 + + + + + + Provides atomic operations for variables that are shared by multiple threads. + 2 + + + Adds two 32-bit integers and replaces the first integer with the sum, as an atomic operation. + The new value stored at . + A variable containing the first value to be added. The sum of the two values is stored in . + The value to be added to the integer at . + The address of is a null pointer. + 1 + + + Adds two 64-bit integers and replaces the first integer with the sum, as an atomic operation. + The new value stored at . + A variable containing the first value to be added. The sum of the two values is stored in . + The value to be added to the integer at . + The address of is a null pointer. + 1 + + + Compares two double-precision floating point numbers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two 32-bit signed integers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two 64-bit signed integers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two platform-specific handles or pointers for equality and, if they are equal, replaces the first one. + The original value in . + The destination , whose value is compared with the value of and possibly replaced by . + The that replaces the destination value if the comparison results in equality. + The that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two objects for reference equality and, if they are equal, replaces the first object. + The original value in . + The destination object that is compared with and possibly replaced. + The object that replaces the destination object if the comparison results in equality. + The object that is compared to the object at . + The address of is a null pointer. + 1 + + + Compares two single-precision floating point numbers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two instances of the specified reference type for equality and, if they are equal, replaces the first one. + The original value in . + The destination, whose value is compared with and possibly replaced. This is a reference parameter (ref in C#, ByRef in Visual Basic). + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The type to be used for , , and . This type must be a reference type. + The address of is a null pointer. + + + Decrements a specified variable and stores the result, as an atomic operation. + The decremented value. + The variable whose value is to be decremented. + The address of is a null pointer. + 1 + + + Decrements the specified variable and stores the result, as an atomic operation. + The decremented value. + The variable whose value is to be decremented. + The address of is a null pointer. + 1 + + + Sets a double-precision floating point number to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a 32-bit signed integer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a 64-bit signed integer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a platform-specific handle or pointer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets an object to a specified value and returns a reference to the original object, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a single-precision floating point number to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a variable of the specified type to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. This is a reference parameter (ref in C#, ByRef in Visual Basic). + The value to which the parameter is set. + The type to be used for and . This type must be a reference type. + The address of is a null pointer. + + + Increments a specified variable and stores the result, as an atomic operation. + The incremented value. + The variable whose value is to be incremented. + The address of is a null pointer. + 1 + + + Increments a specified variable and stores the result, as an atomic operation. + The incremented value. + The variable whose value is to be incremented. + The address of is a null pointer. + 1 + + + Synchronizes memory access as follows: The processor that executes the current thread cannot reorder instructions in such a way that memory accesses before the call to execute after memory accesses that follow the call to . + + + Returns a 64-bit value, loaded as an atomic operation. + The loaded value. + The 64-bit value to be loaded. + 1 + + + Provides lazy initialization routines. + + + Initializes a target reference type with the type's default constructor if it hasn't already been initialized. + The initialized reference of type . + A reference of type to initialize if it has not already been initialized. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference or value type with its default constructor if it hasn't already been initialized. + The initialized value of type . + A reference or value of type to initialize if it hasn't already been initialized. + A reference to a Boolean value that determines whether the target has already been initialized. + A reference to an object used as the mutually exclusive lock for initializing . If is null, a new object will be instantiated. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference or value type by using a specified function if it hasn't already been initialized. + The initialized value of type . + A reference or value of type to initialize if it hasn't already been initialized. + A reference to a Boolean value that determines whether the target has already been initialized. + A reference to an object used as the mutually exclusive lock for initializing . If is null, a new object will be instantiated. + The function that is called to initialize the reference or value. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference type by using a specified function if it hasn't already been initialized. + The initialized value of type . + The reference of type to initialize if it hasn't already been initialized. + The function that is called to initialize the reference. + The reference type of the reference to be initialized. + Type does not have a default constructor. + + returned null (Nothing in Visual Basic). + + + The exception that is thrown when recursive entry into a lock is not compatible with the recursion policy for the lock. + 2 + + + Initializes a new instance of the class with a system-supplied message that describes the error. + 2 + + + Initializes a new instance of the class with a specified message that describes the error. + The message that describes the exception. The caller of this constructor must make sure that this string has been localized for the current system culture. + 2 + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The message that describes the exception. The caller of this constructor must make sure that this string has been localized for the current system culture. + The exception that caused the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + 2 + + + Specifies whether a lock can be entered multiple times by the same thread. + + + If a thread tries to enter a lock recursively, an exception is thrown. Some classes may allow certain recursions when this setting is in effect. + + + A thread can enter a lock recursively. Some classes may restrict this capability. + + + Notifies one or more waiting threads that an event has occurred. This class cannot be inherited. + 2 + + + Initializes a new instance of the class with a Boolean value indicating whether to set the initial state to signaled. + true to set the initial state signaled; false to set the initial state to nonsignaled. + + + Provides a slimmed down version of . + + + Initializes a new instance of the class with an initial state of nonsignaled. + + + Initializes a new instance of the class with a Boolean value indicating whether to set the intial state to signaled. + true to set the initial state signaled; false to set the initial state to nonsignaled. + + + Initializes a new instance of the class with a Boolean value indicating whether to set the intial state to signaled and a specified spin count. + true to set the initial state to signaled; false to set the initial state to nonsignaled. + The number of spin waits that will occur before falling back to a kernel-based wait operation. + + is less than 0 or greater than the maximum allowed value. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets whether the event is set. + true if the event has is set; otherwise, false. + + + Sets the state of the event to nonsignaled, which causes threads to block. + The object has already been disposed. + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed. + + + Gets the number of spin waits that will be occur before falling back to a kernel-based wait operation. + Returns the number of spin waits that will be occur before falling back to a kernel-based wait operation. + + + Blocks the current thread until the current is set. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a 32-bit signed integer to measure the time interval. + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a 32-bit signed integer to measure the time interval, while observing a . + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blocks the current thread until the current receives a signal, while observing a . + The to observe. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blocks the current thread until the current is set, using a to measure the time interval. + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a to measure the time interval, while observing a . + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Gets the underlying object for this . + The underlying event object fore this . + + + Provides a mechanism that synchronizes access to objects. + 2 + + + Acquires an exclusive lock on the specified object. + The object on which to acquire the monitor lock. + The parameter is null. + 1 + + + Acquires an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to wait. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. Note   If no exception occurs, the output of this method is always true. + The input to is true. + The parameter is null. + + + Releases an exclusive lock on the specified object. + The object on which to release the lock. + The parameter is null. + The current thread does not own the lock for the specified object. + 1 + + + Determines whether the current thread holds the lock on the specified object. + true if the current thread holds the lock on ; otherwise, false. + The object to test. + + is null. + + + Notifies a thread in the waiting queue of a change in the locked object's state. + The object a thread is waiting for. + The parameter is null. + The calling thread does not own the lock for the specified object. + 1 + + + Notifies all waiting threads of a change in the object's state. + The object that sends the pulse. + The parameter is null. + The calling thread does not own the lock for the specified object. + 1 + + + Attempts to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + The parameter is null. + 1 + + + Attempts to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + + + Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + The number of milliseconds to wait for the lock. + The parameter is null. + + is negative, and not equal to . + 1 + + + Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The number of milliseconds to wait for the lock. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + + is negative, and not equal to . + + + Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + A representing the amount of time to wait for the lock. A value of –1 millisecond specifies an infinite wait. + The parameter is null. + The value of in milliseconds is negative and is not equal to (–1 millisecond), or is greater than . + 1 + + + Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The amount of time to wait for the lock. A value of –1 millisecond specifies an infinite wait. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + The value of in milliseconds is negative and is not equal to (–1 millisecond), or is greater than . + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. + true if the call returned because the caller reacquired the lock for the specified object. This method does not return if the lock is not reacquired. + The object on which to wait. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + 1 + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. If the specified time-out interval elapses, the thread enters the ready queue. + true if the lock was reacquired before the specified time elapsed; false if the lock was reacquired after the specified time elapsed. The method does not return until the lock is reacquired. + The object on which to wait. + The number of milliseconds to wait before the thread enters the ready queue. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + The value of the parameter is negative, and is not equal to . + 1 + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. If the specified time-out interval elapses, the thread enters the ready queue. + true if the lock was reacquired before the specified time elapsed; false if the lock was reacquired after the specified time elapsed. The method does not return until the lock is reacquired. + The object on which to wait. + A representing the amount of time to wait before the thread enters the ready queue. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + The value of the parameter in milliseconds is negative and does not represent (–1 millisecond), or is greater than . + 1 + + + A synchronization primitive that can also be used for interprocess synchronization. + 1 + + + Initializes a new instance of the class with default properties. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex. + true to give the calling thread initial ownership of the mutex; otherwise, false. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex. + true to give the calling thread initial ownership of the named system mutex if the named system mutex is created as a result of this call; otherwise, false. + The name of the . If the value is null, the is unnamed. + The named mutex exists and has access control security, but the user does not have . + A Win32 error occurred. + The named mutex cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex. + true to give the calling thread initial ownership of the named system mutex if the named system mutex is created as a result of this call; otherwise, false. + The name of the . If the value is null, the is unnamed. + When this method returns, contains a Boolean that is true if a local mutex was created (that is, if is null or an empty string) or if the specified named system mutex was created; false if the specified named system mutex already existed. This parameter is passed uninitialized. + The named mutex exists and has access control security, but the user does not have . + A Win32 error occurred. + The named mutex cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Opens the specified named mutex, if it already exists. + An object that represents the named system mutex. + The name of the system mutex to open. + + is an empty string.-or- is longer than 260 characters. + + is null. + The named mutex does not exist. + A Win32 error occurred. + The named mutex exists, but the user does not have the security access required to use it. + 1 + + + + + + Releases the once. + The calling thread does not own the mutex. + 1 + + + Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named mutex was opened successfully; otherwise, false. + The name of the system mutex to open. + When this method returns, contains a object that represents the named mutex if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named mutex exists, but the user does not have the security access required to use it. + + + Represents a lock that is used to manage access to a resource, allowing multiple threads for reading or exclusive access for writing. + + + Initializes a new instance of the class with default property values. + + + Initializes a new instance of the class, specifying the lock recursion policy. + One of the enumeration values that specifies the lock recursion policy. + + + Gets the total number of unique threads that have entered the lock in read mode. + The number of unique threads that have entered the lock in read mode. + + + Releases all resources used by the current instance of the class. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Tries to enter the lock in read mode. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter. This limit is so large that applications should never encounter it. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The object has been disposed. + + + Tries to enter the lock in write mode. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The object has been disposed. + + + Reduces the recursion count for read mode, and exits read mode if the resulting count is 0 (zero). + The current thread has not entered the lock in read mode. + + + Reduces the recursion count for upgradeable mode, and exits upgradeable mode if the resulting count is 0 (zero). + The current thread has not entered the lock in upgradeable mode. + + + Reduces the recursion count for write mode, and exits write mode if the resulting count is 0 (zero). + The current thread has not entered the lock in write mode. + + + Gets a value that indicates whether the current thread has entered the lock in read mode. + true if the current thread has entered read mode; otherwise, false. + 2 + + + Gets a value that indicates whether the current thread has entered the lock in upgradeable mode. + true if the current thread has entered upgradeable mode; otherwise, false. + 2 + + + Gets a value that indicates whether the current thread has entered the lock in write mode. + true if the current thread has entered write mode; otherwise, false. + 2 + + + Gets a value that indicates the recursion policy for the current object. + One of the enumeration values that specifies the lock recursion policy. + + + Gets the number of times the current thread has entered the lock in read mode, as an indication of recursion. + 0 (zero) if the current thread has not entered read mode, 1 if the thread has entered read mode but has not entered it recursively, or n if the thread has entered the lock recursively n - 1 times. + 2 + + + Gets the number of times the current thread has entered the lock in upgradeable mode, as an indication of recursion. + 0 if the current thread has not entered upgradeable mode, 1 if the thread has entered upgradeable mode but has not entered it recursively, or n if the thread has entered upgradeable mode recursively n - 1 times. + 2 + + + Gets the number of times the current thread has entered the lock in write mode, as an indication of recursion. + 0 if the current thread has not entered write mode, 1 if the thread has entered write mode but has not entered it recursively, or n if the thread has entered write mode recursively n - 1 times. + 2 + + + Tries to enter the lock in read mode, with an optional integer time-out. + true if the calling thread entered read mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in read mode, with an optional time-out. + true if the calling thread entered read mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode, with an optional time-out. + true if the calling thread entered upgradeable mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode, with an optional time-out. + true if the calling thread entered upgradeable mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Tries to enter the lock in write mode, with an optional time-out. + true if the calling thread entered write mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in write mode, with an optional time-out. + true if the calling thread entered write mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Gets the total number of threads that are waiting to enter the lock in read mode. + The total number of threads that are waiting to enter read mode. + 2 + + + Gets the total number of threads that are waiting to enter the lock in upgradeable mode. + The total number of threads that are waiting to enter upgradeable mode. + 2 + + + Gets the total number of threads that are waiting to enter the lock in write mode. + The total number of threads that are waiting to enter write mode. + 2 + + + Limits the number of threads that can access a resource or pool of resources concurrently. + 1 + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + + is greater than . + + is less than 1.-or- is less than 0. + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries, and optionally specifying the name of a system semaphore object. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + The name of a named system semaphore object. + + is greater than .-or- is longer than 260 characters. + + is less than 1.-or- is less than 0. + A Win32 error occurred. + The named semaphore exists and has access control security, and the user does not have . + The named semaphore cannot be created, perhaps because a wait handle of a different type has the same name. + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, and specifying a variable that receives a value indicating whether a new system semaphore was created. + The initial number of requests for the semaphore that can be satisfied concurrently. + The maximum number of requests for the semaphore that can be satisfied concurrently. + The name of a named system semaphore object. + When this method returns, contains true if a local semaphore was created (that is, if is null or an empty string) or if the specified named system semaphore was created; false if the specified named system semaphore already existed. This parameter is passed uninitialized. + + is greater than . -or- is longer than 260 characters. + + is less than 1.-or- is less than 0. + A Win32 error occurred. + The named semaphore exists and has access control security, and the user does not have . + The named semaphore cannot be created, perhaps because a wait handle of a different type has the same name. + + + Opens the specified named semaphore, if it already exists. + An object that represents the named system semaphore. + The name of the system semaphore to open. + + is an empty string.-or- is longer than 260 characters. + + is null. + The named semaphore does not exist. + A Win32 error occurred. + The named semaphore exists, but the user does not have the security access required to use it. + 1 + + + + + + Exits the semaphore and returns the previous count. + The count on the semaphore before the method was called. + The semaphore count is already at the maximum value. + A Win32 error occurred with a named semaphore. + The current semaphore represents a named system semaphore, but the user does not have .-or-The current semaphore represents a named system semaphore, but it was not opened with . + 1 + + + Exits the semaphore a specified number of times and returns the previous count. + The count on the semaphore before the method was called. + The number of times to exit the semaphore. + + is less than 1. + The semaphore count is already at the maximum value. + A Win32 error occurred with a named semaphore. + The current semaphore represents a named system semaphore, but the user does not have rights.-or-The current semaphore represents a named system semaphore, but it was not opened with rights. + 1 + + + Opens the specified named semaphore, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named semaphore was opened successfully; otherwise, false. + The name of the system semaphore to open. + When this method returns, contains a object that represents the named semaphore if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named semaphore exists, but the user does not have the security access required to use it. + + + The exception that is thrown when the method is called on a semaphore whose count is already at the maximum. + 2 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Represents a lightweight alternative to that limits the number of threads that can access a resource or pool of resources concurrently. + + + Initializes a new instance of the class, specifying the initial number of requests that can be granted concurrently. + The initial number of requests for the semaphore that can be granted concurrently. + + is less than 0. + + + Initializes a new instance of the class, specifying the initial and maximum number of requests that can be granted concurrently. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + + is less than 0, or is greater than , or is equal to or less than 0. + + + Returns a that can be used to wait on the semaphore. + A that can be used to wait on the semaphore. + The has been disposed. + + + Gets the number of remaining threads that can enter the object. + The number of remaining threads that can enter the semaphore. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Releases the object once. + The previous count of the . + The current instance has already been disposed. + The has already reached its maximum size. + + + Releases the object a specified number of times. + The previous count of the . + The number of times to exit the semaphore. + The current instance has already been disposed. + + is less than 1. + The has already reached its maximum size. + + + Blocks the current thread until it can enter the . + The current instance has already been disposed. + + + Blocks the current thread until it can enter the , using a 32-bit signed integer that specifies the timeout. + true if the current thread successfully entered the ; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until it can enter the , using a 32-bit signed integer that specifies the timeout, while observing a . + true if the current thread successfully entered the ; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The instance has been disposed, or the that created has been disposed. + + + Blocks the current thread until it can enter the , while observing a . + The token to observe. + + was canceled. + The current instance has already been disposed.-or-The that created has already been disposed. + + + Blocks the current thread until it can enter the , using a to specify the timeout. + true if the current thread successfully entered the ; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + The semaphoreSlim instance has been disposed + + + Blocks the current thread until it can enter the , using a that specifies the timeout, while observing a . + true if the current thread successfully entered the ; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + The semaphoreSlim instance has been disposedThe that created has already been disposed. + + + Asynchronously waits to enter the . + A task that will complete when the semaphore has been entered. + + + Asynchronously waits to enter the , using a 32-bit signed integer to measure the time interval. + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Asynchronously waits to enter the , using a 32-bit signed integer to measure the time interval, while observing a . + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + is a negative number other than -1, which represents an infinite time-out. + The current instance has already been disposed. + + was canceled. + + + Asynchronously waits to enter the , while observing a . + A task that will complete when the semaphore has been entered. + The token to observe. + The current instance has already been disposed. + + was canceled. + + + Asynchronously waits to enter the , using a to measure the time interval. + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out -or- timeout is greater than . + + + Asynchronously waits to enter the , using a to measure the time interval, while observing a . + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The token to observe. + + is a negative number other than -1, which represents an infinite time-out-or-timeout is greater than . + + was canceled. + + + Represents a method to be called when a message is to be dispatched to a synchronization context. + The object passed to the delegate. + 2 + + + Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop repeatedly checking until the lock becomes available. + + + Initializes a new instance of the structure with the option to track thread IDs to improve debugging. + Whether to capture and use thread IDs for debugging purposes. + + + Acquires the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + The argument must be initialized to false prior to calling Enter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Releases the lock. + Thread ownership tracking is enabled, and the current thread is not the owner of this lock. + + + Releases the lock. + A Boolean value that indicates whether a memory fence should be issued in order to immediately publish the exit operation to other threads. + Thread ownership tracking is enabled, and the current thread is not the owner of this lock. + + + Gets whether the lock is currently held by any thread. + true if the lock is currently held by any thread; otherwise false. + + + Gets whether the lock is held by the current thread. + true if the lock is held by the current thread; otherwise false. + Thread ownership tracking is disabled. + + + Gets whether thread ownership tracking is enabled for this instance. + true if thread ownership tracking is enabled for this instance; otherwise false. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + is a negative number other than -1, which represents an infinite time-out. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than milliseconds. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Provides support for spin-based waiting. + + + Gets the number of times has been called on this instance. + Returns an integer that represents the number of times has been called on this instance. + + + Gets whether the next call to will yield the processor, triggering a forced context switch. + Whether the next call to will yield the processor, triggering a forced context switch. + + + Resets the spin counter. + + + Performs a single spin. + + + Spins until the specified condition is satisfied. + A delegate to be executed over and over until it returns true. + The argument is null. + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + True if the condition is satisfied within the timeout; otherwise, false + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The argument is null. + + is a negative number other than -1, which represents an infinite time-out. + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + True if the condition is satisfied within the timeout; otherwise, false + A delegate to be executed over and over until it returns true. + A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. + The argument is null. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Provides the basic functionality for propagating a synchronization context in various synchronization models. + 2 + + + Creates a new instance of the class. + + + When overridden in a derived class, creates a copy of the synchronization context. + A new object. + 2 + + + Gets the synchronization context for the current thread. + A object representing the current synchronization context. + 1 + + + When overridden in a derived class, responds to the notification that an operation has completed. + + + When overridden in a derived class, responds to the notification that an operation has started. + + + When overridden in a derived class, dispatches an asynchronous message to a synchronization context. + The delegate to call. + The object passed to the delegate. + 2 + + + When overridden in a derived class, dispatches a synchronous message to a synchronization context. + The delegate to call. + The object passed to the delegate. + The method was called in a Windows Store app. The implementation of for Windows Store apps does not support the method. + 2 + + + Sets the current synchronization context. + The object to be set. + 1 + + + + + + The exception that is thrown when a method requires the caller to own the lock on a given Monitor, and the method is invoked by a caller that does not own that lock. + 2 + + + Initializes a new instance of the class with default properties. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Provides thread-local storage of data. + Specifies the type of data stored per-thread. + + + Initializes the instance. + + + Initializes the instance. + Whether to track all values set on the instance and expose them through the property. + + + Initializes the instance with the specified function. + The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. + + is a null reference (Nothing in Visual Basic). + + + Initializes the instance with the specified function. + The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. + Whether to track all values set on the instance and expose them via the property. + + is a null reference (Nothing in Visual Basic). + + + Releases all resources used by the current instance of the class. + + + Releases the resources used by this instance. + A Boolean value that indicates whether this method is being called due to a call to . + + + Releases the resources used by this instance. + + + Gets whether is initialized on the current thread. + true if is initialized on the current thread; otherwise false. + The instance has been disposed. + + + Creates and returns a string representation of this instance for the current thread. + The result of calling on the . + The instance has been disposed. + The for the current thread is a null reference (Nothing in Visual Basic). + The initialization function attempted to reference recursively. + No default constructor is provided and no value factory is supplied. + + + Gets or sets the value of this instance for the current thread. + Returns an instance of the object that this ThreadLocal is responsible for initializing. + The instance has been disposed. + The initialization function attempted to reference recursively. + No default constructor is provided and no value factory is supplied. + + + Gets a list for all of the values currently stored by all of the threads that have accessed this instance. + A list for all of the values currently stored by all of the threads that have accessed this instance. + The instance has been disposed. + + + Contains methods for performing volatile memory operations. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the object reference from the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The reference to that was read. This reference is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + The type of field to read. This must be a reference type, not a value type. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a memory operation appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified object reference to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the object reference is written. + The object reference to write. The reference is written immediately so that it is visible to all processors in the computer. + The type of field to write. This must be a reference type, not a value type. + + + The exception that is thrown when an attempt is made to open a system mutex or semaphore that does not exist. + 2 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/de/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/de/System.Threading.xml new file mode 100644 index 000000000..4fb943bbf --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/de/System.Threading.xml @@ -0,0 +1,1799 @@ + + + + System.Threading + + + + Die Ausnahme, die ausgelöst wird, wenn ein Thread ein -Objekt abruft, das von einem anderen Thread abgebrochen wurde, indem das Objekt beim Beenden nicht freigegeben wurde. + 1 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einem festgelegten Index für den abgebrochenen Mutex (falls zutreffend) und einem -Objekt, das den Mutex darstellt. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung und einer festgelegten inneren Ausnahme. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung, der inneren Ausnahme, dem Index für den abgebrochenen Mutex (falls zutreffend) und einem -Objekt, das den Mutex darstellt. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung, dem Index des abgebrochenen Mutex (falls zutreffend) und dem abgebrochenen Mutex. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Ruft den abgebrochenen Mutex ab, das die Ausnahme verursacht hat (falls bekannt). + Ein -Objekt, das den abgebrochenen Mutex darstellt, oder null, wenn der abgebrochene Mutex nicht bestimmt werden konnte. + 1 + + + Ruft den Index des abgebrochenen Mutex ab, der die Ausnahme verursacht hat (falls bekannt). + Der Index des -Objekts, das der abgebrochene Mutex darstellt, im Array von WaitHandles, die an die -Methode übergeben wurden, oder -1, wenn der Index des abgebrochenen Mutex nicht bestimmt werden konnte. + 1 + + + Stellt Umgebungsdaten dar, die für eine angegebene asynchrone Ablaufsteuerung lokal sind, wie etwa eine asynchrone Methode. + Der Typ der Umgebungsdaten. + + + Instanziiert eine -Instanz, die keine Änderungsbenachrichtigungen empfängt. + + + Instanziiert eine lokale -Instanz, die Änderungsbenachrichtigungen empfängt. + Der Delegat, der aufgerufen wird, wenn sich der aktuelle Wert auf einem beliebigen Thread ändert. + + + Ruft den Wert der Umgebungsdaten ab oder legt ihn fest. + Der Wert der Umgebungsdaten. + + + Die Klasse, die -Instanzen, die sich für Änderungsbenachrichtigungen registrieren, Informationen über Datenänderungen zur Verfügung stellt. + Der Typ der Daten. + + + Ruft den aktuellen Wert der Daten ab. + Der aktuelle Wert der Daten. + + + Ruft den vorherigen Wert der Daten ab. + Der vorherige Wert der Daten. + + + Gibt einen Wert zurück, der angibt, ob sich der Wert aufgrund einer Änderung des Ausführungskontexts ändert. + true, wenn sich der Wert aufgrund einer Änderung des Ausführungstexts ändert, andernfalls false. + + + Benachrichtigt einen wartenden Thread über das Eintreten eines Ereignisses.Diese Klasse kann nicht vererbt werden. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf „signalisiert“ festgelegt werden soll. + true, wenn der anfängliche Zustand auf „signalisiert“ festgelegt werden soll. false, wenn der anfängliche Zustand auf „nicht signalisiert“ festgelegt werden soll. + + + Ermöglicht es mehreren Aufgaben, parallel über mehrere Phasen gemeinsam an einem Algorithmus zu arbeiten. + + + Initialisiert eine neue Instanz der -Klasse. + Die Anzahl teilnehmender Threads. + + ist kleiner als 0 oder größer als 32,767. + + + Initialisiert eine neue Instanz der -Klasse. + Die Anzahl teilnehmender Threads. + + , die nach jeder Phase ausgeführt wird. NULL (Nothing in Visual Basic) wird möglicherweise übergeben, um keine Aktion anzugeben. + + ist kleiner als 0 oder größer als 32,767. + + + Benachrichtigt über das Vorhandensein eines weiteren Teilnehmers. + Die Phasennummer der Grenze, an der die neuen Teilnehmer zuerst teilnehmen. + Die aktuelle Instanz wurde bereits freigegeben. + Einen Teilnehmer hinzuzufügen würde verursachen, dass die Teilnehmeranzahl der Barriere 32.767 überschreitet.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Benachrichtigt über das Vorhandensein weiterer Teilnehmer. + Die Phasennummer der Grenze, an der die neuen Teilnehmer zuerst teilnehmen. + Die Anzahl zusätzlicher Teilnehmer, die der Grenze hinzugefügt werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0.– oder –-Teilnehmer hinzuzufügen würde verursachen, dass die Teilnehmeranzahl der Barriere 32.767 überschreitet. + Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Ruft die Nummer der aktuellen Phase der Grenze ab. + Gibt die Nummer der aktuellen Phase der Grenze zurück. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + True, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft die Gesamtanzahl von Teilnehmern für die Grenze ab. + Gibt die Gesamtanzahl von Teilnehmern für die Grenze zurück. + + + Ruft die Anzahl von Teilnehmern für die Grenze ab, die in der aktuellen Phase noch nicht signalisiert haben. + Gibt die Anzahl von Teilnehmern für die Grenze zurück, die in der aktuellen Phase noch nicht signalisiert haben. + + + Benachrichtigt , dass ein Teilnehmer nicht mehr vorhanden ist. + Die aktuelle Instanz wurde bereits freigegeben. + Die Barriere hat bereits 0 Teilnehmer.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Benachrichtigt über die geringere Anzahl von Teilnehmern. + Die Anzahl zusätzlicher Teilnehmer, die aus der Grenze entfernt werden sollen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0. + Die Barriere hat bereits 0 Teilnehmer.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. – oder –aktuelle Teilnehmeranzahl ist kleiner als der angegebene participantCount + Die gesamte Teilnehmeranzahl ist kleiner als der angegebene + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. + Die aktuelle Instanz wurde bereits freigegeben. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + Wenn eine Ausnahme aus der Post-Phasenaktion einer Grenze ausgelöst wird, nachdem alle teilnehmenden Threads SignalAndWait aufgerufen haben, wird die Ausnahme in einer BarrierPostPhaseException umbrochen und für alle teilnehmenden Threads ausgelöst. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet. + wenn alle Teilnehmer die Grenze innerhalb der angegebenen Zeit erreicht haben, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + Wenn eine Ausnahme aus der Post-Phasenaktion einer Grenze ausgelöst wird, nachdem alle teilnehmenden Threads SignalAndWait aufgerufen haben, wird die Ausnahme in einer BarrierPostPhaseException umbrochen und für alle teilnehmenden Threads ausgelöst. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet und ein Abbruchtoken berücksichtigt. + wenn alle Teilnehmer die Grenze innerhalb der angegebenen Zeit erreicht haben, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere erreichen. Dabei wird ein Abbruchtoken überwacht. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird das Zeitintervall mit einem -Objekt gemessen. + True, wenn alle anderen Teilnehmer die Grenze erreicht haben, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, oder er ist größer als 32.767. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird das Zeitintervall mit einem -Objekt gemessen und ein Abbruchtoken berücksichtigt. + True, wenn alle anderen Teilnehmer die Grenze erreicht haben, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1 Millisekunde. Ein Wert von -1 Millisekunde gibt einen unendlichen Timeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Die Ausnahme, die bei einem Fehler der Nachphasenaktion einer ausgelöst wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer vom System generierten Meldung, die den Fehler beschreibt. + + + Initialisiert eine neue Instanz der -Klasse mit der angegebenen internen Ausnahme. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Meldung, die den Fehler beschreibt. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Stellt eine Methode dar, die in einem neuen Kontext aufgerufen werden muss. + Ein Objekt mit den Informationen, die von der Rückrufmethode bei jeder Ausführung verwendet werden. + 1 + + + Stellt einen Synchronisierungsprimitiven dar, der signalisiert wird, wenn seine Anzahl 0 (null) erreicht. + + + Initialisiert eine neue Instanz der -Klasse mit der angegebenen Anzahl. + Die zum Festlegen von ursprünglich erforderliche Anzahl von Signalen. + + ist kleiner als 0. + + + Erhöht die aktuelle Anzahl von um 1. + Die aktuelle Instanz wurde bereits freigegeben. + Die aktuelle Instanz ist bereits festgelegt.– oder – ist größer oder gleich . + + + Erhöht die aktuelle Anzahl von um einen angegebenen Wert. + Der Wert, um den erhöht werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner oder gleich 0. + Die aktuelle Instanz ist bereits festgelegt.– oder – ist größer gleich , nach die Anzahl schrittweise durch erhöht wird. + + + Ruft die Anzahl verbleibender Signale ab, die zum Festlegen des Ereignisses erforderlich sind. + Die Anzahl verbleibender Signale, die zum Festlegen des Ereignisses erforderlich sind. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + True, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft die Anzahl von Signalen ab, die ursprünglich zum Festlegen des Ereignisses erforderlich waren. + Die Anzahl von Signalen, die ursprünglich zum Festlegen des Ereignisses erforderlich waren. + + + Bestimmt, ob das Ereignis festgelegt wurde. + True, wenn das Ereignis festgelegt wurde, andernfalls false. + + + Setzt auf den Wert von zurück. + Die aktuelle Instanz wurde bereits freigegeben. + + + Setzt die -Eigenschaft auf einen angegebenen Wert zurück. + Die zum Festlegen von erforderliche Anzahl von Signalen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0. + + + Registriert ein Signal beim und dekrementiert den Wert von . + True, wenn die Anzahl aufgrund des Signals 0 (null) erreicht hat und das Ereignis festgelegt wurde, andernfalls false. + Die aktuelle Instanz wurde bereits freigegeben. + Die aktuelle Instanz ist bereits festgelegt. + + + Registriert mehrere Signale bei und verringert den Wert von um den angegebenen Wert. + True, wenn die Anzahl aufgrund der Signale 0 (null) erreicht hat und das Ereignis festgelegt wurde, andernfalls false. + Die Anzahl zu registrierender Signale. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 1. + Die aktuelle Instanz ist bereits festgelegt. -oder- ist größer als . + + + Versucht, um eins zu inkrementieren. + True, wenn die Anzahl erfolgreich erhöht wurde, andernfalls false.Wenn bereits 0 (null) ist, gibt diese Methode false zurück. + Die aktuelle Instanz wurde bereits freigegeben. + + ist gleich . + + + Versucht, durch einen angegebenen Wert zu inkrementieren. + True, wenn die Anzahl erfolgreich erhöht wurde, andernfalls false.Wenn bereits 0 (null) ist, wird false zurückgegeben. + Der Wert, um den erhöht werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner oder gleich 0. + Die aktuelle Instanz ist bereits festgelegt.– oder – + ist gleich oder größer als . + + + Blockiert den aktuellen Thread, bis festgelegt wird. + Die aktuelle Instanz wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet wird. + True, wenn festgelegt wurde, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet und ein überwacht wird. + True, wenn festgelegt wurde, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein überwacht wird. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein zum Messen des Timeouts verwendet wird. + True, wenn festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein zum Messen des Zeitintervalls verwendet und ein überwacht wird. + True, wenn festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Ruft ein ab, das verwendet wird, um auf das festzulegende Ereignis zu warten. + Ein , das verwendet wird, um auf das festzulegende Ereignis zu warten. + Die aktuelle Instanz wurde bereits freigegeben. + + + Gibt an, ob eine -Klasse nach dem Empfangen eines Signals automatisch oder manuell zurückgesetzt wird. + 2 + + + Bei Signalisierung wird die -Methode automatisch nach der Freigabe eines einzigen Threads zurückgesetzt.Wenn sich keine Threads in der Warteschlange befinden, bleibt die -Methode solange signalisiert, bis ein Thread blockiert wird. Sie wird zurückgesetzt, nachdem der Thread freigegeben wurde. + + + Bei Signalisierung gibt die -Methode alle wartenden Threads frei. Sie bleibt solange signalisiert, bis sie manuell zurückgesetzt wird. + + + Stellt ein Threadsynchronisierungsereignis dar. + 2 + + + Initialisiert eine neue Instanz der -Klasse und gibt an, ob das WaitHandle anfänglich signalisiert ist und ob es automatisch oder manuell zurückgesetzt wird. + true, wenn der anfängliche Zustand auf signalisiert festgelegt werden soll. false, wenn er auf nicht signalisiert festgelegt werden soll. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + + + Initialisiert eine neue Instanz der -Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses an. + true, um den anfänglichen Zustand auf signalisiert festzulegen, wenn das benannte Ereignis als Ergebnis dieses Aufrufs erstellt wird; false, um den Zustand auf nicht signalisiert festzulegen. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + Der Name eines systemweiten Synchronisierungsereignisses. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Ereignis kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Initialisiert eine neue Instanz der -Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, und ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses und eine boolesche Variable an, deren Wert nach dem Aufruf angibt, ob das benannte Systemereignis erstellt wurde. + true, um den anfänglichen Zustand auf signalisiert festzulegen, wenn das benannte Ereignis als Ergebnis dieses Aufrufs erstellt wird; false, um den Zustand auf nicht signalisiert festzulegen. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + Der Name eines systemweiten Synchronisierungsereignisses. + Enthält nach dem Beenden dieser Methode den Wert true, wenn ein lokales Ereignis erstellt wurde (d. h., wenn gleich null oder eine leere Zeichenfolge ist) oder wenn das angegebene benannte Systemereignis erstellt wurde. Der Wert ist false, wenn das angegebene benannte Systemsereignis bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Ereignis kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist. + Ein Objekt, das das benannte Systemereignis darstellt. + Der Name eines systemweiten Synchronisierungsereignisses, das zu öffnen ist. + + ist eine leere Zeichenfolge. - oder - ist länger als 260 Zeichen. + + ist null. + Das benannte Systemereignis ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Legt den Zustand des Ereignisses auf nicht signalisiert fest, sodass Threads blockiert werden. + true, wenn die Operation erfolgreich ausgeführt wird, andernfalls false. + Die -Methode wurde zuvor für dieses aufgerufen. + 2 + + + Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren. + true, wenn die Operation erfolgreich ausgeführt wird, andernfalls false. + Die -Methode wurde zuvor für dieses aufgerufen. + 2 + + + Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn das benannte Synchronisierungsereignis erfolgreich geöffnet wurde; andernfalls false. + Der Name eines systemweiten Synchronisierungsereignisses, das zu öffnen ist. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Synchronisierungsereignis darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden, der Benutzer verfügt jedoch nicht über den gewünschten Sicherheitszugriff. + + + Verwaltet den Ausführungskontext für den aktuellen Thread.Diese Klasse kann nicht vererbt werden. + 2 + + + Zeichnet den Ausführungskontext des aktuellen Threads auf. + Ein -Objekt, das den Ausführungskontext für den aktuellen Thread darstellt. + 1 + + + Führt für den aktuellen Thread eine Methode in einem angegebenen Ausführungskontext aus. + Der festzulegende . + Ein -Delegat, der die im bereitgestellten Ausführungskontext auszuführende Methode darstellt. + Das Objekt, das an die Rückrufmethode übergeben werden soll. + + ist null.– oder – wurde nicht durch einen Aufzeichnungsvorgang ermittelt. – oder – wurde bereits als Argument für einen Aufruf von verwendet. + 1 + + + + + + Stellt atomare Operationen für Variablen bereit, die von mehreren Threads gemeinsam genutzt werden. + 2 + + + Fügt in einer atomaren Operation zwei 32-Bit-Ganzzahlen hinzu und ersetzt die erste Ganzzahl durch die Summe. + Der unter gespeicherte neue Wert. + Eine Variable, die den ersten Wert enthält, der hinzugefügt werden soll.Die Summe der beiden Werte wird in gespeichert. + Der Wert, der der Ganzzahl in hinzugefügt werden soll. + The address of is a null pointer. + 1 + + + Fügt in einer atomaren Operation zwei 64-Bit-Ganzzahlen hinzu und ersetzt die erste Ganzzahl durch die Summe. + Der unter gespeicherte neue Wert. + Eine Variable, die den ersten Wert enthält, der hinzugefügt werden soll.Die Summe der beiden Werte wird in gespeichert. + Der Wert, der der Ganzzahl in hinzugefügt werden soll. + The address of is a null pointer. + 1 + + + Vergleicht zwei Gleitkommazahlen mit doppelter Genauigkeit hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei 32-Bit-Ganzzahlen mit Vorzeichen hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei 64-Bit-Ganzzahlen mit Vorzeichen hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei plattformspezifische Handles oder Zeiger hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten. + Der ursprüngliche Wert in . + Der Ziel-, dessen Wert mit dem Wert von verglichen und möglicherweise durch ersetzt wird. + Der , der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der , der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Objekte hinsichtlich ihrer Verweisgleichheit und ersetzt bei vorliegender Gleichheit das erste Objekt. + Der ursprüngliche Wert in . + Das Zielobjekt, das mit verglichen und möglicherweise ersetzt wird. + Das Objekt, das das Zielobjekt ersetzt, wenn beim Vergleich Gleichheit festgestellt wird. + Das Objekt, das mit dem Objekt in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Gleitkommazahlen mit einfacher Genauigkeit hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Instanzen des angegebenen Referenztyps hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit die erste. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird.Dies ist ein Verweisparameter (ref in C#, ByRef in Visual Basic). + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + Der Typ, der für , und verwendet werden soll.Dieser Typ muss ein Referenztyp sein. + The address of is a null pointer. + + + Dekrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der dekrementierte Wert. + Die Variable, deren Wert dekrementiert werden soll. + The address of is a null pointer. + 1 + + + Dekrementiert den Wert der angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der dekrementierte Wert. + Die Variable, deren Wert dekrementiert werden soll. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation eine Gleitkommazahl mit doppelter Genauigkeit auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine 32-Bit-Ganzzahl mit Vorzeichen in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine 64-Bit-Ganzzahl mit Vorzeichen in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation ein plattformspezifisches Handle bzw. einen plattformspezifischen Zeiger auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation ein Objekt auf einen angegebenen Wert fest und gibt einen Verweis auf das ursprüngliche Objekt zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation eine Gleitkommazahl mit einfacher Genauigkeit auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine Variable vom angegebenen Typ in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll.Dies ist ein Verweisparameter (ref in C#, ByRef in Visual Basic). + Der Wert, auf den der -Parameter festgelegt ist. + Der Typ, der für und verwendet werden soll.Dieser Typ muss ein Referenztyp sein. + The address of is a null pointer. + + + Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der inkrementierte Wert. + Die Variable, deren Wert inkrementiert werden soll. + The address of is a null pointer. + 1 + + + Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der inkrementierte Wert. + Die Variable, deren Wert inkrementiert werden soll. + The address of is a null pointer. + 1 + + + Synchronisiert den Speicherzugriff wie folgt: Der Prozessor, der den aktuellen Thread ausführt, kann Anweisungen nicht so neu anordnen, dass Speicherzugriffe vor dem Aufruf von nach Speicherzugriffen ausgeführt werden, die nach dem Aufruf von erfolgen. + + + Gibt einen 64-Bit-Wert zurück, der in einer atomaren Operation geladen wird. + Der geladene Wert. + Der zu ladende 64-Bit-Wert. + 1 + + + Stellt verzögerte Initialisierungsroutinen bereit. + + + Initialisiert einen Zielverweistyp mit seinem Standardkonstruktor, wenn er noch nicht initialisiert wurde. + Der initialisierte Verweis vom Typ . + Ein Verweis vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweis- oder Werttyp mit seinem Standardkonstruktor, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Ein Verweis oder Wert vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Ein Verweis auf einen booleschen Wert, der bestimmt, ob das Ziel bereits initialisiert wurde. + Ein Verweis auf ein Objekt, das für die Initialisierung von als sich gegenseitig ausschließende Sperre verwendet wird.Wenn null ist, wird ein neues Objekt instanziiert. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweis- oder Werttyp mit einer angegebenen Funktion, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Ein Verweis oder Wert vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Ein Verweis auf einen booleschen Wert, der bestimmt, ob das Ziel bereits initialisiert wurde. + Ein Verweis auf ein Objekt, das für die Initialisierung von als sich gegenseitig ausschließende Sperre verwendet wird.Wenn null ist, wird ein neues Objekt instanziiert. + Die Funktion, die aufgerufen wird, um den Verweis oder den Wert zu initialisieren. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweistyp mit einer angegebenen Funktion, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Der Verweis vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Die Funktion, die aufgerufen wird, um den Verweis zu initialisieren. + Der Verweistyp des zu initialisierenden Verweises. + Der Typ besitzt keinen Standardkonstruktor. + + gibt null (Nothing in Visual Basic) zurück. + + + Die Ausnahme, die ausgelöst wird, wenn die rekursive Anforderung einer Sperre nicht mit der Rekursionsrichtlinie der Sperre kompatibel ist. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer vom System generierten Meldung, die den Fehler beschreibt. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Meldung, die den Fehler beschreibt. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die aktuelle Ausnahme verursacht hat.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + 2 + + + Gibt an, ob eine Sperre mehrmals dem gleichen Thread zugewiesen werden kann. + + + Wenn ein Thread rekursiv versucht, eine Sperre zu erhalten, wird eine Ausnahme ausgelöst.Einige Klassen gestatten gewisse Rekursionen, wenn diese Einstellung aktiv ist. + + + Ein Thread kann rekursiv eine Sperre erhalten.Einige Klassen beschränken diese Möglichkeit einer rekursiven Zuweisung. + + + Benachrichtigt einen oder mehrere wartende Threads über das Eintreten eines Ereignisses.Diese Klasse kann nicht vererbt werden. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf signalisiert festgelegt werden soll. + true, wenn der anfängliche Zustand auf signalisiert festgelegt werden soll, false, wenn der anfängliche Zustand auf nicht signalisiert festgelegt werden soll. + + + Stellt eine verschlankte Version von bereit. + + + Initialisiert eine neue Instanz der -Klasse mit dem Anfangszustand „nicht signalisiert“. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der Anfangszustand auf „signalisiert“ festgelegt werden soll. + True, um den Anfangszustand auf „signalisiert“ festzulegen, false um den Anfangszustand auf „nicht signalisiert“ festzulegen. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der Anfangszustand auf „signalisiert“ festgelegt werden soll, und einer festgelegten Spin-Anzahl. + True, um den Anfangszustand auf "signalisiert" festzulegen, false um den Anfangszustand auf "nicht signalisiert" festzulegen. + Die Anzahl von Spin-Wartevorgängen, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + + is less than 0 or greater than the maximum allowed value. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft einen Wert ab, der angibt, ob das Ereignis festgelegt wurde. + True, wenn das Ereignis festgelegt wurde, andernfalls false. + + + Legt den Zustand des Ereignisses auf „nicht signalisiert“ fest, sodass Threads blockiert werden. + The object has already been disposed. + + + Legt den Zustand des Ereignisses auf „signalisiert“ fest und ermöglicht so die weitere Ausführung eines oder mehrerer wartender Threads. + + + Ruft die Anzahl von Spin-Wartevorgängen ab, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + Gibt die Anzahl von Spin-Wartevorgängen zurück, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird. + true, wenn der festgelegt wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet und ein überwacht wird. + true, wenn der festgelegt wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle ein Signal empfängt, wobei ein überwacht wird. + Das zu überwachende . + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei ein -Wert zum Messen des Zeitintervalls verwendet wird. + true, wenn der festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird. Dabei wird ein -Wert zum Messen des Zeitintervalls verwendet und ein überwacht. + true, wenn der festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Ruft das zugrunde liegende -Objekt für dieses ab. + Das zugrunde liegende -Ereignisobjekt für dieses . + + + Stellt einen Mechanismus bereit, der den Zugriff auf Objekte synchronisiert. + 2 + + + Erhält eine exklusive Sperre für das angegebene Objekt. + Das Objekt, für das die Monitorsperre erhalten werden soll. + Der -Parameter ist null. + 1 + + + Erhält eine exklusive Sperre für das angegebene Objekt und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, auf das gewartet werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen.Hinweis   Wenn keine Ausnahme auftritt, ist die Ausgabe dieser Methode immer true. + Die Eingabe für ist true. + Der -Parameter ist null. + + + Hebt eine exklusive Sperre für das angegebene Objekt auf. + Das Objekt, dessen Sperre aufgehoben werden soll. + Der -Parameter ist null. + Der aktuelle Thread besitzt die Sperre für das angegebene Objekt nicht. + 1 + + + Bestimmt, ob der aktuelle Thread die Sperre für das angegebene Objekt enthält. + true, wenn der aktuelle Thread die Sperre für enthält, andernfalls false. + Das zu überprüfende Objekt. + + ist null. + + + Benachrichtigt einen Thread in der Warteschlange für abzuarbeitende Threads über eine Änderung am Zustand des gesperrten Objekts. + Das Objekt, auf das ein Thread wartet. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + 1 + + + Benachrichtigt alle wartenden Threads über eine Änderung am Zustand des Objekts. + Das Objekt, das den Impuls sendet. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + 1 + + + Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Der -Parameter ist null. + 1 + + + Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + + + Versucht über eine angegebene Anzahl von Millisekunden hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Die Anzahl der Millisekunden, für die auf die Sperre gewartet werden soll. + Der -Parameter ist null. + + ist negativ und ungleich . + 1 + + + Versucht für die angegebene Anzahl von Millisekunden, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Die Anzahl der Millisekunden, für die auf die Sperre gewartet werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + + ist negativ und ungleich . + + + Versucht über einen angegebenen Zeitraum hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Eine , die die Zeitspanne darstellt, für die auf die Sperre gewartet werden soll.Ein Wert von -1 Millisekunde gibt eine unbegrenzte Wartezeit an. + Der -Parameter ist null. + Der Wert von in Millisekunden ist negativ und ungleich (-1 Millisekunde), oder er ist größer als . + 1 + + + Versucht für die angegebene Dauer, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Die Zeitspanne, für die auf die Sperre gewartet werden soll.Ein Wert von -1 Millisekunde gibt eine unbegrenzte Wartezeit an. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + Der Wert von in Millisekunden ist negativ und ungleich (-1 Millisekunde), oder er ist größer als . + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält. + true, wenn der Aufruf beendet wurde, weil der Aufrufer die Sperre für das angegebene Objekt erneut erhalten hat.Diese Methode wird nicht beendet, wenn die Sperre nicht erneut erhalten wird. + Das Objekt, auf das gewartet werden soll. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + 1 + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält.Wenn das angegebene Timeoutintervall abläuft, tritt der Thread in die Warteschlange für abgearbeitete Threads ein. + true, wenn die Sperre erneut erhalten wurde, bevor die angegebene Zeitspanne verstrichen ist. false, wenn die Sperre erneut erhalten wurde, nachdem die angegebene Zeitspanne verstrichen ist.Die Methode wird erst beendet, wenn die Sperre erneut erhalten wurde. + Das Objekt, auf das gewartet werden soll. + Die Anzahl von Millisekunden, die gewartet wird, bevor der Thread in die Warteschlange für abgearbeitete Threads eintritt. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + Der Wert des -Parameters ist negativ und ungleich . + 1 + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält.Wenn das angegebene Timeoutintervall abläuft, tritt der Thread in die Warteschlange für abgearbeitete Threads ein. + true, wenn die Sperre erneut erhalten wurde, bevor die angegebene Zeitspanne verstrichen ist. false, wenn die Sperre erneut erhalten wurde, nachdem die angegebene Zeitspanne verstrichen ist.Die Methode wird erst beendet, wenn die Sperre erneut erhalten wurde. + Das Objekt, auf das gewartet werden soll. + Ein , der die Zeit angibt, die gewartet wird, bevor der Thread in die Warteschlange für abgearbeitete Threads eintritt. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + Der Wert des -Parameters in Millisekunden ist negativ und stellt nicht (-1 Millisekunde) dar, oder er ist größer als . + 1 + + + Ein primitiver Synchronisierungstyp, der auch für die prozessübergreifende Synchronisierung verwendet werden kann. + 1 + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaften. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll. + true, um dem aufrufenden Thread den anfänglichen Besitz des Mutex zuzuweisen, andernfalls false. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, sowie mit einer Zeichenfolge, die den Namen des Mutex darstellt. + true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false. + Der Name des .Bei einem Wert von null ist das unbenannt. + Der benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex sowie mit einem booleschen Wert, der beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde. + true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false. + Der Name des .Bei einem Wert von null ist das unbenannt. + Enthält nach dem Beenden dieser Methode einen booleschen Wert, der true ist, wenn ein lokaler Mutex erstellt wurde (d. h. wenn gleich null oder eine leere Zeichenfolge ist) oder wenn der angegebene benannte Systemmutex erstellt wurde. Der Wert ist false, wenn der angegebene benannte Systemmutex bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + Der benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist. + Ein Objekt, das den benannten Systemmutex darstellt. + Der Name des zu öffnenden Systemmutex. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Der benannte Mutex ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex ist vorhanden, der Benutzer verfügt jedoch nicht über den erforderlichen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Gibt das einmal frei. + Der aufrufende Thread ist nicht im Besitz des Mutex. + 1 + + + Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn der benannte Mutex erfolgreich geöffnet wurde; andernfalls false. + Der Name des zu öffnenden Systemmutex. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Mutex darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex ist vorhanden, der Benutzer verfügt jedoch nicht über den erforderlichen Sicherheitszugriff, um es zu verwenden. + + + Stellt eine Sperre dar, mit der der Zugriff auf eine Ressource verwaltet wird. Mehrere Threads können hierbei Lesezugriff oder exklusiven Schreibzugriff erhalten. + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaftswerten. + + + Initialisiert eine neue Instanz der -Klasse unter Angabe der Rekursionsrichtlinie für die Sperre. + Einer der Enumerationswerte, der die Rekursionsrichtlinie für die Sperre angibt. + + + Ruft die Gesamtzahl von eindeutigen Threads ab, denen die Sperre im Lesemodus zugewiesen ist. + Die Anzahl von eindeutigen Threads, denen die Sperre im Lesemodus zugewiesen ist. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Versucht, die Sperre im Lesemodus zu erhalten. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Verringert die Rekursionszahl für den Lesemodus und beendet den Lesemodus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in read mode. + + + Verringert die Rekursionszahl für den erweiterbaren Modus und beendet den erweiterbaren Modus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in upgradeable mode. + + + Verringert die Rekursionszahl für den Schreibmodus und beendet den Schreibmodus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in write mode. + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im Lesemodus zugewiesen ist. + true, wenn sich der aktuelle Thread im Lesemodus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im erweiterbaren Modus zugewiesen ist. + true, wenn sich der aktuelle Thread im erweiterbaren Modus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im Schreibmodus zugewiesen ist. + true, wenn sich der aktuelle Thread im Schreibmodus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der die Rekursionsrichtlinie für das aktuelle -Objekt angibt. + Einer der Enumerationswerte, der die Rekursionsrichtlinie für die Sperre angibt. + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im Lesemodus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im Lesemodus befindet, 1, wenn sich der Thread im Lesemodus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread die Sperre n - 1 Mal rekursiv angefordert hat. + 2 + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im erweiterbaren Modus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im erweiterbaren Modus befindet, 1, wenn sich der Thread im erweiterbaren Modus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread den erweiterbaren Modus n - 1 Mal rekursiv angefordert hat. + 2 + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im Schreibmodus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im Schreibmodus befindet, 1, wenn sich der Thread im Schreibmodus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread den Schreibmodus n - 1 Mal rekursiv angefordert hat. + 2 + + + Versucht, die Sperre im Lesemodus zu erhalten. Optional wird ein ganzzahliger Timeout berücksichtigt. + true, wenn der aufrufende Thread den Lesemodus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im Lesemodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Lesemodus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den erweiterbaren Modus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den erweiterbaren Modus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Schreibmodus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Schreibmodus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im Lesemodus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des Lesemodus warten. + 2 + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im erweiterbaren Modus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des erweiterbaren Modus warten. + 2 + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im Schreibmodus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des Schreibmodus warten. + 2 + + + Schränkt die Anzahl von Threads ein, die gleichzeitig auf eine Ressource oder einen Pool von Ressourcen zugreifen können. + 1 + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen an. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist größer als . + + ist kleiner als 1.- oder - ist kleiner als 0. + + + Initialisiert eine neue Instanz der -Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen sowie optional den Namen eines Systemsemaphorobjekts an. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Der Name eines benannten Systemsemaphorobjekts. + + ist größer als .- oder - ist länger als 260 Zeichen. + + ist kleiner als 1.- oder - ist kleiner als 0. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Semaphor kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + + Initialisiert eine neue Instanz der -Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen sowie optional den Namen eines Systemsemaphorobjekts an, gibt eine Variable an, die einen Wert empfängt, der angibt, ob ein neues Systemsemaphor erstellt wurde. + Die ursprüngliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig ausgeführt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig ausgeführt werden können. + Der Name eines benannten Systemsemaphorobjekts. + Enthält nach dem Beenden dieser Methode den Wert true, wenn ein lokales Semaphor erstellt wurde (d. h., wenn gleich null oder eine leere Zeichenfolge ist) oder wenn das angegebene benannte Systemsemaphor erstellt wurde. Der Wert ist false, wenn das angegebene benannte Systemsemaphor bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + + ist größer als . - oder - ist länger als 260 Zeichen. + + ist kleiner als 1.- oder - ist kleiner als 0. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Semaphor kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + + Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist. + Ein Objekt, das das benannte Systemsemaphor darstellt. + Der Name des zu öffnenden Systemsemaphors. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Das benannte Semaphor ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Beendet das Semaphor und gibt die vorherige Anzahl zurück. + Die Anzahl für das Semaphor vor dem Aufruf der -Methode. + Die Anzahl für das Semaphor weist bereits den maximalen Wert auf. + Bei einem benannten Semaphor ist ein Win32-Fehler aufgetreten. + Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar. Der Benutzer verfügt jedoch nicht über .- oder - Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar, es wurde jedoch nicht mit geöffnet. + 1 + + + Gibt das Semaphor eine festgelegte Anzahl von Malen frei und gibt die vorherige Anzahl zurück. + Die Anzahl für das Semaphor vor dem Aufruf der -Methode. + Die Anzahl von Malen, die das Semaphor freigegeben werden soll. + + ist kleiner als 1. + Die Anzahl für das Semaphor weist bereits den maximalen Wert auf. + Bei einem benannten Semaphor ist ein Win32-Fehler aufgetreten. + Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar. Der Benutzer verfügt jedoch nicht über -Rechte.- oder - Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar, es wurde jedoch nicht mit -Rechten geöffnet. + 1 + + + Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn das benannte Semaphor erfolgreich geöffnet wurde; andernfalls false. + Der Name des zu öffnenden Systemsemaphors. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Semaphor darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + + + Die Ausnahme, die ausgelöst wird, wenn die -Methode für ein Semaphor aufgerufen wird, dessen Zähler bereits den Maximalwert aufweist. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Eine einfache Alternative zu , die die Anzahl der Threads beschränkt, die gleichzeitig auf eine Ressource oder einen Ressourcenpool zugreifen können. + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche Anzahl von Anforderungen an, die gleichzeitig gewährt werden können. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist kleiner als 0. + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche sowie die maximale Anzahl von Anforderungen an, die gleichzeitig gewährt werden können. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist kleiner als 0, oder ist größer als , oder ist kleiner gleich 0. + + + Gibt ein zurück, das verwendet werden kann um auf die Semaphore zu warten. + Ein , das verwendet werden kann um auf die Semaphore zu warten. + + wurde verworfen. + + + Ruft die Anzahl der verbleibenden Threads ab, für die das Eintreten in das -Objekt zulässig ist. + Die Anzahl der verbleibenden Threads, für die das Eintreten in das Semaphor zulässig ist. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt das -Objekt einmal frei. + Die vorherige Anzahl von . + Die aktuelle Instanz wurde bereits freigegeben. + Der hat bereits seine maximale Größe erreicht. + + + Gibt das -Objekt eine festgelegte Anzahl von Malen frei. + Die vorherige Anzahl von . + Die Anzahl von Malen, die das Semaphor freigegeben werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 1. + Der hat bereits seine maximale Größe erreicht. + + + Blockiert den aktuellen Thread, bis er in eintreten kann. + Die aktuelle Instanz wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei das Timeout mit einer 32-Bit-Ganzzahl mit Vorzeichen angegeben wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Timeouts verwendet und ein überwacht wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Instanz wurde freigegeben, oder die erstellten freigegeben wurde. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei ein überwacht wird. + Das zu überwachende -Token. + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben.- oder - Die erstellten bereits freigegeben wurde. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei ein zum Angeben des Timeouts verwendet wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + Die semaphoreSlim-Instanz wurde freigegeben + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei eine den Timeout angibt und ein überwacht wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + Die semaphoreSlim-Instanz wurde freigegebenDie , die erstellt hat, wurde bereits freigegeben. + + + Wartet asynchron auf den Eintritt in . + Eine Aufgabe, die abgeschlossen wird, wenn das Semaphor eingegeben wurde. + + + Wartet asynchron auf den Zutritt zum , wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Wartet asynchron auf den Zutritt zum , wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird, während ein beobachtet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die aktuelle Instanz wurde bereits freigegeben. + + wurde abgebrochen. + + + Wartet asynchron auf den Zutritt zum , während ein ein beobachtet wird. + Eine Aufgabe, die abgeschlossen wird, wenn das Semaphor eingegeben wurde. + Das zu überwachende -Token. + Die aktuelle Instanz wurde bereits freigegeben. + + wurde abgebrochen. + + + Wartet asynchron auf den Zutritt zum unter Verwendung einer zum Messen des Zeitintervalls. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. - oder - Timeout ist größer als . + + + Wartet asynchron auf den Zutritt zum unter Verwendung einer zum Messen des Zeitintervalls, während ein beobachtet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende -Token. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an.- oder - Timeout ist größer als . + + wurde abgebrochen. + + + Stellt eine Methode dar, die aufgerufen werden muss, wenn eine Nachricht an einen Synchronisierungskontext gesendet werden soll. + Das an den Delegaten übergebene Objekt. + 2 + + + Stellt einen sich gegenseitig ausschließenden Sperrprimitiven bereit, wobei ein Thread, der versucht, die Sperre abzurufen, wiederholt in einer Schleife wartet, bis die Sperre verfügbar wird. + + + Initialisiert eine neue Instanz der -Struktur mit der Option, Thread-IDs nachzuverfolgen, um das Debuggen zu vereinfachen. + Gibt an, ob Thread-IDs zu Debugzwecken erfasst und verwendet werden. + + + Ruft die Sperre zuverlässig ab, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + Das -Argument muss vor dem Aufrufen von Enter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Hebt die Sperre auf. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread ist nicht Besitzer dieser Sperre. + + + Hebt die Sperre auf. + Ein boolescher Wert, der angibt, ob eine Arbeitsspeicherumgrenzung ausgegeben werden soll, um den Beendigungsvorgang sofort für andere Threads zu veröffentlichen. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread ist nicht Besitzer dieser Sperre. + + + Ruft einen Wert ab, der angibt, ob die Sperre zurzeit von einem Thread verwendet wird. + True, wenn die Sperre zurzeit von einem Thread verwendet wird, andernfalls false. + + + Ruft einen Wert ab, der angibt, ob die Sperre vom aktuellen Thread verwendet wird. + True, wenn die Sperre vom aktuellen Thread verwendet wird, andernfalls false. + Die Threadbesitznachverfolgung wird deaktiviert. + + + Ruft einen Wert ab, der angibt, ob die Threadbesitznachverfolgung für diese Instanz aktiviert ist. + True, wenn die Threadbesitznachverfolgung für diese Instanz aktiviert ist, andernfalls false. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als Millisekunden. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Stellt Unterstützung für Spin-basierte Wartevorgänge bereit. + + + Ruft die Anzahl von -Aufrufen für diese Instanz ab. + Gibt eine ganze Zahl zurück, die angibt, wie häufig für diese Instanz aufgerufen wurde. + + + Ruft einen Wert ab, der angibt, ob der nächste Aufruf von den Prozessor ergibt und einen erzwungenen Kontextwechsel auslöst. + Gibt an, ob der nächste Aufruf von den Prozessor ergibt und einen erzwungenen Kontextwechsel auslöst. + + + Setzt die Spin-Anzahl zurück. + + + Führt einen Spin-Vorgang aus. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Das -Argument ist Null. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird oder das angegebene Timeout abgelaufen ist. + True, wenn die Bedingung innerhalb des Timeouts erfüllt wird, andernfalls false. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das -Argument ist Null. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird oder das angegebene Timeout abgelaufen ist. + True, wenn die Bedingung innerhalb des Timeouts erfüllt wird, andernfalls false. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Ein , das die Wartezeit in Millisekunden darstellt, oder ein TimeSpan-Wert, der -1 Millisekunden für Warten ohne Timeout darstellt. + Das -Argument ist Null. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Stellt die Grundfunktionen für die Weitergabe eines Synchronisierungskontexts in unterschiedlichen Synchronisierungsmodellen bereit. + 2 + + + Erstellt eine neue Instanz der -Klasse. + + + Erstellt beim Überschreiben in einer abgeleiteten Klasse eine Kopie des Synchronisierungskontexts. + Ein neues -Objekt. + 2 + + + Ruft den Synchronisierungskontext für den aktuellen Thread ab. + Ein -Objekt, das den aktuellen Synchronisierungskontext darstellt. + 1 + + + Antwortet beim Überschreiben in einer abgeleiteten Klasse auf die Benachrichtigung, dass ein Vorgang abgeschlossen wurde. + + + Antwortet beim Überschreiben in einer abgeleiteten Klasse auf die Benachrichtigung, dass ein Vorgang gestartet wurde. + + + Sendet beim Überschreiben in einer abgeleiteten Klasse eine asynchrone Meldung an einen Synchronisierungskontext. + Der aufzurufende -Delegat. + Das an den Delegaten übergebene Objekt. + 2 + + + Sendet beim Überschreiben in einer abgeleiteten Klasse eine synchrone Meldung an einen Synchronisierungskontext. + Der aufzurufende -Delegat. + Das an den Delegaten übergebene Objekt. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Legt den aktuellen Synchronisierungskontext fest. + Das festzulegende -Objekt. + 1 + + + + + + Die Ausnahme, die ausgelöst wird, wenn der Aufrufer für eine Methode über eine Sperre für einen bestimmten Monitor verfügen muss und die Methode von einem Aufrufer aufgerufen wird, der nicht über diese Sperre verfügt. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaften. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Stellt einen lokalen Datenspeicher eines Threads bereit. + Gibt den für jeden Thread gespeicherten Datentyp an. + + + Initialisiert die -Instanz. + + + Initialisiert die -Instanz. + Ob alle Werte, die für die Instanz festgelegt werden, verfolgt werden und über die -Eigenschaft verfügbar gemacht sollen. + + + Initialisiert die -Instanz mit der angegebenen -Funktion. + Das , das aufgerufen wird, um einen verzögert initialisierten Wert zu erzeugen, wenn versucht wird, ohne vorherige Initialisierung abzurufen. + + ist ein NULL-Verweis (Nothing in Visual Basic). + + + Initialisiert die -Instanz mit der angegebenen -Funktion. + Das , das aufgerufen wird, um einen verzögert initialisierten Wert zu erzeugen, wenn versucht wird, ohne vorherige Initialisierung abzurufen. + Ob alle Werte, die für die Instanz festgelegt werden, verfolgt werden und über die -Eigenschaft verfügbar gemacht sollen. + + ist ein null-Verweis (Nothing in Visual Basic). + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von dieser -Instanz verwendeten Ressourcen frei. + Ein boolescher Wert, der angibt, ob diese Methode aufgrund eines Aufrufs von aufgerufen wird. + + + Gibt die von dieser -Instanz verwendeten Ressourcen frei. + + + Ruft einen Wert ab, der angibt, ob für den aktuellen Thread initialisiert wurde. + True, wenn erfolgreich im aktuellen Thread initialisiert wurde, andernfalls false. + Die -Instanz wurde freigegeben. + + + Erstellt eine Zeichenfolgendarstellung dieser Instanz für den aktuellen Thread und gibt sie zurück. + Das Ergebnis des Aufrufs von für . + Die -Instanz wurde freigegeben. + Der für den aktuellen Thread ist ein NULL-Verweis (Nothing in Visual Basic). + Die Initialisierungsfunktion versuchte, auf rekursiv zu verweisen. + Kein Standardkonstruktor wird bereitgestellt, und keine Wertfactory wird angegeben. + + + Ruft den Wert dieser Instanz für den aktuellen Thread ab oder legt ihn fest. + Gibt eine Instanz des Objekts zurück, für dessen Initialisierung dieser ThreadLocal zuständig ist. + Die -Instanz wurde freigegeben. + Die Initialisierungsfunktion versuchte, auf rekursiv zu verweisen. + Kein Standardkonstruktor wird bereitgestellt, und keine Wertfactory wird angegeben. + + + Ruft eine Liste aller Werte ab, die aktuell von allen Threads, die auf diese Instanz zugegriffen haben, gespeichert werden. + Eine Liste aller Werte, die aktuell von allen Threads, die auf diese Instanz zugegriffen haben, gespeichert sind. + Die -Instanz wurde freigegeben. + + + Enthält Methoden für die Durchführung von Vorgängen für flüchtigen Speicher. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Objektverweis aus dem angegebenen Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der Verweis auf , der gelesen wurde.Dieser Verweis entspricht dem letzten von einem Prozessor im Computer geschriebenen Verweis, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + Der Typ des zu lesenden Felds.Dabei muss es sich um einen Verweistyp und keinen Werttyp handeln. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Arbeitsspeichervorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Objektverweis in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Objektverweis geschrieben wird. + Der zu schreibende Objektverweis.Der Verweis wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + Der Typ des zu schreibenden Felds.Dabei muss es sich um einen Verweistyp und keinen Werttyp handeln. + + + Die Ausnahme, die ausgelöst wird, wenn versucht wird, einen nicht vorhandenen Systemmutex oder ein nicht vorhandenes Semaphor zu öffnen. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/es/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/es/System.Threading.xml new file mode 100644 index 000000000..3431de9eb --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/es/System.Threading.xml @@ -0,0 +1,1803 @@ + + + + System.Threading + + + + Excepción que se produce cuando un subproceso adquiere un objeto que otro subproceso ha abandonado al salir sin liberarlo. + 1 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con un índice especificado para la exclusión mutua abandonada, si es aplicable, y un objeto que representa la exclusión mutua. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con un mensaje de error y una excepción interna especificados. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado, la excepción interna, el índice para la exclusión mutua abandonada, si es aplicable, y un objeto que representa la exclusión mutua. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado, el índice de la exclusión mutua abandonada, si es aplicable, y la exclusión mutua abandonada. + Mensaje de error que explica la razón de la excepción. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Obtiene la exclusión mutua abandonada que produjo la excepción, si se conoce. + Objeto que representa la exclusión mutua abandonada o null si no se han podido identificar las exclusiones mutuas abandonadas. + 1 + + + Obtiene el índice de la exclusión mutua abandonada que produjo la excepción, si se conoce. + Índice, en la matriz de identificadores de espera que se ha pasado al método , del objeto que representa la exclusión mutua abandonada, o –1 si no se puede determinar el índice de la exclusión mutua abandonada. + 1 + + + Representa datos ambiente locales de un flujo de control asincrónico determinado, por ejemplo, un método asincrónico. + Tipo de los datos ambiente. + + + Crea una instancia que no recibe las notificaciones de cambio. + + + Crea una instancia local que recibe notificaciones de cambio. + Delegado al que se llama cuando cambia el valor actual en cualquier subproceso. + + + Obtiene o establece el valor de los datos ambiente. + Valor de los datos ambiente. + + + Clase que proporciona información de cambio de datos a las instancias que se registran para las notificaciones de cambios. + Tipo de los datos. + + + Obtiene el valor actual de los datos. + Valor actual de los datos. + + + Obtiene el valor anterior de los datos. + Valor anterior de los datos. + + + Devuelve un valor que indica si el valor cambia debido a un cambio de contexto de ejecución. + true si el valor cambió debido a un cambio de contexto de ejecución; de lo contrario, false. + + + Notifica que se ha producido un evento a un subproceso en espera.Esta clase no puede heredarse. + 2 + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + true para establecer el estado inicial en señalado; false para establecer el estado inicial en no señalado. + + + Habilita varias tareas para que cooperen en un algoritmo en paralelo a través de varias fases. + + + Inicializa una nueva instancia de la clase . + Número de subprocesos que participan. + + es menor que 0 o mayor que 32,767. + + + Inicializa una nueva instancia de la clase . + Número de subprocesos que participan. + + que se ejecutará después de cada fase. null (Nothing en Visual Basic) se puede pasar para indicar que no se realiza ninguna acción. + + es menor que 0 o mayor que 32,767. + + + Notifica a que va a haber un participante adicional. + Número de fase de la barrera en la que primero participarán los nuevos participantes. + La instancia actual ya se ha eliminado. + Agregar un participante haría que el recuento de participantes de la barrera superase los 32.767.O bienEl método se invocó desde dentro de una acción posterior a la fase. + + + Notifica a que va a haber participantes adicionales. + Número de fase de la barrera en la que primero participarán los nuevos participantes. + Número de participantes adicionales que se van a agregar a la barrera. + La instancia actual ya se ha eliminado. + + es menor que 0.O bienAgregar haría que el recuento de participantes de la barrera superase los 32.767. + El método se invocó desde dentro de una acción posterior a la fase. + + + Obtiene el número de la fase actual de la barrera. + Devuelve el número de la fase actual de la barrera. + + + Libera todos los recursos usados por la instancia actual de la clase . + El método se invocó desde dentro de una acción posterior a la fase. + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto los recursos administrados como los no administrados; es false para liberar únicamente los recursos no administrados. + + + Obtiene el número total de participantes de la barrera. + Devuelve el número total de participantes de la barrera. + + + Obtiene el número de participantes de la barrera que no aún no se han señalado en la fase actual. + Devuelve el número de participantes de la barrera que no aún no se han señalado en la fase actual. + + + Notifica a que va a haber un participante menos. + La instancia actual ya se ha eliminado. + La barrera ya tiene 0 participantes.O bienEl método se invocó desde dentro de una acción posterior a la fase. + + + Notifica a que va a haber menos participantes. + Número de participantes adicionales que se van a quitar de la barrera. + La instancia actual ya se ha eliminado. + + es menor que 0. + La barrera ya tiene 0 participantes.O bienEl método se invocó desde dentro de una acción posterior a la fase. O bienel recuento del participante actual es menor que el participantCount especificado + El recuento del participante total es menor que el especificado + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera. + La instancia actual ya se ha eliminado. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + Si una excepción se produce de la acción de fase de envío de una barrera después de todos los subprocesos hayan llamado a SignalAndWait, la excepción se ajustará en una BarrierPostPhaseException y se producirá en todos los subprocesos que participan. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera usando un entero de 32 bits con signo para medir el tiempo de espera. + si todos los participantes alcanzaron la barrera dentro del tiempo especificado; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + Si una excepción se produce de la acción de fase de envío de una barrera después de todos los subprocesos hayan llamado a SignalAndWait, la excepción se ajustará en una BarrierPostPhaseException y se producirá en todos los subprocesos que participan. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes la alcancen también usando un entero de 32 bits con signo para medir el tiempo de espera mientras se observa un token de cancelación. + si todos los participantes alcanzaron la barrera dentro del tiempo especificado; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen la barrera mientras se observa un token de cancelación. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera usando un objeto para medir el intervalo de tiempo. + Es true si todos los demás participantes alcanzaron la barrera; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o es mayor de 32.767. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes la alcancen también usando un objeto para medir el intervalo de tiempo, mientras se observa un token de cancelación. + Es true si todos los demás participantes alcanzaron la barrera; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Excepción que se inicia cuando se produce un error en la acción posterior a la fase de + + + Inicializa una nueva instancia de la clase con un mensaje proporcionado por el sistema que describe el error. + + + Inicializa una nueva instancia de la clase con la excepción interna especificada. + La excepción que es la causa de la excepción actual. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado que describe el error. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Representa un método al que se va a llamar dentro de un nuevo contexto. + Objeto que contiene la información que va a utilizar el método de devolución de llamadas cada vez que se ejecute. + 1 + + + Representa una primitiva de sincronización que está señalada cuando su recuento alcanza el valor cero. + + + Inicializa una nueva instancia de la clase con el recuento especificado. + Número de señales necesarias inicialmente para establecer . + + es menor que 0. + + + Incrementa en uno el recuento actual de . + La instancia actual ya se ha eliminado. + La instancia actual ya está establecida.O bien es mayor o igual que . + + + Incrementa en un valor especificado el recuento actual de . + Valor en que se va a aumentar . + La instancia actual ya se ha eliminado. + + es menor o igual que 0. + La instancia actual ya está establecida.O bien es igual o mayor que después de incrementar la cuenta en + + + Obtiene el número de señales restantes necesario para establecer el evento. + El número de señales restantes necesario para establecer el evento. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto los recursos administrados como los no administrados; es false para liberar únicamente los recursos no administrados. + + + Obtiene los números de señales que se necesitan inicialmente para establecer el evento. + El número de señales que se necesitan inicialmente para establecer el evento. + + + Determina si se establece el evento. + Es true si se establece el evento; de lo contrario, es false. + + + Restablece en el valor de . + La instancia actual ya se ha eliminado. + + + Restablece la propiedad según un valor especificado. + Número de señales necesario para establecer . + La instancia actual ya se ha eliminado. + El valor de es menor que 0. + + + Registra una señal con y disminuye el valor de . + Es true si la señal hizo que el recuento alcanzara el valor cero y se estableció el evento; de lo contrario, falso. + La instancia actual ya se ha eliminado. + La instancia actual ya está establecida. + + + Registra varias señales con reduciendo el valor de según la cantidad especificada. + Es true si las señales hicieron que el recuento alcanzara el valor cero y se estableció el evento; de lo contrario, falso. + Número de señales que se va a registrar. + La instancia actual ya se ha eliminado. + + es menor que 1. + La instancia actual ya está establecida. -o bien- es mayor que . + + + Intenta incrementar en uno. + Es true si el incremento se realizó correctamente; en caso contrario, es false.Si ya está en el valor cero, este método devolverá false. + La instancia actual ya se ha eliminado. + + es igual a . + + + Intenta incrementar en un valor especificado. + Es true si el incremento se realizó correctamente; en caso contrario, es false.Si ya está en el valor cero, se devolverá false. + Valor en que se va a aumentar . + La instancia actual ya se ha eliminado. + + es menor o igual que 0. + La instancia actual ya está establecida.O bien + es igual o mayor que . + + + Bloquea el subproceso actual hasta que se establezca el objeto . + La instancia actual ya se ha eliminado. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un entero de 32 bits con signo para medir el tiempo de espera. + Es true si se estableció el objeto ; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un entero de 32 bits con signo para medir el tiempo de espera, mientras se observa un token . + Es true si se estableció el objeto ; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que se establezca el objeto , mientras se observa un token . + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un objeto para medir el tiempo de espera. + Es true si se estableció el objeto ; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un objeto para medir el tiempo de espera, mientras se observa un token . + Es true si se estableció el objeto ; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Obtiene un objeto que se usa para esperar a que se establezca el evento. + Objeto que se usa para esperar a que se establezca el evento. + La instancia actual ya se ha eliminado. + + + Indica si un objeto se restablece automática o manualmente después de recibir una señal. + 2 + + + El objeto , cuando está señalado, se restablece automáticamente después de haber liberado un único subproceso.Si hay ningún subproceso en espera, el objeto permanece señalado hasta que un subproceso se bloquea y se restablece después de haber liberado el subproceso. + + + El objeto , cuando está señalado, libera todos los subprocesos en espera y permanece señalado hasta que se restablece manualmente. + + + Representa un evento de sincronización de subprocesos. + 2 + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente y si se restablece automática o manualmente. + Es true para establecer el estado inicial en señalado; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente y el nombre de un evento de sincronización del sistema. + Es true para establecer el estado inicial en señalado si el evento con nombre se crea como resultado de esta llamada; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + Nombre de un evento de sincronización para todo el sistema. + Se ha producido un error de Win32. + El evento con nombre existe y tiene seguridad de control de acceso, pero el usuario carece de . + No se puede crear el evento con nombre, quizás porque un identificador de espera de un tipo diferente tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente, el nombre de un evento de sincronización del sistema y una variable booleana cuyo valor después de la llamada indica si se ha creado el evento del sistema con nombre. + Es true para establecer el estado inicial en señalado si el evento con nombre se crea como resultado de esta llamada; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + Nombre de un evento de sincronización para todo el sistema. + Cuando este método devuelve un resultado, contiene true si se ha creado un evento local (es decir, si es null o una cadena vacía) o si se ha creado el evento del sistema con nombre especificado; es false si el evento del sistema con nombre especificado ya existía.Este parámetro se pasa sin inicializar. + Se ha producido un error de Win32. + El evento con nombre existe y tiene seguridad de control de acceso, pero el usuario carece de . + No se puede crear el evento con nombre, quizás porque un identificador de espera de un tipo diferente tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Abre el evento de sincronización con nombre especificado, si ya existe. + Un objeto que representa el evento del sistema con nombre. + Nombre del evento de sincronización que se va a abrir. + + es una cadena vacía. O bien tiene más de 260 caracteres. + + es null. + El evento del sistema con nombre no existe. + Se ha producido un error de Win32. + El evento con nombre existe, pero el usuario no tiene el acceso de seguridad exigido para utilizarlo. + 1 + + + + + + Establece el estado del evento en no señalado, haciendo que los subprocesos se bloqueen. + true si la operación se realiza correctamente; en caso contrario, false. + No se ha llamado previamente al método en este . + 2 + + + Establece el estado del evento en señalado, permitiendo que uno o varios subprocesos en espera continúen. + true si la operación se realiza correctamente; en caso contrario, false. + No se ha llamado previamente al método en este . + 2 + + + Abre el evento de sincronización con nombre especificado, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si el evento de sincronización con nombre se abrió correctamente; si no, false. + Nombre del evento de sincronización que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa el evento de sincronización con nombre si la llamada se realizó correctamente, o null si se produjo un error en la llamada.Este parámetro se trata como sin inicializar. + + es una cadena vacía.O bien tiene más de 260 caracteres. + + es null. + Se ha producido un error de Win32. + El evento con nombre existe, pero el usuario no tiene el acceso de seguridad deseado. + + + Administra el contexto de ejecución del subproceso actual.Esta clase no puede heredarse. + 2 + + + Captura el contexto de ejecución del subproceso actual. + Objeto que representa el contexto de ejecución del subproceso actual. + 1 + + + Ejecuta un método en un contexto de ejecución especificado en el subproceso actual. + Contexto de ejecución que se va a establecer. + Delegado que representa el método que se va a ejecutar en el contexto de ejecución proporcionado. + Objeto que se pasa al método de devolución de llamada. + + es null.O bien no se adquirió a través de una operación de captura. O bien ya se ha utilizado como argumento de una llamada a . + 1 + + + + + + Proporciona operaciones atómicas para las variables compartidas por varios subprocesos. + 2 + + + Agrega dos enteros de 32 bits y reemplaza el primer entero por la suma, como una operación atómica. + Nuevo valor almacenado en . + Variable que contiene el primer valor que se va a agregar.La suma de los dos valores se almacena en . + Valor que se va a agregar al entero en . + The address of is a null pointer. + 1 + + + Agrega dos enteros de 64 bits y reemplaza el primer entero por la suma, como una operación atómica. + Nuevo valor almacenado en . + Variable que contiene el primer valor que se va a agregar.La suma de los dos valores se almacena en . + Valor que se va a agregar al entero en . + The address of is a null pointer. + 1 + + + Compara dos números de punto flotante de precisión doble para comprobar si son iguales y, si lo son, reemplaza el primero de los valores. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos enteros de 32 bits con signo para comprobar si son iguales y, si lo son, reemplaza el primer valor. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos enteros de 64 bits con signo para comprobar si son iguales y, si lo son, reemplaza el primer valor. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos identificadores o punteros específicos de plataforma para comprobar si son iguales y, si lo son, reemplaza el primero. + Valor original de . + Estructura de destino, cuyo valor se compara con el valor de y que posiblemente se reemplace por . + Estructura que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Estructura que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos objetos para comprobar si sus referencias son iguales y, si lo son, reemplaza el primero de los objetos. + Valor original de . + Objeto de destino que se compara con y que posiblemente se reemplace. + Objeto que reemplaza el objeto de destino si la comparación da como resultado la igualdad de ambos parámetros. + Objeto que se compara con el objeto que hay en . + The address of is a null pointer. + 1 + + + Compara dos números de punto flotante de precisión sencilla para comprobar si son iguales y, si lo son, reemplaza el primero de los valores. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos instancias del tipo de referencia especificado para comprobar si son iguales y, si lo son, reemplaza la primera. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace.Este es un parámetro de referencia (ref en C#, ByRef en Visual Basic). + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + Tipo que se va a utilizar para , y .Este tipo debe ser un tipo de referencia. + The address of is a null pointer. + + + Disminuye el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor reducido. + Variable cuyo valor se va a reducir. + The address of is a null pointer. + 1 + + + Disminuye el valor de la variable especificada y almacena el resultado, como una operación atómica. + Valor reducido. + Variable cuyo valor se va a reducir. + The address of is a null pointer. + 1 + + + Establece un número de punto flotante de precisión doble en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un entero de 32 bits con signo en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un entero de 64 bits con signo en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un puntero o identificador específico de plataforma en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un objeto en un valor especificado y devuelve una referencia al objeto original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un número de punto flotante de precisión sencilla en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece una variable del tipo especificado en un valor determinado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado.Este es un parámetro de referencia (ref en C#, ByRef en Visual Basic). + Valor en el que está establecido el parámetro . + Tipo que se va a utilizar para y .Este tipo debe ser un tipo de referencia. + The address of is a null pointer. + + + Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor incrementado. + Variable cuyo valor se va a incrementar. + The address of is a null pointer. + 1 + + + Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor incrementado. + Variable cuyo valor se va a incrementar. + The address of is a null pointer. + 1 + + + Sincroniza el acceso a la memoria de la siguiente forma: el procesador que ejecuta el subproceso actual no puede reordenar instrucciones de forma que los accesos a la memoria anteriores a la llamada a se ejecuten después de los accesos a memoria que siguen a la llamada a . + + + Devuelve un valor de 64 bits, cargado como una operación atómica. + Valor cargado. + Valor de 64 bits que se va a cargar. + 1 + + + Proporciona rutinas de inicialización diferida. + + + Inicializa un tipo de referencia de destino con su constructor predeterminado si aún no se ha inicializado el destino. + Referencia de tipo que se ha inicializado. + Referencia de tipo que se va a inicializar si aún no se ha inicializado. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino o tipo de valor con su constructor predeterminado si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia o valor de tipo que se va a inicializar si aún no se ha inicializado. + Referencia a un valor booleano que determina si ya se ha inicializado el destino. + Referencia a un objeto que se usa como bloqueo mutuamente excluyente para la inicialización de .Si es null, se creará una instancia de un nuevo objeto. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino o tipo de valor utilizando la función especificada si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia o valor de tipo que se va a inicializar si aún no se ha inicializado. + Referencia a un valor booleano que determina si ya se ha inicializado el destino. + Referencia a un objeto que se usa como bloqueo mutuamente excluyente para la inicialización de .Si es null, se creará una instancia de un nuevo objeto. + Función que se llama para inicializar la referencia o el valor. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino utilizando la función especificada si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia de tipo que se va a inicializar si aún no se ha inicializado. + Función que se llama para inicializar la referencia. + Tipo de referencia que se va a inicializar. + El tipo no contiene un constructor predeterminado. + + devuelve un valor NULL (Nothing en Visual Basic). + + + Excepción que se inicia cuando la entrada recursiva en un bloqueo no es compatible con la directiva de recursividad del bloqueo. + 2 + + + Inicializa una nueva instancia de la clase con un mensaje proporcionado por el sistema que describe el error. + 2 + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado que describe el error. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que la cadena se ha traducido para la referencia cultural actual del sistema. + 2 + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que la cadena se ha traducido para la referencia cultural actual del sistema. + Excepción que ha producido la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + 2 + + + Especifica si el mismo subproceso puede entrar varias veces en un bloqueo. + + + Si un subproceso intenta entrar en un bloqueo de forma recursiva, se inicia una excepción.Algunas clases pueden permitir cierta recursividad cuando se aplica esta configuración. + + + Un subproceso puede entrar en un bloqueo de forma recursiva.Algunas clases pueden limitar esta posibilidad. + + + Notifica que se ha producido un evento a uno o varios subprocesos en espera.Esta clase no puede heredarse. + 2 + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + true para establecer el estado inicial de señalado; false para establecer el estado inicial en no señalado. + + + Proporciona una versión reducida de . + + + Inicializa una nueva instancia de la clase con el estado inicial establecido en no señalado. + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + Es true para establecer el estado inicial en señalado; es false para establecer el estado inicial en no señalado. + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado y con el recuento circular especificado. + Es true para establecer el estado inicial en señalado; es false para establecer el estado inicial en no señalado. + Número de esperas circulares que se van a producir antes de una operación de espera basada en kernel. + + is less than 0 or greater than the maximum allowed value. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados que usa el objeto y, de forma opcional, libera los recursos administrados. + true para liberar tanto los recursos administrados como los no administrados; false para liberar únicamente los recursos no administrados. + + + Obtiene un valor que indica si se ha establecido el evento. + Es true si se ha establecido el evento; de lo contrario, es false. + + + Establece el estado del evento en no señalado, por lo que se bloquean los subprocesos. + The object has already been disposed. + + + Establece el estado del evento en señalado, lo que permite la continuación de uno o varios subprocesos que están esperando en el evento. + + + Obtiene el número de esperas circulares que se producirán antes de una operación de espera basada en kernel. + Devuelve el número de esperas circulares que se producirán antes de una operación de espera basada en kernel. + + + Bloquea el subproceso actual hasta que se establezca el objeto actual. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, usando un entero de 32 bits con signo para medir el intervalo de tiempo. + Es true si se estableció ; en caso contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, usando un entero de 32 bits con signo para medir el intervalo de tiempo, mientras se observa un token . + true si se estableció ; en caso contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Bloquea el subproceso actual hasta que el actual reciba una señal, mientras se observa un token . + + que se va a observar. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, utilizando un objeto para medir el intervalo de tiempo. + true si se estableció ; en caso contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el , usando un objeto para medir el intervalo de tiempo, mientras se observa un token . + true si se estableció ; en caso contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Obtiene el objeto para este . + Objeto de evento subyacente de este . + + + Proporciona un mecanismo que sincroniza el acceso a los objetos. + 2 + + + Adquiere un bloqueo exclusivo en el objeto especificado. + Objeto en el que se va a adquirir el bloqueo de monitor. + El parámetro es null. + 1 + + + Adquiere un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a esperar. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo.Nota   Si no se produce ninguna excepción, el resultado de este método siempre es true. + La entrada es true. + El parámetro es null. + + + Libera un bloqueo exclusivo en el objeto especificado. + Objeto en el que se va a liberar el bloqueo. + El parámetro es null. + El subproceso actual no posee el bloqueo para el objeto especificado. + 1 + + + Determina si el subproceso actual mantiene el bloqueo en el objeto especificado. + Es true si el subproceso actual mantiene el bloqueo en ; en caso contrario, es false. + Objeto que se va a probar. + El valor de es null. + + + Notifica un cambio de estado del objeto bloqueado al subproceso que se encuentra en la cola de espera. + Objeto que está esperando un subproceso. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + 1 + + + Notifica un cambio de estado del objeto a todos los subprocesos que se encuentran en espera. + Objeto que envía el pulso. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + 1 + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + El parámetro es null. + 1 + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado durante el número de segundos especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + Número de milisegundos durante los que se va a esperar para adquirir el bloqueo. + El parámetro es null. + + es negativo y no es igual a . + 1 + + + Intenta, durante el número especificado de milisegundos, adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Número de milisegundos durante los que se va a esperar para adquirir el bloqueo. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + + es negativo y no es igual a . + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado durante el período de tiempo especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + + que representa el período de tiempo que se va a esperar para adquirir el bloqueo.Un valor de –1 milisegundo especifica una espera infinita. + El parámetro es null. + El valor de en milisegundos es negativo y no es igual a (– 1 milisegundo), o es mayor que . + 1 + + + Intenta, durante el periodo de tiempo indicado, adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Tiempo que se va a esperar el bloqueo.Un valor de –1 milisegundo especifica una espera infinita. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + El valor de en milisegundos es negativo y no es igual a (– 1 milisegundo), o es mayor que . + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo. + Es true si la llamada fue devuelta porque el llamador volvió a adquirir el bloqueo para el objeto especificado.Este método no devuelve ningún resultado si el bloqueo no vuelve a adquirirse. + Objeto en el que se va a esperar. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + 1 + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo.Si transcurre el intervalo de tiempo de espera especificado, el subproceso entra en la cola de subprocesos listos. + Es true si se volvió a adquirir el bloqueo antes de que transcurriera el período de tiempo especificado; es false si se volvió a adquirir el bloqueo después de que transcurriera el período de tiempo especificado.El método no devuelve ningún resultado hasta que se vuelva a adquirir el bloqueo. + Objeto en el que se va a esperar. + Número de milisegundos que se va a estar a la espera antes de que el subproceso entre en la cola de subprocesos listos. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + El valor de la parámetro es negativo y no es igual a . + 1 + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo.Si transcurre el intervalo de tiempo de espera especificado, el subproceso entra en la cola de subprocesos listos. + Es true si se volvió a adquirir el bloqueo antes de que transcurriera el período de tiempo especificado; es false si se volvió a adquirir el bloqueo después de que transcurriera el período de tiempo especificado.El método no devuelve ningún resultado hasta que se vuelva a adquirir el bloqueo. + Objeto en el que se va a esperar. + + que representa la cantidad de tiempo que se va a esperar antes de que el subproceso entre en la cola de subprocesos listos. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + El valor de la parámetro en milisegundos es negativo y no representa (– 1 milisegundo), o es mayor que . + 1 + + + Primitiva de sincronización que puede usarse también para la sincronización entre procesos. + 1 + + + Inicializa una nueva instancia de la clase con propiedades predeterminadas. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua. + true para otorgar la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada, de lo contrario, false. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua y una cadena que representa el nombre de la exclusión mutua. + true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false. + Nombre del objeto .Si el valor es null, no tiene nombre. + La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene . + Se ha producido un error de Win32. + No se puede crear la exclusión mutua con nombre; posiblemente porque un identificador de espera de otro tipo tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua, una cadena que es el nombre de la exclusión mutua y un valor booleano que, cuando se devuelva el método, indicará si se concedió la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada. + true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false. + Nombre del objeto .Si el valor es null, no tiene nombre. + Cuando se devuelve este método, contiene un valor booleano que es true si se creó una exclusión mutua local (es decir, si es null o una cadena vacía) o si se creó la exclusión mutua del sistema con nombre especificada; el valor es false si la exclusión mutua del sistema con nombre especificada ya existía.Este parámetro se pasa sin inicializar. + La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene . + Se ha producido un error de Win32. + No se puede crear la exclusión mutua con nombre; posiblemente porque un identificador de espera de otro tipo tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Abre la exclusión mutua con nombre especificada, si ya existe. + Objeto que representa la exclusión mutua del sistema con nombre. + Nombre de la exclusión mutua del sistema que se va a abrir. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + La excepción mutua con nombre no existe. + Se ha producido un error de Win32. + La exclusión mutua con nombre existe, pero el usuario no dispone del acceso de seguridad exigido para utilizarla. + 1 + + + + + + Libera una vez la instancia de . + El subproceso que realiza la llamada no posee la exclusión mutua. + 1 + + + Abre la exclusión mutua con nombre especificada, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si la exclusión mutua con nombre se abrió correctamente; si no, false. + Nombre de la exclusión mutua del sistema que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa la exclusión mutua con nombre si la llamada se realizó correctamente, o null si se produjo un error en la llamada.Este parámetro se trata como sin inicializar. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + Se ha producido un error de Win32. + La exclusión mutua con nombre existe, pero el usuario no dispone del acceso de seguridad exigido para utilizarla. + + + Representa un bloqueo que se utiliza para administrar el acceso a un recurso y que permite varios subprocesos para la lectura o acceso exclusivo para la escritura. + + + Inicializa una nueva instancia de la clase con los valores de propiedad predeterminados. + + + Inicializa una nueva instancia de la clase especificando la directiva de recursividad de bloqueo. + Uno de los valores de enumeración que especifica la directiva de recursividad de bloqueo. + + + Obtiene el número total de subprocesos únicos que han entrado en el bloqueo en modo de lectura. + Número de subprocesos únicos que han entrado en el bloqueo en modo de lectura. + + + Libera todos los recursos usados por la instancia actual de la clase . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Intenta entrar en el bloqueo en modo de lectura. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Reduce el recuento de recursividad para el modo de lectura y sale del modo de lectura si el recuento resultante es 0 (cero). + The current thread has not entered the lock in read mode. + + + Reduce el recuento de recursividad para el modo de actualización y sale del modo de actualización si el recuento resultante es 0 (cero). + The current thread has not entered the lock in upgradeable mode. + + + Reduce el recuento de recursividad para el modo de escritura y sale del modo de escritura si el recuento resultante es 0 (cero). + The current thread has not entered the lock in write mode. + + + Obtiene un valor que indica si el subproceso actual ha entrado en el bloqueo en modo de lectura. + true si el subproceso actual entró en modo Lectura; en caso contrario, false. + 2 + + + Obtiene un valor que indica si el subproceso actual entró en el bloqueo en modo de actualización. + true si el subproceso actual entró en modo de actualización; en caso contrario, false. + 2 + + + Obtiene un valor que indica si el subproceso actual ha entrado en el bloqueo en modo de escritura. + true si el subproceso actual entró en modo de escritura; en caso contrario, false. + 2 + + + Obtiene un valor que indica la directiva de recursividad del objeto actual. + Uno de los valores de enumeración que especifica la directiva de recursividad de bloqueo. + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de lectura, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo Lectura, 1 si el subproceso entró en modo Lectura pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el bloqueo n - 1 veces. + 2 + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de actualización, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo de actualización, 1 si el subproceso entró en modo de actualización pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el modo de actualización n - 1 veces. + 2 + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de escritura, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo de escritura, 1 si el subproceso entró en modo de escritura pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el modo de escritura n - 1 veces. + 2 + + + Intenta entrar en el bloqueo en modo de lectura, con un tiempo de espera entero opcional. + true si el subproceso que realiza la llamada entró en modo Lectura; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de lectura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo Lectura; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de actualización; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de actualización; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de escritura; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de escritura; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de lectura. + Número total de subprocesos que están a la espera de entrar en modo de lectura. + 2 + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de actualización. + Número total de subprocesos que están a la espera de entrar en modo de actualización. + 2 + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de escritura. + Número total de subprocesos que están a la espera de entrar en modo de escritura. + 2 + + + Limita el número de subprocesos que pueden tener acceso a un recurso o grupo de recursos simultáneamente. + 1 + + + Inicializa una nueva instancia de la clase , que especifica el número inicial de entradas y el número máximo de entradas simultáneas. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + + es mayor que . + + es menor que 1.o bien es menor que 0. + + + Inicializa una nueva instancia de la clase , que especifica el número inicial de entradas y el número máximo de entradas simultáneas, y especificando de forma opcional el nombre de un objeto semáforo de sistema. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + Nombre de un objeto de semáforo del sistema con nombre. + + es mayor que .o bien tiene más de 260 caracteres. + + es menor que 1.o bien es menor que 0. + Se ha producido un error de Win32. + El semáforo con nombre existe y tiene seguridad de control de acceso y el usuario no tiene . + No se puede crear el semáforo con nombre, probablemente porque tiene el mismo nombre que un identificador de espera de otro tipo. + + + Inicializa una instancia nueva de la clase , especificando el número inicial de entradas y el número máximo de entradas simultáneas, especificando de forma opcional el nombre de un objeto semáforo de sistema y especificando una variable que recibe un valor que indica si se creó un semáforo del sistema nuevo. + Número inicial de solicitudes para el semáforo que se puede satisfacer simultáneamente. + Número máximo de solicitudes para el semáforo que se puede satisfacer simultáneamente. + Nombre de un objeto de semáforo del sistema con nombre. + Cuando este método devuelve un resultado, contiene true si se creó un semáforo local (es decir, si es null o una cadena vacía) o si se creó el semáforo del sistema con nombre especificado; es false si el semáforo del sistema con nombre especificado ya existía.Este parámetro se pasa sin inicializar. + + es mayor que . o bien tiene más de 260 caracteres. + + es menor que 1.o bien es menor que 0. + Se ha producido un error de Win32. + El semáforo con nombre existe y tiene seguridad de control de acceso y el usuario no tiene . + No se puede crear el semáforo con nombre, probablemente porque tiene el mismo nombre que un identificador de espera de otro tipo. + + + Abre el semáforo con nombre especificado, si ya existe. + Objeto que representa el semáforo del sistema con nombre. + Nombre del semáforo del sistema que se va a abrir. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + El semáforo con nombre no existe. + Se ha producido un error de Win32. + El semáforo con nombre existe, pero el usuario no tiene el acceso de seguridad necesario para utilizarlo. + 1 + + + + + + Sale del semáforo y devuelve el recuento anterior. + Recuento en el semáforo antes de la llamada al método . + El recuento del semáforo ya está en el valor máximo. + Error de Win32 con un semáforo con nombre. + El semáforo actual representa un semáforo de sistema con nombre, pero el usuario no tiene .o bienEl semáforo actual representa un semáforo de sistema con nombre, pero no se abrió con . + 1 + + + Sale del semáforo un número especificado de veces y devuelve el recuento anterior. + Recuento en el semáforo antes de la llamada al método . + Número de veces que se abandona el semáforo. + + es menor que 1. + El recuento del semáforo ya está en el valor máximo. + Error de Win32 con un semáforo con nombre. + El semáforo actual representa un semáforo de sistema con nombre, pero el usuario no tiene derechos.o bienEl semáforo actual representa un semáforo de sistema con nombre, pero no se abrió con derechos. + 1 + + + Abre el semáforo con nombre especificado, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si el semáforo con nombre se abrió correctamente; si no, false. + Nombre del semáforo del sistema que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa el semáforo con nombre si la llamada se realizó correctamente o null si se produjo un error en la misma.Este parámetro se trata como sin inicializar. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + Se ha producido un error de Win32. + El semáforo con nombre existe, pero el usuario no tiene el acceso de seguridad necesario para utilizarlo. + + + Excepción que se produce cuando se llama al método en un semáforo cuyo recuento ya ha alcanzado el valor máximo. + 2 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Representa una alternativa ligera a que limita el número de subprocesos que puede obtener acceso a la vez a un recurso o a un grupo de recursos. + + + Inicializa una nueva instancia de la clase , especificando el número inicial de solicitudes que se pueden conceder simultáneamente. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + + es menor que 0. + + + Inicializa una nueva instancia de la clase , especificando el número inicial y máximo de solicitudes que se pueden conceder simultáneamente. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + + es menor que 0, o es mayor que , o es igual o menor que 0. + + + Devuelve un objeto que se puede usar para esperar en el semáforo. + + que se puede usar para esperar en el semáforo. + Se ha eliminado . + + + Obtiene el número de subprocesos restantes que puede introducir el objeto . + Obtiene el número de subprocesos restantes que pueden entrar en el semáforo. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Libera una vez el objeto . + Recuento anterior de . + La instancia actual ya se ha eliminado. + El ya se ha alcanzado su tamaño máximo. + + + Libera el objeto un número especificado de veces. + Recuento anterior de . + Número de veces que se abandona el semáforo. + La instancia actual ya se ha eliminado. + + es menor que 1. + El ya se ha alcanzado su tamaño máximo. + + + Bloquea el subproceso actual hasta que pueda introducir . + La instancia actual ya se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , usando un entero de 32 bits con signo que especifica el tiempo de espera. + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que pueda introducir , usando un entero de 32 bits con signo que especifica el tiempo de espera mientras se observa un elemento . + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + se ha cancelado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + El se ha eliminado la instancia, o la que creó se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , mientras se observa un elemento . + Token que se va a observar. + + se ha cancelado. + La instancia actual ya se ha eliminado.o bienEl que creó ya se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , usando para especificar el tiempo de espera. + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + es un número negativo distinto de-1 milisegundo, que representa un tiempo de espera infinito o - tiempo de espera es mayor que . + Se ha eliminado la instancia de semaphoreSlim + + + Bloquea el subproceso actual hasta que pueda introducir , usando un que especifica el tiempo de espera mientras se observa un elemento . + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + + se ha cancelado. + + es un número negativo distinto de-1 milisegundo, que representa un tiempo de espera infinito o - tiempo de espera es mayor que . + Se ha eliminado la instancia de semaphoreSlimEl que creó ya se ha eliminado. + + + De forma asincrónica espera que se introduzca . + Tarea que se completará cuando se entre en el semáforo. + + + De forma asincrónica espera que se introduzca , usando un entero de 32 bits para medir el intervalo de tiempo. + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + + + De forma asincrónica, espera introducir , usando un entero de 32 bits para medir el intervalo de tiempo, mientras observa un elemento . + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + La instancia actual ya se ha eliminado. + + se ha cancelado. + + + De forma asincrónica, espera introducir , mientras observa un elemento . + Tarea que se completará cuando se entre en el semáforo. + Token que se va a observar. + La instancia actual ya se ha eliminado. + + se ha cancelado. + + + De forma asincrónica, espera introducir , usando un para medir el intervalo de tiempo. + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito o bien tiempo de espera es mayor que . + + + De forma asincrónica, espera introducir , usando un para medir el intervalo de tiempo, mientras observa un elemento . + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + Token que se va a observar. + + es un número negativo distinto de -1, que representa el tiempo de espera infinitoo bientiempo de espera es mayor que . + + se ha cancelado. + + + Representa el método al que hay que llamar cuando se va a enviar un mensaje a un contexto de sincronización. + Objeto que se ha pasado al delegado. + 2 + + + Proporciona una primitiva de bloqueo de exclusión mutua donde un subproceso que intenta adquirir el bloqueo espera en un bucle repetidamente comprobando hasta que haya un bloqueo disponible. + + + Inicializa una nueva instancia de la estructura con la opción de realizar el seguimiento de los identificadores de subprocesos para mejorar la depuración. + Indica si se han de capturar y utilizar identificadores de subprocesos con fines de depuración. + + + Adquiere el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + El argumento se debe inicializar en false antes de llamar a Enter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Libera el bloqueo. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual no es el propietario de este bloqueo. + + + Libera el bloqueo. + Valor booleano que indica si una barrera de memoria debe emitirse para publicar inmediatamente la operación de salida a otros subprocesos. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual no es el propietario de este bloqueo. + + + Obtiene un valor que indica si un subproceso mantiene actualmente el bloqueo. + Es true si cualquier subproceso mantiene actualmente el bloqueo; de lo contrario, es false. + + + Obtiene un valor que indica si el subproceso actual mantiene actualmente el bloqueo. + Es true si el subproceso actual mantiene el bloqueo; de lo contrario, es false. + El seguimiento de propiedad de subprocesos está deshabilitado. + + + Obtiene un valor que indica si el seguimiento de propiedad de subprocesos está habilitado para esta instancia. + Es true si se ha habilitado el seguimiento de propiedad de subprocesos para esta instancia; de lo contrario, es false. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que milisegundos. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Proporciona compatibilidad con la espera basada en ciclos. + + + Obtiene el número de veces que se ha llamado a en esta instancia. + Devuelve un entero que representa el número de veces que se ha llamado en esta instancia. + + + Obtiene si la llamada siguiente a da paso al procesador, lo que activa un cambio de contexto forzado. + Si la llamada siguiente a da paso al procesador, lo que activa un cambio de contexto forzado. + + + Restablece el contador de ciclos. + + + Realiza un único ciclo. + + + Itera en ciclos hasta que se satisface la condición especificada. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + El argumento de es nulo. + + + Itera en ciclos hasta que se satisface la condición especificada o se agota el tiempo de espera indicado. + Es true si la condición se satisface dentro del tiempo de espera; de lo contrario, es false. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + El argumento de es nulo. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Itera en ciclos hasta que se satisface la condición especificada o se agota el tiempo de espera indicado. + Es true si la condición se satisface dentro del tiempo de espera; de lo contrario, es false. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + Estructura que representa el número de milisegundos de espera o TimeSpan que representa -1 milisegundo para esperar indefinidamente. + El argumento de es nulo. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Proporciona la funcionalidad básica para propagar un contexto de sincronización en varios modelos de sincronización. + 2 + + + Crea una nueva instancia de la clase . + + + Cuando se invalida en una clase derivada, crea una copia del contexto de sincronización. + Un nuevo objeto . + 2 + + + Obtiene el contexto de sincronización del subproceso actual. + Objeto que representa el contexto de sincronización actual. + 1 + + + Cuando se invalida en una clase derivada, responde a la notificación de que se ha completado una operación. + + + Cuando se invalida en una clase derivada, responde a la notificación de que se ha iniciado una operación. + + + Cuando se invalida en una clase derivada, envía un mensaje asincrónico a un contexto de sincronización. + Delegado de al que se va a llamar. + Objeto que se ha pasado al delegado. + 2 + + + Cuando se invalida en una clase derivada, envía un mensaje sincrónico a un contexto de sincronización. + Delegado de al que se va a llamar. + Objeto que se ha pasado al delegado. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Establece el contexto de sincronización actual. + Objeto que se va a establecer. + 1 + + + + + + Excepción que se produce cuando un método requiere que el llamador sea propietario del bloqueo en un Monitor dado y un llamador al que no pertenece ese bloqueo llama al método. + 2 + + + Inicializa una nueva instancia de la clase con propiedades predeterminadas. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Proporciona almacenamiento local de los datos de un subproceso. + Especifica el tipo de datos que se almacena por subproceso. + + + Inicializa la instancia de . + + + Inicializa la instancia de . + Si se va a hacer un seguimiento de todos los valores establecidos en la instancia y exponerlos a través de la propiedad . + + + Inicializa una instancia de con la función especificada por el parámetro . + + que se invoca para generar un valor de inicialización diferida cuando se intenta recuperar sin que se haya inicializado anteriormente. + + es una referencia nula (Nothing en Visual Basic). + + + Inicializa una instancia de con la función especificada por el parámetro . + + que se invoca para generar un valor de inicialización diferida cuando se intenta recuperar sin que se haya inicializado anteriormente. + Si se va a hacer un seguimiento de todos los valores establecidos en la instancia y exponerlos a través de la propiedad . + + es una referencia null (Nothing en Visual Basic). + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos utilizados por esta instancia de . + Valor booleano que indica si se llama a este método debido a una llamada a . + + + Libera los recursos utilizados por esta instancia de . + + + Obtiene un valor que indica si se inicializa en el subproceso actual. + Es true si se inicializa en el subproceso actual; en caso contrario, es false. + La instancia de se ha eliminado. + + + Crea y devuelve una representación de cadena de esta instancia del subproceso actual. + Resultado de llamar al método en . + La instancia de se ha eliminado. + La propiedad del subproceso actual es una referencia nula (Nothing en Visual Basic). + La función de inicialización intentó hacer referencia de forma recursiva a . + No se proporciona ningún constructor predeterminado y no se proporciona ningún generador de valor. + + + Obtiene o establece el valor de esta instancia del subproceso actual. + Devuelve una instancia del objeto que ThreadLocal es responsable de inicializar. + La instancia de se ha eliminado. + La función de inicialización intentó hacer referencia de forma recursiva a . + No se proporciona ningún constructor predeterminado y no se proporciona ningún generador de valor. + + + Obtiene una lista de todos los valores almacenados actualmente por todos los subprocesos que han tenido acceso a esta instancia. + Lista de todos los valores almacenados actualmente por todos los subprocesos que han tenido acceso a esta instancia. + La instancia de se ha eliminado. + + + Contiene los métodos para realizar operaciones de memoria volátil. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee la referencia al objeto desde el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Referencia al que se ha leído.Esta referencia es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + Tipo del campo que se va a leer.Debe ser un tipo de referencia, no un tipo de valor. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de memoria antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe la referencia de objeto especificada en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe la referencia de objeto. + Referencia de objeto que se va a escribir.La referencia se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + Tipo del campo que se va a escribir.Debe ser un tipo de referencia, no un tipo de valor. + + + Excepción que se produce cuando se intenta abrir una exclusión mutua o semáforo del sistema que no existe. + 2 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/fr/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/fr/System.Threading.xml new file mode 100644 index 000000000..6bbaf9759 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/fr/System.Threading.xml @@ -0,0 +1,1833 @@ + + + + System.Threading + + + + Exception levée lorsqu'un thread acquiert un objet qu'un autre thread a abandonné en se terminant sans le libérer. + 1 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un index spécifié pour le mutex abandonné, le cas échéant, et un objet qui représente le mutex. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur qui indique la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur et une exception interne spécifiés. + Message d'erreur qui indique la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié, l'exception interne, l'index pour le mutex abandonné, le cas échéant, et un objet qui représente le mutex. + Message d'erreur qui indique la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié, l'index du mutex abandonné, le cas échéant, et le mutex abandonné. + Message d'erreur qui indique la raison de l'exception. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Obtient le mutex abandonné qui a provoqué l'exception, s'il est connu. + Objet qui représente le mutex abandonné ou null si les mutex abandonnés n'ont pas pu être identifiés. + 1 + + + Obtient l'index du mutex abandonné qui a provoqué l'exception, s'il est connu. + Index, dans le tableau de handles d'attente passés à la méthode , de l'objet qui représente le mutex abandonné ou -1 si l'index du mutex abandonné n'a pas pu être déterminé. + 1 + + + Représente les données ambiantes qui sont locales à un flux de contrôle asynchrone donné, par exemple une méthode asynchrone. + Type des données ambiantes. + + + Instancie une instance de qui ne reçoit pas de notifications de modification. + + + Instancie une instance locale de qui ne reçoit pas de notifications de modification. + Le délégué est appelé à chaque modification de la valeur actuelle sur n'importe quel thread. + + + Obtient ou définit la valeur des données ambiantes. + Valeur des données ambiantes. + + + Classe qui fournit les informations de modification des données aux instances de qui s'inscrivent pour les notifications de modification. + Type des données. + + + Obtient la valeur actuelle des données. + Valeur actuelle des données. + + + Obtient la valeur précédente des données. + Valeur précédente des données. + + + Retourne une valeur qui indique si la valeur est modifiée en raison d'un changement du contexte d'exécution. + true si la valeur est modifiée en raison d'un changement du contexte d'exécution ; sinon, false. + + + Avertit un thread en attente qu'un événement s'est produit.Cette classe ne peut pas être héritée. + 2 + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé". + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + + + Permet à plusieurs tâches de travailler en parallèle de manière coopérative sur un algorithme via plusieurs phases. + + + Initialise une nouvelle instance de la classe . + Nombre de threads participants. + + est inférieur à 0 ou supérieur à 32,767. + + + Initialise une nouvelle instance de la classe . + Nombre de threads participants. + + à exécuter après chaque phase. null (nothing en Visual Basic) peut être passé pour indiquer qu'aucune action n'est effectuée. + + est inférieur à 0 ou supérieur à 32,767. + + + Signale à qu'il y aura un participant supplémentaire. + Numéro de la phase du cloisonnement à laquelle les nouveaux participants participeront en premier. + L'instance actuelle a déjà été supprimée. + L'ajout d'un participant provoquerait l'augmentation du nombre de participants du cloisonnement au-delà de 32 767.ouLa méthode a été appelée à partir d'une action post-phase. + + + Signale à qu'il y aura des participants supplémentaires. + Numéro de la phase du cloisonnement à laquelle les nouveaux participants participeront en premier. + Nombre de participants supplémentaires à ajouter au cloisonnement. + L'instance actuelle a déjà été supprimée. + + est inférieur à 0.ouL'ajout de participants () provoquerait l'augmentation du nombre de participants du cloisonnement au-delà de 32 767. + La méthode a été appelée à partir d'une action post-phase. + + + Obtient le numéro de la phase actuelle du cloisonnement. + Retourne le numéro de la phase actuelle du cloisonnement. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + La méthode a été appelée à partir d'une action post-phase. + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le nombre total de participants au cloisonnement. + Retourne le nombre total de participants au cloisonnement. + + + Obtient le nombre de participants au cloisonnement qui n'ont pas encore été signalés dans la phase actuelle. + Retourne le nombre de participants au cloisonnement qui n'ont pas encore été signalés dans la phase actuelle. + + + Signale à qu'il y aura un participant en moins. + L'instance actuelle a déjà été supprimée. + La barrière a déjà 0 participant.ouLa méthode a été appelée à partir d'une action post-phase. + + + Signale à qu'il y aura moins de participants. + Nombre de participants supplémentaires à supprimer du cloisonnement. + L'instance actuelle a déjà été supprimée. + + est inférieur à 0. + La barrière a déjà 0 participant.ouLa méthode a été appelée à partir d'une action post-phase. oule nombre de participant actuel est inférieur au participantCount spécifié + Le nombre total de participants est inférieur au spécifié + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement. + L'instance actuelle a déjà été supprimée. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + Si une exception est levée par l'action de post-phase d'un cloisonnement après que tous les threads participants aient appelé SignalAndWait, l'exception sera incluse dans un wrapper dans une BarrierPostPhaseException et levée pour tous les threads participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un entier signé 32 bits pour mesurer le délai d'attente. + si tous les participants ont atteint le cloisonnement dans le délai spécifié ; sinon false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + Si une exception est levée par l'action de post-phase d'un cloisonnement après que tous les threads participants aient appelé SignalAndWait, l'exception sera incluse dans un wrapper dans une BarrierPostPhaseException et levée pour tous les threads participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un entier signé 32 bits pour mesurer le délai d'attente, tout en observant un jeton d'annulation. + si tous les participants ont atteint le cloisonnement dans le délai spécifié ; sinon false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, tout en observant un jeton d'annulation. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un objet qui mesure l'intervalle de temps. + true si tous les autres participants ont atteint le cloisonnement ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini, ou sa valeur est supérieure à 32 767. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un objet qui mesure l'intervalle de temps, tout en observant un jeton d'annulation. + true si tous les autres participants ont atteint le cloisonnement ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + L'exception levée lorsque l'action post-phase d'un échoue. + + + Initialise une nouvelle instance de la classe avec un message système qui décrit l'erreur. + + + Initialise une nouvelle instance de la classe avec l'exception interne spécifiée. + Exception qui constitue la cause de l'exception actuelle. + + + Initialise une nouvelle instance de la classe avec un message spécifié décrivant l'erreur. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Représente une méthode à appeler dans un nouveau contexte. + Objet contenant les informations que la méthode de rappel doit utiliser à chacune de ses exécutions. + 1 + + + Représente une primitive de synchronisation qui est signalée lorsque son décompte atteint zéro. + + + Initialise une nouvelle instance de la classe à l'aide du décompte spécifié. + Nombre de signaux initialement requis pour définir . + + est inférieur à 0. + + + Incrémente de un le décompte actuel de . + L'instance actuelle a déjà été supprimée. + L'instance actuelle est déjà définie.ou est supérieur ou égal à . + + + Incrémente d'une valeur spécifiée le décompte actuel de . + Valeur d'incrément de . + L'instance actuelle a déjà été supprimée. + + est inférieur ou égal à 0. + L'instance actuelle est déjà définie.ou est égal à ou supérieur à une fois le nombre été incrémenté par + + + Obtient le nombre de signaux restants requis pour définir l'événement. + Nombre de signaux restants requis pour définir l'événement. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le nombre de signaux initialement requis pour définir l'événement. + Nombre de signaux initialement requis pour définir l'événement. + + + Détermine si l'événement est défini. + true si l'événement est défini ; sinon, false. + + + Réinitialise avec la valeur . + L'instance actuelle a déjà été supprimée. + + + Définit la propriété spécifiée sur la valeur indiquée. + Nombre de signaux requis pour définir . + L'instance actuelle a déjà été supprimée. + + est inférieur à 0. + + + Enregistre un signal avec le , en décrémentant la valeur de . + true si le décompte a atteint zéro en raison du signal et que l'événement a été défini ; sinon, false. + L'instance actuelle a déjà été supprimée. + L'instance actuelle est déjà définie. + + + Inscrit plusieurs signaux avec , en décrémentant la valeur de selon la valeur spécifiée. + true si le décompte a atteint zéro en raison des signaux et que l'événement a été défini ; sinon, false. + Nombre de signaux à inscrire. + L'instance actuelle a déjà été supprimée. + + est inférieur à 1. + L'instance actuelle est déjà définie. - ou - Ou est supérieur à . + + + Essaie d'incrémenter par un. + true si l'incrémentation a réussi ; sinon, false.Si est déjà à zéro, cette méthode retourne la valeur false. + L'instance actuelle a déjà été supprimée. + + est égal à . + + + Essaie d'incrémenter par une valeur spécifiée. + true si l'incrémentation a réussi ; sinon, false.Si est déjà à zéro, la valeur false est retournée. + Valeur d'incrément de . + L'instance actuelle a déjà été supprimée. + + est inférieur ou égal à 0. + L'instance actuelle est déjà définie.ou + est supérieur ou égal à . + + + Bloque le thread actuel jusqu'à ce que soit défini. + L'instance actuelle a déjà été supprimée. + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un entier signé 32 bits permettant de mesurer le délai d'attente. + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce que soit défini, à l'aide d'un entier signé 32 bits permettant de mesurer le délai d'attente, tout en observant un . + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce que soit défini, tout en observant un . + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un permettant de mesurer le délai d'attente. + true si a été défini ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un permettant de mesurer le délai d'attente, tout en observant un . + true si a été défini ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Obtient un qui est utilisé pour attendre l'événement à définir. + + qui est utilisé pour attendre l'événement à définir. + L'instance actuelle a déjà été supprimée. + + + Indique si un est réinitialisé automatiquement ou manuellement après la réception d'un signal. + 2 + + + Une fois signalé, le se réinitialise automatiquement après avoir libéré un seul thread.Si aucun thread n'attend, le conserve l'état signalé jusqu'à ce qu'un thread se bloque et se réinitialise après l'avoir libéré. + + + Lorsqu'il est signalé, le libère tous les threads en attente et conserve l'état signalé jusqu'à sa réinitialisation manuelle. + + + Représente un événement de synchronisation de threads. + 2 + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement et s'il se réinitialise automatiquement ou manuellement. + true pour définir l'état initial comme étant signalé ; false pour le définir comme étant non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement s'il a été créé à la suite de cet appel, s'il se réinitialise automatiquement ou manuellement, ainsi que le nom d'un événement de synchronisation du système. + true pour définir l'état initial comme signalé si l'événement nommé est créé en conséquence de cet appel ; false pour le définir comme non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + Nom d'un événement de synchronisation à l'échelle du système. + Une erreur Win32 s'est produite. + L'événement nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + L'événement nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + dépasse 260 caractères. + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement s'il a été créé à la suite de cet appel, s'il se réinitialise automatiquement ou manuellement, ainsi que le nom d'un événement de synchronisation du système et une variable booléenne dont la valeur après l'appel indique si l'événement système nommé a été créé. + true pour définir l'état initial comme signalé si l'événement nommé est créé en conséquence de cet appel ; false pour le définir comme non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + Nom d'un événement de synchronisation à l'échelle du système. + Cette méthode retourne true si un événement local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si l'événement système nommé spécifié a été créé ; false si l'événement système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + Une erreur Win32 s'est produite. + L'événement nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + L'événement nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + dépasse 260 caractères. + + + Ouvre l'événement de synchronisation nommé spécifié s'il existe déjà. + Objet qui représente l'événement système nommé. + Nom de l'événement de synchronisation système à ouvrir. + + est une chaîne vide. ou dépasse 260 caractères. + + a la valeur null. + L'événement de système nommé n'existe pas. + Une erreur Win32 s'est produite. + L'événement nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Définit l'état de l'événement comme étant non signalé, entraînant le blocage des threads. + true si l'opération aboutit ; sinon, false. + La méthode a été précédemment appelée sur ce . + 2 + + + Définit l'état de l'événement comme étant signalé, ce qui permet à un ou plusieurs threads en attente de continuer. + true si l'opération aboutit ; sinon, false. + La méthode a été précédemment appelée sur ce . + 2 + + + Ouvre l'événement de synchronisation nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si l'événement de synchronisation nommé a été ouvert ; sinon, false. + Nom de l'événement de synchronisation système à ouvrir. + Lorsque cette méthode est retournée, contient un objet qui représente l'événement de synchronisation nommé si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme non initialisé. + + est une chaîne vide.ou dépasse 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + L'événement nommé existe, mais l'utilisateur n'a pas l'accès de sécurité voulu. + + + Gère le contexte d'exécution du thread actuel.Cette classe ne peut pas être héritée. + 2 + + + Capture le contexte d'exécution du thread actuel. + Objet capturant le contexte d'exécution du thread actuel. + 1 + + + Exécute une méthode dans un contexte d'exécution spécifié sur le thread actuel. + + à définir. + Délégué représentant la méthode à exécuter dans le contexte d'exécution fourni. + Objet à passer à la méthode de rappel. + + a la valeur null.ouLe n'a pas été acquis à l'aide d'une opération de capture. ouLe a déjà été utilisé comme argument pour un appel . + 1 + + + + + + Fournit des opérations atomiques pour des variables partagées par plusieurs threads. + 2 + + + Ajoute deux entiers 32 bits et remplace le premier entier par la somme, sous la forme d'une opération atomique. + La nouvelle valeur stockée à . + Variable qui contient la première valeur à ajouter.La somme des deux valeurs est stockée dans . + Valeur à ajouter à l'entier à . + The address of is a null pointer. + 1 + + + Ajoute deux entiers 64 bits et remplace le premier entier par la somme, sous la forme d'une opération atomique. + La nouvelle valeur stockée à . + Variable qui contient la première valeur à ajouter.La somme des deux valeurs est stockée dans . + Valeur à ajouter à l'entier à . + The address of is a null pointer. + 1 + + + Compare deux nombres à virgule flottante double précision et remplace le premier en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux entiers signés de 32 bits et remplace la première valeur en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux entiers signés de 64 bits et remplace la première valeur en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux handles ou pointeurs spécifiques à la plateforme et remplace le premier en cas d'égalité. + Valeur d'origine dans . + + de destination, dont la valeur est comparée à celle de et qui peut être remplacée par . + + qui remplace la valeur de destination si la comparaison conclut à une égalité. + + comparée à la valeur de . + The address of is a null pointer. + 1 + + + Compare deux objets et remplace le premier en cas d'égalité des références. + Valeur d'origine dans . + Objet de destination comparé à et qui peut être remplacé. + Objet qui remplace l'objet de destination si la comparaison conclut à une égalité. + Objet qui est comparé à l'objet se trouvant à . + The address of is a null pointer. + 1 + + + Compare deux nombres à virgule flottante simple précision et remplace le premier en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux instances du type référence spécifié et remplace la première en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée avec et qui peut être remplacée.C'est un paramètre référence (ref en C#, ByRef en Visual Basic). + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + Type à utiliser pour , et .Ce type doit être un type référence. + The address of is a null pointer. + + + Décrémente une variable spécifiée et stocke le résultat, sous la forme d'une opération atomique. + Valeur décrémentée. + Variable dont la valeur doit être décrémentée. + The address of is a null pointer. + 1 + + + Décrémente la variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur décrémentée. + Variable dont la valeur doit être décrémentée. + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un nombre à virgule flottante double précision, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte un entier signé 32 bits à une valeur spécifiée, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un entier signé 64 bits, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un handle ou un pointeur spécifique à la plateforme, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un objet, puis retourne une référence à l'objet d'origine sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un nombre à virgule flottante simple précision, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à une variable du type spécifié et retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée.C'est un paramètre référence (ref en C#, ByRef en Visual Basic). + Valeur affectée au paramètre . + Type à utiliser pour et .Ce type doit être un type référence. + The address of is a null pointer. + + + Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur incrémentée. + Variable dont la valeur doit être incrémentée. + The address of is a null pointer. + 1 + + + Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur incrémentée. + Variable dont la valeur doit être incrémentée. + The address of is a null pointer. + 1 + + + Synchronise l'accès à la mémoire comme suit : le processeur qui exécute le thread actuel ne peut pas réorganiser les instructions de sorte que les accès à la mémoire avant l'appel de s'exécutent après les accès à la mémoire postérieurs à l'appel de . + + + Retourne une valeur 64 bits chargée sous la forme d'une opération atomique. + Valeur chargée. + Valeur 64 bits à charger. + 1 + + + Fournit des routines d'initialisation tardives. + + + Initialise un type référence cible avec le constructeur par défaut du type s'il n'a pas déjà été initialisé. + Référence initialisée de type . + Référence de type à initialiser si elle ne l'a pas déjà été. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible ou un type valeur avec son constructeur par défaut s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence ou valeur de type à initialiser si elle ne l'a pas déjà été. + Référence à une valeur booléenne qui détermine si la cible a déjà été initialisée. + Référence à un objet utilisé comme verrou mutuellement exclusif pour l'initialisation de .Si est null null, un nouvel objet est instancié. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible ou un type valeur à l'aide d'une fonction spécifiée s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence ou valeur de type à initialiser si elle ne l'a pas déjà été. + Référence à une valeur booléenne qui détermine si la cible a déjà été initialisée. + Référence à un objet utilisé comme verrou mutuellement exclusif pour l'initialisation de .Si est null null, un nouvel objet est instancié. + Fonction appelée pour initialiser la référence ou la valeur. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible à l'aide d'une fonction spécifiée s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence de type à initialiser si elle ne l'a pas déjà été. + Fonction appelée pour initialiser la référence. + Type référence de la référence à initialiser. + Le type n'a pas de constructeur par défaut. + + a retourné null (Nothing en Visual Basic). + + + L'exception levée lorsque l'entrée récursive dans un verrou n'est pas compatible avec la stratégie de récurrence pour le verrou. + 2 + + + Initialise une nouvelle instance de la classe avec un message système qui décrit l'erreur. + 2 + + + Initialise une nouvelle instance de la classe avec un message spécifié décrivant l'erreur. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture système en cours. + 2 + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture système en cours. + Exception qui a provoqué l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + 2 + + + Spécifie si un verrou peut être entré plusieurs fois par le même thread. + + + Si un thread essaie d'entrer un verrou de manière récursive, une exception est levée.Certaines classes peuvent autoriser certaines récurrences lorsque ce paramètre est appliqué. + + + Un thread peut entrer un verrou de manière récursive.Certaines classes peuvent restreindre cette fonction. + + + Avertit un ou plusieurs threads en attente qu'un événement s'est produit.Cette classe ne peut pas être héritée. + 2 + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini comme signalé. + true pour définir un état initial signalé ; false pour définir un état initial non signalé. + + + Fournit une version allégée de . + + + Initialise une nouvelle instance de la classe avec l'état initial "non signalé". + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé". + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé" et un nombre de spins spécifié. + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + Nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + + is less than 0 or greater than the maximum allowed value. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient une valeur qui indique si l'événement est défini. + true si l'événement a été défini ; sinon, false. + + + Définit l'état de l'événement à "non signalé", ce qui entraîne le blocage des threads. + The object has already been disposed. + + + Définit l'état de l'événement à "signalé", ce qui permet à un ou plusieurs threads en attente sur l'événement de continuer à s'exécuter. + + + Obtient le nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + Retourne le nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps. + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps, tout en observant un . + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel reçoive un signal, tout en observant un . + + à observer. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un pour mesurer l'intervalle de temps. + true si a été défini ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde pour un délai d'attente infini. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un pour mesurer l'intervalle de temps, tout en observant un . + true si a été défini ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde pour un délai d'attente infini. + + à observer. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Obtient l'objet sous-jacent pour ce . + Objet d'événement sous-jacent pour ce . + + + Fournit un mécanisme qui synchronise l'accès aux objets. + 2 + + + Acquiert un verrou exclusif sur l'objet spécifié. + Objet sur lequel acquérir le verrou du moniteur. + Le paramètre a la valeur null. + 1 + + + Acquiert un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel attendre. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou.Remarque   Si aucune exception ne se produit, la sortie de cette méthode est toujours true. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + + Libère un verrou exclusif sur l'objet spécifié. + Objet sur lequel libérer le verrou. + Le paramètre a la valeur null. + Le thread en cours ne possède pas le verrou pour l'objet spécifié. + 1 + + + Détermine si le thread actuel détient le verrou sur l'objet spécifié. + true si le thread actuel détient le verrou sur  ; sinon, false. + Objet à tester. + + a la valeur null. + + + Avertit un thread situé dans la file d'attente en suspens d'un changement d'état de l'objet verrouillé. + Objet attendu par un thread. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + 1 + + + Avertit tous les threads en attente d'un changement d'état de l'objet. + Objet qui envoie l'impulsion. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + 1 + + + Essaie d'acquérir un verrou exclusif sur l'objet spécifié. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + Le paramètre a la valeur null. + 1 + + + Tente d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + + Tentatives d'acquisition d'un verrou exclusif sur l'objet spécifié au cours du nombre spécifié de millisecondes. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou en millisecondes. + Le paramètre a la valeur null. + + est négatif et différent de . + 1 + + + Tente, pendant le nombre spécifié de millisecondes, d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou en millisecondes. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + est négatif et différent de . + + + Tentatives d'acquisition d'un verrou exclusif sur l'objet spécifié au cours de la période spécifiée. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + + représentant le délai d'attente du verrou.Une valeur de –1 milliseconde spécifie une attente infinie. + Le paramètre a la valeur null. + La valeur en millisecondes de est négative et différente de (–1 milliseconde), ou elle est supérieure à . + 1 + + + Tente, pendant le délai spécifié, d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou.Une valeur de –1 milliseconde spécifie une attente infinie. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + La valeur en millisecondes de est négative et différente de (–1 milliseconde), ou elle est supérieure à . + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou. + true si l'appel est retourné car l'appelant a de nouveau acquis le verrou pour l'objet spécifié.Cette méthode ne retourne rien si le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + 1 + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou.Si le délai d'attente spécifié est écoulé, le thread intègre la file d'attente opérationnelle. + true si le verrou a fait l'objet d'une nouvelle acquisition avant l'expiration du délai spécifié ; false si le verrou a fait l'objet d'une nouvelle acquisition après l'expiration du délai spécifié.La méthode ne retourne pas de valeur tant que le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + Nombre de millisecondes à attendre avant que le thread intègre la file d'attente opérationnelle. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + La valeur du paramètre est négative et différente de . + 1 + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou.Si le délai d'attente spécifié est écoulé, le thread intègre la file d'attente opérationnelle. + true si le verrou a fait l'objet d'une nouvelle acquisition avant l'expiration du délai spécifié ; false si le verrou a fait l'objet d'une nouvelle acquisition après l'expiration du délai spécifié.La méthode ne retourne pas de valeur tant que le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + + qui représente le temps à attendre avant que le thread n'intègre la file d'attente opérationnelle. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + La valeur en millisecondes du paramètre est négative et ne représente pas (–1 milliseconde) ou est supérieure à . + 1 + + + Primitive de synchronisation qui peut également être utilisée pour la synchronisation entre processus. + 1 + + + Initialise une nouvelle instance de la classe avec des propriétés par défaut. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex. + true pour accorder au thread appelant la propriété initiale du mutex ; sinon, false. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, et une chaîne représentant le nom du mutex. + true pour donner au thread appelant la propriété initiale du mutex système nommé si celui-ci est créé en réponse à cet appel ; sinon, false. + Nom du .Si cette valeur est null, est sans nom. + Le mutex nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + Une erreur Win32 s'est produite. + Le mutex nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + est plus de 260 caractères. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, une chaîne qui représente le nom du mutex et une valeur booléenne qui, quand la méthode retourne son résultat, indique si la propriété initiale du mutex a été accordée au thread appelant. + true pour donner au thread appelant la propriété initiale du mutex système nommé si celui-ci est créé en réponse à cet appel ; sinon, false. + Nom du .Si cette valeur est null, est sans nom. + Cette méthode retourne une valeur booléenne qui est true si un mutex local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si le mutex système nommé spécifié a été créé ; false si le mutex système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + Le mutex nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + Une erreur Win32 s'est produite. + Le mutex nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + est plus de 260 caractères. + + + Ouvre le mutex nommé spécifié, s'il existe déjà. + Objet qui représente le mutex système nommé. + Nom du mutex système à ouvrir. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Le mutex nommé n'existe pas. + Une erreur Win32 s'est produite. + Le mutex nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Libère l'objet une seule fois. + Le thread appelant ne possède pas le mutex. + 1 + + + Ouvre le mutex nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si le mutex nommé a été ouvert ; sinon, false. + Nom du mutex système à ouvrir. + Quand cette méthode est retournée, contient un objet qui représente la structure mutex nommée si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme étant non initialisé. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + Le mutex nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + + + Représente un verrou utilisé pour gérer l'accès à une ressource, en autorisant plusieurs threads pour la lecture ou un accès exclusif en écriture. + + + Initialise une nouvelle instance de la classe avec des valeurs de propriété par défaut. + + + Initialise une nouvelle instance de la classe , en spécifiant la stratégie de récurrence du verrou. + Une des valeurs d'énumération qui spécifie la stratégie de récurrence du verrou. + + + Obtient le nombre total de threads uniques qui ont entré le verrou en mode lecture. + Nombre de threads uniques qui ont entré le verrou en mode lecture. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Essaie d'entrer le verrou en mode lecture. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Réduit le nombre de récurrences pour le mode lecture, et quitte le mode lecture si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in read mode. + + + Réduit le nombre de récurrences pour le mode pouvant être mis à niveau, et quitte le mode pouvant être mis à niveau si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in upgradeable mode. + + + Réduit le nombre de récurrences pour le mode écriture, et quitte le mode écriture si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in write mode. + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode lecture. + true si le thread actuel a entré le verrou en mode lecture ; sinon, false. + 2 + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode pouvant être mis à niveau. + true si le thread actuel a entré le verrou en mode pouvant être mis à niveau ; sinon, false. + 2 + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode écriture. + true si le thread actuel a entré le verrou en mode écriture ; sinon, false. + 2 + + + Obtient une valeur qui indique la stratégie de récurrence pour l'objet actuel. + Une des valeurs d'énumération qui spécifie la stratégie de récurrence du verrou. + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode lecture, comme une indication de récurrence. + 0 (zéro) si le thread actuel n'a pas entré le verrou en mode lecture, 1 si le thread a entré le verrou en mode lecture mais pas de façon récursive, ou n si le thread a entré le verrou de façon récursive n - 1 fois. + 2 + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode pouvant être mis à niveau, comme une indication de récurrence. + 0 si le thread actuel n'a pas entré le verrou en mode pouvant être mis à niveau, 1 si le thread a entré le verrou en mode pouvant être mis à niveau mais pas de façon récursive, ou n si le thread a entré le verrou en mode pouvant être mis à niveau de façon récursive n - 1 fois. + 2 + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode écriture, comme une indication de récurrence. + 0 si le n si le thread a entré le verrou en mode écriture de façon récursive n - 1 fois. + 2 + + + Essaie d'entrer le verrou en mode lecture, avec un délai d'attente entier facultatif. + true si le thread appelant est entré en mode lecture, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode lecture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode lecture, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode de mise à niveau, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode de mise à niveau, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode écriture, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode écriture, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode lecture. + Nombre total de threads qui attendent pour entrer en mode lecture. + 2 + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode pouvant être mis à niveau. + Nombre total de threads qui attendent pour entrer en mode pouvant être mis à niveau. + 2 + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode écriture. + Nombre total de threads qui attendent pour entrer en mode écriture. + 2 + + + Limite le nombre des threads qui peuvent accéder simultanément à une ressource ou un pool de ressources. + 1 + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est supérieur à . + + est inférieur à 1.ou est inférieur à 0. + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées, et en spécifiant en option le nom d'un objet sémaphore système. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nom d'un objet de sémaphore système nommé. + + est supérieur à .ou est plus de 260 caractères. + + est inférieur à 1.ou est inférieur à 0. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe et possède la sécurité du contrôle d'accès, et l'utilisateur n'a pas . + Le sémaphore nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées, en spécifiant en option le nom d'un objet sémaphore système et en spécifiant une variable qui reçoit une valeur indiquant si un sémaphore système a été créé. + Nombre initial de demandes pour le sémaphore qui peut être satisfait simultanément. + Nombre maximal de demandes pour le sémaphore qui peut être satisfait simultanément. + Nom d'un objet de sémaphore système nommé. + Cette méthode retourne true si un sémaphore local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si le sémaphore système nommé spécifié a été créé ; false si le sémaphore système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + + est supérieur à . ou est plus de 260 caractères. + + est inférieur à 1.ou est inférieur à 0. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe et possède la sécurité du contrôle d'accès, et l'utilisateur n'a pas . + Le sémaphore nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + + Ouvre le sémaphore nommé spécifié s'il existe déjà. + Objet qui représente le sémaphore système nommé. + Nom du sémaphore système à ouvrir. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Le sémaphore nommé n'existe pas. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Quitte le sémaphore et retourne le compteur antérieur. + Compteur du sémaphore avant appel de la méthode . + Le compteur du sémaphore est déjà à la valeur maximale. + Une erreur Win32 s'est produite avec un sémaphore nommé. + Le sémaphore actuel représente un sémaphore système nommé, mais l'utilisateur ne détient pas de droits .ouLe sémaphore actuel représente un sémaphore système nommé, mais il n'a pas été ouvert avec des droits . + 1 + + + Quitte le sémaphore un nombre spécifié de fois et retourne le compteur précédent. + Compteur du sémaphore avant appel de la méthode . + Nombre de fois où quitter le sémaphore. + + est inférieur à 1. + Le compteur du sémaphore est déjà à la valeur maximale. + Une erreur Win32 s'est produite avec un sémaphore nommé. + Le sémaphore actuel représente un sémaphore système nommé, mais l'utilisateur ne détient pas de droits .ouLe sémaphore actuel représente un sémaphore système nommé, mais il n'a pas été ouvert avec des droits . + 1 + + + Ouvre le sémaphore nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si le sémaphore nommé a été ouvert ; sinon, false. + Nom du sémaphore système à ouvrir. + Quand cette méthode est retournée, contient un objet qui représente le sémaphore nommé si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme étant non initialisé. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + + + Exception levée lorsque la méthode est appelée sur un sémaphore dont le compteur est déjà au maximum. + 2 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Représente une alternative légère à qui limite le nombre de threads pouvant accéder simultanément à une ressource ou à un pool de ressources. + + + Initialise une nouvelle instance de la classe , en spécifiant le nombre initial de demandes qui peuvent être accordées simultanément. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est inférieur à 0. + + + Initialise une nouvelle instance de la classe , en spécifiant le nombre initial et le nombre maximal de demandes qui peuvent être accordées simultanément. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est inférieur à 0 ou est supérieur à ou est inférieur ou égal à 0. + + + Retourne un qui peut être utilisé pour l'attente sur le sémaphore. + + qui peut être utilisé pour l'attente sur le sémaphore. + + a été supprimé. + + + Obtient le nombre de threads restants qui peuvent accéder à l'objet . + Nombre de threads restants qui peuvent accéder au sémaphore. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par le , et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Libère l'objet une seule fois. + Décompte précédent de . + L'instance actuelle a déjà été supprimée. + Le a déjà atteint sa taille maximale. + + + Libère l'objet un nombre de fois déterminé. + Décompte précédent de . + Nombre de fois où quitter le sémaphore. + L'instance actuelle a déjà été supprimée. + + est inférieur à 1. + Le a déjà atteint sa taille maximale. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à . + L'instance actuelle a déjà été supprimée. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un entier signé 32 bits qui spécifie le délai d'attente. + true si le thread actuel a accédé avec succès à  ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un entier signé 32 bits qui spécifie le délai d'attente, tout en observant un . + true si le thread actuel a accédé avec succès à  ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + Le instance a été supprimée, ou qui créé a été supprimé. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , tout en observant un . + Jeton à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée.ouLes créés a déjà été supprimé. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un pour spécifier le délai d'attente. + true si le thread actuel a accédé avec succès à  ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde de seconde, pour attendre indéfiniment. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + L'instance de semaphoreSlim a été supprimée + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un qui spécifie le délai d'attente, tout en observant un . + true si le thread actuel a accédé avec succès à  ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente -1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + L'instance de semaphoreSlim a été suppriméeLe qui a créé a déjà été supprimé. + + + Attend de façon asynchrone avant d'accéder à . + Tâche qui se termine après l'accès au sémaphore. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps. + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps, tout en observant un . + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + a été annulé. + + + Attend de façon asynchrone d'accéder à , tout en observant un . + Tâche qui se termine après l'accès au sémaphore. + Jeton à observer. + L'instance actuelle a déjà été supprimée. + + a été annulé. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un pour mesurer l'intervalle de temps. + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. ou délai d'attente supérieur à . + + + Attend de façon asynchrone d'accéder à , à l'aide d'un pour mesurer l'intervalle de temps, tout en observant un . + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente -1 millième de seconde, pour attendre indéfiniment. + Jeton à observer. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini.oudélai d'attente supérieur à . + + a été annulé. + + + Représente une méthode à appeler lorsqu'un message doit être distribué à un contexte de synchronisation. + Objet passé au délégué. + 2 + + + Fournit une primitive de verrou d'exclusion mutuelle où un thread qui tente d'acquérir le verrou attend dans une boucle en vérifiant de manière répétée jusqu'à ce que le verrou devienne disponible. + + + Initialise une nouvelle instance de la structure de avec l'option permettant de suivre les ID de thread afin d'améliorer le débogage. + Indique s'il faut capturer et utiliser des ID de thread à des fins de débogage. + + + Acquiert le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + L'argument doit être initialisé sur false avant d'appeler ENTRÉE. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Libère le verrou. + Le suivi de la propriété du thread est autorisé, et le thread actuel n'est pas le propriétaire de ce verrou. + + + Libère le verrou. + Valeur booléenne qui indique si une barrière mémoire doit être émise pour publier immédiatement l'opération de sortie sur d'autres threads. + Le suivi de la propriété du thread est autorisé, et le thread actuel n'est pas le propriétaire de ce verrou. + + + Obtient une valeur qui indique si le verrou est actuellement détenu par un thread. + True si le verrou est actuellement détenu par un thread ; sinon, false. + + + Obtient une valeur qui indique si le verrou est détenu par le thread actuel. + True si le verrou est détenu par le thread actuel ; sinon, false. + Le suivi de la propriété du thread est désactivé. + + + Obtient une valeur qui indique si le suivi de la propriété des threads est activé pour cette instance. + True si le suivi de la propriété du thread est autorisé pour cette instance ; sinon, false. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini - ou - le délai d'attente est supérieur à millisecondes. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Fournit une prise en charge de l'attente basée sur les spins. + + + Obtient le nombre de fois où a été appelé sur cette instance. + Retourne un entier qui représente le nombre d'appels de sur cette instance. + + + Obtient une valeur qui indique si l'appel suivant à générera le processeur, en déclenchant un changement de contexte forcé. + Indique si l'appel suivant à générera le processeur, en déclenchant un changement de contexte forcé. + + + Réinitialise le compteur de spins. + + + Exécute un seul spin. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + L'argument a la valeur null. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite ou jusqu'à ce que le délai d'attente expire. + True si la condition est satisfaite dans le délai d'attente ; sinon, false. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'argument a la valeur null. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite ou jusqu'à ce que le délai d'attente expire. + True si la condition est satisfaite dans le délai d'attente ; sinon, false. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + + qui représente le nombre de millièmes de secondes à attendre, ou TimeSpan qui représente -1 millième de seconde pour attendre indéfiniment. + L'argument a la valeur null. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Fournit les fonctionnalités de base pour propager un contexte de synchronisation dans plusieurs modèles de synchronisation. + 2 + + + Crée une instance de la classe . + + + En cas de substitution dans une classe dérivée, crée une copie du contexte de synchronisation. + Nouvel objet . + 2 + + + Obtient le contexte de synchronisation du thread actuel. + Objet représentant le contexte de synchronisation actuel. + 1 + + + Lors d'une substitution dans une classe dérivée, répond à la notification selon laquelle une opération est terminée. + + + Lors d'une substitution dans une classe dérivée, répond à la notification selon laquelle une opération est lancée. + + + Lors d'une substitution dans une classe dérivée, distribue un message asynchrone à un contexte de synchronisation. + Délégué à appeler. + Objet passé au délégué. + 2 + + + Lors d'une substitution dans une classe dérivée, distribue un message synchrone à un contexte de synchronisation. + Délégué à appeler. + Objet passé au délégué. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Définit le contexte de synchronisation actuel. + Objet à définir. + 1 + + + + + + Exception levée lorsqu'une méthode exige de l'appelant qu'il possède un verrou sur un objet Monitor donné et que la méthode est appelée par un appelant qui ne possède pas ce verrou. + 2 + + + Initialise une nouvelle instance de la classe avec des propriétés par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Fournit le stockage local des données de thread. + Spécifie le type de données stockées par thread. + + + Initialise l'instance de . + + + Initialise l'instance de . + Indique s'il faut suivre toutes les valeurs définies dans l'instance et les exposer via la propriété . + + + Initialise l'instance de avec la fonction spécifiée. + + appelé pour produire une valeur initialisée tardivement lorsqu'une tentative est effectuée pour récupérer sans qu'il ait été précédemment initialisé. + + est une référence null (Nothing en Visual Basic). + + + Initialise l'instance de avec la fonction spécifiée. + + appelé pour produire une valeur initialisée tardivement lorsqu'une tentative est effectuée pour récupérer sans qu'il ait été précédemment initialisé. + Indique s'il faut suivre toutes les valeurs définies dans l'instance et les exposer via la propriété . + + est une référence null (Nothing en Visual Basic). + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources utilisées par cette instance de . + Valeur booléenne qui indique si cette méthode est appelée en raison d'un appel à . + + + Libère les ressources utilisées par cette instance de . + + + Obtient une valeur qui indique si est initialisé sur le thread actuel. + True si est initialisé sur le thread actuel ; sinon, false. + L'instance de a été supprimée. + + + Crée et retourne une représentation sous forme de chaîne de cette instance pour le thread actuel. + Résultat de l'appel à sur . + L'instance de a été supprimée. + Le du thread actuel est une référence null (Nothing en Visual Basic). + La fonction d'initialisation a tenté de référencer de manière récursive. + Aucun constructeur par défaut n'est fourni et aucune fabrique de valeurs n'est fournie. + + + Obtient ou définit la valeur de cette instance pour le thread actuel. + Retourne une instance de l'objet dont ce ThreadLocal est chargé de l'initialisation. + L'instance de a été supprimée. + La fonction d'initialisation a tenté de référencer de manière récursive. + Aucun constructeur par défaut n'est fourni et aucune fabrique de valeurs n'est fournie. + + + Obtient une liste de toutes les valeurs actuellement stockées par tous les threads qui ont accès à cette instance. + Liste de toutes les valeurs actuellement stockées par tous les threads qui ont accès à cette instance. + L'instance de a été supprimée. + + + Contient des méthodes permettant d'effectuer des opérations de mémoire volatile. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la référence d'objet à partir du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Référence à qui a été lue.Il s'agit de la dernière référence écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + Type du champ à lire.Il doit s'agir d'un type référence, et non d'un type valeur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de mémoire apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la référence d'objet spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la référence d'objet est écrite. + Référence d'objet à écrire.La référence est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + Type du champ dans lequel écrire.Il doit s'agir d'un type référence, et non d'un type valeur. + + + Exception levée lors d'une tentative d'ouverture d'un mutex système ou d'un sémaphore qui n'existe pas. + 2 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/it/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/it/System.Threading.xml new file mode 100644 index 000000000..3446f031d --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/it/System.Threading.xml @@ -0,0 +1,1800 @@ + + + + System.Threading + + + + Eccezione generata quando un thread acquisisce un oggetto che un altro thread ha abbandonato uscendo senza rilasciarlo. + 1 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un indice specificato per il mutex abbandonato, se applicabile, e un oggetto che rappresenta il mutex. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo o –1 se l'eccezione viene generata per i metodi o . + Oggetto che rappresenta il mutex abbandonato. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore che spiega il motivo dell'eccezione. + + + Inizializza una nuova istanza della classe con il messaggio di errore e l'eccezione interna specificati. + Messaggio di errore che spiega il motivo dell'eccezione. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente verrà generata in un blocco catch che gestisce l'eccezione interna. + + + Inizializza una nuova istanza della classe con il messaggio di errore, l'eccezione interna, l'indice per il mutex abbandonato, se applicabile, specificati e un oggetto che rappresenta il mutex. + Messaggio di errore che spiega il motivo dell'eccezione. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente verrà generata in un blocco catch che gestisce l'eccezione interna. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo , –1 se l'eccezione viene generata per il metodo o . + Oggetto che rappresenta il mutex abbandonato. + + + Inizializza una nuova istanza della classe con il messaggio di errore, l'indice del mutex abbandonato, se applicabile, e il mutex abbandonato specificati. + Messaggio di errore che spiega il motivo dell'eccezione. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo , –1 se l'eccezione viene generata per il metodo o . + Oggetto che rappresenta il mutex abbandonato. + + + Ottiene il mutex abbandonato che ha causato l'eccezione, se noto. + Oggetto che rappresenta il mutex abbandonato oppure null se il mutex abbandonato non è stato identificato. + 1 + + + Ottiene l'indice del mutex abbandonato che ha causato l'eccezione, se noto. + Nella matrice degli handle in attesa passati al metodo , indice dell'oggetto che rappresenta il mutex abbandonato oppure –1 se l'indice del mutex abbandonato non è stato determinato. + 1 + + + Rappresenta dati di ambiente locali rispetto a un flusso di controllo asincrono specificato, ad esempio un metodo asincrono. + Tipo dei dati di ambiente. + + + Crea un'istanza dell'istanza di che non riceve notifiche di modifica. + + + Crea un'istanza dell'istanza di locale che riceve notifiche di modifica. + Delegato chiamato ogni volta che il valore corrente cambia in qualsiasi thread. + + + Ottiene o imposta il valore dei dati di ambiente. + Valore dei dati di ambiente. + + + Classe che fornisce le informazioni di modifica dei dati alle istanze di registrate per le notifiche di modifica. + Tipo di dati. + + + Ottiene il valore corrente dei dati. + Valore corrente dei dati. + + + Ottiene il valore precedente dei dati. + Valore precedente dei dati. + + + Restituisce un valore che indica se il valore cambia a seguito di una modifica del contesto di esecuzione. + true se il valore è cambiato a seguito di una modifica del contesto di esecuzione; in caso contrario, false. + + + Notifica a un thread in attesa che si è verificato un evento.La classe non può essere ereditata. + 2 + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato. + true per impostare lo stato iniziale su segnalato; false per impostare lo stato iniziale su non segnalato. + + + Consente a più attività di funzionare cooperativamente in un algoritmo in parallelo tramite più fasi. + + + Inizializza una nuova istanza della classe . + Numero di thread che partecipano. + + è minore di 0 o maggiore di 32,767. + + + Inizializza una nuova istanza della classe . + Numero di thread che partecipano. + Oggetto da eseguire dopo ogni fase. Può essere passato Null (Nothing in Visual Basic) per indicare che non è stata intrapresa alcuna azione. + + è minore di 0 o maggiore di 32,767. + + + Notifica all'oggetto che sarà presente un partecipante aggiuntivo. + Numero di fase della barriera in corrispondenza di cui parteciperanno inizialmente i nuovi partecipanti. + L'istanza corrente è già stata eliminata. + L'aggiunta di un partecipante provocherebbe il superamento del conteggio del partecipante della barriera di 32.767.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Notifica all'oggetto che saranno presenti partecipanti aggiuntivi. + Numero di fase della barriera in corrispondenza di cui parteciperanno inizialmente i nuovi partecipanti. + Numero di partecipanti aggiuntivi da aggiungere alla barriera. + L'istanza corrente è già stata eliminata. + + è minore di 0.- oppure -L'aggiunta di partecipanti provocherebbe il superamento del conteggio del partecipante della barriera di 32.767. + Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Ottiene il numero di fase corrente della barriera. + Restituisce il numero di fase corrente della barriera. + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo quelle non gestite. + + + Ottiene il numero totale di partecipanti nella barriera. + Restituisce il numero totale di partecipanti nella barriera. + + + Ottiene il numero di partecipanti nella barriera che non hanno ancora eseguito la segnalazione nella fase corrente. + Restituisce il numero di partecipanti nella barriera che non hanno ancora eseguito la segnalazione nella fase corrente. + + + Notifica all'oggetto che sarà presente un partecipante in meno. + L'istanza corrente è già stata eliminata. + La barriera dispone già di 0 partecipanti.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Notifica all'oggetto che saranno presenti meno partecipanti. + Numero di partecipanti aggiuntivi da rimuovere dalla barriera. + L'istanza corrente è già stata eliminata. + + è minore di 0. + La barriera dispone già di 0 partecipanti.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. - oppure -il conteggio del partecipante corrente è minore del conteggio del partecipante specificato + Il conteggio totale dei partecipanti è minore del specificato + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti. + L'istanza corrente è già stata eliminata. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + Se un'eccezione viene generata da un'azione post-fase di una Barriera dopo che tutti thread che partecipano hanno chiamato SignalAndWait, l'eccezione verrà sottoposta a wrapping in un BarrierPostPhaseException e sarà generata su tutti i thread che partecipano. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un Signed Integer a 32 bit per misurare il timeout. + true se tutti i partecipanti raggiungono la barriera entro il tempo specificato; in caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + Se un'eccezione viene generata da un'azione post-fase di una Barriera dopo che tutti thread che partecipano hanno chiamato SignalAndWait, l'eccezione verrà sottoposta a wrapping in un BarrierPostPhaseException e sarà generata su tutti i thread che partecipano. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un Signed Integer a 32 bit per misurare il timeout, al contempo osservando un token di annullamento. + true se tutti i partecipanti raggiungono la barriera entro il tempo specificato; in caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, al contempo osservando un token di annullamento. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un oggetto per misurare l'intervallo di tempo. + true se tutti gli altri partecipanti hanno raggiunto la barriera. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito, oppure è più grande di 32.767. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un oggetto per misurare l'intervallo di tempo, al contempo osservando un token di annullamento. + true se tutti gli altri partecipanti hanno raggiunto la barriera. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Eccezione generata quando l'azione post-fase di un oggetto non viene eseguita correttamente. + + + Inizializza una nuova istanza della classe con un messaggio fornito dal sistema in cui viene descritto l'errore. + + + Inizializza una nuova istanza della classe con l'eccezione interna specificata. + Eccezione causa dell'eccezione corrente. + + + Inizializza una nuova istanza della classe con un messaggio specifico in cui viene descritto l'errore. + Messaggio in cui viene descritta l'eccezione.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio in cui viene descritta l'eccezione.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Rappresenta un metodo da chiamare all'interno di un nuovo contesto. + Oggetto contenente informazioni che devono essere utilizzate dal metodo di callback ogni volta che viene eseguito. + 1 + + + Rappresenta un primitiva di sincronizzazione segnalata quando il relativo conteggio raggiunge lo zero. + + + Inizializza una nuova istanza della classe con il conteggio specificato. + Numero di segnali inizialmente richiesti per impostare l'oggetto . + + è minore di 0. + + + Incrementa di uno il conteggio corrente di . + L'istanza corrente è già stata eliminata. + L'istanza corrente è già impostata.- oppure - è maggiore di o uguale a . + + + Incrementa di un valore specificato il conteggio corrente di . + Valore che indica l'incremento di . + L'istanza corrente è già stata eliminata. + + è minore o uguale a 0. + L'istanza corrente è già impostata.- oppure - è uguale o maggiore a dopo che il conteggio è incrementato da + + + Ottiene il numero di segnali restanti necessari per impostare l'evento. + Numero di segnali restanti necessari per impostare l'evento. + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo quelle non gestite. + + + Ottiene il numero di segnali necessari inizialmente per impostare l'evento. + Numero di segnali necessari inizialmente per impostare l'evento. + + + Determina se l'evento è impostato. + true se l'evento è impostato, altrimenti false. + + + Reimposta sul valore di . + L'istanza corrente è già stata eliminata. + + + Reimposta la proprietà al valore specificato. + Numero di segnali necessari per impostare l'oggetto . + L'istanza corrente è già stata eliminata. + + è minore di 0. + + + Registra un segnale con l'oggetto , decrementando il valore di . + true se il conteggio ha raggiunto lo zero a causa del segnale e l'evento è stato impostato. In caso contrario, false. + L'istanza corrente è già stata eliminata. + L'istanza corrente è già impostata. + + + Registra più segnali con l'oggetto , decrementandone il valore di della quantità specificata. + true se il conteggio ha raggiunto lo zero a causa dei segnali e l'evento è stato impostato. In caso contrario, false. + Numero di segnali da registrare. + L'istanza corrente è già stata eliminata. + + è minore di 1. + L'istanza corrente è già impostata. oppure è maggiore di . + + + Tenta di incrementare di uno. + true se l'incremento ha avuto esito positivo. In caso contrario, false.Se è già zero, questo metodo restituirà false. + L'istanza corrente è già stata eliminata. + + è uguale a . + + + Tenta di incrementare in base a un valore specificato. + true se l'incremento ha avuto esito positivo. In caso contrario, false.Se è già zero, verrà restituito false. + Valore che indica l'incremento di . + L'istanza corrente è già stata eliminata. + + è minore o uguale a 0. + L'istanza corrente è già impostata.- oppure - + è uguale o maggiore di . + + + Blocca il thread corrente finché l'oggetto non viene impostato. + L'istanza corrente è già stata eliminata. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un intero con segno a 32 bit per misurare il timeout. + true se è stato impostato. In caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un intero con segno a 32 bit per misurare il timeout e al contempo osservando un oggetto . + true se è stato impostato. In caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, al contempo osservando un oggetto . + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un oggetto per misurare il timeout. + true se è stato impostato. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un oggetto per misurare il timeout e al contempo osservando un oggetto . + true se è stato impostato. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Ottiene un oggetto utilizzato per attendere l'impostazione dell'evento. + Oggetto utilizzato per attendere l'impostazione dell'evento. + L'istanza corrente è già stata eliminata. + + + Indica se verrà reimpostato automaticamente o manualmente dopo la ricezione di un segnale. + 2 + + + Con la segnalazione, viene reimpostato automaticamente dopo il rilascio di un singolo thread.Se non sono presenti thread in attesa, resta segnalato fino al blocco di un thread e viene reimpostato dopo il rilascio del thread. + + + Con la segnalazione, rilascia tutti i thread in attesa e resta segnalato finché non viene reimpostato manualmente. + + + Rappresenta un evento di sincronizzazione dei thread. + 2 + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato e se la reimpostazione viene eseguita automaticamente o manualmente. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato se creato a seguito di questa chiamata e se la reimpostazione viene eseguita automaticamente o manualmente e indicando il nome di un evento di sincronizzazione di sistema. + true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato in seguito a questa chiamata; false per impostare lo stato su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + Nome di un evento di sincronizzazione a livello di sistema. + Si è verificato un errore Win32. + L'evento denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non possiede i diritti . + Non è possibile creare l'evento denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è di lunghezza superiore a 260 caratteri. + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato se creato a seguito di questa chiamata e se la reimpostazione viene eseguita automaticamente o manualmente e indicando il nome di un evento di sincronizzazione di sistema e una variabile Boolean il cui valore dopo la chiamata specifica se l'evento di sistema denominato è stato creato. + true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato in seguito a questa chiamata; false per impostare lo stato su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + Nome di un evento di sincronizzazione a livello di sistema. + Quando questo metodo viene restituito, contiene true se è stato creato un evento locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato l'evento di sistema denominato specificato; false se l'evento di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + Si è verificato un errore Win32. + L'evento denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non possiede i diritti . + Non è possibile creare l'evento denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è di lunghezza superiore a 260 caratteri. + + + Apre l'evento di sincronizzazione denominato specificato, se esistente. + Oggetto che rappresenta l'evento di sistema denominato. + Nome dell'evento di sincronizzazione del sistema da aprire. + + è una stringa vuota. In alternativa è di lunghezza superiore a 260 caratteri. + + è null. + L'evento di sistema denominato non esiste. + Si è verificato un errore Win32. + L'evento denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread. + true se l'operazione ha esito positivo; in caso contrario, false. + Il metodo non è stato chiamato precedentemente in questo oggetto . + 2 + + + Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa di procedere. + true se l'operazione ha esito positivo; in caso contrario, false. + Il metodo non è stato chiamato precedentemente in questo oggetto . + 2 + + + Apre l'evento di sincronizzazione denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è stata completata. + true se l'evento di sincronizzazione denominato è stato aperto correttamente; in caso contrario, false. + Nome dell'evento di sincronizzazione del sistema da aprire. + Quando viene eseguita la restituzione del metodo, contiene un oggetto di che rappresenta l'evento di sincronizzazione denominato se la chiamata ha esito positivo, o null se la chiamata ha esito negativo.Questo parametro viene trattato come non inizializzato. + + è una stringa vuota.In alternativa è di lunghezza superiore a 260 caratteri. + + è null. + Si è verificato un errore Win32. + L'evento denominato esiste, ma l'utente non dispone dell'accesso di sicurezza desiderato. + + + Gestisce il contesto di esecuzione per il thread corrente.La classe non può essere ereditata. + 2 + + + Acquisisce il contesto di esecuzione dal thread corrente. + Oggetto che rappresenta il contesto di esecuzione per il thread corrente. + 1 + + + Esegue un metodo in un contesto di esecuzione specifico sul thread corrente. + Oggetto da impostare. + Delegato che rappresenta il metodo da eseguire nel contesto di esecuzione fornito. + Oggetto da passare al metodo di callback. + + è null.- oppure - non è stato acquisito tramite un'operazione di acquisizione. - oppure - è stato già utilizzato come argomento per una chiamata . + 1 + + + + + + Fornisce operazioni atomiche per variabili condivise da più thread. + 2 + + + Somma due interi a 32 bit e sostituisce il primo intero con la somma, come operazione atomica. + Nuovo valore archiviato in . + Variabile contenente il primo valore da sommare.La somma dei due valori viene archiviata in . + Valore da sommare all'intero in corrispondenza di . + The address of is a null pointer. + 1 + + + Somma due interi a 64 bit e sostituisce il primo intero con la somma, come operazione atomica. + Nuovo valore archiviato in . + Variabile contenente il primo valore da sommare.La somma dei due valori viene archiviata in . + Valore da sommare all'intero in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due numeri a virgola mobile e precisione doppia per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due interi con segno a 32 bit per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due interi con segno a 64 bit per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due puntatori o handle specifici della piattaforma per verificarne l'uguaglianza; se sono uguali, sostituisce il primo elemento. + Valore originale in . + Oggetto di destinazione, il cui valore viene confrontato con il valore di e, se possibile, sostituito da . + Oggetto che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Oggetto confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due oggetti per verificarne l'uguaglianza dei riferimenti; se sono uguali, sostituisce il primo oggetto. + Valore originale in . + Oggetto di destinazione confrontato con e, se possibile, sostituito. + Oggetto che sostituisce l'oggetto di destinazione se il confronto rileva l'uguaglianza. + Oggetto confrontato con l'oggetto in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due numeri a virgola mobile e precisione singola per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due istanze del tipo di riferimento specificato per verificarne l'uguaglianza; se sono uguali, sostituisce la prima istanza. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito.Rappresenta un parametro di riferimento (ref in C#, ByRef in Visual Basic). + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + Tipo da usare per , e .Questo tipo deve essere un tipo di riferimento. + The address of is a null pointer. + + + Diminuisce una variabile specificata e archivia il risultato, come operazione atomica. + Valore diminuito. + Variabile il cui valore deve essere diminuito. + The address of is a null pointer. + 1 + + + Diminuisce la variabile specificata e archivia il risultato, come operazione atomica. + Valore diminuito. + Variabile il cui valore deve essere diminuito. + The address of is a null pointer. + 1 + + + Imposta un numero a virgola mobile e precisione doppia su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un intero con segno a 32 bit su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un intero con segno a 64 bit su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un puntatore o un handle specifico della piattaforma su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un oggetto su un valore specificato e restituisce un riferimento all'oggetto originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un numero a virgola mobile e precisione singola su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta una variabile del tipo indicato sul valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato.Rappresenta un parametro di riferimento (ref in C#, ByRef in Visual Basic). + Valore su cui è impostato il parametro . + Tipo da usare per e .Questo tipo deve essere un tipo di riferimento. + The address of is a null pointer. + + + Aumenta una variabile specificata e archivia il risultato, come operazione atomica. + Valore aumentato. + Variabile il cui valore deve essere aumentato. + The address of is a null pointer. + 1 + + + Aumenta una variabile specificata e archivia il risultato, come operazione atomica. + Valore aumentato. + Variabile il cui valore deve essere aumentato. + The address of is a null pointer. + 1 + + + Sincronizza l'accesso alla memoria come segue: il processore che esegue il thread corrente non può riordinare le istruzioni in modo tale che gli accessi alla memoria prima della chiamata al metodo vengano eseguiti dopo quelli successivi alla chiamata al metodo . + + + Restituisce un valore a 64 bit, caricato come operazione atomica. + Valore caricato. + Valore a 64 bit da caricare. + 1 + + + Fornisce routine di inizializzazione differita. + + + Inizializza un tipo di riferimento di destinazione con il relativo costruttore predefinito se non è già stato inizializzato. + Riferimento inizializzato di tipo . + Riferimento di tipo da inizializzare se non è già stato inizializzato. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento o di valore di destinazione con il relativo costruttore predefinito se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento o valore di tipo da inizializzare se non è già stato inizializzato. + Riferimento a un valore booleano che determina se la destinazione è già stata inizializzata. + Riferimento a un oggetto utilizzato come blocco a esclusione reciproca per l'inizializzazione di .Se è null, verrà creata un'istanza di un nuovo oggetto. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento o di valore di destinazione utilizzando una funzione specificata se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento o valore di tipo da inizializzare se non è già stato inizializzato. + Riferimento a un valore booleano che determina se la destinazione è già stata inizializzata. + Riferimento a un oggetto utilizzato come blocco a esclusione reciproca per l'inizializzazione di .Se è null, verrà creata un'istanza di un nuovo oggetto. + Funzione chiamata per inizializzare il riferimento o il valore. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento di destinazione utilizzando una funzione specificata se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento di tipo da inizializzare se non è già stato inizializzato. + Funzione chiamata per inizializzare il riferimento. + Tipo del riferimento da inizializzare. + Il tipo non dispone di un costruttore predefinito. + + restituisce null (Nothing in Visual Basic). + + + Eccezione generata quando una voce ricorsiva in un blocco non è compatibile con i criteri di ricorsione per tale blocco. + 2 + + + Inizializza una nuova istanza della classe con un messaggio fornito dal sistema in cui viene descritto l'errore. + 2 + + + Inizializza una nuova istanza della classe con un messaggio specifico in cui viene descritto l'errore. + Messaggio in cui viene descritta l'eccezione.Il chiamante di questo costruttore deve assicurare che la stringa sia stata localizzata in base alle impostazioni cultura correnti del sistema. + 2 + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio in cui viene descritta l'eccezione.Il chiamante di questo costruttore deve assicurare che la stringa sia stata localizzata in base alle impostazioni cultura correnti del sistema. + Eccezione che ha causato l'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + 2 + + + Specifica se lo stesso thread può accedere a un blocco più volte. + + + Se un thread tenta di accedere a un blocco in modo ricorsivo, viene generata un'eccezione.È possibile che alcune classi consentano particolari ricorsioni quando questa impostazione è attivata. + + + Un thread può accedere a un blocco in modo ricorsivo.Alcune classi possono limitare questa funzionalità. + + + Notifica a uno o più thread in attesa che si è verificato un evento.La classe non può essere ereditata. + 2 + + + Consente l'inizializzazione di una nuova istanza della classe con un valore Booleano che indica se lo stato iniziale deve essere impostato su segnalato. + Viene restituito true per impostare lo stato iniziale su segnalato; false per impostare lo stato iniziale su non segnalato. + + + Fornisce una versione più snella di . + + + Inizializza una nuova istanza della classe con uno stato iniziale di non segnalato. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato e un conteggio rotazioni specificato. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + Numero di attese di rotazione che devono verificarsi prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + + is less than 0 or greater than the maximum allowed value. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dall'oggetto e facoltativamente rilascia le risorse gestite. + True per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene un valore che indica se l'evento è impostato. + true se l'evento è impostato; in caso contrario, false. + + + Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread. + The object has already been disposed. + + + Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa dell'evento di procedere. + + + Ottiene il numero di attese di rotazione che si verificheranno prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + Restituisce il numero di attese di rotazione che si verificheranno prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un intero con segno a 32 bit per misurare l'intervallo di tempo. + true se l'oggetto è stato impostato; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un intero con segno a 32 bit per misurare l'intervallo di tempo e osservando un oggetto . + true se l'oggetto è stato impostato; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non riceve un segnale, osservando un oggetto . + Oggetto da osservare. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un oggetto per misurare l'intervallo di tempo. + true se l'oggetto è stato impostato; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un oggetto per misurare l'intervallo di tempo e osservando un oggetto . + true se l'oggetto è stato impostato; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Ottiene l'oggetto sottostante per questo oggetto . + Oggetto evento sottostante per questo oggetto . + + + Fornisce un meccanismo che sincronizza l'accesso agli oggetti. + 2 + + + Acquisisce un blocco esclusivo sull'oggetto specificato. + Oggetto sui cui acquisire il blocco del monitoraggio. + Il valore del parametro è null. + 1 + + + Acquisisce un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto per il quale attendere. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco.Nota   Se non si verifica alcuna eccezione, l'output di questo metodo è sempre true. + L'input di è true. + Il valore del parametro è null. + + + Viene rilasciato un blocco esclusivo sull'oggetto specificato. + Oggetto sul quale rilasciare il blocco. + Il valore del parametro è null. + Il blocco per l'oggetto specificato non è di proprietà del thread corrente. + 1 + + + Determina se il thread corrente specificato contiene il blocco sull'oggetto specificato. + true se il thread corrente è responsabile del blocco su ; in caso contrario, false. + Oggetto da testare. + + è null. + + + Notifica a un thread della coda di attesa che lo stato dell'oggetto bloccato è stato modificato. + Oggetto atteso da un thread. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + 1 + + + Notifica a tutti i thread in attesa che lo stato dell'oggetto è stato modificato. + Oggetto che invia l'impulso. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + 1 + + + Prova ad acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Il valore del parametro è null. + 1 + + + Prova ad acquisire un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + + + Viene eseguito, per un numero specificato di millisecondi, il tentativo di acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Tempo di attesa espresso in millisecondi prima che si verifichi il blocco. + Il valore del parametro è null. + + è negativo e non è uguale a . + 1 + + + Prova ad acquisire, per il numero di millisecondi specificato, un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Tempo di attesa espresso in millisecondi prima che si verifichi il blocco. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + + è negativo e non è uguale a . + + + Viene eseguito, per una quantità di tempo specificata, il tentativo di acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Oggetto che rappresenta la durata di attesa del blocco.Un valore di –1 millisecondo specifica un'attesa infinita. + Il valore del parametro è null. + Il valore di in millisecondi è negativo ed è diverso da (–1 millisecondi) oppure è maggiore di . + 1 + + + Prova ad acquisire, per la quantità di tempo specificata, un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Quantità di tempo che rappresenta la durata di attesa del blocco.Un valore di –1 millisecondo specifica un'attesa infinita. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + Il valore di in millisecondi è negativo ed è diverso da (–1 millisecondi) oppure è maggiore di . + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco. + true se la chiamata è stata restituita perché il chiamante ha riacquisito il blocco per l'oggetto specificato.Non viene restituito alcun valore se il blocco non viene riacquisito. + Oggetto per il quale attendere. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + 1 + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco.Allo scadere dell'intervallo di timeout specificato, il thread viene inserito nella coda di thread pronti. + true se il blocco è stato riacquisito prima che sia trascorso il tempo specificato; false se il blocco è stato riacquisito dopo che è trascorso il tempo specificato.Il metodo non restituisce alcun valore finché il blocco non viene riacquisito. + Oggetto per il quale attendere. + Numero di millisecondi da attendere prima che il thread venga inserito nella coda di thread pronti. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + Il valore del parametro è negativo e non è uguale a . + 1 + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco.Allo scadere dell'intervallo di timeout specificato, il thread viene inserito nella coda di thread pronti. + true se il blocco è stato riacquisito prima che sia trascorso il tempo specificato; false se il blocco è stato riacquisito dopo che è trascorso il tempo specificato.Il metodo non restituisce alcun valore finché il blocco non viene riacquisito. + Oggetto per il quale attendere. + Oggetto che rappresenta il tempo di attesa prima che il thread venga inserito nella coda di thread pronti. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + Il valore del parametro in millisecondi è negativo e non rappresenta (–1 millisecondo) oppure è maggiore di . + 1 + + + Primitiva di sincronizzazione che può essere usata anche per la sincronizzazione interprocesso. + 1 + + + Inizializza una nuova istanza della classe con le proprietà predefinite. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex; in caso contrario, false. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex e con una stringa che rappresenta il nome del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex di sistema denominato, se questo è stato creato come risultato della chiamata; in caso contrario, false. + Nome di .Se il valore è null, l'oggetto è senza nome. + Il mutex denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non dispone dei diritti . + Si è verificato un errore Win32. + Non è possibile creare il mutex denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è più lungo di 260 caratteri. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex, con una stringa che rappresenta il nome del mutex e con un valore booleano che, quando il metodo viene restituito, indichi se al thread chiamante era stata concessa la proprietà iniziale del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex di sistema denominato, se questo è stato creato come risultato della chiamata; in caso contrario, false. + Nome di .Se il valore è null, l'oggetto è senza nome. + Quando questo metodo viene restituito, contiene un valore booleano che è true se è stato creato un mutex locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato il mutex di sistema denominato specificato; false se il mutex di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + Il mutex denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non dispone dei diritti . + Si è verificato un errore Win32. + Non è possibile creare il mutex denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è più lungo di 260 caratteri. + + + Apre il mutex denominato specificato, se esistente. + Oggetto che rappresenta il mutex di sistema denominato. + Nome del mutex di sistema da aprire. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Il mutex denominato non esiste. + Si è verificato un errore Win32. + Il mutex denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Rilascia l'oggetto una volta. + Il thread chiamante non ha la proprietà del mutex. + 1 + + + Apre il mutex denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è stata completata. + true se il mutex denominato è stato aperto correttamente; in caso contrario, false. + Nome del mutex di sistema da aprire. + Quando questo metodo viene restituito, contiene un oggetto di che rappresenta il mutex denominato se la chiamata ha esito positivo o null se la chiamata ha esito negativo.Questo parametro viene trattato come non inizializzato. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Si è verificato un errore Win32. + Il mutex denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + + + Rappresenta un blocco usato per gestire l'accesso a una risorsa, consentendo a più thread l'accesso in lettura o l'accesso esclusivo in scrittura. + + + Inizializza una nuova istanza della classe con i valori predefiniti delle proprietà. + + + Inizializza una nuova istanza della classe , specificando i criteri di ricorsione del blocco. + Uno dei valori di enumerazione che specifica i criteri di ricorsione del blocco. + + + Ottiene il numero complessivo di thread univoci per i quali è stato attivato il blocco in modalità lettura. + Numero di thread univoci per i quali è stato attivato il blocco in modalità lettura. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Prova ad attivare il blocco in modalità lettura. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Riduce il numero di ricorsioni per la modalità lettura ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in read mode. + + + Riduce il numero di ricorsioni per la modalità aggiornabile ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in upgradeable mode. + + + Riduce il numero di ricorsioni per la modalità scrittura ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in write mode. + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità lettura. + true se per il thread corrente è stata attivata la modalità lettura; in caso contrario, false. + 2 + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità aggiornabile. + true se per il thread corrente è stata attivata la modalità aggiornabile; in caso contrario, false. + 2 + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità scrittura. + true se per il thread corrente è stata attivata la modalità scrittura; in caso contrario, false. + 2 + + + Ottiene un valore che indica i criteri di ricorsione per l'oggetto corrente. + Uno dei valori di enumerazione che specifica i criteri di ricorsione del blocco. + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità lettura, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità lettura, 1 se per il thread è stata attivata la modalità lettura ma non in modo ricorsivo o n se per il thread è stato attivato il blocco in modo ricorsivo n - 1 volte. + 2 + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità aggiornabile, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità aggiornabile, 1 se per il thread è stata attivata la modalità aggiornabile ma non in modo ricorsivo o n se per il thread è stata attivata la modalità aggiornabile in modo ricorsivo n - 1 volte. + 2 + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità scrittura, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità scrittura, 1 se per il thread è stata attivata la modalità scrittura ma non in modo ricorsivo o n se per il thread è stata attivata la modalità scrittura in modo ricorsivo n - 1 volte. + 2 + + + Prova ad attivare il blocco in modalità lettura con un timeout intero facoltativo. + true se il thread chiamante è passato in modalità lettura; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità lettura con un timeout facoltativo. + true se il thread chiamante è passato in modalità lettura; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile con un timeout facoltativo. + true se il thread chiamante è passato in modalità aggiornabile; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile con un timeout facoltativo. + true se il thread chiamante è passato in modalità aggiornabile; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura con un timeout facoltativo. + true se il thread chiamante è passato in modalità scrittura; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura con un timeout facoltativo. + true se il thread chiamante è passato in modalità scrittura; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità lettura. + Numero complessivo di thread in attesa di attivazione della modalità lettura. + 2 + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità aggiornabile. + Numero complessivo di thread in attesa di attivazione della modalità aggiornabile. + 2 + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità scrittura. + Numero complessivo di thread in attesa di attivazione della modalità scrittura. + 2 + + + Limita il numero di thread che possono accedere a una risorsa o a un pool di risorse contemporaneamente. + 1 + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + + è maggiore di . + + è minore di 1.-oppure- è minore di 0. + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei, nonché indicando facoltativamente il nome di un oggetto semaforo di sistema. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + Nome di un oggetto semaforo di sistema denominato. + + è maggiore di .-oppure- è più lungo di 260 caratteri. + + è minore di 1.-oppure- è minore di 0. + Si è verificato un errore Win32. + Il semaforo denominato esiste ed è dotato di sicurezza del controllo di accesso e l'utente non dispone di . + Non è possibile creare il semaforo denominato, probabilmente a causa di un handle di attesa di tipo diverso con lo stesso nome. + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei, indicando facoltativamente il nome di un oggetto semaforo di sistema e specificando una variabile che riceve un valore che indica se è stato creato un nuovo semaforo di sistema. + Numero iniziale di richieste per il semaforo che possono essere soddisfatte contemporaneamente. + Numero massimo di richieste per il semaforo che possono essere soddisfatte contemporaneamente. + Nome di un oggetto semaforo di sistema denominato. + Quando questo metodo viene restituito, contiene true se è stato creato un semaforo locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato il semaforo di sistema denominato specificato; false se il semaforo di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + + è maggiore di . -oppure- è più lungo di 260 caratteri. + + è minore di 1.-oppure- è minore di 0. + Si è verificato un errore Win32. + Il semaforo denominato esiste ed è dotato di sicurezza del controllo di accesso e l'utente non dispone di . + Non è possibile creare il semaforo denominato, probabilmente a causa di un handle di attesa di tipo diverso con lo stesso nome. + + + Apre il semaforo denominato specificato, se esistente. + Oggetto che rappresenta il semaforo di sistema denominato. + Nome del semaforo di sistema da aprire. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Il semaforo denominato non esiste. + Si è verificato un errore Win32. + Il semaforo denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Esce dal semaforo e restituisce il conteggio precedente. + Conteggio del semaforo prima della chiamata del metodo . + Il conteggio del semaforo ha già raggiunto il valore massimo. + Si è verificato un errore Win32 relativo a un semaforo denominato. + Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente non dispone di .-oppure-Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con . + 1 + + + Esce dal semaforo il numero di volte specificato e restituisce il conteggio precedente. + Conteggio del semaforo prima della chiamata del metodo . + Numero di uscite dal semaforo. + + è minore di 1. + Il conteggio del semaforo ha già raggiunto il valore massimo. + Si è verificato un errore Win32 relativo a un semaforo denominato. + Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente non dispone di diritti .-oppure-Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con i diritti . + 1 + + + Apre il semaforo denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è riuscita. + true se l'apertura del semaforo denominato è riuscita; in caso contrario, false. + Nome del semaforo di sistema da aprire. + Quando viene eseguita la restituzione del metodo, quest'ultimo contiene un oggetto che rappresenta il semaforo denominato se la chiamata è riuscita o null se la chiamata non è riuscita.Questo parametro viene trattato come non inizializzato. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Si è verificato un errore Win32. + Il semaforo denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + + + Eccezione generata quando il metodo viene chiamato su un semaforo il cui conteggio ha già raggiunto il valore massimo. + 2 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Rappresenta un'alternativa semplificata a che limita il numero di thread che possono accedere simultaneamente a una risorsa o a un pool di risorse. + + + Inizializza una nuova istanza della classe specificando il numero iniziale di richieste che possono essere concesse simultaneamente. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + + è minore di 0. + + + Inizializza una nuova istanza della classe specificando il numero iniziale e massimo di richieste che possono essere concesse simultaneamente. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + + è minore di 0, o è maggiore di o è uguale o minore di 0. + + + Restituisce un oggetto che può essere usato per attendere il semaforo. + Oggetto che può essere usato per attendere il semaforo. + L'interfaccia è stata eliminata. + + + Ottiene il numero di thread rimanenti che possono accedere all'oggetto . + Numero di thread rimanenti che possono accedere al semaforo. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Rilascia l'oggetto una volta. + Numero precedente di . + L'istanza corrente è già stata eliminata. + + ha già raggiunto la dimensione massima. + + + Rilascia l'oggetto un numero di volte specificato. + Numero precedente di . + Numero di uscite dal semaforo. + L'istanza corrente è già stata eliminata. + + è minore di 1. + + ha già raggiunto la dimensione massima. + + + Blocca il thread corrente finché non può immettere . + L'istanza corrente è già stata eliminata. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un intero con segno a 32 bit che specifica il timeout. + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un intero con segno a 32 bit che specifica il timeout e osservando un oggetto . + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il istanza è stata eliminata, o che ha creato è stato eliminato. + + + Blocca il thread corrente finché non può accedere all'oggetto osservando un oggetto . + Token da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata.-oppure-Il creato è già stato eliminato. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un oggetto per specificare il timeout. + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + L'istanza semaphoreSlim è stata eliminata + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un oggetto che specifica il timeout e osservando un oggetto . + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + L'istanza semaphoreSlim è stata eliminataL'oggetto che ha creato è già stato eliminato. + + + Attende in modo asincrono di immettere . + Attività che verrà completata quando si accede al semaforo. + + + Attende in modo asincrono di accedere all'oggetto , usando un intero con segno a 32 bit per misurare l'intervallo di tempo. + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Attende in modo asincrono di accedere all'oggetto , usando un intero con segno a 32 bit per misurare l'intervallo di tempo e osservando un oggetto . + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + L'istanza corrente è già stata eliminata. + + è stato annullato. + + + Attende in modo asincrono di accedere all'oggetto , osservando un oggetto . + Attività che verrà completata quando si accede al semaforo. + Token da osservare. + L'istanza corrente è già stata eliminata. + + è stato annullato. + + + Attende in modo asincrono di accedere all'oggetto , usando un oggetto per misurare l'intervallo di tempo. + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. -oppure- timeout è maggiore di . + + + Attende in modo asincrono di accedere all'oggetto , usando un oggetto per misurare l'intervallo di tempo e osservando un oggetto . + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Token da osservare. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato.-oppure-timeout è maggiore di . + + è stato annullato. + + + Rappresenta un metodo da chiamare quando un messaggio deve essere inviato a un contesto di sincronizzazione. + Oggetto passato al delegato. + 2 + + + Fornisce un primitiva di blocco a esclusione reciproca in cui un thread che tenta di acquisire il blocco attende in un ciclo eseguendo controlli ripetuti finché il blocco non diventa disponibile. + + + Inizializza una nuova istanza della struttura con l'opzione di rilevamento degli ID dei thread per migliorare il debug. + Valore che indica se acquisire e utilizzare gli ID dei thread per scopi di debug. + + + Acquisisce il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + È necessario inizializzare l'argomento su False prima della chiamata a Enter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Rilascia il blocco. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente non è il proprietario di questo blocco. + + + Rilascia il blocco. + Valore booleano che indica se generare un limite di memoria per pubblicare immediatamente l'operazione di uscita agli altri thread. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente non è il proprietario di questo blocco. + + + Ottiene un valore che indica se attualmente il blocco è mantenuto da un thread. + true se attualmente il blocco è mantenuto da un thread; in caso contrario, false. + + + Ottiene un valore che indica se il blocco è mantenuto dal thread corrente. + true se il blocco è mantenuto dal thread corrente; in caso contrario, false. + Il rilevamento della proprietà dei thread è disabilitato. + + + Ottiene un valore che indica se per questa istanza è abilitato il rilevamento della proprietà dei thread. + true se per questa istanza è abilitato il rilevamento della proprietà dei thread; in caso contrario, false. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito o il timeout è più grande di millisecondi. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Fornisce il supporto per l'attesa basata su rotazione. + + + Ottiene il numero di chiamate di su questa istanza. + Restituisce un intero che rappresenta il numero di volte in cui è stato chiamato su questa istanza. + + + Ottiene un valore che indica se la chiamata successiva a comporterà la cessione del processore, attivando un cambio imposto di contesto. + Valore che indica se la chiamata successiva a comporterà la cessione del processore, attivando un cambio imposto di contesto. + + + Reimposta il contatore delle rotazioni. + + + Esegue una sola rotazione. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata. + Delegato da eseguire ripetutamente finché non restituisce true. + L'argomento è null. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata o fino allo scadere del timeout specificato. + True se la condizione viene soddisfatta entro lo scadere del timeout. In caso contrario, False. + Delegato da eseguire ripetutamente finché non restituisce true. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + L'argomento è null. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata o fino allo scadere del timeout specificato. + True se la condizione viene soddisfatta entro lo scadere del timeout. In caso contrario, False. + Delegato da eseguire ripetutamente finché non restituisce true. + Oggetto che rappresenta il numero di millisecondi di attesa. In alternativa, per un'attesa indefinita, oggetto TimeSpan che rappresenta -1 millisecondi. + L'argomento è null. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Fornisce la funzionalità di base per propagare un contesto di sincronizzazione in vari modelli di sincronizzazione. + 2 + + + Crea una nuova istanza della classe . + + + Quando ne viene eseguito l'override in una classe derivata, crea una copia del contesto di sincronizzazione. + Nuovo oggetto . + 2 + + + Ottiene il contesto di sincronizzazione per il thread corrente. + Oggetto che rappresenta il contesto di sincronizzazione corrente. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, risponde alla notifica di completamento di un'operazione. + + + Quando ne viene eseguito l'override in una classe derivata, risponde alla notifica di avvio di un'operazione. + + + Quando ne viene eseguito l'override in una classe derivata, invia un messaggio asincrono a un contesto di sincronizzazione. + Delegato di da chiamare. + Oggetto passato al delegato. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, invia un messaggio sincrono a un contesto di sincronizzazione. + Delegato di da chiamare. + Oggetto passato al delegato. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Imposta il contesto di sincronizzazione corrente. + Oggetto da impostare. + 1 + + + + + + Eccezione generata quando un metodo richiede che il chiamante sia il proprietario del blocco su un Monitor specifico, e tale metodo viene richiamato da un chiamante che non è proprietario del blocco. + 2 + + + Consente l'inizializzazione di una nuova istanza della classe con le proprietà predefinite. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Consente l'archiviazione dei dati nella memoria locale dei thread. + Specifica il tipo di dati archiviati per thread. + + + Inizializza l'istanza . + + + Inizializza l'istanza . + Se tenere traccia di tutti i valori impostati sull'istanza ed esporli mediante la proprietà di . + + + Inizializza l'istanza di con la funzione specificata. + Oggetto richiamato per produrre un valore con inizializzazione differita quando si tenta di recuperare l'oggetto senza che sia stato inizializzato in precedenza. + + è un riferimento null (Nothing in Visual Basic). + + + Inizializza l'istanza di con la funzione specificata. + Oggetto richiamato per produrre un valore con inizializzazione differita quando si tenta di recuperare l'oggetto senza che sia stato inizializzato in precedenza. + Se tenere traccia di tutti i valori impostati sull'istanza ed esporli mediante la proprietà di . + + è un riferimento null (Nothing in Visual Basic). + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse utilizzate da questa istanza di . + Valore booleano che indica se questo metodo viene chiamato a causa di una chiamata a . + + + Rilascia le risorse utilizzate da questa istanza di . + + + Ottiene un valore che indica se l'oggetto è inizializzato sul thread corrente. + true se viene inizializzato sul thread corrente; in caso contrario, false. + L'istanza di è stata eliminata. + + + Crea e restituisce una rappresentazione di stringa di questa istanza per il thread corrente. + Risultato della chiamata di su . + L'istanza di è stata eliminata. + L'oggetto per il thread corrente è un riferimento Null (Nothing in Visual Basic). + La funzione di inizializzazione tenta di fare riferimento in modo ricorsivo a . + Non è fornito alcun costruttore predefinito e non è fornito alcun valore di factory. + + + Ottiene o imposta il valore di questa istanza per il thread corrente. + Restituisce un'istanza dell'oggetto della cui inizializzazione è responsabile questo oggetto ThreadLocal. + L'istanza di è stata eliminata. + La funzione di inizializzazione tenta di fare riferimento in modo ricorsivo a . + Non è fornito alcun costruttore predefinito e non è fornito alcun valore di factory. + + + Ottiene un elenco di tutti i valori attualmente archiviati da tutti i thread che hanno eseguito l'accesso a questa istanza. + Elenco di tutti i valori attualmente archiviati da tutti i thread che hanno eseguito l'accesso a questa istanza. + L'istanza di è stata eliminata. + + + Contiene metodi per l'esecuzione di operazioni relative alla memoria volatile. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il riferimento a un oggetto dal campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Riferimento a che è stato letto.Questo riferimento è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + Tipo di campo da leggere.Deve essere un tipo di riferimento, non un tipo di valore. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di memoria compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il riferimento a un oggetto specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il riferimento a un oggetto. + Riferimento a un oggetto da scrivere.Il riferimento viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + Tipo di campo da scrivere.Deve essere un tipo di riferimento, non un tipo di valore. + + + Eccezione generata durante il tentativo di aprire un semaforo o un mutex di sistema inesistente. + 2 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/ja/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/ja/System.Threading.xml new file mode 100644 index 000000000..1e2f71c3a --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/ja/System.Threading.xml @@ -0,0 +1,1950 @@ + + + + System.Threading + + + + スレッドが、別のスレッドが解放せずに終了することによって放棄した オブジェクトを取得したときにスローされる例外。 + 1 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 放棄されたミューテックスのインデックスを指定する場合はそのインデックスと、ミューテックスを表す オブジェクトを指定して、 クラスの新しいインスタンスを初期化します。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列内における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + + クラスの新しいインスタンスを、指定したエラー メッセージと内部例外を使用して初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null ではない場合、現在の例外は内部例外を処理する catch ブロックで発生します。 + + + エラー メッセージ、内部例外、放棄されたミューテックスのインデックスを指定する場合はそのインデックス、およびミューテックスを表す オブジェクトを指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null ではない場合、現在の例外は内部例外を処理する catch ブロックで発生します。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + エラー メッセージ、放棄されたミューテックスのインデックスを指定する場合はそのインデックス、および放棄されたミューテックスを指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + 例外の原因となった、放棄されたミューテックスがわかっている場合は、そのミューテックスを取得します。 + 放棄されたミューテックスを表す オブジェクト。放棄されたミューテックスを識別できなかった場合は null。 + 1 + + + 例外の原因となった、放棄されたミューテックスがわかっている場合は、そのミューテックスのインデックスを取得します。 + 放棄されたミューテックスを表す オブジェクトの、 メソッドに渡された待機ハンドルの配列内でのインデックス。放棄されたミューテックスのインデックスが識別できなかった場合は –1。 + 1 + + + 非同期メソッドなど、特定の非同期制御フローに対してローカルなアンビエント データを表します。 + アンビエント データの型。 + + + 変更通知を受信しない インスタンスをインスタンス生成します。 + + + 変更通知を受信する ローカル インスタンスをインスタンス生成します。 + どのスレッド上であっても現在の値が変更されたなら必ず呼び出されるデリゲート。 + + + アンビエント データの値を取得または設定します。 + アンビエント データの値。 + + + 変更通知のために登録する インスタンスに対するデータ変更情報を提供するクラス。 + データの型。 + + + データの現在の値を取得します。 + データの現在の値。 + + + データの前の値を取得します。 + データの前の値。 + + + 実行コンテキストの変更が原因で値が変更されたかどうかを示す値を返します。 + 実行コンテキストの変更が原因で値が変更された場合は true、それ以外の場合は false。 + + + イベントが発生したことを待機中のスレッドに通知します。このクラスは継承できません。 + 2 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + +初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + 複数のタスクが、複数のフェーズを通じて 1 つのアルゴリズムで並行して協調的に動作できるようにします。 + + + + クラスの新しいインスタンスを初期化します。 + 参加しているスレッドの数。 + + が 0 より小さいか、または 32,767 を超えています。 + + + + クラスの新しいインスタンスを初期化します。 + 参加しているスレッドの数。 + 各フェーズ後に実行する 。null (Visual Basic の場合は Nothing) は操作が行われないことを示すために渡されることがあります。 + + が 0 より小さいか、または 32,767 を超えています。 + + + 参加要素が 1 つ追加されることを に通知します。 + 新しい参加要素が最初に参加するバリアのフェーズ番号。 + 現在のインスタンスは既に破棄されています。 + 参加要素を追加すると、バリアの参加要素数が 32,767 を超えます。またはメソッドは、フェーズ後アクション内から呼び出されました。 + + + 複数の参加要素が追加されることを に通知します。 + 新しい参加要素が最初に参加するバリアのフェーズ番号。 + バリアに追加する追加の参加要素の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。または 参加要素を追加すると、バリアの参加要素数が 32,767 を超えます。 + メソッドは、フェーズ後アクション内から呼び出されました。 + + + バリアの現在のフェーズの番号を取得します。 + バリアの現在のフェーズの番号を返します。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + メソッドは、フェーズ後アクション内から呼び出されました。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + バリア内の参加要素の合計数を取得します。 + バリア内の参加要素の合計数を返します。 + + + 現在のフェーズでまだ通知していないバリア内の参加要素の数を取得します。 + 現在のフェーズでまだ通知していないバリア内の参加要素の数を返します。 + + + 参加要素が 1 つ削除されることを に通知します。 + 現在のインスタンスは既に破棄されています。 + バリアでは、既に 0 個の参加要素があります。またはメソッドは、フェーズ後アクション内から呼び出されました。 + + + 複数の参加要素が削除されることを に通知します。 + バリアから削除する追加の参加要素の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。 + バリアでは、既に 0 個の参加要素があります。またはメソッドは、フェーズ後アクション内から呼び出されました。 または現在の参加要素数が、指定された participantCount より小さい値です + 参加要素の総数が、指定した より小さくなっています。 + + + 参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 現在のインスタンスは既に破棄されています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + すべての参加しているスレッドが SignalAndWait を呼び出した後に、バリアのフェーズ後のアクションから例外がスローされた場合、その例外は BarrierPostPhaseException にラップされ、参加しているすべてのスレッドでスローされます。 + + + 32 ビット符号付き整数を使用してタイムアウトを計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 指定した時間内にすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + すべての参加しているスレッドが SignalAndWait を呼び出した後に、バリアのフェーズ後のアクションから例外がスローされた場合、その例外は BarrierPostPhaseException にラップされ、参加しているすべてのスレッドでスローされます。 + + + 取り消しトークンを観察すると同時に、32 ビット符号付き整数を使用してタイムアウトを計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 指定した時間内にすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + 取り消しトークンを観察すると同時に、参加要素がバリアに到達し、他のすべての参加要素がバリアに到達するまで待機することを通知します。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + + オブジェクトを使用して時間間隔を計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 他のすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが 32,767 を超えています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + 取り消しトークンを観察すると同時に、 オブジェクトを使用して時間間隔を計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 他のすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + + のフェーズ後アクションに失敗したときにスローされる例外。 + + + エラーを説明するシステム提供のメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + + + 指定した内部例外を使用して、 クラスの新しいインスタンスを初期化します。 + 現在の例外の原因である例外。 + + + エラーを説明する指定したメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + 新しいコンテキスト内で呼び出すメソッドを表します。 + コールバック メソッドが実行されるたびに使用する情報を格納したオブジェクト。 + 1 + + + カウントが 0 になったときに通知される同期プリミティブを表します。 + + + 指定されたカウントを使用して クラスの新しいインスタンスを初期化します。 + + の設定に最初に必要な通知の数。 + + が 0 未満です。 + + + + の現在のカウントを 1 つインクリメントします。 + 現在のインスタンスは既に破棄されています。 + 現在のインスタンスは既に設定されています。または が 以上です。 + + + + の現在のカウントを指定された値だけインクリメントします。 + + を増やす値。 + 現在のインスタンスは既に破棄されています。 + + が 0 以下です。 + 現在のインスタンスは既に設定されています。またはカウントが ずつインクリメントされた後、 が 以上です + + + イベントの設定に必要な残りの通知の数を取得します。 + イベントの設定に必要な残りの通知の数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + イベントの設定に最初に必要な通知の数を取得します。 + イベントの設定に最初に必要な通知の数。 + + + イベントが設定されているかどうかを判断します。 + イベントが設定されている場合は true。それ以外の場合は false。 + + + + を の値にリセットします。 + 現在のインスタンスは既に破棄されています。 + + + + プロパティを指定した値にリセットします。 + + の設定に必要な通知の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。 + + + 通知を に登録して、 の値をデクリメントします。 + 通知によってカウントが 0 になり、イベントが設定された場合は true。それ以外の場合は false。 + 現在のインスタンスは既に破棄されています。 + 現在のインスタンスは既に設定されています。 + + + 複数の通知を に登録して、 の値を指定された量だけデクリメントします。 + 通知によってカウントが 0 になり、イベントが設定された場合は true。それ以外の場合は false。 + 登録する通知の数。 + 現在のインスタンスは既に破棄されています。 + + が 1 未満です。 + 現在のインスタンスは既に設定されています。-または- または、 が より大きいです。 + + + + を 1 つインクリメントすることを試みます。 + インクリメントが正常に行われた場合は true。それ以外の場合は false。 が既に 0 の場合、このメソッドは false を返します。 + 現在のインスタンスは既に破棄されています。 + + と が等価です。 + + + + を指定した値だけインクリメントすることを試みます。 + インクリメントが正常に行われた場合は true。それ以外の場合は false。 が既に 0 の場合、これは false を返します。 + + を増やす値。 + 現在のインスタンスは既に破棄されています。 + + が 0 以下です。 + 現在のインスタンスは既に設定されています。または + は、 以上です。 + + + + が設定されるまで、現在のスレッドをブロックします。 + 現在のインスタンスは既に破棄されています。 + + + 32 ビット符号付き整数を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、32 ビット符号付き整数を使用してタイムアウトを計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、 が設定されるまで、現在のスレッドをブロックします。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + + + を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + + を観察すると同時に、 を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + イベントの設定を待機するために使用する を取得します。 + イベントの設定を待機するために使用する 。 + 現在のインスタンスは既に破棄されています。 + + + シグナルを受信した後で が自動的にリセットされるか、または手動でリセットされるかを示します。 + 2 + + + シグナルを受信すると、 は 1 つのスレッドを解放した後で自動的にリセットされます。待機しているスレッドがない場合、 はスレッドがブロックされるまでシグナル状態のままとなり、そのスレッドを解放した後でリセットされます。 + + + シグナルを受信すると、 は待機しているスレッドをすべて解放し、手動でリセットされるまでシグナル状態のままとなります。 + + + スレッドの同期イベントを表します。 + 2 + + + 待機ハンドルの初期状態をシグナル状態に設定するかどうか、および、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるかを指定して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + + + この呼び出しの結果として待機ハンドルが作成された場合に待機ハンドルの初期状態をシグナル状態に設定するかどうか、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるか、およびシステムの同期イベントの名前を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きイベントが作成された場合に初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + システム全体で有効な同期イベントの名前。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きイベントが存在しますが、ユーザーに がありません。 + 名前付きイベントを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + が 260 文字を超えています。 + + + この呼び出しの結果として待機ハンドルが作成された場合に待機ハンドルの初期状態をシグナル状態に設定するかどうか、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるか、システム同期イベントの名前、および、呼び出し後の値によって名前付きイベントが作成されたかどうかを示すブール変数を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きイベントが作成された場合に初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + システム全体で有効な同期イベントの名前。 + このメソッドから制御が戻るときに、ローカル イベントが作成された場合 ( が null または空の文字列の場合)、または指定した名前付きシステム イベントが作成された場合は true が格納されます。指定した名前付きシステム イベントが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きイベントが存在しますが、ユーザーに がありません。 + 名前付きイベントを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + が 260 文字を超えています。 + + + 既に存在する場合は、指定した名前付き同期イベントを開きます。 + 名前付きシステム イベントを表すオブジェクト。 + 開くシステム同期イベントの名前。 + + が空の文字列です。または が 260 文字を超えています。 + + は null なので、 + 名前付きシステム イベントが存在しません。 + Win32 エラーが発生しました。 + 名前付きイベントは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + イベントの状態を非シグナル状態に設定し、スレッドをブロックします。 + 正常に操作できた場合は true。それ以外の場合は false。 + この で メソッドが既に呼び出されています。 + 2 + + + イベントの状態をシグナル状態に設定し、待機している 1 つ以上のスレッドが進行できるようにします。 + 正常に操作できた場合は true。それ以外の場合は false。 + この で メソッドが既に呼び出されています。 + 2 + + + 既に存在する場合は、指定した名前付き同期イベントを開き操作が成功したかどうかを示す値を返します。 + 名前付きの同期イベントが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム同期イベントの名前。 + このメソッドから制御が戻るときに、呼び出しに成功した場合は名前付き同期イベントを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または が 260 文字を超えています。 + + は null なので、 + Win32 エラーが発生しました。 + 名前付きイベントは存在しますが、必要なセキュリティ アクセスがユーザーにありません。 + + + 現在のスレッドの実行コンテキストを管理します。このクラスは継承できません。 + 2 + + + 現在のスレッドから実行コンテキストをキャプチャします。 + 現在のスレッドの実行コンテキストを表す オブジェクト。 + 1 + + + 現在のスレッドで指定した実行コンテキストを使用してメソッドを実行します。 + 設定する 。 + 指定した実行コンテキストで実行するメソッドを表す デリゲート。 + コールバック メソッドに渡すオブジェクト。 + + は null なので、またはキャプチャ操作で が取得されませんでした。または は、 呼び出しの引数として既に使用されています。 + 1 + + + + + + 複数のスレッドで共有される変数に分割不可能な操作を提供します。 + 2 + + + 分割不可能な操作として、2 つの 32 ビット整数を加算し、最初の整数を合計で置き換えます。 + + に格納された新しい値。 + 加算する最初の値を含む変数。2 つの値の合計は、 に格納されます。 + + にある整数に加算する値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、2 つの 64 ビット整数を加算し、最初の整数を合計で置き換えます。 + + に格納された新しい値。 + 加算する最初の値を含む変数。2 つの値の合計は、 に格納されます。 + + にある整数に加算する値。 + The address of is a null pointer. + 1 + + + 2 つの倍精度浮動小数点数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つの 32 ビット符号付き整数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つの 64 ビット符号付き整数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つのプラットフォーム固有のハンドルまたはポインターが等しいかどうかを比較します。等しい場合は、最初の 1 つを置き換えます。 + + の元の値。 + 値を の値と比較し、場合によっては によって置き換える、比較先の 。 + 比較した結果が等しい場合に比較先の値を置き換える 。 + + にある値と比較する 。 + The address of is a null pointer. + 1 + + + 2 つのオブジェクトの参照が等値であるかどうかを比較します。等しい場合は、最初のオブジェクトを置き換えます。 + + の元の値。 + + と比較し、場合によっては置き換える比較先のオブジェクト。 + 比較した結果が等しい場合に比較先のオブジェクトを置き換えるオブジェクト。 + + にあるオブジェクトと比較するオブジェクト。 + The address of is a null pointer. + 1 + + + 2 つの単精度浮動小数点数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 指定した参照型 の 2 つのインスタンスが等しいかどうかを比較します。等しい場合は、最初の 1 つを置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。これは参照パラメーターです (C# では ref、Visual Basic では ByRef)。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + + 、、および に使用する型。この型は、参照型である必要があります。 + The address of is a null pointer. + + + 分割不可能な操作として、指定した変数をデクリメントし、結果を格納します。 + デクリメントされた値。 + 値がデクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した変数をデクリメントしてその結果を格納します。 + デクリメントされた値。 + 値がデクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を倍精度浮動小数点数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を 32 ビット符号付き整数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を 64 ビット符号付き整数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、プラットフォーム固有のハンドルまたはポインターに指定した値を設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値をオブジェクトとして設定し、元のオブジェクトへの参照を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を単精度浮動小数点数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した型 の変数に指定した値を設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。これは参照パラメーターです (C# では ref、Visual Basic では ByRef)。 + + パラメーターに設定される値。 + + 、および に使用する型。この型は、参照型である必要があります。 + The address of is a null pointer. + + + 分割不可能な操作として、指定した変数をインクリメントし、結果を格納します。 + インクリメントされた値。 + 値がインクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した変数をインクリメントし、結果を格納します。 + インクリメントされた値。 + 値がインクリメントされる変数。 + The address of is a null pointer. + 1 + + + メモリ アクセスを同期します。現在のスレッドを実行中のプロセッサは、 を呼び出す前のメモリ アクセスを の呼び出し後のメモリ アクセスより後に実行するように命令を並べ替えることはできなくなります。 + + + 分割不可能な操作として 64 ビット値を読み込んで返します。 + 読み込まれた値。 + 読み込む 64 ビット値。 + 1 + + + 限定的な初期化ルーチンを提供します。 + + + まだ初期化されていない場合、型の既定のコンストラクターを使用してターゲット参照型を初期化します。 + 型 の初期化された参照。 + まだ初期化されていない場合は、初期化する型 の参照。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、既定のコンストラクターを使用してターゲット参照または値型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照または値。 + ターゲットが既に初期化されているかどうかを判断するブール値への参照。 + + を初期化するために相互排他的ロックとして使用されるオブジェクトへの参照。 が null の場合、新しいオブジェクトがインスタンス化されます。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、指定された関数を使用してターゲット参照または値型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照または値。 + ターゲットが既に初期化されているかどうかを判断するブール値への参照。 + + を初期化するために相互排他的ロックとして使用されるオブジェクトへの参照。 が null の場合、新しいオブジェクトがインスタンス化されます。 + 参照または値を初期化するために呼び出される関数。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、指定された関数を使用してターゲット参照型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照。 + 参照を初期化するために呼び出される関数。 + 初期化される参照の参照型。 + 型 には既定のコンストラクターがありません。 + + null (Visual Basic の場合は Nothing) を返しました。 + + + 再帰的にロックに入る処理が、ロックの再帰ポリシーと互換性がない場合にスローされる例外です。 + 2 + + + エラーを説明するシステム提供のメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 2 + + + エラーを説明する指定したメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元は、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 2 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元は、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外を引き起こした例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + 2 + + + 同じスレッドが複数回ロックに入れるかどうかを指定します。 + + + スレッドが、再帰的にロックに入ろうとすると、例外がスローされます。クラスによっては、この設定が適用されている場合に、特定の再帰が認められることがあります。 + + + スレッドが再帰的にロックに入ることができます。クラスによっては、この機能が制限されていることがあります。 + + + イベントが発生したことを、1 つ以上の待機中のスレッドに通知します。このクラスは継承できません。 + 2 + + + 初期状態をシグナル状態に設定するかどうかを示す Boolean 型の値を使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + + の規模を小さくしたバージョンを提供します。 + + + 初期状態を非シグナル状態にして、 クラスの新しいインスタンスを初期化します。 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値および指定されたスピン カウントを使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + カーネル ベースの待機操作に戻る前に発生するスピン待機の数。 + + is less than 0 or greater than the maximum allowed value. + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true、アンマネージ リソースだけを解放する場合は false。 + + + イベントが設定されているかどうかを取得します。 + イベントが設定されている場合は true。それ以外の場合は false。 + + + イベントの状態を非シグナル状態に設定し、スレッドをブロックします。 + The object has already been disposed. + + + イベントの状態をシグナル状態に設定して、イベント上で待機している 1 つ以上のスレッドが進行できるようにします。 + + + カーネル ベースの待機操作に戻る前に発生するスピン待機の数を取得します。 + カーネル ベースの待機操作に戻る前に発生するスピン待機の数を返します。 + + + 現在の が設定されるまで、現在のスレッドをブロックします。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 32 ビット符号付き整数を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + を観察すると同時に、32 ビット符号付き整数を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + + を観察すると同時に、現在の が信号を受信するまで、現在のスレッドをブロックします。 + 観察する 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + + を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + を観察すると同時に、 を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + この の オブジェクトを取得します。 + この の基になる イベント オブジェクト。 + + + オブジェクトへのアクセスを同期する機構を提供します。 + 2 + + + 指定したオブジェクトの排他ロックを取得します。 + モニター ロックを取得する対象となるオブジェクト。 + + パラメーターが null です。 + 1 + + + 指定したオブジェクトの排他ロックを取得し、ロックが取得されたかどうかを示す値をアトミックに設定します。 + 待機を行うオブジェクト。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。メモ   例外が発生しない場合、このメソッドの出力は常に true です。 + + への入力は true です。 + + パラメーターが null です。 + + + 指定したオブジェクトの排他ロックを解放します。 + ロックを解放する対象となるオブジェクト。 + + パラメーターが null です。 + 現在のスレッドが、指定したオブジェクトのロックを所有していません。 + 1 + + + 現在のスレッドが指定したオブジェクトのロックを保持しているかどうかを判断します。 + 現在のスレッドが のロックを保持している場合は true。それ以外の場合は false。 + テストするオブジェクト。 + + は null です。 + + + ロックされたオブジェクトの状態が変更されたことを、待機キュー内のスレッドに通知します。 + スレッドが待機するオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + 1 + + + オブジェクトの状態が変更されたことを、待機中のすべてのスレッドに通知します。 + パルスを送るオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + 1 + + + 指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + + パラメーターが null です。 + 1 + + + 指定したオブジェクトの排他ロックの取得を試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + + 指定したミリ秒間に、指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + ロックを待機するミリ秒単位の時間。 + + パラメーターが null です。 + + が負で、 と等価でありません。 + 1 + + + 指定したオブジェクトの排他ロックの取得を指定したミリ秒間試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを待機するミリ秒単位の時間。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + が負で、 と等価でありません。 + + + 指定した時間内に、指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + ロックを待機する時間を表す 。–1 ミリ秒という値は、無期限の待機を指定します。 + + パラメーターが null です。 + + の値 (ミリ秒) が負で、かつ (-1 ミリ秒) と等価でありません。または より大きい値です。 + 1 + + + 指定したオブジェクトの排他ロックの取得を指定した時間にわたって試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを待機する時間。–1 ミリ秒という値は、無期限の待機を指定します。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + の値 (ミリ秒) が負で、かつ (-1 ミリ秒) と等価でありません。または より大きい値です。 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。 + 指定したオブジェクトのロックを呼び出し元が再取得したために、呼び出しが戻った場合は true。このメソッドは、ロックが再取得されないと制御を戻しません。 + 待機を行うオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + 1 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。指定されたタイムアウト期限を過ぎると、スレッドは実行待ちキューに入ります。 + 指定した時間が経過する前にロックが再取得された場合は true。指定した時間が経過した後にロックが再取得された場合は false。このメソッドは、ロックが再取得されるまで制御を戻しません。 + 待機を行うオブジェクト。 + スレッドが実行待ちキューに入るまでの待機時間 (ミリ秒)。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + + パラメーターの値が負で、 と等しくありません。 + 1 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。指定されたタイムアウト期限を過ぎると、スレッドは実行待ちキューに入ります。 + 指定した時間が経過する前にロックが再取得された場合は true。指定した時間が経過した後にロックが再取得された場合は false。このメソッドは、ロックが再取得されるまで制御を戻しません。 + 待機を行うオブジェクト。 + スレッドが実行待ちキューに入るまでの時間を表す 。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + + パラメーターのミリ秒単位の値が負で、かつ (–1 ミリ秒) ではありません。または より大きい値です。 + 1 + + + 同期プリミティブは、プロセス間の同期にも使用できます。 + 1 + + + + クラスの新しいインスタンスを、既定のプロパティを使用して初期化します。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + 呼び出し元スレッドにミューテックスの初期所有権を与える場合は true。それ以外の場合は false。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値と、ミューテックスの名前を表す文字列を使用して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きシステム ミューテックスが作成された場合に、呼び出し元スレッドに名前付きシステム ミューテックスの初期所有権を付与する場合は true。それ以外の場合は false。 + + の名前。値が null の場合、 は無名になります。 + アクセス制御セキュリティを使用した名前付きミューテックスが存在しますが、ユーザーに がありません。 + Win32 エラーが発生しました。 + 名前付きミューテックスを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + 260 文字を超えています。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値、ミューテックスの名前を表す文字列、およびメソッドから戻るときにミューテックスの初期所有権が呼び出し元のスレッドに付与されたかどうかを示すブール値を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きシステム ミューテックスが作成された場合に、呼び出し元スレッドに名前付きシステム ミューテックスの初期所有権を付与する場合は true。それ以外の場合は false。 + + の名前。値が null の場合、 は無名になります。 + このメソッドから制御が戻るとき、ローカル ミューテックスが作成された場合 (つまり が null または空の文字列の場合) または指定した名前付きシステム ミューテックスが作成された場合は、ブール値 true が格納されます。指定した名前付きシステム ミューテックスが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + アクセス制御セキュリティを使用した名前付きミューテックスが存在しますが、ユーザーに がありません。 + Win32 エラーが発生しました。 + 名前付きミューテックスを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + 260 文字を超えています。 + + + 既に存在する場合は、指定した名前付きミューテックスを開きます。 + 名前付きシステム ミューテックスを表すオブジェクト。 + 開くシステム ミューテックスの名前。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + 名前付きミューテックスが存在しません。 + Win32 エラーが発生しました。 + 名前付きミューテックスは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + + を一度解放します。 + 呼び出し元のスレッドはミューテックスを所有していません。 + 1 + + + 既に存在する場合は、指定した名前付きミューテックスを開き操作が成功したかどうかを示す値を返します。 + 名前付きミューテックスが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム ミューテックスの名前。 + このメソッドから戻るときに、呼び出しに成功した場合は名前付きミューテックスを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + Win32 エラーが発生しました。 + 名前付きミューテックスは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + + + リソースへのアクセス管理に使用するロックを表し、複数のスレッドによる読み取りや排他アクセスでの書き込みを実現します。 + + + + クラスの新しいインスタンスを既定のプロパティ値で初期化します。 + + + ロック再帰ポリシーを指定して、 クラスの新しいインスタンスを初期化します。 + ロック再帰ポリシーを指定する列挙値のいずれか。 + + + 読み取りモードでロックに入った一意のスレッドの総数を取得します。 + 読み取りモードでロックに入った一意のスレッドの数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 読み取りモードでロックに入ることを試みます。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + アップグレード可能モードでロックに入ることを試みます。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 書き込みモードでロックに入ることを試みます。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 読み取りモードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合には読み取りモードを終了します。 + The current thread has not entered the lock in read mode. + + + アップグレード可能モードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合にはアップグレード可能モードを終了します。 + The current thread has not entered the lock in upgradeable mode. + + + 書き込みモードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合には書き込みモードを終了します。 + The current thread has not entered the lock in write mode. + + + 現在のスレッドが読み取りモードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在のスレッドがアップグレード可能モードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在のスレッドが書き込みモードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在の オブジェクトの再帰ポリシーを示す値を取得します。 + ロック再帰ポリシーを指定する列挙値のいずれか。 + + + 現在のスレッドが読み取りモードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドは読み取りモードに入っていません。1 の場合、現在のスレッドは読み取りモードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回ロックに入りました。 + 2 + + + 現在のスレッドがアップグレード可能モードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドはアップグレード可能モードに入っていません。1 の場合、現在のスレッドはアップグレード可能モードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回アップグレード可能モードに入りました。 + 2 + + + 現在のスレッドが書き込みモードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドは書き込みモードに入っていません。1 の場合、現在のスレッドは書き込みモードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回書き込みモードに入りました。 + 2 + + + オプションのタイムアウトを表す整数を指定して、読み取りモードでロックに入ることを試みます。 + 呼び出し元のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、読み取りモードでロックに入ることを試みます。 + 呼び出し元のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + オプションのタイムアウトを指定して、アップグレード可能モードでロックに入ることを試みます。 + 呼び出し元のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、アップグレード可能モードでロックに入ることを試みます。 + 呼び出し元のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + オプションのタイムアウトを指定して、書き込みモードでロックに入ることを試みます。 + 呼び出し元のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、書き込みモードでロックに入ることを試みます。 + 呼び出し元のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 読み取りモードでロックに入るのを待機しているスレッドの総数を取得します。 + 読み取りモードに入るのを待機しているスレッドの総数。 + 2 + + + アップグレード可能モードでロックに入るのを待機しているスレッドの総数を取得します。 + アップグレード可能モードに入るのを待機しているスレッドの総数。 + 2 + + + 書き込みモードでロックに入るのを待機しているスレッドの総数を取得します。 + 書き込みモードに入るのを待機しているスレッドの総数。 + 2 + + + リソースまたはリソースのプールに同時にアクセスできるスレッドの数を制限します。 + 1 + + + エントリ数の初期値と同時実行エントリの最大数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + + が より大きくなっています。 + + 1 より小さい値です。または が 0 未満です。 + + + エントリ数の初期値と同時実行エントリの最大数を指定し、オプションでシステム セマフォ オブジェクトの名前を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + 名前付きシステム セマフォ オブジェクトの名前。 + + が より大きくなっています。または 260 文字を超えています。 + + 1 より小さい値です。または が 0 未満です。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きセマフォが存在しており、ユーザーに がありません。 + 名前付きセマフォを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + + エントリ数の初期値と同時実行エントリの最大数を指定し、オプションでシステム セマフォ オブジェクトの名前を指定し、新しいシステム セマフォが作成されたかどうかを示す値を受け取る変数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に満たされるセマフォの要求の初期数。 + 同時に満たされるセマフォの要求の最大数。 + 名前付きシステム セマフォ オブジェクトの名前。 + このメソッドから制御が戻るときに、ローカル セマフォが作成された場合 ( が null または空の文字列の場合)、または指定した名前付きシステム セマフォが作成された場合は true が格納されます。指定した名前付きシステム セマフォが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + + が より大きくなっています。または 260 文字を超えています。 + + 1 より小さい値です。または が 0 未満です。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きセマフォが存在しており、ユーザーに がありません。 + 名前付きセマフォを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + + 既に存在する場合は、指定した名前付きセマフォを開きます。 + 名前付きシステム セマフォを表すオブジェクト。 + 開くシステム セマフォの名前。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + 名前付きセマフォが存在しません。 + Win32 エラーが発生しました。 + 名前付きセマフォは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + セマフォから出て、前のカウントを返します。 + + メソッドが呼び出される前のセマフォのカウント。 + セマフォのカウントは既に最大値です。 + 名前付きセマフォで Win32 エラーが発生しました。 + 現在のセマフォは名前付きシステム セマフォを表していますが、ユーザーに がありません。または現在のセマフォは名前付きシステム セマフォを表していますが、 で開かれませんでした。 + 1 + + + 指定した回数だけセマフォから出て、前のカウントを返します。 + + メソッドが呼び出される前のセマフォのカウント。 + セマフォから出る回数。 + + 1 より小さい値です。 + セマフォのカウントは既に最大値です。 + 名前付きセマフォで Win32 エラーが発生しました。 + 現在のセマフォは名前付きシステム セマフォを表していますが、ユーザーに 権限がありません。または現在のセマフォは名前付きシステム セマフォを表していますが、 権限で開かれませんでした。 + 1 + + + 既に存在する場合は、指定した名前付きセマフォを開き操作が成功したかどうかを示す値を返します。 + 名前付きのセマフォが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム セマフォの名前。 + このメソッドから制御が戻るときに、呼び出しに成功した場合は名前付きセマフォを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + Win32 エラーが発生しました。 + 名前付きセマフォは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + + + カウントが既に最大値であるセマフォに対して メソッドが呼び出された場合にスローされる例外。 + 2 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + リソースまたはリソースのプールに同時にアクセスできるスレッドの数を制限する の軽量版を表します。 + + + 同時に許可される要求の初期数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + + が 0 未満です。 + + + 同時に許可される要求の初期数および最大数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + + が 0 より小さいか、 が を超えているか、または が 0 以下です。 + + + セマフォの待機に使用できる を返します。 + セマフォの待機に使用できる です。 + + は破棄されています。 + + + + オブジェクトに入る、残りのスレッド数を取得します。 + セマフォに入る、残りのスレッド数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + が使用しているアンマネージ リソースを解放します。オプションとして、マネージ リソースを解放することもできます。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + + のオブジェクトを一度解放します。 + + の前のカウント。 + 現在のインスタンスは既に破棄されています。 + + は、既にその最大サイズに達しました。 + + + 指定された回数だけ、 オブジェクトを解放します。 + + の前のカウント。 + セマフォから出る回数。 + 現在のインスタンスは既に破棄されています。 + + 1 より小さい値です。 + + は、既にその最大サイズに達しました。 + + + + に入れるようになるまで、現在のスレッドをブロックします。 + 現在のインスタンスは既に破棄されています。 + + + タイムアウト値を 32 ビット符号付き整数で指定して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、タイムアウト値を 32 ビット符号付き整数で指定して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + インスタンスが破棄されている、または 作成 破棄されています。 + + + + を観察すると同時に、 に入れるようになるまで、現在のスレッドをブロックします。 + 観察する トークン。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または 作成 既に破棄されています。 + + + + を使用してタイムアウトを指定し、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + semaphoreSlim インスタンスが破棄されました。 + + + + を観察すると同時に、タイムアウトを指定する を使用して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + semaphoreSlim インスタンスが破棄されました。 を作成した は既に破棄されています。 + + + + に移行するために非同期に待機します。 + セマフォに入っているときに完了するタスク。 + + + 32 ビット符号付き整数を使用して時間間隔を測定しながら、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + 32 ビット符号付き整数を使用して時間間隔を測定しながら、 を観察すると同時に、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + 現在のインスタンスは既に破棄されています。 + + が取り消されました。 + + + + を観察すると同時に、 に移行するために非同期に待機します。 + セマフォに入っているときに完了するタスク。 + 観察する トークン。 + 現在のインスタンスは既に破棄されています。 + + が取り消されました。 + + + + を使用して時間間隔を測定しながら、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します または タイムアウトは より大きい値です。 + + + + を使用して時間間隔を測定しながら、 を観察すると同時に、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する トークン。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表しますまたはタイムアウトは より大きい値です。 + + が取り消されました。 + + + メッセージを同期コンテキストにディスパッチするときに呼び出すメソッドを表します。 + デリゲートに渡されたオブジェクト。 + 2 + + + ロックが使用可能になるまで、ロックを取得しようとするスレッドがループの繰り返しチェック内で待機する相互排他ロック プリミティブを提供します。 + + + デバッグを向上させるためにスレッド ID を追跡するオプションを使用して、 構造体の新しいインスタンスを初期化します。 + デバッグのためにスレッド ID をキャプチャして使用するかどうか。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックを取得します。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + 引数は、Enter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + ロックを解放します。 + スレッドの所有権の追跡が有効で、現在のスレッドはこのロックの所有者ではありません。 + + + ロックを解放します。 + 終了操作を他のスレッドに直ちに発行するためにメモリ フェンスを発行する必要があるかどうかを示すブール値。 + スレッドの所有権の追跡が有効で、現在のスレッドはこのロックの所有者ではありません。 + + + ロックが現在いずれかのスレッドによって保持されているかどうかを取得します。 + ロックが現在いずれかのスレッドによって保持されている場合は true。それ以外の場合は false。 + + + ロックが現在のスレッドによって保持されているかどうかを取得します。 + ロックが現在のスレッドによって保持されている場合は true。それ以外の場合は false。 + スレッドの所有権の追跡が無効です。 + + + このインスタンスに対してスレッド所有権の追跡が有効になっているかどうかを取得します。 + このインスタンスに対してスレッド所有権の追跡が有効になっている場合は true。それ以外の場合は false。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが ミリ秒を超えています。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + スピンベースの待機のサポートを提供します。 + + + このインスタンスで が呼び出された回数を取得します。 + このインスタンスで が呼び出された回数を表す整数を返します。 + + + 次に を呼び出したときにプロセッサが生成され、強制的にコンテキストが切り替えられるかどうかを取得します。 + 次に を呼び出したときにプロセッサが生成され、強制的にコンテキストが切り替えられるかどうか。 + + + スピン カウンターをリセットします。 + + + 単一のスピンを実行します。 + + + 指定した条件が満たされるまで回転します。 + true を返すまで繰り返し実行されるデリゲート。 + + 引数が null です。 + + + 指定した条件が満たされるか、指定したタイムアウトが経過するまで回転します。 + タイムアウト内に条件が満たされた場合は true。それ以外の場合は false。 + true を返すまで繰り返し実行されるデリゲート。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + 引数が null です。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + 指定した条件が満たされるか、指定したタイムアウトが経過するまで回転します。 + タイムアウト内に条件が満たされた場合は true。それ以外の場合は false。 + true を返すまで繰り返し実行されるデリゲート。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す TimeSpan。 + + 引数が null です。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + 同期コンテキストをさまざまな同期モデルに反映させるための基本機能を提供します。 + 2 + + + + クラスの新しいインスタンスを作成します。 + + + 派生クラスでオーバーライドされた場合、同期コンテキストのコピーを作成します。 + 新しい オブジェクト。 + 2 + + + 現在のスレッドの同期コンテキストを取得します。 + 現在の同期コンテキストを表す オブジェクト。 + 1 + + + 派生クラスでオーバーライドされた場合、操作の完了を伝える通知に応答します。 + + + 派生クラスでオーバーライドされた場合、操作の開始を伝える通知に応答します。 + + + 派生クラスでオーバーライドされた場合、非同期メッセージを同期コンテキストにディスパッチします。 + 呼び出す デリゲート。 + デリゲートに渡されたオブジェクト。 + 2 + + + 派生クラスでオーバーライドされた場合、同期メッセージを同期コンテキストにディスパッチします。 + 呼び出す デリゲート。 + デリゲートに渡されたオブジェクト。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 現在の同期コンテキストを設定します。 + 設定する オブジェクト + 1 + + + + + + 指定した Monitor でロックを所有していることが呼び出し元の条件となるメソッドを、そのロックを所有していない呼び出し元が呼び出した場合にスローされる例外です。 + 2 + + + + クラスの新しいインスタンスを既定のプロパティを使用して初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + データのスレッド ローカル ストレージを提供します。 + スレッド単位で格納されるデータの型を指定します。 + + + + インスタンスを初期化します。 + + + + インスタンスを初期化します。 + インスタンスに設定されているすべての値を追跡し、それらの値を プロパティを通じて公開するかどうか。 + + + + 関数を指定して、 インスタンスを初期化します。 + 前もって初期化せずに を取得しようとすると、後で初期化された値を生成するために が呼び出されます。 + + が null 参照 (Visual Basic の場合は Nothing) です。 + + + + 関数を指定して、 インスタンスを初期化します。 + 前もって初期化せずに を取得しようとすると、後で初期化された値を生成するために が呼び出されます。 + インスタンスに設定されているすべての値を追跡し、それらの値を プロパティを通じて公開するかどうか。 + + が null 参照 (Visual Basic の場合は Nothing) です。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + この インスタンスによって使用されているリソースを解放します。 + + が呼び出されたことが原因でこのメソッドが呼び出されているかどうかを示すブール値。 + + + この インスタンスによって使用されているリソースを解放します。 + + + 現在のスレッドで が初期化されているかどうかを取得します。 + + が現在のスレッドで初期化される場合は true。それ以外の場合は false。 + + インスタンスは破棄されています。 + + + 現在のスレッドのこのインスタンスの文字列形式を作成して返します。 + + で を呼び出した結果。 + + インスタンスは破棄されています。 + 現在のスレッドの は null 参照 (Visual Basic での Nothing) です。 + 初期化関数が、 を再帰的に参照しようとしました。 + 既定のコンストラクターが指定されず、値ファクトリが指定されていません。 + + + 現在のスレッドのこのインスタンスの値を取得または設定します。 + この ThreadLocal が初期化するオブジェクトのインスタンスを返します。 + + インスタンスは破棄されています。 + 初期化関数が、 を再帰的に参照しようとしました。 + 既定のコンストラクターが指定されず、値ファクトリが指定されていません。 + + + このインスタンスにアクセスした全スレッドによって現在格納されているすべての値のリストを取得します。 + このインスタンスにアクセスした全スレッドによって現在格納されているすべての値のリスト。 + + インスタンスは破棄されています。 + + + 不揮発性メモリの操作を実行するためのメソッドが含まれます。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定したフィールドからオブジェクト参照を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた への参照。この参照は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + 読み取るフィールドの型。この型は、値型ではなく、参照型である必要があります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前にメモリ操作が配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定したオブジェクト参照を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + オブジェクト参照を書き込むフィールド。 + 書き込むオブジェクト参照。参照は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + 書き込むフィールドの型。この型は、値型ではなく、参照型である必要があります。 + + + 存在しないシステム ミューテックスまたはシステム セマフォを開こうとしたときにスローされる例外。 + 2 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/ko/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/ko/System.Threading.xml new file mode 100644 index 000000000..dd5f63d87 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/ko/System.Threading.xml @@ -0,0 +1,1952 @@ + + + + System.Threading + + + + 스레드가 다른 스레드에서 해제하지 않고 종료하여 중단한 개체를 가져오면 throw되는 예외입니다. + 1 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 중단된 뮤텍스의 지정된 인덱스 및 뮤텍스를 나타내는 개체(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 내부 예외를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 지정된 오류 메시지, 내부 예외, 중단된 뮤텍스의 인덱스 및 뮤텍스를 나타내는 개체(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 지정된 오류 메시지, 중단된 뮤텍스의 인덱스 및 중단된 뮤텍스(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 예외의 발생시킨 중단된 뮤텍스를 가져옵니다. + 중단된 뮤텍스를 나타내는 개체이며, 중단된 뮤텍스를 식별할 수 없는 경우에는 null입니다. + 1 + + + 예외의 발생시킨 중단된 뮤텍스를 가져옵니다. + + 메서드에 전달된 대기 핸들의 배열에서 중단된 뮤텍스를 나타내는 개체의 인덱스이고, 중단된 뮤텍스의 인덱스를 식별할 수 없는 경우에는 –1입니다. + 1 + + + 비동기 메서드와 같은 지정된 비동기 제어 흐름에 로컬인 앰비언트 데이터를 나타냅니다. + 앰비언트 데이터의 형식입니다. + + + 변경 알림을 받지 않는 인스턴스를 인스턴스화합니다. + + + 변경 알림을 받는 로컬 인스턴스를 인스턴스화합니다. + 스레드에서 현재 값이 변경될 때마다 호출되는 대리자입니다. + + + 앰비언트 데이터의 값을 가져오거나 설정합니다. + 앰비언트 데이터의 값입니다. + + + 변경 알림을 등록하는 인스턴스에 데이터 변경 정보를 제공하는 클래스입니다. + 데이터 형식입니다. + + + 데이터의 현재 값을 가져옵니다. + 데이터의 현재 값입니다. + + + 데이터의 이전 값을 가져옵니다. + 데이터의 이전 값입니다. + + + 실행 컨텍스트가 변경되어 값이 변경되었는지 여부를 나타내는 값을 반환합니다. + 실행 컨텍스트가 변경되어 값이 변경되었으면 true이고, 그렇지 않으면 false입니다. + + + 대기 중인 스레드에 이벤트가 발생했음을 알립니다.이 클래스는 상속될 수 없습니다. + 2 + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + + + 여러 작업이 여러 단계에 걸쳐 특정 알고리즘에서 병렬로 함께 작동할 수 있도록 합니다. + + + + 클래스의 새 인스턴스를 초기화합니다. + 참여 스레드의 수입니다. + + 가 0보다 작거나 32,767보다 큰 경우 + + + + 클래스의 새 인스턴스를 초기화합니다. + 참여 스레드의 수입니다. + 각 단계 후에 실행할 입니다. 아무 작업도 수행되지 않았음을 나타내기 위해 null(Visual Basic의 경우 Nothing)이 전달될 수 있습니다. + + 가 0보다 작거나 32,767보다 큰 경우 + + + 추가 참가자가 있음을 에 알립니다. + 새 참가자가 처음으로 참여할 장벽의 단계 번호입니다. + 현재 인스턴스가 이미 삭제된 경우 + 참가자를 추가하면 해당 장애물 참가자 수가 32,767을 초과하게 됩니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 추가 참가자가 있음을 에 알립니다. + 새 참가자가 처음으로 참여할 장벽의 단계 번호입니다. + 장벽에 추가할 추가 참가자의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우.또는 참가자를 추가하면 해당 장애물 참가자 수가 32,767을 초과하게 됩니다. + 이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 장벽의 현재 단계 번호를 가져옵니다. + 장벽의 현재 단계 번호를 반환합니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + 이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 장벽에 있는 참가자의 총 수를 가져옵니다. + 장벽에 있는 참가자의 총 수를 반환합니다. + + + 현재 단계에서 아직 신호를 받지 않은 장벽의 참가자 수를 가져옵니다. + 현재 단계에서 아직 신호를 받지 않은 장벽의 참가자 수를 반환합니다. + + + 참가자가 하나 감소함을 에 알립니다. + 현재 인스턴스가 이미 삭제된 경우 + 해당 장애물에 이미 0 참가자가 있습니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 참가자가 감소함을 에 알립니다. + 장벽에서 제거할 추가 참가자의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우. + 해당 장애물에 이미 0 참가자가 있습니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. 또는현재 참가자 수가 지정된 participantCount보다 작습니다. + 총 참가자 수가 지정된 보다 작습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 현재 인스턴스가 이미 삭제된 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + 모든 참가 스레드가 SignalAndWait를 호출한 후에 Barrier의 단계 후 작업에서 예외가 throw되는 경우 예외가 BarrierPostPhaseException에서 래핑되고 모든 참가 스레드에서 throw됩니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 부호 있는 32비트 정수로 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 지정된 시간 내에 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + 모든 참가 스레드가 SignalAndWait를 호출한 후에 Barrier의 단계 후 작업에서 예외가 throw되는 경우 예외가 BarrierPostPhaseException에서 래핑되고 모든 참가 스레드에서 throw됩니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 부호 있는 32비트 정수로 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 지정된 시간 내에 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 개체를 사용하여 시간 간격을 측정하여 다른 참가자도 장벽에 도달할 때까지 기다립니다. + 다른 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 없거나, 32,767보다 큰 경우. + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 개체를 사용하여 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 다른 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + + 의 사후 단계 작업이 실패할 경우 throw되는 예외입니다. + + + 오류를 설명하는 시스템 제공 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 내부 예외를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 현재 예외의 원인이 되는 예외입니다. + + + 오류를 설명하는 지정된 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 새 컨텍스트 내에서 호출될 메서드를 나타냅니다. + 콜백 메서드가 실행될 때마다 사용할 정보가 포함된 개체입니다. + 1 + + + 수가 0에 도달하는 경우 신호를 받는 동기화 기본 형식을 나타냅니다. + + + 지정된 수를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 를 설정하는 데 처음 필요한 신호의 수입니다. + + 가 0보다 작은 경우 + + + + 의 현재 수를 1씩 늘립니다. + 현재 인스턴스가 이미 삭제된 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는가 보다 크거나 같은 경우 + + + + 의 현재 수를 지정된 값만큼 늘립니다. + + 를 늘릴 값입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작거나 같은 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는개수가 만큼 증가된 후에 가 보다 크거나 같은 경우 + + + 이벤트를 설정하는 데 필요한 남아 있는 신호의 수를 가져옵니다. + 이벤트를 설정하는 데 필요한 남아 있는 신호의 수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 이벤트를 설정하는 데 처음으로 필요한 신호의 수를 가져옵니다. + 이벤트를 설정하는 데 처음으로 필요한 신호의 수입니다. + + + 이벤트가 설정되었는지 여부를 확인합니다. + 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + + + + 를 의 값으로 다시 설정합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + + 속성을 지정된 값으로 재설정합니다. + + 를 설정하는 데 필요한 신호의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우 + + + + 의 값을 줄이면서 신호를 에 등록합니다. + 신호로 인해 수가 0에 도달하고 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 현재 인스턴스가 이미 삭제된 경우 + 현재 인스턴스가 이미 설정되어 있습니다. + + + 지정된 양만큼 값을 줄이면서 여러 신호를 에 등록합니다. + 신호로 인해 수가 0에 도달하고 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 등록할 신호의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 1보다 작은 경우. + 현재 인스턴스가 이미 설정되어 있습니다. -또는- 가 보다 큰 경우 + + + 하나씩 를 증가하려고 시도했습니다. + 늘렸으면 true이고 그렇지 않으면 false입니다.가 이미 0이면 이 메서드에서 false를 반환합니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 와 같은 경우 + + + 지정된 값만큼 를 증가하려고 시도했습니다. + 늘렸으면 true이고 그렇지 않으면 false입니다.가 이미 0이면 false를 반환합니다. + + 를 늘릴 값입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작거나 같은 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는 + 가 보다 크거나 같은 경우 + + + + 가 설정될 때까지 현재 스레드를 차단합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + 부호 있는 32비트 정수로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을 확인하면서 부호 있는 32비트 정수로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을 확인하면서 가 설정될 때까지 현재 스레드를 차단합니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + + + 으로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + + 을 확인하면서 으로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + 이벤트가 설정될 때까지 대기하는 데 사용되는 을 가져옵니다. + 이벤트가 설정될 때까지 대기하는 데 사용되는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + + + 이 신호를 받은 후 자동이나 수동으로 다시 설정되는지 여부를 나타냅니다. + 2 + + + 신호를 받으면 이 스레드 하나를 해제한 후 자동으로 다시 설정됩니다.대기 중인 스레드가 없으면 은 스레드가 차단될 때까지 신호를 받은 상태로 유지되다가 스레드를 해제한 후 다시 설정됩니다. + + + 신호를 받으면 이 대기하는 스레드를 모두 해제하고 수동으로 다시 설정될 때까지 신호를 받은 상태로 유지됩니다. + + + 스레드 동기화 이벤트를 나타냅니다. + 2 + + + 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부와 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + + + 이 호출의 결과로 만들어진 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부, 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부 및 시스템 동기화 이벤트의 이름을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 이벤트가 만들어진 경우 초기 상태를 신호 받음으로 설정하려면 true를 사용하고, 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + 시스템 차원의 동기화 이벤트의 이름입니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 이벤트를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 이 260자보다 긴 경우 + + + 이 호출의 결과로 만들어진 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부, 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부, 시스템 동기화 이벤트의 이름 및 호출 후 명명된 시스템 이벤트가 만들어졌는지 여부를 나타내는 부울 변수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 이벤트가 만들어진 경우 초기 상태를 신호 받음으로 설정하려면 true를 사용하고, 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + 시스템 차원의 동기화 이벤트의 이름입니다. + 이 메서드가 반환될 때 로컬 이벤트가 만들어지거나(이 null 또는 빈 문자열) 명명된 지정 시스템 이벤트가 만들어지면 true가 포함되고 명명된 지정 시스템 이벤트가 이미 있으면 false가 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 이벤트를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 이 260자보다 긴 경우 + + + 이미 있는 경우 지정한 명명된 동기화 이벤트를 엽니다. + 명명된 시스템 이벤트를 나타내는 개체입니다. + 열려는 시스템 동기화 이벤트의 이름입니다. + + 이 빈 문자열인 경우 또는이 260자보다 긴 경우 + + 가 null입니다. + 명명된 시스템 이벤트가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 이벤트가 있지만 사용자에게 이 이벤트를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + 1 + + + + + + 스레드가 차단되도록 이벤트 상태를 신호 없음으로 설정합니다. + 작업이 성공적으로 수행되면 true이고, 그렇지 않으면 false입니다. + + 메서드가 이 에 대해 이전에 호출된 경우 + 2 + + + 하나 이상의 대기 중인 스레드가 계속 진행되도록 이벤트 상태를 신호 받음으로 설정합니다. + 작업이 성공적으로 수행되면 true이고, 그렇지 않으면 false입니다. + + 메서드가 이 에 대해 이전에 호출된 경우 + 2 + + + 지정된 명명된 synchronization 이벤트(이미 존재하는 경우)를 열고 작업이 성공적으로 수행되었는지를 나타내는 값을 반환합니다. + 명명된 동기화 이벤트를 열었으면 true이고, 그렇지 않으면 false입니다. + 열려는 시스템 동기화 이벤트의 이름입니다. + 이 메서드가 반환될 때 호출이 성공적으로 실행된 경우 이름이 지정된 동기화 이벤트를 나타내는 개체를 포함하고 호출에 실패한 경우는 null을 포함해야 합니다.이 매개 변수는 초기화되지 않은 것으로 취급됩니다. + + 이 빈 문자열인 경우또는이 260자보다 긴 경우 + + 가 null입니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 있지만 사용자에게 원하는 보안 액세스가 없는 경우 + + + 현재 스레드의 실행 컨텍스트를 관리합니다.이 클래스는 상속될 수 없습니다. + 2 + + + 현재 스레드에서 실행 컨텍스트를 캡처합니다. + 현재 스레드의 실행 컨텍스트를 나타내는 개체입니다. + 1 + + + 현재 스레드의 지정된 실행 컨텍스트에서 메서드를 실행합니다. + 설정할 입니다. + 제공된 실행 컨텍스트에서 실행할 메서드를 나타내는 대리자입니다. + 콜백 메서드로 전달할 개체입니다. + + 가 null입니다.또는캡처 작업을 통해 를 가져오지 않은 경우 또는가 이미 호출의 인수로 사용된 경우 + 1 + + + + + + 다중 스레드에서 공유하는 변수에 대한 원자 단위 연산을 제공합니다. + 2 + + + 원자 단위 연산으로 두 32비트 정수를 더하고 첫 번째 정수를 합계로 바꿉니다. + + 에 저장된 새 값입니다. + 더할 첫 번째 값이 있는 변수입니다.두 값의 합계는 에 저장됩니다. + + 에서 정수에 더할 값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 두 64비트 정수를 더하고 첫 번째 정수를 합계로 바꿉니다. + + 에 저장된 새 값입니다. + 더할 첫 번째 값이 있는 변수입니다.두 값의 합계는 에 저장됩니다. + + 에서 정수에 더할 값입니다. + The address of is a null pointer. + 1 + + + 두 배 정밀도 부동 소수점 숫자가 같은지 비교하여 같으면 두 값 중 하나를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 개의 부호 있는 32비트 정수가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 개의 부호 있는 64비트 정수가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 플랫폼별 핸들이나 포인터가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 값과 비교되어 로 바뀔 수 있는 값을 가진 대상 입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 입니다. + + 의 값과 비교할 입니다. + The address of is a null pointer. + 1 + + + 두 개체의 참조가 같은지 비교하여 같으면 첫 번째 개체를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 대상 개체입니다. + 비교한 결과 같은 경우 대상 개체를 바꾸는 개체입니다. + + 의 개체와 비교할 개체입니다. + The address of is a null pointer. + 1 + + + 두 단정밀도 부동 소수점 숫자가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 지정된 참조 형식 의 두 인스턴스가 같은지 비교하여 같으면 두 값 중 하나를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다.이것은 참조 매개 변수입니다. C#에서는 ref이고, Visual Basic에서는 ByRef입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + + , 및 에 사용될 형식입니다.이 형식은 참조 형식이어야 합니다. + The address of is a null pointer. + + + 원자 단위 연산으로 지정된 변수를 감소시키고 결과를 저장합니다. + 감소한 값입니다. + 값을 감소시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 변수를 감소시키고 결과를 저장합니다. + 감소한 값입니다. + 값을 감소시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 배정밀도 부동 소수점 숫자를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 부호 있는 32비트 정수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 부호 있는 64비트 정수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 플랫폼별 핸들 또는 포인터를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 개체를 지정된 값으로 설정하고 참조를 원래 개체로 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 단정밀도 부동 소수점 숫자를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 형식 의 변수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다.이것은 참조 매개 변수입니다. C#에서는 ref이고, Visual Basic에서는 ByRef입니다. + + 매개 변수의 설정값입니다. + + 및 에 사용될 형식입니다.이 형식은 참조 형식이어야 합니다. + The address of is a null pointer. + + + 원자 단위 연산으로 지정된 변수를 증가시키고 결과를 저장합니다. + 증가한 값입니다. + 값을 증가시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 변수를 증가시키고 결과를 저장합니다. + 증가한 값입니다. + 값을 증가시킬 변수입니다. + The address of is a null pointer. + 1 + + + 다음과 같이 메모리 액세스를 동기화합니다. 현재 스레드를 실행하는 프로세서는 에 대한 호출 이전의 메모리 액세스가 에 대한 호출 이후의 메모리 액세스 뒤에 실행되는 방식으로 명령을 다시 정렬할 수 없습니다. + + + 원자 단위 연산으로 로드된 64비트 값을 반환합니다. + 로드된 값입니다. + 로드될 64비트 값입니다. + 1 + + + 초기화 지연 루틴을 제공합니다. + + + 아직 초기화되지 않은 경우 형식의 기본 생성자를 사용하여 대상 참조 형식을 초기화합니다. + 초기화된 형식의 참조입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조입니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 해당 기본 생성자를 사용하여 대상 참조 또는 값 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조 또는 값입니다. + 대상이 이미 초기화되었는지 여부를 결정하는 부울 값에 대한 참조입니다. + + 을 초기화할 때 상호 배타적인 잠금으로 사용할 개체에 대한 참조입니다.이 null이면 새 개체를 인스턴스화할 수 있습니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 지정된 함수를 사용하여 대상 참조 또는 값 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조 또는 값입니다. + 대상이 이미 초기화되었는지 여부를 결정하는 부울 값에 대한 참조입니다. + + 을 초기화할 때 상호 배타적인 잠금으로 사용할 개체에 대한 참조입니다.이 null이면 새 개체를 인스턴스화할 수 있습니다. + 참조 또는 값을 초기화하기 위해 호출되는 함수입니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 지정된 함수를 사용하여 대상 참조 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조입니다. + 참조를 초기화하기 위해 호출되는 함수입니다. + 초기화할 참조의 참조 형식입니다. + 형식 에 기본 생성자가 없는 경우 + + 가 null을 반환합니다(Visual Basic의 경우 Nothing). + + + 잠금에 대한 재귀 정책과 맞지 않는 방식으로 잠금을 재귀적으로 시작할 때 throw되는 예외입니다. + 2 + + + 오류를 설명하는 시스템 제공 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 2 + + + 오류를 설명하는 지정된 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 따라 지역화되었는지 확인해야 합니다. + 2 + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 따라 지역화되었는지 확인해야 합니다. + 현재 예외를 발생시킨 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + 2 + + + 동일한 스레드에서 잠금을 여러 번 시작할 수 있는지 여부를 지정합니다. + + + 스레드에서 잠금을 재귀적으로 시작하려고 하면 예외가 throw됩니다.이 설정을 적용하는 경우 일부 클래스에서 특정 재귀가 허용될 수도 있습니다. + + + 스레드에서 잠금을 재귀적으로 시작할 수 있습니다.일부 클래스에서는 이 기능이 제한될 수 있습니다. + + + 하나 이상의 대기 중인 스레드에 이벤트가 발생했음을 알립니다.이 클래스는 상속될 수 없습니다. + 2 + + + 초기 상태를 신호 받음으로 설정할지 여부를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + + + + 의 슬림 다운 버전을 제공합니다. + + + 신호 없음을 초기 상태로 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true이고 초기 상태를 신호 없음으로 설정하려면 false입니다. + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값과 지정된 회전 수를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true이고 초기 상태를 신호 없음으로 설정하려면 false입니다. + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수입니다. + + is less than 0 or greater than the maximum allowed value. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 이벤트가 설정되었는지를 가져옵니다. + 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + + + 스레드가 차단되도록 이벤트 상태를 신호 없음으로 설정합니다. + The object has already been disposed. + + + 이벤트에서 대기 중인 하나 이상의 스레드가 계속 진행되도록 이벤트 상태를 신호 받음으로 설정합니다. + + + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수를 가져옵니다. + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수를 반환합니다. + + + 현재 이 설정될 때까지 현재 스레드를 차단합니다. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 부호 있는 32비트 정수로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + 을 확인하면서 부호 있는 32비트 정수로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + + 을 확인하면서 현재 이 신호를 받을 때까지 현재 스레드를 차단합니다. + 확인할 입니다. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + + 으로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + 을 확인하면서 으로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 이 의 내부 개체를 가져옵니다. + 이 에 대한 내부 이벤트 개체입니다. + + + 개체에 대한 액세스를 동기화하는 메커니즘을 제공합니다. + 2 + + + 지정된 개체의 단독 잠금을 가져옵니다. + 모니터 잠금을 가져올 개체입니다. + + 매개 변수가 null인 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정합니다. + 대기할 개체입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다.예외가 발생하지 않는 경우 이 메서드의 출력은 항상 true입니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + + 지정된 개체의 단독 잠금을 해제합니다. + 잠금을 해제할 개체입니다. + + 매개 변수가 null인 경우 + 현재 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 현재 스레드에 지정된 개체에 대한 잠금이 있는지 여부를 확인합니다. + 현재 스레드에 에 대한 잠금이 있으면 true이고, 그렇지 않으면 false입니다. + 테스트할 개체입니다. + + 가 null인 경우 + + + 대기 중인 큐에 포함된 스레드에 잠겨 있는 개체의 상태 변경을 알립니다. + 스레드에서 기다리는 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 대기 중인 모든 스레드에 개체 상태 변경을 알립니다. + 펄스를 보내는 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + + 매개 변수가 null인 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + + 지정된 시간(밀리초) 동안 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + 잠금을 기다릴 밀리초 수입니다. + + 매개 변수가 null인 경우 + + 이 음수이고 와 같지 않은 경우 + 1 + + + 지정된 시간(밀리초) 동안 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 기다릴 밀리초 수입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + 이 음수이고 와 같지 않은 경우 + + + 지정된 시간 동안 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + 잠금을 기다리는 시간을 나타내는 입니다.-1밀리초 값은 무한 대기를 지정합니다. + + 매개 변수가 null인 경우 + + 값(밀리초)이 음수이고 (–1밀리초)와 같지 않거나 보다 큰 경우 + 1 + + + 지정된 시간 동안 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 대기할 시간입니다.-1밀리초 값은 무한 대기를 지정합니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + 값(밀리초)이 음수이고 (–1밀리초)와 같지 않거나 보다 큰 경우 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다. + 지정된 개체 잠금을 호출자가 다시 가져와 호출이 반환되면 true입니다.잠금을 다시 가져오지 않으면 이 메서드는 반환하지 않습니다. + 대기할 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + 1 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다.지정된 시간 제한 간격이 지나면 스레드가 준비된 큐에 들어갑니다. + 지정된 시간이 경과하기 전에 잠금을 다시 가져오면 true이고, 지정된 시간이 경과한 후에 잠금을 다시 가져오면 false입니다.이 메서드는 잠금을 다시 가져올 때까지 반환하지 않습니다. + 대기할 개체입니다. + 스레드가 준비된 큐에 들어가기 전에 대기할 밀리초 수입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + + 매개 변수의 값이 음이고 와 같지 않은 경우 + 1 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다.지정된 시간 제한 간격이 지나면 스레드가 준비된 큐에 들어갑니다. + 지정된 시간이 경과하기 전에 잠금을 다시 가져오면 true이고, 지정된 시간이 경과한 후에 잠금을 다시 가져오면 false입니다.이 메서드는 잠금을 다시 가져올 때까지 반환하지 않습니다. + 대기할 개체입니다. + 스레드가 준비된 큐에 들어가기 전에 대기할 시간을 나타내는 입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + + 매개 변수의 값(밀리초)이 음수이고 (-1밀리초)를 나타내지 않거나 보다 큰 경우 + 1 + + + 프로세스 간 동기화에 사용할 수도 있는 동기화 기본 형식입니다. + 1 + + + 기본 속성을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 호출한 스레드에 뮤텍스의 초기 소유권을 부여하면 true이고, 그렇지 않으면 false입니다. + + + 호출 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값과 뮤텍스 이름인 문자열을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 시스템 뮤텍스가 만들어지는 경우 호출한 스레드에 명명된 시스템 뮤텍스의 초기 소유권을 부여하려면 true이고, 그렇지 않으면 false입니다. + + 의 이름입니다.값이 null이면 이(가) 명명되지 않습니다. + 명명된 뮤텍스가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 260 자 보다 깁니다. + + + 호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값, 뮤텍스의 이름인 문자열 및 메서드에서 반환할 때 호출한 스레드에 뮤텍스의 초기 소유권이 부여되었는지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 시스템 뮤텍스가 만들어지는 경우 호출한 스레드에 명명된 시스템 뮤텍스의 초기 소유권을 부여하려면 true이고, 그렇지 않으면 false입니다. + + 의 이름입니다.값이 null이면 이(가) 명명되지 않습니다. + 이 메서드가 반환될 때 로컬 뮤텍스가 만들어진 경우(즉, 이(가) null이거나 빈 문자열인 경우)나 지정된 명명된 시스템 뮤텍스가 만들어진 경우에는 true인 부울이 포함되고, 지정된 명명된 시스템 뮤텍스가 이미 있는 경우에는 false이(가) 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + 명명된 뮤텍스가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 260 자 보다 깁니다. + + + 이미 있는 경우 지정한 명명된 뮤텍스를 엽니다. + 명명된 시스템 뮤텍스를 나타내는 개체입니다. + 열려는 시스템 뮤텍스의 이름입니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + 명명된 뮤텍스가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스가 있지만 사용자에게 이 뮤텍스를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + 1 + + + + + + + 을(를) 한 번 해제합니다. + 호출한 스레드가 뮤텍스를 소유하지 않은 경우 + 1 + + + 지정한 명명된 뮤텍스(이미 존재하는 경우)를 열고 작업이 수행되었는지를 나타내는 값을 반환합니다. + 명명된 뮤텍스를 열었으면 true이고, 그렇지 않으면 false입니다. + 열려는 시스템 뮤텍스의 이름입니다. + 이 메서드가 반환될 때 호출이 성공적으로 실행된 경우 이름이 지정된 뮤텍스를 나타내는 개체를 포함하고 호출에 실패한 경우는 null을(를) 포함해야 합니다.이 매개 변수는 초기화되지 않은 것으로 처리됩니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스가 있지만 사용자에게 이 뮤텍스를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + + + 여러 스레드에서 읽을 수 있도록 허용하거나 쓰기를 위한 단독 액세스를 허용하여 리소스에 대한 액세스를 관리하는 데 사용되는 잠금을 나타냅니다. + + + 기본 속성 값으로 클래스의 새 인스턴스를 초기화합니다. + + + 잠금 재귀 정책을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 잠금 재귀 정책을 지정하는 열거형 값 중 하나입니다. + + + 읽기 모드로 잠금을 시작한 고유 스레드의 총 개수를 가져옵니다. + 읽기 모드로 잠금을 시작한 고유 스레드의 총 개수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 읽기 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 쓰기 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 읽기 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 읽기 모드를 종료합니다. + The current thread has not entered the lock in read mode. + + + 업그레이드 가능 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 업그레이드 가능 모드를 종료합니다. + The current thread has not entered the lock in upgradeable mode. + + + 쓰기 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 쓰기 모드를 종료합니다. + The current thread has not entered the lock in write mode. + + + 현재 스레드에서 읽기 모드로 잠금을 시작했는지를 나타내는 값을 가져옵니다. + 현재 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 스레드에서 업그레이드 가능 모드로 잠금을 시작했는지 여부를 나타내는 값을 가져옵니다. + 현재 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 스레드에서 쓰기 모드로 잠금을 시작했는지를 나타내는 값을 가져옵니다. + 현재 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 개체에 대한 재귀 정책을 나타내는 값을 가져옵니다. + 잠금 재귀 정책을 지정하는 열거형 값 중 하나입니다. + + + 재귀를 확인하기 위해 현재 스레드에서 읽기 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 읽기 모드를 시작하지 않았으면 0이고, 스레드에서 읽기 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 잠금을 n-1회 시작했으면 n입니다. + 2 + + + 재귀를 확인하기 위해 현재 스레드에서 업그레이드 가능 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 업그레이드 가능 모드를 시작하지 않았으면 0이고, 스레드에서 업그레이드 가능 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 업그레이드 가능 모드를 n-1회 시작했으면 n입니다. + 2 + + + 재귀를 확인하기 위해 현재 스레드에서 쓰기 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 쓰기 모드를 시작하지 않았으면 0이고, 스레드에서 쓰기 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 쓰기 모드를 n-1회 시작했으면 n입니다. + 2 + + + 제한 시간(정수)을 선택적으로 적용하여 읽기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 읽기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 쓰기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 쓰기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 읽기 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 읽기 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 업그레이드 가능 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 업그레이드 가능 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 쓰기 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 쓰기 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 리소스 또는 리소스 풀에 동시에 액세스할 수 있는 스레드 수를 제한합니다. + 1 + + + 초기 항목 수 및 최대 동시 항목 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + + 가 보다 큰 경우 + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + + + 초기 항목 수 및 최대 동시 항목 수를 지정하고 선택적으로 시스템 세마포 개체의 이름을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + 명명된 시스템 세마포 개체의 이름입니다. + + 가 보다 큰 경우또는 260 자 보다 깁니다. + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 세마포를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + + 초기 항목 수 및 최대 동시 항목 수를 지정하고, 선택적으로 시스템 세마포 개체의 이름을 지정하고, 새 시스템 세마포가 만들어졌는지 여부를 나타내는 값을 받을 변수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 동시에 충족될 수 있는 세마포의 초기 요청 수입니다. + 동시에 충족될 수 있는 세마포의 최대 요청 수입니다. + 명명된 시스템 세마포 개체의 이름입니다. + 이 메서드가 반환될 때 로컬 세마포가 만들어진 경우(즉, 이 null이거나 빈 문자열인 경우) 또는 지정한 명명된 시스템 세마포가 만들어진 경우에는 true가 포함되고, 지정한 명명된 시스템 세마포가 이미 있는 경우에는 false가 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + + 가 보다 큰 경우 또는 260 자 보다 깁니다. + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 세마포를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + + 이미 있는 경우 지정한 명명된 세마포를 엽니다. + 명명된 시스템 세마포를 나타내는 개체입니다. + 열려는 시스템 세마포의 이름입니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + 명명된 세마포가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 있지만 사용자에게 이 세마포를 사용하는 데 필요한 보안 액세스가 없는 경우 + 1 + + + + + + 세마포를 종료하고 이전 카운트를 반환합니다. + + 메서드가 호출되기 전의 세마포 카운트입니다. + 세마포 카운트가 이미 최대값인 경우 + 명명된 세마포에서 Win32 오류가 발생한 경우 + 현재 세마포가 명명된 시스템 세마포를 나타내지만 사용자에게 가 없는 경우또는현재 세마포가 명명된 시스템 세마포를 나타내지만 세마포가 를 사용하여 열리지 않은 경우 + 1 + + + 지정된 횟수만큼 세마포를 종료하고 이전 카운트를 반환합니다. + + 메서드가 호출되기 전의 세마포 카운트입니다. + 세마포를 종료할 횟수입니다. + + 1 보다 작으면입니다. + 세마포 카운트가 이미 최대값인 경우 + 명명된 세마포에서 Win32 오류가 발생한 경우 + 현재 세마포가 명명된 시스템 세마포를 나타내지만 사용자에게 권한이 없는 경우또는현재 세마포가 명명된 시스템 세마포를 나타내지만 세마포가 권한을 사용하여 열리지 않은 경우 + 1 + + + 지정한 명명된 세마포(이미 존재하는 경우)를 열고 작업이 성공했는지를 나타내는 값을 반환합니다. + 명명된 세마포를 열었으면 true이고, 그 열지 않았으면 false입니다. + 열려는 시스템 세마포의 이름입니다. + 이 메서드가 반환될 때 호출에 성공한 경우에는 명명된 세마포를 나타내는 개체를 포함하고 호출에 실패한 경우에는 null을 포함합니다.이 매개 변수는 초기화되지 않은 것으로 처리됩니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 있지만 사용자에게 이 세마포를 사용하는 데 필요한 보안 액세스가 없는 경우 + + + 카운트가 이미 최대값에 도달한 세마포에서 메서드를 호출하면 throw되는 예외입니다. + 2 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 리소스 또는 리소스 풀에 동시에 액세스할 수 있는 스레드 수를 제한하는 대신 사용할 수 있는 간단한 클래스를 나타냅니다. + + + 동시에 부여할 수 있는 초기 요청 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + + 가 0보다 작은 경우 + + + 동시에 부여할 수 있는 초기 및 최대 요청 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + + 가 0보다 작거나 가 보다 크거나 가 0보다 작거나 같은 경우. + + + 세마포에서 대기하는 데 사용할 수 있는 을(를) 반환합니다. + 세마포에서 대기하는 데 사용할 수 있는 입니다. + + 가 삭제된 경우 + + + + 개체에 들어갈 수 있는 남아 있는 스레드의 수를 가져옵니다. + 세마포에 들어갈 수 있는 남아 있는 스레드의 수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + + 개체를 한 번 해제합니다. + + 의 이전 횟수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 이미 최대 크기에 도달했습니다. + + + + 개체를 지정된 횟수만큼 해제합니다. + + 의 이전 횟수입니다. + 세마포를 종료할 횟수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 1 보다 작으면입니다. + + 이 이미 최대 크기에 도달했습니다. + + + 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + 제한 시간을 지정하는 부호 있는 32비트 정수를 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을(를) 확인하면서 제한 시간을 지정하는 부호 있는 32비트 정수를 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + 인스턴스가 삭제 또는 만든 가 삭제 되었습니다. + + + + 을(를) 확인하면서 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 확인할 토큰입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우또는 만든 이미 삭제 되었습니다. + + + + (으)로 제한 시간을 지정하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + semaphoreSlim 인스턴스가 삭제되었습니다 + + + + 을(를) 확인하면서 제한 시간을 지정하는 을(를) 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + semaphoreSlim 인스턴스가 삭제되었습니다을 만든 가 이미 삭제되었습니다. + + + + (으)로 전환될 때까지 비동기적으로 기다립니다. + 세마포가 입력되었을 때 완료될 작업입니다. + + + 32비트 부호 있는 정수를 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을(를) 관찰하는 동안 32비트 부호 있는 정수를 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 현재 인스턴스가 이미 삭제된 경우 + + 이 취소되었습니다. + + + + 을(를) 관찰하는 동안 (으)로 전환될 때까지 비동기적으로 기다립니다. + 세마포가 입력되었을 때 완료될 작업입니다. + 확인할 토큰입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 취소되었습니다. + + + + 을(를) 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 또는 제한 시간이 보다 큰 경우 + + + + 을 관찰하는 동안 을(를) 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 토큰입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우또는제한 시간이 보다 큰 경우 + + 이 취소되었습니다. + + + 메시지가 동기화 컨텍스트로 디스패치될 때 호출할 메서드를 나타냅니다. + 대리자에 전달된 개체입니다. + 2 + + + 잠금을 얻으려는 스레드가 잠금을 사용할 수 있을 때까지 루프에서 반복적으로 확인하면서 대기하는 기본적인 상호 배타 잠금을 제공합니다. + + + 디버깅을 향상시키기 위해 스레드 ID를 추적하는 옵션을 사용하여 구조체의 새 인스턴스를 초기화합니다. + 디버깅 용도로 스레드 ID를 캡처하고 사용할지 여부입니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으며 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 인수는 Enter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 잠금을 해제합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이 잠금의 소유자가 아닙니다. + + + 잠금을 해제합니다. + 종료 작업을 다른 스레드에 즉시 게시하기 위해 메모리 펜스를 실행할지 여부를 나타내는 부울 값입니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이 잠금의 소유자가 아닙니다. + + + 스레드에서 현재 잠금을 보유하고 있는지 여부를 가져옵니다. + 스레드에서 현재 잠금을 보유하고 있으면 true이고, 그렇지 않으면 false입니다. + + + 현재 스레드에서 잠금을 보유하고 있는지 여부를 가져옵니다. + 현재 스레드에서 잠금을 보유하고 있으면 true이고, 그렇지 않으면 false입니다. + 스레드 소유권 추적을 사용할 수 없습니다. + + + 이 인스턴스에 대해 스레드 소유권 추적이 사용되는지 여부를 가져옵니다. + 이 인스턴스에 대해 스레드 소유권 추적이 사용되면 true이고, 그렇지 않으면 false입니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 밀리초보다 큰 경우. + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 회전 기반 대기를 지원합니다. + + + 이 인스턴스에서 가 호출된 횟수를 가져옵니다. + 이 인스턴스에서 가 호출된 횟수를 나타내는 정수를 반환합니다. + + + 다음 호출이 프로세서를 생성하여 강제 컨텍스트 전환을 트리거할지 여부를 가져옵니다. + 다음 호출이 프로세서를 생성하여 강제 컨텍스트 전환을 트리거할지 여부입니다. + + + 회전 수를 다시 설정합니다. + + + 단일 회전을 수행합니다. + + + 지정된 조건이 충족될 때까지 회전합니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + + 인수가 null인 경우 + + + 지정된 조건이 충족되거나 지정된 제한 시간이 만료될 때까지 회전합니다. + 제한 시간 내에 지정된 조건이 충족되면 true이고, 그렇지 않으면 false입니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + 인수가 null인 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + 지정된 조건이 충족되거나 지정된 제한 시간이 만료될 때까지 회전합니다. + 제한 시간 내에 지정된 조건이 충족되면 true이고, 그렇지 않으면 false입니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 TimeSpan입니다. + + 인수가 null인 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + 다양한 동기화 모델에서 동기화 컨텍스트를 전파하기 위한 기본 기능을 제공합니다. + 2 + + + + 클래스의 새 인스턴스를 만듭니다. + + + 파생 클래스에서 재정의된 경우 동기화 컨텍스트의 복사본을 만듭니다. + 새 개체입니다. + 2 + + + 현재 스레드의 동기화 컨텍스트를 가져옵니다. + 현재 동기화 컨텍스트를 나타내는 개체입니다. + 1 + + + 파생 클래스에서 재정의되면 작업이 완료되었음을 알리는 메시지에 응답합니다. + + + 파생 클래스에서 재정의되면 작업이 시작되었음을 알리는 메시지에 응답합니다. + + + 파생 클래스에서 재정의될 때 비동기 메시지를 동기화 컨텍스트로 디스패치합니다. + 호출할 대리자입니다. + 대리자에 전달된 개체입니다. + 2 + + + 파생 클래스에서 재정의될 때 동기 메시지를 동기화 컨텍스트로 디스패치합니다. + 호출할 대리자입니다. + 대리자에 전달된 개체입니다. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 현재 동기화 컨텍스트를 설정합니다. + 설정할 개체입니다. + 1 + + + + + + 메서드가 지정된 Monitor에 대해 잠금을 소유하도록 호출자에게 요구하지만 해당 잠금을 소유하지 않는 호출자가 해당 메서드를 호출할 때 throw되는 예외입니다. + 2 + + + 기본 속성을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 데이터의 스레드 로컬 저장소를 제공합니다. + 스레드별로 저장되는 데이터의 형식을 지정합니다. + + + + 인스턴스를 초기화합니다. + + + + 인스턴스를 초기화합니다. + 인스턴스에 설정된 모든 값을 추적하고 해당 값을 속성을 통해 노출할지 여부 + + + 지정된 함수를 사용하여 의 인스턴스를 초기화합니다. + + 를 이전에 초기화하지 않고 검색하려고 하는 경우 lazily-initialized 값을 생성하기 위해 호출되는 입니다. + + 는 null 참조(Visual Basic의 경우 Nothing)입니다. + + + 지정된 함수를 사용하여 의 인스턴스를 초기화합니다. + + 를 이전에 초기화하지 않고 검색하려고 하는 경우 lazily-initialized 값을 생성하기 위해 호출되는 입니다. + 인스턴스에 설정된 모든 값을 추적하고 해당 값을 속성을 통해 노출할지 여부 + + 이 null 참조(Visual Basic의 경우 Nothing)인 경우 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + 이 인스턴스에서 사용하는 리소스를 해제합니다. + + 호출로 인해 이 메서드가 호출되는지 여부를 나타내는 부울 값입니다. + + + 이 인스턴스에서 사용하는 리소스를 해제합니다. + + + + 가 현재 스레드에서 초기화되었는지 여부를 가져옵니다. + 현재 스레드에서 가 초기화되었으면 true이고, 그렇지 않으면 false입니다. + + 인스턴스가 삭제된 경우 + + + 현재 스레드에 대한 이 인스턴스의 문자열 표현을 만들고 반환합니다. + + 에서 을 호출한 결과입니다. + + 인스턴스가 삭제된 경우 + 현재 스레드의 는 null 참조입니다(Visual Basic에서는 Nothing). + 초기화 함수는 를 재귀적으로 참조하려고 했습니다. + 기본 생성자가 제공되지 않으며 값 팩터리가 제공되지 않습니다. + + + 현재 인스턴스에 대한 이 인스턴스의 값을 가져오거나 설정합니다. + 이 ThreadLocal이 초기화를 담당하는 개체의 인스턴스를 반환합니다. + + 인스턴스가 삭제된 경우 + 초기화 함수는 를 재귀적으로 참조하려고 했습니다. + 기본 생성자가 제공되지 않으며 값 팩터리가 제공되지 않습니다. + + + 이 인스턴스에 액세스한 모든 스레드가 현재 저장한 모든 값의 목록을 가져옵니다. + 이 인스턴스에 액세스한 모든 스레드가 현재 저장한 모든 값의 목록입니다. + + 인스턴스가 삭제된 경우 + + + 휘발성 메모리 작업을 수행하기 위한 메서드가 포함되어 있습니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드에서 개체 참조를 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 에 대한 참조입니다.이 참조는 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + 읽을 필드의 형식입니다.이 형식은 값 형식이 아니라 참조 형식이어야 합니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 메모리 작업이 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 메모리 작업을 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 개체 참조를 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 개체 참조를 쓴 필드입니다. + 쓸 개체 참조입니다.컴퓨터의 모든 프로세서에서 참조를 볼 수 있도록 참조를 즉시 씁니다. + 쓸 필드의 형식입니다.이 형식은 값 형식이 아니라 참조 형식이어야 합니다. + + + 존재하지 않는 시스템 뮤텍스 또는 세마포를 열려고 시도할 때 throw되는 예외입니다. + 2 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/ru/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/ru/System.Threading.xml new file mode 100644 index 000000000..6ca30336b --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/ru/System.Threading.xml @@ -0,0 +1,1761 @@ + + + + System.Threading + + + + Исключение вызывается, когда некоторый поток получает объект , брошенный другим потоком путем выхода без высвобождения. + 1 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса , используя конкретиый индекс брошенного мьютекса, (если применимо), а также объект , представляющий мьютекс. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причины исключения. + + + Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и внутренним исключением. + Сообщение об ошибке с объяснением причины исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение вызывается в блоке catch, обрабатывающем внутреннее исключение. + + + Инициализирует новый экземпляр класса , используя указанное сообщения об ошибке, внутреннее исключение, индекс брошенного мьютекса (если применимо), а также объект , представляющего мьютекс. + Сообщение об ошибке с объяснением причины исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение вызывается в блоке catch, обрабатывающем внутреннее исключение. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Инициализирует новый экземпляр класса указанным сообщением об ошибке, индексом брошенного мьютекса (если применимо), а также брошенным мьютексом. + Сообщение об ошибке с объяснением причины исключения. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Получает брошенный мьютекс, вызвавший исключение (если он известен). + Объект , представляющий брошенный мьютекс, или null, если брошенный мьютекс не может быть идентифицирован. + 1 + + + Получает индекс брошенного мьютекса, вызвавшего исключение (если он известен). + Индекс в массиве дескрипторов ожидания, передаваемый в метод , объекта , представляющего брошенный мьютекс, или же -1, если индекс брошенного мьютекса невозможно определить. + 1 + + + Представляет внешние данные, локальные для данного асинхронного потока управления, такие как асинхронный метод. + Тип внешних данных. + + + Создает экземпляр экземпляра , который не получает уведомления об изменениях. + + + Создает экземпляр локального экземпляра , который получает уведомления об изменениях. + Делегат, который вызывается при каждом изменении текущего значения в любом потоке. + + + Получает или задает значение внешних данных. + Значение внешних данных. + + + Класс, предоставляющий сведения об изменениях данных экземплярам , которые зарегистрированы для получения уведомлений об изменениях. + Тип данных. + + + Получает текущее значение данных. + Текущее значение данных. + + + Получает предыдущее значение данных. + Предыдущее значение данных. + + + Возвращает значение, указывающее, изменяется ли значение из-за изменения контекста выполнения. + Значение true, если значение изменено из-за изменения контекста выполнения; в противном случае — значение false. + + + Уведомляет ожидающий поток о том, что произошло событие.Этот класс не наследуется. + 2 + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение. + + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + + + Позволяет нескольким задачам параллельно работать с алгоритмом, используя несколько фаз. + + + Инициализирует новый экземпляр класса . + Количество участвующих потоков. + + меньше 0 или больше 32,767. + + + Инициализирует новый экземпляр класса . + Количество участвующих потоков. + + для исполнения после каждой фазы. Значение null (Nothing in Visual Basic) может быть передано, чтобы указать, что действия не предпринимаются. + + меньше 0 или больше 32,767. + + + Уведомляет о добавлении дополнительного участника. + Номер фазы барьера, в которой сначала участвуют новые участники. + Текущий экземпляр уже был удален. + Добавление участника приведет к превышению 32 767 счетчиком участников барьера.– или –Метод был вызван из действия после этапа. + + + Уведомляет барьер о добавлении дополнительных участников. + Номер фазы барьера, в которой сначала участвуют новые участники. + Число дополнительных участников, которых необходимо добавить в барьер. + Текущий экземпляр уже был удален. + Значение параметра меньше 0.– или –Добавление участников приведет к превышению 32 767 счетчиком участников барьера. + Метод был вызван из действия после этапа. + + + Получает номер текущей фазы барьера. + Возвращает номер текущего этапа барьера. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + Метод был вызван из действия после этапа. + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает общее количество участников в барьере. + Возвращает общее количество участников в барьере. + + + Получает количество участников в барьере, которые еще не создали сигнал в текущей фазе. + Возвращает количество участников в барьере, которые еще не создали сигнал на текущем этапе. + + + Уведомляет о удалении одного участника. + Текущий экземпляр уже был удален. + Барьер уже содержит 0 участников.– или –Метод был вызван из действия после этапа. + + + Уведомляет барьер об удалении нескольких участников. + Число дополнительных участников, которых необходимо удалить из барьера. + Текущий экземпляр уже был удален. + Значение параметра меньше 0. + Барьер уже содержит 0 участников.– или –Метод был вызван из действия после этапа. – или –текущее количество участников меньше указанного participantCount + Общее число участников меньше указанного + + + Сообщает, что участник достиг барьера и ожидает достижения барьера другими участниками. + Текущий экземпляр уже был удален. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + Если создается исключение из действия следующего этапа барьера после того, как все участвующие потоки вызвали SignalAndWait, исключение будет вставлено в BarrierPostPhaseException и создано для всех участвующих потоков. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя 32-разрядное знаковое целое число для измерения времени ожидания. + Значение true, если все участники достигли барьера за указанное время; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + Если создается исключение из действия следующего этапа барьера после того, как все участвующие потоки вызвали SignalAndWait, исключение будет вставлено в BarrierPostPhaseException и создано для всех участвующих потоков. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя 32-разрядное знаковое целое число для измерения времени ожидания. Кроме того, метод контролирует токен отмены. + Значение true, если все участники достигли барьера за указанное время; в противном случае — значение false + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками. Кроме того, метод контролирует токен отмены. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя объект для измерения интервала времени. + Значение true, если все остальные участники достигли барьера; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + + является отрицательным числом, отличным от значения -1 миллисекунды, которое представляет неограниченное время ожидания, или превышает 32767. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя объект для измерения интервала времени. Кроме того, метод контролирует токен отмены. + Значение true, если все остальные участники достигли барьера; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + + является отрицательным числом, отличным от значения -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Исключение, которое возникает при сбое действия барьера , выполняемого в конце фазы + + + Инициализирует новый экземпляр класса системным сообщением, содержащим описание ошибки. + + + Инициализирует новый экземпляр класса с указанным внутренним исключением. + Исключение, которое вызвало текущее исключение. + + + Инициализирует новый экземпляр класса с использованием заданного сообщения, содержащего описание ошибки. + Сообщение с описанием исключения.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение с описанием исключения.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Представляет метод, вызываемый в новом контексте. + Объект, содержащий информацию, используемую всякий раз методом обратного вызова при каждом выполнении. + 1 + + + Представляет примитив синхронизации, на который отправляется сигнал при достижении его подсчетом нуля. + + + Инициализирует новый экземпляр класса указанным количеством. + Количество сигналов, первоначально необходимое для задания объекта . + Значение параметра меньше 0. + + + Увеличивает текущий подсчет на один. + Текущий экземпляр уже был удален. + Текущий экземпляр уже задан.– или –Значение параметра больше или равно значению свойства . + + + Увеличивает текущее количество в объекте на указанное значение. + Значение, на которое нужно увеличить . + Текущий экземпляр уже был удален. + Значение меньше или равно 0. + Текущий экземпляр уже задан.– или – равно или больше после увеличения счета параметром + + + Получает количество сигналов, оставшееся до установки события. + Количество сигналов, оставшееся до установки события. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает количество сигналов, изначально нужное для установки события. + Количество сигналов, изначально нужное для установки события. + + + Определяет, установлено ли событие. + Значение true, если событие установлено; в противном случае — значение false. + + + Сбрасывает свойство на значение свойства . + Текущий экземпляр уже был удален. + + + Присваивает свойству заданное значение. + Количество сигналов, необходимое для установки объекта . + Текущий экземпляр уже был удален. + Значение параметра меньше 0. + + + Регистрирует сигнал с событием , уменьшая значение свойства . + Значение true, если после сигнала подсчет стал равен нулю и было создано событие; в противном случае — значение false. + Текущий экземпляр уже был удален. + Текущий экземпляр уже задан. + + + Регистрирует несколько сигналов с объектом , уменьшая значение свойства на указанное число. + Значение true, если после сигналов подсчет стал равен нулю и было создано событие; в противном случае — значение false. + Количество сигналов, которое необходимо зарегистрировать. + Текущий экземпляр уже был удален. + Значение параметра меньше 1. + Текущий экземпляр уже задан. - или- Или значение больше . + + + Попытка увеличить на единицу. + Значение true, если увеличение выполнено успешно; в противном случае — значение false.Если значение свойства уже равно нулю, метод возвращает значение false. + Текущий экземпляр уже был удален. + + равно . + + + Пытается увеличить на указанное значение. + Значение true, если увеличение выполнено успешно; в противном случае — значение false.Если значение свойства уже равно нулю, возвращается значение false. + Значение, на которое нужно увеличить . + Текущий экземпляр уже был удален. + Значение меньше или равно 0. + Текущий экземпляр уже задан.– или –Значение свойства + больше или равно значению свойства . + + + Блокирует текущий поток до установки . + Текущий экземпляр уже был удален. + + + Блокирует текущий поток до тех пор, пока не установлен объект , используя 32-разрядное знаковое целое число для измерения времени ожидания. + Значение true, если установлено событие ; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток до тех пор, пока не будет установлен объект , используя 32-разрядное знаковое целое число для измерения времени ожидания. Кроме того, метод контролирует токен . + Значение true, если установлено событие ; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток, пока не будет установлено , в то же время контролируя . + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + + + Блокирует текущий поток до тех пор, пока не будет установлен объект , используя значение для измерения времени ожидания. + Значение true, если установлено событие ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Блокирует текущий поток, пока не будет установлен объект , используя значение для измерения времени ожидания. Кроме того, метод контролирует токен . + Значение true, если установлено событие ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Получает дескриптор , используемый для ожидания установки события. + Дескриптор , используемый для ожидания установки события. + Текущий экземпляр уже был удален. + + + Указывает, сбрасывается ли автоматически или вручную после получения сигнала. + 2 + + + При получении сигнала сбрасывается автоматически после освобождения одиночного потока.При отсутствии ожидающих потоков остается сигнальным до тех пор, пока поток не блокируется и не сбрасывается после освобождения потока. + + + При получении сигнала, высвобождает все ожидающие потоки и остается сигнальным до тех пор, пока не сбрасывается вручную. + + + Представляет синхронизированное событие потока. + 2 + + + Выполняет инициализацию нового экземпляра класса , определяя, получает ли сигнал, ожидающий дескриптор, и производится ли сброс автоматически или вручную. + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + + + Выполняет инициализацию нового экземпляра класса , определяющего получает ли сигнал дескриптор ожидания, если он был создан в результате данного вызова, сбрасывается ли он автоматически или вручную, а также имя системного события синхронизации. + true, чтобы задать сигнальное начальное состояние, если создано названное событие в результате этого вызова; false, чтобы задать несигнальное начальное состояние. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + Имя общесистемного события синхронизации. + Произошла ошибка Win32. + Именованное событие существует, имеет настройки управления доступом, а пользователь не имеет прав . + Именованное событие не может быть создано, видимо потому что дескриптор ожидания другого типа имеет то же имя. + Длина параметра превышает 260 символов. + + + Выполняет инициализацию нового экземпляра класса , определяющего, является ли дескриптор ожидания изначально сигнальным, если он был создан в результате данного вызова, происходит ли сброс автоматически или вручную, имя системного события синхронизации и логическую переменную, значение которой показывает, было ли создано системное именованное событие. + true, чтобы задать сигнальное начальное состояние, если создано названное событие в результате этого вызова; false, чтобы задать несигнальное начальное состояние. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + Имя общесистемного события синхронизации. + Когда данный метод возвращает значение, он содержит true, если было создано локальное событие (то есть, если имеет значение null или пустую строку) или было создано системное событие с заданным именем; либо значение false, если указанное именованное событие уже существовало.Этот параметр передается без инициализации. + Произошла ошибка Win32. + Именованное событие существует, имеет настройки управления доступом, а пользователь не имеет прав . + Именованное событие не может быть создано, видимо потому что дескриптор ожидания другого типа имеет то же имя. + Длина параметра превышает 260 символов. + + + Открывает указанное именованное событие синхронизации, если оно уже существует. + Объект, представляющий именованное системное событие. + Имя системного события синхронизации для открытия. + Параметр содержит пустую строку. -или-Длина параметра превышает 260 символов. + Параметр имеет значение null. + Именованное системное событие не существует. + Произошла ошибка Win32. + Именованное событие существует, но у пользователя нет необходимых для его использования прав доступа. + 1 + + + + + + Задает несигнальное состояние события, вызывая блокирование потоков. + true, если операция прошла успешно; в противном случае — false. + Для данного объекта ранее вызывался метод . + 2 + + + Задает сигнальное состояние события, позволяя одному или нескольким ожидающим потокам продолжить. + true, если операция прошла успешно; в противном случае — false. + Для данного объекта ранее вызывался метод . + 2 + + + Открывает указанное именованное событие синхронизации, если оно уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованное событие синхронизации было успешно открыто; в противном случае — значение false. + Имя системного события синхронизации для открытия. + Когда выполнение этого метода завершается, содержит объект , представляющий именованное событие синхронизации, если вызов завершился успешно, или значение null, если вызов завершился ошибкой.Этот параметр обрабатывается как неинициализированный. + Параметр содержит пустую строку.-или-Длина параметра превышает 260 символов. + Параметр имеет значение null. + Произошла ошибка Win32. + Именованное событие существует, но у пользователя нет требуемых прав доступа. + + + Управляет контекстом выполнения текущего потока.Этот класс не наследуется. + 2 + + + Перехватывает контекст выполнения из текущего потока. + Объект , представляющий контекст выполнения хоста для текущего потока. + 1 + + + Выполняет метод в указанном контексте выполнения в текущем потоке. + Задаваемый . + Делегат , представляющий выполняемый метод в предоставленном контексте выполнения. + Данный объект передается в метод обратного вызова. + Параметр имеет значение null.– или – не был получен во время операции отслеживания. – или – уже использовался в качестве аргумента в вызове . + 1 + + + + + + Предоставляет атомарные операции для переменных, используемых совместно несколькими потоками. + 2 + + + Добавляет два 32-разрядных целых числа и заменяет первое число на сумму в виде атомарной операции. + Новое значение сохраняется в . + Переменная, содержащая первое добавляемое значение.Сумма двух значений сохраняется в . + Значение, добавляемое к целому в . + The address of is a null pointer. + 1 + + + Добавляет два 64-разрядных целых числа и заменяет первое число на сумму в виде атомарной операции. + Новое значение сохраняется в . + Переменная, содержащая первое добавляемое значение.Сумма двух значений сохраняется в . + Значение, добавляемое к целому в . + The address of is a null pointer. + 1 + + + Сравнивает два числа с плавающей запятой двойной точности на равенство и, если они равны, заменяет первое значение. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два 32-разрядных целых числа со знаком на равенство и, если они равны, заменяет первое. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два 64-разрядных целых числа со знаком на равенство и, если они равны, заменяет первое. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два зависящих от платформы обработчика или указателя на равенство и, если они равны, заменяет первое из значений. + Исходное значение в . + Целевое значение , которое будет сравниваться со значением параметра и, возможно, будет заменено . + Значение , которое заменит целевое значение, если результатом сравнения будет равенство. + Значение , которое сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два объекта на равенство ссылок и, если они равны, заменяет первый объект. + Исходное значение в . + Целевой объект, который будет сравниваться со значением параметра и, возможно, будет заменен. + Объект, который заменит целевой объект, если результатом сравнения будет равенство. + Объект, который сравнивается с объектом в . + The address of is a null pointer. + 1 + + + Сравнивает два числа с плавающей запятой с обычной точностью на равенство и, если они равны, заменяет первое значение. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два экземпляра указанного ссылочного типа на равенство и, если это так, заменяет первый из них. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено.Это ссылочный параметр (ref в C#, ByRef в Visual Basic). + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + Тип, используемый для , и .Этот тип должен быть ссылочным типом. + The address of is a null pointer. + + + Уменьшает значение заданной переменной и сохраняет результат в виде атомарной операции. + Уменьшаемое значение. + Переменная, у которой уменьшается значение. + The address of is a null pointer. + 1 + + + Уменьшает значение заданной переменной и сохраняет результат в виде атомарной операции. + Уменьшаемое значение. + Переменная, у которой уменьшается значение. + The address of is a null pointer. + 1 + + + Задает число с плавающей запятой с двойной точностью указанным значением в виде атомарной операции и возвращает исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Присваивает 32-разрядному целому числу со знаком заданное значение и возвращает исходное значение в виде атомарной операции. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Присваивает 64-разрядному целому числу со знаком заданное значение и возвращает исходное значение в виде атомарной операции. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает указатель или обработчик, зависящий от платформы в виде атомарной операции, и возвращает ссылку на исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает объект указанным значением в виде атомарной операции и возвращает ссылку на исходный объект. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает число с плавающей запятой с одинарной точностью указанным значением в виде атомарной операции и возвращает исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает определенное значение для переменной указанного типа и возвращает исходное значение (атомарная операция). + Исходное значение параметра . + Переменная, которая задается указанным значением.Это ссылочный параметр (ref в C#, ByRef в Visual Basic). + Значение, в которое задан параметр . + Тип, используемый для и .Этот тип должен быть ссылочным типом. + The address of is a null pointer. + + + Увеличивает значение заданной переменной и сохраняет результат в виде атомарной операции. + Увеличиваемое значение. + Переменная, у которой увеличивается значение. + The address of is a null pointer. + 1 + + + Увеличивает значение заданной переменной и сохраняет результат в виде атомарной операции. + Увеличиваемое значение. + Переменная, у которой увеличивается значение. + The address of is a null pointer. + 1 + + + Синхронизирует доступ к памяти следующим образом: процессор, выполняющий текущий поток, не способен упорядочить инструкции так, чтобы обращения к памяти до вызова метода выполнялись после обращений к памяти, следующих за вызовом метода . + + + Возвращает 64-разрядное значение, загруженное в виде атомарной операции. + Загруженное значение. + Загружаемое 64-разрядное значение. + 1 + + + Обеспечивает процедуры неактивной инициализации. + + + Инициализирует целевой ссылочный тип его конструктором типа по умолчанию, если он еще не инициализирован. + Инициализируемая ссылка типа . + Ссылка типа , которую необходимо инициализировать, если она еще не инициализирована. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип или тип значения его конструктором по умолчанию, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка или значение типа , которое необходимо инициализировать, если оно еще не инициализировано. + Ссылка на логическое значение, определяющее, инициализирована ли цель. + Ссылка на объект, используемый как взаимоисключающая блокировка для инициализации параметра .Если равно null, то нового объект будет создан экземпляр. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип или тип значения с использованием указанной функцией, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка или значение типа , которое необходимо инициализировать, если оно еще не инициализировано. + Ссылка на логическое значение, определяющее, инициализирована ли цель. + Ссылка на объект, используемый как взаимоисключающая блокировка для инициализации параметра .Если равно null, то нового объект будет создан экземпляр. + Функция, которая вызывается для инициализации ссылки или значения. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип с использованием указанной функцией, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка типа , которую необходимо инициализировать, если она еще не инициализирована. + Функция, которая вызывается для инициализации ссылки. + Ссылочный тип инициализируемой ссылки. + Тип не имеет конструктора по умолчанию. + + вернул значение NULL (Nothing в Visual Basic). + + + Исключение генерируется, когда рекурсивная запись блокировки не совпадает с рекурсивной политикой блокировки. + 2 + + + Инициализирует новый экземпляр класса системным сообщением, содержащим описание ошибки. + 2 + + + Инициализирует новый экземпляр класса с использованием заданного сообщения, содержащего описание ошибки. + Сообщение с описанием исключения.Вызывающему объекту этого конструктора необходимо убедиться, что эта строка локализована для текущего языка и региональных параметров системы. + 2 + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение с описанием исключения.Вызывающему объекту этого конструктора необходимо убедиться, что эта строка локализована для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + 2 + + + Указывает, можно ли несколько раз войти в блокировку из одного и того же потока. + + + Если поток пытается войти в блокировку рекурсивно, выдается ошибка.Некоторые классы могут допускать определенные виды рекурсий при активированном параметре. + + + Допускается рекурсивный вход потока в блокировку.Некоторые классы могут игнорировать эту возможность. + + + Уведомляет один или более ожидающих потоков о том, что произошло событие.Этот класс не наследуется. + 2 + + + Инициализирует новый экземпляр класса логическим значением, показывающим наличие сигнального состояния. + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + + + Предоставляет уменьшенную версию . + + + Инициализирует новый экземпляр класса начальным состоянием nonsignaled. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение. + значение true для задания начального сигнального состояния; значение false для задания начального несигнального состояния. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение, а также указанным числом прокруток. + Значение true для задания начального сигнального состояния; значение false для задания начального несигнального состояния. + Число ожиданий прокруток до возврата к операции ожидания на основе ядра. + + is less than 0 or greater than the maximum allowed value. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает значение, указывающее, установлено ли событие. + Значение true, если событие установлено; в противном случае — значение false. + + + Задает несигнальное состояние события, вызывая блокирование потоков. + The object has already been disposed. + + + Устанавливает несигнальное состояние события, позволяя продолжить выполнение одному или нескольким потокам, ожидающим событие. + + + Получает число ожиданий прокруток, которые произойдут до возврата к операции ожидания на основе ядра. + Возвращает число ожиданий прокруток, которые произойдут до возврата к операции ожидания на основе ядра. + + + Блокирует текущий поток до установки текущего объекта . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не установлен текущий объект , используя 32-разрядное знаковое целое число для измерения интервала времени. + Значение true, если выполнялась установка ; в противном случае — false. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не будет установлен текущий объект , используя 32-разрядное знаковое целое число для измерения интервала времени. Кроме того, метод контролирует токен . + Значение true, если выполнялась установка ; в противном случае — значение false. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Блокирует текущий поток до получения сигнала текущим объектом . Кроме того, метод контролирует токен . + Токен отмены , который следует контролировать. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Блокирует текущий поток, пока не будет установлен текущий объект , используя объект для измерения интервала времени. + Значение true, если выполнялась установка ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не будет установлен текущий объект , используя значение для измерения интервала времени. Кроме того, метод контролирует токен . + Значение true, если был задан; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Возвращает базовый объект для данного . + Базовый объект события для данного объекта . + + + Предоставляет механизм для синхронизации доступа к объектам. + 2 + + + Получает эксклюзивную блокировку указанного объекта. + Объект, для которого получается блокировка монитора. + Параметр имеет значение null. + 1 + + + Получает монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, в котором следует ожидать. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение.Примечание. Если исключение не возникает, выходное значение этого метода всегда true. + Входное значение параметра — true. + Параметр имеет значение null. + + + Освобождает эксклюзивную блокировку указанного объекта. + Объект, блокировка которого освобождается. + Параметр имеет значение null. + Данный поток не владеет блокировкой для указанного объекта. + 1 + + + Определяет, содержит ли текущий поток блокировку указанного объекта. + Значение true, если текущий поток владеет блокировкой в ; в противном случае — значение false. + Объект для тестирования. + Свойство имеет значение null. + + + Уведомляет поток в очереди готовности об изменении состояния объекта с блокировкой. + Объект, ожидаемый потоком. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + 1 + + + Уведомляет все ожидающие потоки об изменении состояния объекта. + Объект, посылающий импульс. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + 1 + + + Пытается получить эксклюзивную блокировку указанного объекта. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Параметр имеет значение null. + 1 + + + Пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + + + Пытается получить эксклюзивную блокировку указанного объекта на заданное количество миллисекунд. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Количество миллисекунд, в течение которых ожидать блокировку. + Параметр имеет значение null. + Значение параметра отрицательно и не равно . + 1 + + + В течение заданного количества миллисекунд пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Количество миллисекунд, в течение которых ожидать блокировку. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + Значение параметра отрицательно и не равно . + + + Пытается получить эксклюзивную блокировку указанного объекта в течение заданного количества времени. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Класс , представляющий количество времени, в течение которого ожидается блокировка.Значение –1 миллисекунды обозначает бесконечное ожидание. + Параметр имеет значение null. + Значение в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + 1 + + + В течение заданного периода времени пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Период времени, в течение которого ожидается блокировка.Значение -1 обозначает бесконечное ожидание. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + Значение в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова. + true, если вызов осуществил возврат из-за того, что вызывающий поток заново получил блокировку заданного объекта.Этот метод не осуществляет возврат, если блокировка вновь не получена. + Объект, в котором следует ожидать. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + 1 + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова.Если указанные временные интервалы истекают, поток встает в очередь готовности. + Значение true, если блокировка была получена заново до истечения заданного времени; значение false, если блокировка была получена заново по истечении заданного времени.Этот метод не осуществляет возврат, если блокировка не была получена. + Объект, в котором следует ожидать. + Количество миллисекунд для ожидания постановки в очередь готовности. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + Значение параметра отрицательно и не равно . + 1 + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова.Если указанные временные интервалы истекают, поток встает в очередь готовности. + Значение true, если блокировка была получена заново до истечения заданного времени; значение false, если блокировка была получена заново по истечении заданного времени.Этот метод не осуществляет возврат, если блокировка не была получена. + Объект, в котором следует ожидать. + Класс , представляющий количество времени, до истечения которого поток поступает в очередь ожидания. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + Значение параметра в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + 1 + + + Примитив синхронизации, который также может использоваться в межпроцессной синхронизации. + 1 + + + Инициализирует новый экземпляр класса стандартными свойствами. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса. + Значение true для предоставления вызывающему потоку изначального владения мьютексом; в противном случае — false. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, а также иметь строку, являющуюся именем мьютекса. + Значение true для предоставления вызывающему потоку изначального владения именованным системным мьютексом, если этот мьютекс создан данным вызовом; в противном случае — значение false. + Имя .Если значение равно null, у объекта нет имени. + Именованный мьютекс существует, имеет безопасность управления доступом, а пользователь не имеет прав . + Произошла ошибка Win32. + Именованный мьютекс не может быть создан; вероятно, дескриптор ожидания другого типа имеет то же имя. + + длиннее 260 символов. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, иметь строку, являющуюся именем мьютекса, и логическое значение, которое при возврате метода показывает, предоставлено ли вызывающему потоку изначальное владение мьютексом. + Значение true для предоставления вызывающему потоку изначального владения именованным системным мьютексом, если этот мьютекс создан данным вызовом; в противном случае — значение false. + Имя .Если значение равно null, у объекта нет имени. + При возврате из метода содержит логическое значение true, если был создан локальный мьютекс (то есть, если параметр имеет значение null или содержит пустую строку) или был создан именованный системный мьютекс; значение false, если указанный именованный системный мьютекс уже существует.Этот параметр передается неинициализированным. + Именованный мьютекс существует, имеет безопасность управления доступом, а пользователь не имеет прав . + Произошла ошибка Win32. + Именованный мьютекс не может быть создан; вероятно, дескриптор ожидания другого типа имеет то же имя. + + длиннее 260 символов. + + + Открывает указанный именованный мьютекс, если он уже существует. + Объект, представляющий именованный системный мьютекс. + Имя системного мьютекса для открытия. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Именованный мьютекс не существует. + Произошла ошибка Win32. + Именованный мьютекс существует, но у пользователя нет необходимой для его использования безопасности доступа. + 1 + + + + + + Освобождает объект один раз. + Вызывающий поток не является владельцем мьютекса. + 1 + + + Открывает указанный именованный мьютекс, если он уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованный мьютекс был успешно открыт; в противном случае — значение false. + Имя системного мьютекса для открытия. + Когда выполнение этого метода завершается, содержит объект , представляющий именованный мьютекс, если вызов завершился успешно, или значение null, если произошел сбой вызова.Этот параметр обрабатывается как неинициализированный. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Произошла ошибка Win32. + Именованный мьютекс существует, но у пользователя нет необходимой для его использования безопасности доступа. + + + Представляет блокировку, используемую для управления доступом к ресурсу, которая позволяет нескольким потокам производить считывание или получать монопольный доступ на запись. + + + Инициализирует новый экземпляр класса значениями свойств по умолчанию. + + + Инициализирует новый экземпляр класса с указанием политики рекурсии блокировок. + Одно из значений перечисления, определяющее политику рекурсии блокировки. + + + Получает общее количество уникальных потоков, вошедших в блокировку в режиме чтения. + Количество уникальных потоков, вошедших в блокировку в режиме чтения. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Пытается выполнить вход в блокировку в режиме чтения. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Пытается выполнить вход в блокировку в обновляемом режиме. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Пытается выполнить вход в блокировку в режиме записи. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Уменьшает счетчик глубины рекурсии для режима чтения и выходит из режима чтения, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in read mode. + + + Уменьшает счетчик глубины рекурсии для обновляемого режима и выходит из обновляемого режима, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in upgradeable mode. + + + Уменьшает счетчик глубины рекурсии для режима записи и выходит из режима записи, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in write mode. + + + Получает значение, указывающее, вошел ли текущий поток в блокировку в режиме чтения. + Значение true, если текущий поток вошел в режим чтения; в противном случае false. + 2 + + + Возвращает значение, указывающее, вошел ли текущий поток в блокировку в обновляемом режиме. + Значение true, если текущий поток вошел в обновляемый режим; в противном случае false. + 2 + + + Получает значение, указывающее, вошел ли текущий поток в блокировку в режиме записи. + Значение true, если текущий поток вошел в режим записи; в противном случае false. + 2 + + + Возвращает значение, указывающее политику рекурсии для текущего объекта . + Одно из значений перечисления, определяющее политику рекурсии блокировки. + + + Получает количество раз, которые текущий поток входил в блокировку в режиме чтения, как показатель рекурсии. + 0 (нуль), если текущий поток не вошел в режим чтения, 1, если поток вошел в режим чтения, но не рекурсивно, или n, если поток вошел в блокировку рекурсивно n - 1 раз. + 2 + + + Получает количество раз, которые текущий поток входил в блокировку в обновляемом режиме, как показатель рекурсии. + 0 (нуль), если текущий поток не вошел в обновляемый режим, 1, если поток вошел в обновляемый режим, но не рекурсивно, или n, если поток вошел в обновляемый режим рекурсивно n - 1 раз. + 2 + + + Получает количество раз, которые текущий поток входил в блокировку в режиме записи, как показатель рекурсии. + 0 (нуль), если текущий поток, не вошел в режим записи, 1, если поток вошел в режим записи, но не рекурсивно, или n, если поток вошел в режим записи рекурсивно n - 1 раз. + 2 + + + Пытается войти в блокировку в режиме чтения с необязательным указанием времени ожидания целым числом. + Значение true, если вызывающий поток вошел в режим чтения; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в режиме чтения с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим чтения; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Пытается войти в блокировку в обновляемом режиме с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в обновляемый режим; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в обновляемом режиме с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в обновляемый режим; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Пытается войти в блокировку в режиме записи с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим записи; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в режиме записи с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим записи; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Получает общее количество потоков, ожидающих вхождения в блокировку в режиме чтения. + Общее количество потоков, ожидающих вхождения в режим чтения. + 2 + + + Получает общее количество потоков, ожидающих входа в блокировку в обновляемом режиме. + Общее количество потоков, ожидающих входа в обновляемый режим. + 2 + + + Получает общее количество потоков, ожидающих входа в блокировку в режиме записи. + Общее количество потоков, ожидающих входа в режим записи. + 2 + + + Ограничивает число потоков, которые могут одновременно получать доступ к ресурсу или пулу ресурсов. + 1 + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + Значение больше значения . + + имеет значение меньше 1.-или-Значение параметра меньше 0. + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов, а также при необходимости имя объекта системного семафора. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + Имя объекта именованного системного семафора. + Значение больше значения .-или- длиннее 260 символов. + + имеет значение меньше 1.-или-Значение параметра меньше 0. + Произошла ошибка Win32. + Именованный семафор существует, имеет параметры безопасности управления доступом, а пользователь не имеет прав . + Именованный семафор не может быть создан, видимо потому что дескриптор ожидания другого типа имеет то же имя. + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов, а также при необходимости задающий имя объекта системного семафора и переменную, получающую значение, которое указывает, был ли создан новый системный семафор. + Начальное количество запросов семафора, которое может быть удовлетворено одновременно. + Максимальное количество запросов семафора, которое может быть удовлетворено одновременно. + Имя объекта именованного системного семафора. + При возврате этот метод содержит значение true, если был создан локальный семафор (то есть если параметр имеет значение null или содержит пустую строку) или был создан заданный именованный системный семафор; значение false, если указанный именованный семафор уже существовал.Этот параметр передается неинициализированным. + Значение больше значения . -или- длиннее 260 символов. + + имеет значение меньше 1.-или-Значение параметра меньше 0. + Произошла ошибка Win32. + Именованный семафор существует, имеет параметры безопасности управления доступом, а пользователь не имеет прав . + Именованный семафор не может быть создан, видимо потому что дескриптор ожидания другого типа имеет то же имя. + + + Открывает указанный именованный семафор, если он уже существует. + Объект, представляющий именованный системный семафор. + Имя системного семафора для открытия. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Именованный семафор не существует. + Произошла ошибка Win32. + Именованный семафор существует, но у пользователя нет необходимых для его использования прав доступа. + 1 + + + + + + Выходит из семафора и возвращает последнее значение счетчика. + Счетчик семафора перед вызовом метода . + Счетчик семафора уже имеет максимальное значение. + Произошла ошибка Win32, связанная с именованным семафором. + Текущий семафор представляет именованный системный семафор, но пользователь не имеет прав .-или-Текущий семафор представляет именованный системный семафор, но он не был открыт с правами доступа . + 1 + + + Выходит из семафора указанное число раз и возвращает последнее значение счетчика. + Счетчик семафора перед вызовом метода . + Количество требуемых выходов из семафора. + + имеет значение меньше 1. + Счетчик семафора уже имеет максимальное значение. + Произошла ошибка Win32, связанная с именованным семафором. + Текущий семафор представляет именованный системный семафор, но пользователь не имеет прав .-или-Текущий семафор представляет именованный системный семафор, но он не был открыт с правами . + 1 + + + Открывает указанный именованный семафор, если он уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованный семафор был успешно открыт; в противном случае — значение false. + Имя системного семафора для открытия. + При возврате этот метод содержит объект , представляющий именованный семафор, если вызов завершился успешно, или значение null, если вызов завершился неудачно.Этот параметр обрабатывается как неинициализированный. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Произошла ошибка Win32. + Именованный семафор существует, но у пользователя нет необходимых для его использования прав доступа. + + + Исключение, выдаваемое при вызове метода для семафора, значение счетчика которого уже равно максимальному. + 2 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Представляет упрощенную альтернативу семафору , ограничивающему количество потоков, которые могут параллельно обращаться к ресурсу или пулу ресурсов. + + + Инициализирует новый экземпляр класса , указывая первоначальное число запросов, которые могут выполняться одновременно. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Значение параметра меньше 0. + + + Инициализирует новый экземпляр класса , указывая изначальное и максимальное число запросов, которые могут выполняться одновременно. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + + меньше 0 или больше, чем , или меньше или равен 0. + + + Возвращает дескриптор , который можно использовать для ожидания семафора. + Дескриптор , который можно использовать для ожидания семафора. + Объект удален. + + + Возвращает количество оставшихся потоков, которым разрешено входить в объект . + Количество оставшихся потоков, которым разрешено входить в семафор. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые ресурсы, используемые журналом , и при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Освобождает объект один раз. + Предыдущее количество в семафоре . + Текущий экземпляр уже был удален. + + уже достиг максимального размера. + + + Освобождает объект указанное число раз. + Предыдущее количество в семафоре . + Количество требуемых выходов из семафора. + Текущий экземпляр уже был удален. + + имеет значение меньше 1. + + уже достиг максимального размера. + + + Блокирует текущий поток, пока он не сможет войти в . + Текущий экземпляр уже был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя 32-разрядное целое число со знаком, которое определяет время ожидания. + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя 32-разрядное целое число со знаком, которое определяет время ожидания, и контролирует токен . + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + Экземпляр был удален, или создания был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , и контролирует токен . + Токен , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален.-или- Создания уже был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя значение для определения времени ожидания. + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + Экземпляр semaphoreSlim был уничтожен + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя значение , которое определяет время ожидания, и контролирует токен . + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + Экземпляр semaphoreSlim был уничтоженКласс , создавший , уже удален. + + + Асинхронно ожидает входа в . + Задача, которая завершается при входе в семафор. + + + Асинхронно ожидает входа в , используя 32-разрядное целое число со знаком для измерения интервала времени. + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Асинхронно ожидает входа в , используя 32-разрядное целое число со знаком для измерения интервала времени, контролируя . + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Текущий экземпляр уже был удален. + + был отменен. + + + Асинхронно ожидает входа в , контролируя . + Задача, которая завершается при входе в семафор. + Токен , который следует контролировать. + Текущий экземпляр уже был удален. + + был отменен. + + + Асинхронно ожидает входа в , используя для измерения интервала времени. + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. -или- Время ожидания больше . + + + Асинхронно ожидает входа в , используя для измерения интервала времени и контролируя . + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Токен , который следует контролировать. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания.-или-Время ожидания больше . + + был отменен. + + + Указывает метод, вызываемый при отправке сообщения в контекст синхронизации. + Передаваемый делегату объект. + 2 + + + Предоставляет примитив взаимно исключающей блокировки, в котором поток, пытающийся получить блокировку, ожидает в состоянии цикла, проверяя доступность блокировки. + + + Инициализирует новый экземпляр структуры параметром для отслеживания идентификаторов потоков для повышения качества отладки. + Следует ли перенаправлять и использовать идентификаторы потоков для отладки. + + + Получает блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Аргумент должен быть инициализирован в false до вызова Enter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Снимает блокировку. + Включено отслеживание владения потоков и текущий поток не является владельцем этой блокировки. + + + Снимает блокировку. + Логическое значение, указывающее, следует ли выпустить барьер памяти, чтобы немедленно опубликовать операцию выхода для других потоков. + Включено отслеживание владения потоков и текущий поток не является владельцем этой блокировки. + + + Получает значение, определяющее, имеет ли какой-либо поток блокировку в настоящий момент. + Значение true, если в настоящее время блокировка удерживается каким-либо потоком; в противном случае — значение false. + + + Получает значение, определяющее, имеет ли текущий поток блокировку. + Значение true, если блокировка удерживается текущим потоком; в противном случае — значение false. + Отслеживание владения потоков отключено. + + + Получает значение, указывающее, включено ли отслеживание владельца потока для данного экземпляра. + Значение true, если для данного экземпляра включено отслеживание владельца потока; в противном случае — значение false. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + + является отрицательным числом, отличным от значения -1 миллисекунды, которое представляет неограниченное время ожидания - или - время ожидания больше . + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Предоставляет поддержку ожидания на основе прокруток. + + + Получает число раз, которое был вызван для этого экземпляра. + Возвращает целое число, представляющее количество вызовов метода для данного экземпляра. + + + Получает значение, показывающее, даст ли следующий вызов к доступ к процессору, запуская обязательное переключение контекста. + Даст ли следующий вызов к доступ к процессору, запуская обязательное переключение контекста. + + + Сбрасывает подсчет прокруток. + + + Выполняет одну прокрутку. + + + Выполняет прокрутки до удовлетворения заданного условия. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Аргументом параметра является null. + + + Выполняет прокрутки до удовлетворения заданного условия или истечения заданного времени ожидания. + Значение true, если условие удовлетворено до истечения времени ожидания; в противном случае — значение false. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Аргументом параметра является null. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Выполняет прокрутки до удовлетворения заданного условия или истечения заданного времени ожидания. + Значение true, если условие удовлетворено до истечения времени ожидания; в противном случае — значение false. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Объект , указывающий время ожидания в миллисекундах, или TimeSpan, представляющий значение -1 миллисекунда, в случае неограниченного ожидания. + Аргументом параметра является null. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Обеспечивает базовую функциональность для распространения контекста синхронизации в различных моделях синхронизации. + 2 + + + Создает новый экземпляр класса . + + + При переопределении в производном классе создает копию контекста синхронизации. + Новый объект . + 2 + + + Получает контекст синхронизации для текущего потока + Объект , представляющий текущий контекст синхронизации. + 1 + + + При переопределении в производном классе отвечает на уведомление о завершении операции. + + + При переопределении в производном классе отвечает на уведомление о запуске операции. + + + При переопределении в производном классе отправляет асинхронное сообщение в контекст синхронизации. + Вызываемый делегат . + Передаваемый делегату объект. + 2 + + + При переопределении в производном классе отправляет синхронное сообщение в контекст синхронизации. + Вызываемый делегат . + Передаваемый делегату объект. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Задает текущий контекст синхронизации. + Задаваемый объект . + 1 + + + + + + Исключение, которое выдается в то время, когда методу требуется вызвавший его объект для получения блокировки данного Monitor, а метод вызван объектом, не являющимся владельцем блокировки. + 2 + + + Инициализирует новый экземпляр класса со стандартными свойствами. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Предоставляет хранилище для данных, локальных для потока. + Задает тип данных, хранимых для каждого потока. + + + Инициализирует экземпляр . + + + Инициализирует экземпляр . + Следует ли отслеживать все значения, заданные в экземпляре, и представлять их с помощью свойства . + + + Инициализирует экземпляр с заданной функцией . + Объект , вызываемый для получения неактивно инициализированного значения при совершении попытки получить без предварительной инициализации. + + является пустой ссылкой (Nothing в Visual Basic). + + + Инициализирует экземпляр с заданной функцией . + Объект , вызываемый для получения неактивно инициализированного значения при совершении попытки получить без предварительной инициализации. + Следует ли отслеживать все значения, заданные в экземпляре, и представлять их с помощью свойства . + Параметр является пустой (null) ссылкой (Nothing в Visual Basic). + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает ресурсы, используемые данным экземпляром . + Логическое значение, указывающее, вызывается ли данный метод из-за вызова метода . + + + Освобождает ресурсы, используемые данным экземпляром . + + + Получает значение, указывающее, инициализирован ли объект в текущем потоке. + Значение true, если инициализируется в текущем потоке; в противном случае — значение false. + Экземпляр класса был удален. + + + Создает и возвращает строковое представление данного экземпляра для текущего потока. + Результат вызова метода для свойства . + Экземпляр класса был удален. + + для текущего потока представляет пустую ссылку (Nothing в Visual Basic). + Инициализация попыталась создать рекурсивную ссылку . + Не предоставляются конструктор по умолчанию и значение фабрики. + + + Получает или задает значение данного экземпляра для текущего потока. + Возвращает экземпляр объекта, за инициализацию которого ответственен данный ThreadLocal. + Экземпляр класса был удален. + Инициализация попыталась создать рекурсивную ссылку . + Не предоставляются конструктор по умолчанию и значение фабрики. + + + Получает список всех значений, хранящихся в настоящий момент всеми потоками, которые получили доступа к данному экземпляру. + Список всех значений, хранящихся в настоящий момент всеми потоками, которые получили доступа к данному экземпляру. + Экземпляр класса был удален. + + + Содержит методы для выполнения операций энергозависимой памяти. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает ссылку на объект из указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанная ссылка на объект .Эта ссылка является последней, записанной любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + Тип считываемого поля.Должен быть ссылочным типом или типом значения. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция памяти появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданную ссылку на объект в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается ссылка на объект. + Записываемая ссылка на объект.Ссылка записывается немедленно, так что она становится видимой для всех процессоров компьютера. + Тип поля, в которое выполняется запись.Должен быть ссылочным типом или типом значения. + + + Исключение, которое выдается при попытке открыть не существующий в системе семафор или мьютекс. + 2 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/zh-hans/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/zh-hans/System.Threading.xml new file mode 100644 index 000000000..7c174ad66 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/zh-hans/System.Threading.xml @@ -0,0 +1,1854 @@ + + + + System.Threading + + + + 当某个线程获取由另一个线程放弃（即在未释放的情况下退出）的 对象时引发的异常。 + 1 + + + 使用默认值初始化 类的新实例。 + + + 用被放弃的互斥体的指定索引（如果可用）和表示该互斥体的 对象初始化 类的新实例。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误消息。 + + + 用指定的错误信息和内部异常初始化 类的新实例。 + 解释异常原因的错误消息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 用指定的错误信息、内部异常、被放弃的互斥体的索引（如果可用）以及表示该互斥体的 对象初始化 类的新实例。 + 解释异常原因的错误消息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 用指定的错误信息、被放弃的互斥体的索引（如果可用）以及被放弃的互斥体初始化 类的新实例。 + 解释异常原因的错误消息。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 获取导致异常的被放弃的互斥体（如果已知的话）。 + 如果未能识别被放弃的互斥体，则为表示该被放弃的互斥体的 对象或 null。 + 1 + + + 获取导致异常的被放弃的互斥体的索引（如果已知的话）。 + 如果未能确定被放弃的互斥体的索引，则为传递给 方法的等待句柄数组中的索引、表示该被放弃的互斥体的 对象的索引或 –1。 + 1 + + + 表示对于给定异步控制流（如异步方法）是本地数据的环境数据。 + 环境数据的类型。 + + + 实例化不接收更改通知的 实例。 + + + 实例化接收更改通知的 本地实例。 + 只要当前值在任何线程上发生更改时便会调用的委托。 + + + 获取或设置环境数据的值。 + 环境数据的值。 + + + 向针对更改通知进行了注册的 实例提供数据更改信息的类。 + 数据的类型。 + + + 获取数据的当前值。 + 数据的当前值。 + + + 获取数据的上一个值。 + 数据的上一个值。 + + + 返回一个值，该值指示是否由于执行上下文更改而更改了值。 + 如果由于执行上下文更改而更改了值，则为 true；否则为 false。 + + + 通知正在等待的线程已发生事件。此类不能被继承。 + 2 + + + 使用 Boolean 值（指示是否将初始状态设置为终止的）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + + + 使多个任务能够采用并行方式依据某种算法在多个阶段中协同工作。 + + + 初始化 类的新实例。 + 参与线程的数量。 + + 小于 0 或大于 32,767。 + + + 初始化 类的新实例。 + 参与线程的数量。 + 在每个阶段之后要执行的 。可以传递 null (在 Visual Basic 中为 Nothing) 以指示不执行任何操作。 + + 小于 0 或大于 32,767。 + + + 通知 ，告知其将会有另一个参与者。 + 新参与者将首先参与的屏障的阶段编号。 + 当前实例已被释放。 + 添加参与者将导致屏障的参与者计数超过 32,767。- 或 -该方法从阶段后操作中调用。 + + + 通知 ，告知其将会有多个其他参与者。 + 新参与者将首先参与的屏障的阶段编号。 + 要添加到屏障的其他参与者的数量。 + 当前实例已被释放。 + + 小于 0。- 或 -添加 参与者将导致屏障的参与者计数超过 32,767。 + 该方法从阶段后操作中调用。 + + + 获取屏障的当前阶段的编号。 + 返回屏障的当前阶段的编号。 + + + 释放由 类的当前实例占用的所有资源。 + 该方法从阶段后操作中调用。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。 + + + 获取屏障中参与者的总数。 + 返回屏障中参与者的总数。 + + + 获取屏障中尚未在当前阶段发出信号的参与者的数量。 + 返回屏障中尚未在当前阶段发出信号的参与者的数量。 + + + 通知 ，告知其将会减少一个参与者。 + 当前实例已被释放。 + 屏障已经有 0 个参与者。- 或 -该方法从阶段后操作中调用。 + + + 通知 ，告知其将会减少一些参与者。 + 要从屏障中移除的其他参与者的数量。 + 当前实例已被释放。 + + 小于 0。 + 屏障已经有 0 个参与者。- 或 -该方法从阶段后操作中调用。 - 或 -当前的参与者计数小于指定 participantCount + 参与者总数小于指定的 + + + 发出参与者已达到屏障并等待所有其他参与者也达到屏障。 + 当前实例已被释放。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + 在所有参与线程调用了 SignalAndWait 之后，如果关卡的后期阶段操作中引发了异常，该异常将包装在 BarrierPostPhaseException 中并在所有参与线程上引发。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，同时使用 32 位带符号整数测量超时。 + 如果所有参与者都已在指定时间内达到屏障，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + 在所有参与线程调用了 SignalAndWait 之后，如果关卡的后期阶段操作中引发了异常，该异常将包装在 BarrierPostPhaseException 中并在所有参与线程上引发。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，使用 32 位带符号整数测量超时，同时观察取消标记。 + 如果所有参与者都已在指定时间内达到屏障，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者达到屏障，同时观察取消标记。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，同时使用 对象测量时间间隔。 + 如果所有其他参与者已达到屏障，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 32,767。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，使用 对象测量时间间隔，同时观察取消标记。 + 如果所有其他参与者已达到屏障，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + + 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + + 阶段后操作失败时引发的异常。 + + + 使用由系统提供的用来描述错误的消息初始化 类的新实例。 + + + 使用指定的内部异常初始化 类的新实例。 + 导致当前异常的异常。 + + + 使用指定的描述错误的消息初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 表示要在新上下文中调用的方法。 + 一个对象，包含回调方法在每次执行时要使用的信息。 + 1 + + + 表示在计数变为零时处于有信号状态的同步基元。 + + + 使用指定计数初始化 类的新实例。 + 设置 时最初必需的信号数。 + + 小于 0。 + + + 将 的当前计数加 1。 + 当前实例已被释放。 + 当前实例已设置 。- 或 - 等于或大于 。 + + + 将 的当前计数增加指定值。 + + 的增量值。 + 当前实例已被释放。 + + 小于或等于零。 + 当前实例已设置 。- 或 -在计数由 递增后， 大于或等于 。 + + + 获取设置事件时所必需的剩余信号数。 + 设置事件时所必需的剩余信号数。 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。 + + + 获取设置事件时最初必需的信号数。 + 设置事件时最初必需的信号数。 + + + 确定是否设置了事件。 + 如果设置了事件，则为 true；否则为 false。 + + + 将 重置为 的值。 + 当前实例已被释放。 + + + 将 属性重新设置为指定值。 + 设置 时所必需的信号的数量。 + 当前实例已被释放。 + + 小于 0。 + + + 向 注册信号，同时减小 的值。 + 如果信号导致计数变为零并且设置了事件，则为 true；否则为 false。 + 当前实例已被释放。 + 当前实例已设置 。 + + + 向 注册多个信号，同时将 的值减少指定数量。 + 如果信号导致计数变为零并且设置了事件，则为 true；否则为 false。 + 要注册的信号的数量。 + 当前实例已被释放。 + + 小于 1。 + 当前实例已设置 。- 或 - 大于 。 + + + 增加一个 的尝试。 + 如果成功增加，则为 true；否则为 false。如果 已为零，则此方法将返回 false。 + 当前实例已被释放。 + + 等于 。 + + + 增加指定值的 的尝试。 + 如果成功增加，则为 true；否则为 false。如果 已为零，则此方法将返回 false。 + + 的增量值。 + 当前实例已被释放。 + + 小于或等于零。 + 当前实例已设置 。- 或 - + 大于等于 。 + + + 阻止当前线程，直到设置了 为止。 + 当前实例已被释放。 + + + 阻止当前线程，直到设置了 为止，同时使用 32 位带符号整数测量超时。 + 如果设置了 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直到设置了 为止，并使用 32 位带符号整数测量超时，同时观察 。 + 如果设置了 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直到设置了 为止，同时观察 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + + 阻止当前线程，直到设置了 为止，同时使用 测量超时。 + 如果设置了 ，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 阻止当前线程，直到设置了 为止，并使用 测量超时，同时观察 。 + 如果设置了 ，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 获取用于等待要设置的事件的 。 + 用于等待要设置的事件的 。 + 当前实例已被释放。 + + + 指示在接收信号后是自动重置 还是手动重置。 + 2 + + + 当终止时， 在释放一个线程后自动重置。如果没有等待的线程， 将保持终止状态直到一个线程阻止，并在释放此线程后重置。 + + + 当终止时， 释放所有等待的线程，并在手动重置前保持终止状态。 + + + 表示一个线程同步事件。 + 2 + + + 初始化 类的新实例，并指定等待句柄最初是否处于终止状态，以及它是自动重置还是手动重置。 + 如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + + + 初始化 类的新实例，并指定在此调用后创建的等待句柄最初是否处于终止状态，它是自动重置还是手动重置，以及系统同步事件的名称。 + 如果命名事件是通过此调用创建的，则 true 将初始状态设置为终止；false 将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + 系统范围内同步事件的名称。 + 发生了一个 Win32 错误。 + 命名事件存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名事件，原因可能是与另一个不同类型的等待句柄同名。 + + 的长度超过 260 个字符。 + + + 初始化 类的新实例，并指定在此调用后创建的等待句柄最初是否处于终止状态，它是自动重置还是手动重置，系统同步事件的名称，以及一个 Boolean 变量（其值在调用后表示是否创建了已命名的系统事件）。 + 如果命名事件是通过此调用创建的，则 true 将初始状态设置为终止；false 将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + 系统范围内同步事件的名称。 + 在此方法返回时，如果创建了本地事件（即，如果 为 null 或空字符串）或指定的命名系统事件，则包含 true；如果指定的命名系统事件已存在，则为 false。该参数未经初始化即被传递。 + 发生了一个 Win32 错误。 + 命名事件存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名事件，原因可能是与另一个不同类型的等待句柄同名。 + + 的长度超过 260 个字符。 + + + 打开指定名称为同步事件（如果已经存在）。 + 一个对象，表示已命名的系统事件。 + 要打开的系统同步事件的名称。 + + 是空字符串。- 或 - 的长度超过 260 个字符。 + + 为 null。 + 命名的系统事件不存在。 + 发生了一个 Win32 错误。 + 已命名的事件存在，但用户不具备使用它所需的安全访问权限。 + 1 + + + + + + 将事件状态设置为非终止状态，导致线程阻止。 + 如果该操作成功，则为 true；否则，为 false。 + 之前已对此 调用 方法。 + 2 + + + 将事件状态设置为终止状态，允许一个或多个等待线程继续。 + 如果该操作成功，则为 true；否则，为 false。 + 之前已对此 调用 方法。 + 2 + + + 打开指定名称为同步事件（如果已经存在），并返回指示操作是否成功的值。 + 如果命名同步事件成功打开，则为 true；否则为 false。 + 要打开的系统同步事件的名称。 + 当此方法返回时，如果调用成功，则包含表示命名同步事件的 对象；否则为 null。该参数未经初始化即被处理。 + + 是空字符串。- 或 - 的长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的事件存在，但用户不具备所需的安全访问权限。 + + + 管理当前线程的执行上下文。此类不能被继承。 + 2 + + + 从当前线程捕获执行上下文。 + 一个 对象，表示当前线程的执行上下文。 + 1 + + + 在当前线程上的指定执行上下文中运行某个方法。 + 要设置的 。 + 一个 委托，表示要在提供的执行上下文中运行的方法。 + 要传递给回调方法的对象。 + + 为 null。- 或 - 不是通过捕获操作获取的。- 或 - 已用作 调用的参数。 + 1 + + + + + + 为多个线程共享的变量提供原子操作。 + 2 + + + 对两个 32 位整数进行求和并用和替换第一个整数，上述操作作为一个原子操作完成。 + 存储在 处的新值。 + 一个变量，包含要添加的第一个值。两个值的和存储在 中。 + 要添加到整数中的 位置的值。 + The address of is a null pointer. + 1 + + + 对两个 64 位整数进行求和并用和替换第一个整数，上述操作作为一个原子操作完成。 + 存储在 处的新值。 + 一个变量，包含要添加的第一个值。两个值的和存储在 中。 + 要添加到整数中的 位置的值。 + The address of is a null pointer. + 1 + + + 比较两个双精度浮点数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个 32 位有符号整数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个 64 位有符号整数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个平台特定的句柄或指针是否相等，如果相等，则替换第一个。 + + 中的原始值。 + 其值与 的值进行比较并且可能被 替换的目标 。 + 比较结果相等时替换目标值的 。 + 与位于 处的值进行比较的 。 + The address of is a null pointer. + 1 + + + 比较两个对象是否相等，如果相等，则替换第一个对象。 + + 中的原始值。 + 其值与 进行比较并且可能被替换的目标对象。 + 在比较结果相等时替换目标对象的对象。 + 与位于 处的对象进行比较的对象。 + The address of is a null pointer. + 1 + + + 比较两个单精度浮点数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较指定的引用类型 的两个实例是否相等，如果相等，则替换第一个。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。这是一个引用参数（在 C# 中是 ref，在 Visual Basic 中是 ByRef）。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + 用于 , 和 的类型。此类型必须是引用类型。 + The address of is a null pointer. + + + 以原子操作的形式递减指定变量的值并存储结果。 + 递减的值。 + 其值要递减的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式递减指定变量的值并存储结果。 + 递减的值。 + 其值要递减的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将双精度浮点数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将 32 位有符号整数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将 64 位有符号整数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将平台特定的句柄或指针设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将对象设置为指定的值并返回对原始对象的引用。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将单精度浮点数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将指定类型 的变量设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。这是一个引用参数（在 C# 中是 ref，在 Visual Basic 中是 ByRef）。 + + 参数被设置为的值。 + 用于 和 的类型。此类型必须是引用类型。 + The address of is a null pointer. + + + 以原子操作的形式递增指定变量的值并存储结果。 + 递增的值。 + 其值要递增的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式递增指定变量的值并存储结果。 + 递增的值。 + 其值要递增的变量。 + The address of is a null pointer. + 1 + + + 按如下方式同步内存存取：执行当前线程的处理器在对指令重新排序时，不能采用先执行 调用之后的内存存取，再执行 调用之前的内存存取的方式。 + + + 返回一个以原子操作形式加载的 64 位值。 + 加载的值。 + 要加载的 64 位值。 + 1 + + + 提供延迟初始化例程。 + + + 在目标引用或值类型尚未初始化的情况下，使用其默认构造函数初始化目标引用或值类型。 + 类型 的初始化引用。 + 在类型尚未初始化的情况下，要初始化的类型 的引用。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用或值类型尚未初始化的情况下，使用其默认构造函数初始化目标引用或值类型。 + 类型 的初始化值。 + 在尚未初始化的情况下要初始化的类型 的引用或值。 + 对布尔值的引用，该值确定目标是否已初始化。 + 对用作相互排斥锁的对象的引用，用于初始化 。如果 为 null，则新的对象将被实例化。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用或值类型尚未初始化的情况下，使用指定函数初始化目标引用或值类型。 + 类型 的初始化值。 + 在尚未初始化的情况下要初始化的类型 的引用或值。 + 对布尔值的引用，该值确定目标是否已初始化。 + 对用作相互排斥锁的对象的引用，用于初始化 。如果 为 null，则新的对象将被实例化。 + 调用函数以初始化该引用或值。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用类型尚未初始化的情况下，使用指定函数初始化目标引用类型。 + 类型 的初始化值。 + 在类型尚未初始化的情况下，要初始化的类型 的引用。 + 调用函数以初始化该引用。 + 要初始化的引用的引用类型。 + 类型 没有默认的构造函数。 + + 返回 null（在 Visual Basic 中为 Nothing）。 + + + 当进入锁定状态的递归与此锁定的递归策略不兼容时引发的异常。 + 2 + + + 使用由系统提供的用来描述错误的消息初始化 类的新实例。 + 2 + + + 使用指定的描述错误的消息初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方必须确保此字符串已针对当前系统区域性进行了本地化。 + 2 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方必须确保此字符串已针对当前系统区域性进行了本地化。 + 引发当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + 2 + + + 指定同一个线程是否可以多次进入一个锁定状态。 + + + 如果线程尝试以递归方式进入锁定状态，将引发异常。某些类可能会在此设置生效时允许使用特定的递归方式。 + + + 线程可以采用递归方式进入锁定状态。某些类可能会限制此功能。 + + + 通知一个或多个正在等待的线程已发生事件。此类不能被继承。 + 2 + + + 用一个指示是否将初始状态设置为终止的布尔值初始化 类的新实例。 + 如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止。 + + + 提供 的简化版本。 + + + 使用非终止初始状态初始化 类的新实例。 + + + 使用 Boolean 值（指示是否将初始状态设置为终止状态）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + + + 使用 Boolean 值（指示是否将初始状态设置为终止或指定的旋转数）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + 在回退到基于内核的等待操作之前发生的自旋等待数量。 + + is less than 0 or greater than the maximum allowed value. + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 为 true 则释放托管资源和非托管资源；为 false 则仅释放非托管资源。 + + + 获取是否已设置事件。 + 如果设置了事件，则为 true；否则为 false。 + + + 将事件状态设置为非终止，从而导致线程受阻。 + The object has already been disposed. + + + 将事件状态设置为有信号，从而允许一个或多个等待该事件的线程继续。 + + + 获取在回退到基于内核的等待操作之前发生的自旋等待数量。 + 返回在回退到基于内核的等待操作之前发生的自旋等待数量。 + + + 阻止当前线程，直到设置了当前 为止。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到设定 ，使用 32 位已签名整数测量时间间隔。 + 如果已设置 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到设定 ，使用 32 位已签名整数测量时间间隔，同时观察 。 + 如果已设置 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 阻止当前线程，直到 接收到信号，同时观察 。 + 要观察的 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + 阻止当前线程，直到当前 已设定，使用 测量时间间隔。 + 如果已设置 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到当前 已设定，使用 测量时间间隔，同时观察 。 + 如果已设置 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 获取此 的基础 对象。 + 此 的基础 事件对象。 + + + 提供同步访问对象的机制。 + 2 + + + 在指定对象上获取排他锁。 + 在其上获取监视器锁的对象。 + + 参数为 null。 + 1 + + + 获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 要在其上等待的对象。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。注意   如果没有发生异常，则此方法的输出始终为 true。 + 对 的输入是 true。 + + 参数为 null。 + + + 释放指定对象上的排他锁。 + 在其上释放锁的对象。 + + 参数为 null。 + 当前线程不拥有指定对象的锁。 + 1 + + + 确定当前线程是否保留指定对象上的锁。 + 如果当前线程持有 锁，则为 true；否则为 false。 + 要测试的对象。 + + 为 null。 + + + 通知等待队列中的线程锁定对象状态的更改。 + 线程正在等待的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 1 + + + 通知所有的等待线程对象状态的更改。 + 发送脉冲的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 1 + + + 尝试获取指定对象的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + + 参数为 null。 + 1 + + + 尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 在其上获取锁的对象。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + + 在指定的毫秒数内尝试获取指定对象上的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + 等待锁所需的毫秒数。 + + 参数为 null。 + + 为负且不等于 。 + 1 + + + 在指定的毫秒数内尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 在其上获取锁的对象。 + 等待锁所需的毫秒数。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + 为负且不等于 。 + + + 在指定的时间内尝试获取指定对象上的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + + ，表示等待锁所需的时间量。值为 -1 毫秒表示指定无限期等待。 + + 参数为 null。 + + 值（以毫秒为单位）为负且不等于 （-1 毫秒），或者大于 。 + 1 + + + 在指定的一段时间内尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获得了该锁。 + 在其上获取锁的对象。 + 用于等待锁的时间。值为 -1 毫秒表示指定无限期等待。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + 值（以毫秒为单位）为负且不等于 （-1 毫秒），或者大于 。 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。 + 如果调用由于调用方重新获取了指定对象的锁而返回，则为 true。如果未重新获取该锁，则此方法不会返回。 + 要在其上等待的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + 1 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果已用指定的超时时间间隔，则线程进入就绪队列。 + 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。 + 要在其上等待的对象。 + 线程进入就绪队列之前等待的毫秒数。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + + 参数值为负且不等于 。 + 1 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果已用指定的超时时间间隔，则线程进入就绪队列。 + 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。 + 要在其上等待的对象。 + + ，表示线程进入就绪队列之前等待的时间量。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + + 参数值（以毫秒为单位）为负且不表示 （-1 毫秒），或者大于 。 + 1 + + + 还可用于进程间同步的同步基元。 + 1 + + + 使用默认属性初始化 类的新实例。 + + + 使用 Boolean 值（指示调用线程是否应具有互斥体的初始所有权）初始化 类的新实例。 + 如果给调用线程赋予互斥体的初始所属权，则为 true；否则为 false。 + + + 使用 Boolean 值（指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称）初始化 类的新实例。 + 如果为 true，则给予调用线程已命名的系统互斥体的初始所属权（如果已命名的系统互斥体是通过此调用创建的）；否则为 false。 + + 的名称。如果值为 null，则 是未命名的。 + 命名的互斥体存在并具有访问控制安全性，但用户不具有 。 + 发生了一个 Win32 错误。 + 无法创建命名的互斥体，原因可能是与其他类型的等待句柄同名。 + + 长度超过 260 个字符。 + + + 使用可指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称的 Boolean 值和当线程返回时可指示调用线程是否已赋予互斥体的初始所有权的 Boolean 值初始化 类的新实例。 + 如果为 true，则给予调用线程已命名的系统互斥体的初始所属权（如果已命名的系统互斥体是通过此调用创建的）；否则为 false。 + + 的名称。如果值为 null，则 是未命名的。 + 在此方法返回时，如果创建了局部互斥体（即，如果 为 null 或空字符串）或指定的命名系统互斥体，则包含布尔值 true；如果指定的命名系统互斥体已存在，则为 false。此参数未经初始化即被传递。 + 命名的互斥体存在并具有访问控制安全性，但用户不具有 。 + 发生了一个 Win32 错误。 + 无法创建命名的互斥体，原因可能是与其他类型的等待句柄同名。 + + 长度超过 260 个字符。 + + + 打开指定的已命名的互斥体（如果已经存在）。 + 表示已命名的系统互斥体的对象。 + 要打开的系统互斥体的名称。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 命名的 mutex 不存在。 + 发生了一个 Win32 错误。 + 已命名的互斥体存在，但用户不具备使用它所需的安全访问权限。 + 1 + + + + + + 释放 一次。 + 调用线程不拥有互斥体。 + 1 + + + 打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。 + 如果命名互斥体成功打开，则为 true；否则为 false。 + 要打开的系统互斥体的名称。 + 当此方法返回时，如果调用成功，则包含表示命名互斥体的 对象；否则为 null。该参数未经初始化即被处理。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的互斥体存在，但用户不具备使用它所需的安全访问权限。 + + + 表示用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。 + + + 使用默认属性值初始化 类的新实例。 + + + 在指定锁定递归策略的情况下初始化 类的新实例。 + 枚举值之一，用于指定锁定递归策略。 + + + 获取已进入读取模式锁定状态的独有线程的总数。 + 已进入读取模式锁定状态的独有线程的数量。 + + + 释放 类的当前实例所使用的所有资源。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 尝试进入读取模式锁定状态。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 尝试进入可升级模式锁定状态。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 尝试进入写入模式锁定状态。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 减少读取模式的递归计数，并在生成的计数为 0（零）时退出读取模式。 + The current thread has not entered the lock in read mode. + + + 减少可升级模式的递归计数，并在生成的计数为 0（零）时退出可升级模式。 + The current thread has not entered the lock in upgradeable mode. + + + 减少写入模式的递归计数，并在生成的计数为 0（零）时退出写入模式。 + The current thread has not entered the lock in write mode. + + + 获取一个值，该值指示当前线程是否已进入读取模式的锁定状态。 + 如果当前线程已进入读取模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前线程是否已进入可升级模式的锁定状态。 + 如果当前线程已进入可升级模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前线程是否已进入写入模式的锁定状态。 + 如果当前线程已进入写入模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前 对象的递归策略。 + 枚举值之一，用于指定锁定递归策略。 + + + 获取当前线程进入读取模式锁定状态的次数，用于指示递归。 + 如果当前线程未进入读取模式，则为 0（零）；如果线程已进入读取模式但却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入锁定模式 n - 1 次，则为 n。 + 2 + + + 获取当前线程进入可升级模式锁定状态的次数，用于指示递归。 + 如果当前线程没有进入可升级模式，则为 0；如果线程已进入可升级模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入可升级模式 n - 1 次，则为 n。 + 2 + + + 获取当前线程进入写入模式锁定状态的次数，用于指示递归。 + 如果当前线程没有进入写入模式，则为 0；如果线程已进入写入模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入写入模式 n - 1 次，则为 n。 + 2 + + + 尝试进入读取模式锁定状态，可以选择整数超时时间。 + 如果调用线程已进入读取模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入读取模式锁定状态，可以选择超时时间。 + 如果调用线程已进入读取模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 尝试进入可升级模式锁定状态，可以选择超时时间。 + 如果调用线程已进入可升级模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入可升级模式锁定状态，可以选择超时时间。 + 如果调用线程已进入可升级模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 尝试进入写入模式锁定状态，可以选择超时时间。 + 如果调用线程已进入写入模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入写入模式锁定状态，可以选择超时时间。 + 如果调用线程已进入写入模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 获取等待进入读取模式锁定状态的线程总数。 + 等待进入读取模式的线程总数。 + 2 + + + 获取等待进入可升级模式锁定状态的线程总数。 + 等待进入可升级模式的线程总数。 + 2 + + + 获取等待进入写入模式锁定状态的线程总数。 + 等待进入写入模式的线程总数。 + 2 + + + 限制可同时访问某一资源或资源池的线程数。 + 1 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + + 大于 。 + + 为小于 1。- 或 - 小于 0。 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数，可以选择指定系统信号量对象的名称。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + 命名系统信号量对象的名称。 + + 大于 。- 或 - 长度超过 260 个字符。 + + 为小于 1。- 或 - 小于 0。 + 发生了一个 Win32 错误。 + 命名信号量存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名的信号量，可能是因为存在同名但类型不同的等待句柄。 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数，还可以选择指定系统信号量对象的名称，以及指定一个变量来接收指示是否创建了新系统信号量的值。 + 可以同时满足的信号量的初始请求数。 + 可以同时满足的信号量的最大请求数。 + 命名系统信号量对象的名称。 + 在此方法返回时，如果创建了本地信号量（即，如果 为 null 或空字符串）或指定的命名系统信号量，则包含 true；如果指定的命名系统信号量已存在，则为 false。此参数未经初始化即被传递。 + + 大于 。- 或 - 长度超过 260 个字符。 + + 为小于 1。- 或 - 小于 0。 + 发生了一个 Win32 错误。 + 命名信号量存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名的信号量，可能是因为存在同名但类型不同的等待句柄。 + + + 打开指定名称为信号量（如果已经存在）。 + 一个对象，表示已命名的系统信号量。 + 要打开的系统信号量的名称。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 命名的信号量不存在。 + 发生了一个 Win32 错误。 + 已命名的信号量存在，但用户不具备使用它所需的安全访问权。 + 1 + + + + + + 退出信号量并返回前一个计数。 + 调用 方法前信号量的计数。 + 信号量计数已是最大值。 + 发生已命名信号量的 Win32 错误。 + 当前信号量表示一个已命名的系统信号量，但用户不具备 。- 或 -当前信号量表示一个已命名的系统信号量，但它未用 打开。 + 1 + + + 以指定的次数退出信号量并返回前一个计数。 + 调用 方法前信号量的计数。 + 退出信号量的次数。 + + 为小于 1。 + 信号量计数已是最大值。 + 发生已命名信号量的 Win32 错误。 + 当前信号量表示一个已命名的系统信号量，但用户不具备 权限。- 或 -当前信号量表示一个已命名的系统信号量，但它不是以 权限打开的。 + 1 + + + 打开指定名称为信号量（如果已经存在），并返回指示操作是否成功的值。 + 如果命名信号量成功打开，则为 true；否则为 false。 + 要打开的系统信号量的名称。 + 当此方法返回时，如果调用成功，则包含表示命名信号的 对象；否则为 null。该参数未经初始化即被处理。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的信号量存在，但用户不具备使用它所需的安全访问权。 + + + 对计数已达到最大值的信号量调用 方法时引发的异常。 + 2 + + + 使用默认值初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 对可同时访问资源或资源池的线程数加以限制的 的轻量替代。 + + + 初始化 类的新实例，以指定可同时授予的请求的初始数量。 + 可以同时授予的信号量的初始请求数。 + + 小于 0。 + + + 初始化 类的新实例，同时指定可同时授予的请求的初始数量和最大数量。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + + 小于 0，或 大于 ，或 小于等于 0。 + + + 返回一个可用于在信号量上等待的 。 + 可用于在信号量上等待的 。 + 已释放了 。 + + + 获取可以输入 对象的剩余线程数。 + 可以输入信号量的剩余线程数。 + + + 释放 类的当前实例所使用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 释放 对象一次。 + + 的前一个计数。 + 当前实例已被释放。 + + 已达到其最大大小。 + + + 释放 对象指定的次数。 + + 的前一个计数。 + 退出信号量的次数。 + 当前实例已被释放。 + + 为小于 1。 + + 已达到其最大大小。 + + + 阻止当前线程，直至它可进入 为止。 + 当前实例已被释放。 + + + 阻止当前线程，直至它可进入 为止，同时使用 32 位带符号整数来指定超时。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直至它可进入 为止，并使用 32 位带符号整数来指定超时，同时观察 。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + 实例已被释放，或 创建 已被释放。 + + + 阻止当前线程，直至它可进入 为止，同时观察 。 + 要观察的 标记。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 已释放。 + + + 阻止当前线程，直至它可进入 为止，同时使用 来指定超时。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + semaphoreSlim 实例已处理 + + + 阻止当前线程，直至它可进入 为止，并使用 来指定超时，同时观察 。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + semaphoreSlim 实例已处理 创建了 的 已经被释放。 + + + 输入 的异步等待。 + 输入信号量时完成任务。 + + + 输入 的异步等待，使用 32 位带符号整数度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 在观察 时，输入 的异步等待，使用 32 位带符号整数度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 当前实例已被释放。 + + 已取消。 + + + 在观察 时，输入 的异步等待。 + 输入信号量时完成任务。 + 要观察的 标记。 + 当前实例已被释放。 + + 已取消。 + + + 输入 的异步等待，使用 度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时 - 或 - 超时大于 。 + + + 在观察 时，输入 的异步等待，使用 度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 标记。 + + 是一个非 -1 的负数，而 -1 表示无限期超时- 或 -超时大于 。 + + 已取消。 + + + 表示在消息即将被调度到同步上下文时要调用的方法。 + 传递给委托的对象。 + 2 + + + 提供一个相互排斥锁基元，在该基元中，尝试获取锁的线程将在重复检查的循环中等待，直至该锁变为可用为止。 + + + 使用用于跟踪线程 ID 以改善调试的选项初始化 结构的新实例。 + 是否捕获线程 ID 并将其用于调试目的。 + + + 采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + 在调用 Enter 之前， 参数必须初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 释放锁。 + 启用线程所有权跟踪，当前线程不是此锁的所有者。 + + + 释放锁。 + 一个布尔值，该值指示是否应发出内存界定，以便将退出操作立即发布到其他线程。 + 启用线程所有权跟踪，当前线程不是此锁的所有者。 + + + 获取锁当前是否已由任何线程占用。 + 如果锁当前已由任何线程占用，则为 true；否则为 false。 + + + 获取锁是否已由当前线程占用。 + 如果锁已由当前线程占用，则为 true；否则为 false。 + 禁用线程所有权跟踪。 + + + 获取是否已为此实例启用了线程所有权跟踪。 + 如果已为此实例启用了线程所有权跟踪，则为 true；否则为 false。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 毫秒。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 提供对基于自旋的等待的支持。 + + + 获取已对此实例调用 的次数。 + 返回一个整数，该整数表示已对此实例调用 的次数。 + + + 获取对 的下一次调用是否将产生处理器，同时触发强制上下文切换。 + 对 的下一次调用是否将产生处理器，同时触发强制上下文切换。 + + + 重置自旋计数器。 + + + 执行单一自旋。 + + + 在指定条件得到满足之前自旋。 + 在返回 true 之前重复执行的委托。 + + 参数为 null。 + + + 在指定条件得到满足或指定超时过期之前自旋。 + 如果条件在超时时间内得到满足，则为 true；否则为 false + 在返回 true 之前重复执行的委托。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + 参数为 null。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 在指定条件得到满足或指定超时过期之前自旋。 + 如果条件在超时时间内得到满足，则为 true；否则为 false + 在返回 true 之前重复执行的委托。 + 一个 ，表示等待的毫秒数；或者一个 TimeSpan，表示 -1 毫秒（无限期等待）。 + + 参数为 null。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 提供在各种同步模型中传播同步上下文的基本功能。 + 2 + + + 创建 类的新实例。 + + + 在派生类中重写时，创建同步上下文的副本。 + 一个新 对象。 + 2 + + + 获取当前线程的同步上下文。 + 一个 对象，它表示当前同步上下文。 + 1 + + + 在派生类中重写时，响应操作已完成的通知。 + + + 在派生类中重写时，响应操作已开始的通知。 + + + 在派生类中重写时，将异步消息分派到同步上下文。 + 要调用的 委托。 + 传递给委托的对象。 + 2 + + + 在派生类中重写时，将同步消息分派到同步上下文。 + 要调用的 委托。 + 传递给委托的对象。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 设置当前同步上下文。 + 要设置的 对象。 + 1 + + + + + + 当某个方法请求调用方拥有给定 Monitor 上的锁时将引发该异常，而且由不拥有该锁的调用方调用此方法。 + 2 + + + 使用默认属性初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 提供数据的线程本地存储。 + 指定每线程的已存储数据的类型。 + + + 初始化 实例。 + + + 初始化 实例。 + 是否要跟踪实例上的所有值集并通过 属性将其公开。 + + + 使用指定的 函数初始化 实例。 + 如果在 之前尚未初始化的情况下尝试对其进行检索，则会调用 生成延迟初始化的值。 + + 是 null 引用（在 Visual Basic 中为 Nothing）。 + + + 使用指定的 函数初始化 实例。 + 如果在 之前尚未初始化的情况下尝试对其进行检索，则会调用 生成延迟初始化的值。 + 是否要跟踪实例上的所有值集并通过 属性将其公开。 + + 为 null 引用（在 Visual Basic 中为 Nothing）。 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放此 实例使用的资源。 + 一个布尔值，该值指示是否由于调用 的原因而调用此方法。 + + + 释放此 实例使用的资源。 + + + 获取是否在当前线程上初始化 。 + 如果在当前线程上初始化 ，则为 true；否则为 false。 + 已释放 实例。 + + + 创建并返回当前线程的此实例的字符串表示形式。 + 对 调用 的结果。 + 已释放 实例。 + 当前线程的 为 null 引用（Visual Basic 中为 Nothing）。 + 初始化函数尝试以递归方式引用 。 + 没有提供默认构造函数，且没有提供值工厂。 + + + 获取或设置当前线程的此实例的值。 + 返回此 ThreadLocal 负责初始化的对象的实例。 + 已释放 实例。 + 初始化函数尝试以递归方式引用 。 + 没有提供默认构造函数，且没有提供值工厂。 + + + 获取当前由已经访问此实例的所有线程存储的所有值的列表。 + 访问此实例由所有线程存储的当前的所有值的列表。 + 已释放 实例。 + + + 包含用于执行易失内存操作的方法。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 从指定的字段读取对象引用。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 对读取的 的引用。无论处理器的数目或处理器缓存的状态如何，该引用都是由计算机的任何处理器写入的最新引用。 + 要读取的字段。 + 要读取的字段的类型。此类型必须是引用类型，而不是值类型。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入如下所示的防止处理器重新对内存操作进行排序的内存栅：如果内存操作出现在代码中的此方法之前，则处理器不能将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的对象引用写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将对象引用写入的字段。 + 要写入的对象引用。立即写入一个引用，以使该引用对计算机中的所有处理器都可见。 + 要写入的字段的类型。此类型必须是引用类型，而不是值类型。 + + + 在尝试打开不存在的系统互斥体或信号量时引发的异常。 + 2 + + + 使用默认值初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netcore50/zh-hant/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netcore50/zh-hant/System.Threading.xml new file mode 100644 index 000000000..9ff1745d9 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netcore50/zh-hant/System.Threading.xml @@ -0,0 +1,1885 @@ + + + + System.Threading + + + + 當一個執行緒取得另一個執行緒已放棄，但是結束時並未釋放的 物件時，所擲回的例外狀況。 + 1 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用已放棄 Mutex 的指定索引 (若適用的話) 以及表示此 Mutex 的 物件，初始化 類別的新執行個體 。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和內部例外狀況初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 使用指定的錯誤訊息、內部例外狀況、已放棄 Mutex 的索引 (若適用的話)，以及表示此 Mutex 的 物件，初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 以指定的錯誤訊息、已放棄 Mutex 的索引 (若適用的話) 以及放棄的 Mutex 初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 取得造成例外狀況的已放棄 Mutex (若為已知)。 + + 物件，表示已放棄的 Mutex；若無法識別已放棄的 Mutex，則為 null。 + 1 + + + 取得造成例外狀況之已放棄 Mutex 的索引 (若為已知)。 + 等候控制代碼陣列中的索引 (已傳遞給 物件的 方法)，表示已放棄的 Mutex；如果無法判斷已放棄 Mutex 的索引，則為 -1。 + 1 + + + 表示對於指定的非同步控制流程為本機的環境資料，例如非同步方法。 + 環境資料的類型。 + + + 具現化不會接收變更告知的 執行個體。 + + + 具現化會接收變更告知的 本機執行個體。 + 每當在任何執行緒上變更目前的值就會呼叫委派。 + + + 取得或設定環境資料的值。 + 環境資料的值。 + + + 會提供資料變更資訊給 執行個體的的類別，該執行個體會註冊變更告知。 + 資料的類型。 + + + 取得資料目前的值。 + 資料目前的值。 + + + 取得資料先前的值。 + 資料先前的值。 + + + 傳回值，指出值是否會因為執行內容的變更而變更。 + 如果值會因為執行內容的變更而變更，則為 true；否則為 false。 + + + 向等候的執行緒通知發生事件。此類別無法被繼承。 + 2 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值，初始化 類別的新執行個體。 + true 表示初始狀態設定為已收到信號，false 表示初始狀態設定為未收到信號。 + + + 允許多項工作在多個階段中以平行方式來合作處理某個演算法。 + + + 初始化 類別的新執行個體。 + 參與執行緒的數目。 + + 小於 0 或大於 32,767。 + + + 初始化 類別的新執行個體。 + 參與執行緒的數目。 + 要在每個階段之後執行的 。可以傳遞 null (在 Visual Basic 中為 Nothing) 表示不執行任何動作。 + + 小於 0 或大於 32,767。 + + + 通知 ，表示還會有一個其他參與者。 + 新參與者將第一次參與其中的屏障階段編號。 + 目前的執行個體已經處置。 + 加入參與者會造成屏障的參與者計數超過 32,767。-或-此方法是從 post-phase 動作中叫用。 + + + 通知 ，表示還會有多個其他參與者。 + 新參與者將第一次參與其中的屏障階段編號。 + 要加入至屏障的其他參與者數目。 + 目前的執行個體已經處置。 + + 小於 0。-或-加入 參與者會造成屏障的參與者計數超過 32,767。 + 此方法是從 post-phase 動作中叫用。 + + + 取得屏障目前階段的編號。 + 傳回屏障目前階段的編號。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + 此方法是從 post-phase 動作中叫用。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示同時釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得在屏障中的參與者總數。 + 傳回在屏障中的參與者總數。 + + + 取得在目前階段中尚未發出訊號的屏障中參與者數目。 + 傳回在目前階段中尚未發出訊號的屏障中參與者數目。 + + + 通知 ，表示會減少一個參與者。 + 目前的執行個體已經處置。 + 屏障已經有 0 個參與者。-或-此方法是從 post-phase 動作中叫用。 + + + 通知 ，表示會減少一些參與者。 + 要從屏障中移除的其他參與者數目。 + 目前的執行個體已經處置。 + + 小於 0。 + 屏障已經有 0 個參與者。-或-此方法是從 post-phase 動作中叫用。 -或-目前的參與者計數少於指定的 participantCount + 參與者總計數小於指定的 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障。 + 目前的執行個體已經處置。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + 所有參與執行緒皆已呼叫 SignalAndWait 後，如果從 Barrier 的階段後動作擲回例外，會將例外狀況包裝在 BarrierPostPhaseException 中，並擲回所有參與執行緒。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障 (使用 32 位元帶正負號的整數以測量逾時)。 + 如果所有參與者已在指定時間內達到屏障則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + 所有參與執行緒皆已呼叫 SignalAndWait 後，如果從 Barrier 的階段後動作擲回例外，會將例外狀況包裝在 BarrierPostPhaseException 中，並擲回所有參與執行緒。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達 (使用 32 位元帶正負號的整數以測量逾時)，同時觀察取消語彙基元。 + 如果所有參與者已在指定時間內達到屏障則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達，同時觀察取消語彙基元。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障 (使用 物件以測量時間間隔)。 + 如果所有其他參與者已達到屏障則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 32,767 的逾時。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達 (使用 物件以測量時間間隔)，同時觀察取消語彙基元。 + 如果所有其他參與者已達到屏障則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 在 的後續階段動作失敗時所擲回的例外狀況。 + + + 以系統提供的錯誤說明訊息，初始化 類別的新執行個體。 + + + 使用指定的內部例外狀況，初始化 類別的新執行個體。 + 導致目前例外狀況的例外。 + + + 使用指定的錯誤說明訊息，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 表示要在新內容裡面呼叫的方法。 + 物件，它包含回呼方法所使用的資訊。 + 1 + + + 代表當計數到達零時收到訊號的同步處理原始物件。 + + + 使用指定的計數，初始化 類別的新執行個體。 + 設定 時最初所需的訊號次數。 + + 小於 0。 + + + 將 目前的計數遞增一。 + 目前的執行個體已經處置。 + 目前的執行個體已經設定。-或- 等於或大於 。 + + + 將 目前的計數遞增所指定的值。 + + 所要增加的值。 + 目前的執行個體已經處置。 + + 小於或等於 0。 + 目前的執行個體已經設定。-或-計數遞增 後， 會等於或大於 + + + 取得設定事件時需要的剩餘訊號次數。 + 設定事件時需要的剩餘訊號次數。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示同時釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得設定事件一開始時所需要的訊號次數。 + 設定事件一開始時所需要的訊號次數。 + + + 判斷事件是否已設定。 + 如果已設定事件則為 true，否則為 false。 + + + 將 重設為 的值。 + 目前的執行個體已經處置。 + + + 將 屬性重設為指定的值。 + 設定 時所需的訊號次數。 + 目前的執行個體已經處置。 + + 小於 0。 + + + 向 註冊訊號，並遞減 的值。 + 如果訊號使計數到達零且設定事件則為 true，否則為 false。 + 目前的執行個體已經處置。 + 目前的執行個體已經設定。 + + + 向 註冊多個訊號，並將 的值遞減指定的數量。 + 如果信號使計數到達零且設定事件則為 true，否則為 false。 + 要註冊的訊號數。 + 目前的執行個體已經處置。 + + 小於 1。 + 目前的執行個體已經設定。或 大於 。 + + + 嘗試將 遞增一。 + 如果遞增成功則為 true，否則為 false。如果 已經位於零，這個方法將傳回 false。 + 目前的執行個體已經處置。 + + 等於 。 + + + 嘗試以指定的值遞增 。 + 如果遞增成功則為 true，否則為 false。如果 已經為零，這將傳回 false。 + + 所要增加的值。 + 目前的執行個體已經處置。 + + 小於或等於 0。 + 目前的執行個體已經設定。-或- + 等於或大於 。 + + + 封鎖目前的執行緒，直到設定了 為止。 + 目前的執行個體已經處置。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 32 位元帶正負號的整數以測量逾時)。 + 如果已設定 則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 32 位元帶正負號的整數以測量逾時)，同時觀察 。 + 如果已設定 則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到設定了 為止，同時觀察 。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 以測量逾時)。 + 如果已設定 則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 以測量逾時)，同時觀察 。 + 如果已設定 則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 取得用來等候事件獲得設定的 。 + + ，其會用於等候事件獲得設定。 + 目前的執行個體已經處置。 + + + 表示收到信號之後，是否會自動或手動重設 。 + 2 + + + 收到信號通知時， 在釋放單一執行緒後會自動重設。如果沒有任何執行緒在等待，則 會保持收到信號的狀態，直到有執行緒被封鎖為止，接著就釋放這個執行緒並將自己重設。 + + + 收到信號通知時， 會釋放所有正在等待的執行緒，並保持收到信號的狀態，直到被手動重設為止。 + + + 表示執行緒同步處理事件。 + 2 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號，以及是以自動還是手動方式來重設。 + true 表示初始狀態設定為已收到信號，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號 (如果它是因這個呼叫而建立)、是以自動還是手動方式進行重設，以及系統同步處理事件的名稱。 + true 表示初始狀態設定為已收到信號 (如果具名事件是因這個呼叫而建立)，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + 整個系統的同步處理事件名稱。 + 發生 Win32 錯誤。 + 具名的事件已存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的事件，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 長度超過 260 個字元。 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號 (如果它是因這個呼叫而建立)、是以自動還是手動方式進行重設、系統同步處理事件的名稱，以及呼叫之後的布林變數值 (此值可指示是否已建立具名系統事件)。 + true 表示初始狀態設定為已收到信號 (如果具名事件是因這個呼叫而建立)，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + 整個系統的同步處理事件名稱。 + 這個方法傳回時，如果已建立本機事件 (也就是說，如果 為 null 或空字串)，或是已建立指定的已命名系統事件，則會包含 true；如果指定的已命名系統事件已存在則為 false。這個參數會以未初始化的狀態傳遞。 + 發生 Win32 錯誤。 + 具名的事件已存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的事件，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 長度超過 260 個字元。 + + + 開啟指定的具名同步處理事件 (如果已經存在)。 + 表示具名系統事件的物件。 + 要開啟的系統同步處理事件的名稱。 + + 為空字串。-或- 長度超過 260 個字元。 + + 為 null。 + 具名系統事件不存在。 + 發生 Win32 錯誤。 + 具名事件存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 將事件的狀態設定為未收到信號，會造成執行緒封鎖。 + 如果作業成功，則為 true，否則為 false . + 之前在這個 上呼叫 方法。 + 2 + + + 將事件的狀態設定為未收到信號，讓一個或多個等候執行緒繼續執行。 + 如果作業成功，則為 true，否則為 false . + 之前在這個 上呼叫 方法。 + 2 + + + 開啟指定的具名同步處理事件 (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名同步處理事件，則為 true，否則為 false。 + 要開啟的系統同步處理事件的名稱。 + 這個方法傳回時，如果呼叫成功，則包含物件，此物件代表具名同步處理事件，如果呼叫失敗，則為null。這個參數會被視為未初始化。 + + 為空字串。-或- 長度超過 260 個字元。 + + 為 null。 + 發生 Win32 錯誤。 + 具名事件已存在，但是使用者沒有所需的安全性存取權。 + + + 管理目前執行緒的執行內容。此類別無法被繼承。 + 2 + + + 從目前的執行緒擷取執行內容。 + + 物件，表示目前執行緒的執行內容。 + 1 + + + 在目前執行緒上的指定執行內容中執行方法。 + 要設定的 。 + + 委派，表示要在所提供執行內容中執行的方法。 + 要傳遞至回呼 (Callback) 方法的物件。 + + 為 null。-或- 不是透過擷取作業取得。-或-已經將 當做 呼叫的引數使用。 + 1 + + + + + + 為多重執行緒共用的變數提供不可部分完成的作業 (Atomic Operation)。 + 2 + + + 將兩個 32 位元整數加相，並以總和取代第一個整數，成為不可部分完成的作業。 + 新值儲存於 。 + 包含要加入的第一個值的變數。這兩個值的總和會存放在 中。 + 要加入 的整數的值。 + The address of is a null pointer. + 1 + + + 將兩個 64 位元整數加相，並以總和取代第一個整數，成為不可部分完成的作業。 + 新值儲存於 。 + 包含要加入的第一個值的變數。這兩個值的總和會存放在 中。 + 要加入 的整數的值。 + The address of is a null pointer. + 1 + + + 比較兩個雙精確度浮點數是否相等；如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個 32 位元帶正負號的整數是否相等，如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個 64 位元帶正負號的整數是否相等，如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個平台特定的控制代碼或指標是否相等；如果相等，則取代第一個。 + + 中的原始值。 + 目的端 ，其值會與 的值進行比較，且可能被 所取代。 + + ，當比較的結果相等時會取代目的端值。 + + ，會與 的值相比較。 + The address of is a null pointer. + 1 + + + 比較兩個物件的參考是否相等；如果相等，則取代第一個物件。 + + 中的原始值。 + 目的端物件，此物件會與 進行比較且可能被取代。 + 當比較的結果相等時，會取代目的端物件的物件。 + 與 的物件相比較的物件。 + The address of is a null pointer. + 1 + + + 比較兩個單精確度浮點數是否相等；如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較指定參考類型 的兩個執行個體是否相等；如果相等，則取代第一個。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。此為參考參數 (在 C# 中為 ref，在 Visual Basic 中為 ByRef)。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + 要用於 、 和 的類型。此類型必須是參考類型。 + The address of is a null pointer. + + + 遞減特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞減後的值。 + 值會被遞減的變數。 + The address of is a null pointer. + 1 + + + 遞減特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞減後的值。 + 值會被遞減的變數。 + The address of is a null pointer. + 1 + + + 將雙精確度浮點數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將 32 位元帶正負號的整數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將 64 位元帶正負號的整數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將平台特定的控制代碼或指標設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將物件設定為指定值，然後傳回原始物件的參考，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將單精確度浮點數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將指定類型 的變數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。此為參考參數 (在 C# 中為 ref，在 Visual Basic 中為 ByRef)。 + + 參數要設定成的值。 + 要用於 和 的類型。此類型必須是參考類型。 + The address of is a null pointer. + + + 遞增特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞增後的值。 + 值會被遞增的變數。 + The address of is a null pointer. + 1 + + + 遞增特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞增後的值。 + 值會被遞增的變數。 + The address of is a null pointer. + 1 + + + 同步處理記憶體存取，如下所示：執行目前執行緒的處理器無法以下列方式重新排列指示：呼叫 之前的記憶體存取在呼叫 後的記憶體存取之後執行。 + + + 傳回 64 位元的值 (載入為不可部分完成的作業)。 + 載入的值。 + 要載入的 64 位元值。 + 1 + + + 提供延遲初始化常式。 + + + 如果目標參考型別尚未初始化，則使用該型別的預設建構函式來進行初始化。 + 型別 的已初始化參考。 + 要初始化 (如果尚未初始化) 的型別 的參考。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用其預設建構函式來初始化目標的參考型別或實值型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考或實值。 + 布林值的參考，這個值可判斷目標是否已初始化。 + 物件的參考，這個物件用來當做初始化 時的互斥鎖定。如果 為 null，則具現化新的物件。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用指定的函式來初始化目標的參考或實值型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考或實值。 + 布林值的參考，這個值可判斷目標是否已初始化。 + 物件的參考，這個物件用來當做初始化 時的互斥鎖定。如果 為 null，則具現化新的物件。 + 呼叫來初始化參考或值的函式。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用指定的函式來初始化目標的參考型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考。 + 呼叫來初始化參考的函式。 + 要初始化之參考的參考型別。 + + 型別沒有預設的建構函式。 + + 傳回 null (在 Visual Basic 中為 Nothing)。 + + + 當遞迴進入鎖定與鎖定的遞迴原則不相符時，擲回的例外狀況。 + 2 + + + 以系統提供的錯誤說明訊息，初始化 類別的新執行個體。 + 2 + + + 使用指定的錯誤說明訊息，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已針對目前系統的文化特性，執行過當地語系化。 + 2 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已針對目前系統的文化特性，執行過當地語系化。 + 造成目前例外狀況的例外狀況。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + 2 + + + 指定相同的執行緒是否可以多次進入鎖定。 + + + 如果執行緒嘗試遞迴地進入鎖定，則會擲回例外狀況。某些類別可能會在此設定有效時允許特定的遞迴。 + + + 執行緒可以遞迴地進入鎖定。某些類別可能會限制此功能。 + + + 告知一個以上的等候中執行緒已發生事件。此類別無法被繼承。 + 2 + + + 使用布林值 (Boolean) 來初始化 類別的新執行個體，指出初始狀態是否設定為信號狀態。 + 如果初始狀態設定為信號狀態，為 true；初始狀態設定為非信號狀態則為 false。 + + + 提供 的精簡版本。 + + + 使用未收到訊號的初始狀態來初始化 類別的新執行個體。 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值，初始化 類別的新執行個體。 + true 表示會將初始狀態設定為已收到訊號，false 表示會將初始狀態設定為未收到訊號。 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值以及指定的微調計數，初始化 類別的新執行個體。 + true 表示會將初始狀態設定為已收到訊號，false 表示會將初始狀態設定為未收到訊號。 + 在回到以核心為基礎的等候作業之前進行微調等候的次數。 + + is less than 0 or greater than the maximum allowed value. + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 與 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得值，表示事件是否已設定。 + 如果已設定事件則為 true，否則為 false。 + + + 將事件的狀態設定為未收到信號，會造成執行緒封鎖。 + The object has already been disposed. + + + 將事件的狀態設定為已收到訊號，讓正在等候該事件的一或多個執行緒繼續執行。 + + + 取得在回到以核心為基礎的等候作業之前進行微調等候的次數。 + 傳回在回到以核心為基礎的等候作業之前進行微調等候的次數。 + + + 封鎖目前的執行緒，直到設定了目前的 為止。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止 (使用 32 位元帶正負號的整數以測量時間間隔)。 + 如果設定了 ，則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 32 位元帶正負號的整數以測量時間間隔，同時觀察 。 + 如果設定了 ，則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 封鎖目前的執行緒，直到目前的 收到訊號為止，同時觀察 。 + 要觀察的 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 以測量時間間隔。 + 如果設定了 ，則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 以量測時間間隔，同時觀察 。 + 如果設定了 ，則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 取得這個 的基礎 物件。 + 這個 的基礎 事件物件。 + + + 提供一套機制，同步處理物件的存取。 + 2 + + + 取得指定物件的獨佔鎖定。 + 要從其上取得監視器鎖定的物件。 + + 參數為 null。 + 1 + + + 取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要等候的物件。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。注意：如果沒有發生例外狀況，這個方法的輸出一律為 true。 + + 的輸入為 true。 + + 參數為 null。 + + + 釋出指定物件的獨佔鎖定。 + 要從其上釋出鎖定的物件。 + + 參數為 null。 + 目前執行緒沒有指定物件的鎖定。 + 1 + + + 判斷目前執行緒是否保持鎖定指定的物件。 + 如果目前的執行緒持有 的鎖定，則為 true；否則為 false。 + 要測試的物件。 + + 為 null。 + + + 通知等候佇列中的執行緒，鎖定物件的狀態有所變更。 + 執行緒正等候的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 1 + + + 通知所有等候中的執行緒，物件的狀態有所變更。 + 送出 Pulse 的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 1 + + + 嘗試取得指定物件的獨佔鎖定。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + + 參數為 null。 + 1 + + + 嘗試取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + + 嘗試取得指定物件的獨佔鎖定 (在指定的毫秒數時間內)。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + 等候鎖定的毫秒數。 + + 參數為 null。 + + 為負，且不等於 。 + 1 + + + 嘗試在指定的毫秒數內取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 等候鎖定的毫秒數。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + 為負，且不等於 。 + + + 嘗試取得指定物件的獨佔鎖定 (在指定的時間內)。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + + ，代表等候鎖定的時間量。-1 毫秒的值會指定無限期等候。 + + 參數為 null。 + + 的毫秒值為負且不等於 (-1 毫秒) 或大於 。 + 1 + + + 嘗試在指定的時間內取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 等候鎖定的時間長度。-1 毫秒的值會指定無限期等候。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + 的毫秒值為負且不等於 (-1 毫秒) 或大於 。 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。 + 如果由於呼叫端重新取得指定物件的鎖定而傳回呼叫，則為 true。如果鎖定不被重新取得，則這個方法不會傳回。 + 要等候的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + 1 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。如果超過指定的逾時間隔時間，執行緒會進入就緒序列。 + 如果在經過指定的時間之前重新取得鎖定，則為 true；如果在經過指定的時間之後重新取得鎖定，則為 false。要等到重新取得鎖定之後，此方法才會傳回。 + 要等候的物件。 + 在執行緒進入就緒佇列之前要等候的毫秒數。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + + 參數的值為負，且不等於 。 + 1 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。如果超過指定的逾時間隔時間，執行緒會進入就緒序列。 + 如果在經過指定的時間之前重新取得鎖定，則為 true；如果在經過指定的時間之後重新取得鎖定，則為 false。要等到重新取得鎖定之後，此方法才會傳回。 + 要等候的物件。 + + ，代表在執行緒進入就緒佇列之前要等候的時間量。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + + 參數的毫秒值為負，且不表示 (-1 毫秒)，或大於 。 + 1 + + + 同步處理原始物件，該物件也可用於進行處理序之間的同步處理。 + 1 + + + 使用預設屬性，初始化 類別的新執行個體。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值，初始化 類別的新執行個體。 + true 表示將 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值，以及代表 Mutex 名稱的字串，初始化 類別的新執行個體。 + true 表示如果這個呼叫的結果建立了具名系統 Mutex，則將具名系統 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + 的名稱。如果值是 null，則 未命名。 + 具名的 Mutex 存在，而且具有存取控制安全性，但是使用者沒有 。 + 發生 Win32 錯誤。 + 無法建立具名的 Mutex，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 长度超过 260 个字符。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值、代表 Mutex 名稱的字串，以及當方法傳回時表示是否將 Mutex 的初始擁有權授與呼叫執行緒的布林值，初始化 類別的新執行個體。 + true 表示如果這個呼叫的結果建立了具名系統 Mutex，則將具名系統 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + 的名稱。如果值是 null，則 未命名。 + 當這個方法傳回時，如果已建立本機 Mutex (也就是說，如果 為 null 或空字串)，或是已建立指定的具名系統 Mutex，則會包含 true 的布林值；如果指定的具名系統 Mutex 已存在，則為 false。這個參數會以未初始化的狀態傳遞。 + 具名的 Mutex 存在，而且具有存取控制安全性，但是使用者沒有 。 + 發生 Win32 錯誤。 + 無法建立具名的 Mutex，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 长度超过 260 个字符。 + + + 開啟指定的具名 mutex (如果已經存在)。 + 表示具名系統 Mutex 的物件。 + 要開啟的系統 Mutex 的名稱。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 具名 Mutex 不存在。 + 發生 Win32 錯誤。 + 具名 Mutex 存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 釋出 一次。 + 呼叫執行緒並不擁有 Mutex。 + 1 + + + 開啟指定的具名 mutex (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名 Mutex，則為 true，否則為 false。 + 要開啟的系統 Mutex 的名稱。 + 當這個方法傳回時，如果呼叫成功，則包含代表具名 Mutex 的 物件；如果呼叫失敗，則為 null。這個參數會被視為未初始化。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 發生 Win32 錯誤。 + 具名 Mutex 存在，但是使用者並沒有使用它所需的安全性存取權。 + + + 代表鎖定，用來管理資源存取，允許多個執行緒的讀取權限或獨佔寫入權限。 + + + 使用預設屬性值，初始化 類別的新執行個體。 + + + 指定鎖定遞迴原則，初始化 類別的新執行個體。 + 一個列舉值，指定鎖定遞迴原則。 + + + 取得已進入讀取模式鎖定狀態的唯一執行緒總數。 + 已進入讀取模式鎖定狀態的唯一執行緒數目。 + + + 釋放 類別目前的執行個體所使用的全部資源。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 嘗試進入讀取模式的鎖定。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 嘗試進入可升級模式的鎖定狀態。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 嘗試進入寫入模式的鎖定。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 減少讀取模式遞迴的計數，如果得出的計數為 0 (零)，則結束讀取模式。 + The current thread has not entered the lock in read mode. + + + 減少可升級模式遞迴的計數，如果得出的計數為 0 (零)，則結束可升級模式。 + The current thread has not entered the lock in upgradeable mode. + + + 減少寫入模式遞迴的計數，如果得出的計數為 0 (零)，則結束寫入模式。 + The current thread has not entered the lock in write mode. + + + 取得值，表示目前執行緒是否已進入讀取模式的鎖定。 + 如果目前執行緒已進入讀取模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前執行緒是否已進入可升級模式的鎖定。 + 如果目前執行緒已進入可升級模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前執行緒是否已進入寫入模式的鎖定。 + 如果目前執行緒已進入寫入模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前 物件的遞迴原則。 + 一個列舉值，指定鎖定遞迴原則。 + + + 取得目前執行緒已進入讀取模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入讀取模式，則為 0 (零)；如果執行緒已進入讀取模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入鎖定 n - 1 次，則為 n。 + 2 + + + 取得目前執行緒已進入可升級模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入可升級模式，則為 0；如果執行緒已進入可升級模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入可升級模式 n - 1 次，則為 n。 + 2 + + + 取得目前執行緒已進入寫入模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入寫入模式，則為 0；如果執行緒已進入寫入模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入寫入模式 n - 1 次，則為 n。 + 2 + + + 嘗試以選用的整數逾時，進入讀取模式的鎖定狀態。 + 如果呼叫執行緒已進入讀取模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在讀取模式下進入鎖定狀態。 + 如果呼叫執行緒已進入讀取模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 嘗試以選用的逾時，在可升級模式下進入鎖定狀態。 + 如果呼叫執行緒已進入可升級模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在可升級模式下進入鎖定狀態。 + 如果呼叫執行緒已進入可升級模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 嘗試以選用的逾時，在寫入模式下進入鎖定狀態。 + 如果呼叫執行緒已進入寫入模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在寫入模式下進入鎖定狀態。 + 如果呼叫執行緒已進入寫入模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 取得等待進入讀取模式鎖定狀態的執行緒總數。 + 等待進入讀取模式的執行緒總數。 + 2 + + + 取得等待進入可升級模式鎖定狀態的執行緒總數。 + 等待進入可升級模式的執行緒總數。 + 2 + + + 取得等待進入寫入模式鎖定狀態的執行緒總數。 + 等待進入寫入模式的執行緒總數。 + 2 + + + 限制可以同時存取資源或資源集區的執行緒數目。 + 1 + + + 初始化 類別的新執行個體，以及指定並行項目的最大數目及選擇性地保留某些項目。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + + 大於 。 + + 为小于 1。-或- 小於 0。 + + + 初始化 類別的新執行個體，然後指定初始項目數目與並行項目的最大數目，以及選擇性地指定系統號誌物件的名稱。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + 具名系統號誌物件的名稱。 + + 大於 。-或- 长度超过 260 个字符。 + + 为小于 1。-或- 小於 0。 + 發生 Win32 錯誤。 + 具名的號誌存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的號誌，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + + 初始化 類別的新執行個體，然後指定初始項目物件數目與並行項目的最大數目，選擇性地指定系統號誌物件的名稱，以及指定接收值的變數，指出是否已建立新的系統號誌。 + 可以同時滿足之號誌要求的初始數目。 + 可以同時滿足之號誌要求的最大數目。 + 具名系統號誌物件的名稱。 + 這個方法傳回時，如果已建立本機號誌 (也就是說，如果 為 null 或空字串)，或是已建立指定的已命名系統號誌，則會包含 true；如果指定的已命名系統號誌已存在則為 false。這個參數會以未初始化的狀態傳遞。 + + 大於 。-或- 长度超过 260 个字符。 + + 为小于 1。-或- 小於 0。 + 發生 Win32 錯誤。 + 具名的號誌存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的號誌，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + + 開啟指定的具名號誌 (如果已經存在)。 + 表示具名系統號誌的物件。 + 要開啟之系統號誌的名稱。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 具名號誌不存在。 + 發生 Win32 錯誤。 + 具名號誌存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 結束號誌，並傳回上一個計數。 + 呼叫 方法之前，號誌上的計數。 + 號誌計數已達到最大值。 + 具名號誌中發生 Win32 錯誤。 + 目前的號誌代表具名系統號誌，但是使用者沒有 。-或-目前的號誌代表具名系統號誌，但是並未以 開啟。 + 1 + + + 以指定的次數結束號誌，並回到上一個計數。 + 呼叫 方法之前，號誌上的計數。 + 結束號誌的次數。 + + 为小于 1。 + 號誌計數已達到最大值。 + 具名號誌中發生 Win32 錯誤。 + 目前的號誌代表具名系統號誌，但是使用者沒有 權限。-或-目前的號誌代表具名系統號誌，但是並未以 權限開啟。 + 1 + + + 開啟指定的具名號誌 (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名號誌，則為 true；否則為 false。 + 要開啟之系統號誌的名稱。 + 這個方法傳回時，如果呼叫成功，則包含 物件，此物件代表具名信號，如果呼叫失敗，則為null。這個參數會被視為未初始化。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 發生 Win32 錯誤。 + 具名號誌存在，但是使用者並沒有使用它所需的安全性存取權。 + + + 在已經達到最大計數的號誌上呼叫 方法時，所擲回的例外狀況。 + 2 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 代表 的輕量型替代品，限制可同時存取一項資源或資源集區的執行緒數目。 + + + 指定可同時授與的初始要求數目，初始化 類別的新執行個體。 + 可同時授與給號誌的初始要求數目。 + + 小於 0。 + + + 指定可同時授與的初始要求數目及最大數目，初始化 類別的新執行個體。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + + 小於 0，或者 大於 ，或者 等於或小於 0。 + + + 傳回可用來等候號誌的 。 + 可用來等候號誌的 。 + + 已經處置。 + + + 取得可以進入 物件的剩餘執行緒數目。 + 可以進入號誌的剩餘執行緒數目。 + + + 釋放 類別目前的執行個體所使用的全部資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 釋出 物件一次。 + + 的先前計數。 + 目前的執行個體已經處置。 + + 已經達到其大小上限。 + + + 釋出 物件指定的次數。 + + 的先前計數。 + 結束號誌的次數。 + 目前的執行個體已經處置。 + + 为小于 1。 + + 已經達到其大小上限。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止。 + 目前的執行個體已經處置。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 32 位元帶正負號的整數來指定逾時。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + 要等候的毫秒數；若要無限期等候，則為 (-1)。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 32 位元帶正負號的整數來指定逾時，同時觀察 。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + 要等候的毫秒數；若要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + 实例已被释放，或 创建 已被释放。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，同時觀察 。 + 要觀察的 語彙基元。 + + 已取消。 + 目前的執行個體已經處置。-或- 创建 已释放。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 來指定逾時。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + semaphoreSlim 執行個體已經處置 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 來指定逾時，同時觀察 。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + semaphoreSlim 執行個體已經處置 已處置建立 的 。 + + + 以非同步方式等候進入 。 + 將會在號誌 (Semaphore) 輸入後完成的工作。 + + + 以非同步方式等候進入 ，並使用 32 位元帶正負號的整數來測量時間間隔。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 以非同步方式等候進入 ，並使用 32 位元帶正負號的整數來測量時間間隔，同時觀察 。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 目前的執行個體已經處置。 + + 已取消。 + + + 以非同步方式等候進入 ，同時觀察 。 + 將會在號誌 (Semaphore) 輸入後完成的工作。 + 要觀察的 語彙基元。 + 目前的執行個體已經處置。 + + 已取消。 + + + 以非同步方式等候進入 ，並使用 來測量時間間隔。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是不等於 -1 的負數，-1 表示等候逾時為無限 -或- 逾時大於 。 + + + 以非同步方式等候進入 ，並使用 來測量時間間隔，同時觀察 。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 要觀察的 語彙基元。 + + 是不等於 -1 的負數，-1 表示等候逾時為無限-或-逾時大於 。 + + 已取消。 + + + 表示要將訊息分派至同步處理內容時，所要呼叫的方法。 + 傳送至委派的物件。 + 2 + + + 提供互斥鎖定基本作業，在這個作業中，嘗試取得鎖定的執行緒會用迴圈方式等候，並重複檢查，直到鎖定可用為止。 + + + 使用可追蹤執行緒 ID 以改善偵錯的選項，初始化 結構的新執行個體。 + 是否要擷取並使用執行緒 ID 以進行偵錯。 + + + 以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 引數必須在呼叫 Enter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 釋放鎖定。 + 已啟用執行緒擁有權追蹤，且目前的執行緒不是這個鎖定的擁有者。 + + + 釋放鎖定。 + 布林值，表示是否應該發出記憶體柵欄，以便立即將結束作業發行至其他執行緒。 + 已啟用執行緒擁有權追蹤，且目前的執行緒不是這個鎖定的擁有者。 + + + 取得值，這個值表示此鎖定目前是否由任何執行緒持有。 + 如果此鎖定目前由任何執行緒持有則為 true，否則為 false。 + + + 取得值，表示此鎖定是否由目前執行緒持有。 + 如果此鎖定由目前執行緒持有則為 true，否則為 false。 + 已停用執行緒擁有權追蹤。 + + + 取得值，表示這個執行個體是否已啟用執行緒擁有權追蹤。 + 如果這個執行個體已啟用執行緒擁有權追蹤則為 true，否則為 false。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 毫秒的逾時。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 提供微調式等候支援。 + + + 取得已在這個執行個體上呼叫 的次數。 + 傳回整數，表示已在這個執行個體上呼叫 的次數。 + + + 取得值，這個值表示下一次呼叫 時是否讓出處理器，並觸發強制的環境切換。 + 下一次呼叫 時是否讓出處理器，並觸發強制的環境切換。 + + + 重設微調計數器。 + + + 執行單一微調。 + + + 執行微調，直到滿足指定的條件為止。 + 會重複執行直到傳回 true 為止的委派。 + + 引數為 null。 + + + 執行微調，直到滿足指定的條件或是指定的逾時過期為止。 + 如果滿足條件則為 true，否則為 false。 + 會重複執行直到傳回 true 為止的委派。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + + 引數為 null。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 執行微調，直到滿足指定的條件或是指定的逾時過期為止。 + 如果滿足條件則為 true，否則為 false。 + 會重複執行直到傳回 true 為止的委派。 + + ，表示要等候的毫秒數，或是 TimeSpan，表示無限期等候的 -1 毫秒。 + + 引數為 null。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 提供在各種同步處理模式中傳播同步處理內容的基本功能。 + 2 + + + 建立 類別的新執行個體。 + + + 在衍生類別中覆寫時，會建立同步處理內容的複本。 + 新的 物件。 + 2 + + + 取得目前執行緒的同步處理內容。 + + 物件，代表目前的同步處理內容。 + 1 + + + 在衍生類別中覆寫時，會回應作業已經完成的通知。 + + + 在衍生類別中覆寫時，會回應作業已經啟動的通知。 + + + 在衍生類別中覆寫時，會將非同步訊息分派至同步處理內容。 + 要呼叫的 委派。 + 傳送至委派的物件。 + 2 + + + 在衍生類別中覆寫時，會將同步訊息分派至同步處理內容。 + 要呼叫的 委派。 + 傳送至委派的物件。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 設定目前的同步處理內容。 + 要設定的 物件。 + 1 + + + + + + 方法要求呼叫端擁有指定 Monitor 的鎖定，但是不擁有鎖定的呼叫端叫用方法時所擲回的例外狀況。 + 2 + + + 使用預設屬性來初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 提供資料的執行緒區域儲存區。 + 指定依個別執行緒儲存的資料型別。 + + + 初始化 執行個體。 + + + 初始化 執行個體。 + 是否要追蹤所有在執行個體上設定的值，並透過屬性將它們公開。 + + + 使用指定的 函式來初始化 的執行個體。 + 當嘗試擷取未事先初始化的 時，系統會叫用 來產生延遲初始化的值。 + + 是 Null 參考 (在 Visual Basic 中為 Nothing)。 + + + 使用指定的 函式來初始化 的執行個體。 + 當嘗試擷取未事先初始化的 時，系統會叫用 來產生延遲初始化的值。 + 是否要追蹤所有在執行個體上設定的值，並透過屬性將它們公開。 + + 為 null 參考 (在 Visual Basic 中為 Nothing)。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放這個 執行個體所使用的資源。 + 布林值，表示是否會因為呼叫 而呼叫這個方法。 + + + 釋放這個 執行個體所使用的資源。 + + + 取得值，這個值表示 是否已在目前執行緒中完成初始化。 + 如果已在目前執行緒上初始化 則為 true，否則為 false。 + 已處置 執行個體。 + + + 建立並傳回目前執行緒的這個執行個體的字串表示。 + 在 上呼叫 的結果。 + 已處置 執行個體。 + 目前執行緒的 是 Null 參考 (在 Visual Basic 中為 Nothing)。 + 初始化函式會嘗試遞迴參考 。 + 沒有提供任何預設的建構函式，也沒有提供任何値 Factory。 + + + 取得或設定目前執行緒的這個執行個體的值。 + 傳回這個 ThreadLocal 負責初始化之物件的執行個體。 + 已處置 執行個體。 + 初始化函式會嘗試遞迴參考 。 + 沒有提供任何預設的建構函式，也沒有提供任何値 Factory。 + + + 取得清單，其中包含已存取這個執行個體的所有執行緒目前所儲存的所有值。 + 已存取這個執行個體的所有執行緒目前所儲存之所有值的清單。 + 已處置 執行個體。 + + + 包含用來執行動態記憶體作業的方法。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 從指定的欄位讀取物件參考。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取之 的參考。這個參考是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + 要讀取之欄位的型別。此型別必須是參考型別，不得為實值型別。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現記憶體作業，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的物件參考寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入物件參考的欄位。 + 要寫入的物件參考。立即寫入此參考，好讓電腦中的所有處理器都可以看到此參考。 + 要寫入之欄位的型別。此型別必須是參考型別，不得為實值型別。 + + + 當嘗試開啟不存在的系統 Mutex 或號誌時，所擲回的例外狀況。 + 2 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/System.Threading.dll b/packages/System.Threading.4.3.0/ref/netstandard1.0/System.Threading.dll new file mode 100644 index 0000000000000000000000000000000000000000..3a68050b1954c52e148131bea64c7f166369f820 GIT binary patch literal 32720 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 k8bWtl4l{N3wSMTjOnmP5dZ)H literal 0 HcmV?d00001 diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/System.Threading.xml new file mode 100644 index 000000000..72254652d --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/System.Threading.xml @@ -0,0 +1,1797 @@ + + + + System.Threading + + + + The exception that is thrown when one thread acquires a object that another thread has abandoned by exiting without releasing it. + 1 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified index for the abandoned mutex, if applicable, and a object that represents the mutex. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Initializes a new instance of the class with a specified error message. + An error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and inner exception. + An error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Initializes a new instance of the class with a specified error message, the inner exception, the index for the abandoned mutex, if applicable, and a object that represents the mutex. + An error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Initializes a new instance of the class with a specified error message, the index of the abandoned mutex, if applicable, and the abandoned mutex. + An error message that explains the reason for the exception. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Gets the abandoned mutex that caused the exception, if known. + A object that represents the abandoned mutex, or null if the abandoned mutex could not be identified. + 1 + + + Gets the index of the abandoned mutex that caused the exception, if known. + The index, in the array of wait handles passed to the method, of the object that represents the abandoned mutex, or –1 if the index of the abandoned mutex could not be determined. + 1 + + + Represents ambient data that is local to a given asynchronous control flow, such as an asynchronous method. + The type of the ambient data. + + + Instantiates an instance that does not receive change notifications. + + + Instantiates an local instance that receives change notifications. + The delegate that is called whenever the current value changes on any thread. + + + Gets or sets the value of the ambient data. + The value of the ambient data. + + + The class that provides data change information to instances that register for change notifications. + The type of the data. + + + Gets the data's current value. + The data's current value. + + + Gets the data's previous value. + The data's previous value. + + + Returns a value that indicates whether the value changes because of a change of execution context. + true if the value changed because of a change of execution context; otherwise, false. + + + Notifies a waiting thread that an event has occurred. This class cannot be inherited. + 2 + + + Initializes a new instance of the class with a Boolean value indicating whether to set the initial state to signaled. + true to set the initial state to signaled; false to set the initial state to non-signaled. + + + Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases. + + + Initializes a new instance of the class. + The number of participating threads. + + is less than 0 or greater than 32,767. + + + Initializes a new instance of the class. + The number of participating threads. + The to be executed after each phase. null (Nothing in Visual Basic) may be passed to indicate no action is taken. + + is less than 0 or greater than 32,767. + + + Notifies the that there will be an additional participant. + The phase number of the barrier in which the new participants will first participate. + The current instance has already been disposed. + Adding a participant would cause the barrier's participant count to exceed 32,767.-or-The method was invoked from within a post-phase action. + + + Notifies the that there will be additional participants. + The phase number of the barrier in which the new participants will first participate. + The number of additional participants to add to the barrier. + The current instance has already been disposed. + + is less than 0.-or-Adding participants would cause the barrier's participant count to exceed 32,767. + The method was invoked from within a post-phase action. + + + Gets the number of the barrier's current phase. + Returns the number of the barrier's current phase. + + + Releases all resources used by the current instance of the class. + The method was invoked from within a post-phase action. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the total number of participants in the barrier. + Returns the total number of participants in the barrier. + + + Gets the number of participants in the barrier that haven’t yet signaled in the current phase. + Returns the number of participants in the barrier that haven’t yet signaled in the current phase. + + + Notifies the that there will be one less participant. + The current instance has already been disposed. + The barrier already has 0 participants.-or-The method was invoked from within a post-phase action. + + + Notifies the that there will be fewer participants. + The number of additional participants to remove from the barrier. + The current instance has already been disposed. + + is less than 0. + The barrier already has 0 participants.-or-The method was invoked from within a post-phase action. -or-current participant count is less than the specified participantCount + The total participant count is less than the specified + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well. + The current instance has already been disposed. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + If an exception is thrown from the post phase action of a Barrier after all participating threads have called SignalAndWait, the exception will be wrapped in a BarrierPostPhaseException and be thrown on all participating threads. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the timeout. + if all participants reached the barrier within the specified time; otherwise false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + If an exception is thrown from the post phase action of a Barrier after all participating threads have called SignalAndWait, the exception will be wrapped in a BarrierPostPhaseException and be thrown on all participating threads. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the timeout, while observing a cancellation token. + if all participants reached the barrier within the specified time; otherwise false + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier, while observing a cancellation token. + The to observe. + + has been canceled. + The current instance has already been disposed. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a object to measure the time interval. + true if all other participants reached the barrier; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out, or it is greater than 32,767. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a object to measure the time interval, while observing a cancellation token. + true if all other participants reached the barrier; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + The exception that is thrown when the post-phase action of a fails + + + Initializes a new instance of the class with a system-supplied message that describes the error. + + + Initializes a new instance of the class with the specified inner exception. + The exception that is the cause of the current exception. + + + Initializes a new instance of the class with a specified message that describes the error. + The message that describes the exception. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The message that describes the exception. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Represents a method to be called within a new context. + An object containing information to be used by the callback method each time it executes. + 1 + + + Represents a synchronization primitive that is signaled when its count reaches zero. + + + Initializes a new instance of class with the specified count. + The number of signals initially required to set the . + + is less than 0. + + + Increments the 's current count by one. + The current instance has already been disposed. + The current instance is already set.-or- is equal to or greater than . + + + Increments the 's current count by a specified value. + The value by which to increase . + The current instance has already been disposed. + + is less than or equal to 0. + The current instance is already set.-or- is equal to or greater than after count is incremented by + + + Gets the number of remaining signals required to set the event. + The number of remaining signals required to set the event. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the numbers of signals initially required to set the event. + The number of signals initially required to set the event. + + + Determines whether the event is set. + true if the event is set; otherwise, false. + + + Resets the to the value of . + The current instance has already been disposed.. + + + Resets the property to a specified value. + The number of signals required to set the . + The current instance has alread been disposed. + + is less than 0. + + + Registers a signal with the , decrementing the value of . + true if the signal caused the count to reach zero and the event was set; otherwise, false. + The current instance has already been disposed. + The current instance is already set. + + + Registers multiple signals with the , decrementing the value of by the specified amount. + true if the signals caused the count to reach zero and the event was set; otherwise, false. + The number of signals to register. + The current instance has already been disposed. + + is less than 1. + The current instance is already set. -or- Or is greater than . + + + Attempts to increment by one. + true if the increment succeeded; otherwise, false. If is already at zero, this method will return false. + The current instance has already been disposed. + + is equal to . + + + Attempts to increment by a specified value. + true if the increment succeeded; otherwise, false. If is already at zero this will return false. + The value by which to increase . + The current instance has already been disposed. + + is less than or equal to 0. + The current instance is already set.-or- + is equal to or greater than . + + + Blocks the current thread until the is set. + The current instance has already been disposed. + + + Blocks the current thread until the is set, using a 32-bit signed integer to measure the timeout. + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until the is set, using a 32-bit signed integer to measure the timeout, while observing a . + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until the is set, while observing a . + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + + Blocks the current thread until the is set, using a to measure the timeout. + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Blocks the current thread until the is set, using a to measure the timeout, while observing a . + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Gets a that is used to wait for the event to be set. + A that is used to wait for the event to be set. + The current instance has already been disposed. + + + Indicates whether an is reset automatically or manually after receiving a signal. + 2 + + + When signaled, the resets automatically after releasing a single thread. If no threads are waiting, the remains signaled until a thread blocks, and resets after releasing the thread. + + + When signaled, the releases all waiting threads and remains signaled until it is manually reset. + + + Represents a thread synchronization event. + 2 + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled, and whether it resets automatically or manually. + true to set the initial state to signaled; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled if created as a result of this call, whether it resets automatically or manually, and the name of a system synchronization event. + true to set the initial state to signaled if the named event is created as a result of this call; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + The name of a system-wide synchronization event. + A Win32 error occurred. + The named event exists and has access control security, but the user does not have . + The named event cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled if created as a result of this call, whether it resets automatically or manually, the name of a system synchronization event, and a Boolean variable whose value after the call indicates whether the named system event was created. + true to set the initial state to signaled if the named event is created as a result of this call; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + The name of a system-wide synchronization event. + When this method returns, contains true if a local event was created (that is, if is null or an empty string) or if the specified named system event was created; false if the specified named system event already existed. This parameter is passed uninitialized. + A Win32 error occurred. + The named event exists and has access control security, but the user does not have . + The named event cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Opens the specified named synchronization event, if it already exists. + An object that represents the named system event. + The name of the system synchronization event to open. + + is an empty string. -or- is longer than 260 characters. + + is null. + The named system event does not exist. + A Win32 error occurred. + The named event exists, but the user does not have the security access required to use it. + 1 + + + + + + Sets the state of the event to nonsignaled, causing threads to block. + true if the operation succeeds; otherwise, false. + The method was previously called on this . + 2 + + + Sets the state of the event to signaled, allowing one or more waiting threads to proceed. + true if the operation succeeds; otherwise, false. + The method was previously called on this . + 2 + + + Opens the specified named synchronization event, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named synchronization event was opened successfully; otherwise, false. + The name of the system synchronization event to open. + When this method returns, contains a object that represents the named synchronization event if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named event exists, but the user does not have the desired security access. + + + Manages the execution context for the current thread. This class cannot be inherited. + 2 + + + Captures the execution context from the current thread. + An object representing the execution context for the current thread. + 1 + + + Runs a method in a specified execution context on the current thread. + The to set. + A delegate that represents the method to be run in the provided execution context. + The object to pass to the callback method. + + is null.-or- was not acquired through a capture operation. -or- has already been used as the argument to a call. + 1 + + + + + + Provides atomic operations for variables that are shared by multiple threads. + 2 + + + Adds two 32-bit integers and replaces the first integer with the sum, as an atomic operation. + The new value stored at . + A variable containing the first value to be added. The sum of the two values is stored in . + The value to be added to the integer at . + The address of is a null pointer. + 1 + + + Adds two 64-bit integers and replaces the first integer with the sum, as an atomic operation. + The new value stored at . + A variable containing the first value to be added. The sum of the two values is stored in . + The value to be added to the integer at . + The address of is a null pointer. + 1 + + + Compares two double-precision floating point numbers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two 32-bit signed integers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two 64-bit signed integers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two platform-specific handles or pointers for equality and, if they are equal, replaces the first one. + The original value in . + The destination , whose value is compared with the value of and possibly replaced by . + The that replaces the destination value if the comparison results in equality. + The that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two objects for reference equality and, if they are equal, replaces the first object. + The original value in . + The destination object that is compared with and possibly replaced. + The object that replaces the destination object if the comparison results in equality. + The object that is compared to the object at . + The address of is a null pointer. + 1 + + + Compares two single-precision floating point numbers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two instances of the specified reference type for equality and, if they are equal, replaces the first one. + The original value in . + The destination, whose value is compared with and possibly replaced. This is a reference parameter (ref in C#, ByRef in Visual Basic). + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The type to be used for , , and . This type must be a reference type. + The address of is a null pointer. + + + Decrements a specified variable and stores the result, as an atomic operation. + The decremented value. + The variable whose value is to be decremented. + The address of is a null pointer. + 1 + + + Decrements the specified variable and stores the result, as an atomic operation. + The decremented value. + The variable whose value is to be decremented. + The address of is a null pointer. + 1 + + + Sets a double-precision floating point number to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a 32-bit signed integer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a 64-bit signed integer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a platform-specific handle or pointer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets an object to a specified value and returns a reference to the original object, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a single-precision floating point number to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a variable of the specified type to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. This is a reference parameter (ref in C#, ByRef in Visual Basic). + The value to which the parameter is set. + The type to be used for and . This type must be a reference type. + The address of is a null pointer. + + + Increments a specified variable and stores the result, as an atomic operation. + The incremented value. + The variable whose value is to be incremented. + The address of is a null pointer. + 1 + + + Increments a specified variable and stores the result, as an atomic operation. + The incremented value. + The variable whose value is to be incremented. + The address of is a null pointer. + 1 + + + Synchronizes memory access as follows: The processor that executes the current thread cannot reorder instructions in such a way that memory accesses before the call to execute after memory accesses that follow the call to . + + + Returns a 64-bit value, loaded as an atomic operation. + The loaded value. + The 64-bit value to be loaded. + 1 + + + Provides lazy initialization routines. + + + Initializes a target reference type with the type's default constructor if it hasn't already been initialized. + The initialized reference of type . + A reference of type to initialize if it has not already been initialized. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference or value type with its default constructor if it hasn't already been initialized. + The initialized value of type . + A reference or value of type to initialize if it hasn't already been initialized. + A reference to a Boolean value that determines whether the target has already been initialized. + A reference to an object used as the mutually exclusive lock for initializing . If is null, a new object will be instantiated. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference or value type by using a specified function if it hasn't already been initialized. + The initialized value of type . + A reference or value of type to initialize if it hasn't already been initialized. + A reference to a Boolean value that determines whether the target has already been initialized. + A reference to an object used as the mutually exclusive lock for initializing . If is null, a new object will be instantiated. + The function that is called to initialize the reference or value. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference type by using a specified function if it hasn't already been initialized. + The initialized value of type . + The reference of type to initialize if it hasn't already been initialized. + The function that is called to initialize the reference. + The reference type of the reference to be initialized. + Type does not have a default constructor. + + returned null (Nothing in Visual Basic). + + + The exception that is thrown when recursive entry into a lock is not compatible with the recursion policy for the lock. + 2 + + + Initializes a new instance of the class with a system-supplied message that describes the error. + 2 + + + Initializes a new instance of the class with a specified message that describes the error. + The message that describes the exception. The caller of this constructor must make sure that this string has been localized for the current system culture. + 2 + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The message that describes the exception. The caller of this constructor must make sure that this string has been localized for the current system culture. + The exception that caused the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + 2 + + + Specifies whether a lock can be entered multiple times by the same thread. + + + If a thread tries to enter a lock recursively, an exception is thrown. Some classes may allow certain recursions when this setting is in effect. + + + A thread can enter a lock recursively. Some classes may restrict this capability. + + + Notifies one or more waiting threads that an event has occurred. This class cannot be inherited. + 2 + + + Initializes a new instance of the class with a Boolean value indicating whether to set the initial state to signaled. + true to set the initial state signaled; false to set the initial state to nonsignaled. + + + Provides a slimmed down version of . + + + Initializes a new instance of the class with an initial state of nonsignaled. + + + Initializes a new instance of the class with a Boolean value indicating whether to set the intial state to signaled. + true to set the initial state signaled; false to set the initial state to nonsignaled. + + + Initializes a new instance of the class with a Boolean value indicating whether to set the intial state to signaled and a specified spin count. + true to set the initial state to signaled; false to set the initial state to nonsignaled. + The number of spin waits that will occur before falling back to a kernel-based wait operation. + + is less than 0 or greater than the maximum allowed value. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets whether the event is set. + true if the event has is set; otherwise, false. + + + Sets the state of the event to nonsignaled, which causes threads to block. + The object has already been disposed. + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed. + + + Gets the number of spin waits that will be occur before falling back to a kernel-based wait operation. + Returns the number of spin waits that will be occur before falling back to a kernel-based wait operation. + + + Blocks the current thread until the current is set. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a 32-bit signed integer to measure the time interval. + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a 32-bit signed integer to measure the time interval, while observing a . + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blocks the current thread until the current receives a signal, while observing a . + The to observe. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blocks the current thread until the current is set, using a to measure the time interval. + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a to measure the time interval, while observing a . + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Gets the underlying object for this . + The underlying event object fore this . + + + Provides a mechanism that synchronizes access to objects. + 2 + + + Acquires an exclusive lock on the specified object. + The object on which to acquire the monitor lock. + The parameter is null. + 1 + + + Acquires an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to wait. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. Note   If no exception occurs, the output of this method is always true. + The input to is true. + The parameter is null. + + + Releases an exclusive lock on the specified object. + The object on which to release the lock. + The parameter is null. + The current thread does not own the lock for the specified object. + 1 + + + Determines whether the current thread holds the lock on the specified object. + true if the current thread holds the lock on ; otherwise, false. + The object to test. + + is null. + + + Notifies a thread in the waiting queue of a change in the locked object's state. + The object a thread is waiting for. + The parameter is null. + The calling thread does not own the lock for the specified object. + 1 + + + Notifies all waiting threads of a change in the object's state. + The object that sends the pulse. + The parameter is null. + The calling thread does not own the lock for the specified object. + 1 + + + Attempts to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + The parameter is null. + 1 + + + Attempts to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + + + Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + The number of milliseconds to wait for the lock. + The parameter is null. + + is negative, and not equal to . + 1 + + + Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The number of milliseconds to wait for the lock. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + + is negative, and not equal to . + + + Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + A representing the amount of time to wait for the lock. A value of –1 millisecond specifies an infinite wait. + The parameter is null. + The value of in milliseconds is negative and is not equal to (–1 millisecond), or is greater than . + 1 + + + Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The amount of time to wait for the lock. A value of –1 millisecond specifies an infinite wait. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + The value of in milliseconds is negative and is not equal to (–1 millisecond), or is greater than . + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. + true if the call returned because the caller reacquired the lock for the specified object. This method does not return if the lock is not reacquired. + The object on which to wait. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + 1 + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. If the specified time-out interval elapses, the thread enters the ready queue. + true if the lock was reacquired before the specified time elapsed; false if the lock was reacquired after the specified time elapsed. The method does not return until the lock is reacquired. + The object on which to wait. + The number of milliseconds to wait before the thread enters the ready queue. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + The value of the parameter is negative, and is not equal to . + 1 + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. If the specified time-out interval elapses, the thread enters the ready queue. + true if the lock was reacquired before the specified time elapsed; false if the lock was reacquired after the specified time elapsed. The method does not return until the lock is reacquired. + The object on which to wait. + A representing the amount of time to wait before the thread enters the ready queue. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + The value of the parameter in milliseconds is negative and does not represent (–1 millisecond), or is greater than . + 1 + + + A synchronization primitive that can also be used for interprocess synchronization. + 1 + + + Initializes a new instance of the class with default properties. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex. + true to give the calling thread initial ownership of the mutex; otherwise, false. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex. + true to give the calling thread initial ownership of the named system mutex if the named system mutex is created as a result of this call; otherwise, false. + The name of the . If the value is null, the is unnamed. + The named mutex exists and has access control security, but the user does not have . + A Win32 error occurred. + The named mutex cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex. + true to give the calling thread initial ownership of the named system mutex if the named system mutex is created as a result of this call; otherwise, false. + The name of the . If the value is null, the is unnamed. + When this method returns, contains a Boolean that is true if a local mutex was created (that is, if is null or an empty string) or if the specified named system mutex was created; false if the specified named system mutex already existed. This parameter is passed uninitialized. + The named mutex exists and has access control security, but the user does not have . + A Win32 error occurred. + The named mutex cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Opens the specified named mutex, if it already exists. + An object that represents the named system mutex. + The name of the system mutex to open. + + is an empty string.-or- is longer than 260 characters. + + is null. + The named mutex does not exist. + A Win32 error occurred. + The named mutex exists, but the user does not have the security access required to use it. + 1 + + + + + + Releases the once. + The calling thread does not own the mutex. + 1 + + + Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named mutex was opened successfully; otherwise, false. + The name of the system mutex to open. + When this method returns, contains a object that represents the named mutex if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named mutex exists, but the user does not have the security access required to use it. + + + Represents a lock that is used to manage access to a resource, allowing multiple threads for reading or exclusive access for writing. + + + Initializes a new instance of the class with default property values. + + + Initializes a new instance of the class, specifying the lock recursion policy. + One of the enumeration values that specifies the lock recursion policy. + + + Gets the total number of unique threads that have entered the lock in read mode. + The number of unique threads that have entered the lock in read mode. + + + Releases all resources used by the current instance of the class. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Tries to enter the lock in read mode. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter. This limit is so large that applications should never encounter it. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The object has been disposed. + + + Tries to enter the lock in write mode. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The object has been disposed. + + + Reduces the recursion count for read mode, and exits read mode if the resulting count is 0 (zero). + The current thread has not entered the lock in read mode. + + + Reduces the recursion count for upgradeable mode, and exits upgradeable mode if the resulting count is 0 (zero). + The current thread has not entered the lock in upgradeable mode. + + + Reduces the recursion count for write mode, and exits write mode if the resulting count is 0 (zero). + The current thread has not entered the lock in write mode. + + + Gets a value that indicates whether the current thread has entered the lock in read mode. + true if the current thread has entered read mode; otherwise, false. + 2 + + + Gets a value that indicates whether the current thread has entered the lock in upgradeable mode. + true if the current thread has entered upgradeable mode; otherwise, false. + 2 + + + Gets a value that indicates whether the current thread has entered the lock in write mode. + true if the current thread has entered write mode; otherwise, false. + 2 + + + Gets a value that indicates the recursion policy for the current object. + One of the enumeration values that specifies the lock recursion policy. + + + Gets the number of times the current thread has entered the lock in read mode, as an indication of recursion. + 0 (zero) if the current thread has not entered read mode, 1 if the thread has entered read mode but has not entered it recursively, or n if the thread has entered the lock recursively n - 1 times. + 2 + + + Gets the number of times the current thread has entered the lock in upgradeable mode, as an indication of recursion. + 0 if the current thread has not entered upgradeable mode, 1 if the thread has entered upgradeable mode but has not entered it recursively, or n if the thread has entered upgradeable mode recursively n - 1 times. + 2 + + + Gets the number of times the current thread has entered the lock in write mode, as an indication of recursion. + 0 if the current thread has not entered write mode, 1 if the thread has entered write mode but has not entered it recursively, or n if the thread has entered write mode recursively n - 1 times. + 2 + + + Tries to enter the lock in read mode, with an optional integer time-out. + true if the calling thread entered read mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in read mode, with an optional time-out. + true if the calling thread entered read mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode, with an optional time-out. + true if the calling thread entered upgradeable mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode, with an optional time-out. + true if the calling thread entered upgradeable mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Tries to enter the lock in write mode, with an optional time-out. + true if the calling thread entered write mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in write mode, with an optional time-out. + true if the calling thread entered write mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Gets the total number of threads that are waiting to enter the lock in read mode. + The total number of threads that are waiting to enter read mode. + 2 + + + Gets the total number of threads that are waiting to enter the lock in upgradeable mode. + The total number of threads that are waiting to enter upgradeable mode. + 2 + + + Gets the total number of threads that are waiting to enter the lock in write mode. + The total number of threads that are waiting to enter write mode. + 2 + + + Limits the number of threads that can access a resource or pool of resources concurrently. + 1 + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + + is greater than . + + is less than 1.-or- is less than 0. + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries, and optionally specifying the name of a system semaphore object. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + The name of a named system semaphore object. + + is greater than .-or- is longer than 260 characters. + + is less than 1.-or- is less than 0. + A Win32 error occurred. + The named semaphore exists and has access control security, and the user does not have . + The named semaphore cannot be created, perhaps because a wait handle of a different type has the same name. + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, and specifying a variable that receives a value indicating whether a new system semaphore was created. + The initial number of requests for the semaphore that can be satisfied concurrently. + The maximum number of requests for the semaphore that can be satisfied concurrently. + The name of a named system semaphore object. + When this method returns, contains true if a local semaphore was created (that is, if is null or an empty string) or if the specified named system semaphore was created; false if the specified named system semaphore already existed. This parameter is passed uninitialized. + + is greater than . -or- is longer than 260 characters. + + is less than 1.-or- is less than 0. + A Win32 error occurred. + The named semaphore exists and has access control security, and the user does not have . + The named semaphore cannot be created, perhaps because a wait handle of a different type has the same name. + + + Opens the specified named semaphore, if it already exists. + An object that represents the named system semaphore. + The name of the system semaphore to open. + + is an empty string.-or- is longer than 260 characters. + + is null. + The named semaphore does not exist. + A Win32 error occurred. + The named semaphore exists, but the user does not have the security access required to use it. + 1 + + + + + + Exits the semaphore and returns the previous count. + The count on the semaphore before the method was called. + The semaphore count is already at the maximum value. + A Win32 error occurred with a named semaphore. + The current semaphore represents a named system semaphore, but the user does not have .-or-The current semaphore represents a named system semaphore, but it was not opened with . + 1 + + + Exits the semaphore a specified number of times and returns the previous count. + The count on the semaphore before the method was called. + The number of times to exit the semaphore. + + is less than 1. + The semaphore count is already at the maximum value. + A Win32 error occurred with a named semaphore. + The current semaphore represents a named system semaphore, but the user does not have rights.-or-The current semaphore represents a named system semaphore, but it was not opened with rights. + 1 + + + Opens the specified named semaphore, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named semaphore was opened successfully; otherwise, false. + The name of the system semaphore to open. + When this method returns, contains a object that represents the named semaphore if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named semaphore exists, but the user does not have the security access required to use it. + + + The exception that is thrown when the method is called on a semaphore whose count is already at the maximum. + 2 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Represents a lightweight alternative to that limits the number of threads that can access a resource or pool of resources concurrently. + + + Initializes a new instance of the class, specifying the initial number of requests that can be granted concurrently. + The initial number of requests for the semaphore that can be granted concurrently. + + is less than 0. + + + Initializes a new instance of the class, specifying the initial and maximum number of requests that can be granted concurrently. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + + is less than 0, or is greater than , or is equal to or less than 0. + + + Returns a that can be used to wait on the semaphore. + A that can be used to wait on the semaphore. + The has been disposed. + + + Gets the number of remaining threads that can enter the object. + The number of remaining threads that can enter the semaphore. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Releases the object once. + The previous count of the . + The current instance has already been disposed. + The has already reached its maximum size. + + + Releases the object a specified number of times. + The previous count of the . + The number of times to exit the semaphore. + The current instance has already been disposed. + + is less than 1. + The has already reached its maximum size. + + + Blocks the current thread until it can enter the . + The current instance has already been disposed. + + + Blocks the current thread until it can enter the , using a 32-bit signed integer that specifies the timeout. + true if the current thread successfully entered the ; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until it can enter the , using a 32-bit signed integer that specifies the timeout, while observing a . + true if the current thread successfully entered the ; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The instance has been disposed, or the that created has been disposed. + + + Blocks the current thread until it can enter the , while observing a . + The token to observe. + + was canceled. + The current instance has already been disposed.-or-The that created has already been disposed. + + + Blocks the current thread until it can enter the , using a to specify the timeout. + true if the current thread successfully entered the ; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + The semaphoreSlim instance has been disposed + + + Blocks the current thread until it can enter the , using a that specifies the timeout, while observing a . + true if the current thread successfully entered the ; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + The semaphoreSlim instance has been disposedThe that created has already been disposed. + + + Asynchronously waits to enter the . + A task that will complete when the semaphore has been entered. + + + Asynchronously waits to enter the , using a 32-bit signed integer to measure the time interval. + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Asynchronously waits to enter the , using a 32-bit signed integer to measure the time interval, while observing a . + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + is a negative number other than -1, which represents an infinite time-out. + The current instance has already been disposed. + + was canceled. + + + Asynchronously waits to enter the , while observing a . + A task that will complete when the semaphore has been entered. + The token to observe. + The current instance has already been disposed. + + was canceled. + + + Asynchronously waits to enter the , using a to measure the time interval. + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out -or- timeout is greater than . + + + Asynchronously waits to enter the , using a to measure the time interval, while observing a . + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The token to observe. + + is a negative number other than -1, which represents an infinite time-out-or-timeout is greater than . + + was canceled. + + + Represents a method to be called when a message is to be dispatched to a synchronization context. + The object passed to the delegate. + 2 + + + Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop repeatedly checking until the lock becomes available. + + + Initializes a new instance of the structure with the option to track thread IDs to improve debugging. + Whether to capture and use thread IDs for debugging purposes. + + + Acquires the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + The argument must be initialized to false prior to calling Enter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Releases the lock. + Thread ownership tracking is enabled, and the current thread is not the owner of this lock. + + + Releases the lock. + A Boolean value that indicates whether a memory fence should be issued in order to immediately publish the exit operation to other threads. + Thread ownership tracking is enabled, and the current thread is not the owner of this lock. + + + Gets whether the lock is currently held by any thread. + true if the lock is currently held by any thread; otherwise false. + + + Gets whether the lock is held by the current thread. + true if the lock is held by the current thread; otherwise false. + Thread ownership tracking is disabled. + + + Gets whether thread ownership tracking is enabled for this instance. + true if thread ownership tracking is enabled for this instance; otherwise false. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + is a negative number other than -1, which represents an infinite time-out. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than milliseconds. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Provides support for spin-based waiting. + + + Gets the number of times has been called on this instance. + Returns an integer that represents the number of times has been called on this instance. + + + Gets whether the next call to will yield the processor, triggering a forced context switch. + Whether the next call to will yield the processor, triggering a forced context switch. + + + Resets the spin counter. + + + Performs a single spin. + + + Spins until the specified condition is satisfied. + A delegate to be executed over and over until it returns true. + The argument is null. + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + True if the condition is satisfied within the timeout; otherwise, false + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The argument is null. + + is a negative number other than -1, which represents an infinite time-out. + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + True if the condition is satisfied within the timeout; otherwise, false + A delegate to be executed over and over until it returns true. + A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. + The argument is null. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Provides the basic functionality for propagating a synchronization context in various synchronization models. + 2 + + + Creates a new instance of the class. + + + When overridden in a derived class, creates a copy of the synchronization context. + A new object. + 2 + + + Gets the synchronization context for the current thread. + A object representing the current synchronization context. + 1 + + + When overridden in a derived class, responds to the notification that an operation has completed. + + + When overridden in a derived class, responds to the notification that an operation has started. + + + When overridden in a derived class, dispatches an asynchronous message to a synchronization context. + The delegate to call. + The object passed to the delegate. + 2 + + + When overridden in a derived class, dispatches a synchronous message to a synchronization context. + The delegate to call. + The object passed to the delegate. + The method was called in a Windows Store app. The implementation of for Windows Store apps does not support the method. + 2 + + + Sets the current synchronization context. + The object to be set. + 1 + + + + + + The exception that is thrown when a method requires the caller to own the lock on a given Monitor, and the method is invoked by a caller that does not own that lock. + 2 + + + Initializes a new instance of the class with default properties. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Provides thread-local storage of data. + Specifies the type of data stored per-thread. + + + Initializes the instance. + + + Initializes the instance. + Whether to track all values set on the instance and expose them through the property. + + + Initializes the instance with the specified function. + The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. + + is a null reference (Nothing in Visual Basic). + + + Initializes the instance with the specified function. + The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. + Whether to track all values set on the instance and expose them via the property. + + is a null reference (Nothing in Visual Basic). + + + Releases all resources used by the current instance of the class. + + + Releases the resources used by this instance. + A Boolean value that indicates whether this method is being called due to a call to . + + + Releases the resources used by this instance. + + + Gets whether is initialized on the current thread. + true if is initialized on the current thread; otherwise false. + The instance has been disposed. + + + Creates and returns a string representation of this instance for the current thread. + The result of calling on the . + The instance has been disposed. + The for the current thread is a null reference (Nothing in Visual Basic). + The initialization function attempted to reference recursively. + No default constructor is provided and no value factory is supplied. + + + Gets or sets the value of this instance for the current thread. + Returns an instance of the object that this ThreadLocal is responsible for initializing. + The instance has been disposed. + The initialization function attempted to reference recursively. + No default constructor is provided and no value factory is supplied. + + + Gets a list for all of the values currently stored by all of the threads that have accessed this instance. + A list for all of the values currently stored by all of the threads that have accessed this instance. + The instance has been disposed. + + + Contains methods for performing volatile memory operations. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the object reference from the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The reference to that was read. This reference is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + The type of field to read. This must be a reference type, not a value type. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a memory operation appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified object reference to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the object reference is written. + The object reference to write. The reference is written immediately so that it is visible to all processors in the computer. + The type of field to write. This must be a reference type, not a value type. + + + The exception that is thrown when an attempt is made to open a system mutex or semaphore that does not exist. + 2 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/de/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/de/System.Threading.xml new file mode 100644 index 000000000..4fb943bbf --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/de/System.Threading.xml @@ -0,0 +1,1799 @@ + + + + System.Threading + + + + Die Ausnahme, die ausgelöst wird, wenn ein Thread ein -Objekt abruft, das von einem anderen Thread abgebrochen wurde, indem das Objekt beim Beenden nicht freigegeben wurde. + 1 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einem festgelegten Index für den abgebrochenen Mutex (falls zutreffend) und einem -Objekt, das den Mutex darstellt. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung und einer festgelegten inneren Ausnahme. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung, der inneren Ausnahme, dem Index für den abgebrochenen Mutex (falls zutreffend) und einem -Objekt, das den Mutex darstellt. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung, dem Index des abgebrochenen Mutex (falls zutreffend) und dem abgebrochenen Mutex. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Ruft den abgebrochenen Mutex ab, das die Ausnahme verursacht hat (falls bekannt). + Ein -Objekt, das den abgebrochenen Mutex darstellt, oder null, wenn der abgebrochene Mutex nicht bestimmt werden konnte. + 1 + + + Ruft den Index des abgebrochenen Mutex ab, der die Ausnahme verursacht hat (falls bekannt). + Der Index des -Objekts, das der abgebrochene Mutex darstellt, im Array von WaitHandles, die an die -Methode übergeben wurden, oder -1, wenn der Index des abgebrochenen Mutex nicht bestimmt werden konnte. + 1 + + + Stellt Umgebungsdaten dar, die für eine angegebene asynchrone Ablaufsteuerung lokal sind, wie etwa eine asynchrone Methode. + Der Typ der Umgebungsdaten. + + + Instanziiert eine -Instanz, die keine Änderungsbenachrichtigungen empfängt. + + + Instanziiert eine lokale -Instanz, die Änderungsbenachrichtigungen empfängt. + Der Delegat, der aufgerufen wird, wenn sich der aktuelle Wert auf einem beliebigen Thread ändert. + + + Ruft den Wert der Umgebungsdaten ab oder legt ihn fest. + Der Wert der Umgebungsdaten. + + + Die Klasse, die -Instanzen, die sich für Änderungsbenachrichtigungen registrieren, Informationen über Datenänderungen zur Verfügung stellt. + Der Typ der Daten. + + + Ruft den aktuellen Wert der Daten ab. + Der aktuelle Wert der Daten. + + + Ruft den vorherigen Wert der Daten ab. + Der vorherige Wert der Daten. + + + Gibt einen Wert zurück, der angibt, ob sich der Wert aufgrund einer Änderung des Ausführungskontexts ändert. + true, wenn sich der Wert aufgrund einer Änderung des Ausführungstexts ändert, andernfalls false. + + + Benachrichtigt einen wartenden Thread über das Eintreten eines Ereignisses.Diese Klasse kann nicht vererbt werden. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf „signalisiert“ festgelegt werden soll. + true, wenn der anfängliche Zustand auf „signalisiert“ festgelegt werden soll. false, wenn der anfängliche Zustand auf „nicht signalisiert“ festgelegt werden soll. + + + Ermöglicht es mehreren Aufgaben, parallel über mehrere Phasen gemeinsam an einem Algorithmus zu arbeiten. + + + Initialisiert eine neue Instanz der -Klasse. + Die Anzahl teilnehmender Threads. + + ist kleiner als 0 oder größer als 32,767. + + + Initialisiert eine neue Instanz der -Klasse. + Die Anzahl teilnehmender Threads. + + , die nach jeder Phase ausgeführt wird. NULL (Nothing in Visual Basic) wird möglicherweise übergeben, um keine Aktion anzugeben. + + ist kleiner als 0 oder größer als 32,767. + + + Benachrichtigt über das Vorhandensein eines weiteren Teilnehmers. + Die Phasennummer der Grenze, an der die neuen Teilnehmer zuerst teilnehmen. + Die aktuelle Instanz wurde bereits freigegeben. + Einen Teilnehmer hinzuzufügen würde verursachen, dass die Teilnehmeranzahl der Barriere 32.767 überschreitet.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Benachrichtigt über das Vorhandensein weiterer Teilnehmer. + Die Phasennummer der Grenze, an der die neuen Teilnehmer zuerst teilnehmen. + Die Anzahl zusätzlicher Teilnehmer, die der Grenze hinzugefügt werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0.– oder –-Teilnehmer hinzuzufügen würde verursachen, dass die Teilnehmeranzahl der Barriere 32.767 überschreitet. + Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Ruft die Nummer der aktuellen Phase der Grenze ab. + Gibt die Nummer der aktuellen Phase der Grenze zurück. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + True, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft die Gesamtanzahl von Teilnehmern für die Grenze ab. + Gibt die Gesamtanzahl von Teilnehmern für die Grenze zurück. + + + Ruft die Anzahl von Teilnehmern für die Grenze ab, die in der aktuellen Phase noch nicht signalisiert haben. + Gibt die Anzahl von Teilnehmern für die Grenze zurück, die in der aktuellen Phase noch nicht signalisiert haben. + + + Benachrichtigt , dass ein Teilnehmer nicht mehr vorhanden ist. + Die aktuelle Instanz wurde bereits freigegeben. + Die Barriere hat bereits 0 Teilnehmer.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Benachrichtigt über die geringere Anzahl von Teilnehmern. + Die Anzahl zusätzlicher Teilnehmer, die aus der Grenze entfernt werden sollen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0. + Die Barriere hat bereits 0 Teilnehmer.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. – oder –aktuelle Teilnehmeranzahl ist kleiner als der angegebene participantCount + Die gesamte Teilnehmeranzahl ist kleiner als der angegebene + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. + Die aktuelle Instanz wurde bereits freigegeben. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + Wenn eine Ausnahme aus der Post-Phasenaktion einer Grenze ausgelöst wird, nachdem alle teilnehmenden Threads SignalAndWait aufgerufen haben, wird die Ausnahme in einer BarrierPostPhaseException umbrochen und für alle teilnehmenden Threads ausgelöst. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet. + wenn alle Teilnehmer die Grenze innerhalb der angegebenen Zeit erreicht haben, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + Wenn eine Ausnahme aus der Post-Phasenaktion einer Grenze ausgelöst wird, nachdem alle teilnehmenden Threads SignalAndWait aufgerufen haben, wird die Ausnahme in einer BarrierPostPhaseException umbrochen und für alle teilnehmenden Threads ausgelöst. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet und ein Abbruchtoken berücksichtigt. + wenn alle Teilnehmer die Grenze innerhalb der angegebenen Zeit erreicht haben, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere erreichen. Dabei wird ein Abbruchtoken überwacht. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird das Zeitintervall mit einem -Objekt gemessen. + True, wenn alle anderen Teilnehmer die Grenze erreicht haben, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, oder er ist größer als 32.767. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird das Zeitintervall mit einem -Objekt gemessen und ein Abbruchtoken berücksichtigt. + True, wenn alle anderen Teilnehmer die Grenze erreicht haben, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1 Millisekunde. Ein Wert von -1 Millisekunde gibt einen unendlichen Timeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Die Ausnahme, die bei einem Fehler der Nachphasenaktion einer ausgelöst wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer vom System generierten Meldung, die den Fehler beschreibt. + + + Initialisiert eine neue Instanz der -Klasse mit der angegebenen internen Ausnahme. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Meldung, die den Fehler beschreibt. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Stellt eine Methode dar, die in einem neuen Kontext aufgerufen werden muss. + Ein Objekt mit den Informationen, die von der Rückrufmethode bei jeder Ausführung verwendet werden. + 1 + + + Stellt einen Synchronisierungsprimitiven dar, der signalisiert wird, wenn seine Anzahl 0 (null) erreicht. + + + Initialisiert eine neue Instanz der -Klasse mit der angegebenen Anzahl. + Die zum Festlegen von ursprünglich erforderliche Anzahl von Signalen. + + ist kleiner als 0. + + + Erhöht die aktuelle Anzahl von um 1. + Die aktuelle Instanz wurde bereits freigegeben. + Die aktuelle Instanz ist bereits festgelegt.– oder – ist größer oder gleich . + + + Erhöht die aktuelle Anzahl von um einen angegebenen Wert. + Der Wert, um den erhöht werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner oder gleich 0. + Die aktuelle Instanz ist bereits festgelegt.– oder – ist größer gleich , nach die Anzahl schrittweise durch erhöht wird. + + + Ruft die Anzahl verbleibender Signale ab, die zum Festlegen des Ereignisses erforderlich sind. + Die Anzahl verbleibender Signale, die zum Festlegen des Ereignisses erforderlich sind. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + True, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft die Anzahl von Signalen ab, die ursprünglich zum Festlegen des Ereignisses erforderlich waren. + Die Anzahl von Signalen, die ursprünglich zum Festlegen des Ereignisses erforderlich waren. + + + Bestimmt, ob das Ereignis festgelegt wurde. + True, wenn das Ereignis festgelegt wurde, andernfalls false. + + + Setzt auf den Wert von zurück. + Die aktuelle Instanz wurde bereits freigegeben. + + + Setzt die -Eigenschaft auf einen angegebenen Wert zurück. + Die zum Festlegen von erforderliche Anzahl von Signalen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0. + + + Registriert ein Signal beim und dekrementiert den Wert von . + True, wenn die Anzahl aufgrund des Signals 0 (null) erreicht hat und das Ereignis festgelegt wurde, andernfalls false. + Die aktuelle Instanz wurde bereits freigegeben. + Die aktuelle Instanz ist bereits festgelegt. + + + Registriert mehrere Signale bei und verringert den Wert von um den angegebenen Wert. + True, wenn die Anzahl aufgrund der Signale 0 (null) erreicht hat und das Ereignis festgelegt wurde, andernfalls false. + Die Anzahl zu registrierender Signale. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 1. + Die aktuelle Instanz ist bereits festgelegt. -oder- ist größer als . + + + Versucht, um eins zu inkrementieren. + True, wenn die Anzahl erfolgreich erhöht wurde, andernfalls false.Wenn bereits 0 (null) ist, gibt diese Methode false zurück. + Die aktuelle Instanz wurde bereits freigegeben. + + ist gleich . + + + Versucht, durch einen angegebenen Wert zu inkrementieren. + True, wenn die Anzahl erfolgreich erhöht wurde, andernfalls false.Wenn bereits 0 (null) ist, wird false zurückgegeben. + Der Wert, um den erhöht werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner oder gleich 0. + Die aktuelle Instanz ist bereits festgelegt.– oder – + ist gleich oder größer als . + + + Blockiert den aktuellen Thread, bis festgelegt wird. + Die aktuelle Instanz wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet wird. + True, wenn festgelegt wurde, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet und ein überwacht wird. + True, wenn festgelegt wurde, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein überwacht wird. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein zum Messen des Timeouts verwendet wird. + True, wenn festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein zum Messen des Zeitintervalls verwendet und ein überwacht wird. + True, wenn festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Ruft ein ab, das verwendet wird, um auf das festzulegende Ereignis zu warten. + Ein , das verwendet wird, um auf das festzulegende Ereignis zu warten. + Die aktuelle Instanz wurde bereits freigegeben. + + + Gibt an, ob eine -Klasse nach dem Empfangen eines Signals automatisch oder manuell zurückgesetzt wird. + 2 + + + Bei Signalisierung wird die -Methode automatisch nach der Freigabe eines einzigen Threads zurückgesetzt.Wenn sich keine Threads in der Warteschlange befinden, bleibt die -Methode solange signalisiert, bis ein Thread blockiert wird. Sie wird zurückgesetzt, nachdem der Thread freigegeben wurde. + + + Bei Signalisierung gibt die -Methode alle wartenden Threads frei. Sie bleibt solange signalisiert, bis sie manuell zurückgesetzt wird. + + + Stellt ein Threadsynchronisierungsereignis dar. + 2 + + + Initialisiert eine neue Instanz der -Klasse und gibt an, ob das WaitHandle anfänglich signalisiert ist und ob es automatisch oder manuell zurückgesetzt wird. + true, wenn der anfängliche Zustand auf signalisiert festgelegt werden soll. false, wenn er auf nicht signalisiert festgelegt werden soll. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + + + Initialisiert eine neue Instanz der -Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses an. + true, um den anfänglichen Zustand auf signalisiert festzulegen, wenn das benannte Ereignis als Ergebnis dieses Aufrufs erstellt wird; false, um den Zustand auf nicht signalisiert festzulegen. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + Der Name eines systemweiten Synchronisierungsereignisses. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Ereignis kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Initialisiert eine neue Instanz der -Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, und ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses und eine boolesche Variable an, deren Wert nach dem Aufruf angibt, ob das benannte Systemereignis erstellt wurde. + true, um den anfänglichen Zustand auf signalisiert festzulegen, wenn das benannte Ereignis als Ergebnis dieses Aufrufs erstellt wird; false, um den Zustand auf nicht signalisiert festzulegen. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + Der Name eines systemweiten Synchronisierungsereignisses. + Enthält nach dem Beenden dieser Methode den Wert true, wenn ein lokales Ereignis erstellt wurde (d. h., wenn gleich null oder eine leere Zeichenfolge ist) oder wenn das angegebene benannte Systemereignis erstellt wurde. Der Wert ist false, wenn das angegebene benannte Systemsereignis bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Ereignis kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist. + Ein Objekt, das das benannte Systemereignis darstellt. + Der Name eines systemweiten Synchronisierungsereignisses, das zu öffnen ist. + + ist eine leere Zeichenfolge. - oder - ist länger als 260 Zeichen. + + ist null. + Das benannte Systemereignis ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Legt den Zustand des Ereignisses auf nicht signalisiert fest, sodass Threads blockiert werden. + true, wenn die Operation erfolgreich ausgeführt wird, andernfalls false. + Die -Methode wurde zuvor für dieses aufgerufen. + 2 + + + Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren. + true, wenn die Operation erfolgreich ausgeführt wird, andernfalls false. + Die -Methode wurde zuvor für dieses aufgerufen. + 2 + + + Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn das benannte Synchronisierungsereignis erfolgreich geöffnet wurde; andernfalls false. + Der Name eines systemweiten Synchronisierungsereignisses, das zu öffnen ist. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Synchronisierungsereignis darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden, der Benutzer verfügt jedoch nicht über den gewünschten Sicherheitszugriff. + + + Verwaltet den Ausführungskontext für den aktuellen Thread.Diese Klasse kann nicht vererbt werden. + 2 + + + Zeichnet den Ausführungskontext des aktuellen Threads auf. + Ein -Objekt, das den Ausführungskontext für den aktuellen Thread darstellt. + 1 + + + Führt für den aktuellen Thread eine Methode in einem angegebenen Ausführungskontext aus. + Der festzulegende . + Ein -Delegat, der die im bereitgestellten Ausführungskontext auszuführende Methode darstellt. + Das Objekt, das an die Rückrufmethode übergeben werden soll. + + ist null.– oder – wurde nicht durch einen Aufzeichnungsvorgang ermittelt. – oder – wurde bereits als Argument für einen Aufruf von verwendet. + 1 + + + + + + Stellt atomare Operationen für Variablen bereit, die von mehreren Threads gemeinsam genutzt werden. + 2 + + + Fügt in einer atomaren Operation zwei 32-Bit-Ganzzahlen hinzu und ersetzt die erste Ganzzahl durch die Summe. + Der unter gespeicherte neue Wert. + Eine Variable, die den ersten Wert enthält, der hinzugefügt werden soll.Die Summe der beiden Werte wird in gespeichert. + Der Wert, der der Ganzzahl in hinzugefügt werden soll. + The address of is a null pointer. + 1 + + + Fügt in einer atomaren Operation zwei 64-Bit-Ganzzahlen hinzu und ersetzt die erste Ganzzahl durch die Summe. + Der unter gespeicherte neue Wert. + Eine Variable, die den ersten Wert enthält, der hinzugefügt werden soll.Die Summe der beiden Werte wird in gespeichert. + Der Wert, der der Ganzzahl in hinzugefügt werden soll. + The address of is a null pointer. + 1 + + + Vergleicht zwei Gleitkommazahlen mit doppelter Genauigkeit hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei 32-Bit-Ganzzahlen mit Vorzeichen hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei 64-Bit-Ganzzahlen mit Vorzeichen hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei plattformspezifische Handles oder Zeiger hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten. + Der ursprüngliche Wert in . + Der Ziel-, dessen Wert mit dem Wert von verglichen und möglicherweise durch ersetzt wird. + Der , der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der , der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Objekte hinsichtlich ihrer Verweisgleichheit und ersetzt bei vorliegender Gleichheit das erste Objekt. + Der ursprüngliche Wert in . + Das Zielobjekt, das mit verglichen und möglicherweise ersetzt wird. + Das Objekt, das das Zielobjekt ersetzt, wenn beim Vergleich Gleichheit festgestellt wird. + Das Objekt, das mit dem Objekt in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Gleitkommazahlen mit einfacher Genauigkeit hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Instanzen des angegebenen Referenztyps hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit die erste. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird.Dies ist ein Verweisparameter (ref in C#, ByRef in Visual Basic). + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + Der Typ, der für , und verwendet werden soll.Dieser Typ muss ein Referenztyp sein. + The address of is a null pointer. + + + Dekrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der dekrementierte Wert. + Die Variable, deren Wert dekrementiert werden soll. + The address of is a null pointer. + 1 + + + Dekrementiert den Wert der angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der dekrementierte Wert. + Die Variable, deren Wert dekrementiert werden soll. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation eine Gleitkommazahl mit doppelter Genauigkeit auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine 32-Bit-Ganzzahl mit Vorzeichen in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine 64-Bit-Ganzzahl mit Vorzeichen in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation ein plattformspezifisches Handle bzw. einen plattformspezifischen Zeiger auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation ein Objekt auf einen angegebenen Wert fest und gibt einen Verweis auf das ursprüngliche Objekt zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation eine Gleitkommazahl mit einfacher Genauigkeit auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine Variable vom angegebenen Typ in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll.Dies ist ein Verweisparameter (ref in C#, ByRef in Visual Basic). + Der Wert, auf den der -Parameter festgelegt ist. + Der Typ, der für und verwendet werden soll.Dieser Typ muss ein Referenztyp sein. + The address of is a null pointer. + + + Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der inkrementierte Wert. + Die Variable, deren Wert inkrementiert werden soll. + The address of is a null pointer. + 1 + + + Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der inkrementierte Wert. + Die Variable, deren Wert inkrementiert werden soll. + The address of is a null pointer. + 1 + + + Synchronisiert den Speicherzugriff wie folgt: Der Prozessor, der den aktuellen Thread ausführt, kann Anweisungen nicht so neu anordnen, dass Speicherzugriffe vor dem Aufruf von nach Speicherzugriffen ausgeführt werden, die nach dem Aufruf von erfolgen. + + + Gibt einen 64-Bit-Wert zurück, der in einer atomaren Operation geladen wird. + Der geladene Wert. + Der zu ladende 64-Bit-Wert. + 1 + + + Stellt verzögerte Initialisierungsroutinen bereit. + + + Initialisiert einen Zielverweistyp mit seinem Standardkonstruktor, wenn er noch nicht initialisiert wurde. + Der initialisierte Verweis vom Typ . + Ein Verweis vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweis- oder Werttyp mit seinem Standardkonstruktor, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Ein Verweis oder Wert vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Ein Verweis auf einen booleschen Wert, der bestimmt, ob das Ziel bereits initialisiert wurde. + Ein Verweis auf ein Objekt, das für die Initialisierung von als sich gegenseitig ausschließende Sperre verwendet wird.Wenn null ist, wird ein neues Objekt instanziiert. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweis- oder Werttyp mit einer angegebenen Funktion, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Ein Verweis oder Wert vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Ein Verweis auf einen booleschen Wert, der bestimmt, ob das Ziel bereits initialisiert wurde. + Ein Verweis auf ein Objekt, das für die Initialisierung von als sich gegenseitig ausschließende Sperre verwendet wird.Wenn null ist, wird ein neues Objekt instanziiert. + Die Funktion, die aufgerufen wird, um den Verweis oder den Wert zu initialisieren. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweistyp mit einer angegebenen Funktion, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Der Verweis vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Die Funktion, die aufgerufen wird, um den Verweis zu initialisieren. + Der Verweistyp des zu initialisierenden Verweises. + Der Typ besitzt keinen Standardkonstruktor. + + gibt null (Nothing in Visual Basic) zurück. + + + Die Ausnahme, die ausgelöst wird, wenn die rekursive Anforderung einer Sperre nicht mit der Rekursionsrichtlinie der Sperre kompatibel ist. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer vom System generierten Meldung, die den Fehler beschreibt. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Meldung, die den Fehler beschreibt. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die aktuelle Ausnahme verursacht hat.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + 2 + + + Gibt an, ob eine Sperre mehrmals dem gleichen Thread zugewiesen werden kann. + + + Wenn ein Thread rekursiv versucht, eine Sperre zu erhalten, wird eine Ausnahme ausgelöst.Einige Klassen gestatten gewisse Rekursionen, wenn diese Einstellung aktiv ist. + + + Ein Thread kann rekursiv eine Sperre erhalten.Einige Klassen beschränken diese Möglichkeit einer rekursiven Zuweisung. + + + Benachrichtigt einen oder mehrere wartende Threads über das Eintreten eines Ereignisses.Diese Klasse kann nicht vererbt werden. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf signalisiert festgelegt werden soll. + true, wenn der anfängliche Zustand auf signalisiert festgelegt werden soll, false, wenn der anfängliche Zustand auf nicht signalisiert festgelegt werden soll. + + + Stellt eine verschlankte Version von bereit. + + + Initialisiert eine neue Instanz der -Klasse mit dem Anfangszustand „nicht signalisiert“. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der Anfangszustand auf „signalisiert“ festgelegt werden soll. + True, um den Anfangszustand auf „signalisiert“ festzulegen, false um den Anfangszustand auf „nicht signalisiert“ festzulegen. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der Anfangszustand auf „signalisiert“ festgelegt werden soll, und einer festgelegten Spin-Anzahl. + True, um den Anfangszustand auf "signalisiert" festzulegen, false um den Anfangszustand auf "nicht signalisiert" festzulegen. + Die Anzahl von Spin-Wartevorgängen, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + + is less than 0 or greater than the maximum allowed value. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft einen Wert ab, der angibt, ob das Ereignis festgelegt wurde. + True, wenn das Ereignis festgelegt wurde, andernfalls false. + + + Legt den Zustand des Ereignisses auf „nicht signalisiert“ fest, sodass Threads blockiert werden. + The object has already been disposed. + + + Legt den Zustand des Ereignisses auf „signalisiert“ fest und ermöglicht so die weitere Ausführung eines oder mehrerer wartender Threads. + + + Ruft die Anzahl von Spin-Wartevorgängen ab, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + Gibt die Anzahl von Spin-Wartevorgängen zurück, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird. + true, wenn der festgelegt wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet und ein überwacht wird. + true, wenn der festgelegt wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle ein Signal empfängt, wobei ein überwacht wird. + Das zu überwachende . + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei ein -Wert zum Messen des Zeitintervalls verwendet wird. + true, wenn der festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird. Dabei wird ein -Wert zum Messen des Zeitintervalls verwendet und ein überwacht. + true, wenn der festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Ruft das zugrunde liegende -Objekt für dieses ab. + Das zugrunde liegende -Ereignisobjekt für dieses . + + + Stellt einen Mechanismus bereit, der den Zugriff auf Objekte synchronisiert. + 2 + + + Erhält eine exklusive Sperre für das angegebene Objekt. + Das Objekt, für das die Monitorsperre erhalten werden soll. + Der -Parameter ist null. + 1 + + + Erhält eine exklusive Sperre für das angegebene Objekt und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, auf das gewartet werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen.Hinweis   Wenn keine Ausnahme auftritt, ist die Ausgabe dieser Methode immer true. + Die Eingabe für ist true. + Der -Parameter ist null. + + + Hebt eine exklusive Sperre für das angegebene Objekt auf. + Das Objekt, dessen Sperre aufgehoben werden soll. + Der -Parameter ist null. + Der aktuelle Thread besitzt die Sperre für das angegebene Objekt nicht. + 1 + + + Bestimmt, ob der aktuelle Thread die Sperre für das angegebene Objekt enthält. + true, wenn der aktuelle Thread die Sperre für enthält, andernfalls false. + Das zu überprüfende Objekt. + + ist null. + + + Benachrichtigt einen Thread in der Warteschlange für abzuarbeitende Threads über eine Änderung am Zustand des gesperrten Objekts. + Das Objekt, auf das ein Thread wartet. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + 1 + + + Benachrichtigt alle wartenden Threads über eine Änderung am Zustand des Objekts. + Das Objekt, das den Impuls sendet. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + 1 + + + Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Der -Parameter ist null. + 1 + + + Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + + + Versucht über eine angegebene Anzahl von Millisekunden hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Die Anzahl der Millisekunden, für die auf die Sperre gewartet werden soll. + Der -Parameter ist null. + + ist negativ und ungleich . + 1 + + + Versucht für die angegebene Anzahl von Millisekunden, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Die Anzahl der Millisekunden, für die auf die Sperre gewartet werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + + ist negativ und ungleich . + + + Versucht über einen angegebenen Zeitraum hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Eine , die die Zeitspanne darstellt, für die auf die Sperre gewartet werden soll.Ein Wert von -1 Millisekunde gibt eine unbegrenzte Wartezeit an. + Der -Parameter ist null. + Der Wert von in Millisekunden ist negativ und ungleich (-1 Millisekunde), oder er ist größer als . + 1 + + + Versucht für die angegebene Dauer, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Die Zeitspanne, für die auf die Sperre gewartet werden soll.Ein Wert von -1 Millisekunde gibt eine unbegrenzte Wartezeit an. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + Der Wert von in Millisekunden ist negativ und ungleich (-1 Millisekunde), oder er ist größer als . + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält. + true, wenn der Aufruf beendet wurde, weil der Aufrufer die Sperre für das angegebene Objekt erneut erhalten hat.Diese Methode wird nicht beendet, wenn die Sperre nicht erneut erhalten wird. + Das Objekt, auf das gewartet werden soll. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + 1 + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält.Wenn das angegebene Timeoutintervall abläuft, tritt der Thread in die Warteschlange für abgearbeitete Threads ein. + true, wenn die Sperre erneut erhalten wurde, bevor die angegebene Zeitspanne verstrichen ist. false, wenn die Sperre erneut erhalten wurde, nachdem die angegebene Zeitspanne verstrichen ist.Die Methode wird erst beendet, wenn die Sperre erneut erhalten wurde. + Das Objekt, auf das gewartet werden soll. + Die Anzahl von Millisekunden, die gewartet wird, bevor der Thread in die Warteschlange für abgearbeitete Threads eintritt. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + Der Wert des -Parameters ist negativ und ungleich . + 1 + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält.Wenn das angegebene Timeoutintervall abläuft, tritt der Thread in die Warteschlange für abgearbeitete Threads ein. + true, wenn die Sperre erneut erhalten wurde, bevor die angegebene Zeitspanne verstrichen ist. false, wenn die Sperre erneut erhalten wurde, nachdem die angegebene Zeitspanne verstrichen ist.Die Methode wird erst beendet, wenn die Sperre erneut erhalten wurde. + Das Objekt, auf das gewartet werden soll. + Ein , der die Zeit angibt, die gewartet wird, bevor der Thread in die Warteschlange für abgearbeitete Threads eintritt. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + Der Wert des -Parameters in Millisekunden ist negativ und stellt nicht (-1 Millisekunde) dar, oder er ist größer als . + 1 + + + Ein primitiver Synchronisierungstyp, der auch für die prozessübergreifende Synchronisierung verwendet werden kann. + 1 + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaften. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll. + true, um dem aufrufenden Thread den anfänglichen Besitz des Mutex zuzuweisen, andernfalls false. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, sowie mit einer Zeichenfolge, die den Namen des Mutex darstellt. + true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false. + Der Name des .Bei einem Wert von null ist das unbenannt. + Der benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex sowie mit einem booleschen Wert, der beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde. + true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false. + Der Name des .Bei einem Wert von null ist das unbenannt. + Enthält nach dem Beenden dieser Methode einen booleschen Wert, der true ist, wenn ein lokaler Mutex erstellt wurde (d. h. wenn gleich null oder eine leere Zeichenfolge ist) oder wenn der angegebene benannte Systemmutex erstellt wurde. Der Wert ist false, wenn der angegebene benannte Systemmutex bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + Der benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist. + Ein Objekt, das den benannten Systemmutex darstellt. + Der Name des zu öffnenden Systemmutex. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Der benannte Mutex ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex ist vorhanden, der Benutzer verfügt jedoch nicht über den erforderlichen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Gibt das einmal frei. + Der aufrufende Thread ist nicht im Besitz des Mutex. + 1 + + + Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn der benannte Mutex erfolgreich geöffnet wurde; andernfalls false. + Der Name des zu öffnenden Systemmutex. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Mutex darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex ist vorhanden, der Benutzer verfügt jedoch nicht über den erforderlichen Sicherheitszugriff, um es zu verwenden. + + + Stellt eine Sperre dar, mit der der Zugriff auf eine Ressource verwaltet wird. Mehrere Threads können hierbei Lesezugriff oder exklusiven Schreibzugriff erhalten. + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaftswerten. + + + Initialisiert eine neue Instanz der -Klasse unter Angabe der Rekursionsrichtlinie für die Sperre. + Einer der Enumerationswerte, der die Rekursionsrichtlinie für die Sperre angibt. + + + Ruft die Gesamtzahl von eindeutigen Threads ab, denen die Sperre im Lesemodus zugewiesen ist. + Die Anzahl von eindeutigen Threads, denen die Sperre im Lesemodus zugewiesen ist. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Versucht, die Sperre im Lesemodus zu erhalten. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Verringert die Rekursionszahl für den Lesemodus und beendet den Lesemodus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in read mode. + + + Verringert die Rekursionszahl für den erweiterbaren Modus und beendet den erweiterbaren Modus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in upgradeable mode. + + + Verringert die Rekursionszahl für den Schreibmodus und beendet den Schreibmodus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in write mode. + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im Lesemodus zugewiesen ist. + true, wenn sich der aktuelle Thread im Lesemodus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im erweiterbaren Modus zugewiesen ist. + true, wenn sich der aktuelle Thread im erweiterbaren Modus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im Schreibmodus zugewiesen ist. + true, wenn sich der aktuelle Thread im Schreibmodus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der die Rekursionsrichtlinie für das aktuelle -Objekt angibt. + Einer der Enumerationswerte, der die Rekursionsrichtlinie für die Sperre angibt. + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im Lesemodus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im Lesemodus befindet, 1, wenn sich der Thread im Lesemodus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread die Sperre n - 1 Mal rekursiv angefordert hat. + 2 + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im erweiterbaren Modus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im erweiterbaren Modus befindet, 1, wenn sich der Thread im erweiterbaren Modus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread den erweiterbaren Modus n - 1 Mal rekursiv angefordert hat. + 2 + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im Schreibmodus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im Schreibmodus befindet, 1, wenn sich der Thread im Schreibmodus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread den Schreibmodus n - 1 Mal rekursiv angefordert hat. + 2 + + + Versucht, die Sperre im Lesemodus zu erhalten. Optional wird ein ganzzahliger Timeout berücksichtigt. + true, wenn der aufrufende Thread den Lesemodus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im Lesemodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Lesemodus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den erweiterbaren Modus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den erweiterbaren Modus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Schreibmodus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Schreibmodus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im Lesemodus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des Lesemodus warten. + 2 + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im erweiterbaren Modus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des erweiterbaren Modus warten. + 2 + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im Schreibmodus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des Schreibmodus warten. + 2 + + + Schränkt die Anzahl von Threads ein, die gleichzeitig auf eine Ressource oder einen Pool von Ressourcen zugreifen können. + 1 + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen an. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist größer als . + + ist kleiner als 1.- oder - ist kleiner als 0. + + + Initialisiert eine neue Instanz der -Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen sowie optional den Namen eines Systemsemaphorobjekts an. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Der Name eines benannten Systemsemaphorobjekts. + + ist größer als .- oder - ist länger als 260 Zeichen. + + ist kleiner als 1.- oder - ist kleiner als 0. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Semaphor kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + + Initialisiert eine neue Instanz der -Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen sowie optional den Namen eines Systemsemaphorobjekts an, gibt eine Variable an, die einen Wert empfängt, der angibt, ob ein neues Systemsemaphor erstellt wurde. + Die ursprüngliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig ausgeführt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig ausgeführt werden können. + Der Name eines benannten Systemsemaphorobjekts. + Enthält nach dem Beenden dieser Methode den Wert true, wenn ein lokales Semaphor erstellt wurde (d. h., wenn gleich null oder eine leere Zeichenfolge ist) oder wenn das angegebene benannte Systemsemaphor erstellt wurde. Der Wert ist false, wenn das angegebene benannte Systemsemaphor bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + + ist größer als . - oder - ist länger als 260 Zeichen. + + ist kleiner als 1.- oder - ist kleiner als 0. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Semaphor kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + + Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist. + Ein Objekt, das das benannte Systemsemaphor darstellt. + Der Name des zu öffnenden Systemsemaphors. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Das benannte Semaphor ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Beendet das Semaphor und gibt die vorherige Anzahl zurück. + Die Anzahl für das Semaphor vor dem Aufruf der -Methode. + Die Anzahl für das Semaphor weist bereits den maximalen Wert auf. + Bei einem benannten Semaphor ist ein Win32-Fehler aufgetreten. + Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar. Der Benutzer verfügt jedoch nicht über .- oder - Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar, es wurde jedoch nicht mit geöffnet. + 1 + + + Gibt das Semaphor eine festgelegte Anzahl von Malen frei und gibt die vorherige Anzahl zurück. + Die Anzahl für das Semaphor vor dem Aufruf der -Methode. + Die Anzahl von Malen, die das Semaphor freigegeben werden soll. + + ist kleiner als 1. + Die Anzahl für das Semaphor weist bereits den maximalen Wert auf. + Bei einem benannten Semaphor ist ein Win32-Fehler aufgetreten. + Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar. Der Benutzer verfügt jedoch nicht über -Rechte.- oder - Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar, es wurde jedoch nicht mit -Rechten geöffnet. + 1 + + + Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn das benannte Semaphor erfolgreich geöffnet wurde; andernfalls false. + Der Name des zu öffnenden Systemsemaphors. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Semaphor darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + + + Die Ausnahme, die ausgelöst wird, wenn die -Methode für ein Semaphor aufgerufen wird, dessen Zähler bereits den Maximalwert aufweist. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Eine einfache Alternative zu , die die Anzahl der Threads beschränkt, die gleichzeitig auf eine Ressource oder einen Ressourcenpool zugreifen können. + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche Anzahl von Anforderungen an, die gleichzeitig gewährt werden können. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist kleiner als 0. + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche sowie die maximale Anzahl von Anforderungen an, die gleichzeitig gewährt werden können. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist kleiner als 0, oder ist größer als , oder ist kleiner gleich 0. + + + Gibt ein zurück, das verwendet werden kann um auf die Semaphore zu warten. + Ein , das verwendet werden kann um auf die Semaphore zu warten. + + wurde verworfen. + + + Ruft die Anzahl der verbleibenden Threads ab, für die das Eintreten in das -Objekt zulässig ist. + Die Anzahl der verbleibenden Threads, für die das Eintreten in das Semaphor zulässig ist. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt das -Objekt einmal frei. + Die vorherige Anzahl von . + Die aktuelle Instanz wurde bereits freigegeben. + Der hat bereits seine maximale Größe erreicht. + + + Gibt das -Objekt eine festgelegte Anzahl von Malen frei. + Die vorherige Anzahl von . + Die Anzahl von Malen, die das Semaphor freigegeben werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 1. + Der hat bereits seine maximale Größe erreicht. + + + Blockiert den aktuellen Thread, bis er in eintreten kann. + Die aktuelle Instanz wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei das Timeout mit einer 32-Bit-Ganzzahl mit Vorzeichen angegeben wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Timeouts verwendet und ein überwacht wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Instanz wurde freigegeben, oder die erstellten freigegeben wurde. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei ein überwacht wird. + Das zu überwachende -Token. + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben.- oder - Die erstellten bereits freigegeben wurde. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei ein zum Angeben des Timeouts verwendet wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + Die semaphoreSlim-Instanz wurde freigegeben + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei eine den Timeout angibt und ein überwacht wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + Die semaphoreSlim-Instanz wurde freigegebenDie , die erstellt hat, wurde bereits freigegeben. + + + Wartet asynchron auf den Eintritt in . + Eine Aufgabe, die abgeschlossen wird, wenn das Semaphor eingegeben wurde. + + + Wartet asynchron auf den Zutritt zum , wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Wartet asynchron auf den Zutritt zum , wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird, während ein beobachtet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die aktuelle Instanz wurde bereits freigegeben. + + wurde abgebrochen. + + + Wartet asynchron auf den Zutritt zum , während ein ein beobachtet wird. + Eine Aufgabe, die abgeschlossen wird, wenn das Semaphor eingegeben wurde. + Das zu überwachende -Token. + Die aktuelle Instanz wurde bereits freigegeben. + + wurde abgebrochen. + + + Wartet asynchron auf den Zutritt zum unter Verwendung einer zum Messen des Zeitintervalls. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. - oder - Timeout ist größer als . + + + Wartet asynchron auf den Zutritt zum unter Verwendung einer zum Messen des Zeitintervalls, während ein beobachtet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende -Token. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an.- oder - Timeout ist größer als . + + wurde abgebrochen. + + + Stellt eine Methode dar, die aufgerufen werden muss, wenn eine Nachricht an einen Synchronisierungskontext gesendet werden soll. + Das an den Delegaten übergebene Objekt. + 2 + + + Stellt einen sich gegenseitig ausschließenden Sperrprimitiven bereit, wobei ein Thread, der versucht, die Sperre abzurufen, wiederholt in einer Schleife wartet, bis die Sperre verfügbar wird. + + + Initialisiert eine neue Instanz der -Struktur mit der Option, Thread-IDs nachzuverfolgen, um das Debuggen zu vereinfachen. + Gibt an, ob Thread-IDs zu Debugzwecken erfasst und verwendet werden. + + + Ruft die Sperre zuverlässig ab, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + Das -Argument muss vor dem Aufrufen von Enter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Hebt die Sperre auf. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread ist nicht Besitzer dieser Sperre. + + + Hebt die Sperre auf. + Ein boolescher Wert, der angibt, ob eine Arbeitsspeicherumgrenzung ausgegeben werden soll, um den Beendigungsvorgang sofort für andere Threads zu veröffentlichen. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread ist nicht Besitzer dieser Sperre. + + + Ruft einen Wert ab, der angibt, ob die Sperre zurzeit von einem Thread verwendet wird. + True, wenn die Sperre zurzeit von einem Thread verwendet wird, andernfalls false. + + + Ruft einen Wert ab, der angibt, ob die Sperre vom aktuellen Thread verwendet wird. + True, wenn die Sperre vom aktuellen Thread verwendet wird, andernfalls false. + Die Threadbesitznachverfolgung wird deaktiviert. + + + Ruft einen Wert ab, der angibt, ob die Threadbesitznachverfolgung für diese Instanz aktiviert ist. + True, wenn die Threadbesitznachverfolgung für diese Instanz aktiviert ist, andernfalls false. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als Millisekunden. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Stellt Unterstützung für Spin-basierte Wartevorgänge bereit. + + + Ruft die Anzahl von -Aufrufen für diese Instanz ab. + Gibt eine ganze Zahl zurück, die angibt, wie häufig für diese Instanz aufgerufen wurde. + + + Ruft einen Wert ab, der angibt, ob der nächste Aufruf von den Prozessor ergibt und einen erzwungenen Kontextwechsel auslöst. + Gibt an, ob der nächste Aufruf von den Prozessor ergibt und einen erzwungenen Kontextwechsel auslöst. + + + Setzt die Spin-Anzahl zurück. + + + Führt einen Spin-Vorgang aus. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Das -Argument ist Null. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird oder das angegebene Timeout abgelaufen ist. + True, wenn die Bedingung innerhalb des Timeouts erfüllt wird, andernfalls false. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das -Argument ist Null. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird oder das angegebene Timeout abgelaufen ist. + True, wenn die Bedingung innerhalb des Timeouts erfüllt wird, andernfalls false. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Ein , das die Wartezeit in Millisekunden darstellt, oder ein TimeSpan-Wert, der -1 Millisekunden für Warten ohne Timeout darstellt. + Das -Argument ist Null. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Stellt die Grundfunktionen für die Weitergabe eines Synchronisierungskontexts in unterschiedlichen Synchronisierungsmodellen bereit. + 2 + + + Erstellt eine neue Instanz der -Klasse. + + + Erstellt beim Überschreiben in einer abgeleiteten Klasse eine Kopie des Synchronisierungskontexts. + Ein neues -Objekt. + 2 + + + Ruft den Synchronisierungskontext für den aktuellen Thread ab. + Ein -Objekt, das den aktuellen Synchronisierungskontext darstellt. + 1 + + + Antwortet beim Überschreiben in einer abgeleiteten Klasse auf die Benachrichtigung, dass ein Vorgang abgeschlossen wurde. + + + Antwortet beim Überschreiben in einer abgeleiteten Klasse auf die Benachrichtigung, dass ein Vorgang gestartet wurde. + + + Sendet beim Überschreiben in einer abgeleiteten Klasse eine asynchrone Meldung an einen Synchronisierungskontext. + Der aufzurufende -Delegat. + Das an den Delegaten übergebene Objekt. + 2 + + + Sendet beim Überschreiben in einer abgeleiteten Klasse eine synchrone Meldung an einen Synchronisierungskontext. + Der aufzurufende -Delegat. + Das an den Delegaten übergebene Objekt. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Legt den aktuellen Synchronisierungskontext fest. + Das festzulegende -Objekt. + 1 + + + + + + Die Ausnahme, die ausgelöst wird, wenn der Aufrufer für eine Methode über eine Sperre für einen bestimmten Monitor verfügen muss und die Methode von einem Aufrufer aufgerufen wird, der nicht über diese Sperre verfügt. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaften. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Stellt einen lokalen Datenspeicher eines Threads bereit. + Gibt den für jeden Thread gespeicherten Datentyp an. + + + Initialisiert die -Instanz. + + + Initialisiert die -Instanz. + Ob alle Werte, die für die Instanz festgelegt werden, verfolgt werden und über die -Eigenschaft verfügbar gemacht sollen. + + + Initialisiert die -Instanz mit der angegebenen -Funktion. + Das , das aufgerufen wird, um einen verzögert initialisierten Wert zu erzeugen, wenn versucht wird, ohne vorherige Initialisierung abzurufen. + + ist ein NULL-Verweis (Nothing in Visual Basic). + + + Initialisiert die -Instanz mit der angegebenen -Funktion. + Das , das aufgerufen wird, um einen verzögert initialisierten Wert zu erzeugen, wenn versucht wird, ohne vorherige Initialisierung abzurufen. + Ob alle Werte, die für die Instanz festgelegt werden, verfolgt werden und über die -Eigenschaft verfügbar gemacht sollen. + + ist ein null-Verweis (Nothing in Visual Basic). + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von dieser -Instanz verwendeten Ressourcen frei. + Ein boolescher Wert, der angibt, ob diese Methode aufgrund eines Aufrufs von aufgerufen wird. + + + Gibt die von dieser -Instanz verwendeten Ressourcen frei. + + + Ruft einen Wert ab, der angibt, ob für den aktuellen Thread initialisiert wurde. + True, wenn erfolgreich im aktuellen Thread initialisiert wurde, andernfalls false. + Die -Instanz wurde freigegeben. + + + Erstellt eine Zeichenfolgendarstellung dieser Instanz für den aktuellen Thread und gibt sie zurück. + Das Ergebnis des Aufrufs von für . + Die -Instanz wurde freigegeben. + Der für den aktuellen Thread ist ein NULL-Verweis (Nothing in Visual Basic). + Die Initialisierungsfunktion versuchte, auf rekursiv zu verweisen. + Kein Standardkonstruktor wird bereitgestellt, und keine Wertfactory wird angegeben. + + + Ruft den Wert dieser Instanz für den aktuellen Thread ab oder legt ihn fest. + Gibt eine Instanz des Objekts zurück, für dessen Initialisierung dieser ThreadLocal zuständig ist. + Die -Instanz wurde freigegeben. + Die Initialisierungsfunktion versuchte, auf rekursiv zu verweisen. + Kein Standardkonstruktor wird bereitgestellt, und keine Wertfactory wird angegeben. + + + Ruft eine Liste aller Werte ab, die aktuell von allen Threads, die auf diese Instanz zugegriffen haben, gespeichert werden. + Eine Liste aller Werte, die aktuell von allen Threads, die auf diese Instanz zugegriffen haben, gespeichert sind. + Die -Instanz wurde freigegeben. + + + Enthält Methoden für die Durchführung von Vorgängen für flüchtigen Speicher. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Objektverweis aus dem angegebenen Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der Verweis auf , der gelesen wurde.Dieser Verweis entspricht dem letzten von einem Prozessor im Computer geschriebenen Verweis, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + Der Typ des zu lesenden Felds.Dabei muss es sich um einen Verweistyp und keinen Werttyp handeln. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Arbeitsspeichervorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Objektverweis in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Objektverweis geschrieben wird. + Der zu schreibende Objektverweis.Der Verweis wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + Der Typ des zu schreibenden Felds.Dabei muss es sich um einen Verweistyp und keinen Werttyp handeln. + + + Die Ausnahme, die ausgelöst wird, wenn versucht wird, einen nicht vorhandenen Systemmutex oder ein nicht vorhandenes Semaphor zu öffnen. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/es/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/es/System.Threading.xml new file mode 100644 index 000000000..3431de9eb --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/es/System.Threading.xml @@ -0,0 +1,1803 @@ + + + + System.Threading + + + + Excepción que se produce cuando un subproceso adquiere un objeto que otro subproceso ha abandonado al salir sin liberarlo. + 1 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con un índice especificado para la exclusión mutua abandonada, si es aplicable, y un objeto que representa la exclusión mutua. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con un mensaje de error y una excepción interna especificados. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado, la excepción interna, el índice para la exclusión mutua abandonada, si es aplicable, y un objeto que representa la exclusión mutua. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado, el índice de la exclusión mutua abandonada, si es aplicable, y la exclusión mutua abandonada. + Mensaje de error que explica la razón de la excepción. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Obtiene la exclusión mutua abandonada que produjo la excepción, si se conoce. + Objeto que representa la exclusión mutua abandonada o null si no se han podido identificar las exclusiones mutuas abandonadas. + 1 + + + Obtiene el índice de la exclusión mutua abandonada que produjo la excepción, si se conoce. + Índice, en la matriz de identificadores de espera que se ha pasado al método , del objeto que representa la exclusión mutua abandonada, o –1 si no se puede determinar el índice de la exclusión mutua abandonada. + 1 + + + Representa datos ambiente locales de un flujo de control asincrónico determinado, por ejemplo, un método asincrónico. + Tipo de los datos ambiente. + + + Crea una instancia que no recibe las notificaciones de cambio. + + + Crea una instancia local que recibe notificaciones de cambio. + Delegado al que se llama cuando cambia el valor actual en cualquier subproceso. + + + Obtiene o establece el valor de los datos ambiente. + Valor de los datos ambiente. + + + Clase que proporciona información de cambio de datos a las instancias que se registran para las notificaciones de cambios. + Tipo de los datos. + + + Obtiene el valor actual de los datos. + Valor actual de los datos. + + + Obtiene el valor anterior de los datos. + Valor anterior de los datos. + + + Devuelve un valor que indica si el valor cambia debido a un cambio de contexto de ejecución. + true si el valor cambió debido a un cambio de contexto de ejecución; de lo contrario, false. + + + Notifica que se ha producido un evento a un subproceso en espera.Esta clase no puede heredarse. + 2 + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + true para establecer el estado inicial en señalado; false para establecer el estado inicial en no señalado. + + + Habilita varias tareas para que cooperen en un algoritmo en paralelo a través de varias fases. + + + Inicializa una nueva instancia de la clase . + Número de subprocesos que participan. + + es menor que 0 o mayor que 32,767. + + + Inicializa una nueva instancia de la clase . + Número de subprocesos que participan. + + que se ejecutará después de cada fase. null (Nothing en Visual Basic) se puede pasar para indicar que no se realiza ninguna acción. + + es menor que 0 o mayor que 32,767. + + + Notifica a que va a haber un participante adicional. + Número de fase de la barrera en la que primero participarán los nuevos participantes. + La instancia actual ya se ha eliminado. + Agregar un participante haría que el recuento de participantes de la barrera superase los 32.767.O bienEl método se invocó desde dentro de una acción posterior a la fase. + + + Notifica a que va a haber participantes adicionales. + Número de fase de la barrera en la que primero participarán los nuevos participantes. + Número de participantes adicionales que se van a agregar a la barrera. + La instancia actual ya se ha eliminado. + + es menor que 0.O bienAgregar haría que el recuento de participantes de la barrera superase los 32.767. + El método se invocó desde dentro de una acción posterior a la fase. + + + Obtiene el número de la fase actual de la barrera. + Devuelve el número de la fase actual de la barrera. + + + Libera todos los recursos usados por la instancia actual de la clase . + El método se invocó desde dentro de una acción posterior a la fase. + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto los recursos administrados como los no administrados; es false para liberar únicamente los recursos no administrados. + + + Obtiene el número total de participantes de la barrera. + Devuelve el número total de participantes de la barrera. + + + Obtiene el número de participantes de la barrera que no aún no se han señalado en la fase actual. + Devuelve el número de participantes de la barrera que no aún no se han señalado en la fase actual. + + + Notifica a que va a haber un participante menos. + La instancia actual ya se ha eliminado. + La barrera ya tiene 0 participantes.O bienEl método se invocó desde dentro de una acción posterior a la fase. + + + Notifica a que va a haber menos participantes. + Número de participantes adicionales que se van a quitar de la barrera. + La instancia actual ya se ha eliminado. + + es menor que 0. + La barrera ya tiene 0 participantes.O bienEl método se invocó desde dentro de una acción posterior a la fase. O bienel recuento del participante actual es menor que el participantCount especificado + El recuento del participante total es menor que el especificado + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera. + La instancia actual ya se ha eliminado. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + Si una excepción se produce de la acción de fase de envío de una barrera después de todos los subprocesos hayan llamado a SignalAndWait, la excepción se ajustará en una BarrierPostPhaseException y se producirá en todos los subprocesos que participan. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera usando un entero de 32 bits con signo para medir el tiempo de espera. + si todos los participantes alcanzaron la barrera dentro del tiempo especificado; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + Si una excepción se produce de la acción de fase de envío de una barrera después de todos los subprocesos hayan llamado a SignalAndWait, la excepción se ajustará en una BarrierPostPhaseException y se producirá en todos los subprocesos que participan. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes la alcancen también usando un entero de 32 bits con signo para medir el tiempo de espera mientras se observa un token de cancelación. + si todos los participantes alcanzaron la barrera dentro del tiempo especificado; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen la barrera mientras se observa un token de cancelación. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera usando un objeto para medir el intervalo de tiempo. + Es true si todos los demás participantes alcanzaron la barrera; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o es mayor de 32.767. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes la alcancen también usando un objeto para medir el intervalo de tiempo, mientras se observa un token de cancelación. + Es true si todos los demás participantes alcanzaron la barrera; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Excepción que se inicia cuando se produce un error en la acción posterior a la fase de + + + Inicializa una nueva instancia de la clase con un mensaje proporcionado por el sistema que describe el error. + + + Inicializa una nueva instancia de la clase con la excepción interna especificada. + La excepción que es la causa de la excepción actual. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado que describe el error. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Representa un método al que se va a llamar dentro de un nuevo contexto. + Objeto que contiene la información que va a utilizar el método de devolución de llamadas cada vez que se ejecute. + 1 + + + Representa una primitiva de sincronización que está señalada cuando su recuento alcanza el valor cero. + + + Inicializa una nueva instancia de la clase con el recuento especificado. + Número de señales necesarias inicialmente para establecer . + + es menor que 0. + + + Incrementa en uno el recuento actual de . + La instancia actual ya se ha eliminado. + La instancia actual ya está establecida.O bien es mayor o igual que . + + + Incrementa en un valor especificado el recuento actual de . + Valor en que se va a aumentar . + La instancia actual ya se ha eliminado. + + es menor o igual que 0. + La instancia actual ya está establecida.O bien es igual o mayor que después de incrementar la cuenta en + + + Obtiene el número de señales restantes necesario para establecer el evento. + El número de señales restantes necesario para establecer el evento. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto los recursos administrados como los no administrados; es false para liberar únicamente los recursos no administrados. + + + Obtiene los números de señales que se necesitan inicialmente para establecer el evento. + El número de señales que se necesitan inicialmente para establecer el evento. + + + Determina si se establece el evento. + Es true si se establece el evento; de lo contrario, es false. + + + Restablece en el valor de . + La instancia actual ya se ha eliminado. + + + Restablece la propiedad según un valor especificado. + Número de señales necesario para establecer . + La instancia actual ya se ha eliminado. + El valor de es menor que 0. + + + Registra una señal con y disminuye el valor de . + Es true si la señal hizo que el recuento alcanzara el valor cero y se estableció el evento; de lo contrario, falso. + La instancia actual ya se ha eliminado. + La instancia actual ya está establecida. + + + Registra varias señales con reduciendo el valor de según la cantidad especificada. + Es true si las señales hicieron que el recuento alcanzara el valor cero y se estableció el evento; de lo contrario, falso. + Número de señales que se va a registrar. + La instancia actual ya se ha eliminado. + + es menor que 1. + La instancia actual ya está establecida. -o bien- es mayor que . + + + Intenta incrementar en uno. + Es true si el incremento se realizó correctamente; en caso contrario, es false.Si ya está en el valor cero, este método devolverá false. + La instancia actual ya se ha eliminado. + + es igual a . + + + Intenta incrementar en un valor especificado. + Es true si el incremento se realizó correctamente; en caso contrario, es false.Si ya está en el valor cero, se devolverá false. + Valor en que se va a aumentar . + La instancia actual ya se ha eliminado. + + es menor o igual que 0. + La instancia actual ya está establecida.O bien + es igual o mayor que . + + + Bloquea el subproceso actual hasta que se establezca el objeto . + La instancia actual ya se ha eliminado. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un entero de 32 bits con signo para medir el tiempo de espera. + Es true si se estableció el objeto ; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un entero de 32 bits con signo para medir el tiempo de espera, mientras se observa un token . + Es true si se estableció el objeto ; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que se establezca el objeto , mientras se observa un token . + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un objeto para medir el tiempo de espera. + Es true si se estableció el objeto ; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un objeto para medir el tiempo de espera, mientras se observa un token . + Es true si se estableció el objeto ; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Obtiene un objeto que se usa para esperar a que se establezca el evento. + Objeto que se usa para esperar a que se establezca el evento. + La instancia actual ya se ha eliminado. + + + Indica si un objeto se restablece automática o manualmente después de recibir una señal. + 2 + + + El objeto , cuando está señalado, se restablece automáticamente después de haber liberado un único subproceso.Si hay ningún subproceso en espera, el objeto permanece señalado hasta que un subproceso se bloquea y se restablece después de haber liberado el subproceso. + + + El objeto , cuando está señalado, libera todos los subprocesos en espera y permanece señalado hasta que se restablece manualmente. + + + Representa un evento de sincronización de subprocesos. + 2 + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente y si se restablece automática o manualmente. + Es true para establecer el estado inicial en señalado; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente y el nombre de un evento de sincronización del sistema. + Es true para establecer el estado inicial en señalado si el evento con nombre se crea como resultado de esta llamada; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + Nombre de un evento de sincronización para todo el sistema. + Se ha producido un error de Win32. + El evento con nombre existe y tiene seguridad de control de acceso, pero el usuario carece de . + No se puede crear el evento con nombre, quizás porque un identificador de espera de un tipo diferente tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente, el nombre de un evento de sincronización del sistema y una variable booleana cuyo valor después de la llamada indica si se ha creado el evento del sistema con nombre. + Es true para establecer el estado inicial en señalado si el evento con nombre se crea como resultado de esta llamada; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + Nombre de un evento de sincronización para todo el sistema. + Cuando este método devuelve un resultado, contiene true si se ha creado un evento local (es decir, si es null o una cadena vacía) o si se ha creado el evento del sistema con nombre especificado; es false si el evento del sistema con nombre especificado ya existía.Este parámetro se pasa sin inicializar. + Se ha producido un error de Win32. + El evento con nombre existe y tiene seguridad de control de acceso, pero el usuario carece de . + No se puede crear el evento con nombre, quizás porque un identificador de espera de un tipo diferente tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Abre el evento de sincronización con nombre especificado, si ya existe. + Un objeto que representa el evento del sistema con nombre. + Nombre del evento de sincronización que se va a abrir. + + es una cadena vacía. O bien tiene más de 260 caracteres. + + es null. + El evento del sistema con nombre no existe. + Se ha producido un error de Win32. + El evento con nombre existe, pero el usuario no tiene el acceso de seguridad exigido para utilizarlo. + 1 + + + + + + Establece el estado del evento en no señalado, haciendo que los subprocesos se bloqueen. + true si la operación se realiza correctamente; en caso contrario, false. + No se ha llamado previamente al método en este . + 2 + + + Establece el estado del evento en señalado, permitiendo que uno o varios subprocesos en espera continúen. + true si la operación se realiza correctamente; en caso contrario, false. + No se ha llamado previamente al método en este . + 2 + + + Abre el evento de sincronización con nombre especificado, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si el evento de sincronización con nombre se abrió correctamente; si no, false. + Nombre del evento de sincronización que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa el evento de sincronización con nombre si la llamada se realizó correctamente, o null si se produjo un error en la llamada.Este parámetro se trata como sin inicializar. + + es una cadena vacía.O bien tiene más de 260 caracteres. + + es null. + Se ha producido un error de Win32. + El evento con nombre existe, pero el usuario no tiene el acceso de seguridad deseado. + + + Administra el contexto de ejecución del subproceso actual.Esta clase no puede heredarse. + 2 + + + Captura el contexto de ejecución del subproceso actual. + Objeto que representa el contexto de ejecución del subproceso actual. + 1 + + + Ejecuta un método en un contexto de ejecución especificado en el subproceso actual. + Contexto de ejecución que se va a establecer. + Delegado que representa el método que se va a ejecutar en el contexto de ejecución proporcionado. + Objeto que se pasa al método de devolución de llamada. + + es null.O bien no se adquirió a través de una operación de captura. O bien ya se ha utilizado como argumento de una llamada a . + 1 + + + + + + Proporciona operaciones atómicas para las variables compartidas por varios subprocesos. + 2 + + + Agrega dos enteros de 32 bits y reemplaza el primer entero por la suma, como una operación atómica. + Nuevo valor almacenado en . + Variable que contiene el primer valor que se va a agregar.La suma de los dos valores se almacena en . + Valor que se va a agregar al entero en . + The address of is a null pointer. + 1 + + + Agrega dos enteros de 64 bits y reemplaza el primer entero por la suma, como una operación atómica. + Nuevo valor almacenado en . + Variable que contiene el primer valor que se va a agregar.La suma de los dos valores se almacena en . + Valor que se va a agregar al entero en . + The address of is a null pointer. + 1 + + + Compara dos números de punto flotante de precisión doble para comprobar si son iguales y, si lo son, reemplaza el primero de los valores. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos enteros de 32 bits con signo para comprobar si son iguales y, si lo son, reemplaza el primer valor. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos enteros de 64 bits con signo para comprobar si son iguales y, si lo son, reemplaza el primer valor. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos identificadores o punteros específicos de plataforma para comprobar si son iguales y, si lo son, reemplaza el primero. + Valor original de . + Estructura de destino, cuyo valor se compara con el valor de y que posiblemente se reemplace por . + Estructura que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Estructura que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos objetos para comprobar si sus referencias son iguales y, si lo son, reemplaza el primero de los objetos. + Valor original de . + Objeto de destino que se compara con y que posiblemente se reemplace. + Objeto que reemplaza el objeto de destino si la comparación da como resultado la igualdad de ambos parámetros. + Objeto que se compara con el objeto que hay en . + The address of is a null pointer. + 1 + + + Compara dos números de punto flotante de precisión sencilla para comprobar si son iguales y, si lo son, reemplaza el primero de los valores. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos instancias del tipo de referencia especificado para comprobar si son iguales y, si lo son, reemplaza la primera. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace.Este es un parámetro de referencia (ref en C#, ByRef en Visual Basic). + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + Tipo que se va a utilizar para , y .Este tipo debe ser un tipo de referencia. + The address of is a null pointer. + + + Disminuye el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor reducido. + Variable cuyo valor se va a reducir. + The address of is a null pointer. + 1 + + + Disminuye el valor de la variable especificada y almacena el resultado, como una operación atómica. + Valor reducido. + Variable cuyo valor se va a reducir. + The address of is a null pointer. + 1 + + + Establece un número de punto flotante de precisión doble en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un entero de 32 bits con signo en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un entero de 64 bits con signo en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un puntero o identificador específico de plataforma en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un objeto en un valor especificado y devuelve una referencia al objeto original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un número de punto flotante de precisión sencilla en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece una variable del tipo especificado en un valor determinado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado.Este es un parámetro de referencia (ref en C#, ByRef en Visual Basic). + Valor en el que está establecido el parámetro . + Tipo que se va a utilizar para y .Este tipo debe ser un tipo de referencia. + The address of is a null pointer. + + + Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor incrementado. + Variable cuyo valor se va a incrementar. + The address of is a null pointer. + 1 + + + Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor incrementado. + Variable cuyo valor se va a incrementar. + The address of is a null pointer. + 1 + + + Sincroniza el acceso a la memoria de la siguiente forma: el procesador que ejecuta el subproceso actual no puede reordenar instrucciones de forma que los accesos a la memoria anteriores a la llamada a se ejecuten después de los accesos a memoria que siguen a la llamada a . + + + Devuelve un valor de 64 bits, cargado como una operación atómica. + Valor cargado. + Valor de 64 bits que se va a cargar. + 1 + + + Proporciona rutinas de inicialización diferida. + + + Inicializa un tipo de referencia de destino con su constructor predeterminado si aún no se ha inicializado el destino. + Referencia de tipo que se ha inicializado. + Referencia de tipo que se va a inicializar si aún no se ha inicializado. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino o tipo de valor con su constructor predeterminado si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia o valor de tipo que se va a inicializar si aún no se ha inicializado. + Referencia a un valor booleano que determina si ya se ha inicializado el destino. + Referencia a un objeto que se usa como bloqueo mutuamente excluyente para la inicialización de .Si es null, se creará una instancia de un nuevo objeto. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino o tipo de valor utilizando la función especificada si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia o valor de tipo que se va a inicializar si aún no se ha inicializado. + Referencia a un valor booleano que determina si ya se ha inicializado el destino. + Referencia a un objeto que se usa como bloqueo mutuamente excluyente para la inicialización de .Si es null, se creará una instancia de un nuevo objeto. + Función que se llama para inicializar la referencia o el valor. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino utilizando la función especificada si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia de tipo que se va a inicializar si aún no se ha inicializado. + Función que se llama para inicializar la referencia. + Tipo de referencia que se va a inicializar. + El tipo no contiene un constructor predeterminado. + + devuelve un valor NULL (Nothing en Visual Basic). + + + Excepción que se inicia cuando la entrada recursiva en un bloqueo no es compatible con la directiva de recursividad del bloqueo. + 2 + + + Inicializa una nueva instancia de la clase con un mensaje proporcionado por el sistema que describe el error. + 2 + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado que describe el error. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que la cadena se ha traducido para la referencia cultural actual del sistema. + 2 + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que la cadena se ha traducido para la referencia cultural actual del sistema. + Excepción que ha producido la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + 2 + + + Especifica si el mismo subproceso puede entrar varias veces en un bloqueo. + + + Si un subproceso intenta entrar en un bloqueo de forma recursiva, se inicia una excepción.Algunas clases pueden permitir cierta recursividad cuando se aplica esta configuración. + + + Un subproceso puede entrar en un bloqueo de forma recursiva.Algunas clases pueden limitar esta posibilidad. + + + Notifica que se ha producido un evento a uno o varios subprocesos en espera.Esta clase no puede heredarse. + 2 + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + true para establecer el estado inicial de señalado; false para establecer el estado inicial en no señalado. + + + Proporciona una versión reducida de . + + + Inicializa una nueva instancia de la clase con el estado inicial establecido en no señalado. + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + Es true para establecer el estado inicial en señalado; es false para establecer el estado inicial en no señalado. + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado y con el recuento circular especificado. + Es true para establecer el estado inicial en señalado; es false para establecer el estado inicial en no señalado. + Número de esperas circulares que se van a producir antes de una operación de espera basada en kernel. + + is less than 0 or greater than the maximum allowed value. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados que usa el objeto y, de forma opcional, libera los recursos administrados. + true para liberar tanto los recursos administrados como los no administrados; false para liberar únicamente los recursos no administrados. + + + Obtiene un valor que indica si se ha establecido el evento. + Es true si se ha establecido el evento; de lo contrario, es false. + + + Establece el estado del evento en no señalado, por lo que se bloquean los subprocesos. + The object has already been disposed. + + + Establece el estado del evento en señalado, lo que permite la continuación de uno o varios subprocesos que están esperando en el evento. + + + Obtiene el número de esperas circulares que se producirán antes de una operación de espera basada en kernel. + Devuelve el número de esperas circulares que se producirán antes de una operación de espera basada en kernel. + + + Bloquea el subproceso actual hasta que se establezca el objeto actual. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, usando un entero de 32 bits con signo para medir el intervalo de tiempo. + Es true si se estableció ; en caso contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, usando un entero de 32 bits con signo para medir el intervalo de tiempo, mientras se observa un token . + true si se estableció ; en caso contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Bloquea el subproceso actual hasta que el actual reciba una señal, mientras se observa un token . + + que se va a observar. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, utilizando un objeto para medir el intervalo de tiempo. + true si se estableció ; en caso contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el , usando un objeto para medir el intervalo de tiempo, mientras se observa un token . + true si se estableció ; en caso contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Obtiene el objeto para este . + Objeto de evento subyacente de este . + + + Proporciona un mecanismo que sincroniza el acceso a los objetos. + 2 + + + Adquiere un bloqueo exclusivo en el objeto especificado. + Objeto en el que se va a adquirir el bloqueo de monitor. + El parámetro es null. + 1 + + + Adquiere un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a esperar. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo.Nota   Si no se produce ninguna excepción, el resultado de este método siempre es true. + La entrada es true. + El parámetro es null. + + + Libera un bloqueo exclusivo en el objeto especificado. + Objeto en el que se va a liberar el bloqueo. + El parámetro es null. + El subproceso actual no posee el bloqueo para el objeto especificado. + 1 + + + Determina si el subproceso actual mantiene el bloqueo en el objeto especificado. + Es true si el subproceso actual mantiene el bloqueo en ; en caso contrario, es false. + Objeto que se va a probar. + El valor de es null. + + + Notifica un cambio de estado del objeto bloqueado al subproceso que se encuentra en la cola de espera. + Objeto que está esperando un subproceso. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + 1 + + + Notifica un cambio de estado del objeto a todos los subprocesos que se encuentran en espera. + Objeto que envía el pulso. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + 1 + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + El parámetro es null. + 1 + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado durante el número de segundos especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + Número de milisegundos durante los que se va a esperar para adquirir el bloqueo. + El parámetro es null. + + es negativo y no es igual a . + 1 + + + Intenta, durante el número especificado de milisegundos, adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Número de milisegundos durante los que se va a esperar para adquirir el bloqueo. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + + es negativo y no es igual a . + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado durante el período de tiempo especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + + que representa el período de tiempo que se va a esperar para adquirir el bloqueo.Un valor de –1 milisegundo especifica una espera infinita. + El parámetro es null. + El valor de en milisegundos es negativo y no es igual a (– 1 milisegundo), o es mayor que . + 1 + + + Intenta, durante el periodo de tiempo indicado, adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Tiempo que se va a esperar el bloqueo.Un valor de –1 milisegundo especifica una espera infinita. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + El valor de en milisegundos es negativo y no es igual a (– 1 milisegundo), o es mayor que . + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo. + Es true si la llamada fue devuelta porque el llamador volvió a adquirir el bloqueo para el objeto especificado.Este método no devuelve ningún resultado si el bloqueo no vuelve a adquirirse. + Objeto en el que se va a esperar. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + 1 + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo.Si transcurre el intervalo de tiempo de espera especificado, el subproceso entra en la cola de subprocesos listos. + Es true si se volvió a adquirir el bloqueo antes de que transcurriera el período de tiempo especificado; es false si se volvió a adquirir el bloqueo después de que transcurriera el período de tiempo especificado.El método no devuelve ningún resultado hasta que se vuelva a adquirir el bloqueo. + Objeto en el que se va a esperar. + Número de milisegundos que se va a estar a la espera antes de que el subproceso entre en la cola de subprocesos listos. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + El valor de la parámetro es negativo y no es igual a . + 1 + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo.Si transcurre el intervalo de tiempo de espera especificado, el subproceso entra en la cola de subprocesos listos. + Es true si se volvió a adquirir el bloqueo antes de que transcurriera el período de tiempo especificado; es false si se volvió a adquirir el bloqueo después de que transcurriera el período de tiempo especificado.El método no devuelve ningún resultado hasta que se vuelva a adquirir el bloqueo. + Objeto en el que se va a esperar. + + que representa la cantidad de tiempo que se va a esperar antes de que el subproceso entre en la cola de subprocesos listos. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + El valor de la parámetro en milisegundos es negativo y no representa (– 1 milisegundo), o es mayor que . + 1 + + + Primitiva de sincronización que puede usarse también para la sincronización entre procesos. + 1 + + + Inicializa una nueva instancia de la clase con propiedades predeterminadas. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua. + true para otorgar la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada, de lo contrario, false. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua y una cadena que representa el nombre de la exclusión mutua. + true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false. + Nombre del objeto .Si el valor es null, no tiene nombre. + La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene . + Se ha producido un error de Win32. + No se puede crear la exclusión mutua con nombre; posiblemente porque un identificador de espera de otro tipo tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua, una cadena que es el nombre de la exclusión mutua y un valor booleano que, cuando se devuelva el método, indicará si se concedió la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada. + true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false. + Nombre del objeto .Si el valor es null, no tiene nombre. + Cuando se devuelve este método, contiene un valor booleano que es true si se creó una exclusión mutua local (es decir, si es null o una cadena vacía) o si se creó la exclusión mutua del sistema con nombre especificada; el valor es false si la exclusión mutua del sistema con nombre especificada ya existía.Este parámetro se pasa sin inicializar. + La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene . + Se ha producido un error de Win32. + No se puede crear la exclusión mutua con nombre; posiblemente porque un identificador de espera de otro tipo tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Abre la exclusión mutua con nombre especificada, si ya existe. + Objeto que representa la exclusión mutua del sistema con nombre. + Nombre de la exclusión mutua del sistema que se va a abrir. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + La excepción mutua con nombre no existe. + Se ha producido un error de Win32. + La exclusión mutua con nombre existe, pero el usuario no dispone del acceso de seguridad exigido para utilizarla. + 1 + + + + + + Libera una vez la instancia de . + El subproceso que realiza la llamada no posee la exclusión mutua. + 1 + + + Abre la exclusión mutua con nombre especificada, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si la exclusión mutua con nombre se abrió correctamente; si no, false. + Nombre de la exclusión mutua del sistema que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa la exclusión mutua con nombre si la llamada se realizó correctamente, o null si se produjo un error en la llamada.Este parámetro se trata como sin inicializar. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + Se ha producido un error de Win32. + La exclusión mutua con nombre existe, pero el usuario no dispone del acceso de seguridad exigido para utilizarla. + + + Representa un bloqueo que se utiliza para administrar el acceso a un recurso y que permite varios subprocesos para la lectura o acceso exclusivo para la escritura. + + + Inicializa una nueva instancia de la clase con los valores de propiedad predeterminados. + + + Inicializa una nueva instancia de la clase especificando la directiva de recursividad de bloqueo. + Uno de los valores de enumeración que especifica la directiva de recursividad de bloqueo. + + + Obtiene el número total de subprocesos únicos que han entrado en el bloqueo en modo de lectura. + Número de subprocesos únicos que han entrado en el bloqueo en modo de lectura. + + + Libera todos los recursos usados por la instancia actual de la clase . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Intenta entrar en el bloqueo en modo de lectura. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Reduce el recuento de recursividad para el modo de lectura y sale del modo de lectura si el recuento resultante es 0 (cero). + The current thread has not entered the lock in read mode. + + + Reduce el recuento de recursividad para el modo de actualización y sale del modo de actualización si el recuento resultante es 0 (cero). + The current thread has not entered the lock in upgradeable mode. + + + Reduce el recuento de recursividad para el modo de escritura y sale del modo de escritura si el recuento resultante es 0 (cero). + The current thread has not entered the lock in write mode. + + + Obtiene un valor que indica si el subproceso actual ha entrado en el bloqueo en modo de lectura. + true si el subproceso actual entró en modo Lectura; en caso contrario, false. + 2 + + + Obtiene un valor que indica si el subproceso actual entró en el bloqueo en modo de actualización. + true si el subproceso actual entró en modo de actualización; en caso contrario, false. + 2 + + + Obtiene un valor que indica si el subproceso actual ha entrado en el bloqueo en modo de escritura. + true si el subproceso actual entró en modo de escritura; en caso contrario, false. + 2 + + + Obtiene un valor que indica la directiva de recursividad del objeto actual. + Uno de los valores de enumeración que especifica la directiva de recursividad de bloqueo. + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de lectura, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo Lectura, 1 si el subproceso entró en modo Lectura pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el bloqueo n - 1 veces. + 2 + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de actualización, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo de actualización, 1 si el subproceso entró en modo de actualización pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el modo de actualización n - 1 veces. + 2 + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de escritura, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo de escritura, 1 si el subproceso entró en modo de escritura pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el modo de escritura n - 1 veces. + 2 + + + Intenta entrar en el bloqueo en modo de lectura, con un tiempo de espera entero opcional. + true si el subproceso que realiza la llamada entró en modo Lectura; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de lectura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo Lectura; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de actualización; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de actualización; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de escritura; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de escritura; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de lectura. + Número total de subprocesos que están a la espera de entrar en modo de lectura. + 2 + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de actualización. + Número total de subprocesos que están a la espera de entrar en modo de actualización. + 2 + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de escritura. + Número total de subprocesos que están a la espera de entrar en modo de escritura. + 2 + + + Limita el número de subprocesos que pueden tener acceso a un recurso o grupo de recursos simultáneamente. + 1 + + + Inicializa una nueva instancia de la clase , que especifica el número inicial de entradas y el número máximo de entradas simultáneas. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + + es mayor que . + + es menor que 1.o bien es menor que 0. + + + Inicializa una nueva instancia de la clase , que especifica el número inicial de entradas y el número máximo de entradas simultáneas, y especificando de forma opcional el nombre de un objeto semáforo de sistema. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + Nombre de un objeto de semáforo del sistema con nombre. + + es mayor que .o bien tiene más de 260 caracteres. + + es menor que 1.o bien es menor que 0. + Se ha producido un error de Win32. + El semáforo con nombre existe y tiene seguridad de control de acceso y el usuario no tiene . + No se puede crear el semáforo con nombre, probablemente porque tiene el mismo nombre que un identificador de espera de otro tipo. + + + Inicializa una instancia nueva de la clase , especificando el número inicial de entradas y el número máximo de entradas simultáneas, especificando de forma opcional el nombre de un objeto semáforo de sistema y especificando una variable que recibe un valor que indica si se creó un semáforo del sistema nuevo. + Número inicial de solicitudes para el semáforo que se puede satisfacer simultáneamente. + Número máximo de solicitudes para el semáforo que se puede satisfacer simultáneamente. + Nombre de un objeto de semáforo del sistema con nombre. + Cuando este método devuelve un resultado, contiene true si se creó un semáforo local (es decir, si es null o una cadena vacía) o si se creó el semáforo del sistema con nombre especificado; es false si el semáforo del sistema con nombre especificado ya existía.Este parámetro se pasa sin inicializar. + + es mayor que . o bien tiene más de 260 caracteres. + + es menor que 1.o bien es menor que 0. + Se ha producido un error de Win32. + El semáforo con nombre existe y tiene seguridad de control de acceso y el usuario no tiene . + No se puede crear el semáforo con nombre, probablemente porque tiene el mismo nombre que un identificador de espera de otro tipo. + + + Abre el semáforo con nombre especificado, si ya existe. + Objeto que representa el semáforo del sistema con nombre. + Nombre del semáforo del sistema que se va a abrir. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + El semáforo con nombre no existe. + Se ha producido un error de Win32. + El semáforo con nombre existe, pero el usuario no tiene el acceso de seguridad necesario para utilizarlo. + 1 + + + + + + Sale del semáforo y devuelve el recuento anterior. + Recuento en el semáforo antes de la llamada al método . + El recuento del semáforo ya está en el valor máximo. + Error de Win32 con un semáforo con nombre. + El semáforo actual representa un semáforo de sistema con nombre, pero el usuario no tiene .o bienEl semáforo actual representa un semáforo de sistema con nombre, pero no se abrió con . + 1 + + + Sale del semáforo un número especificado de veces y devuelve el recuento anterior. + Recuento en el semáforo antes de la llamada al método . + Número de veces que se abandona el semáforo. + + es menor que 1. + El recuento del semáforo ya está en el valor máximo. + Error de Win32 con un semáforo con nombre. + El semáforo actual representa un semáforo de sistema con nombre, pero el usuario no tiene derechos.o bienEl semáforo actual representa un semáforo de sistema con nombre, pero no se abrió con derechos. + 1 + + + Abre el semáforo con nombre especificado, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si el semáforo con nombre se abrió correctamente; si no, false. + Nombre del semáforo del sistema que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa el semáforo con nombre si la llamada se realizó correctamente o null si se produjo un error en la misma.Este parámetro se trata como sin inicializar. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + Se ha producido un error de Win32. + El semáforo con nombre existe, pero el usuario no tiene el acceso de seguridad necesario para utilizarlo. + + + Excepción que se produce cuando se llama al método en un semáforo cuyo recuento ya ha alcanzado el valor máximo. + 2 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Representa una alternativa ligera a que limita el número de subprocesos que puede obtener acceso a la vez a un recurso o a un grupo de recursos. + + + Inicializa una nueva instancia de la clase , especificando el número inicial de solicitudes que se pueden conceder simultáneamente. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + + es menor que 0. + + + Inicializa una nueva instancia de la clase , especificando el número inicial y máximo de solicitudes que se pueden conceder simultáneamente. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + + es menor que 0, o es mayor que , o es igual o menor que 0. + + + Devuelve un objeto que se puede usar para esperar en el semáforo. + + que se puede usar para esperar en el semáforo. + Se ha eliminado . + + + Obtiene el número de subprocesos restantes que puede introducir el objeto . + Obtiene el número de subprocesos restantes que pueden entrar en el semáforo. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Libera una vez el objeto . + Recuento anterior de . + La instancia actual ya se ha eliminado. + El ya se ha alcanzado su tamaño máximo. + + + Libera el objeto un número especificado de veces. + Recuento anterior de . + Número de veces que se abandona el semáforo. + La instancia actual ya se ha eliminado. + + es menor que 1. + El ya se ha alcanzado su tamaño máximo. + + + Bloquea el subproceso actual hasta que pueda introducir . + La instancia actual ya se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , usando un entero de 32 bits con signo que especifica el tiempo de espera. + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que pueda introducir , usando un entero de 32 bits con signo que especifica el tiempo de espera mientras se observa un elemento . + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + se ha cancelado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + El se ha eliminado la instancia, o la que creó se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , mientras se observa un elemento . + Token que se va a observar. + + se ha cancelado. + La instancia actual ya se ha eliminado.o bienEl que creó ya se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , usando para especificar el tiempo de espera. + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + es un número negativo distinto de-1 milisegundo, que representa un tiempo de espera infinito o - tiempo de espera es mayor que . + Se ha eliminado la instancia de semaphoreSlim + + + Bloquea el subproceso actual hasta que pueda introducir , usando un que especifica el tiempo de espera mientras se observa un elemento . + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + + se ha cancelado. + + es un número negativo distinto de-1 milisegundo, que representa un tiempo de espera infinito o - tiempo de espera es mayor que . + Se ha eliminado la instancia de semaphoreSlimEl que creó ya se ha eliminado. + + + De forma asincrónica espera que se introduzca . + Tarea que se completará cuando se entre en el semáforo. + + + De forma asincrónica espera que se introduzca , usando un entero de 32 bits para medir el intervalo de tiempo. + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + + + De forma asincrónica, espera introducir , usando un entero de 32 bits para medir el intervalo de tiempo, mientras observa un elemento . + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + La instancia actual ya se ha eliminado. + + se ha cancelado. + + + De forma asincrónica, espera introducir , mientras observa un elemento . + Tarea que se completará cuando se entre en el semáforo. + Token que se va a observar. + La instancia actual ya se ha eliminado. + + se ha cancelado. + + + De forma asincrónica, espera introducir , usando un para medir el intervalo de tiempo. + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito o bien tiempo de espera es mayor que . + + + De forma asincrónica, espera introducir , usando un para medir el intervalo de tiempo, mientras observa un elemento . + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + Token que se va a observar. + + es un número negativo distinto de -1, que representa el tiempo de espera infinitoo bientiempo de espera es mayor que . + + se ha cancelado. + + + Representa el método al que hay que llamar cuando se va a enviar un mensaje a un contexto de sincronización. + Objeto que se ha pasado al delegado. + 2 + + + Proporciona una primitiva de bloqueo de exclusión mutua donde un subproceso que intenta adquirir el bloqueo espera en un bucle repetidamente comprobando hasta que haya un bloqueo disponible. + + + Inicializa una nueva instancia de la estructura con la opción de realizar el seguimiento de los identificadores de subprocesos para mejorar la depuración. + Indica si se han de capturar y utilizar identificadores de subprocesos con fines de depuración. + + + Adquiere el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + El argumento se debe inicializar en false antes de llamar a Enter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Libera el bloqueo. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual no es el propietario de este bloqueo. + + + Libera el bloqueo. + Valor booleano que indica si una barrera de memoria debe emitirse para publicar inmediatamente la operación de salida a otros subprocesos. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual no es el propietario de este bloqueo. + + + Obtiene un valor que indica si un subproceso mantiene actualmente el bloqueo. + Es true si cualquier subproceso mantiene actualmente el bloqueo; de lo contrario, es false. + + + Obtiene un valor que indica si el subproceso actual mantiene actualmente el bloqueo. + Es true si el subproceso actual mantiene el bloqueo; de lo contrario, es false. + El seguimiento de propiedad de subprocesos está deshabilitado. + + + Obtiene un valor que indica si el seguimiento de propiedad de subprocesos está habilitado para esta instancia. + Es true si se ha habilitado el seguimiento de propiedad de subprocesos para esta instancia; de lo contrario, es false. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que milisegundos. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Proporciona compatibilidad con la espera basada en ciclos. + + + Obtiene el número de veces que se ha llamado a en esta instancia. + Devuelve un entero que representa el número de veces que se ha llamado en esta instancia. + + + Obtiene si la llamada siguiente a da paso al procesador, lo que activa un cambio de contexto forzado. + Si la llamada siguiente a da paso al procesador, lo que activa un cambio de contexto forzado. + + + Restablece el contador de ciclos. + + + Realiza un único ciclo. + + + Itera en ciclos hasta que se satisface la condición especificada. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + El argumento de es nulo. + + + Itera en ciclos hasta que se satisface la condición especificada o se agota el tiempo de espera indicado. + Es true si la condición se satisface dentro del tiempo de espera; de lo contrario, es false. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + El argumento de es nulo. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Itera en ciclos hasta que se satisface la condición especificada o se agota el tiempo de espera indicado. + Es true si la condición se satisface dentro del tiempo de espera; de lo contrario, es false. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + Estructura que representa el número de milisegundos de espera o TimeSpan que representa -1 milisegundo para esperar indefinidamente. + El argumento de es nulo. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Proporciona la funcionalidad básica para propagar un contexto de sincronización en varios modelos de sincronización. + 2 + + + Crea una nueva instancia de la clase . + + + Cuando se invalida en una clase derivada, crea una copia del contexto de sincronización. + Un nuevo objeto . + 2 + + + Obtiene el contexto de sincronización del subproceso actual. + Objeto que representa el contexto de sincronización actual. + 1 + + + Cuando se invalida en una clase derivada, responde a la notificación de que se ha completado una operación. + + + Cuando se invalida en una clase derivada, responde a la notificación de que se ha iniciado una operación. + + + Cuando se invalida en una clase derivada, envía un mensaje asincrónico a un contexto de sincronización. + Delegado de al que se va a llamar. + Objeto que se ha pasado al delegado. + 2 + + + Cuando se invalida en una clase derivada, envía un mensaje sincrónico a un contexto de sincronización. + Delegado de al que se va a llamar. + Objeto que se ha pasado al delegado. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Establece el contexto de sincronización actual. + Objeto que se va a establecer. + 1 + + + + + + Excepción que se produce cuando un método requiere que el llamador sea propietario del bloqueo en un Monitor dado y un llamador al que no pertenece ese bloqueo llama al método. + 2 + + + Inicializa una nueva instancia de la clase con propiedades predeterminadas. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Proporciona almacenamiento local de los datos de un subproceso. + Especifica el tipo de datos que se almacena por subproceso. + + + Inicializa la instancia de . + + + Inicializa la instancia de . + Si se va a hacer un seguimiento de todos los valores establecidos en la instancia y exponerlos a través de la propiedad . + + + Inicializa una instancia de con la función especificada por el parámetro . + + que se invoca para generar un valor de inicialización diferida cuando se intenta recuperar sin que se haya inicializado anteriormente. + + es una referencia nula (Nothing en Visual Basic). + + + Inicializa una instancia de con la función especificada por el parámetro . + + que se invoca para generar un valor de inicialización diferida cuando se intenta recuperar sin que se haya inicializado anteriormente. + Si se va a hacer un seguimiento de todos los valores establecidos en la instancia y exponerlos a través de la propiedad . + + es una referencia null (Nothing en Visual Basic). + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos utilizados por esta instancia de . + Valor booleano que indica si se llama a este método debido a una llamada a . + + + Libera los recursos utilizados por esta instancia de . + + + Obtiene un valor que indica si se inicializa en el subproceso actual. + Es true si se inicializa en el subproceso actual; en caso contrario, es false. + La instancia de se ha eliminado. + + + Crea y devuelve una representación de cadena de esta instancia del subproceso actual. + Resultado de llamar al método en . + La instancia de se ha eliminado. + La propiedad del subproceso actual es una referencia nula (Nothing en Visual Basic). + La función de inicialización intentó hacer referencia de forma recursiva a . + No se proporciona ningún constructor predeterminado y no se proporciona ningún generador de valor. + + + Obtiene o establece el valor de esta instancia del subproceso actual. + Devuelve una instancia del objeto que ThreadLocal es responsable de inicializar. + La instancia de se ha eliminado. + La función de inicialización intentó hacer referencia de forma recursiva a . + No se proporciona ningún constructor predeterminado y no se proporciona ningún generador de valor. + + + Obtiene una lista de todos los valores almacenados actualmente por todos los subprocesos que han tenido acceso a esta instancia. + Lista de todos los valores almacenados actualmente por todos los subprocesos que han tenido acceso a esta instancia. + La instancia de se ha eliminado. + + + Contiene los métodos para realizar operaciones de memoria volátil. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee la referencia al objeto desde el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Referencia al que se ha leído.Esta referencia es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + Tipo del campo que se va a leer.Debe ser un tipo de referencia, no un tipo de valor. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de memoria antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe la referencia de objeto especificada en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe la referencia de objeto. + Referencia de objeto que se va a escribir.La referencia se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + Tipo del campo que se va a escribir.Debe ser un tipo de referencia, no un tipo de valor. + + + Excepción que se produce cuando se intenta abrir una exclusión mutua o semáforo del sistema que no existe. + 2 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/fr/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/fr/System.Threading.xml new file mode 100644 index 000000000..6bbaf9759 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/fr/System.Threading.xml @@ -0,0 +1,1833 @@ + + + + System.Threading + + + + Exception levée lorsqu'un thread acquiert un objet qu'un autre thread a abandonné en se terminant sans le libérer. + 1 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un index spécifié pour le mutex abandonné, le cas échéant, et un objet qui représente le mutex. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur qui indique la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur et une exception interne spécifiés. + Message d'erreur qui indique la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié, l'exception interne, l'index pour le mutex abandonné, le cas échéant, et un objet qui représente le mutex. + Message d'erreur qui indique la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié, l'index du mutex abandonné, le cas échéant, et le mutex abandonné. + Message d'erreur qui indique la raison de l'exception. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Obtient le mutex abandonné qui a provoqué l'exception, s'il est connu. + Objet qui représente le mutex abandonné ou null si les mutex abandonnés n'ont pas pu être identifiés. + 1 + + + Obtient l'index du mutex abandonné qui a provoqué l'exception, s'il est connu. + Index, dans le tableau de handles d'attente passés à la méthode , de l'objet qui représente le mutex abandonné ou -1 si l'index du mutex abandonné n'a pas pu être déterminé. + 1 + + + Représente les données ambiantes qui sont locales à un flux de contrôle asynchrone donné, par exemple une méthode asynchrone. + Type des données ambiantes. + + + Instancie une instance de qui ne reçoit pas de notifications de modification. + + + Instancie une instance locale de qui ne reçoit pas de notifications de modification. + Le délégué est appelé à chaque modification de la valeur actuelle sur n'importe quel thread. + + + Obtient ou définit la valeur des données ambiantes. + Valeur des données ambiantes. + + + Classe qui fournit les informations de modification des données aux instances de qui s'inscrivent pour les notifications de modification. + Type des données. + + + Obtient la valeur actuelle des données. + Valeur actuelle des données. + + + Obtient la valeur précédente des données. + Valeur précédente des données. + + + Retourne une valeur qui indique si la valeur est modifiée en raison d'un changement du contexte d'exécution. + true si la valeur est modifiée en raison d'un changement du contexte d'exécution ; sinon, false. + + + Avertit un thread en attente qu'un événement s'est produit.Cette classe ne peut pas être héritée. + 2 + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé". + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + + + Permet à plusieurs tâches de travailler en parallèle de manière coopérative sur un algorithme via plusieurs phases. + + + Initialise une nouvelle instance de la classe . + Nombre de threads participants. + + est inférieur à 0 ou supérieur à 32,767. + + + Initialise une nouvelle instance de la classe . + Nombre de threads participants. + + à exécuter après chaque phase. null (nothing en Visual Basic) peut être passé pour indiquer qu'aucune action n'est effectuée. + + est inférieur à 0 ou supérieur à 32,767. + + + Signale à qu'il y aura un participant supplémentaire. + Numéro de la phase du cloisonnement à laquelle les nouveaux participants participeront en premier. + L'instance actuelle a déjà été supprimée. + L'ajout d'un participant provoquerait l'augmentation du nombre de participants du cloisonnement au-delà de 32 767.ouLa méthode a été appelée à partir d'une action post-phase. + + + Signale à qu'il y aura des participants supplémentaires. + Numéro de la phase du cloisonnement à laquelle les nouveaux participants participeront en premier. + Nombre de participants supplémentaires à ajouter au cloisonnement. + L'instance actuelle a déjà été supprimée. + + est inférieur à 0.ouL'ajout de participants () provoquerait l'augmentation du nombre de participants du cloisonnement au-delà de 32 767. + La méthode a été appelée à partir d'une action post-phase. + + + Obtient le numéro de la phase actuelle du cloisonnement. + Retourne le numéro de la phase actuelle du cloisonnement. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + La méthode a été appelée à partir d'une action post-phase. + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le nombre total de participants au cloisonnement. + Retourne le nombre total de participants au cloisonnement. + + + Obtient le nombre de participants au cloisonnement qui n'ont pas encore été signalés dans la phase actuelle. + Retourne le nombre de participants au cloisonnement qui n'ont pas encore été signalés dans la phase actuelle. + + + Signale à qu'il y aura un participant en moins. + L'instance actuelle a déjà été supprimée. + La barrière a déjà 0 participant.ouLa méthode a été appelée à partir d'une action post-phase. + + + Signale à qu'il y aura moins de participants. + Nombre de participants supplémentaires à supprimer du cloisonnement. + L'instance actuelle a déjà été supprimée. + + est inférieur à 0. + La barrière a déjà 0 participant.ouLa méthode a été appelée à partir d'une action post-phase. oule nombre de participant actuel est inférieur au participantCount spécifié + Le nombre total de participants est inférieur au spécifié + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement. + L'instance actuelle a déjà été supprimée. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + Si une exception est levée par l'action de post-phase d'un cloisonnement après que tous les threads participants aient appelé SignalAndWait, l'exception sera incluse dans un wrapper dans une BarrierPostPhaseException et levée pour tous les threads participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un entier signé 32 bits pour mesurer le délai d'attente. + si tous les participants ont atteint le cloisonnement dans le délai spécifié ; sinon false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + Si une exception est levée par l'action de post-phase d'un cloisonnement après que tous les threads participants aient appelé SignalAndWait, l'exception sera incluse dans un wrapper dans une BarrierPostPhaseException et levée pour tous les threads participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un entier signé 32 bits pour mesurer le délai d'attente, tout en observant un jeton d'annulation. + si tous les participants ont atteint le cloisonnement dans le délai spécifié ; sinon false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, tout en observant un jeton d'annulation. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un objet qui mesure l'intervalle de temps. + true si tous les autres participants ont atteint le cloisonnement ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini, ou sa valeur est supérieure à 32 767. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un objet qui mesure l'intervalle de temps, tout en observant un jeton d'annulation. + true si tous les autres participants ont atteint le cloisonnement ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + L'exception levée lorsque l'action post-phase d'un échoue. + + + Initialise une nouvelle instance de la classe avec un message système qui décrit l'erreur. + + + Initialise une nouvelle instance de la classe avec l'exception interne spécifiée. + Exception qui constitue la cause de l'exception actuelle. + + + Initialise une nouvelle instance de la classe avec un message spécifié décrivant l'erreur. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Représente une méthode à appeler dans un nouveau contexte. + Objet contenant les informations que la méthode de rappel doit utiliser à chacune de ses exécutions. + 1 + + + Représente une primitive de synchronisation qui est signalée lorsque son décompte atteint zéro. + + + Initialise une nouvelle instance de la classe à l'aide du décompte spécifié. + Nombre de signaux initialement requis pour définir . + + est inférieur à 0. + + + Incrémente de un le décompte actuel de . + L'instance actuelle a déjà été supprimée. + L'instance actuelle est déjà définie.ou est supérieur ou égal à . + + + Incrémente d'une valeur spécifiée le décompte actuel de . + Valeur d'incrément de . + L'instance actuelle a déjà été supprimée. + + est inférieur ou égal à 0. + L'instance actuelle est déjà définie.ou est égal à ou supérieur à une fois le nombre été incrémenté par + + + Obtient le nombre de signaux restants requis pour définir l'événement. + Nombre de signaux restants requis pour définir l'événement. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le nombre de signaux initialement requis pour définir l'événement. + Nombre de signaux initialement requis pour définir l'événement. + + + Détermine si l'événement est défini. + true si l'événement est défini ; sinon, false. + + + Réinitialise avec la valeur . + L'instance actuelle a déjà été supprimée. + + + Définit la propriété spécifiée sur la valeur indiquée. + Nombre de signaux requis pour définir . + L'instance actuelle a déjà été supprimée. + + est inférieur à 0. + + + Enregistre un signal avec le , en décrémentant la valeur de . + true si le décompte a atteint zéro en raison du signal et que l'événement a été défini ; sinon, false. + L'instance actuelle a déjà été supprimée. + L'instance actuelle est déjà définie. + + + Inscrit plusieurs signaux avec , en décrémentant la valeur de selon la valeur spécifiée. + true si le décompte a atteint zéro en raison des signaux et que l'événement a été défini ; sinon, false. + Nombre de signaux à inscrire. + L'instance actuelle a déjà été supprimée. + + est inférieur à 1. + L'instance actuelle est déjà définie. - ou - Ou est supérieur à . + + + Essaie d'incrémenter par un. + true si l'incrémentation a réussi ; sinon, false.Si est déjà à zéro, cette méthode retourne la valeur false. + L'instance actuelle a déjà été supprimée. + + est égal à . + + + Essaie d'incrémenter par une valeur spécifiée. + true si l'incrémentation a réussi ; sinon, false.Si est déjà à zéro, la valeur false est retournée. + Valeur d'incrément de . + L'instance actuelle a déjà été supprimée. + + est inférieur ou égal à 0. + L'instance actuelle est déjà définie.ou + est supérieur ou égal à . + + + Bloque le thread actuel jusqu'à ce que soit défini. + L'instance actuelle a déjà été supprimée. + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un entier signé 32 bits permettant de mesurer le délai d'attente. + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce que soit défini, à l'aide d'un entier signé 32 bits permettant de mesurer le délai d'attente, tout en observant un . + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce que soit défini, tout en observant un . + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un permettant de mesurer le délai d'attente. + true si a été défini ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un permettant de mesurer le délai d'attente, tout en observant un . + true si a été défini ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Obtient un qui est utilisé pour attendre l'événement à définir. + + qui est utilisé pour attendre l'événement à définir. + L'instance actuelle a déjà été supprimée. + + + Indique si un est réinitialisé automatiquement ou manuellement après la réception d'un signal. + 2 + + + Une fois signalé, le se réinitialise automatiquement après avoir libéré un seul thread.Si aucun thread n'attend, le conserve l'état signalé jusqu'à ce qu'un thread se bloque et se réinitialise après l'avoir libéré. + + + Lorsqu'il est signalé, le libère tous les threads en attente et conserve l'état signalé jusqu'à sa réinitialisation manuelle. + + + Représente un événement de synchronisation de threads. + 2 + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement et s'il se réinitialise automatiquement ou manuellement. + true pour définir l'état initial comme étant signalé ; false pour le définir comme étant non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement s'il a été créé à la suite de cet appel, s'il se réinitialise automatiquement ou manuellement, ainsi que le nom d'un événement de synchronisation du système. + true pour définir l'état initial comme signalé si l'événement nommé est créé en conséquence de cet appel ; false pour le définir comme non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + Nom d'un événement de synchronisation à l'échelle du système. + Une erreur Win32 s'est produite. + L'événement nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + L'événement nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + dépasse 260 caractères. + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement s'il a été créé à la suite de cet appel, s'il se réinitialise automatiquement ou manuellement, ainsi que le nom d'un événement de synchronisation du système et une variable booléenne dont la valeur après l'appel indique si l'événement système nommé a été créé. + true pour définir l'état initial comme signalé si l'événement nommé est créé en conséquence de cet appel ; false pour le définir comme non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + Nom d'un événement de synchronisation à l'échelle du système. + Cette méthode retourne true si un événement local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si l'événement système nommé spécifié a été créé ; false si l'événement système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + Une erreur Win32 s'est produite. + L'événement nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + L'événement nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + dépasse 260 caractères. + + + Ouvre l'événement de synchronisation nommé spécifié s'il existe déjà. + Objet qui représente l'événement système nommé. + Nom de l'événement de synchronisation système à ouvrir. + + est une chaîne vide. ou dépasse 260 caractères. + + a la valeur null. + L'événement de système nommé n'existe pas. + Une erreur Win32 s'est produite. + L'événement nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Définit l'état de l'événement comme étant non signalé, entraînant le blocage des threads. + true si l'opération aboutit ; sinon, false. + La méthode a été précédemment appelée sur ce . + 2 + + + Définit l'état de l'événement comme étant signalé, ce qui permet à un ou plusieurs threads en attente de continuer. + true si l'opération aboutit ; sinon, false. + La méthode a été précédemment appelée sur ce . + 2 + + + Ouvre l'événement de synchronisation nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si l'événement de synchronisation nommé a été ouvert ; sinon, false. + Nom de l'événement de synchronisation système à ouvrir. + Lorsque cette méthode est retournée, contient un objet qui représente l'événement de synchronisation nommé si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme non initialisé. + + est une chaîne vide.ou dépasse 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + L'événement nommé existe, mais l'utilisateur n'a pas l'accès de sécurité voulu. + + + Gère le contexte d'exécution du thread actuel.Cette classe ne peut pas être héritée. + 2 + + + Capture le contexte d'exécution du thread actuel. + Objet capturant le contexte d'exécution du thread actuel. + 1 + + + Exécute une méthode dans un contexte d'exécution spécifié sur le thread actuel. + + à définir. + Délégué représentant la méthode à exécuter dans le contexte d'exécution fourni. + Objet à passer à la méthode de rappel. + + a la valeur null.ouLe n'a pas été acquis à l'aide d'une opération de capture. ouLe a déjà été utilisé comme argument pour un appel . + 1 + + + + + + Fournit des opérations atomiques pour des variables partagées par plusieurs threads. + 2 + + + Ajoute deux entiers 32 bits et remplace le premier entier par la somme, sous la forme d'une opération atomique. + La nouvelle valeur stockée à . + Variable qui contient la première valeur à ajouter.La somme des deux valeurs est stockée dans . + Valeur à ajouter à l'entier à . + The address of is a null pointer. + 1 + + + Ajoute deux entiers 64 bits et remplace le premier entier par la somme, sous la forme d'une opération atomique. + La nouvelle valeur stockée à . + Variable qui contient la première valeur à ajouter.La somme des deux valeurs est stockée dans . + Valeur à ajouter à l'entier à . + The address of is a null pointer. + 1 + + + Compare deux nombres à virgule flottante double précision et remplace le premier en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux entiers signés de 32 bits et remplace la première valeur en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux entiers signés de 64 bits et remplace la première valeur en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux handles ou pointeurs spécifiques à la plateforme et remplace le premier en cas d'égalité. + Valeur d'origine dans . + + de destination, dont la valeur est comparée à celle de et qui peut être remplacée par . + + qui remplace la valeur de destination si la comparaison conclut à une égalité. + + comparée à la valeur de . + The address of is a null pointer. + 1 + + + Compare deux objets et remplace le premier en cas d'égalité des références. + Valeur d'origine dans . + Objet de destination comparé à et qui peut être remplacé. + Objet qui remplace l'objet de destination si la comparaison conclut à une égalité. + Objet qui est comparé à l'objet se trouvant à . + The address of is a null pointer. + 1 + + + Compare deux nombres à virgule flottante simple précision et remplace le premier en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux instances du type référence spécifié et remplace la première en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée avec et qui peut être remplacée.C'est un paramètre référence (ref en C#, ByRef en Visual Basic). + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + Type à utiliser pour , et .Ce type doit être un type référence. + The address of is a null pointer. + + + Décrémente une variable spécifiée et stocke le résultat, sous la forme d'une opération atomique. + Valeur décrémentée. + Variable dont la valeur doit être décrémentée. + The address of is a null pointer. + 1 + + + Décrémente la variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur décrémentée. + Variable dont la valeur doit être décrémentée. + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un nombre à virgule flottante double précision, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte un entier signé 32 bits à une valeur spécifiée, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un entier signé 64 bits, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un handle ou un pointeur spécifique à la plateforme, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un objet, puis retourne une référence à l'objet d'origine sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un nombre à virgule flottante simple précision, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à une variable du type spécifié et retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée.C'est un paramètre référence (ref en C#, ByRef en Visual Basic). + Valeur affectée au paramètre . + Type à utiliser pour et .Ce type doit être un type référence. + The address of is a null pointer. + + + Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur incrémentée. + Variable dont la valeur doit être incrémentée. + The address of is a null pointer. + 1 + + + Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur incrémentée. + Variable dont la valeur doit être incrémentée. + The address of is a null pointer. + 1 + + + Synchronise l'accès à la mémoire comme suit : le processeur qui exécute le thread actuel ne peut pas réorganiser les instructions de sorte que les accès à la mémoire avant l'appel de s'exécutent après les accès à la mémoire postérieurs à l'appel de . + + + Retourne une valeur 64 bits chargée sous la forme d'une opération atomique. + Valeur chargée. + Valeur 64 bits à charger. + 1 + + + Fournit des routines d'initialisation tardives. + + + Initialise un type référence cible avec le constructeur par défaut du type s'il n'a pas déjà été initialisé. + Référence initialisée de type . + Référence de type à initialiser si elle ne l'a pas déjà été. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible ou un type valeur avec son constructeur par défaut s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence ou valeur de type à initialiser si elle ne l'a pas déjà été. + Référence à une valeur booléenne qui détermine si la cible a déjà été initialisée. + Référence à un objet utilisé comme verrou mutuellement exclusif pour l'initialisation de .Si est null null, un nouvel objet est instancié. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible ou un type valeur à l'aide d'une fonction spécifiée s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence ou valeur de type à initialiser si elle ne l'a pas déjà été. + Référence à une valeur booléenne qui détermine si la cible a déjà été initialisée. + Référence à un objet utilisé comme verrou mutuellement exclusif pour l'initialisation de .Si est null null, un nouvel objet est instancié. + Fonction appelée pour initialiser la référence ou la valeur. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible à l'aide d'une fonction spécifiée s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence de type à initialiser si elle ne l'a pas déjà été. + Fonction appelée pour initialiser la référence. + Type référence de la référence à initialiser. + Le type n'a pas de constructeur par défaut. + + a retourné null (Nothing en Visual Basic). + + + L'exception levée lorsque l'entrée récursive dans un verrou n'est pas compatible avec la stratégie de récurrence pour le verrou. + 2 + + + Initialise une nouvelle instance de la classe avec un message système qui décrit l'erreur. + 2 + + + Initialise une nouvelle instance de la classe avec un message spécifié décrivant l'erreur. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture système en cours. + 2 + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture système en cours. + Exception qui a provoqué l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + 2 + + + Spécifie si un verrou peut être entré plusieurs fois par le même thread. + + + Si un thread essaie d'entrer un verrou de manière récursive, une exception est levée.Certaines classes peuvent autoriser certaines récurrences lorsque ce paramètre est appliqué. + + + Un thread peut entrer un verrou de manière récursive.Certaines classes peuvent restreindre cette fonction. + + + Avertit un ou plusieurs threads en attente qu'un événement s'est produit.Cette classe ne peut pas être héritée. + 2 + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini comme signalé. + true pour définir un état initial signalé ; false pour définir un état initial non signalé. + + + Fournit une version allégée de . + + + Initialise une nouvelle instance de la classe avec l'état initial "non signalé". + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé". + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé" et un nombre de spins spécifié. + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + Nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + + is less than 0 or greater than the maximum allowed value. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient une valeur qui indique si l'événement est défini. + true si l'événement a été défini ; sinon, false. + + + Définit l'état de l'événement à "non signalé", ce qui entraîne le blocage des threads. + The object has already been disposed. + + + Définit l'état de l'événement à "signalé", ce qui permet à un ou plusieurs threads en attente sur l'événement de continuer à s'exécuter. + + + Obtient le nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + Retourne le nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps. + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps, tout en observant un . + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel reçoive un signal, tout en observant un . + + à observer. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un pour mesurer l'intervalle de temps. + true si a été défini ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde pour un délai d'attente infini. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un pour mesurer l'intervalle de temps, tout en observant un . + true si a été défini ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde pour un délai d'attente infini. + + à observer. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Obtient l'objet sous-jacent pour ce . + Objet d'événement sous-jacent pour ce . + + + Fournit un mécanisme qui synchronise l'accès aux objets. + 2 + + + Acquiert un verrou exclusif sur l'objet spécifié. + Objet sur lequel acquérir le verrou du moniteur. + Le paramètre a la valeur null. + 1 + + + Acquiert un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel attendre. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou.Remarque   Si aucune exception ne se produit, la sortie de cette méthode est toujours true. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + + Libère un verrou exclusif sur l'objet spécifié. + Objet sur lequel libérer le verrou. + Le paramètre a la valeur null. + Le thread en cours ne possède pas le verrou pour l'objet spécifié. + 1 + + + Détermine si le thread actuel détient le verrou sur l'objet spécifié. + true si le thread actuel détient le verrou sur  ; sinon, false. + Objet à tester. + + a la valeur null. + + + Avertit un thread situé dans la file d'attente en suspens d'un changement d'état de l'objet verrouillé. + Objet attendu par un thread. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + 1 + + + Avertit tous les threads en attente d'un changement d'état de l'objet. + Objet qui envoie l'impulsion. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + 1 + + + Essaie d'acquérir un verrou exclusif sur l'objet spécifié. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + Le paramètre a la valeur null. + 1 + + + Tente d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + + Tentatives d'acquisition d'un verrou exclusif sur l'objet spécifié au cours du nombre spécifié de millisecondes. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou en millisecondes. + Le paramètre a la valeur null. + + est négatif et différent de . + 1 + + + Tente, pendant le nombre spécifié de millisecondes, d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou en millisecondes. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + est négatif et différent de . + + + Tentatives d'acquisition d'un verrou exclusif sur l'objet spécifié au cours de la période spécifiée. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + + représentant le délai d'attente du verrou.Une valeur de –1 milliseconde spécifie une attente infinie. + Le paramètre a la valeur null. + La valeur en millisecondes de est négative et différente de (–1 milliseconde), ou elle est supérieure à . + 1 + + + Tente, pendant le délai spécifié, d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou.Une valeur de –1 milliseconde spécifie une attente infinie. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + La valeur en millisecondes de est négative et différente de (–1 milliseconde), ou elle est supérieure à . + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou. + true si l'appel est retourné car l'appelant a de nouveau acquis le verrou pour l'objet spécifié.Cette méthode ne retourne rien si le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + 1 + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou.Si le délai d'attente spécifié est écoulé, le thread intègre la file d'attente opérationnelle. + true si le verrou a fait l'objet d'une nouvelle acquisition avant l'expiration du délai spécifié ; false si le verrou a fait l'objet d'une nouvelle acquisition après l'expiration du délai spécifié.La méthode ne retourne pas de valeur tant que le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + Nombre de millisecondes à attendre avant que le thread intègre la file d'attente opérationnelle. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + La valeur du paramètre est négative et différente de . + 1 + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou.Si le délai d'attente spécifié est écoulé, le thread intègre la file d'attente opérationnelle. + true si le verrou a fait l'objet d'une nouvelle acquisition avant l'expiration du délai spécifié ; false si le verrou a fait l'objet d'une nouvelle acquisition après l'expiration du délai spécifié.La méthode ne retourne pas de valeur tant que le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + + qui représente le temps à attendre avant que le thread n'intègre la file d'attente opérationnelle. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + La valeur en millisecondes du paramètre est négative et ne représente pas (–1 milliseconde) ou est supérieure à . + 1 + + + Primitive de synchronisation qui peut également être utilisée pour la synchronisation entre processus. + 1 + + + Initialise une nouvelle instance de la classe avec des propriétés par défaut. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex. + true pour accorder au thread appelant la propriété initiale du mutex ; sinon, false. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, et une chaîne représentant le nom du mutex. + true pour donner au thread appelant la propriété initiale du mutex système nommé si celui-ci est créé en réponse à cet appel ; sinon, false. + Nom du .Si cette valeur est null, est sans nom. + Le mutex nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + Une erreur Win32 s'est produite. + Le mutex nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + est plus de 260 caractères. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, une chaîne qui représente le nom du mutex et une valeur booléenne qui, quand la méthode retourne son résultat, indique si la propriété initiale du mutex a été accordée au thread appelant. + true pour donner au thread appelant la propriété initiale du mutex système nommé si celui-ci est créé en réponse à cet appel ; sinon, false. + Nom du .Si cette valeur est null, est sans nom. + Cette méthode retourne une valeur booléenne qui est true si un mutex local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si le mutex système nommé spécifié a été créé ; false si le mutex système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + Le mutex nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + Une erreur Win32 s'est produite. + Le mutex nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + est plus de 260 caractères. + + + Ouvre le mutex nommé spécifié, s'il existe déjà. + Objet qui représente le mutex système nommé. + Nom du mutex système à ouvrir. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Le mutex nommé n'existe pas. + Une erreur Win32 s'est produite. + Le mutex nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Libère l'objet une seule fois. + Le thread appelant ne possède pas le mutex. + 1 + + + Ouvre le mutex nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si le mutex nommé a été ouvert ; sinon, false. + Nom du mutex système à ouvrir. + Quand cette méthode est retournée, contient un objet qui représente la structure mutex nommée si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme étant non initialisé. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + Le mutex nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + + + Représente un verrou utilisé pour gérer l'accès à une ressource, en autorisant plusieurs threads pour la lecture ou un accès exclusif en écriture. + + + Initialise une nouvelle instance de la classe avec des valeurs de propriété par défaut. + + + Initialise une nouvelle instance de la classe , en spécifiant la stratégie de récurrence du verrou. + Une des valeurs d'énumération qui spécifie la stratégie de récurrence du verrou. + + + Obtient le nombre total de threads uniques qui ont entré le verrou en mode lecture. + Nombre de threads uniques qui ont entré le verrou en mode lecture. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Essaie d'entrer le verrou en mode lecture. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Réduit le nombre de récurrences pour le mode lecture, et quitte le mode lecture si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in read mode. + + + Réduit le nombre de récurrences pour le mode pouvant être mis à niveau, et quitte le mode pouvant être mis à niveau si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in upgradeable mode. + + + Réduit le nombre de récurrences pour le mode écriture, et quitte le mode écriture si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in write mode. + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode lecture. + true si le thread actuel a entré le verrou en mode lecture ; sinon, false. + 2 + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode pouvant être mis à niveau. + true si le thread actuel a entré le verrou en mode pouvant être mis à niveau ; sinon, false. + 2 + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode écriture. + true si le thread actuel a entré le verrou en mode écriture ; sinon, false. + 2 + + + Obtient une valeur qui indique la stratégie de récurrence pour l'objet actuel. + Une des valeurs d'énumération qui spécifie la stratégie de récurrence du verrou. + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode lecture, comme une indication de récurrence. + 0 (zéro) si le thread actuel n'a pas entré le verrou en mode lecture, 1 si le thread a entré le verrou en mode lecture mais pas de façon récursive, ou n si le thread a entré le verrou de façon récursive n - 1 fois. + 2 + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode pouvant être mis à niveau, comme une indication de récurrence. + 0 si le thread actuel n'a pas entré le verrou en mode pouvant être mis à niveau, 1 si le thread a entré le verrou en mode pouvant être mis à niveau mais pas de façon récursive, ou n si le thread a entré le verrou en mode pouvant être mis à niveau de façon récursive n - 1 fois. + 2 + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode écriture, comme une indication de récurrence. + 0 si le n si le thread a entré le verrou en mode écriture de façon récursive n - 1 fois. + 2 + + + Essaie d'entrer le verrou en mode lecture, avec un délai d'attente entier facultatif. + true si le thread appelant est entré en mode lecture, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode lecture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode lecture, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode de mise à niveau, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode de mise à niveau, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode écriture, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode écriture, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode lecture. + Nombre total de threads qui attendent pour entrer en mode lecture. + 2 + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode pouvant être mis à niveau. + Nombre total de threads qui attendent pour entrer en mode pouvant être mis à niveau. + 2 + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode écriture. + Nombre total de threads qui attendent pour entrer en mode écriture. + 2 + + + Limite le nombre des threads qui peuvent accéder simultanément à une ressource ou un pool de ressources. + 1 + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est supérieur à . + + est inférieur à 1.ou est inférieur à 0. + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées, et en spécifiant en option le nom d'un objet sémaphore système. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nom d'un objet de sémaphore système nommé. + + est supérieur à .ou est plus de 260 caractères. + + est inférieur à 1.ou est inférieur à 0. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe et possède la sécurité du contrôle d'accès, et l'utilisateur n'a pas . + Le sémaphore nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées, en spécifiant en option le nom d'un objet sémaphore système et en spécifiant une variable qui reçoit une valeur indiquant si un sémaphore système a été créé. + Nombre initial de demandes pour le sémaphore qui peut être satisfait simultanément. + Nombre maximal de demandes pour le sémaphore qui peut être satisfait simultanément. + Nom d'un objet de sémaphore système nommé. + Cette méthode retourne true si un sémaphore local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si le sémaphore système nommé spécifié a été créé ; false si le sémaphore système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + + est supérieur à . ou est plus de 260 caractères. + + est inférieur à 1.ou est inférieur à 0. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe et possède la sécurité du contrôle d'accès, et l'utilisateur n'a pas . + Le sémaphore nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + + Ouvre le sémaphore nommé spécifié s'il existe déjà. + Objet qui représente le sémaphore système nommé. + Nom du sémaphore système à ouvrir. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Le sémaphore nommé n'existe pas. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Quitte le sémaphore et retourne le compteur antérieur. + Compteur du sémaphore avant appel de la méthode . + Le compteur du sémaphore est déjà à la valeur maximale. + Une erreur Win32 s'est produite avec un sémaphore nommé. + Le sémaphore actuel représente un sémaphore système nommé, mais l'utilisateur ne détient pas de droits .ouLe sémaphore actuel représente un sémaphore système nommé, mais il n'a pas été ouvert avec des droits . + 1 + + + Quitte le sémaphore un nombre spécifié de fois et retourne le compteur précédent. + Compteur du sémaphore avant appel de la méthode . + Nombre de fois où quitter le sémaphore. + + est inférieur à 1. + Le compteur du sémaphore est déjà à la valeur maximale. + Une erreur Win32 s'est produite avec un sémaphore nommé. + Le sémaphore actuel représente un sémaphore système nommé, mais l'utilisateur ne détient pas de droits .ouLe sémaphore actuel représente un sémaphore système nommé, mais il n'a pas été ouvert avec des droits . + 1 + + + Ouvre le sémaphore nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si le sémaphore nommé a été ouvert ; sinon, false. + Nom du sémaphore système à ouvrir. + Quand cette méthode est retournée, contient un objet qui représente le sémaphore nommé si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme étant non initialisé. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + + + Exception levée lorsque la méthode est appelée sur un sémaphore dont le compteur est déjà au maximum. + 2 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Représente une alternative légère à qui limite le nombre de threads pouvant accéder simultanément à une ressource ou à un pool de ressources. + + + Initialise une nouvelle instance de la classe , en spécifiant le nombre initial de demandes qui peuvent être accordées simultanément. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est inférieur à 0. + + + Initialise une nouvelle instance de la classe , en spécifiant le nombre initial et le nombre maximal de demandes qui peuvent être accordées simultanément. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est inférieur à 0 ou est supérieur à ou est inférieur ou égal à 0. + + + Retourne un qui peut être utilisé pour l'attente sur le sémaphore. + + qui peut être utilisé pour l'attente sur le sémaphore. + + a été supprimé. + + + Obtient le nombre de threads restants qui peuvent accéder à l'objet . + Nombre de threads restants qui peuvent accéder au sémaphore. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par le , et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Libère l'objet une seule fois. + Décompte précédent de . + L'instance actuelle a déjà été supprimée. + Le a déjà atteint sa taille maximale. + + + Libère l'objet un nombre de fois déterminé. + Décompte précédent de . + Nombre de fois où quitter le sémaphore. + L'instance actuelle a déjà été supprimée. + + est inférieur à 1. + Le a déjà atteint sa taille maximale. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à . + L'instance actuelle a déjà été supprimée. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un entier signé 32 bits qui spécifie le délai d'attente. + true si le thread actuel a accédé avec succès à  ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un entier signé 32 bits qui spécifie le délai d'attente, tout en observant un . + true si le thread actuel a accédé avec succès à  ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + Le instance a été supprimée, ou qui créé a été supprimé. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , tout en observant un . + Jeton à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée.ouLes créés a déjà été supprimé. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un pour spécifier le délai d'attente. + true si le thread actuel a accédé avec succès à  ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde de seconde, pour attendre indéfiniment. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + L'instance de semaphoreSlim a été supprimée + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un qui spécifie le délai d'attente, tout en observant un . + true si le thread actuel a accédé avec succès à  ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente -1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + L'instance de semaphoreSlim a été suppriméeLe qui a créé a déjà été supprimé. + + + Attend de façon asynchrone avant d'accéder à . + Tâche qui se termine après l'accès au sémaphore. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps. + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps, tout en observant un . + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + a été annulé. + + + Attend de façon asynchrone d'accéder à , tout en observant un . + Tâche qui se termine après l'accès au sémaphore. + Jeton à observer. + L'instance actuelle a déjà été supprimée. + + a été annulé. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un pour mesurer l'intervalle de temps. + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. ou délai d'attente supérieur à . + + + Attend de façon asynchrone d'accéder à , à l'aide d'un pour mesurer l'intervalle de temps, tout en observant un . + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente -1 millième de seconde, pour attendre indéfiniment. + Jeton à observer. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini.oudélai d'attente supérieur à . + + a été annulé. + + + Représente une méthode à appeler lorsqu'un message doit être distribué à un contexte de synchronisation. + Objet passé au délégué. + 2 + + + Fournit une primitive de verrou d'exclusion mutuelle où un thread qui tente d'acquérir le verrou attend dans une boucle en vérifiant de manière répétée jusqu'à ce que le verrou devienne disponible. + + + Initialise une nouvelle instance de la structure de avec l'option permettant de suivre les ID de thread afin d'améliorer le débogage. + Indique s'il faut capturer et utiliser des ID de thread à des fins de débogage. + + + Acquiert le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + L'argument doit être initialisé sur false avant d'appeler ENTRÉE. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Libère le verrou. + Le suivi de la propriété du thread est autorisé, et le thread actuel n'est pas le propriétaire de ce verrou. + + + Libère le verrou. + Valeur booléenne qui indique si une barrière mémoire doit être émise pour publier immédiatement l'opération de sortie sur d'autres threads. + Le suivi de la propriété du thread est autorisé, et le thread actuel n'est pas le propriétaire de ce verrou. + + + Obtient une valeur qui indique si le verrou est actuellement détenu par un thread. + True si le verrou est actuellement détenu par un thread ; sinon, false. + + + Obtient une valeur qui indique si le verrou est détenu par le thread actuel. + True si le verrou est détenu par le thread actuel ; sinon, false. + Le suivi de la propriété du thread est désactivé. + + + Obtient une valeur qui indique si le suivi de la propriété des threads est activé pour cette instance. + True si le suivi de la propriété du thread est autorisé pour cette instance ; sinon, false. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini - ou - le délai d'attente est supérieur à millisecondes. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Fournit une prise en charge de l'attente basée sur les spins. + + + Obtient le nombre de fois où a été appelé sur cette instance. + Retourne un entier qui représente le nombre d'appels de sur cette instance. + + + Obtient une valeur qui indique si l'appel suivant à générera le processeur, en déclenchant un changement de contexte forcé. + Indique si l'appel suivant à générera le processeur, en déclenchant un changement de contexte forcé. + + + Réinitialise le compteur de spins. + + + Exécute un seul spin. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + L'argument a la valeur null. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite ou jusqu'à ce que le délai d'attente expire. + True si la condition est satisfaite dans le délai d'attente ; sinon, false. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'argument a la valeur null. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite ou jusqu'à ce que le délai d'attente expire. + True si la condition est satisfaite dans le délai d'attente ; sinon, false. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + + qui représente le nombre de millièmes de secondes à attendre, ou TimeSpan qui représente -1 millième de seconde pour attendre indéfiniment. + L'argument a la valeur null. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Fournit les fonctionnalités de base pour propager un contexte de synchronisation dans plusieurs modèles de synchronisation. + 2 + + + Crée une instance de la classe . + + + En cas de substitution dans une classe dérivée, crée une copie du contexte de synchronisation. + Nouvel objet . + 2 + + + Obtient le contexte de synchronisation du thread actuel. + Objet représentant le contexte de synchronisation actuel. + 1 + + + Lors d'une substitution dans une classe dérivée, répond à la notification selon laquelle une opération est terminée. + + + Lors d'une substitution dans une classe dérivée, répond à la notification selon laquelle une opération est lancée. + + + Lors d'une substitution dans une classe dérivée, distribue un message asynchrone à un contexte de synchronisation. + Délégué à appeler. + Objet passé au délégué. + 2 + + + Lors d'une substitution dans une classe dérivée, distribue un message synchrone à un contexte de synchronisation. + Délégué à appeler. + Objet passé au délégué. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Définit le contexte de synchronisation actuel. + Objet à définir. + 1 + + + + + + Exception levée lorsqu'une méthode exige de l'appelant qu'il possède un verrou sur un objet Monitor donné et que la méthode est appelée par un appelant qui ne possède pas ce verrou. + 2 + + + Initialise une nouvelle instance de la classe avec des propriétés par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Fournit le stockage local des données de thread. + Spécifie le type de données stockées par thread. + + + Initialise l'instance de . + + + Initialise l'instance de . + Indique s'il faut suivre toutes les valeurs définies dans l'instance et les exposer via la propriété . + + + Initialise l'instance de avec la fonction spécifiée. + + appelé pour produire une valeur initialisée tardivement lorsqu'une tentative est effectuée pour récupérer sans qu'il ait été précédemment initialisé. + + est une référence null (Nothing en Visual Basic). + + + Initialise l'instance de avec la fonction spécifiée. + + appelé pour produire une valeur initialisée tardivement lorsqu'une tentative est effectuée pour récupérer sans qu'il ait été précédemment initialisé. + Indique s'il faut suivre toutes les valeurs définies dans l'instance et les exposer via la propriété . + + est une référence null (Nothing en Visual Basic). + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources utilisées par cette instance de . + Valeur booléenne qui indique si cette méthode est appelée en raison d'un appel à . + + + Libère les ressources utilisées par cette instance de . + + + Obtient une valeur qui indique si est initialisé sur le thread actuel. + True si est initialisé sur le thread actuel ; sinon, false. + L'instance de a été supprimée. + + + Crée et retourne une représentation sous forme de chaîne de cette instance pour le thread actuel. + Résultat de l'appel à sur . + L'instance de a été supprimée. + Le du thread actuel est une référence null (Nothing en Visual Basic). + La fonction d'initialisation a tenté de référencer de manière récursive. + Aucun constructeur par défaut n'est fourni et aucune fabrique de valeurs n'est fournie. + + + Obtient ou définit la valeur de cette instance pour le thread actuel. + Retourne une instance de l'objet dont ce ThreadLocal est chargé de l'initialisation. + L'instance de a été supprimée. + La fonction d'initialisation a tenté de référencer de manière récursive. + Aucun constructeur par défaut n'est fourni et aucune fabrique de valeurs n'est fournie. + + + Obtient une liste de toutes les valeurs actuellement stockées par tous les threads qui ont accès à cette instance. + Liste de toutes les valeurs actuellement stockées par tous les threads qui ont accès à cette instance. + L'instance de a été supprimée. + + + Contient des méthodes permettant d'effectuer des opérations de mémoire volatile. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la référence d'objet à partir du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Référence à qui a été lue.Il s'agit de la dernière référence écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + Type du champ à lire.Il doit s'agir d'un type référence, et non d'un type valeur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de mémoire apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la référence d'objet spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la référence d'objet est écrite. + Référence d'objet à écrire.La référence est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + Type du champ dans lequel écrire.Il doit s'agir d'un type référence, et non d'un type valeur. + + + Exception levée lors d'une tentative d'ouverture d'un mutex système ou d'un sémaphore qui n'existe pas. + 2 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/it/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/it/System.Threading.xml new file mode 100644 index 000000000..3446f031d --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/it/System.Threading.xml @@ -0,0 +1,1800 @@ + + + + System.Threading + + + + Eccezione generata quando un thread acquisisce un oggetto che un altro thread ha abbandonato uscendo senza rilasciarlo. + 1 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un indice specificato per il mutex abbandonato, se applicabile, e un oggetto che rappresenta il mutex. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo o –1 se l'eccezione viene generata per i metodi o . + Oggetto che rappresenta il mutex abbandonato. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore che spiega il motivo dell'eccezione. + + + Inizializza una nuova istanza della classe con il messaggio di errore e l'eccezione interna specificati. + Messaggio di errore che spiega il motivo dell'eccezione. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente verrà generata in un blocco catch che gestisce l'eccezione interna. + + + Inizializza una nuova istanza della classe con il messaggio di errore, l'eccezione interna, l'indice per il mutex abbandonato, se applicabile, specificati e un oggetto che rappresenta il mutex. + Messaggio di errore che spiega il motivo dell'eccezione. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente verrà generata in un blocco catch che gestisce l'eccezione interna. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo , –1 se l'eccezione viene generata per il metodo o . + Oggetto che rappresenta il mutex abbandonato. + + + Inizializza una nuova istanza della classe con il messaggio di errore, l'indice del mutex abbandonato, se applicabile, e il mutex abbandonato specificati. + Messaggio di errore che spiega il motivo dell'eccezione. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo , –1 se l'eccezione viene generata per il metodo o . + Oggetto che rappresenta il mutex abbandonato. + + + Ottiene il mutex abbandonato che ha causato l'eccezione, se noto. + Oggetto che rappresenta il mutex abbandonato oppure null se il mutex abbandonato non è stato identificato. + 1 + + + Ottiene l'indice del mutex abbandonato che ha causato l'eccezione, se noto. + Nella matrice degli handle in attesa passati al metodo , indice dell'oggetto che rappresenta il mutex abbandonato oppure –1 se l'indice del mutex abbandonato non è stato determinato. + 1 + + + Rappresenta dati di ambiente locali rispetto a un flusso di controllo asincrono specificato, ad esempio un metodo asincrono. + Tipo dei dati di ambiente. + + + Crea un'istanza dell'istanza di che non riceve notifiche di modifica. + + + Crea un'istanza dell'istanza di locale che riceve notifiche di modifica. + Delegato chiamato ogni volta che il valore corrente cambia in qualsiasi thread. + + + Ottiene o imposta il valore dei dati di ambiente. + Valore dei dati di ambiente. + + + Classe che fornisce le informazioni di modifica dei dati alle istanze di registrate per le notifiche di modifica. + Tipo di dati. + + + Ottiene il valore corrente dei dati. + Valore corrente dei dati. + + + Ottiene il valore precedente dei dati. + Valore precedente dei dati. + + + Restituisce un valore che indica se il valore cambia a seguito di una modifica del contesto di esecuzione. + true se il valore è cambiato a seguito di una modifica del contesto di esecuzione; in caso contrario, false. + + + Notifica a un thread in attesa che si è verificato un evento.La classe non può essere ereditata. + 2 + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato. + true per impostare lo stato iniziale su segnalato; false per impostare lo stato iniziale su non segnalato. + + + Consente a più attività di funzionare cooperativamente in un algoritmo in parallelo tramite più fasi. + + + Inizializza una nuova istanza della classe . + Numero di thread che partecipano. + + è minore di 0 o maggiore di 32,767. + + + Inizializza una nuova istanza della classe . + Numero di thread che partecipano. + Oggetto da eseguire dopo ogni fase. Può essere passato Null (Nothing in Visual Basic) per indicare che non è stata intrapresa alcuna azione. + + è minore di 0 o maggiore di 32,767. + + + Notifica all'oggetto che sarà presente un partecipante aggiuntivo. + Numero di fase della barriera in corrispondenza di cui parteciperanno inizialmente i nuovi partecipanti. + L'istanza corrente è già stata eliminata. + L'aggiunta di un partecipante provocherebbe il superamento del conteggio del partecipante della barriera di 32.767.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Notifica all'oggetto che saranno presenti partecipanti aggiuntivi. + Numero di fase della barriera in corrispondenza di cui parteciperanno inizialmente i nuovi partecipanti. + Numero di partecipanti aggiuntivi da aggiungere alla barriera. + L'istanza corrente è già stata eliminata. + + è minore di 0.- oppure -L'aggiunta di partecipanti provocherebbe il superamento del conteggio del partecipante della barriera di 32.767. + Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Ottiene il numero di fase corrente della barriera. + Restituisce il numero di fase corrente della barriera. + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo quelle non gestite. + + + Ottiene il numero totale di partecipanti nella barriera. + Restituisce il numero totale di partecipanti nella barriera. + + + Ottiene il numero di partecipanti nella barriera che non hanno ancora eseguito la segnalazione nella fase corrente. + Restituisce il numero di partecipanti nella barriera che non hanno ancora eseguito la segnalazione nella fase corrente. + + + Notifica all'oggetto che sarà presente un partecipante in meno. + L'istanza corrente è già stata eliminata. + La barriera dispone già di 0 partecipanti.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Notifica all'oggetto che saranno presenti meno partecipanti. + Numero di partecipanti aggiuntivi da rimuovere dalla barriera. + L'istanza corrente è già stata eliminata. + + è minore di 0. + La barriera dispone già di 0 partecipanti.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. - oppure -il conteggio del partecipante corrente è minore del conteggio del partecipante specificato + Il conteggio totale dei partecipanti è minore del specificato + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti. + L'istanza corrente è già stata eliminata. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + Se un'eccezione viene generata da un'azione post-fase di una Barriera dopo che tutti thread che partecipano hanno chiamato SignalAndWait, l'eccezione verrà sottoposta a wrapping in un BarrierPostPhaseException e sarà generata su tutti i thread che partecipano. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un Signed Integer a 32 bit per misurare il timeout. + true se tutti i partecipanti raggiungono la barriera entro il tempo specificato; in caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + Se un'eccezione viene generata da un'azione post-fase di una Barriera dopo che tutti thread che partecipano hanno chiamato SignalAndWait, l'eccezione verrà sottoposta a wrapping in un BarrierPostPhaseException e sarà generata su tutti i thread che partecipano. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un Signed Integer a 32 bit per misurare il timeout, al contempo osservando un token di annullamento. + true se tutti i partecipanti raggiungono la barriera entro il tempo specificato; in caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, al contempo osservando un token di annullamento. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un oggetto per misurare l'intervallo di tempo. + true se tutti gli altri partecipanti hanno raggiunto la barriera. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito, oppure è più grande di 32.767. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un oggetto per misurare l'intervallo di tempo, al contempo osservando un token di annullamento. + true se tutti gli altri partecipanti hanno raggiunto la barriera. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Eccezione generata quando l'azione post-fase di un oggetto non viene eseguita correttamente. + + + Inizializza una nuova istanza della classe con un messaggio fornito dal sistema in cui viene descritto l'errore. + + + Inizializza una nuova istanza della classe con l'eccezione interna specificata. + Eccezione causa dell'eccezione corrente. + + + Inizializza una nuova istanza della classe con un messaggio specifico in cui viene descritto l'errore. + Messaggio in cui viene descritta l'eccezione.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio in cui viene descritta l'eccezione.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Rappresenta un metodo da chiamare all'interno di un nuovo contesto. + Oggetto contenente informazioni che devono essere utilizzate dal metodo di callback ogni volta che viene eseguito. + 1 + + + Rappresenta un primitiva di sincronizzazione segnalata quando il relativo conteggio raggiunge lo zero. + + + Inizializza una nuova istanza della classe con il conteggio specificato. + Numero di segnali inizialmente richiesti per impostare l'oggetto . + + è minore di 0. + + + Incrementa di uno il conteggio corrente di . + L'istanza corrente è già stata eliminata. + L'istanza corrente è già impostata.- oppure - è maggiore di o uguale a . + + + Incrementa di un valore specificato il conteggio corrente di . + Valore che indica l'incremento di . + L'istanza corrente è già stata eliminata. + + è minore o uguale a 0. + L'istanza corrente è già impostata.- oppure - è uguale o maggiore a dopo che il conteggio è incrementato da + + + Ottiene il numero di segnali restanti necessari per impostare l'evento. + Numero di segnali restanti necessari per impostare l'evento. + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo quelle non gestite. + + + Ottiene il numero di segnali necessari inizialmente per impostare l'evento. + Numero di segnali necessari inizialmente per impostare l'evento. + + + Determina se l'evento è impostato. + true se l'evento è impostato, altrimenti false. + + + Reimposta sul valore di . + L'istanza corrente è già stata eliminata. + + + Reimposta la proprietà al valore specificato. + Numero di segnali necessari per impostare l'oggetto . + L'istanza corrente è già stata eliminata. + + è minore di 0. + + + Registra un segnale con l'oggetto , decrementando il valore di . + true se il conteggio ha raggiunto lo zero a causa del segnale e l'evento è stato impostato. In caso contrario, false. + L'istanza corrente è già stata eliminata. + L'istanza corrente è già impostata. + + + Registra più segnali con l'oggetto , decrementandone il valore di della quantità specificata. + true se il conteggio ha raggiunto lo zero a causa dei segnali e l'evento è stato impostato. In caso contrario, false. + Numero di segnali da registrare. + L'istanza corrente è già stata eliminata. + + è minore di 1. + L'istanza corrente è già impostata. oppure è maggiore di . + + + Tenta di incrementare di uno. + true se l'incremento ha avuto esito positivo. In caso contrario, false.Se è già zero, questo metodo restituirà false. + L'istanza corrente è già stata eliminata. + + è uguale a . + + + Tenta di incrementare in base a un valore specificato. + true se l'incremento ha avuto esito positivo. In caso contrario, false.Se è già zero, verrà restituito false. + Valore che indica l'incremento di . + L'istanza corrente è già stata eliminata. + + è minore o uguale a 0. + L'istanza corrente è già impostata.- oppure - + è uguale o maggiore di . + + + Blocca il thread corrente finché l'oggetto non viene impostato. + L'istanza corrente è già stata eliminata. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un intero con segno a 32 bit per misurare il timeout. + true se è stato impostato. In caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un intero con segno a 32 bit per misurare il timeout e al contempo osservando un oggetto . + true se è stato impostato. In caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, al contempo osservando un oggetto . + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un oggetto per misurare il timeout. + true se è stato impostato. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un oggetto per misurare il timeout e al contempo osservando un oggetto . + true se è stato impostato. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Ottiene un oggetto utilizzato per attendere l'impostazione dell'evento. + Oggetto utilizzato per attendere l'impostazione dell'evento. + L'istanza corrente è già stata eliminata. + + + Indica se verrà reimpostato automaticamente o manualmente dopo la ricezione di un segnale. + 2 + + + Con la segnalazione, viene reimpostato automaticamente dopo il rilascio di un singolo thread.Se non sono presenti thread in attesa, resta segnalato fino al blocco di un thread e viene reimpostato dopo il rilascio del thread. + + + Con la segnalazione, rilascia tutti i thread in attesa e resta segnalato finché non viene reimpostato manualmente. + + + Rappresenta un evento di sincronizzazione dei thread. + 2 + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato e se la reimpostazione viene eseguita automaticamente o manualmente. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato se creato a seguito di questa chiamata e se la reimpostazione viene eseguita automaticamente o manualmente e indicando il nome di un evento di sincronizzazione di sistema. + true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato in seguito a questa chiamata; false per impostare lo stato su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + Nome di un evento di sincronizzazione a livello di sistema. + Si è verificato un errore Win32. + L'evento denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non possiede i diritti . + Non è possibile creare l'evento denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è di lunghezza superiore a 260 caratteri. + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato se creato a seguito di questa chiamata e se la reimpostazione viene eseguita automaticamente o manualmente e indicando il nome di un evento di sincronizzazione di sistema e una variabile Boolean il cui valore dopo la chiamata specifica se l'evento di sistema denominato è stato creato. + true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato in seguito a questa chiamata; false per impostare lo stato su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + Nome di un evento di sincronizzazione a livello di sistema. + Quando questo metodo viene restituito, contiene true se è stato creato un evento locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato l'evento di sistema denominato specificato; false se l'evento di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + Si è verificato un errore Win32. + L'evento denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non possiede i diritti . + Non è possibile creare l'evento denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è di lunghezza superiore a 260 caratteri. + + + Apre l'evento di sincronizzazione denominato specificato, se esistente. + Oggetto che rappresenta l'evento di sistema denominato. + Nome dell'evento di sincronizzazione del sistema da aprire. + + è una stringa vuota. In alternativa è di lunghezza superiore a 260 caratteri. + + è null. + L'evento di sistema denominato non esiste. + Si è verificato un errore Win32. + L'evento denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread. + true se l'operazione ha esito positivo; in caso contrario, false. + Il metodo non è stato chiamato precedentemente in questo oggetto . + 2 + + + Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa di procedere. + true se l'operazione ha esito positivo; in caso contrario, false. + Il metodo non è stato chiamato precedentemente in questo oggetto . + 2 + + + Apre l'evento di sincronizzazione denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è stata completata. + true se l'evento di sincronizzazione denominato è stato aperto correttamente; in caso contrario, false. + Nome dell'evento di sincronizzazione del sistema da aprire. + Quando viene eseguita la restituzione del metodo, contiene un oggetto di che rappresenta l'evento di sincronizzazione denominato se la chiamata ha esito positivo, o null se la chiamata ha esito negativo.Questo parametro viene trattato come non inizializzato. + + è una stringa vuota.In alternativa è di lunghezza superiore a 260 caratteri. + + è null. + Si è verificato un errore Win32. + L'evento denominato esiste, ma l'utente non dispone dell'accesso di sicurezza desiderato. + + + Gestisce il contesto di esecuzione per il thread corrente.La classe non può essere ereditata. + 2 + + + Acquisisce il contesto di esecuzione dal thread corrente. + Oggetto che rappresenta il contesto di esecuzione per il thread corrente. + 1 + + + Esegue un metodo in un contesto di esecuzione specifico sul thread corrente. + Oggetto da impostare. + Delegato che rappresenta il metodo da eseguire nel contesto di esecuzione fornito. + Oggetto da passare al metodo di callback. + + è null.- oppure - non è stato acquisito tramite un'operazione di acquisizione. - oppure - è stato già utilizzato come argomento per una chiamata . + 1 + + + + + + Fornisce operazioni atomiche per variabili condivise da più thread. + 2 + + + Somma due interi a 32 bit e sostituisce il primo intero con la somma, come operazione atomica. + Nuovo valore archiviato in . + Variabile contenente il primo valore da sommare.La somma dei due valori viene archiviata in . + Valore da sommare all'intero in corrispondenza di . + The address of is a null pointer. + 1 + + + Somma due interi a 64 bit e sostituisce il primo intero con la somma, come operazione atomica. + Nuovo valore archiviato in . + Variabile contenente il primo valore da sommare.La somma dei due valori viene archiviata in . + Valore da sommare all'intero in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due numeri a virgola mobile e precisione doppia per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due interi con segno a 32 bit per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due interi con segno a 64 bit per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due puntatori o handle specifici della piattaforma per verificarne l'uguaglianza; se sono uguali, sostituisce il primo elemento. + Valore originale in . + Oggetto di destinazione, il cui valore viene confrontato con il valore di e, se possibile, sostituito da . + Oggetto che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Oggetto confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due oggetti per verificarne l'uguaglianza dei riferimenti; se sono uguali, sostituisce il primo oggetto. + Valore originale in . + Oggetto di destinazione confrontato con e, se possibile, sostituito. + Oggetto che sostituisce l'oggetto di destinazione se il confronto rileva l'uguaglianza. + Oggetto confrontato con l'oggetto in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due numeri a virgola mobile e precisione singola per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due istanze del tipo di riferimento specificato per verificarne l'uguaglianza; se sono uguali, sostituisce la prima istanza. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito.Rappresenta un parametro di riferimento (ref in C#, ByRef in Visual Basic). + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + Tipo da usare per , e .Questo tipo deve essere un tipo di riferimento. + The address of is a null pointer. + + + Diminuisce una variabile specificata e archivia il risultato, come operazione atomica. + Valore diminuito. + Variabile il cui valore deve essere diminuito. + The address of is a null pointer. + 1 + + + Diminuisce la variabile specificata e archivia il risultato, come operazione atomica. + Valore diminuito. + Variabile il cui valore deve essere diminuito. + The address of is a null pointer. + 1 + + + Imposta un numero a virgola mobile e precisione doppia su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un intero con segno a 32 bit su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un intero con segno a 64 bit su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un puntatore o un handle specifico della piattaforma su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un oggetto su un valore specificato e restituisce un riferimento all'oggetto originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un numero a virgola mobile e precisione singola su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta una variabile del tipo indicato sul valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato.Rappresenta un parametro di riferimento (ref in C#, ByRef in Visual Basic). + Valore su cui è impostato il parametro . + Tipo da usare per e .Questo tipo deve essere un tipo di riferimento. + The address of is a null pointer. + + + Aumenta una variabile specificata e archivia il risultato, come operazione atomica. + Valore aumentato. + Variabile il cui valore deve essere aumentato. + The address of is a null pointer. + 1 + + + Aumenta una variabile specificata e archivia il risultato, come operazione atomica. + Valore aumentato. + Variabile il cui valore deve essere aumentato. + The address of is a null pointer. + 1 + + + Sincronizza l'accesso alla memoria come segue: il processore che esegue il thread corrente non può riordinare le istruzioni in modo tale che gli accessi alla memoria prima della chiamata al metodo vengano eseguiti dopo quelli successivi alla chiamata al metodo . + + + Restituisce un valore a 64 bit, caricato come operazione atomica. + Valore caricato. + Valore a 64 bit da caricare. + 1 + + + Fornisce routine di inizializzazione differita. + + + Inizializza un tipo di riferimento di destinazione con il relativo costruttore predefinito se non è già stato inizializzato. + Riferimento inizializzato di tipo . + Riferimento di tipo da inizializzare se non è già stato inizializzato. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento o di valore di destinazione con il relativo costruttore predefinito se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento o valore di tipo da inizializzare se non è già stato inizializzato. + Riferimento a un valore booleano che determina se la destinazione è già stata inizializzata. + Riferimento a un oggetto utilizzato come blocco a esclusione reciproca per l'inizializzazione di .Se è null, verrà creata un'istanza di un nuovo oggetto. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento o di valore di destinazione utilizzando una funzione specificata se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento o valore di tipo da inizializzare se non è già stato inizializzato. + Riferimento a un valore booleano che determina se la destinazione è già stata inizializzata. + Riferimento a un oggetto utilizzato come blocco a esclusione reciproca per l'inizializzazione di .Se è null, verrà creata un'istanza di un nuovo oggetto. + Funzione chiamata per inizializzare il riferimento o il valore. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento di destinazione utilizzando una funzione specificata se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento di tipo da inizializzare se non è già stato inizializzato. + Funzione chiamata per inizializzare il riferimento. + Tipo del riferimento da inizializzare. + Il tipo non dispone di un costruttore predefinito. + + restituisce null (Nothing in Visual Basic). + + + Eccezione generata quando una voce ricorsiva in un blocco non è compatibile con i criteri di ricorsione per tale blocco. + 2 + + + Inizializza una nuova istanza della classe con un messaggio fornito dal sistema in cui viene descritto l'errore. + 2 + + + Inizializza una nuova istanza della classe con un messaggio specifico in cui viene descritto l'errore. + Messaggio in cui viene descritta l'eccezione.Il chiamante di questo costruttore deve assicurare che la stringa sia stata localizzata in base alle impostazioni cultura correnti del sistema. + 2 + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio in cui viene descritta l'eccezione.Il chiamante di questo costruttore deve assicurare che la stringa sia stata localizzata in base alle impostazioni cultura correnti del sistema. + Eccezione che ha causato l'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + 2 + + + Specifica se lo stesso thread può accedere a un blocco più volte. + + + Se un thread tenta di accedere a un blocco in modo ricorsivo, viene generata un'eccezione.È possibile che alcune classi consentano particolari ricorsioni quando questa impostazione è attivata. + + + Un thread può accedere a un blocco in modo ricorsivo.Alcune classi possono limitare questa funzionalità. + + + Notifica a uno o più thread in attesa che si è verificato un evento.La classe non può essere ereditata. + 2 + + + Consente l'inizializzazione di una nuova istanza della classe con un valore Booleano che indica se lo stato iniziale deve essere impostato su segnalato. + Viene restituito true per impostare lo stato iniziale su segnalato; false per impostare lo stato iniziale su non segnalato. + + + Fornisce una versione più snella di . + + + Inizializza una nuova istanza della classe con uno stato iniziale di non segnalato. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato e un conteggio rotazioni specificato. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + Numero di attese di rotazione che devono verificarsi prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + + is less than 0 or greater than the maximum allowed value. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dall'oggetto e facoltativamente rilascia le risorse gestite. + True per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene un valore che indica se l'evento è impostato. + true se l'evento è impostato; in caso contrario, false. + + + Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread. + The object has already been disposed. + + + Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa dell'evento di procedere. + + + Ottiene il numero di attese di rotazione che si verificheranno prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + Restituisce il numero di attese di rotazione che si verificheranno prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un intero con segno a 32 bit per misurare l'intervallo di tempo. + true se l'oggetto è stato impostato; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un intero con segno a 32 bit per misurare l'intervallo di tempo e osservando un oggetto . + true se l'oggetto è stato impostato; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non riceve un segnale, osservando un oggetto . + Oggetto da osservare. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un oggetto per misurare l'intervallo di tempo. + true se l'oggetto è stato impostato; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un oggetto per misurare l'intervallo di tempo e osservando un oggetto . + true se l'oggetto è stato impostato; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Ottiene l'oggetto sottostante per questo oggetto . + Oggetto evento sottostante per questo oggetto . + + + Fornisce un meccanismo che sincronizza l'accesso agli oggetti. + 2 + + + Acquisisce un blocco esclusivo sull'oggetto specificato. + Oggetto sui cui acquisire il blocco del monitoraggio. + Il valore del parametro è null. + 1 + + + Acquisisce un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto per il quale attendere. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco.Nota   Se non si verifica alcuna eccezione, l'output di questo metodo è sempre true. + L'input di è true. + Il valore del parametro è null. + + + Viene rilasciato un blocco esclusivo sull'oggetto specificato. + Oggetto sul quale rilasciare il blocco. + Il valore del parametro è null. + Il blocco per l'oggetto specificato non è di proprietà del thread corrente. + 1 + + + Determina se il thread corrente specificato contiene il blocco sull'oggetto specificato. + true se il thread corrente è responsabile del blocco su ; in caso contrario, false. + Oggetto da testare. + + è null. + + + Notifica a un thread della coda di attesa che lo stato dell'oggetto bloccato è stato modificato. + Oggetto atteso da un thread. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + 1 + + + Notifica a tutti i thread in attesa che lo stato dell'oggetto è stato modificato. + Oggetto che invia l'impulso. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + 1 + + + Prova ad acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Il valore del parametro è null. + 1 + + + Prova ad acquisire un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + + + Viene eseguito, per un numero specificato di millisecondi, il tentativo di acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Tempo di attesa espresso in millisecondi prima che si verifichi il blocco. + Il valore del parametro è null. + + è negativo e non è uguale a . + 1 + + + Prova ad acquisire, per il numero di millisecondi specificato, un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Tempo di attesa espresso in millisecondi prima che si verifichi il blocco. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + + è negativo e non è uguale a . + + + Viene eseguito, per una quantità di tempo specificata, il tentativo di acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Oggetto che rappresenta la durata di attesa del blocco.Un valore di –1 millisecondo specifica un'attesa infinita. + Il valore del parametro è null. + Il valore di in millisecondi è negativo ed è diverso da (–1 millisecondi) oppure è maggiore di . + 1 + + + Prova ad acquisire, per la quantità di tempo specificata, un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Quantità di tempo che rappresenta la durata di attesa del blocco.Un valore di –1 millisecondo specifica un'attesa infinita. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + Il valore di in millisecondi è negativo ed è diverso da (–1 millisecondi) oppure è maggiore di . + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco. + true se la chiamata è stata restituita perché il chiamante ha riacquisito il blocco per l'oggetto specificato.Non viene restituito alcun valore se il blocco non viene riacquisito. + Oggetto per il quale attendere. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + 1 + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco.Allo scadere dell'intervallo di timeout specificato, il thread viene inserito nella coda di thread pronti. + true se il blocco è stato riacquisito prima che sia trascorso il tempo specificato; false se il blocco è stato riacquisito dopo che è trascorso il tempo specificato.Il metodo non restituisce alcun valore finché il blocco non viene riacquisito. + Oggetto per il quale attendere. + Numero di millisecondi da attendere prima che il thread venga inserito nella coda di thread pronti. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + Il valore del parametro è negativo e non è uguale a . + 1 + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco.Allo scadere dell'intervallo di timeout specificato, il thread viene inserito nella coda di thread pronti. + true se il blocco è stato riacquisito prima che sia trascorso il tempo specificato; false se il blocco è stato riacquisito dopo che è trascorso il tempo specificato.Il metodo non restituisce alcun valore finché il blocco non viene riacquisito. + Oggetto per il quale attendere. + Oggetto che rappresenta il tempo di attesa prima che il thread venga inserito nella coda di thread pronti. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + Il valore del parametro in millisecondi è negativo e non rappresenta (–1 millisecondo) oppure è maggiore di . + 1 + + + Primitiva di sincronizzazione che può essere usata anche per la sincronizzazione interprocesso. + 1 + + + Inizializza una nuova istanza della classe con le proprietà predefinite. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex; in caso contrario, false. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex e con una stringa che rappresenta il nome del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex di sistema denominato, se questo è stato creato come risultato della chiamata; in caso contrario, false. + Nome di .Se il valore è null, l'oggetto è senza nome. + Il mutex denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non dispone dei diritti . + Si è verificato un errore Win32. + Non è possibile creare il mutex denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è più lungo di 260 caratteri. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex, con una stringa che rappresenta il nome del mutex e con un valore booleano che, quando il metodo viene restituito, indichi se al thread chiamante era stata concessa la proprietà iniziale del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex di sistema denominato, se questo è stato creato come risultato della chiamata; in caso contrario, false. + Nome di .Se il valore è null, l'oggetto è senza nome. + Quando questo metodo viene restituito, contiene un valore booleano che è true se è stato creato un mutex locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato il mutex di sistema denominato specificato; false se il mutex di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + Il mutex denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non dispone dei diritti . + Si è verificato un errore Win32. + Non è possibile creare il mutex denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è più lungo di 260 caratteri. + + + Apre il mutex denominato specificato, se esistente. + Oggetto che rappresenta il mutex di sistema denominato. + Nome del mutex di sistema da aprire. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Il mutex denominato non esiste. + Si è verificato un errore Win32. + Il mutex denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Rilascia l'oggetto una volta. + Il thread chiamante non ha la proprietà del mutex. + 1 + + + Apre il mutex denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è stata completata. + true se il mutex denominato è stato aperto correttamente; in caso contrario, false. + Nome del mutex di sistema da aprire. + Quando questo metodo viene restituito, contiene un oggetto di che rappresenta il mutex denominato se la chiamata ha esito positivo o null se la chiamata ha esito negativo.Questo parametro viene trattato come non inizializzato. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Si è verificato un errore Win32. + Il mutex denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + + + Rappresenta un blocco usato per gestire l'accesso a una risorsa, consentendo a più thread l'accesso in lettura o l'accesso esclusivo in scrittura. + + + Inizializza una nuova istanza della classe con i valori predefiniti delle proprietà. + + + Inizializza una nuova istanza della classe , specificando i criteri di ricorsione del blocco. + Uno dei valori di enumerazione che specifica i criteri di ricorsione del blocco. + + + Ottiene il numero complessivo di thread univoci per i quali è stato attivato il blocco in modalità lettura. + Numero di thread univoci per i quali è stato attivato il blocco in modalità lettura. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Prova ad attivare il blocco in modalità lettura. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Riduce il numero di ricorsioni per la modalità lettura ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in read mode. + + + Riduce il numero di ricorsioni per la modalità aggiornabile ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in upgradeable mode. + + + Riduce il numero di ricorsioni per la modalità scrittura ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in write mode. + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità lettura. + true se per il thread corrente è stata attivata la modalità lettura; in caso contrario, false. + 2 + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità aggiornabile. + true se per il thread corrente è stata attivata la modalità aggiornabile; in caso contrario, false. + 2 + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità scrittura. + true se per il thread corrente è stata attivata la modalità scrittura; in caso contrario, false. + 2 + + + Ottiene un valore che indica i criteri di ricorsione per l'oggetto corrente. + Uno dei valori di enumerazione che specifica i criteri di ricorsione del blocco. + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità lettura, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità lettura, 1 se per il thread è stata attivata la modalità lettura ma non in modo ricorsivo o n se per il thread è stato attivato il blocco in modo ricorsivo n - 1 volte. + 2 + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità aggiornabile, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità aggiornabile, 1 se per il thread è stata attivata la modalità aggiornabile ma non in modo ricorsivo o n se per il thread è stata attivata la modalità aggiornabile in modo ricorsivo n - 1 volte. + 2 + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità scrittura, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità scrittura, 1 se per il thread è stata attivata la modalità scrittura ma non in modo ricorsivo o n se per il thread è stata attivata la modalità scrittura in modo ricorsivo n - 1 volte. + 2 + + + Prova ad attivare il blocco in modalità lettura con un timeout intero facoltativo. + true se il thread chiamante è passato in modalità lettura; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità lettura con un timeout facoltativo. + true se il thread chiamante è passato in modalità lettura; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile con un timeout facoltativo. + true se il thread chiamante è passato in modalità aggiornabile; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile con un timeout facoltativo. + true se il thread chiamante è passato in modalità aggiornabile; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura con un timeout facoltativo. + true se il thread chiamante è passato in modalità scrittura; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura con un timeout facoltativo. + true se il thread chiamante è passato in modalità scrittura; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità lettura. + Numero complessivo di thread in attesa di attivazione della modalità lettura. + 2 + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità aggiornabile. + Numero complessivo di thread in attesa di attivazione della modalità aggiornabile. + 2 + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità scrittura. + Numero complessivo di thread in attesa di attivazione della modalità scrittura. + 2 + + + Limita il numero di thread che possono accedere a una risorsa o a un pool di risorse contemporaneamente. + 1 + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + + è maggiore di . + + è minore di 1.-oppure- è minore di 0. + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei, nonché indicando facoltativamente il nome di un oggetto semaforo di sistema. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + Nome di un oggetto semaforo di sistema denominato. + + è maggiore di .-oppure- è più lungo di 260 caratteri. + + è minore di 1.-oppure- è minore di 0. + Si è verificato un errore Win32. + Il semaforo denominato esiste ed è dotato di sicurezza del controllo di accesso e l'utente non dispone di . + Non è possibile creare il semaforo denominato, probabilmente a causa di un handle di attesa di tipo diverso con lo stesso nome. + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei, indicando facoltativamente il nome di un oggetto semaforo di sistema e specificando una variabile che riceve un valore che indica se è stato creato un nuovo semaforo di sistema. + Numero iniziale di richieste per il semaforo che possono essere soddisfatte contemporaneamente. + Numero massimo di richieste per il semaforo che possono essere soddisfatte contemporaneamente. + Nome di un oggetto semaforo di sistema denominato. + Quando questo metodo viene restituito, contiene true se è stato creato un semaforo locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato il semaforo di sistema denominato specificato; false se il semaforo di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + + è maggiore di . -oppure- è più lungo di 260 caratteri. + + è minore di 1.-oppure- è minore di 0. + Si è verificato un errore Win32. + Il semaforo denominato esiste ed è dotato di sicurezza del controllo di accesso e l'utente non dispone di . + Non è possibile creare il semaforo denominato, probabilmente a causa di un handle di attesa di tipo diverso con lo stesso nome. + + + Apre il semaforo denominato specificato, se esistente. + Oggetto che rappresenta il semaforo di sistema denominato. + Nome del semaforo di sistema da aprire. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Il semaforo denominato non esiste. + Si è verificato un errore Win32. + Il semaforo denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Esce dal semaforo e restituisce il conteggio precedente. + Conteggio del semaforo prima della chiamata del metodo . + Il conteggio del semaforo ha già raggiunto il valore massimo. + Si è verificato un errore Win32 relativo a un semaforo denominato. + Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente non dispone di .-oppure-Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con . + 1 + + + Esce dal semaforo il numero di volte specificato e restituisce il conteggio precedente. + Conteggio del semaforo prima della chiamata del metodo . + Numero di uscite dal semaforo. + + è minore di 1. + Il conteggio del semaforo ha già raggiunto il valore massimo. + Si è verificato un errore Win32 relativo a un semaforo denominato. + Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente non dispone di diritti .-oppure-Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con i diritti . + 1 + + + Apre il semaforo denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è riuscita. + true se l'apertura del semaforo denominato è riuscita; in caso contrario, false. + Nome del semaforo di sistema da aprire. + Quando viene eseguita la restituzione del metodo, quest'ultimo contiene un oggetto che rappresenta il semaforo denominato se la chiamata è riuscita o null se la chiamata non è riuscita.Questo parametro viene trattato come non inizializzato. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Si è verificato un errore Win32. + Il semaforo denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + + + Eccezione generata quando il metodo viene chiamato su un semaforo il cui conteggio ha già raggiunto il valore massimo. + 2 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Rappresenta un'alternativa semplificata a che limita il numero di thread che possono accedere simultaneamente a una risorsa o a un pool di risorse. + + + Inizializza una nuova istanza della classe specificando il numero iniziale di richieste che possono essere concesse simultaneamente. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + + è minore di 0. + + + Inizializza una nuova istanza della classe specificando il numero iniziale e massimo di richieste che possono essere concesse simultaneamente. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + + è minore di 0, o è maggiore di o è uguale o minore di 0. + + + Restituisce un oggetto che può essere usato per attendere il semaforo. + Oggetto che può essere usato per attendere il semaforo. + L'interfaccia è stata eliminata. + + + Ottiene il numero di thread rimanenti che possono accedere all'oggetto . + Numero di thread rimanenti che possono accedere al semaforo. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Rilascia l'oggetto una volta. + Numero precedente di . + L'istanza corrente è già stata eliminata. + + ha già raggiunto la dimensione massima. + + + Rilascia l'oggetto un numero di volte specificato. + Numero precedente di . + Numero di uscite dal semaforo. + L'istanza corrente è già stata eliminata. + + è minore di 1. + + ha già raggiunto la dimensione massima. + + + Blocca il thread corrente finché non può immettere . + L'istanza corrente è già stata eliminata. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un intero con segno a 32 bit che specifica il timeout. + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un intero con segno a 32 bit che specifica il timeout e osservando un oggetto . + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il istanza è stata eliminata, o che ha creato è stato eliminato. + + + Blocca il thread corrente finché non può accedere all'oggetto osservando un oggetto . + Token da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata.-oppure-Il creato è già stato eliminato. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un oggetto per specificare il timeout. + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + L'istanza semaphoreSlim è stata eliminata + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un oggetto che specifica il timeout e osservando un oggetto . + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + L'istanza semaphoreSlim è stata eliminataL'oggetto che ha creato è già stato eliminato. + + + Attende in modo asincrono di immettere . + Attività che verrà completata quando si accede al semaforo. + + + Attende in modo asincrono di accedere all'oggetto , usando un intero con segno a 32 bit per misurare l'intervallo di tempo. + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Attende in modo asincrono di accedere all'oggetto , usando un intero con segno a 32 bit per misurare l'intervallo di tempo e osservando un oggetto . + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + L'istanza corrente è già stata eliminata. + + è stato annullato. + + + Attende in modo asincrono di accedere all'oggetto , osservando un oggetto . + Attività che verrà completata quando si accede al semaforo. + Token da osservare. + L'istanza corrente è già stata eliminata. + + è stato annullato. + + + Attende in modo asincrono di accedere all'oggetto , usando un oggetto per misurare l'intervallo di tempo. + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. -oppure- timeout è maggiore di . + + + Attende in modo asincrono di accedere all'oggetto , usando un oggetto per misurare l'intervallo di tempo e osservando un oggetto . + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Token da osservare. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato.-oppure-timeout è maggiore di . + + è stato annullato. + + + Rappresenta un metodo da chiamare quando un messaggio deve essere inviato a un contesto di sincronizzazione. + Oggetto passato al delegato. + 2 + + + Fornisce un primitiva di blocco a esclusione reciproca in cui un thread che tenta di acquisire il blocco attende in un ciclo eseguendo controlli ripetuti finché il blocco non diventa disponibile. + + + Inizializza una nuova istanza della struttura con l'opzione di rilevamento degli ID dei thread per migliorare il debug. + Valore che indica se acquisire e utilizzare gli ID dei thread per scopi di debug. + + + Acquisisce il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + È necessario inizializzare l'argomento su False prima della chiamata a Enter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Rilascia il blocco. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente non è il proprietario di questo blocco. + + + Rilascia il blocco. + Valore booleano che indica se generare un limite di memoria per pubblicare immediatamente l'operazione di uscita agli altri thread. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente non è il proprietario di questo blocco. + + + Ottiene un valore che indica se attualmente il blocco è mantenuto da un thread. + true se attualmente il blocco è mantenuto da un thread; in caso contrario, false. + + + Ottiene un valore che indica se il blocco è mantenuto dal thread corrente. + true se il blocco è mantenuto dal thread corrente; in caso contrario, false. + Il rilevamento della proprietà dei thread è disabilitato. + + + Ottiene un valore che indica se per questa istanza è abilitato il rilevamento della proprietà dei thread. + true se per questa istanza è abilitato il rilevamento della proprietà dei thread; in caso contrario, false. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito o il timeout è più grande di millisecondi. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Fornisce il supporto per l'attesa basata su rotazione. + + + Ottiene il numero di chiamate di su questa istanza. + Restituisce un intero che rappresenta il numero di volte in cui è stato chiamato su questa istanza. + + + Ottiene un valore che indica se la chiamata successiva a comporterà la cessione del processore, attivando un cambio imposto di contesto. + Valore che indica se la chiamata successiva a comporterà la cessione del processore, attivando un cambio imposto di contesto. + + + Reimposta il contatore delle rotazioni. + + + Esegue una sola rotazione. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata. + Delegato da eseguire ripetutamente finché non restituisce true. + L'argomento è null. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata o fino allo scadere del timeout specificato. + True se la condizione viene soddisfatta entro lo scadere del timeout. In caso contrario, False. + Delegato da eseguire ripetutamente finché non restituisce true. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + L'argomento è null. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata o fino allo scadere del timeout specificato. + True se la condizione viene soddisfatta entro lo scadere del timeout. In caso contrario, False. + Delegato da eseguire ripetutamente finché non restituisce true. + Oggetto che rappresenta il numero di millisecondi di attesa. In alternativa, per un'attesa indefinita, oggetto TimeSpan che rappresenta -1 millisecondi. + L'argomento è null. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Fornisce la funzionalità di base per propagare un contesto di sincronizzazione in vari modelli di sincronizzazione. + 2 + + + Crea una nuova istanza della classe . + + + Quando ne viene eseguito l'override in una classe derivata, crea una copia del contesto di sincronizzazione. + Nuovo oggetto . + 2 + + + Ottiene il contesto di sincronizzazione per il thread corrente. + Oggetto che rappresenta il contesto di sincronizzazione corrente. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, risponde alla notifica di completamento di un'operazione. + + + Quando ne viene eseguito l'override in una classe derivata, risponde alla notifica di avvio di un'operazione. + + + Quando ne viene eseguito l'override in una classe derivata, invia un messaggio asincrono a un contesto di sincronizzazione. + Delegato di da chiamare. + Oggetto passato al delegato. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, invia un messaggio sincrono a un contesto di sincronizzazione. + Delegato di da chiamare. + Oggetto passato al delegato. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Imposta il contesto di sincronizzazione corrente. + Oggetto da impostare. + 1 + + + + + + Eccezione generata quando un metodo richiede che il chiamante sia il proprietario del blocco su un Monitor specifico, e tale metodo viene richiamato da un chiamante che non è proprietario del blocco. + 2 + + + Consente l'inizializzazione di una nuova istanza della classe con le proprietà predefinite. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Consente l'archiviazione dei dati nella memoria locale dei thread. + Specifica il tipo di dati archiviati per thread. + + + Inizializza l'istanza . + + + Inizializza l'istanza . + Se tenere traccia di tutti i valori impostati sull'istanza ed esporli mediante la proprietà di . + + + Inizializza l'istanza di con la funzione specificata. + Oggetto richiamato per produrre un valore con inizializzazione differita quando si tenta di recuperare l'oggetto senza che sia stato inizializzato in precedenza. + + è un riferimento null (Nothing in Visual Basic). + + + Inizializza l'istanza di con la funzione specificata. + Oggetto richiamato per produrre un valore con inizializzazione differita quando si tenta di recuperare l'oggetto senza che sia stato inizializzato in precedenza. + Se tenere traccia di tutti i valori impostati sull'istanza ed esporli mediante la proprietà di . + + è un riferimento null (Nothing in Visual Basic). + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse utilizzate da questa istanza di . + Valore booleano che indica se questo metodo viene chiamato a causa di una chiamata a . + + + Rilascia le risorse utilizzate da questa istanza di . + + + Ottiene un valore che indica se l'oggetto è inizializzato sul thread corrente. + true se viene inizializzato sul thread corrente; in caso contrario, false. + L'istanza di è stata eliminata. + + + Crea e restituisce una rappresentazione di stringa di questa istanza per il thread corrente. + Risultato della chiamata di su . + L'istanza di è stata eliminata. + L'oggetto per il thread corrente è un riferimento Null (Nothing in Visual Basic). + La funzione di inizializzazione tenta di fare riferimento in modo ricorsivo a . + Non è fornito alcun costruttore predefinito e non è fornito alcun valore di factory. + + + Ottiene o imposta il valore di questa istanza per il thread corrente. + Restituisce un'istanza dell'oggetto della cui inizializzazione è responsabile questo oggetto ThreadLocal. + L'istanza di è stata eliminata. + La funzione di inizializzazione tenta di fare riferimento in modo ricorsivo a . + Non è fornito alcun costruttore predefinito e non è fornito alcun valore di factory. + + + Ottiene un elenco di tutti i valori attualmente archiviati da tutti i thread che hanno eseguito l'accesso a questa istanza. + Elenco di tutti i valori attualmente archiviati da tutti i thread che hanno eseguito l'accesso a questa istanza. + L'istanza di è stata eliminata. + + + Contiene metodi per l'esecuzione di operazioni relative alla memoria volatile. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il riferimento a un oggetto dal campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Riferimento a che è stato letto.Questo riferimento è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + Tipo di campo da leggere.Deve essere un tipo di riferimento, non un tipo di valore. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di memoria compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il riferimento a un oggetto specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il riferimento a un oggetto. + Riferimento a un oggetto da scrivere.Il riferimento viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + Tipo di campo da scrivere.Deve essere un tipo di riferimento, non un tipo di valore. + + + Eccezione generata durante il tentativo di aprire un semaforo o un mutex di sistema inesistente. + 2 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/ja/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/ja/System.Threading.xml new file mode 100644 index 000000000..1e2f71c3a --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/ja/System.Threading.xml @@ -0,0 +1,1950 @@ + + + + System.Threading + + + + スレッドが、別のスレッドが解放せずに終了することによって放棄した オブジェクトを取得したときにスローされる例外。 + 1 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 放棄されたミューテックスのインデックスを指定する場合はそのインデックスと、ミューテックスを表す オブジェクトを指定して、 クラスの新しいインスタンスを初期化します。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列内における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + + クラスの新しいインスタンスを、指定したエラー メッセージと内部例外を使用して初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null ではない場合、現在の例外は内部例外を処理する catch ブロックで発生します。 + + + エラー メッセージ、内部例外、放棄されたミューテックスのインデックスを指定する場合はそのインデックス、およびミューテックスを表す オブジェクトを指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null ではない場合、現在の例外は内部例外を処理する catch ブロックで発生します。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + エラー メッセージ、放棄されたミューテックスのインデックスを指定する場合はそのインデックス、および放棄されたミューテックスを指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + 例外の原因となった、放棄されたミューテックスがわかっている場合は、そのミューテックスを取得します。 + 放棄されたミューテックスを表す オブジェクト。放棄されたミューテックスを識別できなかった場合は null。 + 1 + + + 例外の原因となった、放棄されたミューテックスがわかっている場合は、そのミューテックスのインデックスを取得します。 + 放棄されたミューテックスを表す オブジェクトの、 メソッドに渡された待機ハンドルの配列内でのインデックス。放棄されたミューテックスのインデックスが識別できなかった場合は –1。 + 1 + + + 非同期メソッドなど、特定の非同期制御フローに対してローカルなアンビエント データを表します。 + アンビエント データの型。 + + + 変更通知を受信しない インスタンスをインスタンス生成します。 + + + 変更通知を受信する ローカル インスタンスをインスタンス生成します。 + どのスレッド上であっても現在の値が変更されたなら必ず呼び出されるデリゲート。 + + + アンビエント データの値を取得または設定します。 + アンビエント データの値。 + + + 変更通知のために登録する インスタンスに対するデータ変更情報を提供するクラス。 + データの型。 + + + データの現在の値を取得します。 + データの現在の値。 + + + データの前の値を取得します。 + データの前の値。 + + + 実行コンテキストの変更が原因で値が変更されたかどうかを示す値を返します。 + 実行コンテキストの変更が原因で値が変更された場合は true、それ以外の場合は false。 + + + イベントが発生したことを待機中のスレッドに通知します。このクラスは継承できません。 + 2 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + +初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + 複数のタスクが、複数のフェーズを通じて 1 つのアルゴリズムで並行して協調的に動作できるようにします。 + + + + クラスの新しいインスタンスを初期化します。 + 参加しているスレッドの数。 + + が 0 より小さいか、または 32,767 を超えています。 + + + + クラスの新しいインスタンスを初期化します。 + 参加しているスレッドの数。 + 各フェーズ後に実行する 。null (Visual Basic の場合は Nothing) は操作が行われないことを示すために渡されることがあります。 + + が 0 より小さいか、または 32,767 を超えています。 + + + 参加要素が 1 つ追加されることを に通知します。 + 新しい参加要素が最初に参加するバリアのフェーズ番号。 + 現在のインスタンスは既に破棄されています。 + 参加要素を追加すると、バリアの参加要素数が 32,767 を超えます。またはメソッドは、フェーズ後アクション内から呼び出されました。 + + + 複数の参加要素が追加されることを に通知します。 + 新しい参加要素が最初に参加するバリアのフェーズ番号。 + バリアに追加する追加の参加要素の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。または 参加要素を追加すると、バリアの参加要素数が 32,767 を超えます。 + メソッドは、フェーズ後アクション内から呼び出されました。 + + + バリアの現在のフェーズの番号を取得します。 + バリアの現在のフェーズの番号を返します。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + メソッドは、フェーズ後アクション内から呼び出されました。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + バリア内の参加要素の合計数を取得します。 + バリア内の参加要素の合計数を返します。 + + + 現在のフェーズでまだ通知していないバリア内の参加要素の数を取得します。 + 現在のフェーズでまだ通知していないバリア内の参加要素の数を返します。 + + + 参加要素が 1 つ削除されることを に通知します。 + 現在のインスタンスは既に破棄されています。 + バリアでは、既に 0 個の参加要素があります。またはメソッドは、フェーズ後アクション内から呼び出されました。 + + + 複数の参加要素が削除されることを に通知します。 + バリアから削除する追加の参加要素の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。 + バリアでは、既に 0 個の参加要素があります。またはメソッドは、フェーズ後アクション内から呼び出されました。 または現在の参加要素数が、指定された participantCount より小さい値です + 参加要素の総数が、指定した より小さくなっています。 + + + 参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 現在のインスタンスは既に破棄されています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + すべての参加しているスレッドが SignalAndWait を呼び出した後に、バリアのフェーズ後のアクションから例外がスローされた場合、その例外は BarrierPostPhaseException にラップされ、参加しているすべてのスレッドでスローされます。 + + + 32 ビット符号付き整数を使用してタイムアウトを計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 指定した時間内にすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + すべての参加しているスレッドが SignalAndWait を呼び出した後に、バリアのフェーズ後のアクションから例外がスローされた場合、その例外は BarrierPostPhaseException にラップされ、参加しているすべてのスレッドでスローされます。 + + + 取り消しトークンを観察すると同時に、32 ビット符号付き整数を使用してタイムアウトを計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 指定した時間内にすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + 取り消しトークンを観察すると同時に、参加要素がバリアに到達し、他のすべての参加要素がバリアに到達するまで待機することを通知します。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + + オブジェクトを使用して時間間隔を計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 他のすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが 32,767 を超えています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + 取り消しトークンを観察すると同時に、 オブジェクトを使用して時間間隔を計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 他のすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + + のフェーズ後アクションに失敗したときにスローされる例外。 + + + エラーを説明するシステム提供のメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + + + 指定した内部例外を使用して、 クラスの新しいインスタンスを初期化します。 + 現在の例外の原因である例外。 + + + エラーを説明する指定したメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + 新しいコンテキスト内で呼び出すメソッドを表します。 + コールバック メソッドが実行されるたびに使用する情報を格納したオブジェクト。 + 1 + + + カウントが 0 になったときに通知される同期プリミティブを表します。 + + + 指定されたカウントを使用して クラスの新しいインスタンスを初期化します。 + + の設定に最初に必要な通知の数。 + + が 0 未満です。 + + + + の現在のカウントを 1 つインクリメントします。 + 現在のインスタンスは既に破棄されています。 + 現在のインスタンスは既に設定されています。または が 以上です。 + + + + の現在のカウントを指定された値だけインクリメントします。 + + を増やす値。 + 現在のインスタンスは既に破棄されています。 + + が 0 以下です。 + 現在のインスタンスは既に設定されています。またはカウントが ずつインクリメントされた後、 が 以上です + + + イベントの設定に必要な残りの通知の数を取得します。 + イベントの設定に必要な残りの通知の数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + イベントの設定に最初に必要な通知の数を取得します。 + イベントの設定に最初に必要な通知の数。 + + + イベントが設定されているかどうかを判断します。 + イベントが設定されている場合は true。それ以外の場合は false。 + + + + を の値にリセットします。 + 現在のインスタンスは既に破棄されています。 + + + + プロパティを指定した値にリセットします。 + + の設定に必要な通知の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。 + + + 通知を に登録して、 の値をデクリメントします。 + 通知によってカウントが 0 になり、イベントが設定された場合は true。それ以外の場合は false。 + 現在のインスタンスは既に破棄されています。 + 現在のインスタンスは既に設定されています。 + + + 複数の通知を に登録して、 の値を指定された量だけデクリメントします。 + 通知によってカウントが 0 になり、イベントが設定された場合は true。それ以外の場合は false。 + 登録する通知の数。 + 現在のインスタンスは既に破棄されています。 + + が 1 未満です。 + 現在のインスタンスは既に設定されています。-または- または、 が より大きいです。 + + + + を 1 つインクリメントすることを試みます。 + インクリメントが正常に行われた場合は true。それ以外の場合は false。 が既に 0 の場合、このメソッドは false を返します。 + 現在のインスタンスは既に破棄されています。 + + と が等価です。 + + + + を指定した値だけインクリメントすることを試みます。 + インクリメントが正常に行われた場合は true。それ以外の場合は false。 が既に 0 の場合、これは false を返します。 + + を増やす値。 + 現在のインスタンスは既に破棄されています。 + + が 0 以下です。 + 現在のインスタンスは既に設定されています。または + は、 以上です。 + + + + が設定されるまで、現在のスレッドをブロックします。 + 現在のインスタンスは既に破棄されています。 + + + 32 ビット符号付き整数を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、32 ビット符号付き整数を使用してタイムアウトを計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、 が設定されるまで、現在のスレッドをブロックします。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + + + を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + + を観察すると同時に、 を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + イベントの設定を待機するために使用する を取得します。 + イベントの設定を待機するために使用する 。 + 現在のインスタンスは既に破棄されています。 + + + シグナルを受信した後で が自動的にリセットされるか、または手動でリセットされるかを示します。 + 2 + + + シグナルを受信すると、 は 1 つのスレッドを解放した後で自動的にリセットされます。待機しているスレッドがない場合、 はスレッドがブロックされるまでシグナル状態のままとなり、そのスレッドを解放した後でリセットされます。 + + + シグナルを受信すると、 は待機しているスレッドをすべて解放し、手動でリセットされるまでシグナル状態のままとなります。 + + + スレッドの同期イベントを表します。 + 2 + + + 待機ハンドルの初期状態をシグナル状態に設定するかどうか、および、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるかを指定して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + + + この呼び出しの結果として待機ハンドルが作成された場合に待機ハンドルの初期状態をシグナル状態に設定するかどうか、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるか、およびシステムの同期イベントの名前を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きイベントが作成された場合に初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + システム全体で有効な同期イベントの名前。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きイベントが存在しますが、ユーザーに がありません。 + 名前付きイベントを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + が 260 文字を超えています。 + + + この呼び出しの結果として待機ハンドルが作成された場合に待機ハンドルの初期状態をシグナル状態に設定するかどうか、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるか、システム同期イベントの名前、および、呼び出し後の値によって名前付きイベントが作成されたかどうかを示すブール変数を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きイベントが作成された場合に初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + システム全体で有効な同期イベントの名前。 + このメソッドから制御が戻るときに、ローカル イベントが作成された場合 ( が null または空の文字列の場合)、または指定した名前付きシステム イベントが作成された場合は true が格納されます。指定した名前付きシステム イベントが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きイベントが存在しますが、ユーザーに がありません。 + 名前付きイベントを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + が 260 文字を超えています。 + + + 既に存在する場合は、指定した名前付き同期イベントを開きます。 + 名前付きシステム イベントを表すオブジェクト。 + 開くシステム同期イベントの名前。 + + が空の文字列です。または が 260 文字を超えています。 + + は null なので、 + 名前付きシステム イベントが存在しません。 + Win32 エラーが発生しました。 + 名前付きイベントは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + イベントの状態を非シグナル状態に設定し、スレッドをブロックします。 + 正常に操作できた場合は true。それ以外の場合は false。 + この で メソッドが既に呼び出されています。 + 2 + + + イベントの状態をシグナル状態に設定し、待機している 1 つ以上のスレッドが進行できるようにします。 + 正常に操作できた場合は true。それ以外の場合は false。 + この で メソッドが既に呼び出されています。 + 2 + + + 既に存在する場合は、指定した名前付き同期イベントを開き操作が成功したかどうかを示す値を返します。 + 名前付きの同期イベントが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム同期イベントの名前。 + このメソッドから制御が戻るときに、呼び出しに成功した場合は名前付き同期イベントを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または が 260 文字を超えています。 + + は null なので、 + Win32 エラーが発生しました。 + 名前付きイベントは存在しますが、必要なセキュリティ アクセスがユーザーにありません。 + + + 現在のスレッドの実行コンテキストを管理します。このクラスは継承できません。 + 2 + + + 現在のスレッドから実行コンテキストをキャプチャします。 + 現在のスレッドの実行コンテキストを表す オブジェクト。 + 1 + + + 現在のスレッドで指定した実行コンテキストを使用してメソッドを実行します。 + 設定する 。 + 指定した実行コンテキストで実行するメソッドを表す デリゲート。 + コールバック メソッドに渡すオブジェクト。 + + は null なので、またはキャプチャ操作で が取得されませんでした。または は、 呼び出しの引数として既に使用されています。 + 1 + + + + + + 複数のスレッドで共有される変数に分割不可能な操作を提供します。 + 2 + + + 分割不可能な操作として、2 つの 32 ビット整数を加算し、最初の整数を合計で置き換えます。 + + に格納された新しい値。 + 加算する最初の値を含む変数。2 つの値の合計は、 に格納されます。 + + にある整数に加算する値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、2 つの 64 ビット整数を加算し、最初の整数を合計で置き換えます。 + + に格納された新しい値。 + 加算する最初の値を含む変数。2 つの値の合計は、 に格納されます。 + + にある整数に加算する値。 + The address of is a null pointer. + 1 + + + 2 つの倍精度浮動小数点数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つの 32 ビット符号付き整数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つの 64 ビット符号付き整数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つのプラットフォーム固有のハンドルまたはポインターが等しいかどうかを比較します。等しい場合は、最初の 1 つを置き換えます。 + + の元の値。 + 値を の値と比較し、場合によっては によって置き換える、比較先の 。 + 比較した結果が等しい場合に比較先の値を置き換える 。 + + にある値と比較する 。 + The address of is a null pointer. + 1 + + + 2 つのオブジェクトの参照が等値であるかどうかを比較します。等しい場合は、最初のオブジェクトを置き換えます。 + + の元の値。 + + と比較し、場合によっては置き換える比較先のオブジェクト。 + 比較した結果が等しい場合に比較先のオブジェクトを置き換えるオブジェクト。 + + にあるオブジェクトと比較するオブジェクト。 + The address of is a null pointer. + 1 + + + 2 つの単精度浮動小数点数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 指定した参照型 の 2 つのインスタンスが等しいかどうかを比較します。等しい場合は、最初の 1 つを置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。これは参照パラメーターです (C# では ref、Visual Basic では ByRef)。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + + 、、および に使用する型。この型は、参照型である必要があります。 + The address of is a null pointer. + + + 分割不可能な操作として、指定した変数をデクリメントし、結果を格納します。 + デクリメントされた値。 + 値がデクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した変数をデクリメントしてその結果を格納します。 + デクリメントされた値。 + 値がデクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を倍精度浮動小数点数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を 32 ビット符号付き整数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を 64 ビット符号付き整数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、プラットフォーム固有のハンドルまたはポインターに指定した値を設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値をオブジェクトとして設定し、元のオブジェクトへの参照を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を単精度浮動小数点数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した型 の変数に指定した値を設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。これは参照パラメーターです (C# では ref、Visual Basic では ByRef)。 + + パラメーターに設定される値。 + + 、および に使用する型。この型は、参照型である必要があります。 + The address of is a null pointer. + + + 分割不可能な操作として、指定した変数をインクリメントし、結果を格納します。 + インクリメントされた値。 + 値がインクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した変数をインクリメントし、結果を格納します。 + インクリメントされた値。 + 値がインクリメントされる変数。 + The address of is a null pointer. + 1 + + + メモリ アクセスを同期します。現在のスレッドを実行中のプロセッサは、 を呼び出す前のメモリ アクセスを の呼び出し後のメモリ アクセスより後に実行するように命令を並べ替えることはできなくなります。 + + + 分割不可能な操作として 64 ビット値を読み込んで返します。 + 読み込まれた値。 + 読み込む 64 ビット値。 + 1 + + + 限定的な初期化ルーチンを提供します。 + + + まだ初期化されていない場合、型の既定のコンストラクターを使用してターゲット参照型を初期化します。 + 型 の初期化された参照。 + まだ初期化されていない場合は、初期化する型 の参照。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、既定のコンストラクターを使用してターゲット参照または値型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照または値。 + ターゲットが既に初期化されているかどうかを判断するブール値への参照。 + + を初期化するために相互排他的ロックとして使用されるオブジェクトへの参照。 が null の場合、新しいオブジェクトがインスタンス化されます。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、指定された関数を使用してターゲット参照または値型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照または値。 + ターゲットが既に初期化されているかどうかを判断するブール値への参照。 + + を初期化するために相互排他的ロックとして使用されるオブジェクトへの参照。 が null の場合、新しいオブジェクトがインスタンス化されます。 + 参照または値を初期化するために呼び出される関数。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、指定された関数を使用してターゲット参照型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照。 + 参照を初期化するために呼び出される関数。 + 初期化される参照の参照型。 + 型 には既定のコンストラクターがありません。 + + null (Visual Basic の場合は Nothing) を返しました。 + + + 再帰的にロックに入る処理が、ロックの再帰ポリシーと互換性がない場合にスローされる例外です。 + 2 + + + エラーを説明するシステム提供のメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 2 + + + エラーを説明する指定したメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元は、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 2 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元は、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外を引き起こした例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + 2 + + + 同じスレッドが複数回ロックに入れるかどうかを指定します。 + + + スレッドが、再帰的にロックに入ろうとすると、例外がスローされます。クラスによっては、この設定が適用されている場合に、特定の再帰が認められることがあります。 + + + スレッドが再帰的にロックに入ることができます。クラスによっては、この機能が制限されていることがあります。 + + + イベントが発生したことを、1 つ以上の待機中のスレッドに通知します。このクラスは継承できません。 + 2 + + + 初期状態をシグナル状態に設定するかどうかを示す Boolean 型の値を使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + + の規模を小さくしたバージョンを提供します。 + + + 初期状態を非シグナル状態にして、 クラスの新しいインスタンスを初期化します。 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値および指定されたスピン カウントを使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + カーネル ベースの待機操作に戻る前に発生するスピン待機の数。 + + is less than 0 or greater than the maximum allowed value. + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true、アンマネージ リソースだけを解放する場合は false。 + + + イベントが設定されているかどうかを取得します。 + イベントが設定されている場合は true。それ以外の場合は false。 + + + イベントの状態を非シグナル状態に設定し、スレッドをブロックします。 + The object has already been disposed. + + + イベントの状態をシグナル状態に設定して、イベント上で待機している 1 つ以上のスレッドが進行できるようにします。 + + + カーネル ベースの待機操作に戻る前に発生するスピン待機の数を取得します。 + カーネル ベースの待機操作に戻る前に発生するスピン待機の数を返します。 + + + 現在の が設定されるまで、現在のスレッドをブロックします。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 32 ビット符号付き整数を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + を観察すると同時に、32 ビット符号付き整数を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + + を観察すると同時に、現在の が信号を受信するまで、現在のスレッドをブロックします。 + 観察する 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + + を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + を観察すると同時に、 を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + この の オブジェクトを取得します。 + この の基になる イベント オブジェクト。 + + + オブジェクトへのアクセスを同期する機構を提供します。 + 2 + + + 指定したオブジェクトの排他ロックを取得します。 + モニター ロックを取得する対象となるオブジェクト。 + + パラメーターが null です。 + 1 + + + 指定したオブジェクトの排他ロックを取得し、ロックが取得されたかどうかを示す値をアトミックに設定します。 + 待機を行うオブジェクト。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。メモ   例外が発生しない場合、このメソッドの出力は常に true です。 + + への入力は true です。 + + パラメーターが null です。 + + + 指定したオブジェクトの排他ロックを解放します。 + ロックを解放する対象となるオブジェクト。 + + パラメーターが null です。 + 現在のスレッドが、指定したオブジェクトのロックを所有していません。 + 1 + + + 現在のスレッドが指定したオブジェクトのロックを保持しているかどうかを判断します。 + 現在のスレッドが のロックを保持している場合は true。それ以外の場合は false。 + テストするオブジェクト。 + + は null です。 + + + ロックされたオブジェクトの状態が変更されたことを、待機キュー内のスレッドに通知します。 + スレッドが待機するオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + 1 + + + オブジェクトの状態が変更されたことを、待機中のすべてのスレッドに通知します。 + パルスを送るオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + 1 + + + 指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + + パラメーターが null です。 + 1 + + + 指定したオブジェクトの排他ロックの取得を試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + + 指定したミリ秒間に、指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + ロックを待機するミリ秒単位の時間。 + + パラメーターが null です。 + + が負で、 と等価でありません。 + 1 + + + 指定したオブジェクトの排他ロックの取得を指定したミリ秒間試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを待機するミリ秒単位の時間。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + が負で、 と等価でありません。 + + + 指定した時間内に、指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + ロックを待機する時間を表す 。–1 ミリ秒という値は、無期限の待機を指定します。 + + パラメーターが null です。 + + の値 (ミリ秒) が負で、かつ (-1 ミリ秒) と等価でありません。または より大きい値です。 + 1 + + + 指定したオブジェクトの排他ロックの取得を指定した時間にわたって試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを待機する時間。–1 ミリ秒という値は、無期限の待機を指定します。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + の値 (ミリ秒) が負で、かつ (-1 ミリ秒) と等価でありません。または より大きい値です。 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。 + 指定したオブジェクトのロックを呼び出し元が再取得したために、呼び出しが戻った場合は true。このメソッドは、ロックが再取得されないと制御を戻しません。 + 待機を行うオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + 1 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。指定されたタイムアウト期限を過ぎると、スレッドは実行待ちキューに入ります。 + 指定した時間が経過する前にロックが再取得された場合は true。指定した時間が経過した後にロックが再取得された場合は false。このメソッドは、ロックが再取得されるまで制御を戻しません。 + 待機を行うオブジェクト。 + スレッドが実行待ちキューに入るまでの待機時間 (ミリ秒)。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + + パラメーターの値が負で、 と等しくありません。 + 1 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。指定されたタイムアウト期限を過ぎると、スレッドは実行待ちキューに入ります。 + 指定した時間が経過する前にロックが再取得された場合は true。指定した時間が経過した後にロックが再取得された場合は false。このメソッドは、ロックが再取得されるまで制御を戻しません。 + 待機を行うオブジェクト。 + スレッドが実行待ちキューに入るまでの時間を表す 。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + + パラメーターのミリ秒単位の値が負で、かつ (–1 ミリ秒) ではありません。または より大きい値です。 + 1 + + + 同期プリミティブは、プロセス間の同期にも使用できます。 + 1 + + + + クラスの新しいインスタンスを、既定のプロパティを使用して初期化します。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + 呼び出し元スレッドにミューテックスの初期所有権を与える場合は true。それ以外の場合は false。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値と、ミューテックスの名前を表す文字列を使用して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きシステム ミューテックスが作成された場合に、呼び出し元スレッドに名前付きシステム ミューテックスの初期所有権を付与する場合は true。それ以外の場合は false。 + + の名前。値が null の場合、 は無名になります。 + アクセス制御セキュリティを使用した名前付きミューテックスが存在しますが、ユーザーに がありません。 + Win32 エラーが発生しました。 + 名前付きミューテックスを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + 260 文字を超えています。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値、ミューテックスの名前を表す文字列、およびメソッドから戻るときにミューテックスの初期所有権が呼び出し元のスレッドに付与されたかどうかを示すブール値を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きシステム ミューテックスが作成された場合に、呼び出し元スレッドに名前付きシステム ミューテックスの初期所有権を付与する場合は true。それ以外の場合は false。 + + の名前。値が null の場合、 は無名になります。 + このメソッドから制御が戻るとき、ローカル ミューテックスが作成された場合 (つまり が null または空の文字列の場合) または指定した名前付きシステム ミューテックスが作成された場合は、ブール値 true が格納されます。指定した名前付きシステム ミューテックスが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + アクセス制御セキュリティを使用した名前付きミューテックスが存在しますが、ユーザーに がありません。 + Win32 エラーが発生しました。 + 名前付きミューテックスを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + 260 文字を超えています。 + + + 既に存在する場合は、指定した名前付きミューテックスを開きます。 + 名前付きシステム ミューテックスを表すオブジェクト。 + 開くシステム ミューテックスの名前。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + 名前付きミューテックスが存在しません。 + Win32 エラーが発生しました。 + 名前付きミューテックスは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + + を一度解放します。 + 呼び出し元のスレッドはミューテックスを所有していません。 + 1 + + + 既に存在する場合は、指定した名前付きミューテックスを開き操作が成功したかどうかを示す値を返します。 + 名前付きミューテックスが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム ミューテックスの名前。 + このメソッドから戻るときに、呼び出しに成功した場合は名前付きミューテックスを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + Win32 エラーが発生しました。 + 名前付きミューテックスは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + + + リソースへのアクセス管理に使用するロックを表し、複数のスレッドによる読み取りや排他アクセスでの書き込みを実現します。 + + + + クラスの新しいインスタンスを既定のプロパティ値で初期化します。 + + + ロック再帰ポリシーを指定して、 クラスの新しいインスタンスを初期化します。 + ロック再帰ポリシーを指定する列挙値のいずれか。 + + + 読み取りモードでロックに入った一意のスレッドの総数を取得します。 + 読み取りモードでロックに入った一意のスレッドの数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 読み取りモードでロックに入ることを試みます。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + アップグレード可能モードでロックに入ることを試みます。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 書き込みモードでロックに入ることを試みます。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 読み取りモードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合には読み取りモードを終了します。 + The current thread has not entered the lock in read mode. + + + アップグレード可能モードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合にはアップグレード可能モードを終了します。 + The current thread has not entered the lock in upgradeable mode. + + + 書き込みモードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合には書き込みモードを終了します。 + The current thread has not entered the lock in write mode. + + + 現在のスレッドが読み取りモードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在のスレッドがアップグレード可能モードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在のスレッドが書き込みモードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在の オブジェクトの再帰ポリシーを示す値を取得します。 + ロック再帰ポリシーを指定する列挙値のいずれか。 + + + 現在のスレッドが読み取りモードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドは読み取りモードに入っていません。1 の場合、現在のスレッドは読み取りモードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回ロックに入りました。 + 2 + + + 現在のスレッドがアップグレード可能モードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドはアップグレード可能モードに入っていません。1 の場合、現在のスレッドはアップグレード可能モードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回アップグレード可能モードに入りました。 + 2 + + + 現在のスレッドが書き込みモードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドは書き込みモードに入っていません。1 の場合、現在のスレッドは書き込みモードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回書き込みモードに入りました。 + 2 + + + オプションのタイムアウトを表す整数を指定して、読み取りモードでロックに入ることを試みます。 + 呼び出し元のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、読み取りモードでロックに入ることを試みます。 + 呼び出し元のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + オプションのタイムアウトを指定して、アップグレード可能モードでロックに入ることを試みます。 + 呼び出し元のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、アップグレード可能モードでロックに入ることを試みます。 + 呼び出し元のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + オプションのタイムアウトを指定して、書き込みモードでロックに入ることを試みます。 + 呼び出し元のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、書き込みモードでロックに入ることを試みます。 + 呼び出し元のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 読み取りモードでロックに入るのを待機しているスレッドの総数を取得します。 + 読み取りモードに入るのを待機しているスレッドの総数。 + 2 + + + アップグレード可能モードでロックに入るのを待機しているスレッドの総数を取得します。 + アップグレード可能モードに入るのを待機しているスレッドの総数。 + 2 + + + 書き込みモードでロックに入るのを待機しているスレッドの総数を取得します。 + 書き込みモードに入るのを待機しているスレッドの総数。 + 2 + + + リソースまたはリソースのプールに同時にアクセスできるスレッドの数を制限します。 + 1 + + + エントリ数の初期値と同時実行エントリの最大数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + + が より大きくなっています。 + + 1 より小さい値です。または が 0 未満です。 + + + エントリ数の初期値と同時実行エントリの最大数を指定し、オプションでシステム セマフォ オブジェクトの名前を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + 名前付きシステム セマフォ オブジェクトの名前。 + + が より大きくなっています。または 260 文字を超えています。 + + 1 より小さい値です。または が 0 未満です。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きセマフォが存在しており、ユーザーに がありません。 + 名前付きセマフォを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + + エントリ数の初期値と同時実行エントリの最大数を指定し、オプションでシステム セマフォ オブジェクトの名前を指定し、新しいシステム セマフォが作成されたかどうかを示す値を受け取る変数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に満たされるセマフォの要求の初期数。 + 同時に満たされるセマフォの要求の最大数。 + 名前付きシステム セマフォ オブジェクトの名前。 + このメソッドから制御が戻るときに、ローカル セマフォが作成された場合 ( が null または空の文字列の場合)、または指定した名前付きシステム セマフォが作成された場合は true が格納されます。指定した名前付きシステム セマフォが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + + が より大きくなっています。または 260 文字を超えています。 + + 1 より小さい値です。または が 0 未満です。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きセマフォが存在しており、ユーザーに がありません。 + 名前付きセマフォを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + + 既に存在する場合は、指定した名前付きセマフォを開きます。 + 名前付きシステム セマフォを表すオブジェクト。 + 開くシステム セマフォの名前。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + 名前付きセマフォが存在しません。 + Win32 エラーが発生しました。 + 名前付きセマフォは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + セマフォから出て、前のカウントを返します。 + + メソッドが呼び出される前のセマフォのカウント。 + セマフォのカウントは既に最大値です。 + 名前付きセマフォで Win32 エラーが発生しました。 + 現在のセマフォは名前付きシステム セマフォを表していますが、ユーザーに がありません。または現在のセマフォは名前付きシステム セマフォを表していますが、 で開かれませんでした。 + 1 + + + 指定した回数だけセマフォから出て、前のカウントを返します。 + + メソッドが呼び出される前のセマフォのカウント。 + セマフォから出る回数。 + + 1 より小さい値です。 + セマフォのカウントは既に最大値です。 + 名前付きセマフォで Win32 エラーが発生しました。 + 現在のセマフォは名前付きシステム セマフォを表していますが、ユーザーに 権限がありません。または現在のセマフォは名前付きシステム セマフォを表していますが、 権限で開かれませんでした。 + 1 + + + 既に存在する場合は、指定した名前付きセマフォを開き操作が成功したかどうかを示す値を返します。 + 名前付きのセマフォが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム セマフォの名前。 + このメソッドから制御が戻るときに、呼び出しに成功した場合は名前付きセマフォを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + Win32 エラーが発生しました。 + 名前付きセマフォは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + + + カウントが既に最大値であるセマフォに対して メソッドが呼び出された場合にスローされる例外。 + 2 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + リソースまたはリソースのプールに同時にアクセスできるスレッドの数を制限する の軽量版を表します。 + + + 同時に許可される要求の初期数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + + が 0 未満です。 + + + 同時に許可される要求の初期数および最大数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + + が 0 より小さいか、 が を超えているか、または が 0 以下です。 + + + セマフォの待機に使用できる を返します。 + セマフォの待機に使用できる です。 + + は破棄されています。 + + + + オブジェクトに入る、残りのスレッド数を取得します。 + セマフォに入る、残りのスレッド数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + が使用しているアンマネージ リソースを解放します。オプションとして、マネージ リソースを解放することもできます。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + + のオブジェクトを一度解放します。 + + の前のカウント。 + 現在のインスタンスは既に破棄されています。 + + は、既にその最大サイズに達しました。 + + + 指定された回数だけ、 オブジェクトを解放します。 + + の前のカウント。 + セマフォから出る回数。 + 現在のインスタンスは既に破棄されています。 + + 1 より小さい値です。 + + は、既にその最大サイズに達しました。 + + + + に入れるようになるまで、現在のスレッドをブロックします。 + 現在のインスタンスは既に破棄されています。 + + + タイムアウト値を 32 ビット符号付き整数で指定して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、タイムアウト値を 32 ビット符号付き整数で指定して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + インスタンスが破棄されている、または 作成 破棄されています。 + + + + を観察すると同時に、 に入れるようになるまで、現在のスレッドをブロックします。 + 観察する トークン。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または 作成 既に破棄されています。 + + + + を使用してタイムアウトを指定し、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + semaphoreSlim インスタンスが破棄されました。 + + + + を観察すると同時に、タイムアウトを指定する を使用して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + semaphoreSlim インスタンスが破棄されました。 を作成した は既に破棄されています。 + + + + に移行するために非同期に待機します。 + セマフォに入っているときに完了するタスク。 + + + 32 ビット符号付き整数を使用して時間間隔を測定しながら、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + 32 ビット符号付き整数を使用して時間間隔を測定しながら、 を観察すると同時に、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + 現在のインスタンスは既に破棄されています。 + + が取り消されました。 + + + + を観察すると同時に、 に移行するために非同期に待機します。 + セマフォに入っているときに完了するタスク。 + 観察する トークン。 + 現在のインスタンスは既に破棄されています。 + + が取り消されました。 + + + + を使用して時間間隔を測定しながら、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します または タイムアウトは より大きい値です。 + + + + を使用して時間間隔を測定しながら、 を観察すると同時に、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する トークン。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表しますまたはタイムアウトは より大きい値です。 + + が取り消されました。 + + + メッセージを同期コンテキストにディスパッチするときに呼び出すメソッドを表します。 + デリゲートに渡されたオブジェクト。 + 2 + + + ロックが使用可能になるまで、ロックを取得しようとするスレッドがループの繰り返しチェック内で待機する相互排他ロック プリミティブを提供します。 + + + デバッグを向上させるためにスレッド ID を追跡するオプションを使用して、 構造体の新しいインスタンスを初期化します。 + デバッグのためにスレッド ID をキャプチャして使用するかどうか。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックを取得します。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + 引数は、Enter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + ロックを解放します。 + スレッドの所有権の追跡が有効で、現在のスレッドはこのロックの所有者ではありません。 + + + ロックを解放します。 + 終了操作を他のスレッドに直ちに発行するためにメモリ フェンスを発行する必要があるかどうかを示すブール値。 + スレッドの所有権の追跡が有効で、現在のスレッドはこのロックの所有者ではありません。 + + + ロックが現在いずれかのスレッドによって保持されているかどうかを取得します。 + ロックが現在いずれかのスレッドによって保持されている場合は true。それ以外の場合は false。 + + + ロックが現在のスレッドによって保持されているかどうかを取得します。 + ロックが現在のスレッドによって保持されている場合は true。それ以外の場合は false。 + スレッドの所有権の追跡が無効です。 + + + このインスタンスに対してスレッド所有権の追跡が有効になっているかどうかを取得します。 + このインスタンスに対してスレッド所有権の追跡が有効になっている場合は true。それ以外の場合は false。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが ミリ秒を超えています。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + スピンベースの待機のサポートを提供します。 + + + このインスタンスで が呼び出された回数を取得します。 + このインスタンスで が呼び出された回数を表す整数を返します。 + + + 次に を呼び出したときにプロセッサが生成され、強制的にコンテキストが切り替えられるかどうかを取得します。 + 次に を呼び出したときにプロセッサが生成され、強制的にコンテキストが切り替えられるかどうか。 + + + スピン カウンターをリセットします。 + + + 単一のスピンを実行します。 + + + 指定した条件が満たされるまで回転します。 + true を返すまで繰り返し実行されるデリゲート。 + + 引数が null です。 + + + 指定した条件が満たされるか、指定したタイムアウトが経過するまで回転します。 + タイムアウト内に条件が満たされた場合は true。それ以外の場合は false。 + true を返すまで繰り返し実行されるデリゲート。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + 引数が null です。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + 指定した条件が満たされるか、指定したタイムアウトが経過するまで回転します。 + タイムアウト内に条件が満たされた場合は true。それ以外の場合は false。 + true を返すまで繰り返し実行されるデリゲート。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す TimeSpan。 + + 引数が null です。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + 同期コンテキストをさまざまな同期モデルに反映させるための基本機能を提供します。 + 2 + + + + クラスの新しいインスタンスを作成します。 + + + 派生クラスでオーバーライドされた場合、同期コンテキストのコピーを作成します。 + 新しい オブジェクト。 + 2 + + + 現在のスレッドの同期コンテキストを取得します。 + 現在の同期コンテキストを表す オブジェクト。 + 1 + + + 派生クラスでオーバーライドされた場合、操作の完了を伝える通知に応答します。 + + + 派生クラスでオーバーライドされた場合、操作の開始を伝える通知に応答します。 + + + 派生クラスでオーバーライドされた場合、非同期メッセージを同期コンテキストにディスパッチします。 + 呼び出す デリゲート。 + デリゲートに渡されたオブジェクト。 + 2 + + + 派生クラスでオーバーライドされた場合、同期メッセージを同期コンテキストにディスパッチします。 + 呼び出す デリゲート。 + デリゲートに渡されたオブジェクト。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 現在の同期コンテキストを設定します。 + 設定する オブジェクト + 1 + + + + + + 指定した Monitor でロックを所有していることが呼び出し元の条件となるメソッドを、そのロックを所有していない呼び出し元が呼び出した場合にスローされる例外です。 + 2 + + + + クラスの新しいインスタンスを既定のプロパティを使用して初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + データのスレッド ローカル ストレージを提供します。 + スレッド単位で格納されるデータの型を指定します。 + + + + インスタンスを初期化します。 + + + + インスタンスを初期化します。 + インスタンスに設定されているすべての値を追跡し、それらの値を プロパティを通じて公開するかどうか。 + + + + 関数を指定して、 インスタンスを初期化します。 + 前もって初期化せずに を取得しようとすると、後で初期化された値を生成するために が呼び出されます。 + + が null 参照 (Visual Basic の場合は Nothing) です。 + + + + 関数を指定して、 インスタンスを初期化します。 + 前もって初期化せずに を取得しようとすると、後で初期化された値を生成するために が呼び出されます。 + インスタンスに設定されているすべての値を追跡し、それらの値を プロパティを通じて公開するかどうか。 + + が null 参照 (Visual Basic の場合は Nothing) です。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + この インスタンスによって使用されているリソースを解放します。 + + が呼び出されたことが原因でこのメソッドが呼び出されているかどうかを示すブール値。 + + + この インスタンスによって使用されているリソースを解放します。 + + + 現在のスレッドで が初期化されているかどうかを取得します。 + + が現在のスレッドで初期化される場合は true。それ以外の場合は false。 + + インスタンスは破棄されています。 + + + 現在のスレッドのこのインスタンスの文字列形式を作成して返します。 + + で を呼び出した結果。 + + インスタンスは破棄されています。 + 現在のスレッドの は null 参照 (Visual Basic での Nothing) です。 + 初期化関数が、 を再帰的に参照しようとしました。 + 既定のコンストラクターが指定されず、値ファクトリが指定されていません。 + + + 現在のスレッドのこのインスタンスの値を取得または設定します。 + この ThreadLocal が初期化するオブジェクトのインスタンスを返します。 + + インスタンスは破棄されています。 + 初期化関数が、 を再帰的に参照しようとしました。 + 既定のコンストラクターが指定されず、値ファクトリが指定されていません。 + + + このインスタンスにアクセスした全スレッドによって現在格納されているすべての値のリストを取得します。 + このインスタンスにアクセスした全スレッドによって現在格納されているすべての値のリスト。 + + インスタンスは破棄されています。 + + + 不揮発性メモリの操作を実行するためのメソッドが含まれます。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定したフィールドからオブジェクト参照を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた への参照。この参照は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + 読み取るフィールドの型。この型は、値型ではなく、参照型である必要があります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前にメモリ操作が配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定したオブジェクト参照を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + オブジェクト参照を書き込むフィールド。 + 書き込むオブジェクト参照。参照は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + 書き込むフィールドの型。この型は、値型ではなく、参照型である必要があります。 + + + 存在しないシステム ミューテックスまたはシステム セマフォを開こうとしたときにスローされる例外。 + 2 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/ko/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/ko/System.Threading.xml new file mode 100644 index 000000000..dd5f63d87 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/ko/System.Threading.xml @@ -0,0 +1,1952 @@ + + + + System.Threading + + + + 스레드가 다른 스레드에서 해제하지 않고 종료하여 중단한 개체를 가져오면 throw되는 예외입니다. + 1 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 중단된 뮤텍스의 지정된 인덱스 및 뮤텍스를 나타내는 개체(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 내부 예외를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 지정된 오류 메시지, 내부 예외, 중단된 뮤텍스의 인덱스 및 뮤텍스를 나타내는 개체(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 지정된 오류 메시지, 중단된 뮤텍스의 인덱스 및 중단된 뮤텍스(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 예외의 발생시킨 중단된 뮤텍스를 가져옵니다. + 중단된 뮤텍스를 나타내는 개체이며, 중단된 뮤텍스를 식별할 수 없는 경우에는 null입니다. + 1 + + + 예외의 발생시킨 중단된 뮤텍스를 가져옵니다. + + 메서드에 전달된 대기 핸들의 배열에서 중단된 뮤텍스를 나타내는 개체의 인덱스이고, 중단된 뮤텍스의 인덱스를 식별할 수 없는 경우에는 –1입니다. + 1 + + + 비동기 메서드와 같은 지정된 비동기 제어 흐름에 로컬인 앰비언트 데이터를 나타냅니다. + 앰비언트 데이터의 형식입니다. + + + 변경 알림을 받지 않는 인스턴스를 인스턴스화합니다. + + + 변경 알림을 받는 로컬 인스턴스를 인스턴스화합니다. + 스레드에서 현재 값이 변경될 때마다 호출되는 대리자입니다. + + + 앰비언트 데이터의 값을 가져오거나 설정합니다. + 앰비언트 데이터의 값입니다. + + + 변경 알림을 등록하는 인스턴스에 데이터 변경 정보를 제공하는 클래스입니다. + 데이터 형식입니다. + + + 데이터의 현재 값을 가져옵니다. + 데이터의 현재 값입니다. + + + 데이터의 이전 값을 가져옵니다. + 데이터의 이전 값입니다. + + + 실행 컨텍스트가 변경되어 값이 변경되었는지 여부를 나타내는 값을 반환합니다. + 실행 컨텍스트가 변경되어 값이 변경되었으면 true이고, 그렇지 않으면 false입니다. + + + 대기 중인 스레드에 이벤트가 발생했음을 알립니다.이 클래스는 상속될 수 없습니다. + 2 + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + + + 여러 작업이 여러 단계에 걸쳐 특정 알고리즘에서 병렬로 함께 작동할 수 있도록 합니다. + + + + 클래스의 새 인스턴스를 초기화합니다. + 참여 스레드의 수입니다. + + 가 0보다 작거나 32,767보다 큰 경우 + + + + 클래스의 새 인스턴스를 초기화합니다. + 참여 스레드의 수입니다. + 각 단계 후에 실행할 입니다. 아무 작업도 수행되지 않았음을 나타내기 위해 null(Visual Basic의 경우 Nothing)이 전달될 수 있습니다. + + 가 0보다 작거나 32,767보다 큰 경우 + + + 추가 참가자가 있음을 에 알립니다. + 새 참가자가 처음으로 참여할 장벽의 단계 번호입니다. + 현재 인스턴스가 이미 삭제된 경우 + 참가자를 추가하면 해당 장애물 참가자 수가 32,767을 초과하게 됩니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 추가 참가자가 있음을 에 알립니다. + 새 참가자가 처음으로 참여할 장벽의 단계 번호입니다. + 장벽에 추가할 추가 참가자의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우.또는 참가자를 추가하면 해당 장애물 참가자 수가 32,767을 초과하게 됩니다. + 이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 장벽의 현재 단계 번호를 가져옵니다. + 장벽의 현재 단계 번호를 반환합니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + 이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 장벽에 있는 참가자의 총 수를 가져옵니다. + 장벽에 있는 참가자의 총 수를 반환합니다. + + + 현재 단계에서 아직 신호를 받지 않은 장벽의 참가자 수를 가져옵니다. + 현재 단계에서 아직 신호를 받지 않은 장벽의 참가자 수를 반환합니다. + + + 참가자가 하나 감소함을 에 알립니다. + 현재 인스턴스가 이미 삭제된 경우 + 해당 장애물에 이미 0 참가자가 있습니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 참가자가 감소함을 에 알립니다. + 장벽에서 제거할 추가 참가자의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우. + 해당 장애물에 이미 0 참가자가 있습니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. 또는현재 참가자 수가 지정된 participantCount보다 작습니다. + 총 참가자 수가 지정된 보다 작습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 현재 인스턴스가 이미 삭제된 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + 모든 참가 스레드가 SignalAndWait를 호출한 후에 Barrier의 단계 후 작업에서 예외가 throw되는 경우 예외가 BarrierPostPhaseException에서 래핑되고 모든 참가 스레드에서 throw됩니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 부호 있는 32비트 정수로 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 지정된 시간 내에 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + 모든 참가 스레드가 SignalAndWait를 호출한 후에 Barrier의 단계 후 작업에서 예외가 throw되는 경우 예외가 BarrierPostPhaseException에서 래핑되고 모든 참가 스레드에서 throw됩니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 부호 있는 32비트 정수로 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 지정된 시간 내에 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 개체를 사용하여 시간 간격을 측정하여 다른 참가자도 장벽에 도달할 때까지 기다립니다. + 다른 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 없거나, 32,767보다 큰 경우. + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 개체를 사용하여 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 다른 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + + 의 사후 단계 작업이 실패할 경우 throw되는 예외입니다. + + + 오류를 설명하는 시스템 제공 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 내부 예외를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 현재 예외의 원인이 되는 예외입니다. + + + 오류를 설명하는 지정된 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 새 컨텍스트 내에서 호출될 메서드를 나타냅니다. + 콜백 메서드가 실행될 때마다 사용할 정보가 포함된 개체입니다. + 1 + + + 수가 0에 도달하는 경우 신호를 받는 동기화 기본 형식을 나타냅니다. + + + 지정된 수를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 를 설정하는 데 처음 필요한 신호의 수입니다. + + 가 0보다 작은 경우 + + + + 의 현재 수를 1씩 늘립니다. + 현재 인스턴스가 이미 삭제된 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는가 보다 크거나 같은 경우 + + + + 의 현재 수를 지정된 값만큼 늘립니다. + + 를 늘릴 값입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작거나 같은 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는개수가 만큼 증가된 후에 가 보다 크거나 같은 경우 + + + 이벤트를 설정하는 데 필요한 남아 있는 신호의 수를 가져옵니다. + 이벤트를 설정하는 데 필요한 남아 있는 신호의 수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 이벤트를 설정하는 데 처음으로 필요한 신호의 수를 가져옵니다. + 이벤트를 설정하는 데 처음으로 필요한 신호의 수입니다. + + + 이벤트가 설정되었는지 여부를 확인합니다. + 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + + + + 를 의 값으로 다시 설정합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + + 속성을 지정된 값으로 재설정합니다. + + 를 설정하는 데 필요한 신호의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우 + + + + 의 값을 줄이면서 신호를 에 등록합니다. + 신호로 인해 수가 0에 도달하고 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 현재 인스턴스가 이미 삭제된 경우 + 현재 인스턴스가 이미 설정되어 있습니다. + + + 지정된 양만큼 값을 줄이면서 여러 신호를 에 등록합니다. + 신호로 인해 수가 0에 도달하고 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 등록할 신호의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 1보다 작은 경우. + 현재 인스턴스가 이미 설정되어 있습니다. -또는- 가 보다 큰 경우 + + + 하나씩 를 증가하려고 시도했습니다. + 늘렸으면 true이고 그렇지 않으면 false입니다.가 이미 0이면 이 메서드에서 false를 반환합니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 와 같은 경우 + + + 지정된 값만큼 를 증가하려고 시도했습니다. + 늘렸으면 true이고 그렇지 않으면 false입니다.가 이미 0이면 false를 반환합니다. + + 를 늘릴 값입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작거나 같은 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는 + 가 보다 크거나 같은 경우 + + + + 가 설정될 때까지 현재 스레드를 차단합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + 부호 있는 32비트 정수로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을 확인하면서 부호 있는 32비트 정수로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을 확인하면서 가 설정될 때까지 현재 스레드를 차단합니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + + + 으로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + + 을 확인하면서 으로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + 이벤트가 설정될 때까지 대기하는 데 사용되는 을 가져옵니다. + 이벤트가 설정될 때까지 대기하는 데 사용되는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + + + 이 신호를 받은 후 자동이나 수동으로 다시 설정되는지 여부를 나타냅니다. + 2 + + + 신호를 받으면 이 스레드 하나를 해제한 후 자동으로 다시 설정됩니다.대기 중인 스레드가 없으면 은 스레드가 차단될 때까지 신호를 받은 상태로 유지되다가 스레드를 해제한 후 다시 설정됩니다. + + + 신호를 받으면 이 대기하는 스레드를 모두 해제하고 수동으로 다시 설정될 때까지 신호를 받은 상태로 유지됩니다. + + + 스레드 동기화 이벤트를 나타냅니다. + 2 + + + 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부와 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + + + 이 호출의 결과로 만들어진 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부, 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부 및 시스템 동기화 이벤트의 이름을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 이벤트가 만들어진 경우 초기 상태를 신호 받음으로 설정하려면 true를 사용하고, 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + 시스템 차원의 동기화 이벤트의 이름입니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 이벤트를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 이 260자보다 긴 경우 + + + 이 호출의 결과로 만들어진 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부, 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부, 시스템 동기화 이벤트의 이름 및 호출 후 명명된 시스템 이벤트가 만들어졌는지 여부를 나타내는 부울 변수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 이벤트가 만들어진 경우 초기 상태를 신호 받음으로 설정하려면 true를 사용하고, 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + 시스템 차원의 동기화 이벤트의 이름입니다. + 이 메서드가 반환될 때 로컬 이벤트가 만들어지거나(이 null 또는 빈 문자열) 명명된 지정 시스템 이벤트가 만들어지면 true가 포함되고 명명된 지정 시스템 이벤트가 이미 있으면 false가 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 이벤트를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 이 260자보다 긴 경우 + + + 이미 있는 경우 지정한 명명된 동기화 이벤트를 엽니다. + 명명된 시스템 이벤트를 나타내는 개체입니다. + 열려는 시스템 동기화 이벤트의 이름입니다. + + 이 빈 문자열인 경우 또는이 260자보다 긴 경우 + + 가 null입니다. + 명명된 시스템 이벤트가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 이벤트가 있지만 사용자에게 이 이벤트를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + 1 + + + + + + 스레드가 차단되도록 이벤트 상태를 신호 없음으로 설정합니다. + 작업이 성공적으로 수행되면 true이고, 그렇지 않으면 false입니다. + + 메서드가 이 에 대해 이전에 호출된 경우 + 2 + + + 하나 이상의 대기 중인 스레드가 계속 진행되도록 이벤트 상태를 신호 받음으로 설정합니다. + 작업이 성공적으로 수행되면 true이고, 그렇지 않으면 false입니다. + + 메서드가 이 에 대해 이전에 호출된 경우 + 2 + + + 지정된 명명된 synchronization 이벤트(이미 존재하는 경우)를 열고 작업이 성공적으로 수행되었는지를 나타내는 값을 반환합니다. + 명명된 동기화 이벤트를 열었으면 true이고, 그렇지 않으면 false입니다. + 열려는 시스템 동기화 이벤트의 이름입니다. + 이 메서드가 반환될 때 호출이 성공적으로 실행된 경우 이름이 지정된 동기화 이벤트를 나타내는 개체를 포함하고 호출에 실패한 경우는 null을 포함해야 합니다.이 매개 변수는 초기화되지 않은 것으로 취급됩니다. + + 이 빈 문자열인 경우또는이 260자보다 긴 경우 + + 가 null입니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 있지만 사용자에게 원하는 보안 액세스가 없는 경우 + + + 현재 스레드의 실행 컨텍스트를 관리합니다.이 클래스는 상속될 수 없습니다. + 2 + + + 현재 스레드에서 실행 컨텍스트를 캡처합니다. + 현재 스레드의 실행 컨텍스트를 나타내는 개체입니다. + 1 + + + 현재 스레드의 지정된 실행 컨텍스트에서 메서드를 실행합니다. + 설정할 입니다. + 제공된 실행 컨텍스트에서 실행할 메서드를 나타내는 대리자입니다. + 콜백 메서드로 전달할 개체입니다. + + 가 null입니다.또는캡처 작업을 통해 를 가져오지 않은 경우 또는가 이미 호출의 인수로 사용된 경우 + 1 + + + + + + 다중 스레드에서 공유하는 변수에 대한 원자 단위 연산을 제공합니다. + 2 + + + 원자 단위 연산으로 두 32비트 정수를 더하고 첫 번째 정수를 합계로 바꿉니다. + + 에 저장된 새 값입니다. + 더할 첫 번째 값이 있는 변수입니다.두 값의 합계는 에 저장됩니다. + + 에서 정수에 더할 값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 두 64비트 정수를 더하고 첫 번째 정수를 합계로 바꿉니다. + + 에 저장된 새 값입니다. + 더할 첫 번째 값이 있는 변수입니다.두 값의 합계는 에 저장됩니다. + + 에서 정수에 더할 값입니다. + The address of is a null pointer. + 1 + + + 두 배 정밀도 부동 소수점 숫자가 같은지 비교하여 같으면 두 값 중 하나를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 개의 부호 있는 32비트 정수가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 개의 부호 있는 64비트 정수가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 플랫폼별 핸들이나 포인터가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 값과 비교되어 로 바뀔 수 있는 값을 가진 대상 입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 입니다. + + 의 값과 비교할 입니다. + The address of is a null pointer. + 1 + + + 두 개체의 참조가 같은지 비교하여 같으면 첫 번째 개체를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 대상 개체입니다. + 비교한 결과 같은 경우 대상 개체를 바꾸는 개체입니다. + + 의 개체와 비교할 개체입니다. + The address of is a null pointer. + 1 + + + 두 단정밀도 부동 소수점 숫자가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 지정된 참조 형식 의 두 인스턴스가 같은지 비교하여 같으면 두 값 중 하나를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다.이것은 참조 매개 변수입니다. C#에서는 ref이고, Visual Basic에서는 ByRef입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + + , 및 에 사용될 형식입니다.이 형식은 참조 형식이어야 합니다. + The address of is a null pointer. + + + 원자 단위 연산으로 지정된 변수를 감소시키고 결과를 저장합니다. + 감소한 값입니다. + 값을 감소시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 변수를 감소시키고 결과를 저장합니다. + 감소한 값입니다. + 값을 감소시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 배정밀도 부동 소수점 숫자를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 부호 있는 32비트 정수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 부호 있는 64비트 정수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 플랫폼별 핸들 또는 포인터를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 개체를 지정된 값으로 설정하고 참조를 원래 개체로 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 단정밀도 부동 소수점 숫자를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 형식 의 변수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다.이것은 참조 매개 변수입니다. C#에서는 ref이고, Visual Basic에서는 ByRef입니다. + + 매개 변수의 설정값입니다. + + 및 에 사용될 형식입니다.이 형식은 참조 형식이어야 합니다. + The address of is a null pointer. + + + 원자 단위 연산으로 지정된 변수를 증가시키고 결과를 저장합니다. + 증가한 값입니다. + 값을 증가시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 변수를 증가시키고 결과를 저장합니다. + 증가한 값입니다. + 값을 증가시킬 변수입니다. + The address of is a null pointer. + 1 + + + 다음과 같이 메모리 액세스를 동기화합니다. 현재 스레드를 실행하는 프로세서는 에 대한 호출 이전의 메모리 액세스가 에 대한 호출 이후의 메모리 액세스 뒤에 실행되는 방식으로 명령을 다시 정렬할 수 없습니다. + + + 원자 단위 연산으로 로드된 64비트 값을 반환합니다. + 로드된 값입니다. + 로드될 64비트 값입니다. + 1 + + + 초기화 지연 루틴을 제공합니다. + + + 아직 초기화되지 않은 경우 형식의 기본 생성자를 사용하여 대상 참조 형식을 초기화합니다. + 초기화된 형식의 참조입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조입니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 해당 기본 생성자를 사용하여 대상 참조 또는 값 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조 또는 값입니다. + 대상이 이미 초기화되었는지 여부를 결정하는 부울 값에 대한 참조입니다. + + 을 초기화할 때 상호 배타적인 잠금으로 사용할 개체에 대한 참조입니다.이 null이면 새 개체를 인스턴스화할 수 있습니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 지정된 함수를 사용하여 대상 참조 또는 값 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조 또는 값입니다. + 대상이 이미 초기화되었는지 여부를 결정하는 부울 값에 대한 참조입니다. + + 을 초기화할 때 상호 배타적인 잠금으로 사용할 개체에 대한 참조입니다.이 null이면 새 개체를 인스턴스화할 수 있습니다. + 참조 또는 값을 초기화하기 위해 호출되는 함수입니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 지정된 함수를 사용하여 대상 참조 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조입니다. + 참조를 초기화하기 위해 호출되는 함수입니다. + 초기화할 참조의 참조 형식입니다. + 형식 에 기본 생성자가 없는 경우 + + 가 null을 반환합니다(Visual Basic의 경우 Nothing). + + + 잠금에 대한 재귀 정책과 맞지 않는 방식으로 잠금을 재귀적으로 시작할 때 throw되는 예외입니다. + 2 + + + 오류를 설명하는 시스템 제공 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 2 + + + 오류를 설명하는 지정된 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 따라 지역화되었는지 확인해야 합니다. + 2 + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 따라 지역화되었는지 확인해야 합니다. + 현재 예외를 발생시킨 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + 2 + + + 동일한 스레드에서 잠금을 여러 번 시작할 수 있는지 여부를 지정합니다. + + + 스레드에서 잠금을 재귀적으로 시작하려고 하면 예외가 throw됩니다.이 설정을 적용하는 경우 일부 클래스에서 특정 재귀가 허용될 수도 있습니다. + + + 스레드에서 잠금을 재귀적으로 시작할 수 있습니다.일부 클래스에서는 이 기능이 제한될 수 있습니다. + + + 하나 이상의 대기 중인 스레드에 이벤트가 발생했음을 알립니다.이 클래스는 상속될 수 없습니다. + 2 + + + 초기 상태를 신호 받음으로 설정할지 여부를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + + + + 의 슬림 다운 버전을 제공합니다. + + + 신호 없음을 초기 상태로 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true이고 초기 상태를 신호 없음으로 설정하려면 false입니다. + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값과 지정된 회전 수를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true이고 초기 상태를 신호 없음으로 설정하려면 false입니다. + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수입니다. + + is less than 0 or greater than the maximum allowed value. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 이벤트가 설정되었는지를 가져옵니다. + 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + + + 스레드가 차단되도록 이벤트 상태를 신호 없음으로 설정합니다. + The object has already been disposed. + + + 이벤트에서 대기 중인 하나 이상의 스레드가 계속 진행되도록 이벤트 상태를 신호 받음으로 설정합니다. + + + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수를 가져옵니다. + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수를 반환합니다. + + + 현재 이 설정될 때까지 현재 스레드를 차단합니다. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 부호 있는 32비트 정수로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + 을 확인하면서 부호 있는 32비트 정수로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + + 을 확인하면서 현재 이 신호를 받을 때까지 현재 스레드를 차단합니다. + 확인할 입니다. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + + 으로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + 을 확인하면서 으로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 이 의 내부 개체를 가져옵니다. + 이 에 대한 내부 이벤트 개체입니다. + + + 개체에 대한 액세스를 동기화하는 메커니즘을 제공합니다. + 2 + + + 지정된 개체의 단독 잠금을 가져옵니다. + 모니터 잠금을 가져올 개체입니다. + + 매개 변수가 null인 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정합니다. + 대기할 개체입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다.예외가 발생하지 않는 경우 이 메서드의 출력은 항상 true입니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + + 지정된 개체의 단독 잠금을 해제합니다. + 잠금을 해제할 개체입니다. + + 매개 변수가 null인 경우 + 현재 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 현재 스레드에 지정된 개체에 대한 잠금이 있는지 여부를 확인합니다. + 현재 스레드에 에 대한 잠금이 있으면 true이고, 그렇지 않으면 false입니다. + 테스트할 개체입니다. + + 가 null인 경우 + + + 대기 중인 큐에 포함된 스레드에 잠겨 있는 개체의 상태 변경을 알립니다. + 스레드에서 기다리는 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 대기 중인 모든 스레드에 개체 상태 변경을 알립니다. + 펄스를 보내는 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + + 매개 변수가 null인 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + + 지정된 시간(밀리초) 동안 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + 잠금을 기다릴 밀리초 수입니다. + + 매개 변수가 null인 경우 + + 이 음수이고 와 같지 않은 경우 + 1 + + + 지정된 시간(밀리초) 동안 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 기다릴 밀리초 수입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + 이 음수이고 와 같지 않은 경우 + + + 지정된 시간 동안 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + 잠금을 기다리는 시간을 나타내는 입니다.-1밀리초 값은 무한 대기를 지정합니다. + + 매개 변수가 null인 경우 + + 값(밀리초)이 음수이고 (–1밀리초)와 같지 않거나 보다 큰 경우 + 1 + + + 지정된 시간 동안 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 대기할 시간입니다.-1밀리초 값은 무한 대기를 지정합니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + 값(밀리초)이 음수이고 (–1밀리초)와 같지 않거나 보다 큰 경우 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다. + 지정된 개체 잠금을 호출자가 다시 가져와 호출이 반환되면 true입니다.잠금을 다시 가져오지 않으면 이 메서드는 반환하지 않습니다. + 대기할 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + 1 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다.지정된 시간 제한 간격이 지나면 스레드가 준비된 큐에 들어갑니다. + 지정된 시간이 경과하기 전에 잠금을 다시 가져오면 true이고, 지정된 시간이 경과한 후에 잠금을 다시 가져오면 false입니다.이 메서드는 잠금을 다시 가져올 때까지 반환하지 않습니다. + 대기할 개체입니다. + 스레드가 준비된 큐에 들어가기 전에 대기할 밀리초 수입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + + 매개 변수의 값이 음이고 와 같지 않은 경우 + 1 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다.지정된 시간 제한 간격이 지나면 스레드가 준비된 큐에 들어갑니다. + 지정된 시간이 경과하기 전에 잠금을 다시 가져오면 true이고, 지정된 시간이 경과한 후에 잠금을 다시 가져오면 false입니다.이 메서드는 잠금을 다시 가져올 때까지 반환하지 않습니다. + 대기할 개체입니다. + 스레드가 준비된 큐에 들어가기 전에 대기할 시간을 나타내는 입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + + 매개 변수의 값(밀리초)이 음수이고 (-1밀리초)를 나타내지 않거나 보다 큰 경우 + 1 + + + 프로세스 간 동기화에 사용할 수도 있는 동기화 기본 형식입니다. + 1 + + + 기본 속성을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 호출한 스레드에 뮤텍스의 초기 소유권을 부여하면 true이고, 그렇지 않으면 false입니다. + + + 호출 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값과 뮤텍스 이름인 문자열을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 시스템 뮤텍스가 만들어지는 경우 호출한 스레드에 명명된 시스템 뮤텍스의 초기 소유권을 부여하려면 true이고, 그렇지 않으면 false입니다. + + 의 이름입니다.값이 null이면 이(가) 명명되지 않습니다. + 명명된 뮤텍스가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 260 자 보다 깁니다. + + + 호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값, 뮤텍스의 이름인 문자열 및 메서드에서 반환할 때 호출한 스레드에 뮤텍스의 초기 소유권이 부여되었는지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 시스템 뮤텍스가 만들어지는 경우 호출한 스레드에 명명된 시스템 뮤텍스의 초기 소유권을 부여하려면 true이고, 그렇지 않으면 false입니다. + + 의 이름입니다.값이 null이면 이(가) 명명되지 않습니다. + 이 메서드가 반환될 때 로컬 뮤텍스가 만들어진 경우(즉, 이(가) null이거나 빈 문자열인 경우)나 지정된 명명된 시스템 뮤텍스가 만들어진 경우에는 true인 부울이 포함되고, 지정된 명명된 시스템 뮤텍스가 이미 있는 경우에는 false이(가) 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + 명명된 뮤텍스가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 260 자 보다 깁니다. + + + 이미 있는 경우 지정한 명명된 뮤텍스를 엽니다. + 명명된 시스템 뮤텍스를 나타내는 개체입니다. + 열려는 시스템 뮤텍스의 이름입니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + 명명된 뮤텍스가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스가 있지만 사용자에게 이 뮤텍스를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + 1 + + + + + + + 을(를) 한 번 해제합니다. + 호출한 스레드가 뮤텍스를 소유하지 않은 경우 + 1 + + + 지정한 명명된 뮤텍스(이미 존재하는 경우)를 열고 작업이 수행되었는지를 나타내는 값을 반환합니다. + 명명된 뮤텍스를 열었으면 true이고, 그렇지 않으면 false입니다. + 열려는 시스템 뮤텍스의 이름입니다. + 이 메서드가 반환될 때 호출이 성공적으로 실행된 경우 이름이 지정된 뮤텍스를 나타내는 개체를 포함하고 호출에 실패한 경우는 null을(를) 포함해야 합니다.이 매개 변수는 초기화되지 않은 것으로 처리됩니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스가 있지만 사용자에게 이 뮤텍스를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + + + 여러 스레드에서 읽을 수 있도록 허용하거나 쓰기를 위한 단독 액세스를 허용하여 리소스에 대한 액세스를 관리하는 데 사용되는 잠금을 나타냅니다. + + + 기본 속성 값으로 클래스의 새 인스턴스를 초기화합니다. + + + 잠금 재귀 정책을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 잠금 재귀 정책을 지정하는 열거형 값 중 하나입니다. + + + 읽기 모드로 잠금을 시작한 고유 스레드의 총 개수를 가져옵니다. + 읽기 모드로 잠금을 시작한 고유 스레드의 총 개수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 읽기 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 쓰기 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 읽기 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 읽기 모드를 종료합니다. + The current thread has not entered the lock in read mode. + + + 업그레이드 가능 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 업그레이드 가능 모드를 종료합니다. + The current thread has not entered the lock in upgradeable mode. + + + 쓰기 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 쓰기 모드를 종료합니다. + The current thread has not entered the lock in write mode. + + + 현재 스레드에서 읽기 모드로 잠금을 시작했는지를 나타내는 값을 가져옵니다. + 현재 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 스레드에서 업그레이드 가능 모드로 잠금을 시작했는지 여부를 나타내는 값을 가져옵니다. + 현재 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 스레드에서 쓰기 모드로 잠금을 시작했는지를 나타내는 값을 가져옵니다. + 현재 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 개체에 대한 재귀 정책을 나타내는 값을 가져옵니다. + 잠금 재귀 정책을 지정하는 열거형 값 중 하나입니다. + + + 재귀를 확인하기 위해 현재 스레드에서 읽기 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 읽기 모드를 시작하지 않았으면 0이고, 스레드에서 읽기 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 잠금을 n-1회 시작했으면 n입니다. + 2 + + + 재귀를 확인하기 위해 현재 스레드에서 업그레이드 가능 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 업그레이드 가능 모드를 시작하지 않았으면 0이고, 스레드에서 업그레이드 가능 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 업그레이드 가능 모드를 n-1회 시작했으면 n입니다. + 2 + + + 재귀를 확인하기 위해 현재 스레드에서 쓰기 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 쓰기 모드를 시작하지 않았으면 0이고, 스레드에서 쓰기 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 쓰기 모드를 n-1회 시작했으면 n입니다. + 2 + + + 제한 시간(정수)을 선택적으로 적용하여 읽기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 읽기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 쓰기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 쓰기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 읽기 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 읽기 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 업그레이드 가능 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 업그레이드 가능 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 쓰기 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 쓰기 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 리소스 또는 리소스 풀에 동시에 액세스할 수 있는 스레드 수를 제한합니다. + 1 + + + 초기 항목 수 및 최대 동시 항목 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + + 가 보다 큰 경우 + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + + + 초기 항목 수 및 최대 동시 항목 수를 지정하고 선택적으로 시스템 세마포 개체의 이름을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + 명명된 시스템 세마포 개체의 이름입니다. + + 가 보다 큰 경우또는 260 자 보다 깁니다. + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 세마포를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + + 초기 항목 수 및 최대 동시 항목 수를 지정하고, 선택적으로 시스템 세마포 개체의 이름을 지정하고, 새 시스템 세마포가 만들어졌는지 여부를 나타내는 값을 받을 변수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 동시에 충족될 수 있는 세마포의 초기 요청 수입니다. + 동시에 충족될 수 있는 세마포의 최대 요청 수입니다. + 명명된 시스템 세마포 개체의 이름입니다. + 이 메서드가 반환될 때 로컬 세마포가 만들어진 경우(즉, 이 null이거나 빈 문자열인 경우) 또는 지정한 명명된 시스템 세마포가 만들어진 경우에는 true가 포함되고, 지정한 명명된 시스템 세마포가 이미 있는 경우에는 false가 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + + 가 보다 큰 경우 또는 260 자 보다 깁니다. + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 세마포를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + + 이미 있는 경우 지정한 명명된 세마포를 엽니다. + 명명된 시스템 세마포를 나타내는 개체입니다. + 열려는 시스템 세마포의 이름입니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + 명명된 세마포가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 있지만 사용자에게 이 세마포를 사용하는 데 필요한 보안 액세스가 없는 경우 + 1 + + + + + + 세마포를 종료하고 이전 카운트를 반환합니다. + + 메서드가 호출되기 전의 세마포 카운트입니다. + 세마포 카운트가 이미 최대값인 경우 + 명명된 세마포에서 Win32 오류가 발생한 경우 + 현재 세마포가 명명된 시스템 세마포를 나타내지만 사용자에게 가 없는 경우또는현재 세마포가 명명된 시스템 세마포를 나타내지만 세마포가 를 사용하여 열리지 않은 경우 + 1 + + + 지정된 횟수만큼 세마포를 종료하고 이전 카운트를 반환합니다. + + 메서드가 호출되기 전의 세마포 카운트입니다. + 세마포를 종료할 횟수입니다. + + 1 보다 작으면입니다. + 세마포 카운트가 이미 최대값인 경우 + 명명된 세마포에서 Win32 오류가 발생한 경우 + 현재 세마포가 명명된 시스템 세마포를 나타내지만 사용자에게 권한이 없는 경우또는현재 세마포가 명명된 시스템 세마포를 나타내지만 세마포가 권한을 사용하여 열리지 않은 경우 + 1 + + + 지정한 명명된 세마포(이미 존재하는 경우)를 열고 작업이 성공했는지를 나타내는 값을 반환합니다. + 명명된 세마포를 열었으면 true이고, 그 열지 않았으면 false입니다. + 열려는 시스템 세마포의 이름입니다. + 이 메서드가 반환될 때 호출에 성공한 경우에는 명명된 세마포를 나타내는 개체를 포함하고 호출에 실패한 경우에는 null을 포함합니다.이 매개 변수는 초기화되지 않은 것으로 처리됩니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 있지만 사용자에게 이 세마포를 사용하는 데 필요한 보안 액세스가 없는 경우 + + + 카운트가 이미 최대값에 도달한 세마포에서 메서드를 호출하면 throw되는 예외입니다. + 2 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 리소스 또는 리소스 풀에 동시에 액세스할 수 있는 스레드 수를 제한하는 대신 사용할 수 있는 간단한 클래스를 나타냅니다. + + + 동시에 부여할 수 있는 초기 요청 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + + 가 0보다 작은 경우 + + + 동시에 부여할 수 있는 초기 및 최대 요청 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + + 가 0보다 작거나 가 보다 크거나 가 0보다 작거나 같은 경우. + + + 세마포에서 대기하는 데 사용할 수 있는 을(를) 반환합니다. + 세마포에서 대기하는 데 사용할 수 있는 입니다. + + 가 삭제된 경우 + + + + 개체에 들어갈 수 있는 남아 있는 스레드의 수를 가져옵니다. + 세마포에 들어갈 수 있는 남아 있는 스레드의 수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + + 개체를 한 번 해제합니다. + + 의 이전 횟수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 이미 최대 크기에 도달했습니다. + + + + 개체를 지정된 횟수만큼 해제합니다. + + 의 이전 횟수입니다. + 세마포를 종료할 횟수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 1 보다 작으면입니다. + + 이 이미 최대 크기에 도달했습니다. + + + 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + 제한 시간을 지정하는 부호 있는 32비트 정수를 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을(를) 확인하면서 제한 시간을 지정하는 부호 있는 32비트 정수를 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + 인스턴스가 삭제 또는 만든 가 삭제 되었습니다. + + + + 을(를) 확인하면서 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 확인할 토큰입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우또는 만든 이미 삭제 되었습니다. + + + + (으)로 제한 시간을 지정하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + semaphoreSlim 인스턴스가 삭제되었습니다 + + + + 을(를) 확인하면서 제한 시간을 지정하는 을(를) 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + semaphoreSlim 인스턴스가 삭제되었습니다을 만든 가 이미 삭제되었습니다. + + + + (으)로 전환될 때까지 비동기적으로 기다립니다. + 세마포가 입력되었을 때 완료될 작업입니다. + + + 32비트 부호 있는 정수를 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을(를) 관찰하는 동안 32비트 부호 있는 정수를 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 현재 인스턴스가 이미 삭제된 경우 + + 이 취소되었습니다. + + + + 을(를) 관찰하는 동안 (으)로 전환될 때까지 비동기적으로 기다립니다. + 세마포가 입력되었을 때 완료될 작업입니다. + 확인할 토큰입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 취소되었습니다. + + + + 을(를) 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 또는 제한 시간이 보다 큰 경우 + + + + 을 관찰하는 동안 을(를) 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 토큰입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우또는제한 시간이 보다 큰 경우 + + 이 취소되었습니다. + + + 메시지가 동기화 컨텍스트로 디스패치될 때 호출할 메서드를 나타냅니다. + 대리자에 전달된 개체입니다. + 2 + + + 잠금을 얻으려는 스레드가 잠금을 사용할 수 있을 때까지 루프에서 반복적으로 확인하면서 대기하는 기본적인 상호 배타 잠금을 제공합니다. + + + 디버깅을 향상시키기 위해 스레드 ID를 추적하는 옵션을 사용하여 구조체의 새 인스턴스를 초기화합니다. + 디버깅 용도로 스레드 ID를 캡처하고 사용할지 여부입니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으며 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 인수는 Enter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 잠금을 해제합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이 잠금의 소유자가 아닙니다. + + + 잠금을 해제합니다. + 종료 작업을 다른 스레드에 즉시 게시하기 위해 메모리 펜스를 실행할지 여부를 나타내는 부울 값입니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이 잠금의 소유자가 아닙니다. + + + 스레드에서 현재 잠금을 보유하고 있는지 여부를 가져옵니다. + 스레드에서 현재 잠금을 보유하고 있으면 true이고, 그렇지 않으면 false입니다. + + + 현재 스레드에서 잠금을 보유하고 있는지 여부를 가져옵니다. + 현재 스레드에서 잠금을 보유하고 있으면 true이고, 그렇지 않으면 false입니다. + 스레드 소유권 추적을 사용할 수 없습니다. + + + 이 인스턴스에 대해 스레드 소유권 추적이 사용되는지 여부를 가져옵니다. + 이 인스턴스에 대해 스레드 소유권 추적이 사용되면 true이고, 그렇지 않으면 false입니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 밀리초보다 큰 경우. + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 회전 기반 대기를 지원합니다. + + + 이 인스턴스에서 가 호출된 횟수를 가져옵니다. + 이 인스턴스에서 가 호출된 횟수를 나타내는 정수를 반환합니다. + + + 다음 호출이 프로세서를 생성하여 강제 컨텍스트 전환을 트리거할지 여부를 가져옵니다. + 다음 호출이 프로세서를 생성하여 강제 컨텍스트 전환을 트리거할지 여부입니다. + + + 회전 수를 다시 설정합니다. + + + 단일 회전을 수행합니다. + + + 지정된 조건이 충족될 때까지 회전합니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + + 인수가 null인 경우 + + + 지정된 조건이 충족되거나 지정된 제한 시간이 만료될 때까지 회전합니다. + 제한 시간 내에 지정된 조건이 충족되면 true이고, 그렇지 않으면 false입니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + 인수가 null인 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + 지정된 조건이 충족되거나 지정된 제한 시간이 만료될 때까지 회전합니다. + 제한 시간 내에 지정된 조건이 충족되면 true이고, 그렇지 않으면 false입니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 TimeSpan입니다. + + 인수가 null인 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + 다양한 동기화 모델에서 동기화 컨텍스트를 전파하기 위한 기본 기능을 제공합니다. + 2 + + + + 클래스의 새 인스턴스를 만듭니다. + + + 파생 클래스에서 재정의된 경우 동기화 컨텍스트의 복사본을 만듭니다. + 새 개체입니다. + 2 + + + 현재 스레드의 동기화 컨텍스트를 가져옵니다. + 현재 동기화 컨텍스트를 나타내는 개체입니다. + 1 + + + 파생 클래스에서 재정의되면 작업이 완료되었음을 알리는 메시지에 응답합니다. + + + 파생 클래스에서 재정의되면 작업이 시작되었음을 알리는 메시지에 응답합니다. + + + 파생 클래스에서 재정의될 때 비동기 메시지를 동기화 컨텍스트로 디스패치합니다. + 호출할 대리자입니다. + 대리자에 전달된 개체입니다. + 2 + + + 파생 클래스에서 재정의될 때 동기 메시지를 동기화 컨텍스트로 디스패치합니다. + 호출할 대리자입니다. + 대리자에 전달된 개체입니다. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 현재 동기화 컨텍스트를 설정합니다. + 설정할 개체입니다. + 1 + + + + + + 메서드가 지정된 Monitor에 대해 잠금을 소유하도록 호출자에게 요구하지만 해당 잠금을 소유하지 않는 호출자가 해당 메서드를 호출할 때 throw되는 예외입니다. + 2 + + + 기본 속성을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 데이터의 스레드 로컬 저장소를 제공합니다. + 스레드별로 저장되는 데이터의 형식을 지정합니다. + + + + 인스턴스를 초기화합니다. + + + + 인스턴스를 초기화합니다. + 인스턴스에 설정된 모든 값을 추적하고 해당 값을 속성을 통해 노출할지 여부 + + + 지정된 함수를 사용하여 의 인스턴스를 초기화합니다. + + 를 이전에 초기화하지 않고 검색하려고 하는 경우 lazily-initialized 값을 생성하기 위해 호출되는 입니다. + + 는 null 참조(Visual Basic의 경우 Nothing)입니다. + + + 지정된 함수를 사용하여 의 인스턴스를 초기화합니다. + + 를 이전에 초기화하지 않고 검색하려고 하는 경우 lazily-initialized 값을 생성하기 위해 호출되는 입니다. + 인스턴스에 설정된 모든 값을 추적하고 해당 값을 속성을 통해 노출할지 여부 + + 이 null 참조(Visual Basic의 경우 Nothing)인 경우 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + 이 인스턴스에서 사용하는 리소스를 해제합니다. + + 호출로 인해 이 메서드가 호출되는지 여부를 나타내는 부울 값입니다. + + + 이 인스턴스에서 사용하는 리소스를 해제합니다. + + + + 가 현재 스레드에서 초기화되었는지 여부를 가져옵니다. + 현재 스레드에서 가 초기화되었으면 true이고, 그렇지 않으면 false입니다. + + 인스턴스가 삭제된 경우 + + + 현재 스레드에 대한 이 인스턴스의 문자열 표현을 만들고 반환합니다. + + 에서 을 호출한 결과입니다. + + 인스턴스가 삭제된 경우 + 현재 스레드의 는 null 참조입니다(Visual Basic에서는 Nothing). + 초기화 함수는 를 재귀적으로 참조하려고 했습니다. + 기본 생성자가 제공되지 않으며 값 팩터리가 제공되지 않습니다. + + + 현재 인스턴스에 대한 이 인스턴스의 값을 가져오거나 설정합니다. + 이 ThreadLocal이 초기화를 담당하는 개체의 인스턴스를 반환합니다. + + 인스턴스가 삭제된 경우 + 초기화 함수는 를 재귀적으로 참조하려고 했습니다. + 기본 생성자가 제공되지 않으며 값 팩터리가 제공되지 않습니다. + + + 이 인스턴스에 액세스한 모든 스레드가 현재 저장한 모든 값의 목록을 가져옵니다. + 이 인스턴스에 액세스한 모든 스레드가 현재 저장한 모든 값의 목록입니다. + + 인스턴스가 삭제된 경우 + + + 휘발성 메모리 작업을 수행하기 위한 메서드가 포함되어 있습니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드에서 개체 참조를 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 에 대한 참조입니다.이 참조는 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + 읽을 필드의 형식입니다.이 형식은 값 형식이 아니라 참조 형식이어야 합니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 메모리 작업이 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 메모리 작업을 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 개체 참조를 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 개체 참조를 쓴 필드입니다. + 쓸 개체 참조입니다.컴퓨터의 모든 프로세서에서 참조를 볼 수 있도록 참조를 즉시 씁니다. + 쓸 필드의 형식입니다.이 형식은 값 형식이 아니라 참조 형식이어야 합니다. + + + 존재하지 않는 시스템 뮤텍스 또는 세마포를 열려고 시도할 때 throw되는 예외입니다. + 2 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/ru/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/ru/System.Threading.xml new file mode 100644 index 000000000..6ca30336b --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/ru/System.Threading.xml @@ -0,0 +1,1761 @@ + + + + System.Threading + + + + Исключение вызывается, когда некоторый поток получает объект , брошенный другим потоком путем выхода без высвобождения. + 1 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса , используя конкретиый индекс брошенного мьютекса, (если применимо), а также объект , представляющий мьютекс. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причины исключения. + + + Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и внутренним исключением. + Сообщение об ошибке с объяснением причины исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение вызывается в блоке catch, обрабатывающем внутреннее исключение. + + + Инициализирует новый экземпляр класса , используя указанное сообщения об ошибке, внутреннее исключение, индекс брошенного мьютекса (если применимо), а также объект , представляющего мьютекс. + Сообщение об ошибке с объяснением причины исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение вызывается в блоке catch, обрабатывающем внутреннее исключение. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Инициализирует новый экземпляр класса указанным сообщением об ошибке, индексом брошенного мьютекса (если применимо), а также брошенным мьютексом. + Сообщение об ошибке с объяснением причины исключения. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Получает брошенный мьютекс, вызвавший исключение (если он известен). + Объект , представляющий брошенный мьютекс, или null, если брошенный мьютекс не может быть идентифицирован. + 1 + + + Получает индекс брошенного мьютекса, вызвавшего исключение (если он известен). + Индекс в массиве дескрипторов ожидания, передаваемый в метод , объекта , представляющего брошенный мьютекс, или же -1, если индекс брошенного мьютекса невозможно определить. + 1 + + + Представляет внешние данные, локальные для данного асинхронного потока управления, такие как асинхронный метод. + Тип внешних данных. + + + Создает экземпляр экземпляра , который не получает уведомления об изменениях. + + + Создает экземпляр локального экземпляра , который получает уведомления об изменениях. + Делегат, который вызывается при каждом изменении текущего значения в любом потоке. + + + Получает или задает значение внешних данных. + Значение внешних данных. + + + Класс, предоставляющий сведения об изменениях данных экземплярам , которые зарегистрированы для получения уведомлений об изменениях. + Тип данных. + + + Получает текущее значение данных. + Текущее значение данных. + + + Получает предыдущее значение данных. + Предыдущее значение данных. + + + Возвращает значение, указывающее, изменяется ли значение из-за изменения контекста выполнения. + Значение true, если значение изменено из-за изменения контекста выполнения; в противном случае — значение false. + + + Уведомляет ожидающий поток о том, что произошло событие.Этот класс не наследуется. + 2 + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение. + + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + + + Позволяет нескольким задачам параллельно работать с алгоритмом, используя несколько фаз. + + + Инициализирует новый экземпляр класса . + Количество участвующих потоков. + + меньше 0 или больше 32,767. + + + Инициализирует новый экземпляр класса . + Количество участвующих потоков. + + для исполнения после каждой фазы. Значение null (Nothing in Visual Basic) может быть передано, чтобы указать, что действия не предпринимаются. + + меньше 0 или больше 32,767. + + + Уведомляет о добавлении дополнительного участника. + Номер фазы барьера, в которой сначала участвуют новые участники. + Текущий экземпляр уже был удален. + Добавление участника приведет к превышению 32 767 счетчиком участников барьера.– или –Метод был вызван из действия после этапа. + + + Уведомляет барьер о добавлении дополнительных участников. + Номер фазы барьера, в которой сначала участвуют новые участники. + Число дополнительных участников, которых необходимо добавить в барьер. + Текущий экземпляр уже был удален. + Значение параметра меньше 0.– или –Добавление участников приведет к превышению 32 767 счетчиком участников барьера. + Метод был вызван из действия после этапа. + + + Получает номер текущей фазы барьера. + Возвращает номер текущего этапа барьера. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + Метод был вызван из действия после этапа. + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает общее количество участников в барьере. + Возвращает общее количество участников в барьере. + + + Получает количество участников в барьере, которые еще не создали сигнал в текущей фазе. + Возвращает количество участников в барьере, которые еще не создали сигнал на текущем этапе. + + + Уведомляет о удалении одного участника. + Текущий экземпляр уже был удален. + Барьер уже содержит 0 участников.– или –Метод был вызван из действия после этапа. + + + Уведомляет барьер об удалении нескольких участников. + Число дополнительных участников, которых необходимо удалить из барьера. + Текущий экземпляр уже был удален. + Значение параметра меньше 0. + Барьер уже содержит 0 участников.– или –Метод был вызван из действия после этапа. – или –текущее количество участников меньше указанного participantCount + Общее число участников меньше указанного + + + Сообщает, что участник достиг барьера и ожидает достижения барьера другими участниками. + Текущий экземпляр уже был удален. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + Если создается исключение из действия следующего этапа барьера после того, как все участвующие потоки вызвали SignalAndWait, исключение будет вставлено в BarrierPostPhaseException и создано для всех участвующих потоков. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя 32-разрядное знаковое целое число для измерения времени ожидания. + Значение true, если все участники достигли барьера за указанное время; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + Если создается исключение из действия следующего этапа барьера после того, как все участвующие потоки вызвали SignalAndWait, исключение будет вставлено в BarrierPostPhaseException и создано для всех участвующих потоков. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя 32-разрядное знаковое целое число для измерения времени ожидания. Кроме того, метод контролирует токен отмены. + Значение true, если все участники достигли барьера за указанное время; в противном случае — значение false + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками. Кроме того, метод контролирует токен отмены. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя объект для измерения интервала времени. + Значение true, если все остальные участники достигли барьера; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + + является отрицательным числом, отличным от значения -1 миллисекунды, которое представляет неограниченное время ожидания, или превышает 32767. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя объект для измерения интервала времени. Кроме того, метод контролирует токен отмены. + Значение true, если все остальные участники достигли барьера; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + + является отрицательным числом, отличным от значения -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Исключение, которое возникает при сбое действия барьера , выполняемого в конце фазы + + + Инициализирует новый экземпляр класса системным сообщением, содержащим описание ошибки. + + + Инициализирует новый экземпляр класса с указанным внутренним исключением. + Исключение, которое вызвало текущее исключение. + + + Инициализирует новый экземпляр класса с использованием заданного сообщения, содержащего описание ошибки. + Сообщение с описанием исключения.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение с описанием исключения.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Представляет метод, вызываемый в новом контексте. + Объект, содержащий информацию, используемую всякий раз методом обратного вызова при каждом выполнении. + 1 + + + Представляет примитив синхронизации, на который отправляется сигнал при достижении его подсчетом нуля. + + + Инициализирует новый экземпляр класса указанным количеством. + Количество сигналов, первоначально необходимое для задания объекта . + Значение параметра меньше 0. + + + Увеличивает текущий подсчет на один. + Текущий экземпляр уже был удален. + Текущий экземпляр уже задан.– или –Значение параметра больше или равно значению свойства . + + + Увеличивает текущее количество в объекте на указанное значение. + Значение, на которое нужно увеличить . + Текущий экземпляр уже был удален. + Значение меньше или равно 0. + Текущий экземпляр уже задан.– или – равно или больше после увеличения счета параметром + + + Получает количество сигналов, оставшееся до установки события. + Количество сигналов, оставшееся до установки события. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает количество сигналов, изначально нужное для установки события. + Количество сигналов, изначально нужное для установки события. + + + Определяет, установлено ли событие. + Значение true, если событие установлено; в противном случае — значение false. + + + Сбрасывает свойство на значение свойства . + Текущий экземпляр уже был удален. + + + Присваивает свойству заданное значение. + Количество сигналов, необходимое для установки объекта . + Текущий экземпляр уже был удален. + Значение параметра меньше 0. + + + Регистрирует сигнал с событием , уменьшая значение свойства . + Значение true, если после сигнала подсчет стал равен нулю и было создано событие; в противном случае — значение false. + Текущий экземпляр уже был удален. + Текущий экземпляр уже задан. + + + Регистрирует несколько сигналов с объектом , уменьшая значение свойства на указанное число. + Значение true, если после сигналов подсчет стал равен нулю и было создано событие; в противном случае — значение false. + Количество сигналов, которое необходимо зарегистрировать. + Текущий экземпляр уже был удален. + Значение параметра меньше 1. + Текущий экземпляр уже задан. - или- Или значение больше . + + + Попытка увеличить на единицу. + Значение true, если увеличение выполнено успешно; в противном случае — значение false.Если значение свойства уже равно нулю, метод возвращает значение false. + Текущий экземпляр уже был удален. + + равно . + + + Пытается увеличить на указанное значение. + Значение true, если увеличение выполнено успешно; в противном случае — значение false.Если значение свойства уже равно нулю, возвращается значение false. + Значение, на которое нужно увеличить . + Текущий экземпляр уже был удален. + Значение меньше или равно 0. + Текущий экземпляр уже задан.– или –Значение свойства + больше или равно значению свойства . + + + Блокирует текущий поток до установки . + Текущий экземпляр уже был удален. + + + Блокирует текущий поток до тех пор, пока не установлен объект , используя 32-разрядное знаковое целое число для измерения времени ожидания. + Значение true, если установлено событие ; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток до тех пор, пока не будет установлен объект , используя 32-разрядное знаковое целое число для измерения времени ожидания. Кроме того, метод контролирует токен . + Значение true, если установлено событие ; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток, пока не будет установлено , в то же время контролируя . + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + + + Блокирует текущий поток до тех пор, пока не будет установлен объект , используя значение для измерения времени ожидания. + Значение true, если установлено событие ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Блокирует текущий поток, пока не будет установлен объект , используя значение для измерения времени ожидания. Кроме того, метод контролирует токен . + Значение true, если установлено событие ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Получает дескриптор , используемый для ожидания установки события. + Дескриптор , используемый для ожидания установки события. + Текущий экземпляр уже был удален. + + + Указывает, сбрасывается ли автоматически или вручную после получения сигнала. + 2 + + + При получении сигнала сбрасывается автоматически после освобождения одиночного потока.При отсутствии ожидающих потоков остается сигнальным до тех пор, пока поток не блокируется и не сбрасывается после освобождения потока. + + + При получении сигнала, высвобождает все ожидающие потоки и остается сигнальным до тех пор, пока не сбрасывается вручную. + + + Представляет синхронизированное событие потока. + 2 + + + Выполняет инициализацию нового экземпляра класса , определяя, получает ли сигнал, ожидающий дескриптор, и производится ли сброс автоматически или вручную. + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + + + Выполняет инициализацию нового экземпляра класса , определяющего получает ли сигнал дескриптор ожидания, если он был создан в результате данного вызова, сбрасывается ли он автоматически или вручную, а также имя системного события синхронизации. + true, чтобы задать сигнальное начальное состояние, если создано названное событие в результате этого вызова; false, чтобы задать несигнальное начальное состояние. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + Имя общесистемного события синхронизации. + Произошла ошибка Win32. + Именованное событие существует, имеет настройки управления доступом, а пользователь не имеет прав . + Именованное событие не может быть создано, видимо потому что дескриптор ожидания другого типа имеет то же имя. + Длина параметра превышает 260 символов. + + + Выполняет инициализацию нового экземпляра класса , определяющего, является ли дескриптор ожидания изначально сигнальным, если он был создан в результате данного вызова, происходит ли сброс автоматически или вручную, имя системного события синхронизации и логическую переменную, значение которой показывает, было ли создано системное именованное событие. + true, чтобы задать сигнальное начальное состояние, если создано названное событие в результате этого вызова; false, чтобы задать несигнальное начальное состояние. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + Имя общесистемного события синхронизации. + Когда данный метод возвращает значение, он содержит true, если было создано локальное событие (то есть, если имеет значение null или пустую строку) или было создано системное событие с заданным именем; либо значение false, если указанное именованное событие уже существовало.Этот параметр передается без инициализации. + Произошла ошибка Win32. + Именованное событие существует, имеет настройки управления доступом, а пользователь не имеет прав . + Именованное событие не может быть создано, видимо потому что дескриптор ожидания другого типа имеет то же имя. + Длина параметра превышает 260 символов. + + + Открывает указанное именованное событие синхронизации, если оно уже существует. + Объект, представляющий именованное системное событие. + Имя системного события синхронизации для открытия. + Параметр содержит пустую строку. -или-Длина параметра превышает 260 символов. + Параметр имеет значение null. + Именованное системное событие не существует. + Произошла ошибка Win32. + Именованное событие существует, но у пользователя нет необходимых для его использования прав доступа. + 1 + + + + + + Задает несигнальное состояние события, вызывая блокирование потоков. + true, если операция прошла успешно; в противном случае — false. + Для данного объекта ранее вызывался метод . + 2 + + + Задает сигнальное состояние события, позволяя одному или нескольким ожидающим потокам продолжить. + true, если операция прошла успешно; в противном случае — false. + Для данного объекта ранее вызывался метод . + 2 + + + Открывает указанное именованное событие синхронизации, если оно уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованное событие синхронизации было успешно открыто; в противном случае — значение false. + Имя системного события синхронизации для открытия. + Когда выполнение этого метода завершается, содержит объект , представляющий именованное событие синхронизации, если вызов завершился успешно, или значение null, если вызов завершился ошибкой.Этот параметр обрабатывается как неинициализированный. + Параметр содержит пустую строку.-или-Длина параметра превышает 260 символов. + Параметр имеет значение null. + Произошла ошибка Win32. + Именованное событие существует, но у пользователя нет требуемых прав доступа. + + + Управляет контекстом выполнения текущего потока.Этот класс не наследуется. + 2 + + + Перехватывает контекст выполнения из текущего потока. + Объект , представляющий контекст выполнения хоста для текущего потока. + 1 + + + Выполняет метод в указанном контексте выполнения в текущем потоке. + Задаваемый . + Делегат , представляющий выполняемый метод в предоставленном контексте выполнения. + Данный объект передается в метод обратного вызова. + Параметр имеет значение null.– или – не был получен во время операции отслеживания. – или – уже использовался в качестве аргумента в вызове . + 1 + + + + + + Предоставляет атомарные операции для переменных, используемых совместно несколькими потоками. + 2 + + + Добавляет два 32-разрядных целых числа и заменяет первое число на сумму в виде атомарной операции. + Новое значение сохраняется в . + Переменная, содержащая первое добавляемое значение.Сумма двух значений сохраняется в . + Значение, добавляемое к целому в . + The address of is a null pointer. + 1 + + + Добавляет два 64-разрядных целых числа и заменяет первое число на сумму в виде атомарной операции. + Новое значение сохраняется в . + Переменная, содержащая первое добавляемое значение.Сумма двух значений сохраняется в . + Значение, добавляемое к целому в . + The address of is a null pointer. + 1 + + + Сравнивает два числа с плавающей запятой двойной точности на равенство и, если они равны, заменяет первое значение. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два 32-разрядных целых числа со знаком на равенство и, если они равны, заменяет первое. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два 64-разрядных целых числа со знаком на равенство и, если они равны, заменяет первое. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два зависящих от платформы обработчика или указателя на равенство и, если они равны, заменяет первое из значений. + Исходное значение в . + Целевое значение , которое будет сравниваться со значением параметра и, возможно, будет заменено . + Значение , которое заменит целевое значение, если результатом сравнения будет равенство. + Значение , которое сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два объекта на равенство ссылок и, если они равны, заменяет первый объект. + Исходное значение в . + Целевой объект, который будет сравниваться со значением параметра и, возможно, будет заменен. + Объект, который заменит целевой объект, если результатом сравнения будет равенство. + Объект, который сравнивается с объектом в . + The address of is a null pointer. + 1 + + + Сравнивает два числа с плавающей запятой с обычной точностью на равенство и, если они равны, заменяет первое значение. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два экземпляра указанного ссылочного типа на равенство и, если это так, заменяет первый из них. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено.Это ссылочный параметр (ref в C#, ByRef в Visual Basic). + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + Тип, используемый для , и .Этот тип должен быть ссылочным типом. + The address of is a null pointer. + + + Уменьшает значение заданной переменной и сохраняет результат в виде атомарной операции. + Уменьшаемое значение. + Переменная, у которой уменьшается значение. + The address of is a null pointer. + 1 + + + Уменьшает значение заданной переменной и сохраняет результат в виде атомарной операции. + Уменьшаемое значение. + Переменная, у которой уменьшается значение. + The address of is a null pointer. + 1 + + + Задает число с плавающей запятой с двойной точностью указанным значением в виде атомарной операции и возвращает исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Присваивает 32-разрядному целому числу со знаком заданное значение и возвращает исходное значение в виде атомарной операции. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Присваивает 64-разрядному целому числу со знаком заданное значение и возвращает исходное значение в виде атомарной операции. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает указатель или обработчик, зависящий от платформы в виде атомарной операции, и возвращает ссылку на исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает объект указанным значением в виде атомарной операции и возвращает ссылку на исходный объект. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает число с плавающей запятой с одинарной точностью указанным значением в виде атомарной операции и возвращает исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает определенное значение для переменной указанного типа и возвращает исходное значение (атомарная операция). + Исходное значение параметра . + Переменная, которая задается указанным значением.Это ссылочный параметр (ref в C#, ByRef в Visual Basic). + Значение, в которое задан параметр . + Тип, используемый для и .Этот тип должен быть ссылочным типом. + The address of is a null pointer. + + + Увеличивает значение заданной переменной и сохраняет результат в виде атомарной операции. + Увеличиваемое значение. + Переменная, у которой увеличивается значение. + The address of is a null pointer. + 1 + + + Увеличивает значение заданной переменной и сохраняет результат в виде атомарной операции. + Увеличиваемое значение. + Переменная, у которой увеличивается значение. + The address of is a null pointer. + 1 + + + Синхронизирует доступ к памяти следующим образом: процессор, выполняющий текущий поток, не способен упорядочить инструкции так, чтобы обращения к памяти до вызова метода выполнялись после обращений к памяти, следующих за вызовом метода . + + + Возвращает 64-разрядное значение, загруженное в виде атомарной операции. + Загруженное значение. + Загружаемое 64-разрядное значение. + 1 + + + Обеспечивает процедуры неактивной инициализации. + + + Инициализирует целевой ссылочный тип его конструктором типа по умолчанию, если он еще не инициализирован. + Инициализируемая ссылка типа . + Ссылка типа , которую необходимо инициализировать, если она еще не инициализирована. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип или тип значения его конструктором по умолчанию, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка или значение типа , которое необходимо инициализировать, если оно еще не инициализировано. + Ссылка на логическое значение, определяющее, инициализирована ли цель. + Ссылка на объект, используемый как взаимоисключающая блокировка для инициализации параметра .Если равно null, то нового объект будет создан экземпляр. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип или тип значения с использованием указанной функцией, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка или значение типа , которое необходимо инициализировать, если оно еще не инициализировано. + Ссылка на логическое значение, определяющее, инициализирована ли цель. + Ссылка на объект, используемый как взаимоисключающая блокировка для инициализации параметра .Если равно null, то нового объект будет создан экземпляр. + Функция, которая вызывается для инициализации ссылки или значения. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип с использованием указанной функцией, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка типа , которую необходимо инициализировать, если она еще не инициализирована. + Функция, которая вызывается для инициализации ссылки. + Ссылочный тип инициализируемой ссылки. + Тип не имеет конструктора по умолчанию. + + вернул значение NULL (Nothing в Visual Basic). + + + Исключение генерируется, когда рекурсивная запись блокировки не совпадает с рекурсивной политикой блокировки. + 2 + + + Инициализирует новый экземпляр класса системным сообщением, содержащим описание ошибки. + 2 + + + Инициализирует новый экземпляр класса с использованием заданного сообщения, содержащего описание ошибки. + Сообщение с описанием исключения.Вызывающему объекту этого конструктора необходимо убедиться, что эта строка локализована для текущего языка и региональных параметров системы. + 2 + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение с описанием исключения.Вызывающему объекту этого конструктора необходимо убедиться, что эта строка локализована для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + 2 + + + Указывает, можно ли несколько раз войти в блокировку из одного и того же потока. + + + Если поток пытается войти в блокировку рекурсивно, выдается ошибка.Некоторые классы могут допускать определенные виды рекурсий при активированном параметре. + + + Допускается рекурсивный вход потока в блокировку.Некоторые классы могут игнорировать эту возможность. + + + Уведомляет один или более ожидающих потоков о том, что произошло событие.Этот класс не наследуется. + 2 + + + Инициализирует новый экземпляр класса логическим значением, показывающим наличие сигнального состояния. + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + + + Предоставляет уменьшенную версию . + + + Инициализирует новый экземпляр класса начальным состоянием nonsignaled. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение. + значение true для задания начального сигнального состояния; значение false для задания начального несигнального состояния. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение, а также указанным числом прокруток. + Значение true для задания начального сигнального состояния; значение false для задания начального несигнального состояния. + Число ожиданий прокруток до возврата к операции ожидания на основе ядра. + + is less than 0 or greater than the maximum allowed value. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает значение, указывающее, установлено ли событие. + Значение true, если событие установлено; в противном случае — значение false. + + + Задает несигнальное состояние события, вызывая блокирование потоков. + The object has already been disposed. + + + Устанавливает несигнальное состояние события, позволяя продолжить выполнение одному или нескольким потокам, ожидающим событие. + + + Получает число ожиданий прокруток, которые произойдут до возврата к операции ожидания на основе ядра. + Возвращает число ожиданий прокруток, которые произойдут до возврата к операции ожидания на основе ядра. + + + Блокирует текущий поток до установки текущего объекта . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не установлен текущий объект , используя 32-разрядное знаковое целое число для измерения интервала времени. + Значение true, если выполнялась установка ; в противном случае — false. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не будет установлен текущий объект , используя 32-разрядное знаковое целое число для измерения интервала времени. Кроме того, метод контролирует токен . + Значение true, если выполнялась установка ; в противном случае — значение false. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Блокирует текущий поток до получения сигнала текущим объектом . Кроме того, метод контролирует токен . + Токен отмены , который следует контролировать. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Блокирует текущий поток, пока не будет установлен текущий объект , используя объект для измерения интервала времени. + Значение true, если выполнялась установка ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не будет установлен текущий объект , используя значение для измерения интервала времени. Кроме того, метод контролирует токен . + Значение true, если был задан; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Возвращает базовый объект для данного . + Базовый объект события для данного объекта . + + + Предоставляет механизм для синхронизации доступа к объектам. + 2 + + + Получает эксклюзивную блокировку указанного объекта. + Объект, для которого получается блокировка монитора. + Параметр имеет значение null. + 1 + + + Получает монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, в котором следует ожидать. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение.Примечание. Если исключение не возникает, выходное значение этого метода всегда true. + Входное значение параметра — true. + Параметр имеет значение null. + + + Освобождает эксклюзивную блокировку указанного объекта. + Объект, блокировка которого освобождается. + Параметр имеет значение null. + Данный поток не владеет блокировкой для указанного объекта. + 1 + + + Определяет, содержит ли текущий поток блокировку указанного объекта. + Значение true, если текущий поток владеет блокировкой в ; в противном случае — значение false. + Объект для тестирования. + Свойство имеет значение null. + + + Уведомляет поток в очереди готовности об изменении состояния объекта с блокировкой. + Объект, ожидаемый потоком. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + 1 + + + Уведомляет все ожидающие потоки об изменении состояния объекта. + Объект, посылающий импульс. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + 1 + + + Пытается получить эксклюзивную блокировку указанного объекта. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Параметр имеет значение null. + 1 + + + Пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + + + Пытается получить эксклюзивную блокировку указанного объекта на заданное количество миллисекунд. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Количество миллисекунд, в течение которых ожидать блокировку. + Параметр имеет значение null. + Значение параметра отрицательно и не равно . + 1 + + + В течение заданного количества миллисекунд пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Количество миллисекунд, в течение которых ожидать блокировку. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + Значение параметра отрицательно и не равно . + + + Пытается получить эксклюзивную блокировку указанного объекта в течение заданного количества времени. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Класс , представляющий количество времени, в течение которого ожидается блокировка.Значение –1 миллисекунды обозначает бесконечное ожидание. + Параметр имеет значение null. + Значение в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + 1 + + + В течение заданного периода времени пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Период времени, в течение которого ожидается блокировка.Значение -1 обозначает бесконечное ожидание. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + Значение в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова. + true, если вызов осуществил возврат из-за того, что вызывающий поток заново получил блокировку заданного объекта.Этот метод не осуществляет возврат, если блокировка вновь не получена. + Объект, в котором следует ожидать. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + 1 + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова.Если указанные временные интервалы истекают, поток встает в очередь готовности. + Значение true, если блокировка была получена заново до истечения заданного времени; значение false, если блокировка была получена заново по истечении заданного времени.Этот метод не осуществляет возврат, если блокировка не была получена. + Объект, в котором следует ожидать. + Количество миллисекунд для ожидания постановки в очередь готовности. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + Значение параметра отрицательно и не равно . + 1 + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова.Если указанные временные интервалы истекают, поток встает в очередь готовности. + Значение true, если блокировка была получена заново до истечения заданного времени; значение false, если блокировка была получена заново по истечении заданного времени.Этот метод не осуществляет возврат, если блокировка не была получена. + Объект, в котором следует ожидать. + Класс , представляющий количество времени, до истечения которого поток поступает в очередь ожидания. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + Значение параметра в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + 1 + + + Примитив синхронизации, который также может использоваться в межпроцессной синхронизации. + 1 + + + Инициализирует новый экземпляр класса стандартными свойствами. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса. + Значение true для предоставления вызывающему потоку изначального владения мьютексом; в противном случае — false. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, а также иметь строку, являющуюся именем мьютекса. + Значение true для предоставления вызывающему потоку изначального владения именованным системным мьютексом, если этот мьютекс создан данным вызовом; в противном случае — значение false. + Имя .Если значение равно null, у объекта нет имени. + Именованный мьютекс существует, имеет безопасность управления доступом, а пользователь не имеет прав . + Произошла ошибка Win32. + Именованный мьютекс не может быть создан; вероятно, дескриптор ожидания другого типа имеет то же имя. + + длиннее 260 символов. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, иметь строку, являющуюся именем мьютекса, и логическое значение, которое при возврате метода показывает, предоставлено ли вызывающему потоку изначальное владение мьютексом. + Значение true для предоставления вызывающему потоку изначального владения именованным системным мьютексом, если этот мьютекс создан данным вызовом; в противном случае — значение false. + Имя .Если значение равно null, у объекта нет имени. + При возврате из метода содержит логическое значение true, если был создан локальный мьютекс (то есть, если параметр имеет значение null или содержит пустую строку) или был создан именованный системный мьютекс; значение false, если указанный именованный системный мьютекс уже существует.Этот параметр передается неинициализированным. + Именованный мьютекс существует, имеет безопасность управления доступом, а пользователь не имеет прав . + Произошла ошибка Win32. + Именованный мьютекс не может быть создан; вероятно, дескриптор ожидания другого типа имеет то же имя. + + длиннее 260 символов. + + + Открывает указанный именованный мьютекс, если он уже существует. + Объект, представляющий именованный системный мьютекс. + Имя системного мьютекса для открытия. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Именованный мьютекс не существует. + Произошла ошибка Win32. + Именованный мьютекс существует, но у пользователя нет необходимой для его использования безопасности доступа. + 1 + + + + + + Освобождает объект один раз. + Вызывающий поток не является владельцем мьютекса. + 1 + + + Открывает указанный именованный мьютекс, если он уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованный мьютекс был успешно открыт; в противном случае — значение false. + Имя системного мьютекса для открытия. + Когда выполнение этого метода завершается, содержит объект , представляющий именованный мьютекс, если вызов завершился успешно, или значение null, если произошел сбой вызова.Этот параметр обрабатывается как неинициализированный. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Произошла ошибка Win32. + Именованный мьютекс существует, но у пользователя нет необходимой для его использования безопасности доступа. + + + Представляет блокировку, используемую для управления доступом к ресурсу, которая позволяет нескольким потокам производить считывание или получать монопольный доступ на запись. + + + Инициализирует новый экземпляр класса значениями свойств по умолчанию. + + + Инициализирует новый экземпляр класса с указанием политики рекурсии блокировок. + Одно из значений перечисления, определяющее политику рекурсии блокировки. + + + Получает общее количество уникальных потоков, вошедших в блокировку в режиме чтения. + Количество уникальных потоков, вошедших в блокировку в режиме чтения. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Пытается выполнить вход в блокировку в режиме чтения. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Пытается выполнить вход в блокировку в обновляемом режиме. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Пытается выполнить вход в блокировку в режиме записи. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Уменьшает счетчик глубины рекурсии для режима чтения и выходит из режима чтения, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in read mode. + + + Уменьшает счетчик глубины рекурсии для обновляемого режима и выходит из обновляемого режима, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in upgradeable mode. + + + Уменьшает счетчик глубины рекурсии для режима записи и выходит из режима записи, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in write mode. + + + Получает значение, указывающее, вошел ли текущий поток в блокировку в режиме чтения. + Значение true, если текущий поток вошел в режим чтения; в противном случае false. + 2 + + + Возвращает значение, указывающее, вошел ли текущий поток в блокировку в обновляемом режиме. + Значение true, если текущий поток вошел в обновляемый режим; в противном случае false. + 2 + + + Получает значение, указывающее, вошел ли текущий поток в блокировку в режиме записи. + Значение true, если текущий поток вошел в режим записи; в противном случае false. + 2 + + + Возвращает значение, указывающее политику рекурсии для текущего объекта . + Одно из значений перечисления, определяющее политику рекурсии блокировки. + + + Получает количество раз, которые текущий поток входил в блокировку в режиме чтения, как показатель рекурсии. + 0 (нуль), если текущий поток не вошел в режим чтения, 1, если поток вошел в режим чтения, но не рекурсивно, или n, если поток вошел в блокировку рекурсивно n - 1 раз. + 2 + + + Получает количество раз, которые текущий поток входил в блокировку в обновляемом режиме, как показатель рекурсии. + 0 (нуль), если текущий поток не вошел в обновляемый режим, 1, если поток вошел в обновляемый режим, но не рекурсивно, или n, если поток вошел в обновляемый режим рекурсивно n - 1 раз. + 2 + + + Получает количество раз, которые текущий поток входил в блокировку в режиме записи, как показатель рекурсии. + 0 (нуль), если текущий поток, не вошел в режим записи, 1, если поток вошел в режим записи, но не рекурсивно, или n, если поток вошел в режим записи рекурсивно n - 1 раз. + 2 + + + Пытается войти в блокировку в режиме чтения с необязательным указанием времени ожидания целым числом. + Значение true, если вызывающий поток вошел в режим чтения; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в режиме чтения с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим чтения; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Пытается войти в блокировку в обновляемом режиме с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в обновляемый режим; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в обновляемом режиме с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в обновляемый режим; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Пытается войти в блокировку в режиме записи с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим записи; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в режиме записи с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим записи; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Получает общее количество потоков, ожидающих вхождения в блокировку в режиме чтения. + Общее количество потоков, ожидающих вхождения в режим чтения. + 2 + + + Получает общее количество потоков, ожидающих входа в блокировку в обновляемом режиме. + Общее количество потоков, ожидающих входа в обновляемый режим. + 2 + + + Получает общее количество потоков, ожидающих входа в блокировку в режиме записи. + Общее количество потоков, ожидающих входа в режим записи. + 2 + + + Ограничивает число потоков, которые могут одновременно получать доступ к ресурсу или пулу ресурсов. + 1 + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + Значение больше значения . + + имеет значение меньше 1.-или-Значение параметра меньше 0. + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов, а также при необходимости имя объекта системного семафора. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + Имя объекта именованного системного семафора. + Значение больше значения .-или- длиннее 260 символов. + + имеет значение меньше 1.-или-Значение параметра меньше 0. + Произошла ошибка Win32. + Именованный семафор существует, имеет параметры безопасности управления доступом, а пользователь не имеет прав . + Именованный семафор не может быть создан, видимо потому что дескриптор ожидания другого типа имеет то же имя. + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов, а также при необходимости задающий имя объекта системного семафора и переменную, получающую значение, которое указывает, был ли создан новый системный семафор. + Начальное количество запросов семафора, которое может быть удовлетворено одновременно. + Максимальное количество запросов семафора, которое может быть удовлетворено одновременно. + Имя объекта именованного системного семафора. + При возврате этот метод содержит значение true, если был создан локальный семафор (то есть если параметр имеет значение null или содержит пустую строку) или был создан заданный именованный системный семафор; значение false, если указанный именованный семафор уже существовал.Этот параметр передается неинициализированным. + Значение больше значения . -или- длиннее 260 символов. + + имеет значение меньше 1.-или-Значение параметра меньше 0. + Произошла ошибка Win32. + Именованный семафор существует, имеет параметры безопасности управления доступом, а пользователь не имеет прав . + Именованный семафор не может быть создан, видимо потому что дескриптор ожидания другого типа имеет то же имя. + + + Открывает указанный именованный семафор, если он уже существует. + Объект, представляющий именованный системный семафор. + Имя системного семафора для открытия. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Именованный семафор не существует. + Произошла ошибка Win32. + Именованный семафор существует, но у пользователя нет необходимых для его использования прав доступа. + 1 + + + + + + Выходит из семафора и возвращает последнее значение счетчика. + Счетчик семафора перед вызовом метода . + Счетчик семафора уже имеет максимальное значение. + Произошла ошибка Win32, связанная с именованным семафором. + Текущий семафор представляет именованный системный семафор, но пользователь не имеет прав .-или-Текущий семафор представляет именованный системный семафор, но он не был открыт с правами доступа . + 1 + + + Выходит из семафора указанное число раз и возвращает последнее значение счетчика. + Счетчик семафора перед вызовом метода . + Количество требуемых выходов из семафора. + + имеет значение меньше 1. + Счетчик семафора уже имеет максимальное значение. + Произошла ошибка Win32, связанная с именованным семафором. + Текущий семафор представляет именованный системный семафор, но пользователь не имеет прав .-или-Текущий семафор представляет именованный системный семафор, но он не был открыт с правами . + 1 + + + Открывает указанный именованный семафор, если он уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованный семафор был успешно открыт; в противном случае — значение false. + Имя системного семафора для открытия. + При возврате этот метод содержит объект , представляющий именованный семафор, если вызов завершился успешно, или значение null, если вызов завершился неудачно.Этот параметр обрабатывается как неинициализированный. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Произошла ошибка Win32. + Именованный семафор существует, но у пользователя нет необходимых для его использования прав доступа. + + + Исключение, выдаваемое при вызове метода для семафора, значение счетчика которого уже равно максимальному. + 2 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Представляет упрощенную альтернативу семафору , ограничивающему количество потоков, которые могут параллельно обращаться к ресурсу или пулу ресурсов. + + + Инициализирует новый экземпляр класса , указывая первоначальное число запросов, которые могут выполняться одновременно. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Значение параметра меньше 0. + + + Инициализирует новый экземпляр класса , указывая изначальное и максимальное число запросов, которые могут выполняться одновременно. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + + меньше 0 или больше, чем , или меньше или равен 0. + + + Возвращает дескриптор , который можно использовать для ожидания семафора. + Дескриптор , который можно использовать для ожидания семафора. + Объект удален. + + + Возвращает количество оставшихся потоков, которым разрешено входить в объект . + Количество оставшихся потоков, которым разрешено входить в семафор. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые ресурсы, используемые журналом , и при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Освобождает объект один раз. + Предыдущее количество в семафоре . + Текущий экземпляр уже был удален. + + уже достиг максимального размера. + + + Освобождает объект указанное число раз. + Предыдущее количество в семафоре . + Количество требуемых выходов из семафора. + Текущий экземпляр уже был удален. + + имеет значение меньше 1. + + уже достиг максимального размера. + + + Блокирует текущий поток, пока он не сможет войти в . + Текущий экземпляр уже был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя 32-разрядное целое число со знаком, которое определяет время ожидания. + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя 32-разрядное целое число со знаком, которое определяет время ожидания, и контролирует токен . + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + Экземпляр был удален, или создания был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , и контролирует токен . + Токен , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален.-или- Создания уже был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя значение для определения времени ожидания. + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + Экземпляр semaphoreSlim был уничтожен + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя значение , которое определяет время ожидания, и контролирует токен . + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + Экземпляр semaphoreSlim был уничтоженКласс , создавший , уже удален. + + + Асинхронно ожидает входа в . + Задача, которая завершается при входе в семафор. + + + Асинхронно ожидает входа в , используя 32-разрядное целое число со знаком для измерения интервала времени. + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Асинхронно ожидает входа в , используя 32-разрядное целое число со знаком для измерения интервала времени, контролируя . + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Текущий экземпляр уже был удален. + + был отменен. + + + Асинхронно ожидает входа в , контролируя . + Задача, которая завершается при входе в семафор. + Токен , который следует контролировать. + Текущий экземпляр уже был удален. + + был отменен. + + + Асинхронно ожидает входа в , используя для измерения интервала времени. + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. -или- Время ожидания больше . + + + Асинхронно ожидает входа в , используя для измерения интервала времени и контролируя . + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Токен , который следует контролировать. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания.-или-Время ожидания больше . + + был отменен. + + + Указывает метод, вызываемый при отправке сообщения в контекст синхронизации. + Передаваемый делегату объект. + 2 + + + Предоставляет примитив взаимно исключающей блокировки, в котором поток, пытающийся получить блокировку, ожидает в состоянии цикла, проверяя доступность блокировки. + + + Инициализирует новый экземпляр структуры параметром для отслеживания идентификаторов потоков для повышения качества отладки. + Следует ли перенаправлять и использовать идентификаторы потоков для отладки. + + + Получает блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Аргумент должен быть инициализирован в false до вызова Enter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Снимает блокировку. + Включено отслеживание владения потоков и текущий поток не является владельцем этой блокировки. + + + Снимает блокировку. + Логическое значение, указывающее, следует ли выпустить барьер памяти, чтобы немедленно опубликовать операцию выхода для других потоков. + Включено отслеживание владения потоков и текущий поток не является владельцем этой блокировки. + + + Получает значение, определяющее, имеет ли какой-либо поток блокировку в настоящий момент. + Значение true, если в настоящее время блокировка удерживается каким-либо потоком; в противном случае — значение false. + + + Получает значение, определяющее, имеет ли текущий поток блокировку. + Значение true, если блокировка удерживается текущим потоком; в противном случае — значение false. + Отслеживание владения потоков отключено. + + + Получает значение, указывающее, включено ли отслеживание владельца потока для данного экземпляра. + Значение true, если для данного экземпляра включено отслеживание владельца потока; в противном случае — значение false. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + + является отрицательным числом, отличным от значения -1 миллисекунды, которое представляет неограниченное время ожидания - или - время ожидания больше . + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Предоставляет поддержку ожидания на основе прокруток. + + + Получает число раз, которое был вызван для этого экземпляра. + Возвращает целое число, представляющее количество вызовов метода для данного экземпляра. + + + Получает значение, показывающее, даст ли следующий вызов к доступ к процессору, запуская обязательное переключение контекста. + Даст ли следующий вызов к доступ к процессору, запуская обязательное переключение контекста. + + + Сбрасывает подсчет прокруток. + + + Выполняет одну прокрутку. + + + Выполняет прокрутки до удовлетворения заданного условия. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Аргументом параметра является null. + + + Выполняет прокрутки до удовлетворения заданного условия или истечения заданного времени ожидания. + Значение true, если условие удовлетворено до истечения времени ожидания; в противном случае — значение false. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Аргументом параметра является null. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Выполняет прокрутки до удовлетворения заданного условия или истечения заданного времени ожидания. + Значение true, если условие удовлетворено до истечения времени ожидания; в противном случае — значение false. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Объект , указывающий время ожидания в миллисекундах, или TimeSpan, представляющий значение -1 миллисекунда, в случае неограниченного ожидания. + Аргументом параметра является null. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Обеспечивает базовую функциональность для распространения контекста синхронизации в различных моделях синхронизации. + 2 + + + Создает новый экземпляр класса . + + + При переопределении в производном классе создает копию контекста синхронизации. + Новый объект . + 2 + + + Получает контекст синхронизации для текущего потока + Объект , представляющий текущий контекст синхронизации. + 1 + + + При переопределении в производном классе отвечает на уведомление о завершении операции. + + + При переопределении в производном классе отвечает на уведомление о запуске операции. + + + При переопределении в производном классе отправляет асинхронное сообщение в контекст синхронизации. + Вызываемый делегат . + Передаваемый делегату объект. + 2 + + + При переопределении в производном классе отправляет синхронное сообщение в контекст синхронизации. + Вызываемый делегат . + Передаваемый делегату объект. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Задает текущий контекст синхронизации. + Задаваемый объект . + 1 + + + + + + Исключение, которое выдается в то время, когда методу требуется вызвавший его объект для получения блокировки данного Monitor, а метод вызван объектом, не являющимся владельцем блокировки. + 2 + + + Инициализирует новый экземпляр класса со стандартными свойствами. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Предоставляет хранилище для данных, локальных для потока. + Задает тип данных, хранимых для каждого потока. + + + Инициализирует экземпляр . + + + Инициализирует экземпляр . + Следует ли отслеживать все значения, заданные в экземпляре, и представлять их с помощью свойства . + + + Инициализирует экземпляр с заданной функцией . + Объект , вызываемый для получения неактивно инициализированного значения при совершении попытки получить без предварительной инициализации. + + является пустой ссылкой (Nothing в Visual Basic). + + + Инициализирует экземпляр с заданной функцией . + Объект , вызываемый для получения неактивно инициализированного значения при совершении попытки получить без предварительной инициализации. + Следует ли отслеживать все значения, заданные в экземпляре, и представлять их с помощью свойства . + Параметр является пустой (null) ссылкой (Nothing в Visual Basic). + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает ресурсы, используемые данным экземпляром . + Логическое значение, указывающее, вызывается ли данный метод из-за вызова метода . + + + Освобождает ресурсы, используемые данным экземпляром . + + + Получает значение, указывающее, инициализирован ли объект в текущем потоке. + Значение true, если инициализируется в текущем потоке; в противном случае — значение false. + Экземпляр класса был удален. + + + Создает и возвращает строковое представление данного экземпляра для текущего потока. + Результат вызова метода для свойства . + Экземпляр класса был удален. + + для текущего потока представляет пустую ссылку (Nothing в Visual Basic). + Инициализация попыталась создать рекурсивную ссылку . + Не предоставляются конструктор по умолчанию и значение фабрики. + + + Получает или задает значение данного экземпляра для текущего потока. + Возвращает экземпляр объекта, за инициализацию которого ответственен данный ThreadLocal. + Экземпляр класса был удален. + Инициализация попыталась создать рекурсивную ссылку . + Не предоставляются конструктор по умолчанию и значение фабрики. + + + Получает список всех значений, хранящихся в настоящий момент всеми потоками, которые получили доступа к данному экземпляру. + Список всех значений, хранящихся в настоящий момент всеми потоками, которые получили доступа к данному экземпляру. + Экземпляр класса был удален. + + + Содержит методы для выполнения операций энергозависимой памяти. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает ссылку на объект из указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанная ссылка на объект .Эта ссылка является последней, записанной любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + Тип считываемого поля.Должен быть ссылочным типом или типом значения. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция памяти появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданную ссылку на объект в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается ссылка на объект. + Записываемая ссылка на объект.Ссылка записывается немедленно, так что она становится видимой для всех процессоров компьютера. + Тип поля, в которое выполняется запись.Должен быть ссылочным типом или типом значения. + + + Исключение, которое выдается при попытке открыть не существующий в системе семафор или мьютекс. + 2 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/zh-hans/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/zh-hans/System.Threading.xml new file mode 100644 index 000000000..7c174ad66 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/zh-hans/System.Threading.xml @@ -0,0 +1,1854 @@ + + + + System.Threading + + + + 当某个线程获取由另一个线程放弃（即在未释放的情况下退出）的 对象时引发的异常。 + 1 + + + 使用默认值初始化 类的新实例。 + + + 用被放弃的互斥体的指定索引（如果可用）和表示该互斥体的 对象初始化 类的新实例。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误消息。 + + + 用指定的错误信息和内部异常初始化 类的新实例。 + 解释异常原因的错误消息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 用指定的错误信息、内部异常、被放弃的互斥体的索引（如果可用）以及表示该互斥体的 对象初始化 类的新实例。 + 解释异常原因的错误消息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 用指定的错误信息、被放弃的互斥体的索引（如果可用）以及被放弃的互斥体初始化 类的新实例。 + 解释异常原因的错误消息。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 获取导致异常的被放弃的互斥体（如果已知的话）。 + 如果未能识别被放弃的互斥体，则为表示该被放弃的互斥体的 对象或 null。 + 1 + + + 获取导致异常的被放弃的互斥体的索引（如果已知的话）。 + 如果未能确定被放弃的互斥体的索引，则为传递给 方法的等待句柄数组中的索引、表示该被放弃的互斥体的 对象的索引或 –1。 + 1 + + + 表示对于给定异步控制流（如异步方法）是本地数据的环境数据。 + 环境数据的类型。 + + + 实例化不接收更改通知的 实例。 + + + 实例化接收更改通知的 本地实例。 + 只要当前值在任何线程上发生更改时便会调用的委托。 + + + 获取或设置环境数据的值。 + 环境数据的值。 + + + 向针对更改通知进行了注册的 实例提供数据更改信息的类。 + 数据的类型。 + + + 获取数据的当前值。 + 数据的当前值。 + + + 获取数据的上一个值。 + 数据的上一个值。 + + + 返回一个值，该值指示是否由于执行上下文更改而更改了值。 + 如果由于执行上下文更改而更改了值，则为 true；否则为 false。 + + + 通知正在等待的线程已发生事件。此类不能被继承。 + 2 + + + 使用 Boolean 值（指示是否将初始状态设置为终止的）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + + + 使多个任务能够采用并行方式依据某种算法在多个阶段中协同工作。 + + + 初始化 类的新实例。 + 参与线程的数量。 + + 小于 0 或大于 32,767。 + + + 初始化 类的新实例。 + 参与线程的数量。 + 在每个阶段之后要执行的 。可以传递 null (在 Visual Basic 中为 Nothing) 以指示不执行任何操作。 + + 小于 0 或大于 32,767。 + + + 通知 ，告知其将会有另一个参与者。 + 新参与者将首先参与的屏障的阶段编号。 + 当前实例已被释放。 + 添加参与者将导致屏障的参与者计数超过 32,767。- 或 -该方法从阶段后操作中调用。 + + + 通知 ，告知其将会有多个其他参与者。 + 新参与者将首先参与的屏障的阶段编号。 + 要添加到屏障的其他参与者的数量。 + 当前实例已被释放。 + + 小于 0。- 或 -添加 参与者将导致屏障的参与者计数超过 32,767。 + 该方法从阶段后操作中调用。 + + + 获取屏障的当前阶段的编号。 + 返回屏障的当前阶段的编号。 + + + 释放由 类的当前实例占用的所有资源。 + 该方法从阶段后操作中调用。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。 + + + 获取屏障中参与者的总数。 + 返回屏障中参与者的总数。 + + + 获取屏障中尚未在当前阶段发出信号的参与者的数量。 + 返回屏障中尚未在当前阶段发出信号的参与者的数量。 + + + 通知 ，告知其将会减少一个参与者。 + 当前实例已被释放。 + 屏障已经有 0 个参与者。- 或 -该方法从阶段后操作中调用。 + + + 通知 ，告知其将会减少一些参与者。 + 要从屏障中移除的其他参与者的数量。 + 当前实例已被释放。 + + 小于 0。 + 屏障已经有 0 个参与者。- 或 -该方法从阶段后操作中调用。 - 或 -当前的参与者计数小于指定 participantCount + 参与者总数小于指定的 + + + 发出参与者已达到屏障并等待所有其他参与者也达到屏障。 + 当前实例已被释放。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + 在所有参与线程调用了 SignalAndWait 之后，如果关卡的后期阶段操作中引发了异常，该异常将包装在 BarrierPostPhaseException 中并在所有参与线程上引发。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，同时使用 32 位带符号整数测量超时。 + 如果所有参与者都已在指定时间内达到屏障，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + 在所有参与线程调用了 SignalAndWait 之后，如果关卡的后期阶段操作中引发了异常，该异常将包装在 BarrierPostPhaseException 中并在所有参与线程上引发。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，使用 32 位带符号整数测量超时，同时观察取消标记。 + 如果所有参与者都已在指定时间内达到屏障，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者达到屏障，同时观察取消标记。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，同时使用 对象测量时间间隔。 + 如果所有其他参与者已达到屏障，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 32,767。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，使用 对象测量时间间隔，同时观察取消标记。 + 如果所有其他参与者已达到屏障，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + + 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + + 阶段后操作失败时引发的异常。 + + + 使用由系统提供的用来描述错误的消息初始化 类的新实例。 + + + 使用指定的内部异常初始化 类的新实例。 + 导致当前异常的异常。 + + + 使用指定的描述错误的消息初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 表示要在新上下文中调用的方法。 + 一个对象，包含回调方法在每次执行时要使用的信息。 + 1 + + + 表示在计数变为零时处于有信号状态的同步基元。 + + + 使用指定计数初始化 类的新实例。 + 设置 时最初必需的信号数。 + + 小于 0。 + + + 将 的当前计数加 1。 + 当前实例已被释放。 + 当前实例已设置 。- 或 - 等于或大于 。 + + + 将 的当前计数增加指定值。 + + 的增量值。 + 当前实例已被释放。 + + 小于或等于零。 + 当前实例已设置 。- 或 -在计数由 递增后， 大于或等于 。 + + + 获取设置事件时所必需的剩余信号数。 + 设置事件时所必需的剩余信号数。 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。 + + + 获取设置事件时最初必需的信号数。 + 设置事件时最初必需的信号数。 + + + 确定是否设置了事件。 + 如果设置了事件，则为 true；否则为 false。 + + + 将 重置为 的值。 + 当前实例已被释放。 + + + 将 属性重新设置为指定值。 + 设置 时所必需的信号的数量。 + 当前实例已被释放。 + + 小于 0。 + + + 向 注册信号，同时减小 的值。 + 如果信号导致计数变为零并且设置了事件，则为 true；否则为 false。 + 当前实例已被释放。 + 当前实例已设置 。 + + + 向 注册多个信号，同时将 的值减少指定数量。 + 如果信号导致计数变为零并且设置了事件，则为 true；否则为 false。 + 要注册的信号的数量。 + 当前实例已被释放。 + + 小于 1。 + 当前实例已设置 。- 或 - 大于 。 + + + 增加一个 的尝试。 + 如果成功增加，则为 true；否则为 false。如果 已为零，则此方法将返回 false。 + 当前实例已被释放。 + + 等于 。 + + + 增加指定值的 的尝试。 + 如果成功增加，则为 true；否则为 false。如果 已为零，则此方法将返回 false。 + + 的增量值。 + 当前实例已被释放。 + + 小于或等于零。 + 当前实例已设置 。- 或 - + 大于等于 。 + + + 阻止当前线程，直到设置了 为止。 + 当前实例已被释放。 + + + 阻止当前线程，直到设置了 为止，同时使用 32 位带符号整数测量超时。 + 如果设置了 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直到设置了 为止，并使用 32 位带符号整数测量超时，同时观察 。 + 如果设置了 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直到设置了 为止，同时观察 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + + 阻止当前线程，直到设置了 为止，同时使用 测量超时。 + 如果设置了 ，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 阻止当前线程，直到设置了 为止，并使用 测量超时，同时观察 。 + 如果设置了 ，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 获取用于等待要设置的事件的 。 + 用于等待要设置的事件的 。 + 当前实例已被释放。 + + + 指示在接收信号后是自动重置 还是手动重置。 + 2 + + + 当终止时， 在释放一个线程后自动重置。如果没有等待的线程， 将保持终止状态直到一个线程阻止，并在释放此线程后重置。 + + + 当终止时， 释放所有等待的线程，并在手动重置前保持终止状态。 + + + 表示一个线程同步事件。 + 2 + + + 初始化 类的新实例，并指定等待句柄最初是否处于终止状态，以及它是自动重置还是手动重置。 + 如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + + + 初始化 类的新实例，并指定在此调用后创建的等待句柄最初是否处于终止状态，它是自动重置还是手动重置，以及系统同步事件的名称。 + 如果命名事件是通过此调用创建的，则 true 将初始状态设置为终止；false 将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + 系统范围内同步事件的名称。 + 发生了一个 Win32 错误。 + 命名事件存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名事件，原因可能是与另一个不同类型的等待句柄同名。 + + 的长度超过 260 个字符。 + + + 初始化 类的新实例，并指定在此调用后创建的等待句柄最初是否处于终止状态，它是自动重置还是手动重置，系统同步事件的名称，以及一个 Boolean 变量（其值在调用后表示是否创建了已命名的系统事件）。 + 如果命名事件是通过此调用创建的，则 true 将初始状态设置为终止；false 将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + 系统范围内同步事件的名称。 + 在此方法返回时，如果创建了本地事件（即，如果 为 null 或空字符串）或指定的命名系统事件，则包含 true；如果指定的命名系统事件已存在，则为 false。该参数未经初始化即被传递。 + 发生了一个 Win32 错误。 + 命名事件存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名事件，原因可能是与另一个不同类型的等待句柄同名。 + + 的长度超过 260 个字符。 + + + 打开指定名称为同步事件（如果已经存在）。 + 一个对象，表示已命名的系统事件。 + 要打开的系统同步事件的名称。 + + 是空字符串。- 或 - 的长度超过 260 个字符。 + + 为 null。 + 命名的系统事件不存在。 + 发生了一个 Win32 错误。 + 已命名的事件存在，但用户不具备使用它所需的安全访问权限。 + 1 + + + + + + 将事件状态设置为非终止状态，导致线程阻止。 + 如果该操作成功，则为 true；否则，为 false。 + 之前已对此 调用 方法。 + 2 + + + 将事件状态设置为终止状态，允许一个或多个等待线程继续。 + 如果该操作成功，则为 true；否则，为 false。 + 之前已对此 调用 方法。 + 2 + + + 打开指定名称为同步事件（如果已经存在），并返回指示操作是否成功的值。 + 如果命名同步事件成功打开，则为 true；否则为 false。 + 要打开的系统同步事件的名称。 + 当此方法返回时，如果调用成功，则包含表示命名同步事件的 对象；否则为 null。该参数未经初始化即被处理。 + + 是空字符串。- 或 - 的长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的事件存在，但用户不具备所需的安全访问权限。 + + + 管理当前线程的执行上下文。此类不能被继承。 + 2 + + + 从当前线程捕获执行上下文。 + 一个 对象，表示当前线程的执行上下文。 + 1 + + + 在当前线程上的指定执行上下文中运行某个方法。 + 要设置的 。 + 一个 委托，表示要在提供的执行上下文中运行的方法。 + 要传递给回调方法的对象。 + + 为 null。- 或 - 不是通过捕获操作获取的。- 或 - 已用作 调用的参数。 + 1 + + + + + + 为多个线程共享的变量提供原子操作。 + 2 + + + 对两个 32 位整数进行求和并用和替换第一个整数，上述操作作为一个原子操作完成。 + 存储在 处的新值。 + 一个变量，包含要添加的第一个值。两个值的和存储在 中。 + 要添加到整数中的 位置的值。 + The address of is a null pointer. + 1 + + + 对两个 64 位整数进行求和并用和替换第一个整数，上述操作作为一个原子操作完成。 + 存储在 处的新值。 + 一个变量，包含要添加的第一个值。两个值的和存储在 中。 + 要添加到整数中的 位置的值。 + The address of is a null pointer. + 1 + + + 比较两个双精度浮点数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个 32 位有符号整数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个 64 位有符号整数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个平台特定的句柄或指针是否相等，如果相等，则替换第一个。 + + 中的原始值。 + 其值与 的值进行比较并且可能被 替换的目标 。 + 比较结果相等时替换目标值的 。 + 与位于 处的值进行比较的 。 + The address of is a null pointer. + 1 + + + 比较两个对象是否相等，如果相等，则替换第一个对象。 + + 中的原始值。 + 其值与 进行比较并且可能被替换的目标对象。 + 在比较结果相等时替换目标对象的对象。 + 与位于 处的对象进行比较的对象。 + The address of is a null pointer. + 1 + + + 比较两个单精度浮点数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较指定的引用类型 的两个实例是否相等，如果相等，则替换第一个。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。这是一个引用参数（在 C# 中是 ref，在 Visual Basic 中是 ByRef）。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + 用于 , 和 的类型。此类型必须是引用类型。 + The address of is a null pointer. + + + 以原子操作的形式递减指定变量的值并存储结果。 + 递减的值。 + 其值要递减的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式递减指定变量的值并存储结果。 + 递减的值。 + 其值要递减的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将双精度浮点数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将 32 位有符号整数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将 64 位有符号整数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将平台特定的句柄或指针设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将对象设置为指定的值并返回对原始对象的引用。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将单精度浮点数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将指定类型 的变量设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。这是一个引用参数（在 C# 中是 ref，在 Visual Basic 中是 ByRef）。 + + 参数被设置为的值。 + 用于 和 的类型。此类型必须是引用类型。 + The address of is a null pointer. + + + 以原子操作的形式递增指定变量的值并存储结果。 + 递增的值。 + 其值要递增的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式递增指定变量的值并存储结果。 + 递增的值。 + 其值要递增的变量。 + The address of is a null pointer. + 1 + + + 按如下方式同步内存存取：执行当前线程的处理器在对指令重新排序时，不能采用先执行 调用之后的内存存取，再执行 调用之前的内存存取的方式。 + + + 返回一个以原子操作形式加载的 64 位值。 + 加载的值。 + 要加载的 64 位值。 + 1 + + + 提供延迟初始化例程。 + + + 在目标引用或值类型尚未初始化的情况下，使用其默认构造函数初始化目标引用或值类型。 + 类型 的初始化引用。 + 在类型尚未初始化的情况下，要初始化的类型 的引用。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用或值类型尚未初始化的情况下，使用其默认构造函数初始化目标引用或值类型。 + 类型 的初始化值。 + 在尚未初始化的情况下要初始化的类型 的引用或值。 + 对布尔值的引用，该值确定目标是否已初始化。 + 对用作相互排斥锁的对象的引用，用于初始化 。如果 为 null，则新的对象将被实例化。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用或值类型尚未初始化的情况下，使用指定函数初始化目标引用或值类型。 + 类型 的初始化值。 + 在尚未初始化的情况下要初始化的类型 的引用或值。 + 对布尔值的引用，该值确定目标是否已初始化。 + 对用作相互排斥锁的对象的引用，用于初始化 。如果 为 null，则新的对象将被实例化。 + 调用函数以初始化该引用或值。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用类型尚未初始化的情况下，使用指定函数初始化目标引用类型。 + 类型 的初始化值。 + 在类型尚未初始化的情况下，要初始化的类型 的引用。 + 调用函数以初始化该引用。 + 要初始化的引用的引用类型。 + 类型 没有默认的构造函数。 + + 返回 null（在 Visual Basic 中为 Nothing）。 + + + 当进入锁定状态的递归与此锁定的递归策略不兼容时引发的异常。 + 2 + + + 使用由系统提供的用来描述错误的消息初始化 类的新实例。 + 2 + + + 使用指定的描述错误的消息初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方必须确保此字符串已针对当前系统区域性进行了本地化。 + 2 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方必须确保此字符串已针对当前系统区域性进行了本地化。 + 引发当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + 2 + + + 指定同一个线程是否可以多次进入一个锁定状态。 + + + 如果线程尝试以递归方式进入锁定状态，将引发异常。某些类可能会在此设置生效时允许使用特定的递归方式。 + + + 线程可以采用递归方式进入锁定状态。某些类可能会限制此功能。 + + + 通知一个或多个正在等待的线程已发生事件。此类不能被继承。 + 2 + + + 用一个指示是否将初始状态设置为终止的布尔值初始化 类的新实例。 + 如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止。 + + + 提供 的简化版本。 + + + 使用非终止初始状态初始化 类的新实例。 + + + 使用 Boolean 值（指示是否将初始状态设置为终止状态）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + + + 使用 Boolean 值（指示是否将初始状态设置为终止或指定的旋转数）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + 在回退到基于内核的等待操作之前发生的自旋等待数量。 + + is less than 0 or greater than the maximum allowed value. + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 为 true 则释放托管资源和非托管资源；为 false 则仅释放非托管资源。 + + + 获取是否已设置事件。 + 如果设置了事件，则为 true；否则为 false。 + + + 将事件状态设置为非终止，从而导致线程受阻。 + The object has already been disposed. + + + 将事件状态设置为有信号，从而允许一个或多个等待该事件的线程继续。 + + + 获取在回退到基于内核的等待操作之前发生的自旋等待数量。 + 返回在回退到基于内核的等待操作之前发生的自旋等待数量。 + + + 阻止当前线程，直到设置了当前 为止。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到设定 ，使用 32 位已签名整数测量时间间隔。 + 如果已设置 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到设定 ，使用 32 位已签名整数测量时间间隔，同时观察 。 + 如果已设置 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 阻止当前线程，直到 接收到信号，同时观察 。 + 要观察的 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + 阻止当前线程，直到当前 已设定，使用 测量时间间隔。 + 如果已设置 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到当前 已设定，使用 测量时间间隔，同时观察 。 + 如果已设置 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 获取此 的基础 对象。 + 此 的基础 事件对象。 + + + 提供同步访问对象的机制。 + 2 + + + 在指定对象上获取排他锁。 + 在其上获取监视器锁的对象。 + + 参数为 null。 + 1 + + + 获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 要在其上等待的对象。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。注意   如果没有发生异常，则此方法的输出始终为 true。 + 对 的输入是 true。 + + 参数为 null。 + + + 释放指定对象上的排他锁。 + 在其上释放锁的对象。 + + 参数为 null。 + 当前线程不拥有指定对象的锁。 + 1 + + + 确定当前线程是否保留指定对象上的锁。 + 如果当前线程持有 锁，则为 true；否则为 false。 + 要测试的对象。 + + 为 null。 + + + 通知等待队列中的线程锁定对象状态的更改。 + 线程正在等待的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 1 + + + 通知所有的等待线程对象状态的更改。 + 发送脉冲的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 1 + + + 尝试获取指定对象的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + + 参数为 null。 + 1 + + + 尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 在其上获取锁的对象。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + + 在指定的毫秒数内尝试获取指定对象上的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + 等待锁所需的毫秒数。 + + 参数为 null。 + + 为负且不等于 。 + 1 + + + 在指定的毫秒数内尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 在其上获取锁的对象。 + 等待锁所需的毫秒数。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + 为负且不等于 。 + + + 在指定的时间内尝试获取指定对象上的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + + ，表示等待锁所需的时间量。值为 -1 毫秒表示指定无限期等待。 + + 参数为 null。 + + 值（以毫秒为单位）为负且不等于 （-1 毫秒），或者大于 。 + 1 + + + 在指定的一段时间内尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获得了该锁。 + 在其上获取锁的对象。 + 用于等待锁的时间。值为 -1 毫秒表示指定无限期等待。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + 值（以毫秒为单位）为负且不等于 （-1 毫秒），或者大于 。 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。 + 如果调用由于调用方重新获取了指定对象的锁而返回，则为 true。如果未重新获取该锁，则此方法不会返回。 + 要在其上等待的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + 1 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果已用指定的超时时间间隔，则线程进入就绪队列。 + 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。 + 要在其上等待的对象。 + 线程进入就绪队列之前等待的毫秒数。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + + 参数值为负且不等于 。 + 1 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果已用指定的超时时间间隔，则线程进入就绪队列。 + 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。 + 要在其上等待的对象。 + + ，表示线程进入就绪队列之前等待的时间量。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + + 参数值（以毫秒为单位）为负且不表示 （-1 毫秒），或者大于 。 + 1 + + + 还可用于进程间同步的同步基元。 + 1 + + + 使用默认属性初始化 类的新实例。 + + + 使用 Boolean 值（指示调用线程是否应具有互斥体的初始所有权）初始化 类的新实例。 + 如果给调用线程赋予互斥体的初始所属权，则为 true；否则为 false。 + + + 使用 Boolean 值（指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称）初始化 类的新实例。 + 如果为 true，则给予调用线程已命名的系统互斥体的初始所属权（如果已命名的系统互斥体是通过此调用创建的）；否则为 false。 + + 的名称。如果值为 null，则 是未命名的。 + 命名的互斥体存在并具有访问控制安全性，但用户不具有 。 + 发生了一个 Win32 错误。 + 无法创建命名的互斥体，原因可能是与其他类型的等待句柄同名。 + + 长度超过 260 个字符。 + + + 使用可指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称的 Boolean 值和当线程返回时可指示调用线程是否已赋予互斥体的初始所有权的 Boolean 值初始化 类的新实例。 + 如果为 true，则给予调用线程已命名的系统互斥体的初始所属权（如果已命名的系统互斥体是通过此调用创建的）；否则为 false。 + + 的名称。如果值为 null，则 是未命名的。 + 在此方法返回时，如果创建了局部互斥体（即，如果 为 null 或空字符串）或指定的命名系统互斥体，则包含布尔值 true；如果指定的命名系统互斥体已存在，则为 false。此参数未经初始化即被传递。 + 命名的互斥体存在并具有访问控制安全性，但用户不具有 。 + 发生了一个 Win32 错误。 + 无法创建命名的互斥体，原因可能是与其他类型的等待句柄同名。 + + 长度超过 260 个字符。 + + + 打开指定的已命名的互斥体（如果已经存在）。 + 表示已命名的系统互斥体的对象。 + 要打开的系统互斥体的名称。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 命名的 mutex 不存在。 + 发生了一个 Win32 错误。 + 已命名的互斥体存在，但用户不具备使用它所需的安全访问权限。 + 1 + + + + + + 释放 一次。 + 调用线程不拥有互斥体。 + 1 + + + 打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。 + 如果命名互斥体成功打开，则为 true；否则为 false。 + 要打开的系统互斥体的名称。 + 当此方法返回时，如果调用成功，则包含表示命名互斥体的 对象；否则为 null。该参数未经初始化即被处理。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的互斥体存在，但用户不具备使用它所需的安全访问权限。 + + + 表示用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。 + + + 使用默认属性值初始化 类的新实例。 + + + 在指定锁定递归策略的情况下初始化 类的新实例。 + 枚举值之一，用于指定锁定递归策略。 + + + 获取已进入读取模式锁定状态的独有线程的总数。 + 已进入读取模式锁定状态的独有线程的数量。 + + + 释放 类的当前实例所使用的所有资源。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 尝试进入读取模式锁定状态。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 尝试进入可升级模式锁定状态。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 尝试进入写入模式锁定状态。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 减少读取模式的递归计数，并在生成的计数为 0（零）时退出读取模式。 + The current thread has not entered the lock in read mode. + + + 减少可升级模式的递归计数，并在生成的计数为 0（零）时退出可升级模式。 + The current thread has not entered the lock in upgradeable mode. + + + 减少写入模式的递归计数，并在生成的计数为 0（零）时退出写入模式。 + The current thread has not entered the lock in write mode. + + + 获取一个值，该值指示当前线程是否已进入读取模式的锁定状态。 + 如果当前线程已进入读取模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前线程是否已进入可升级模式的锁定状态。 + 如果当前线程已进入可升级模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前线程是否已进入写入模式的锁定状态。 + 如果当前线程已进入写入模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前 对象的递归策略。 + 枚举值之一，用于指定锁定递归策略。 + + + 获取当前线程进入读取模式锁定状态的次数，用于指示递归。 + 如果当前线程未进入读取模式，则为 0（零）；如果线程已进入读取模式但却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入锁定模式 n - 1 次，则为 n。 + 2 + + + 获取当前线程进入可升级模式锁定状态的次数，用于指示递归。 + 如果当前线程没有进入可升级模式，则为 0；如果线程已进入可升级模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入可升级模式 n - 1 次，则为 n。 + 2 + + + 获取当前线程进入写入模式锁定状态的次数，用于指示递归。 + 如果当前线程没有进入写入模式，则为 0；如果线程已进入写入模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入写入模式 n - 1 次，则为 n。 + 2 + + + 尝试进入读取模式锁定状态，可以选择整数超时时间。 + 如果调用线程已进入读取模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入读取模式锁定状态，可以选择超时时间。 + 如果调用线程已进入读取模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 尝试进入可升级模式锁定状态，可以选择超时时间。 + 如果调用线程已进入可升级模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入可升级模式锁定状态，可以选择超时时间。 + 如果调用线程已进入可升级模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 尝试进入写入模式锁定状态，可以选择超时时间。 + 如果调用线程已进入写入模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入写入模式锁定状态，可以选择超时时间。 + 如果调用线程已进入写入模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 获取等待进入读取模式锁定状态的线程总数。 + 等待进入读取模式的线程总数。 + 2 + + + 获取等待进入可升级模式锁定状态的线程总数。 + 等待进入可升级模式的线程总数。 + 2 + + + 获取等待进入写入模式锁定状态的线程总数。 + 等待进入写入模式的线程总数。 + 2 + + + 限制可同时访问某一资源或资源池的线程数。 + 1 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + + 大于 。 + + 为小于 1。- 或 - 小于 0。 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数，可以选择指定系统信号量对象的名称。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + 命名系统信号量对象的名称。 + + 大于 。- 或 - 长度超过 260 个字符。 + + 为小于 1。- 或 - 小于 0。 + 发生了一个 Win32 错误。 + 命名信号量存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名的信号量，可能是因为存在同名但类型不同的等待句柄。 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数，还可以选择指定系统信号量对象的名称，以及指定一个变量来接收指示是否创建了新系统信号量的值。 + 可以同时满足的信号量的初始请求数。 + 可以同时满足的信号量的最大请求数。 + 命名系统信号量对象的名称。 + 在此方法返回时，如果创建了本地信号量（即，如果 为 null 或空字符串）或指定的命名系统信号量，则包含 true；如果指定的命名系统信号量已存在，则为 false。此参数未经初始化即被传递。 + + 大于 。- 或 - 长度超过 260 个字符。 + + 为小于 1。- 或 - 小于 0。 + 发生了一个 Win32 错误。 + 命名信号量存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名的信号量，可能是因为存在同名但类型不同的等待句柄。 + + + 打开指定名称为信号量（如果已经存在）。 + 一个对象，表示已命名的系统信号量。 + 要打开的系统信号量的名称。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 命名的信号量不存在。 + 发生了一个 Win32 错误。 + 已命名的信号量存在，但用户不具备使用它所需的安全访问权。 + 1 + + + + + + 退出信号量并返回前一个计数。 + 调用 方法前信号量的计数。 + 信号量计数已是最大值。 + 发生已命名信号量的 Win32 错误。 + 当前信号量表示一个已命名的系统信号量，但用户不具备 。- 或 -当前信号量表示一个已命名的系统信号量，但它未用 打开。 + 1 + + + 以指定的次数退出信号量并返回前一个计数。 + 调用 方法前信号量的计数。 + 退出信号量的次数。 + + 为小于 1。 + 信号量计数已是最大值。 + 发生已命名信号量的 Win32 错误。 + 当前信号量表示一个已命名的系统信号量，但用户不具备 权限。- 或 -当前信号量表示一个已命名的系统信号量，但它不是以 权限打开的。 + 1 + + + 打开指定名称为信号量（如果已经存在），并返回指示操作是否成功的值。 + 如果命名信号量成功打开，则为 true；否则为 false。 + 要打开的系统信号量的名称。 + 当此方法返回时，如果调用成功，则包含表示命名信号的 对象；否则为 null。该参数未经初始化即被处理。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的信号量存在，但用户不具备使用它所需的安全访问权。 + + + 对计数已达到最大值的信号量调用 方法时引发的异常。 + 2 + + + 使用默认值初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 对可同时访问资源或资源池的线程数加以限制的 的轻量替代。 + + + 初始化 类的新实例，以指定可同时授予的请求的初始数量。 + 可以同时授予的信号量的初始请求数。 + + 小于 0。 + + + 初始化 类的新实例，同时指定可同时授予的请求的初始数量和最大数量。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + + 小于 0，或 大于 ，或 小于等于 0。 + + + 返回一个可用于在信号量上等待的 。 + 可用于在信号量上等待的 。 + 已释放了 。 + + + 获取可以输入 对象的剩余线程数。 + 可以输入信号量的剩余线程数。 + + + 释放 类的当前实例所使用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 释放 对象一次。 + + 的前一个计数。 + 当前实例已被释放。 + + 已达到其最大大小。 + + + 释放 对象指定的次数。 + + 的前一个计数。 + 退出信号量的次数。 + 当前实例已被释放。 + + 为小于 1。 + + 已达到其最大大小。 + + + 阻止当前线程，直至它可进入 为止。 + 当前实例已被释放。 + + + 阻止当前线程，直至它可进入 为止，同时使用 32 位带符号整数来指定超时。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直至它可进入 为止，并使用 32 位带符号整数来指定超时，同时观察 。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + 实例已被释放，或 创建 已被释放。 + + + 阻止当前线程，直至它可进入 为止，同时观察 。 + 要观察的 标记。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 已释放。 + + + 阻止当前线程，直至它可进入 为止，同时使用 来指定超时。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + semaphoreSlim 实例已处理 + + + 阻止当前线程，直至它可进入 为止，并使用 来指定超时，同时观察 。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + semaphoreSlim 实例已处理 创建了 的 已经被释放。 + + + 输入 的异步等待。 + 输入信号量时完成任务。 + + + 输入 的异步等待，使用 32 位带符号整数度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 在观察 时，输入 的异步等待，使用 32 位带符号整数度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 当前实例已被释放。 + + 已取消。 + + + 在观察 时，输入 的异步等待。 + 输入信号量时完成任务。 + 要观察的 标记。 + 当前实例已被释放。 + + 已取消。 + + + 输入 的异步等待，使用 度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时 - 或 - 超时大于 。 + + + 在观察 时，输入 的异步等待，使用 度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 标记。 + + 是一个非 -1 的负数，而 -1 表示无限期超时- 或 -超时大于 。 + + 已取消。 + + + 表示在消息即将被调度到同步上下文时要调用的方法。 + 传递给委托的对象。 + 2 + + + 提供一个相互排斥锁基元，在该基元中，尝试获取锁的线程将在重复检查的循环中等待，直至该锁变为可用为止。 + + + 使用用于跟踪线程 ID 以改善调试的选项初始化 结构的新实例。 + 是否捕获线程 ID 并将其用于调试目的。 + + + 采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + 在调用 Enter 之前， 参数必须初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 释放锁。 + 启用线程所有权跟踪，当前线程不是此锁的所有者。 + + + 释放锁。 + 一个布尔值，该值指示是否应发出内存界定，以便将退出操作立即发布到其他线程。 + 启用线程所有权跟踪，当前线程不是此锁的所有者。 + + + 获取锁当前是否已由任何线程占用。 + 如果锁当前已由任何线程占用，则为 true；否则为 false。 + + + 获取锁是否已由当前线程占用。 + 如果锁已由当前线程占用，则为 true；否则为 false。 + 禁用线程所有权跟踪。 + + + 获取是否已为此实例启用了线程所有权跟踪。 + 如果已为此实例启用了线程所有权跟踪，则为 true；否则为 false。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 毫秒。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 提供对基于自旋的等待的支持。 + + + 获取已对此实例调用 的次数。 + 返回一个整数，该整数表示已对此实例调用 的次数。 + + + 获取对 的下一次调用是否将产生处理器，同时触发强制上下文切换。 + 对 的下一次调用是否将产生处理器，同时触发强制上下文切换。 + + + 重置自旋计数器。 + + + 执行单一自旋。 + + + 在指定条件得到满足之前自旋。 + 在返回 true 之前重复执行的委托。 + + 参数为 null。 + + + 在指定条件得到满足或指定超时过期之前自旋。 + 如果条件在超时时间内得到满足，则为 true；否则为 false + 在返回 true 之前重复执行的委托。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + 参数为 null。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 在指定条件得到满足或指定超时过期之前自旋。 + 如果条件在超时时间内得到满足，则为 true；否则为 false + 在返回 true 之前重复执行的委托。 + 一个 ，表示等待的毫秒数；或者一个 TimeSpan，表示 -1 毫秒（无限期等待）。 + + 参数为 null。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 提供在各种同步模型中传播同步上下文的基本功能。 + 2 + + + 创建 类的新实例。 + + + 在派生类中重写时，创建同步上下文的副本。 + 一个新 对象。 + 2 + + + 获取当前线程的同步上下文。 + 一个 对象，它表示当前同步上下文。 + 1 + + + 在派生类中重写时，响应操作已完成的通知。 + + + 在派生类中重写时，响应操作已开始的通知。 + + + 在派生类中重写时，将异步消息分派到同步上下文。 + 要调用的 委托。 + 传递给委托的对象。 + 2 + + + 在派生类中重写时，将同步消息分派到同步上下文。 + 要调用的 委托。 + 传递给委托的对象。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 设置当前同步上下文。 + 要设置的 对象。 + 1 + + + + + + 当某个方法请求调用方拥有给定 Monitor 上的锁时将引发该异常，而且由不拥有该锁的调用方调用此方法。 + 2 + + + 使用默认属性初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 提供数据的线程本地存储。 + 指定每线程的已存储数据的类型。 + + + 初始化 实例。 + + + 初始化 实例。 + 是否要跟踪实例上的所有值集并通过 属性将其公开。 + + + 使用指定的 函数初始化 实例。 + 如果在 之前尚未初始化的情况下尝试对其进行检索，则会调用 生成延迟初始化的值。 + + 是 null 引用（在 Visual Basic 中为 Nothing）。 + + + 使用指定的 函数初始化 实例。 + 如果在 之前尚未初始化的情况下尝试对其进行检索，则会调用 生成延迟初始化的值。 + 是否要跟踪实例上的所有值集并通过 属性将其公开。 + + 为 null 引用（在 Visual Basic 中为 Nothing）。 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放此 实例使用的资源。 + 一个布尔值，该值指示是否由于调用 的原因而调用此方法。 + + + 释放此 实例使用的资源。 + + + 获取是否在当前线程上初始化 。 + 如果在当前线程上初始化 ，则为 true；否则为 false。 + 已释放 实例。 + + + 创建并返回当前线程的此实例的字符串表示形式。 + 对 调用 的结果。 + 已释放 实例。 + 当前线程的 为 null 引用（Visual Basic 中为 Nothing）。 + 初始化函数尝试以递归方式引用 。 + 没有提供默认构造函数，且没有提供值工厂。 + + + 获取或设置当前线程的此实例的值。 + 返回此 ThreadLocal 负责初始化的对象的实例。 + 已释放 实例。 + 初始化函数尝试以递归方式引用 。 + 没有提供默认构造函数，且没有提供值工厂。 + + + 获取当前由已经访问此实例的所有线程存储的所有值的列表。 + 访问此实例由所有线程存储的当前的所有值的列表。 + 已释放 实例。 + + + 包含用于执行易失内存操作的方法。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 从指定的字段读取对象引用。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 对读取的 的引用。无论处理器的数目或处理器缓存的状态如何，该引用都是由计算机的任何处理器写入的最新引用。 + 要读取的字段。 + 要读取的字段的类型。此类型必须是引用类型，而不是值类型。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入如下所示的防止处理器重新对内存操作进行排序的内存栅：如果内存操作出现在代码中的此方法之前，则处理器不能将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的对象引用写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将对象引用写入的字段。 + 要写入的对象引用。立即写入一个引用，以使该引用对计算机中的所有处理器都可见。 + 要写入的字段的类型。此类型必须是引用类型，而不是值类型。 + + + 在尝试打开不存在的系统互斥体或信号量时引发的异常。 + 2 + + + 使用默认值初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.0/zh-hant/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.0/zh-hant/System.Threading.xml new file mode 100644 index 000000000..9ff1745d9 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.0/zh-hant/System.Threading.xml @@ -0,0 +1,1885 @@ + + + + System.Threading + + + + 當一個執行緒取得另一個執行緒已放棄，但是結束時並未釋放的 物件時，所擲回的例外狀況。 + 1 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用已放棄 Mutex 的指定索引 (若適用的話) 以及表示此 Mutex 的 物件，初始化 類別的新執行個體 。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和內部例外狀況初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 使用指定的錯誤訊息、內部例外狀況、已放棄 Mutex 的索引 (若適用的話)，以及表示此 Mutex 的 物件，初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 以指定的錯誤訊息、已放棄 Mutex 的索引 (若適用的話) 以及放棄的 Mutex 初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 取得造成例外狀況的已放棄 Mutex (若為已知)。 + + 物件，表示已放棄的 Mutex；若無法識別已放棄的 Mutex，則為 null。 + 1 + + + 取得造成例外狀況之已放棄 Mutex 的索引 (若為已知)。 + 等候控制代碼陣列中的索引 (已傳遞給 物件的 方法)，表示已放棄的 Mutex；如果無法判斷已放棄 Mutex 的索引，則為 -1。 + 1 + + + 表示對於指定的非同步控制流程為本機的環境資料，例如非同步方法。 + 環境資料的類型。 + + + 具現化不會接收變更告知的 執行個體。 + + + 具現化會接收變更告知的 本機執行個體。 + 每當在任何執行緒上變更目前的值就會呼叫委派。 + + + 取得或設定環境資料的值。 + 環境資料的值。 + + + 會提供資料變更資訊給 執行個體的的類別，該執行個體會註冊變更告知。 + 資料的類型。 + + + 取得資料目前的值。 + 資料目前的值。 + + + 取得資料先前的值。 + 資料先前的值。 + + + 傳回值，指出值是否會因為執行內容的變更而變更。 + 如果值會因為執行內容的變更而變更，則為 true；否則為 false。 + + + 向等候的執行緒通知發生事件。此類別無法被繼承。 + 2 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值，初始化 類別的新執行個體。 + true 表示初始狀態設定為已收到信號，false 表示初始狀態設定為未收到信號。 + + + 允許多項工作在多個階段中以平行方式來合作處理某個演算法。 + + + 初始化 類別的新執行個體。 + 參與執行緒的數目。 + + 小於 0 或大於 32,767。 + + + 初始化 類別的新執行個體。 + 參與執行緒的數目。 + 要在每個階段之後執行的 。可以傳遞 null (在 Visual Basic 中為 Nothing) 表示不執行任何動作。 + + 小於 0 或大於 32,767。 + + + 通知 ，表示還會有一個其他參與者。 + 新參與者將第一次參與其中的屏障階段編號。 + 目前的執行個體已經處置。 + 加入參與者會造成屏障的參與者計數超過 32,767。-或-此方法是從 post-phase 動作中叫用。 + + + 通知 ，表示還會有多個其他參與者。 + 新參與者將第一次參與其中的屏障階段編號。 + 要加入至屏障的其他參與者數目。 + 目前的執行個體已經處置。 + + 小於 0。-或-加入 參與者會造成屏障的參與者計數超過 32,767。 + 此方法是從 post-phase 動作中叫用。 + + + 取得屏障目前階段的編號。 + 傳回屏障目前階段的編號。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + 此方法是從 post-phase 動作中叫用。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示同時釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得在屏障中的參與者總數。 + 傳回在屏障中的參與者總數。 + + + 取得在目前階段中尚未發出訊號的屏障中參與者數目。 + 傳回在目前階段中尚未發出訊號的屏障中參與者數目。 + + + 通知 ，表示會減少一個參與者。 + 目前的執行個體已經處置。 + 屏障已經有 0 個參與者。-或-此方法是從 post-phase 動作中叫用。 + + + 通知 ，表示會減少一些參與者。 + 要從屏障中移除的其他參與者數目。 + 目前的執行個體已經處置。 + + 小於 0。 + 屏障已經有 0 個參與者。-或-此方法是從 post-phase 動作中叫用。 -或-目前的參與者計數少於指定的 participantCount + 參與者總計數小於指定的 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障。 + 目前的執行個體已經處置。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + 所有參與執行緒皆已呼叫 SignalAndWait 後，如果從 Barrier 的階段後動作擲回例外，會將例外狀況包裝在 BarrierPostPhaseException 中，並擲回所有參與執行緒。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障 (使用 32 位元帶正負號的整數以測量逾時)。 + 如果所有參與者已在指定時間內達到屏障則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + 所有參與執行緒皆已呼叫 SignalAndWait 後，如果從 Barrier 的階段後動作擲回例外，會將例外狀況包裝在 BarrierPostPhaseException 中，並擲回所有參與執行緒。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達 (使用 32 位元帶正負號的整數以測量逾時)，同時觀察取消語彙基元。 + 如果所有參與者已在指定時間內達到屏障則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達，同時觀察取消語彙基元。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障 (使用 物件以測量時間間隔)。 + 如果所有其他參與者已達到屏障則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 32,767 的逾時。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達 (使用 物件以測量時間間隔)，同時觀察取消語彙基元。 + 如果所有其他參與者已達到屏障則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 在 的後續階段動作失敗時所擲回的例外狀況。 + + + 以系統提供的錯誤說明訊息，初始化 類別的新執行個體。 + + + 使用指定的內部例外狀況，初始化 類別的新執行個體。 + 導致目前例外狀況的例外。 + + + 使用指定的錯誤說明訊息，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 表示要在新內容裡面呼叫的方法。 + 物件，它包含回呼方法所使用的資訊。 + 1 + + + 代表當計數到達零時收到訊號的同步處理原始物件。 + + + 使用指定的計數，初始化 類別的新執行個體。 + 設定 時最初所需的訊號次數。 + + 小於 0。 + + + 將 目前的計數遞增一。 + 目前的執行個體已經處置。 + 目前的執行個體已經設定。-或- 等於或大於 。 + + + 將 目前的計數遞增所指定的值。 + + 所要增加的值。 + 目前的執行個體已經處置。 + + 小於或等於 0。 + 目前的執行個體已經設定。-或-計數遞增 後， 會等於或大於 + + + 取得設定事件時需要的剩餘訊號次數。 + 設定事件時需要的剩餘訊號次數。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示同時釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得設定事件一開始時所需要的訊號次數。 + 設定事件一開始時所需要的訊號次數。 + + + 判斷事件是否已設定。 + 如果已設定事件則為 true，否則為 false。 + + + 將 重設為 的值。 + 目前的執行個體已經處置。 + + + 將 屬性重設為指定的值。 + 設定 時所需的訊號次數。 + 目前的執行個體已經處置。 + + 小於 0。 + + + 向 註冊訊號，並遞減 的值。 + 如果訊號使計數到達零且設定事件則為 true，否則為 false。 + 目前的執行個體已經處置。 + 目前的執行個體已經設定。 + + + 向 註冊多個訊號，並將 的值遞減指定的數量。 + 如果信號使計數到達零且設定事件則為 true，否則為 false。 + 要註冊的訊號數。 + 目前的執行個體已經處置。 + + 小於 1。 + 目前的執行個體已經設定。或 大於 。 + + + 嘗試將 遞增一。 + 如果遞增成功則為 true，否則為 false。如果 已經位於零，這個方法將傳回 false。 + 目前的執行個體已經處置。 + + 等於 。 + + + 嘗試以指定的值遞增 。 + 如果遞增成功則為 true，否則為 false。如果 已經為零，這將傳回 false。 + + 所要增加的值。 + 目前的執行個體已經處置。 + + 小於或等於 0。 + 目前的執行個體已經設定。-或- + 等於或大於 。 + + + 封鎖目前的執行緒，直到設定了 為止。 + 目前的執行個體已經處置。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 32 位元帶正負號的整數以測量逾時)。 + 如果已設定 則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 32 位元帶正負號的整數以測量逾時)，同時觀察 。 + 如果已設定 則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到設定了 為止，同時觀察 。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 以測量逾時)。 + 如果已設定 則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 以測量逾時)，同時觀察 。 + 如果已設定 則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 取得用來等候事件獲得設定的 。 + + ，其會用於等候事件獲得設定。 + 目前的執行個體已經處置。 + + + 表示收到信號之後，是否會自動或手動重設 。 + 2 + + + 收到信號通知時， 在釋放單一執行緒後會自動重設。如果沒有任何執行緒在等待，則 會保持收到信號的狀態，直到有執行緒被封鎖為止，接著就釋放這個執行緒並將自己重設。 + + + 收到信號通知時， 會釋放所有正在等待的執行緒，並保持收到信號的狀態，直到被手動重設為止。 + + + 表示執行緒同步處理事件。 + 2 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號，以及是以自動還是手動方式來重設。 + true 表示初始狀態設定為已收到信號，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號 (如果它是因這個呼叫而建立)、是以自動還是手動方式進行重設，以及系統同步處理事件的名稱。 + true 表示初始狀態設定為已收到信號 (如果具名事件是因這個呼叫而建立)，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + 整個系統的同步處理事件名稱。 + 發生 Win32 錯誤。 + 具名的事件已存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的事件，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 長度超過 260 個字元。 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號 (如果它是因這個呼叫而建立)、是以自動還是手動方式進行重設、系統同步處理事件的名稱，以及呼叫之後的布林變數值 (此值可指示是否已建立具名系統事件)。 + true 表示初始狀態設定為已收到信號 (如果具名事件是因這個呼叫而建立)，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + 整個系統的同步處理事件名稱。 + 這個方法傳回時，如果已建立本機事件 (也就是說，如果 為 null 或空字串)，或是已建立指定的已命名系統事件，則會包含 true；如果指定的已命名系統事件已存在則為 false。這個參數會以未初始化的狀態傳遞。 + 發生 Win32 錯誤。 + 具名的事件已存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的事件，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 長度超過 260 個字元。 + + + 開啟指定的具名同步處理事件 (如果已經存在)。 + 表示具名系統事件的物件。 + 要開啟的系統同步處理事件的名稱。 + + 為空字串。-或- 長度超過 260 個字元。 + + 為 null。 + 具名系統事件不存在。 + 發生 Win32 錯誤。 + 具名事件存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 將事件的狀態設定為未收到信號，會造成執行緒封鎖。 + 如果作業成功，則為 true，否則為 false . + 之前在這個 上呼叫 方法。 + 2 + + + 將事件的狀態設定為未收到信號，讓一個或多個等候執行緒繼續執行。 + 如果作業成功，則為 true，否則為 false . + 之前在這個 上呼叫 方法。 + 2 + + + 開啟指定的具名同步處理事件 (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名同步處理事件，則為 true，否則為 false。 + 要開啟的系統同步處理事件的名稱。 + 這個方法傳回時，如果呼叫成功，則包含物件，此物件代表具名同步處理事件，如果呼叫失敗，則為null。這個參數會被視為未初始化。 + + 為空字串。-或- 長度超過 260 個字元。 + + 為 null。 + 發生 Win32 錯誤。 + 具名事件已存在，但是使用者沒有所需的安全性存取權。 + + + 管理目前執行緒的執行內容。此類別無法被繼承。 + 2 + + + 從目前的執行緒擷取執行內容。 + + 物件，表示目前執行緒的執行內容。 + 1 + + + 在目前執行緒上的指定執行內容中執行方法。 + 要設定的 。 + + 委派，表示要在所提供執行內容中執行的方法。 + 要傳遞至回呼 (Callback) 方法的物件。 + + 為 null。-或- 不是透過擷取作業取得。-或-已經將 當做 呼叫的引數使用。 + 1 + + + + + + 為多重執行緒共用的變數提供不可部分完成的作業 (Atomic Operation)。 + 2 + + + 將兩個 32 位元整數加相，並以總和取代第一個整數，成為不可部分完成的作業。 + 新值儲存於 。 + 包含要加入的第一個值的變數。這兩個值的總和會存放在 中。 + 要加入 的整數的值。 + The address of is a null pointer. + 1 + + + 將兩個 64 位元整數加相，並以總和取代第一個整數，成為不可部分完成的作業。 + 新值儲存於 。 + 包含要加入的第一個值的變數。這兩個值的總和會存放在 中。 + 要加入 的整數的值。 + The address of is a null pointer. + 1 + + + 比較兩個雙精確度浮點數是否相等；如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個 32 位元帶正負號的整數是否相等，如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個 64 位元帶正負號的整數是否相等，如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個平台特定的控制代碼或指標是否相等；如果相等，則取代第一個。 + + 中的原始值。 + 目的端 ，其值會與 的值進行比較，且可能被 所取代。 + + ，當比較的結果相等時會取代目的端值。 + + ，會與 的值相比較。 + The address of is a null pointer. + 1 + + + 比較兩個物件的參考是否相等；如果相等，則取代第一個物件。 + + 中的原始值。 + 目的端物件，此物件會與 進行比較且可能被取代。 + 當比較的結果相等時，會取代目的端物件的物件。 + 與 的物件相比較的物件。 + The address of is a null pointer. + 1 + + + 比較兩個單精確度浮點數是否相等；如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較指定參考類型 的兩個執行個體是否相等；如果相等，則取代第一個。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。此為參考參數 (在 C# 中為 ref，在 Visual Basic 中為 ByRef)。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + 要用於 、 和 的類型。此類型必須是參考類型。 + The address of is a null pointer. + + + 遞減特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞減後的值。 + 值會被遞減的變數。 + The address of is a null pointer. + 1 + + + 遞減特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞減後的值。 + 值會被遞減的變數。 + The address of is a null pointer. + 1 + + + 將雙精確度浮點數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將 32 位元帶正負號的整數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將 64 位元帶正負號的整數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將平台特定的控制代碼或指標設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將物件設定為指定值，然後傳回原始物件的參考，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將單精確度浮點數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將指定類型 的變數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。此為參考參數 (在 C# 中為 ref，在 Visual Basic 中為 ByRef)。 + + 參數要設定成的值。 + 要用於 和 的類型。此類型必須是參考類型。 + The address of is a null pointer. + + + 遞增特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞增後的值。 + 值會被遞增的變數。 + The address of is a null pointer. + 1 + + + 遞增特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞增後的值。 + 值會被遞增的變數。 + The address of is a null pointer. + 1 + + + 同步處理記憶體存取，如下所示：執行目前執行緒的處理器無法以下列方式重新排列指示：呼叫 之前的記憶體存取在呼叫 後的記憶體存取之後執行。 + + + 傳回 64 位元的值 (載入為不可部分完成的作業)。 + 載入的值。 + 要載入的 64 位元值。 + 1 + + + 提供延遲初始化常式。 + + + 如果目標參考型別尚未初始化，則使用該型別的預設建構函式來進行初始化。 + 型別 的已初始化參考。 + 要初始化 (如果尚未初始化) 的型別 的參考。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用其預設建構函式來初始化目標的參考型別或實值型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考或實值。 + 布林值的參考，這個值可判斷目標是否已初始化。 + 物件的參考，這個物件用來當做初始化 時的互斥鎖定。如果 為 null，則具現化新的物件。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用指定的函式來初始化目標的參考或實值型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考或實值。 + 布林值的參考，這個值可判斷目標是否已初始化。 + 物件的參考，這個物件用來當做初始化 時的互斥鎖定。如果 為 null，則具現化新的物件。 + 呼叫來初始化參考或值的函式。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用指定的函式來初始化目標的參考型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考。 + 呼叫來初始化參考的函式。 + 要初始化之參考的參考型別。 + + 型別沒有預設的建構函式。 + + 傳回 null (在 Visual Basic 中為 Nothing)。 + + + 當遞迴進入鎖定與鎖定的遞迴原則不相符時，擲回的例外狀況。 + 2 + + + 以系統提供的錯誤說明訊息，初始化 類別的新執行個體。 + 2 + + + 使用指定的錯誤說明訊息，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已針對目前系統的文化特性，執行過當地語系化。 + 2 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已針對目前系統的文化特性，執行過當地語系化。 + 造成目前例外狀況的例外狀況。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + 2 + + + 指定相同的執行緒是否可以多次進入鎖定。 + + + 如果執行緒嘗試遞迴地進入鎖定，則會擲回例外狀況。某些類別可能會在此設定有效時允許特定的遞迴。 + + + 執行緒可以遞迴地進入鎖定。某些類別可能會限制此功能。 + + + 告知一個以上的等候中執行緒已發生事件。此類別無法被繼承。 + 2 + + + 使用布林值 (Boolean) 來初始化 類別的新執行個體，指出初始狀態是否設定為信號狀態。 + 如果初始狀態設定為信號狀態，為 true；初始狀態設定為非信號狀態則為 false。 + + + 提供 的精簡版本。 + + + 使用未收到訊號的初始狀態來初始化 類別的新執行個體。 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值，初始化 類別的新執行個體。 + true 表示會將初始狀態設定為已收到訊號，false 表示會將初始狀態設定為未收到訊號。 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值以及指定的微調計數，初始化 類別的新執行個體。 + true 表示會將初始狀態設定為已收到訊號，false 表示會將初始狀態設定為未收到訊號。 + 在回到以核心為基礎的等候作業之前進行微調等候的次數。 + + is less than 0 or greater than the maximum allowed value. + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 與 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得值，表示事件是否已設定。 + 如果已設定事件則為 true，否則為 false。 + + + 將事件的狀態設定為未收到信號，會造成執行緒封鎖。 + The object has already been disposed. + + + 將事件的狀態設定為已收到訊號，讓正在等候該事件的一或多個執行緒繼續執行。 + + + 取得在回到以核心為基礎的等候作業之前進行微調等候的次數。 + 傳回在回到以核心為基礎的等候作業之前進行微調等候的次數。 + + + 封鎖目前的執行緒，直到設定了目前的 為止。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止 (使用 32 位元帶正負號的整數以測量時間間隔)。 + 如果設定了 ，則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 32 位元帶正負號的整數以測量時間間隔，同時觀察 。 + 如果設定了 ，則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 封鎖目前的執行緒，直到目前的 收到訊號為止，同時觀察 。 + 要觀察的 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 以測量時間間隔。 + 如果設定了 ，則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 以量測時間間隔，同時觀察 。 + 如果設定了 ，則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 取得這個 的基礎 物件。 + 這個 的基礎 事件物件。 + + + 提供一套機制，同步處理物件的存取。 + 2 + + + 取得指定物件的獨佔鎖定。 + 要從其上取得監視器鎖定的物件。 + + 參數為 null。 + 1 + + + 取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要等候的物件。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。注意：如果沒有發生例外狀況，這個方法的輸出一律為 true。 + + 的輸入為 true。 + + 參數為 null。 + + + 釋出指定物件的獨佔鎖定。 + 要從其上釋出鎖定的物件。 + + 參數為 null。 + 目前執行緒沒有指定物件的鎖定。 + 1 + + + 判斷目前執行緒是否保持鎖定指定的物件。 + 如果目前的執行緒持有 的鎖定，則為 true；否則為 false。 + 要測試的物件。 + + 為 null。 + + + 通知等候佇列中的執行緒，鎖定物件的狀態有所變更。 + 執行緒正等候的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 1 + + + 通知所有等候中的執行緒，物件的狀態有所變更。 + 送出 Pulse 的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 1 + + + 嘗試取得指定物件的獨佔鎖定。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + + 參數為 null。 + 1 + + + 嘗試取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + + 嘗試取得指定物件的獨佔鎖定 (在指定的毫秒數時間內)。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + 等候鎖定的毫秒數。 + + 參數為 null。 + + 為負，且不等於 。 + 1 + + + 嘗試在指定的毫秒數內取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 等候鎖定的毫秒數。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + 為負，且不等於 。 + + + 嘗試取得指定物件的獨佔鎖定 (在指定的時間內)。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + + ，代表等候鎖定的時間量。-1 毫秒的值會指定無限期等候。 + + 參數為 null。 + + 的毫秒值為負且不等於 (-1 毫秒) 或大於 。 + 1 + + + 嘗試在指定的時間內取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 等候鎖定的時間長度。-1 毫秒的值會指定無限期等候。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + 的毫秒值為負且不等於 (-1 毫秒) 或大於 。 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。 + 如果由於呼叫端重新取得指定物件的鎖定而傳回呼叫，則為 true。如果鎖定不被重新取得，則這個方法不會傳回。 + 要等候的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + 1 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。如果超過指定的逾時間隔時間，執行緒會進入就緒序列。 + 如果在經過指定的時間之前重新取得鎖定，則為 true；如果在經過指定的時間之後重新取得鎖定，則為 false。要等到重新取得鎖定之後，此方法才會傳回。 + 要等候的物件。 + 在執行緒進入就緒佇列之前要等候的毫秒數。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + + 參數的值為負，且不等於 。 + 1 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。如果超過指定的逾時間隔時間，執行緒會進入就緒序列。 + 如果在經過指定的時間之前重新取得鎖定，則為 true；如果在經過指定的時間之後重新取得鎖定，則為 false。要等到重新取得鎖定之後，此方法才會傳回。 + 要等候的物件。 + + ，代表在執行緒進入就緒佇列之前要等候的時間量。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + + 參數的毫秒值為負，且不表示 (-1 毫秒)，或大於 。 + 1 + + + 同步處理原始物件，該物件也可用於進行處理序之間的同步處理。 + 1 + + + 使用預設屬性，初始化 類別的新執行個體。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值，初始化 類別的新執行個體。 + true 表示將 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值，以及代表 Mutex 名稱的字串，初始化 類別的新執行個體。 + true 表示如果這個呼叫的結果建立了具名系統 Mutex，則將具名系統 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + 的名稱。如果值是 null，則 未命名。 + 具名的 Mutex 存在，而且具有存取控制安全性，但是使用者沒有 。 + 發生 Win32 錯誤。 + 無法建立具名的 Mutex，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 长度超过 260 个字符。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值、代表 Mutex 名稱的字串，以及當方法傳回時表示是否將 Mutex 的初始擁有權授與呼叫執行緒的布林值，初始化 類別的新執行個體。 + true 表示如果這個呼叫的結果建立了具名系統 Mutex，則將具名系統 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + 的名稱。如果值是 null，則 未命名。 + 當這個方法傳回時，如果已建立本機 Mutex (也就是說，如果 為 null 或空字串)，或是已建立指定的具名系統 Mutex，則會包含 true 的布林值；如果指定的具名系統 Mutex 已存在，則為 false。這個參數會以未初始化的狀態傳遞。 + 具名的 Mutex 存在，而且具有存取控制安全性，但是使用者沒有 。 + 發生 Win32 錯誤。 + 無法建立具名的 Mutex，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 长度超过 260 个字符。 + + + 開啟指定的具名 mutex (如果已經存在)。 + 表示具名系統 Mutex 的物件。 + 要開啟的系統 Mutex 的名稱。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 具名 Mutex 不存在。 + 發生 Win32 錯誤。 + 具名 Mutex 存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 釋出 一次。 + 呼叫執行緒並不擁有 Mutex。 + 1 + + + 開啟指定的具名 mutex (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名 Mutex，則為 true，否則為 false。 + 要開啟的系統 Mutex 的名稱。 + 當這個方法傳回時，如果呼叫成功，則包含代表具名 Mutex 的 物件；如果呼叫失敗，則為 null。這個參數會被視為未初始化。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 發生 Win32 錯誤。 + 具名 Mutex 存在，但是使用者並沒有使用它所需的安全性存取權。 + + + 代表鎖定，用來管理資源存取，允許多個執行緒的讀取權限或獨佔寫入權限。 + + + 使用預設屬性值，初始化 類別的新執行個體。 + + + 指定鎖定遞迴原則，初始化 類別的新執行個體。 + 一個列舉值，指定鎖定遞迴原則。 + + + 取得已進入讀取模式鎖定狀態的唯一執行緒總數。 + 已進入讀取模式鎖定狀態的唯一執行緒數目。 + + + 釋放 類別目前的執行個體所使用的全部資源。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 嘗試進入讀取模式的鎖定。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 嘗試進入可升級模式的鎖定狀態。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 嘗試進入寫入模式的鎖定。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 減少讀取模式遞迴的計數，如果得出的計數為 0 (零)，則結束讀取模式。 + The current thread has not entered the lock in read mode. + + + 減少可升級模式遞迴的計數，如果得出的計數為 0 (零)，則結束可升級模式。 + The current thread has not entered the lock in upgradeable mode. + + + 減少寫入模式遞迴的計數，如果得出的計數為 0 (零)，則結束寫入模式。 + The current thread has not entered the lock in write mode. + + + 取得值，表示目前執行緒是否已進入讀取模式的鎖定。 + 如果目前執行緒已進入讀取模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前執行緒是否已進入可升級模式的鎖定。 + 如果目前執行緒已進入可升級模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前執行緒是否已進入寫入模式的鎖定。 + 如果目前執行緒已進入寫入模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前 物件的遞迴原則。 + 一個列舉值，指定鎖定遞迴原則。 + + + 取得目前執行緒已進入讀取模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入讀取模式，則為 0 (零)；如果執行緒已進入讀取模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入鎖定 n - 1 次，則為 n。 + 2 + + + 取得目前執行緒已進入可升級模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入可升級模式，則為 0；如果執行緒已進入可升級模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入可升級模式 n - 1 次，則為 n。 + 2 + + + 取得目前執行緒已進入寫入模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入寫入模式，則為 0；如果執行緒已進入寫入模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入寫入模式 n - 1 次，則為 n。 + 2 + + + 嘗試以選用的整數逾時，進入讀取模式的鎖定狀態。 + 如果呼叫執行緒已進入讀取模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在讀取模式下進入鎖定狀態。 + 如果呼叫執行緒已進入讀取模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 嘗試以選用的逾時，在可升級模式下進入鎖定狀態。 + 如果呼叫執行緒已進入可升級模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在可升級模式下進入鎖定狀態。 + 如果呼叫執行緒已進入可升級模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 嘗試以選用的逾時，在寫入模式下進入鎖定狀態。 + 如果呼叫執行緒已進入寫入模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在寫入模式下進入鎖定狀態。 + 如果呼叫執行緒已進入寫入模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 取得等待進入讀取模式鎖定狀態的執行緒總數。 + 等待進入讀取模式的執行緒總數。 + 2 + + + 取得等待進入可升級模式鎖定狀態的執行緒總數。 + 等待進入可升級模式的執行緒總數。 + 2 + + + 取得等待進入寫入模式鎖定狀態的執行緒總數。 + 等待進入寫入模式的執行緒總數。 + 2 + + + 限制可以同時存取資源或資源集區的執行緒數目。 + 1 + + + 初始化 類別的新執行個體，以及指定並行項目的最大數目及選擇性地保留某些項目。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + + 大於 。 + + 为小于 1。-或- 小於 0。 + + + 初始化 類別的新執行個體，然後指定初始項目數目與並行項目的最大數目，以及選擇性地指定系統號誌物件的名稱。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + 具名系統號誌物件的名稱。 + + 大於 。-或- 长度超过 260 个字符。 + + 为小于 1。-或- 小於 0。 + 發生 Win32 錯誤。 + 具名的號誌存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的號誌，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + + 初始化 類別的新執行個體，然後指定初始項目物件數目與並行項目的最大數目，選擇性地指定系統號誌物件的名稱，以及指定接收值的變數，指出是否已建立新的系統號誌。 + 可以同時滿足之號誌要求的初始數目。 + 可以同時滿足之號誌要求的最大數目。 + 具名系統號誌物件的名稱。 + 這個方法傳回時，如果已建立本機號誌 (也就是說，如果 為 null 或空字串)，或是已建立指定的已命名系統號誌，則會包含 true；如果指定的已命名系統號誌已存在則為 false。這個參數會以未初始化的狀態傳遞。 + + 大於 。-或- 长度超过 260 个字符。 + + 为小于 1。-或- 小於 0。 + 發生 Win32 錯誤。 + 具名的號誌存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的號誌，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + + 開啟指定的具名號誌 (如果已經存在)。 + 表示具名系統號誌的物件。 + 要開啟之系統號誌的名稱。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 具名號誌不存在。 + 發生 Win32 錯誤。 + 具名號誌存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 結束號誌，並傳回上一個計數。 + 呼叫 方法之前，號誌上的計數。 + 號誌計數已達到最大值。 + 具名號誌中發生 Win32 錯誤。 + 目前的號誌代表具名系統號誌，但是使用者沒有 。-或-目前的號誌代表具名系統號誌，但是並未以 開啟。 + 1 + + + 以指定的次數結束號誌，並回到上一個計數。 + 呼叫 方法之前，號誌上的計數。 + 結束號誌的次數。 + + 为小于 1。 + 號誌計數已達到最大值。 + 具名號誌中發生 Win32 錯誤。 + 目前的號誌代表具名系統號誌，但是使用者沒有 權限。-或-目前的號誌代表具名系統號誌，但是並未以 權限開啟。 + 1 + + + 開啟指定的具名號誌 (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名號誌，則為 true；否則為 false。 + 要開啟之系統號誌的名稱。 + 這個方法傳回時，如果呼叫成功，則包含 物件，此物件代表具名信號，如果呼叫失敗，則為null。這個參數會被視為未初始化。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 發生 Win32 錯誤。 + 具名號誌存在，但是使用者並沒有使用它所需的安全性存取權。 + + + 在已經達到最大計數的號誌上呼叫 方法時，所擲回的例外狀況。 + 2 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 代表 的輕量型替代品，限制可同時存取一項資源或資源集區的執行緒數目。 + + + 指定可同時授與的初始要求數目，初始化 類別的新執行個體。 + 可同時授與給號誌的初始要求數目。 + + 小於 0。 + + + 指定可同時授與的初始要求數目及最大數目，初始化 類別的新執行個體。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + + 小於 0，或者 大於 ，或者 等於或小於 0。 + + + 傳回可用來等候號誌的 。 + 可用來等候號誌的 。 + + 已經處置。 + + + 取得可以進入 物件的剩餘執行緒數目。 + 可以進入號誌的剩餘執行緒數目。 + + + 釋放 類別目前的執行個體所使用的全部資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 釋出 物件一次。 + + 的先前計數。 + 目前的執行個體已經處置。 + + 已經達到其大小上限。 + + + 釋出 物件指定的次數。 + + 的先前計數。 + 結束號誌的次數。 + 目前的執行個體已經處置。 + + 为小于 1。 + + 已經達到其大小上限。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止。 + 目前的執行個體已經處置。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 32 位元帶正負號的整數來指定逾時。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + 要等候的毫秒數；若要無限期等候，則為 (-1)。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 32 位元帶正負號的整數來指定逾時，同時觀察 。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + 要等候的毫秒數；若要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + 实例已被释放，或 创建 已被释放。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，同時觀察 。 + 要觀察的 語彙基元。 + + 已取消。 + 目前的執行個體已經處置。-或- 创建 已释放。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 來指定逾時。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + semaphoreSlim 執行個體已經處置 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 來指定逾時，同時觀察 。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + semaphoreSlim 執行個體已經處置 已處置建立 的 。 + + + 以非同步方式等候進入 。 + 將會在號誌 (Semaphore) 輸入後完成的工作。 + + + 以非同步方式等候進入 ，並使用 32 位元帶正負號的整數來測量時間間隔。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 以非同步方式等候進入 ，並使用 32 位元帶正負號的整數來測量時間間隔，同時觀察 。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 目前的執行個體已經處置。 + + 已取消。 + + + 以非同步方式等候進入 ，同時觀察 。 + 將會在號誌 (Semaphore) 輸入後完成的工作。 + 要觀察的 語彙基元。 + 目前的執行個體已經處置。 + + 已取消。 + + + 以非同步方式等候進入 ，並使用 來測量時間間隔。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是不等於 -1 的負數，-1 表示等候逾時為無限 -或- 逾時大於 。 + + + 以非同步方式等候進入 ，並使用 來測量時間間隔，同時觀察 。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 要觀察的 語彙基元。 + + 是不等於 -1 的負數，-1 表示等候逾時為無限-或-逾時大於 。 + + 已取消。 + + + 表示要將訊息分派至同步處理內容時，所要呼叫的方法。 + 傳送至委派的物件。 + 2 + + + 提供互斥鎖定基本作業，在這個作業中，嘗試取得鎖定的執行緒會用迴圈方式等候，並重複檢查，直到鎖定可用為止。 + + + 使用可追蹤執行緒 ID 以改善偵錯的選項，初始化 結構的新執行個體。 + 是否要擷取並使用執行緒 ID 以進行偵錯。 + + + 以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 引數必須在呼叫 Enter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 釋放鎖定。 + 已啟用執行緒擁有權追蹤，且目前的執行緒不是這個鎖定的擁有者。 + + + 釋放鎖定。 + 布林值，表示是否應該發出記憶體柵欄，以便立即將結束作業發行至其他執行緒。 + 已啟用執行緒擁有權追蹤，且目前的執行緒不是這個鎖定的擁有者。 + + + 取得值，這個值表示此鎖定目前是否由任何執行緒持有。 + 如果此鎖定目前由任何執行緒持有則為 true，否則為 false。 + + + 取得值，表示此鎖定是否由目前執行緒持有。 + 如果此鎖定由目前執行緒持有則為 true，否則為 false。 + 已停用執行緒擁有權追蹤。 + + + 取得值，表示這個執行個體是否已啟用執行緒擁有權追蹤。 + 如果這個執行個體已啟用執行緒擁有權追蹤則為 true，否則為 false。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 毫秒的逾時。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 提供微調式等候支援。 + + + 取得已在這個執行個體上呼叫 的次數。 + 傳回整數，表示已在這個執行個體上呼叫 的次數。 + + + 取得值，這個值表示下一次呼叫 時是否讓出處理器，並觸發強制的環境切換。 + 下一次呼叫 時是否讓出處理器，並觸發強制的環境切換。 + + + 重設微調計數器。 + + + 執行單一微調。 + + + 執行微調，直到滿足指定的條件為止。 + 會重複執行直到傳回 true 為止的委派。 + + 引數為 null。 + + + 執行微調，直到滿足指定的條件或是指定的逾時過期為止。 + 如果滿足條件則為 true，否則為 false。 + 會重複執行直到傳回 true 為止的委派。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + + 引數為 null。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 執行微調，直到滿足指定的條件或是指定的逾時過期為止。 + 如果滿足條件則為 true，否則為 false。 + 會重複執行直到傳回 true 為止的委派。 + + ，表示要等候的毫秒數，或是 TimeSpan，表示無限期等候的 -1 毫秒。 + + 引數為 null。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 提供在各種同步處理模式中傳播同步處理內容的基本功能。 + 2 + + + 建立 類別的新執行個體。 + + + 在衍生類別中覆寫時，會建立同步處理內容的複本。 + 新的 物件。 + 2 + + + 取得目前執行緒的同步處理內容。 + + 物件，代表目前的同步處理內容。 + 1 + + + 在衍生類別中覆寫時，會回應作業已經完成的通知。 + + + 在衍生類別中覆寫時，會回應作業已經啟動的通知。 + + + 在衍生類別中覆寫時，會將非同步訊息分派至同步處理內容。 + 要呼叫的 委派。 + 傳送至委派的物件。 + 2 + + + 在衍生類別中覆寫時，會將同步訊息分派至同步處理內容。 + 要呼叫的 委派。 + 傳送至委派的物件。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 設定目前的同步處理內容。 + 要設定的 物件。 + 1 + + + + + + 方法要求呼叫端擁有指定 Monitor 的鎖定，但是不擁有鎖定的呼叫端叫用方法時所擲回的例外狀況。 + 2 + + + 使用預設屬性來初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 提供資料的執行緒區域儲存區。 + 指定依個別執行緒儲存的資料型別。 + + + 初始化 執行個體。 + + + 初始化 執行個體。 + 是否要追蹤所有在執行個體上設定的值，並透過屬性將它們公開。 + + + 使用指定的 函式來初始化 的執行個體。 + 當嘗試擷取未事先初始化的 時，系統會叫用 來產生延遲初始化的值。 + + 是 Null 參考 (在 Visual Basic 中為 Nothing)。 + + + 使用指定的 函式來初始化 的執行個體。 + 當嘗試擷取未事先初始化的 時，系統會叫用 來產生延遲初始化的值。 + 是否要追蹤所有在執行個體上設定的值，並透過屬性將它們公開。 + + 為 null 參考 (在 Visual Basic 中為 Nothing)。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放這個 執行個體所使用的資源。 + 布林值，表示是否會因為呼叫 而呼叫這個方法。 + + + 釋放這個 執行個體所使用的資源。 + + + 取得值，這個值表示 是否已在目前執行緒中完成初始化。 + 如果已在目前執行緒上初始化 則為 true，否則為 false。 + 已處置 執行個體。 + + + 建立並傳回目前執行緒的這個執行個體的字串表示。 + 在 上呼叫 的結果。 + 已處置 執行個體。 + 目前執行緒的 是 Null 參考 (在 Visual Basic 中為 Nothing)。 + 初始化函式會嘗試遞迴參考 。 + 沒有提供任何預設的建構函式，也沒有提供任何値 Factory。 + + + 取得或設定目前執行緒的這個執行個體的值。 + 傳回這個 ThreadLocal 負責初始化之物件的執行個體。 + 已處置 執行個體。 + 初始化函式會嘗試遞迴參考 。 + 沒有提供任何預設的建構函式，也沒有提供任何値 Factory。 + + + 取得清單，其中包含已存取這個執行個體的所有執行緒目前所儲存的所有值。 + 已存取這個執行個體的所有執行緒目前所儲存之所有值的清單。 + 已處置 執行個體。 + + + 包含用來執行動態記憶體作業的方法。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 從指定的欄位讀取物件參考。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取之 的參考。這個參考是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + 要讀取之欄位的型別。此型別必須是參考型別，不得為實值型別。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現記憶體作業，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的物件參考寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入物件參考的欄位。 + 要寫入的物件參考。立即寫入此參考，好讓電腦中的所有處理器都可以看到此參考。 + 要寫入之欄位的型別。此型別必須是參考型別，不得為實值型別。 + + + 當嘗試開啟不存在的系統 Mutex 或號誌時，所擲回的例外狀況。 + 2 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/System.Threading.dll b/packages/System.Threading.4.3.0/ref/netstandard1.3/System.Threading.dll new file mode 100644 index 0000000000000000000000000000000000000000..c77b70bc08effbcb9425a01f6302730f1b3823a4 GIT binary patch literal 32096 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 + + + System.Threading + + + + The exception that is thrown when one thread acquires a object that another thread has abandoned by exiting without releasing it. + 1 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified index for the abandoned mutex, if applicable, and a object that represents the mutex. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Initializes a new instance of the class with a specified error message. + An error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and inner exception. + An error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Initializes a new instance of the class with a specified error message, the inner exception, the index for the abandoned mutex, if applicable, and a object that represents the mutex. + An error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Initializes a new instance of the class with a specified error message, the index of the abandoned mutex, if applicable, and the abandoned mutex. + An error message that explains the reason for the exception. + The index of the abandoned mutex in the array of wait handles if the exception is thrown for the method, or –1 if the exception is thrown for the or methods. + A object that represents the abandoned mutex. + + + Gets the abandoned mutex that caused the exception, if known. + A object that represents the abandoned mutex, or null if the abandoned mutex could not be identified. + 1 + + + Gets the index of the abandoned mutex that caused the exception, if known. + The index, in the array of wait handles passed to the method, of the object that represents the abandoned mutex, or –1 if the index of the abandoned mutex could not be determined. + 1 + + + Represents ambient data that is local to a given asynchronous control flow, such as an asynchronous method. + The type of the ambient data. + + + Instantiates an instance that does not receive change notifications. + + + Instantiates an local instance that receives change notifications. + The delegate that is called whenever the current value changes on any thread. + + + Gets or sets the value of the ambient data. + The value of the ambient data. + + + The class that provides data change information to instances that register for change notifications. + The type of the data. + + + Gets the data's current value. + The data's current value. + + + Gets the data's previous value. + The data's previous value. + + + Returns a value that indicates whether the value changes because of a change of execution context. + true if the value changed because of a change of execution context; otherwise, false. + + + Notifies a waiting thread that an event has occurred. This class cannot be inherited. + 2 + + + Initializes a new instance of the class with a Boolean value indicating whether to set the initial state to signaled. + true to set the initial state to signaled; false to set the initial state to non-signaled. + + + Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases. + + + Initializes a new instance of the class. + The number of participating threads. + + is less than 0 or greater than 32,767. + + + Initializes a new instance of the class. + The number of participating threads. + The to be executed after each phase. null (Nothing in Visual Basic) may be passed to indicate no action is taken. + + is less than 0 or greater than 32,767. + + + Notifies the that there will be an additional participant. + The phase number of the barrier in which the new participants will first participate. + The current instance has already been disposed. + Adding a participant would cause the barrier's participant count to exceed 32,767.-or-The method was invoked from within a post-phase action. + + + Notifies the that there will be additional participants. + The phase number of the barrier in which the new participants will first participate. + The number of additional participants to add to the barrier. + The current instance has already been disposed. + + is less than 0.-or-Adding participants would cause the barrier's participant count to exceed 32,767. + The method was invoked from within a post-phase action. + + + Gets the number of the barrier's current phase. + Returns the number of the barrier's current phase. + + + Releases all resources used by the current instance of the class. + The method was invoked from within a post-phase action. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the total number of participants in the barrier. + Returns the total number of participants in the barrier. + + + Gets the number of participants in the barrier that haven’t yet signaled in the current phase. + Returns the number of participants in the barrier that haven’t yet signaled in the current phase. + + + Notifies the that there will be one less participant. + The current instance has already been disposed. + The barrier already has 0 participants.-or-The method was invoked from within a post-phase action. + + + Notifies the that there will be fewer participants. + The number of additional participants to remove from the barrier. + The current instance has already been disposed. + + is less than 0. + The barrier already has 0 participants.-or-The method was invoked from within a post-phase action. -or-current participant count is less than the specified participantCount + The total participant count is less than the specified + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well. + The current instance has already been disposed. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + If an exception is thrown from the post phase action of a Barrier after all participating threads have called SignalAndWait, the exception will be wrapped in a BarrierPostPhaseException and be thrown on all participating threads. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the timeout. + if all participants reached the barrier within the specified time; otherwise false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + If an exception is thrown from the post phase action of a Barrier after all participating threads have called SignalAndWait, the exception will be wrapped in a BarrierPostPhaseException and be thrown on all participating threads. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a 32-bit signed integer to measure the timeout, while observing a cancellation token. + if all participants reached the barrier within the specified time; otherwise false + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier, while observing a cancellation token. + The to observe. + + has been canceled. + The current instance has already been disposed. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a object to measure the time interval. + true if all other participants reached the barrier; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out, or it is greater than 32,767. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + Signals that a participant has reached the barrier and waits for all other participants to reach the barrier as well, using a object to measure the time interval, while observing a cancellation token. + true if all other participants reached the barrier; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. + The method was invoked from within a post-phase action, the barrier currently has 0 participants, or the barrier is signaled by more threads than are registered as participants. + + + The exception that is thrown when the post-phase action of a fails + + + Initializes a new instance of the class with a system-supplied message that describes the error. + + + Initializes a new instance of the class with the specified inner exception. + The exception that is the cause of the current exception. + + + Initializes a new instance of the class with a specified message that describes the error. + The message that describes the exception. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The message that describes the exception. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Represents a method to be called within a new context. + An object containing information to be used by the callback method each time it executes. + 1 + + + Represents a synchronization primitive that is signaled when its count reaches zero. + + + Initializes a new instance of class with the specified count. + The number of signals initially required to set the . + + is less than 0. + + + Increments the 's current count by one. + The current instance has already been disposed. + The current instance is already set.-or- is equal to or greater than . + + + Increments the 's current count by a specified value. + The value by which to increase . + The current instance has already been disposed. + + is less than or equal to 0. + The current instance is already set.-or- is equal to or greater than after count is incremented by + + + Gets the number of remaining signals required to set the event. + The number of remaining signals required to set the event. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the numbers of signals initially required to set the event. + The number of signals initially required to set the event. + + + Determines whether the event is set. + true if the event is set; otherwise, false. + + + Resets the to the value of . + The current instance has already been disposed.. + + + Resets the property to a specified value. + The number of signals required to set the . + The current instance has alread been disposed. + + is less than 0. + + + Registers a signal with the , decrementing the value of . + true if the signal caused the count to reach zero and the event was set; otherwise, false. + The current instance has already been disposed. + The current instance is already set. + + + Registers multiple signals with the , decrementing the value of by the specified amount. + true if the signals caused the count to reach zero and the event was set; otherwise, false. + The number of signals to register. + The current instance has already been disposed. + + is less than 1. + The current instance is already set. -or- Or is greater than . + + + Attempts to increment by one. + true if the increment succeeded; otherwise, false. If is already at zero, this method will return false. + The current instance has already been disposed. + + is equal to . + + + Attempts to increment by a specified value. + true if the increment succeeded; otherwise, false. If is already at zero this will return false. + The value by which to increase . + The current instance has already been disposed. + + is less than or equal to 0. + The current instance is already set.-or- + is equal to or greater than . + + + Blocks the current thread until the is set. + The current instance has already been disposed. + + + Blocks the current thread until the is set, using a 32-bit signed integer to measure the timeout. + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until the is set, using a 32-bit signed integer to measure the timeout, while observing a . + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until the is set, while observing a . + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + + Blocks the current thread until the is set, using a to measure the timeout. + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Blocks the current thread until the is set, using a to measure the timeout, while observing a . + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + has been canceled. + The current instance has already been disposed. -or- The that created has already been disposed. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Gets a that is used to wait for the event to be set. + A that is used to wait for the event to be set. + The current instance has already been disposed. + + + Indicates whether an is reset automatically or manually after receiving a signal. + 2 + + + When signaled, the resets automatically after releasing a single thread. If no threads are waiting, the remains signaled until a thread blocks, and resets after releasing the thread. + + + When signaled, the releases all waiting threads and remains signaled until it is manually reset. + + + Represents a thread synchronization event. + 2 + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled, and whether it resets automatically or manually. + true to set the initial state to signaled; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled if created as a result of this call, whether it resets automatically or manually, and the name of a system synchronization event. + true to set the initial state to signaled if the named event is created as a result of this call; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + The name of a system-wide synchronization event. + A Win32 error occurred. + The named event exists and has access control security, but the user does not have . + The named event cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Initializes a new instance of the class, specifying whether the wait handle is initially signaled if created as a result of this call, whether it resets automatically or manually, the name of a system synchronization event, and a Boolean variable whose value after the call indicates whether the named system event was created. + true to set the initial state to signaled if the named event is created as a result of this call; false to set it to nonsignaled. + One of the values that determines whether the event resets automatically or manually. + The name of a system-wide synchronization event. + When this method returns, contains true if a local event was created (that is, if is null or an empty string) or if the specified named system event was created; false if the specified named system event already existed. This parameter is passed uninitialized. + A Win32 error occurred. + The named event exists and has access control security, but the user does not have . + The named event cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Opens the specified named synchronization event, if it already exists. + An object that represents the named system event. + The name of the system synchronization event to open. + + is an empty string. -or- is longer than 260 characters. + + is null. + The named system event does not exist. + A Win32 error occurred. + The named event exists, but the user does not have the security access required to use it. + 1 + + + + + + Sets the state of the event to nonsignaled, causing threads to block. + true if the operation succeeds; otherwise, false. + The method was previously called on this . + 2 + + + Sets the state of the event to signaled, allowing one or more waiting threads to proceed. + true if the operation succeeds; otherwise, false. + The method was previously called on this . + 2 + + + Opens the specified named synchronization event, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named synchronization event was opened successfully; otherwise, false. + The name of the system synchronization event to open. + When this method returns, contains a object that represents the named synchronization event if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named event exists, but the user does not have the desired security access. + + + Manages the execution context for the current thread. This class cannot be inherited. + 2 + + + Captures the execution context from the current thread. + An object representing the execution context for the current thread. + 1 + + + Runs a method in a specified execution context on the current thread. + The to set. + A delegate that represents the method to be run in the provided execution context. + The object to pass to the callback method. + + is null.-or- was not acquired through a capture operation. -or- has already been used as the argument to a call. + 1 + + + + + + Provides atomic operations for variables that are shared by multiple threads. + 2 + + + Adds two 32-bit integers and replaces the first integer with the sum, as an atomic operation. + The new value stored at . + A variable containing the first value to be added. The sum of the two values is stored in . + The value to be added to the integer at . + The address of is a null pointer. + 1 + + + Adds two 64-bit integers and replaces the first integer with the sum, as an atomic operation. + The new value stored at . + A variable containing the first value to be added. The sum of the two values is stored in . + The value to be added to the integer at . + The address of is a null pointer. + 1 + + + Compares two double-precision floating point numbers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two 32-bit signed integers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two 64-bit signed integers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two platform-specific handles or pointers for equality and, if they are equal, replaces the first one. + The original value in . + The destination , whose value is compared with the value of and possibly replaced by . + The that replaces the destination value if the comparison results in equality. + The that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two objects for reference equality and, if they are equal, replaces the first object. + The original value in . + The destination object that is compared with and possibly replaced. + The object that replaces the destination object if the comparison results in equality. + The object that is compared to the object at . + The address of is a null pointer. + 1 + + + Compares two single-precision floating point numbers for equality and, if they are equal, replaces the first value. + The original value in . + The destination, whose value is compared with and possibly replaced. + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The address of is a null pointer. + 1 + + + Compares two instances of the specified reference type for equality and, if they are equal, replaces the first one. + The original value in . + The destination, whose value is compared with and possibly replaced. This is a reference parameter (ref in C#, ByRef in Visual Basic). + The value that replaces the destination value if the comparison results in equality. + The value that is compared to the value at . + The type to be used for , , and . This type must be a reference type. + The address of is a null pointer. + + + Decrements a specified variable and stores the result, as an atomic operation. + The decremented value. + The variable whose value is to be decremented. + The address of is a null pointer. + 1 + + + Decrements the specified variable and stores the result, as an atomic operation. + The decremented value. + The variable whose value is to be decremented. + The address of is a null pointer. + 1 + + + Sets a double-precision floating point number to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a 32-bit signed integer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a 64-bit signed integer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a platform-specific handle or pointer to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets an object to a specified value and returns a reference to the original object, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a single-precision floating point number to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. + The value to which the parameter is set. + The address of is a null pointer. + 1 + + + Sets a variable of the specified type to a specified value and returns the original value, as an atomic operation. + The original value of . + The variable to set to the specified value. This is a reference parameter (ref in C#, ByRef in Visual Basic). + The value to which the parameter is set. + The type to be used for and . This type must be a reference type. + The address of is a null pointer. + + + Increments a specified variable and stores the result, as an atomic operation. + The incremented value. + The variable whose value is to be incremented. + The address of is a null pointer. + 1 + + + Increments a specified variable and stores the result, as an atomic operation. + The incremented value. + The variable whose value is to be incremented. + The address of is a null pointer. + 1 + + + Synchronizes memory access as follows: The processor that executes the current thread cannot reorder instructions in such a way that memory accesses before the call to execute after memory accesses that follow the call to . + + + Returns a 64-bit value, loaded as an atomic operation. + The loaded value. + The 64-bit value to be loaded. + 1 + + + Provides lazy initialization routines. + + + Initializes a target reference type with the type's default constructor if it hasn't already been initialized. + The initialized reference of type . + A reference of type to initialize if it has not already been initialized. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference or value type with its default constructor if it hasn't already been initialized. + The initialized value of type . + A reference or value of type to initialize if it hasn't already been initialized. + A reference to a Boolean value that determines whether the target has already been initialized. + A reference to an object used as the mutually exclusive lock for initializing . If is null, a new object will be instantiated. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference or value type by using a specified function if it hasn't already been initialized. + The initialized value of type . + A reference or value of type to initialize if it hasn't already been initialized. + A reference to a Boolean value that determines whether the target has already been initialized. + A reference to an object used as the mutually exclusive lock for initializing . If is null, a new object will be instantiated. + The function that is called to initialize the reference or value. + The type of the reference to be initialized. + Permissions to access the constructor of type were missing. + Type does not have a default constructor. + + + Initializes a target reference type by using a specified function if it hasn't already been initialized. + The initialized value of type . + The reference of type to initialize if it hasn't already been initialized. + The function that is called to initialize the reference. + The reference type of the reference to be initialized. + Type does not have a default constructor. + + returned null (Nothing in Visual Basic). + + + The exception that is thrown when recursive entry into a lock is not compatible with the recursion policy for the lock. + 2 + + + Initializes a new instance of the class with a system-supplied message that describes the error. + 2 + + + Initializes a new instance of the class with a specified message that describes the error. + The message that describes the exception. The caller of this constructor must make sure that this string has been localized for the current system culture. + 2 + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The message that describes the exception. The caller of this constructor must make sure that this string has been localized for the current system culture. + The exception that caused the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + 2 + + + Specifies whether a lock can be entered multiple times by the same thread. + + + If a thread tries to enter a lock recursively, an exception is thrown. Some classes may allow certain recursions when this setting is in effect. + + + A thread can enter a lock recursively. Some classes may restrict this capability. + + + Notifies one or more waiting threads that an event has occurred. This class cannot be inherited. + 2 + + + Initializes a new instance of the class with a Boolean value indicating whether to set the initial state to signaled. + true to set the initial state signaled; false to set the initial state to nonsignaled. + + + Provides a slimmed down version of . + + + Initializes a new instance of the class with an initial state of nonsignaled. + + + Initializes a new instance of the class with a Boolean value indicating whether to set the intial state to signaled. + true to set the initial state signaled; false to set the initial state to nonsignaled. + + + Initializes a new instance of the class with a Boolean value indicating whether to set the intial state to signaled and a specified spin count. + true to set the initial state to signaled; false to set the initial state to nonsignaled. + The number of spin waits that will occur before falling back to a kernel-based wait operation. + + is less than 0 or greater than the maximum allowed value. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets whether the event is set. + true if the event has is set; otherwise, false. + + + Sets the state of the event to nonsignaled, which causes threads to block. + The object has already been disposed. + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed. + + + Gets the number of spin waits that will be occur before falling back to a kernel-based wait operation. + Returns the number of spin waits that will be occur before falling back to a kernel-based wait operation. + + + Blocks the current thread until the current is set. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a 32-bit signed integer to measure the time interval. + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a 32-bit signed integer to measure the time interval, while observing a . + true if the was set; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blocks the current thread until the current receives a signal, while observing a . + The to observe. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blocks the current thread until the current is set, using a to measure the time interval. + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocks the current thread until the current is set, using a to measure the time interval, while observing a . + true if the was set; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Gets the underlying object for this . + The underlying event object fore this . + + + Provides a mechanism that synchronizes access to objects. + 2 + + + Acquires an exclusive lock on the specified object. + The object on which to acquire the monitor lock. + The parameter is null. + 1 + + + Acquires an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to wait. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. Note   If no exception occurs, the output of this method is always true. + The input to is true. + The parameter is null. + + + Releases an exclusive lock on the specified object. + The object on which to release the lock. + The parameter is null. + The current thread does not own the lock for the specified object. + 1 + + + Determines whether the current thread holds the lock on the specified object. + true if the current thread holds the lock on ; otherwise, false. + The object to test. + + is null. + + + Notifies a thread in the waiting queue of a change in the locked object's state. + The object a thread is waiting for. + The parameter is null. + The calling thread does not own the lock for the specified object. + 1 + + + Notifies all waiting threads of a change in the object's state. + The object that sends the pulse. + The parameter is null. + The calling thread does not own the lock for the specified object. + 1 + + + Attempts to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + The parameter is null. + 1 + + + Attempts to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + + + Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + The number of milliseconds to wait for the lock. + The parameter is null. + + is negative, and not equal to . + 1 + + + Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The number of milliseconds to wait for the lock. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + + is negative, and not equal to . + + + Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object. + true if the current thread acquires the lock; otherwise, false. + The object on which to acquire the lock. + A representing the amount of time to wait for the lock. A value of –1 millisecond specifies an infinite wait. + The parameter is null. + The value of in milliseconds is negative and is not equal to (–1 millisecond), or is greater than . + 1 + + + Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken. + The object on which to acquire the lock. + The amount of time to wait for the lock. A value of –1 millisecond specifies an infinite wait. + The result of the attempt to acquire the lock, passed by reference. The input must be false. The output is true if the lock is acquired; otherwise, the output is false. The output is set even if an exception occurs during the attempt to acquire the lock. + The input to is true. + The parameter is null. + The value of in milliseconds is negative and is not equal to (–1 millisecond), or is greater than . + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. + true if the call returned because the caller reacquired the lock for the specified object. This method does not return if the lock is not reacquired. + The object on which to wait. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + 1 + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. If the specified time-out interval elapses, the thread enters the ready queue. + true if the lock was reacquired before the specified time elapsed; false if the lock was reacquired after the specified time elapsed. The method does not return until the lock is reacquired. + The object on which to wait. + The number of milliseconds to wait before the thread enters the ready queue. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + The value of the parameter is negative, and is not equal to . + 1 + + + Releases the lock on an object and blocks the current thread until it reacquires the lock. If the specified time-out interval elapses, the thread enters the ready queue. + true if the lock was reacquired before the specified time elapsed; false if the lock was reacquired after the specified time elapsed. The method does not return until the lock is reacquired. + The object on which to wait. + A representing the amount of time to wait before the thread enters the ready queue. + The parameter is null. + The calling thread does not own the lock for the specified object. + The thread that invokes Wait is later interrupted from the waiting state. This happens when another thread calls this thread's method. + The value of the parameter in milliseconds is negative and does not represent (–1 millisecond), or is greater than . + 1 + + + A synchronization primitive that can also be used for interprocess synchronization. + 1 + + + Initializes a new instance of the class with default properties. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex. + true to give the calling thread initial ownership of the mutex; otherwise, false. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex. + true to give the calling thread initial ownership of the named system mutex if the named system mutex is created as a result of this call; otherwise, false. + The name of the . If the value is null, the is unnamed. + The named mutex exists and has access control security, but the user does not have . + A Win32 error occurred. + The named mutex cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Initializes a new instance of the class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex. + true to give the calling thread initial ownership of the named system mutex if the named system mutex is created as a result of this call; otherwise, false. + The name of the . If the value is null, the is unnamed. + When this method returns, contains a Boolean that is true if a local mutex was created (that is, if is null or an empty string) or if the specified named system mutex was created; false if the specified named system mutex already existed. This parameter is passed uninitialized. + The named mutex exists and has access control security, but the user does not have . + A Win32 error occurred. + The named mutex cannot be created, perhaps because a wait handle of a different type has the same name. + + is longer than 260 characters. + + + Opens the specified named mutex, if it already exists. + An object that represents the named system mutex. + The name of the system mutex to open. + + is an empty string.-or- is longer than 260 characters. + + is null. + The named mutex does not exist. + A Win32 error occurred. + The named mutex exists, but the user does not have the security access required to use it. + 1 + + + + + + Releases the once. + The calling thread does not own the mutex. + 1 + + + Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named mutex was opened successfully; otherwise, false. + The name of the system mutex to open. + When this method returns, contains a object that represents the named mutex if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named mutex exists, but the user does not have the security access required to use it. + + + Represents a lock that is used to manage access to a resource, allowing multiple threads for reading or exclusive access for writing. + + + Initializes a new instance of the class with default property values. + + + Initializes a new instance of the class, specifying the lock recursion policy. + One of the enumeration values that specifies the lock recursion policy. + + + Gets the total number of unique threads that have entered the lock in read mode. + The number of unique threads that have entered the lock in read mode. + + + Releases all resources used by the current instance of the class. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Tries to enter the lock in read mode. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter. This limit is so large that applications should never encounter it. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The object has been disposed. + + + Tries to enter the lock in write mode. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The object has been disposed. + + + Reduces the recursion count for read mode, and exits read mode if the resulting count is 0 (zero). + The current thread has not entered the lock in read mode. + + + Reduces the recursion count for upgradeable mode, and exits upgradeable mode if the resulting count is 0 (zero). + The current thread has not entered the lock in upgradeable mode. + + + Reduces the recursion count for write mode, and exits write mode if the resulting count is 0 (zero). + The current thread has not entered the lock in write mode. + + + Gets a value that indicates whether the current thread has entered the lock in read mode. + true if the current thread has entered read mode; otherwise, false. + 2 + + + Gets a value that indicates whether the current thread has entered the lock in upgradeable mode. + true if the current thread has entered upgradeable mode; otherwise, false. + 2 + + + Gets a value that indicates whether the current thread has entered the lock in write mode. + true if the current thread has entered write mode; otherwise, false. + 2 + + + Gets a value that indicates the recursion policy for the current object. + One of the enumeration values that specifies the lock recursion policy. + + + Gets the number of times the current thread has entered the lock in read mode, as an indication of recursion. + 0 (zero) if the current thread has not entered read mode, 1 if the thread has entered read mode but has not entered it recursively, or n if the thread has entered the lock recursively n - 1 times. + 2 + + + Gets the number of times the current thread has entered the lock in upgradeable mode, as an indication of recursion. + 0 if the current thread has not entered upgradeable mode, 1 if the thread has entered upgradeable mode but has not entered it recursively, or n if the thread has entered upgradeable mode recursively n - 1 times. + 2 + + + Gets the number of times the current thread has entered the lock in write mode, as an indication of recursion. + 0 if the current thread has not entered write mode, 1 if the thread has entered write mode but has not entered it recursively, or n if the thread has entered write mode recursively n - 1 times. + 2 + + + Tries to enter the lock in read mode, with an optional integer time-out. + true if the calling thread entered read mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in read mode, with an optional time-out. + true if the calling thread entered read mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode, with an optional time-out. + true if the calling thread entered upgradeable mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in upgradeable mode, with an optional time-out. + true if the calling thread entered upgradeable mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Tries to enter the lock in write mode, with an optional time-out. + true if the calling thread entered write mode, otherwise, false. + The number of milliseconds to wait, or -1 () to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Tries to enter the lock in write mode, with an optional time-out. + true if the calling thread entered write mode, otherwise, false. + The interval to wait, or -1 milliseconds to wait indefinitely. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter. The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Gets the total number of threads that are waiting to enter the lock in read mode. + The total number of threads that are waiting to enter read mode. + 2 + + + Gets the total number of threads that are waiting to enter the lock in upgradeable mode. + The total number of threads that are waiting to enter upgradeable mode. + 2 + + + Gets the total number of threads that are waiting to enter the lock in write mode. + The total number of threads that are waiting to enter write mode. + 2 + + + Limits the number of threads that can access a resource or pool of resources concurrently. + 1 + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + + is greater than . + + is less than 1.-or- is less than 0. + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries, and optionally specifying the name of a system semaphore object. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + The name of a named system semaphore object. + + is greater than .-or- is longer than 260 characters. + + is less than 1.-or- is less than 0. + A Win32 error occurred. + The named semaphore exists and has access control security, and the user does not have . + The named semaphore cannot be created, perhaps because a wait handle of a different type has the same name. + + + Initializes a new instance of the class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, and specifying a variable that receives a value indicating whether a new system semaphore was created. + The initial number of requests for the semaphore that can be satisfied concurrently. + The maximum number of requests for the semaphore that can be satisfied concurrently. + The name of a named system semaphore object. + When this method returns, contains true if a local semaphore was created (that is, if is null or an empty string) or if the specified named system semaphore was created; false if the specified named system semaphore already existed. This parameter is passed uninitialized. + + is greater than . -or- is longer than 260 characters. + + is less than 1.-or- is less than 0. + A Win32 error occurred. + The named semaphore exists and has access control security, and the user does not have . + The named semaphore cannot be created, perhaps because a wait handle of a different type has the same name. + + + Opens the specified named semaphore, if it already exists. + An object that represents the named system semaphore. + The name of the system semaphore to open. + + is an empty string.-or- is longer than 260 characters. + + is null. + The named semaphore does not exist. + A Win32 error occurred. + The named semaphore exists, but the user does not have the security access required to use it. + 1 + + + + + + Exits the semaphore and returns the previous count. + The count on the semaphore before the method was called. + The semaphore count is already at the maximum value. + A Win32 error occurred with a named semaphore. + The current semaphore represents a named system semaphore, but the user does not have .-or-The current semaphore represents a named system semaphore, but it was not opened with . + 1 + + + Exits the semaphore a specified number of times and returns the previous count. + The count on the semaphore before the method was called. + The number of times to exit the semaphore. + + is less than 1. + The semaphore count is already at the maximum value. + A Win32 error occurred with a named semaphore. + The current semaphore represents a named system semaphore, but the user does not have rights.-or-The current semaphore represents a named system semaphore, but it was not opened with rights. + 1 + + + Opens the specified named semaphore, if it already exists, and returns a value that indicates whether the operation succeeded. + true if the named semaphore was opened successfully; otherwise, false. + The name of the system semaphore to open. + When this method returns, contains a object that represents the named semaphore if the call succeeded, or null if the call failed. This parameter is treated as uninitialized. + + is an empty string.-or- is longer than 260 characters. + + is null. + A Win32 error occurred. + The named semaphore exists, but the user does not have the security access required to use it. + + + The exception that is thrown when the method is called on a semaphore whose count is already at the maximum. + 2 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Represents a lightweight alternative to that limits the number of threads that can access a resource or pool of resources concurrently. + + + Initializes a new instance of the class, specifying the initial number of requests that can be granted concurrently. + The initial number of requests for the semaphore that can be granted concurrently. + + is less than 0. + + + Initializes a new instance of the class, specifying the initial and maximum number of requests that can be granted concurrently. + The initial number of requests for the semaphore that can be granted concurrently. + The maximum number of requests for the semaphore that can be granted concurrently. + + is less than 0, or is greater than , or is equal to or less than 0. + + + Returns a that can be used to wait on the semaphore. + A that can be used to wait on the semaphore. + The has been disposed. + + + Gets the number of remaining threads that can enter the object. + The number of remaining threads that can enter the semaphore. + + + Releases all resources used by the current instance of the class. + + + Releases the unmanaged resources used by the , and optionally releases the managed resources. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Releases the object once. + The previous count of the . + The current instance has already been disposed. + The has already reached its maximum size. + + + Releases the object a specified number of times. + The previous count of the . + The number of times to exit the semaphore. + The current instance has already been disposed. + + is less than 1. + The has already reached its maximum size. + + + Blocks the current thread until it can enter the . + The current instance has already been disposed. + + + Blocks the current thread until it can enter the , using a 32-bit signed integer that specifies the timeout. + true if the current thread successfully entered the ; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + + is a negative number other than -1, which represents an infinite time-out. + + + Blocks the current thread until it can enter the , using a 32-bit signed integer that specifies the timeout, while observing a . + true if the current thread successfully entered the ; otherwise, false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The instance has been disposed, or the that created has been disposed. + + + Blocks the current thread until it can enter the , while observing a . + The token to observe. + + was canceled. + The current instance has already been disposed.-or-The that created has already been disposed. + + + Blocks the current thread until it can enter the , using a to specify the timeout. + true if the current thread successfully entered the ; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + The semaphoreSlim instance has been disposed + + + Blocks the current thread until it can enter the , using a that specifies the timeout, while observing a . + true if the current thread successfully entered the ; otherwise, false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The to observe. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + The semaphoreSlim instance has been disposedThe that created has already been disposed. + + + Asynchronously waits to enter the . + A task that will complete when the semaphore has been entered. + + + Asynchronously waits to enter the , using a 32-bit signed integer to measure the time interval. + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out. + + + Asynchronously waits to enter the , using a 32-bit signed integer to measure the time interval, while observing a . + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to observe. + + is a negative number other than -1, which represents an infinite time-out. + The current instance has already been disposed. + + was canceled. + + + Asynchronously waits to enter the , while observing a . + A task that will complete when the semaphore has been entered. + The token to observe. + The current instance has already been disposed. + + was canceled. + + + Asynchronously waits to enter the , using a to measure the time interval. + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The current instance has already been disposed. + + is a negative number other than -1, which represents an infinite time-out -or- timeout is greater than . + + + Asynchronously waits to enter the , using a to measure the time interval, while observing a . + A task that will complete with a result of true if the current thread successfully entered the , otherwise with a result of false. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + The token to observe. + + is a negative number other than -1, which represents an infinite time-out-or-timeout is greater than . + + was canceled. + + + Represents a method to be called when a message is to be dispatched to a synchronization context. + The object passed to the delegate. + 2 + + + Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop repeatedly checking until the lock becomes available. + + + Initializes a new instance of the structure with the option to track thread IDs to improve debugging. + Whether to capture and use thread IDs for debugging purposes. + + + Acquires the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + The argument must be initialized to false prior to calling Enter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Releases the lock. + Thread ownership tracking is enabled, and the current thread is not the owner of this lock. + + + Releases the lock. + A Boolean value that indicates whether a memory fence should be issued in order to immediately publish the exit operation to other threads. + Thread ownership tracking is enabled, and the current thread is not the owner of this lock. + + + Gets whether the lock is currently held by any thread. + true if the lock is currently held by any thread; otherwise false. + + + Gets whether the lock is held by the current thread. + true if the lock is held by the current thread; otherwise false. + Thread ownership tracking is disabled. + + + Gets whether thread ownership tracking is enabled for this instance. + true if thread ownership tracking is enabled for this instance; otherwise false. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + is a negative number other than -1, which represents an infinite time-out. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within the method call, can be examined reliably to determine whether the lock was acquired. + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than milliseconds. + The argument must be initialized to false prior to calling TryEnter. + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + Provides support for spin-based waiting. + + + Gets the number of times has been called on this instance. + Returns an integer that represents the number of times has been called on this instance. + + + Gets whether the next call to will yield the processor, triggering a forced context switch. + Whether the next call to will yield the processor, triggering a forced context switch. + + + Resets the spin counter. + + + Performs a single spin. + + + Spins until the specified condition is satisfied. + A delegate to be executed over and over until it returns true. + The argument is null. + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + True if the condition is satisfied within the timeout; otherwise, false + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The argument is null. + + is a negative number other than -1, which represents an infinite time-out. + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + True if the condition is satisfied within the timeout; otherwise, false + A delegate to be executed over and over until it returns true. + A that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely. + The argument is null. + + is a negative number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than . + + + Provides the basic functionality for propagating a synchronization context in various synchronization models. + 2 + + + Creates a new instance of the class. + + + When overridden in a derived class, creates a copy of the synchronization context. + A new object. + 2 + + + Gets the synchronization context for the current thread. + A object representing the current synchronization context. + 1 + + + When overridden in a derived class, responds to the notification that an operation has completed. + + + When overridden in a derived class, responds to the notification that an operation has started. + + + When overridden in a derived class, dispatches an asynchronous message to a synchronization context. + The delegate to call. + The object passed to the delegate. + 2 + + + When overridden in a derived class, dispatches a synchronous message to a synchronization context. + The delegate to call. + The object passed to the delegate. + The method was called in a Windows Store app. The implementation of for Windows Store apps does not support the method. + 2 + + + Sets the current synchronization context. + The object to be set. + 1 + + + + + + The exception that is thrown when a method requires the caller to own the lock on a given Monitor, and the method is invoked by a caller that does not own that lock. + 2 + + + Initializes a new instance of the class with default properties. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + Provides thread-local storage of data. + Specifies the type of data stored per-thread. + + + Initializes the instance. + + + Initializes the instance. + Whether to track all values set on the instance and expose them through the property. + + + Initializes the instance with the specified function. + The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. + + is a null reference (Nothing in Visual Basic). + + + Initializes the instance with the specified function. + The invoked to produce a lazily-initialized value when an attempt is made to retrieve without it having been previously initialized. + Whether to track all values set on the instance and expose them via the property. + + is a null reference (Nothing in Visual Basic). + + + Releases all resources used by the current instance of the class. + + + Releases the resources used by this instance. + A Boolean value that indicates whether this method is being called due to a call to . + + + Releases the resources used by this instance. + + + Gets whether is initialized on the current thread. + true if is initialized on the current thread; otherwise false. + The instance has been disposed. + + + Creates and returns a string representation of this instance for the current thread. + The result of calling on the . + The instance has been disposed. + The for the current thread is a null reference (Nothing in Visual Basic). + The initialization function attempted to reference recursively. + No default constructor is provided and no value factory is supplied. + + + Gets or sets the value of this instance for the current thread. + Returns an instance of the object that this ThreadLocal is responsible for initializing. + The instance has been disposed. + The initialization function attempted to reference recursively. + No default constructor is provided and no value factory is supplied. + + + Gets a list for all of the values currently stored by all of the threads that have accessed this instance. + A list for all of the values currently stored by all of the threads that have accessed this instance. + The instance has been disposed. + + + Contains methods for performing volatile memory operations. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the value of the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The value that was read. This value is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + + + Reads the object reference from the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears after this method in the code, the processor cannot move it before this method. + The reference to that was read. This reference is the latest written by any processor in the computer, regardless of the number of processors or the state of processor cache. + The field to read. + The type of field to read. This must be a reference type, not a value type. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a memory operation appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the value is written. + The value to write. The value is written immediately so that it is visible to all processors in the computer. + + + Writes the specified object reference to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method. + The field where the object reference is written. + The object reference to write. The reference is written immediately so that it is visible to all processors in the computer. + The type of field to write. This must be a reference type, not a value type. + + + The exception that is thrown when an attempt is made to open a system mutex or semaphore that does not exist. + 2 + + + Initializes a new instance of the class with default values. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/de/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/de/System.Threading.xml new file mode 100644 index 000000000..4fb943bbf --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/de/System.Threading.xml @@ -0,0 +1,1799 @@ + + + + System.Threading + + + + Die Ausnahme, die ausgelöst wird, wenn ein Thread ein -Objekt abruft, das von einem anderen Thread abgebrochen wurde, indem das Objekt beim Beenden nicht freigegeben wurde. + 1 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einem festgelegten Index für den abgebrochenen Mutex (falls zutreffend) und einem -Objekt, das den Mutex darstellt. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung und einer festgelegten inneren Ausnahme. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung, der inneren Ausnahme, dem Index für den abgebrochenen Mutex (falls zutreffend) und einem -Objekt, das den Mutex darstellt. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Initialisiert eine neue Instanz der -Klasse mit einer festgelegten Fehlermeldung, dem Index des abgebrochenen Mutex (falls zutreffend) und dem abgebrochenen Mutex. + Eine Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Der Index des abgebrochenen Mutex im Array von WaitHandles, wenn die Ausnahme für die -Methode ausgelöst wird, oder -1, wenn die Ausnahme für die -Methode oder die -Methode ausgelöst wird. + Ein -Objekt, das den abgebrochenen Mutex darstellt. + + + Ruft den abgebrochenen Mutex ab, das die Ausnahme verursacht hat (falls bekannt). + Ein -Objekt, das den abgebrochenen Mutex darstellt, oder null, wenn der abgebrochene Mutex nicht bestimmt werden konnte. + 1 + + + Ruft den Index des abgebrochenen Mutex ab, der die Ausnahme verursacht hat (falls bekannt). + Der Index des -Objekts, das der abgebrochene Mutex darstellt, im Array von WaitHandles, die an die -Methode übergeben wurden, oder -1, wenn der Index des abgebrochenen Mutex nicht bestimmt werden konnte. + 1 + + + Stellt Umgebungsdaten dar, die für eine angegebene asynchrone Ablaufsteuerung lokal sind, wie etwa eine asynchrone Methode. + Der Typ der Umgebungsdaten. + + + Instanziiert eine -Instanz, die keine Änderungsbenachrichtigungen empfängt. + + + Instanziiert eine lokale -Instanz, die Änderungsbenachrichtigungen empfängt. + Der Delegat, der aufgerufen wird, wenn sich der aktuelle Wert auf einem beliebigen Thread ändert. + + + Ruft den Wert der Umgebungsdaten ab oder legt ihn fest. + Der Wert der Umgebungsdaten. + + + Die Klasse, die -Instanzen, die sich für Änderungsbenachrichtigungen registrieren, Informationen über Datenänderungen zur Verfügung stellt. + Der Typ der Daten. + + + Ruft den aktuellen Wert der Daten ab. + Der aktuelle Wert der Daten. + + + Ruft den vorherigen Wert der Daten ab. + Der vorherige Wert der Daten. + + + Gibt einen Wert zurück, der angibt, ob sich der Wert aufgrund einer Änderung des Ausführungskontexts ändert. + true, wenn sich der Wert aufgrund einer Änderung des Ausführungstexts ändert, andernfalls false. + + + Benachrichtigt einen wartenden Thread über das Eintreten eines Ereignisses.Diese Klasse kann nicht vererbt werden. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf „signalisiert“ festgelegt werden soll. + true, wenn der anfängliche Zustand auf „signalisiert“ festgelegt werden soll. false, wenn der anfängliche Zustand auf „nicht signalisiert“ festgelegt werden soll. + + + Ermöglicht es mehreren Aufgaben, parallel über mehrere Phasen gemeinsam an einem Algorithmus zu arbeiten. + + + Initialisiert eine neue Instanz der -Klasse. + Die Anzahl teilnehmender Threads. + + ist kleiner als 0 oder größer als 32,767. + + + Initialisiert eine neue Instanz der -Klasse. + Die Anzahl teilnehmender Threads. + + , die nach jeder Phase ausgeführt wird. NULL (Nothing in Visual Basic) wird möglicherweise übergeben, um keine Aktion anzugeben. + + ist kleiner als 0 oder größer als 32,767. + + + Benachrichtigt über das Vorhandensein eines weiteren Teilnehmers. + Die Phasennummer der Grenze, an der die neuen Teilnehmer zuerst teilnehmen. + Die aktuelle Instanz wurde bereits freigegeben. + Einen Teilnehmer hinzuzufügen würde verursachen, dass die Teilnehmeranzahl der Barriere 32.767 überschreitet.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Benachrichtigt über das Vorhandensein weiterer Teilnehmer. + Die Phasennummer der Grenze, an der die neuen Teilnehmer zuerst teilnehmen. + Die Anzahl zusätzlicher Teilnehmer, die der Grenze hinzugefügt werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0.– oder –-Teilnehmer hinzuzufügen würde verursachen, dass die Teilnehmeranzahl der Barriere 32.767 überschreitet. + Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Ruft die Nummer der aktuellen Phase der Grenze ab. + Gibt die Nummer der aktuellen Phase der Grenze zurück. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + True, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft die Gesamtanzahl von Teilnehmern für die Grenze ab. + Gibt die Gesamtanzahl von Teilnehmern für die Grenze zurück. + + + Ruft die Anzahl von Teilnehmern für die Grenze ab, die in der aktuellen Phase noch nicht signalisiert haben. + Gibt die Anzahl von Teilnehmern für die Grenze zurück, die in der aktuellen Phase noch nicht signalisiert haben. + + + Benachrichtigt , dass ein Teilnehmer nicht mehr vorhanden ist. + Die aktuelle Instanz wurde bereits freigegeben. + Die Barriere hat bereits 0 Teilnehmer.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. + + + Benachrichtigt über die geringere Anzahl von Teilnehmern. + Die Anzahl zusätzlicher Teilnehmer, die aus der Grenze entfernt werden sollen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0. + Die Barriere hat bereits 0 Teilnehmer.– oder –Die Methode wurde aus einer Postphasenaktion aufgerufen. – oder –aktuelle Teilnehmeranzahl ist kleiner als der angegebene participantCount + Die gesamte Teilnehmeranzahl ist kleiner als der angegebene + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. + Die aktuelle Instanz wurde bereits freigegeben. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + Wenn eine Ausnahme aus der Post-Phasenaktion einer Grenze ausgelöst wird, nachdem alle teilnehmenden Threads SignalAndWait aufgerufen haben, wird die Ausnahme in einer BarrierPostPhaseException umbrochen und für alle teilnehmenden Threads ausgelöst. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet. + wenn alle Teilnehmer die Grenze innerhalb der angegebenen Zeit erreicht haben, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + Wenn eine Ausnahme aus der Post-Phasenaktion einer Grenze ausgelöst wird, nachdem alle teilnehmenden Threads SignalAndWait aufgerufen haben, wird die Ausnahme in einer BarrierPostPhaseException umbrochen und für alle teilnehmenden Threads ausgelöst. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet und ein Abbruchtoken berücksichtigt. + wenn alle Teilnehmer die Grenze innerhalb der angegebenen Zeit erreicht haben, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere erreichen. Dabei wird ein Abbruchtoken überwacht. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird das Zeitintervall mit einem -Objekt gemessen. + True, wenn alle anderen Teilnehmer die Grenze erreicht haben, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, oder er ist größer als 32.767. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Signalisiert, dass ein Teilnehmer die Barriere erreicht hat und darauf wartet, dass alle anderen Teilnehmer die Barriere ebenfalls erreichen. Dabei wird das Zeitintervall mit einem -Objekt gemessen und ein Abbruchtoken berücksichtigt. + True, wenn alle anderen Teilnehmer die Grenze erreicht haben, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1 Millisekunde. Ein Wert von -1 Millisekunde gibt einen unendlichen Timeout an. + Die Methode wurde innerhalb einer Postphasenaktion aufgerufen, die Barriere hat derzeit 0 Teilnehmer, oder die Barriere wird von mehr Threads gemeldet als Teilnehmer registriert sind. + + + Die Ausnahme, die bei einem Fehler der Nachphasenaktion einer ausgelöst wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer vom System generierten Meldung, die den Fehler beschreibt. + + + Initialisiert eine neue Instanz der -Klasse mit der angegebenen internen Ausnahme. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Meldung, die den Fehler beschreibt. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Stellt eine Methode dar, die in einem neuen Kontext aufgerufen werden muss. + Ein Objekt mit den Informationen, die von der Rückrufmethode bei jeder Ausführung verwendet werden. + 1 + + + Stellt einen Synchronisierungsprimitiven dar, der signalisiert wird, wenn seine Anzahl 0 (null) erreicht. + + + Initialisiert eine neue Instanz der -Klasse mit der angegebenen Anzahl. + Die zum Festlegen von ursprünglich erforderliche Anzahl von Signalen. + + ist kleiner als 0. + + + Erhöht die aktuelle Anzahl von um 1. + Die aktuelle Instanz wurde bereits freigegeben. + Die aktuelle Instanz ist bereits festgelegt.– oder – ist größer oder gleich . + + + Erhöht die aktuelle Anzahl von um einen angegebenen Wert. + Der Wert, um den erhöht werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner oder gleich 0. + Die aktuelle Instanz ist bereits festgelegt.– oder – ist größer gleich , nach die Anzahl schrittweise durch erhöht wird. + + + Ruft die Anzahl verbleibender Signale ab, die zum Festlegen des Ereignisses erforderlich sind. + Die Anzahl verbleibender Signale, die zum Festlegen des Ereignisses erforderlich sind. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + True, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft die Anzahl von Signalen ab, die ursprünglich zum Festlegen des Ereignisses erforderlich waren. + Die Anzahl von Signalen, die ursprünglich zum Festlegen des Ereignisses erforderlich waren. + + + Bestimmt, ob das Ereignis festgelegt wurde. + True, wenn das Ereignis festgelegt wurde, andernfalls false. + + + Setzt auf den Wert von zurück. + Die aktuelle Instanz wurde bereits freigegeben. + + + Setzt die -Eigenschaft auf einen angegebenen Wert zurück. + Die zum Festlegen von erforderliche Anzahl von Signalen. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 0. + + + Registriert ein Signal beim und dekrementiert den Wert von . + True, wenn die Anzahl aufgrund des Signals 0 (null) erreicht hat und das Ereignis festgelegt wurde, andernfalls false. + Die aktuelle Instanz wurde bereits freigegeben. + Die aktuelle Instanz ist bereits festgelegt. + + + Registriert mehrere Signale bei und verringert den Wert von um den angegebenen Wert. + True, wenn die Anzahl aufgrund der Signale 0 (null) erreicht hat und das Ereignis festgelegt wurde, andernfalls false. + Die Anzahl zu registrierender Signale. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 1. + Die aktuelle Instanz ist bereits festgelegt. -oder- ist größer als . + + + Versucht, um eins zu inkrementieren. + True, wenn die Anzahl erfolgreich erhöht wurde, andernfalls false.Wenn bereits 0 (null) ist, gibt diese Methode false zurück. + Die aktuelle Instanz wurde bereits freigegeben. + + ist gleich . + + + Versucht, durch einen angegebenen Wert zu inkrementieren. + True, wenn die Anzahl erfolgreich erhöht wurde, andernfalls false.Wenn bereits 0 (null) ist, wird false zurückgegeben. + Der Wert, um den erhöht werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner oder gleich 0. + Die aktuelle Instanz ist bereits festgelegt.– oder – + ist gleich oder größer als . + + + Blockiert den aktuellen Thread, bis festgelegt wird. + Die aktuelle Instanz wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet wird. + True, wenn festgelegt wurde, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Timeouts verwendet und ein überwacht wird. + True, wenn festgelegt wurde, andernfalls false. + Die Wartezeit in Millisekunden oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein überwacht wird. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein zum Messen des Timeouts verwendet wird. + True, wenn festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Blockiert den aktuellen Thread, bis festgelegt wird, wobei ein zum Messen des Zeitintervalls verwendet und ein überwacht wird. + True, wenn festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben. - Oder - Die , die erstellte, wurde bereits freigegeben. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Ruft ein ab, das verwendet wird, um auf das festzulegende Ereignis zu warten. + Ein , das verwendet wird, um auf das festzulegende Ereignis zu warten. + Die aktuelle Instanz wurde bereits freigegeben. + + + Gibt an, ob eine -Klasse nach dem Empfangen eines Signals automatisch oder manuell zurückgesetzt wird. + 2 + + + Bei Signalisierung wird die -Methode automatisch nach der Freigabe eines einzigen Threads zurückgesetzt.Wenn sich keine Threads in der Warteschlange befinden, bleibt die -Methode solange signalisiert, bis ein Thread blockiert wird. Sie wird zurückgesetzt, nachdem der Thread freigegeben wurde. + + + Bei Signalisierung gibt die -Methode alle wartenden Threads frei. Sie bleibt solange signalisiert, bis sie manuell zurückgesetzt wird. + + + Stellt ein Threadsynchronisierungsereignis dar. + 2 + + + Initialisiert eine neue Instanz der -Klasse und gibt an, ob das WaitHandle anfänglich signalisiert ist und ob es automatisch oder manuell zurückgesetzt wird. + true, wenn der anfängliche Zustand auf signalisiert festgelegt werden soll. false, wenn er auf nicht signalisiert festgelegt werden soll. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + + + Initialisiert eine neue Instanz der -Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses an. + true, um den anfänglichen Zustand auf signalisiert festzulegen, wenn das benannte Ereignis als Ergebnis dieses Aufrufs erstellt wird; false, um den Zustand auf nicht signalisiert festzulegen. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + Der Name eines systemweiten Synchronisierungsereignisses. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Ereignis kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Initialisiert eine neue Instanz der -Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, und ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses und eine boolesche Variable an, deren Wert nach dem Aufruf angibt, ob das benannte Systemereignis erstellt wurde. + true, um den anfänglichen Zustand auf signalisiert festzulegen, wenn das benannte Ereignis als Ergebnis dieses Aufrufs erstellt wird; false, um den Zustand auf nicht signalisiert festzulegen. + Einer der -Werte, die bestimmen, ob das Ereignis automatisch oder manuell zurückgesetzt wird. + Der Name eines systemweiten Synchronisierungsereignisses. + Enthält nach dem Beenden dieser Methode den Wert true, wenn ein lokales Ereignis erstellt wurde (d. h., wenn gleich null oder eine leere Zeichenfolge ist) oder wenn das angegebene benannte Systemereignis erstellt wurde. Der Wert ist false, wenn das angegebene benannte Systemsereignis bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Ereignis kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist. + Ein Objekt, das das benannte Systemereignis darstellt. + Der Name eines systemweiten Synchronisierungsereignisses, das zu öffnen ist. + + ist eine leere Zeichenfolge. - oder - ist länger als 260 Zeichen. + + ist null. + Das benannte Systemereignis ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Legt den Zustand des Ereignisses auf nicht signalisiert fest, sodass Threads blockiert werden. + true, wenn die Operation erfolgreich ausgeführt wird, andernfalls false. + Die -Methode wurde zuvor für dieses aufgerufen. + 2 + + + Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren. + true, wenn die Operation erfolgreich ausgeführt wird, andernfalls false. + Die -Methode wurde zuvor für dieses aufgerufen. + 2 + + + Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn das benannte Synchronisierungsereignis erfolgreich geöffnet wurde; andernfalls false. + Der Name eines systemweiten Synchronisierungsereignisses, das zu öffnen ist. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Synchronisierungsereignis darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Das benannte Ereignis ist vorhanden, der Benutzer verfügt jedoch nicht über den gewünschten Sicherheitszugriff. + + + Verwaltet den Ausführungskontext für den aktuellen Thread.Diese Klasse kann nicht vererbt werden. + 2 + + + Zeichnet den Ausführungskontext des aktuellen Threads auf. + Ein -Objekt, das den Ausführungskontext für den aktuellen Thread darstellt. + 1 + + + Führt für den aktuellen Thread eine Methode in einem angegebenen Ausführungskontext aus. + Der festzulegende . + Ein -Delegat, der die im bereitgestellten Ausführungskontext auszuführende Methode darstellt. + Das Objekt, das an die Rückrufmethode übergeben werden soll. + + ist null.– oder – wurde nicht durch einen Aufzeichnungsvorgang ermittelt. – oder – wurde bereits als Argument für einen Aufruf von verwendet. + 1 + + + + + + Stellt atomare Operationen für Variablen bereit, die von mehreren Threads gemeinsam genutzt werden. + 2 + + + Fügt in einer atomaren Operation zwei 32-Bit-Ganzzahlen hinzu und ersetzt die erste Ganzzahl durch die Summe. + Der unter gespeicherte neue Wert. + Eine Variable, die den ersten Wert enthält, der hinzugefügt werden soll.Die Summe der beiden Werte wird in gespeichert. + Der Wert, der der Ganzzahl in hinzugefügt werden soll. + The address of is a null pointer. + 1 + + + Fügt in einer atomaren Operation zwei 64-Bit-Ganzzahlen hinzu und ersetzt die erste Ganzzahl durch die Summe. + Der unter gespeicherte neue Wert. + Eine Variable, die den ersten Wert enthält, der hinzugefügt werden soll.Die Summe der beiden Werte wird in gespeichert. + Der Wert, der der Ganzzahl in hinzugefügt werden soll. + The address of is a null pointer. + 1 + + + Vergleicht zwei Gleitkommazahlen mit doppelter Genauigkeit hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei 32-Bit-Ganzzahlen mit Vorzeichen hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei 64-Bit-Ganzzahlen mit Vorzeichen hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei plattformspezifische Handles oder Zeiger hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten. + Der ursprüngliche Wert in . + Der Ziel-, dessen Wert mit dem Wert von verglichen und möglicherweise durch ersetzt wird. + Der , der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der , der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Objekte hinsichtlich ihrer Verweisgleichheit und ersetzt bei vorliegender Gleichheit das erste Objekt. + Der ursprüngliche Wert in . + Das Zielobjekt, das mit verglichen und möglicherweise ersetzt wird. + Das Objekt, das das Zielobjekt ersetzt, wenn beim Vergleich Gleichheit festgestellt wird. + Das Objekt, das mit dem Objekt in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Gleitkommazahlen mit einfacher Genauigkeit hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit den ersten Wert. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird. + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + The address of is a null pointer. + 1 + + + Vergleicht zwei Instanzen des angegebenen Referenztyps hinsichtlich ihrer Gleichheit und ersetzt bei vorliegender Gleichheit die erste. + Der ursprüngliche Wert in . + Das Ziel, dessen Wert mit verglichen und möglicherweise ersetzt wird.Dies ist ein Verweisparameter (ref in C#, ByRef in Visual Basic). + Der Wert, der den Zielwert ersetzt, wenn der Vergleich Gleichheit ergibt. + Der Wert, der mit dem Wert in verglichen wird. + Der Typ, der für , und verwendet werden soll.Dieser Typ muss ein Referenztyp sein. + The address of is a null pointer. + + + Dekrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der dekrementierte Wert. + Die Variable, deren Wert dekrementiert werden soll. + The address of is a null pointer. + 1 + + + Dekrementiert den Wert der angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der dekrementierte Wert. + Die Variable, deren Wert dekrementiert werden soll. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation eine Gleitkommazahl mit doppelter Genauigkeit auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine 32-Bit-Ganzzahl mit Vorzeichen in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine 64-Bit-Ganzzahl mit Vorzeichen in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation ein plattformspezifisches Handle bzw. einen plattformspezifischen Zeiger auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation ein Objekt auf einen angegebenen Wert fest und gibt einen Verweis auf das ursprüngliche Objekt zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt in einer atomaren Operation eine Gleitkommazahl mit einfacher Genauigkeit auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll. + Der Wert, auf den der -Parameter festgelegt ist. + The address of is a null pointer. + 1 + + + Legt eine Variable vom angegebenen Typ in einer atomaren Operation auf einen angegebenen Wert fest und gibt den ursprünglichen Wert zurück. + Der ursprüngliche Wert von . + Die Variable, die auf den angegebenen Wert festgelegt werden soll.Dies ist ein Verweisparameter (ref in C#, ByRef in Visual Basic). + Der Wert, auf den der -Parameter festgelegt ist. + Der Typ, der für und verwendet werden soll.Dieser Typ muss ein Referenztyp sein. + The address of is a null pointer. + + + Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der inkrementierte Wert. + Die Variable, deren Wert inkrementiert werden soll. + The address of is a null pointer. + 1 + + + Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation. + Der inkrementierte Wert. + Die Variable, deren Wert inkrementiert werden soll. + The address of is a null pointer. + 1 + + + Synchronisiert den Speicherzugriff wie folgt: Der Prozessor, der den aktuellen Thread ausführt, kann Anweisungen nicht so neu anordnen, dass Speicherzugriffe vor dem Aufruf von nach Speicherzugriffen ausgeführt werden, die nach dem Aufruf von erfolgen. + + + Gibt einen 64-Bit-Wert zurück, der in einer atomaren Operation geladen wird. + Der geladene Wert. + Der zu ladende 64-Bit-Wert. + 1 + + + Stellt verzögerte Initialisierungsroutinen bereit. + + + Initialisiert einen Zielverweistyp mit seinem Standardkonstruktor, wenn er noch nicht initialisiert wurde. + Der initialisierte Verweis vom Typ . + Ein Verweis vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweis- oder Werttyp mit seinem Standardkonstruktor, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Ein Verweis oder Wert vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Ein Verweis auf einen booleschen Wert, der bestimmt, ob das Ziel bereits initialisiert wurde. + Ein Verweis auf ein Objekt, das für die Initialisierung von als sich gegenseitig ausschließende Sperre verwendet wird.Wenn null ist, wird ein neues Objekt instanziiert. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweis- oder Werttyp mit einer angegebenen Funktion, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Ein Verweis oder Wert vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Ein Verweis auf einen booleschen Wert, der bestimmt, ob das Ziel bereits initialisiert wurde. + Ein Verweis auf ein Objekt, das für die Initialisierung von als sich gegenseitig ausschließende Sperre verwendet wird.Wenn null ist, wird ein neues Objekt instanziiert. + Die Funktion, die aufgerufen wird, um den Verweis oder den Wert zu initialisieren. + Der Typ des zu initialisierenden Verweises. + Berechtigungen, auf den Konstruktor des Typs zuzugreifen, haben gefehlt. + Der Typ besitzt keinen Standardkonstruktor. + + + Initialisiert einen Zielverweistyp mit einer angegebenen Funktion, wenn er noch nicht initialisiert wurde. + Der initialisierte Wert vom Typ . + Der Verweis vom Typ , der initialisiert werden soll, wenn er noch nicht initialisiert wurde. + Die Funktion, die aufgerufen wird, um den Verweis zu initialisieren. + Der Verweistyp des zu initialisierenden Verweises. + Der Typ besitzt keinen Standardkonstruktor. + + gibt null (Nothing in Visual Basic) zurück. + + + Die Ausnahme, die ausgelöst wird, wenn die rekursive Anforderung einer Sperre nicht mit der Rekursionsrichtlinie der Sperre kompatibel ist. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer vom System generierten Meldung, die den Fehler beschreibt. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Meldung, die den Fehler beschreibt. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Meldung, in der die Ausnahme beschrieben wirdDer Aufrufer dieses Konstruktors muss sicherstellen, dass diese Zeichenfolge für die aktuelle Systemkultur lokalisiert wurde. + Die Ausnahme, die die aktuelle Ausnahme verursacht hat.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + 2 + + + Gibt an, ob eine Sperre mehrmals dem gleichen Thread zugewiesen werden kann. + + + Wenn ein Thread rekursiv versucht, eine Sperre zu erhalten, wird eine Ausnahme ausgelöst.Einige Klassen gestatten gewisse Rekursionen, wenn diese Einstellung aktiv ist. + + + Ein Thread kann rekursiv eine Sperre erhalten.Einige Klassen beschränken diese Möglichkeit einer rekursiven Zuweisung. + + + Benachrichtigt einen oder mehrere wartende Threads über das Eintreten eines Ereignisses.Diese Klasse kann nicht vererbt werden. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf signalisiert festgelegt werden soll. + true, wenn der anfängliche Zustand auf signalisiert festgelegt werden soll, false, wenn der anfängliche Zustand auf nicht signalisiert festgelegt werden soll. + + + Stellt eine verschlankte Version von bereit. + + + Initialisiert eine neue Instanz der -Klasse mit dem Anfangszustand „nicht signalisiert“. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der Anfangszustand auf „signalisiert“ festgelegt werden soll. + True, um den Anfangszustand auf „signalisiert“ festzulegen, false um den Anfangszustand auf „nicht signalisiert“ festzulegen. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob der Anfangszustand auf „signalisiert“ festgelegt werden soll, und einer festgelegten Spin-Anzahl. + True, um den Anfangszustand auf "signalisiert" festzulegen, false um den Anfangszustand auf "nicht signalisiert" festzulegen. + Die Anzahl von Spin-Wartevorgängen, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + + is less than 0 or greater than the maximum allowed value. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die vom verwendeten nicht verwalteten Ressourcen und optional auch die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um nur nicht verwaltete Ressourcen freizugeben. + + + Ruft einen Wert ab, der angibt, ob das Ereignis festgelegt wurde. + True, wenn das Ereignis festgelegt wurde, andernfalls false. + + + Legt den Zustand des Ereignisses auf „nicht signalisiert“ fest, sodass Threads blockiert werden. + The object has already been disposed. + + + Legt den Zustand des Ereignisses auf „signalisiert“ fest und ermöglicht so die weitere Ausführung eines oder mehrerer wartender Threads. + + + Ruft die Anzahl von Spin-Wartevorgängen ab, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + Gibt die Anzahl von Spin-Wartevorgängen zurück, die vor dem Fallback auf einen kernelbasierten Wartevorgang stattfinden. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird. + true, wenn der festgelegt wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet und ein überwacht wird. + true, wenn der festgelegt wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle ein Signal empfängt, wobei ein überwacht wird. + Das zu überwachende . + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird, wobei ein -Wert zum Messen des Zeitintervalls verwendet wird. + true, wenn der festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blockiert den aktuellen Thread, bis das aktuelle festgelegt wird. Dabei wird ein -Wert zum Messen des Zeitintervalls verwendet und ein überwacht. + true, wenn der festgelegt wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Ruft das zugrunde liegende -Objekt für dieses ab. + Das zugrunde liegende -Ereignisobjekt für dieses . + + + Stellt einen Mechanismus bereit, der den Zugriff auf Objekte synchronisiert. + 2 + + + Erhält eine exklusive Sperre für das angegebene Objekt. + Das Objekt, für das die Monitorsperre erhalten werden soll. + Der -Parameter ist null. + 1 + + + Erhält eine exklusive Sperre für das angegebene Objekt und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, auf das gewartet werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen.Hinweis   Wenn keine Ausnahme auftritt, ist die Ausgabe dieser Methode immer true. + Die Eingabe für ist true. + Der -Parameter ist null. + + + Hebt eine exklusive Sperre für das angegebene Objekt auf. + Das Objekt, dessen Sperre aufgehoben werden soll. + Der -Parameter ist null. + Der aktuelle Thread besitzt die Sperre für das angegebene Objekt nicht. + 1 + + + Bestimmt, ob der aktuelle Thread die Sperre für das angegebene Objekt enthält. + true, wenn der aktuelle Thread die Sperre für enthält, andernfalls false. + Das zu überprüfende Objekt. + + ist null. + + + Benachrichtigt einen Thread in der Warteschlange für abzuarbeitende Threads über eine Änderung am Zustand des gesperrten Objekts. + Das Objekt, auf das ein Thread wartet. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + 1 + + + Benachrichtigt alle wartenden Threads über eine Änderung am Zustand des Objekts. + Das Objekt, das den Impuls sendet. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + 1 + + + Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Der -Parameter ist null. + 1 + + + Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + + + Versucht über eine angegebene Anzahl von Millisekunden hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Die Anzahl der Millisekunden, für die auf die Sperre gewartet werden soll. + Der -Parameter ist null. + + ist negativ und ungleich . + 1 + + + Versucht für die angegebene Anzahl von Millisekunden, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Die Anzahl der Millisekunden, für die auf die Sperre gewartet werden soll. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + + ist negativ und ungleich . + + + Versucht über einen angegebenen Zeitraum hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten. + true, wenn der aktuelle Thread die Sperre erhält, andernfalls false. + Das Objekt, für das die Sperre erhalten werden soll. + Eine , die die Zeitspanne darstellt, für die auf die Sperre gewartet werden soll.Ein Wert von -1 Millisekunde gibt eine unbegrenzte Wartezeit an. + Der -Parameter ist null. + Der Wert von in Millisekunden ist negativ und ungleich (-1 Millisekunde), oder er ist größer als . + 1 + + + Versucht für die angegebene Dauer, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. + Das Objekt, für das die Sperre erhalten werden soll. + Die Zeitspanne, für die auf die Sperre gewartet werden soll.Ein Wert von -1 Millisekunde gibt eine unbegrenzte Wartezeit an. + Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis.Die Eingabe muss false sein.Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false.Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen. + Die Eingabe für ist true. + Der -Parameter ist null. + Der Wert von in Millisekunden ist negativ und ungleich (-1 Millisekunde), oder er ist größer als . + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält. + true, wenn der Aufruf beendet wurde, weil der Aufrufer die Sperre für das angegebene Objekt erneut erhalten hat.Diese Methode wird nicht beendet, wenn die Sperre nicht erneut erhalten wird. + Das Objekt, auf das gewartet werden soll. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + 1 + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält.Wenn das angegebene Timeoutintervall abläuft, tritt der Thread in die Warteschlange für abgearbeitete Threads ein. + true, wenn die Sperre erneut erhalten wurde, bevor die angegebene Zeitspanne verstrichen ist. false, wenn die Sperre erneut erhalten wurde, nachdem die angegebene Zeitspanne verstrichen ist.Die Methode wird erst beendet, wenn die Sperre erneut erhalten wurde. + Das Objekt, auf das gewartet werden soll. + Die Anzahl von Millisekunden, die gewartet wird, bevor der Thread in die Warteschlange für abgearbeitete Threads eintritt. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + Der Wert des -Parameters ist negativ und ungleich . + 1 + + + Hebt die Sperre für ein Objekt auf und blockiert den aktuellen Thread, bis er die Sperre erneut erhält.Wenn das angegebene Timeoutintervall abläuft, tritt der Thread in die Warteschlange für abgearbeitete Threads ein. + true, wenn die Sperre erneut erhalten wurde, bevor die angegebene Zeitspanne verstrichen ist. false, wenn die Sperre erneut erhalten wurde, nachdem die angegebene Zeitspanne verstrichen ist.Die Methode wird erst beendet, wenn die Sperre erneut erhalten wurde. + Das Objekt, auf das gewartet werden soll. + Ein , der die Zeit angibt, die gewartet wird, bevor der Thread in die Warteschlange für abgearbeitete Threads eintritt. + Der -Parameter ist null. + Der aufrufende Thread besitzt keine Sperre für das angegebene Objekt. + Der Thread, der Wait aufruft, wird später im Wartezustand unterbrochen.Dieser Fall tritt ein, wenn ein anderer Thread die -Methode dieses Threads aufruft. + Der Wert des -Parameters in Millisekunden ist negativ und stellt nicht (-1 Millisekunde) dar, oder er ist größer als . + 1 + + + Ein primitiver Synchronisierungstyp, der auch für die prozessübergreifende Synchronisierung verwendet werden kann. + 1 + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaften. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll. + true, um dem aufrufenden Thread den anfänglichen Besitz des Mutex zuzuweisen, andernfalls false. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, sowie mit einer Zeichenfolge, die den Namen des Mutex darstellt. + true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false. + Der Name des .Bei einem Wert von null ist das unbenannt. + Der benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Initialisiert eine neue Instanz der -Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex sowie mit einem booleschen Wert, der beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde. + true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false. + Der Name des .Bei einem Wert von null ist das unbenannt. + Enthält nach dem Beenden dieser Methode einen booleschen Wert, der true ist, wenn ein lokaler Mutex erstellt wurde (d. h. wenn gleich null oder eine leere Zeichenfolge ist) oder wenn der angegebene benannte Systemmutex erstellt wurde. Der Wert ist false, wenn der angegebene benannte Systemmutex bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + Der benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + ist länger als 260 Zeichen. + + + Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist. + Ein Objekt, das den benannten Systemmutex darstellt. + Der Name des zu öffnenden Systemmutex. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Der benannte Mutex ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex ist vorhanden, der Benutzer verfügt jedoch nicht über den erforderlichen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Gibt das einmal frei. + Der aufrufende Thread ist nicht im Besitz des Mutex. + 1 + + + Öffnet den bestimmten benannten Mutex, wenn er bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn der benannte Mutex erfolgreich geöffnet wurde; andernfalls false. + Der Name des zu öffnenden Systemmutex. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Mutex darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Der benannte Mutex ist vorhanden, der Benutzer verfügt jedoch nicht über den erforderlichen Sicherheitszugriff, um es zu verwenden. + + + Stellt eine Sperre dar, mit der der Zugriff auf eine Ressource verwaltet wird. Mehrere Threads können hierbei Lesezugriff oder exklusiven Schreibzugriff erhalten. + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaftswerten. + + + Initialisiert eine neue Instanz der -Klasse unter Angabe der Rekursionsrichtlinie für die Sperre. + Einer der Enumerationswerte, der die Rekursionsrichtlinie für die Sperre angibt. + + + Ruft die Gesamtzahl von eindeutigen Threads ab, denen die Sperre im Lesemodus zugewiesen ist. + Die Anzahl von eindeutigen Threads, denen die Sperre im Lesemodus zugewiesen ist. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Versucht, die Sperre im Lesemodus zu erhalten. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Verringert die Rekursionszahl für den Lesemodus und beendet den Lesemodus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in read mode. + + + Verringert die Rekursionszahl für den erweiterbaren Modus und beendet den erweiterbaren Modus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in upgradeable mode. + + + Verringert die Rekursionszahl für den Schreibmodus und beendet den Schreibmodus, wenn das Rekursionsergebnis 0 (null) ist. + The current thread has not entered the lock in write mode. + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im Lesemodus zugewiesen ist. + true, wenn sich der aktuelle Thread im Lesemodus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im erweiterbaren Modus zugewiesen ist. + true, wenn sich der aktuelle Thread im erweiterbaren Modus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der angibt, ob die Sperre dem aktuellen Thread im Schreibmodus zugewiesen ist. + true, wenn sich der aktuelle Thread im Schreibmodus befindet, andernfalls false. + 2 + + + Ruft einen Wert ab, der die Rekursionsrichtlinie für das aktuelle -Objekt angibt. + Einer der Enumerationswerte, der die Rekursionsrichtlinie für die Sperre angibt. + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im Lesemodus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im Lesemodus befindet, 1, wenn sich der Thread im Lesemodus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread die Sperre n - 1 Mal rekursiv angefordert hat. + 2 + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im erweiterbaren Modus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im erweiterbaren Modus befindet, 1, wenn sich der Thread im erweiterbaren Modus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread den erweiterbaren Modus n - 1 Mal rekursiv angefordert hat. + 2 + + + Ruft einen Wert ab, der als Indikator für eine Rekursion angibt, wie oft dem aktuellen Thread die Sperre im Schreibmodus zugewiesen ist. + 0 (null), wenn sich der aktuelle Thread nicht im Schreibmodus befindet, 1, wenn sich der Thread im Schreibmodus befindet und diesen nicht rekursiv angefordert hat, oder n, wenn der Thread den Schreibmodus n - 1 Mal rekursiv angefordert hat. + 2 + + + Versucht, die Sperre im Lesemodus zu erhalten. Optional wird ein ganzzahliger Timeout berücksichtigt. + true, wenn der aufrufende Thread den Lesemodus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im Lesemodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Lesemodus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den erweiterbaren Modus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im erweiterbaren Modus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den erweiterbaren Modus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Schreibmodus erhalten hat, andernfalls false. + Die Zeit in Millisekunden, die gewartet wird, oder -1 (), um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Versucht, die Sperre im Schreibmodus zu erhalten. Optional wird ein Timeout berücksichtigt. + true, wenn der aufrufende Thread den Schreibmodus erhalten hat, andernfalls false. + Das Zeitintervall bis zum Timeout, oder -1 Millisekunden, um unbegrenzt zu warten. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im Lesemodus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des Lesemodus warten. + 2 + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im erweiterbaren Modus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des erweiterbaren Modus warten. + 2 + + + Ruft die Gesamtzahl von Threads ab, die auf eine Zuweisung der Sperre im Schreibmodus warten. + Die Gesamtzahl von Threads, die auf eine Zuweisung des Schreibmodus warten. + 2 + + + Schränkt die Anzahl von Threads ein, die gleichzeitig auf eine Ressource oder einen Pool von Ressourcen zugreifen können. + 1 + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen an. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist größer als . + + ist kleiner als 1.- oder - ist kleiner als 0. + + + Initialisiert eine neue Instanz der -Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen sowie optional den Namen eines Systemsemaphorobjekts an. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Der Name eines benannten Systemsemaphorobjekts. + + ist größer als .- oder - ist länger als 260 Zeichen. + + ist kleiner als 1.- oder - ist kleiner als 0. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Semaphor kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + + Initialisiert eine neue Instanz der -Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen sowie optional den Namen eines Systemsemaphorobjekts an, gibt eine Variable an, die einen Wert empfängt, der angibt, ob ein neues Systemsemaphor erstellt wurde. + Die ursprüngliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig ausgeführt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig ausgeführt werden können. + Der Name eines benannten Systemsemaphorobjekts. + Enthält nach dem Beenden dieser Methode den Wert true, wenn ein lokales Semaphor erstellt wurde (d. h., wenn gleich null oder eine leere Zeichenfolge ist) oder wenn das angegebene benannte Systemsemaphor erstellt wurde. Der Wert ist false, wenn das angegebene benannte Systemsemaphor bereits vorhanden war.Dieser Parameter wird nicht initialisiert übergeben. + + ist größer als . - oder - ist länger als 260 Zeichen. + + ist kleiner als 1.- oder - ist kleiner als 0. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über . + Das benannte Semaphor kann nicht erstellt werden, möglicherweise weil ein WaitHandle eines anderen Typs denselben Namen hat. + + + Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist. + Ein Objekt, das das benannte Systemsemaphor darstellt. + Der Name des zu öffnenden Systemsemaphors. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Das benannte Semaphor ist nicht vorhanden. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + 1 + + + + + + Beendet das Semaphor und gibt die vorherige Anzahl zurück. + Die Anzahl für das Semaphor vor dem Aufruf der -Methode. + Die Anzahl für das Semaphor weist bereits den maximalen Wert auf. + Bei einem benannten Semaphor ist ein Win32-Fehler aufgetreten. + Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar. Der Benutzer verfügt jedoch nicht über .- oder - Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar, es wurde jedoch nicht mit geöffnet. + 1 + + + Gibt das Semaphor eine festgelegte Anzahl von Malen frei und gibt die vorherige Anzahl zurück. + Die Anzahl für das Semaphor vor dem Aufruf der -Methode. + Die Anzahl von Malen, die das Semaphor freigegeben werden soll. + + ist kleiner als 1. + Die Anzahl für das Semaphor weist bereits den maximalen Wert auf. + Bei einem benannten Semaphor ist ein Win32-Fehler aufgetreten. + Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar. Der Benutzer verfügt jedoch nicht über -Rechte.- oder - Das aktuelle Semaphor stellt ein benanntes Systemsemaphor dar, es wurde jedoch nicht mit -Rechten geöffnet. + 1 + + + Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. + true, wenn das benannte Semaphor erfolgreich geöffnet wurde; andernfalls false. + Der Name des zu öffnenden Systemsemaphors. + Enthält nach Beenden der Methode ein -Objekt, das das benannte Semaphor darstellt, wenn der Aufruf erfolgreich ausgeführt wurde, oder null, wenn der Aufruf fehlgeschlagen ist.Dieser Parameter wird nicht initialisiert behandelt. + + ist eine leere Zeichenfolge.- oder - ist länger als 260 Zeichen. + + ist null. + Ein Win32-Fehler ist aufgetreten. + Das benannte Semaphor ist vorhanden, der Benutzer verfügt jedoch nicht über den nötigen Sicherheitszugriff, um es zu verwenden. + + + Die Ausnahme, die ausgelöst wird, wenn die -Methode für ein Semaphor aufgerufen wird, dessen Zähler bereits den Maximalwert aufweist. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Eine einfache Alternative zu , die die Anzahl der Threads beschränkt, die gleichzeitig auf eine Ressource oder einen Ressourcenpool zugreifen können. + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche Anzahl von Anforderungen an, die gleichzeitig gewährt werden können. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist kleiner als 0. + + + Initialisiert eine neue Instanz der -Klasse und gibt die ursprüngliche sowie die maximale Anzahl von Anforderungen an, die gleichzeitig gewährt werden können. + Die anfängliche Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + Die maximale Anzahl von Anforderungen für das Semaphor, die gleichzeitig gewährt werden können. + + ist kleiner als 0, oder ist größer als , oder ist kleiner gleich 0. + + + Gibt ein zurück, das verwendet werden kann um auf die Semaphore zu warten. + Ein , das verwendet werden kann um auf die Semaphore zu warten. + + wurde verworfen. + + + Ruft die Anzahl der verbleibenden Threads ab, für die das Eintreten in das -Objekt zulässig ist. + Die Anzahl der verbleibenden Threads, für die das Eintreten in das Semaphor zulässig ist. + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. + true, um sowohl verwaltete als auch nicht verwaltete Ressourcen freizugeben, false, um ausschließlich nicht verwaltete Ressourcen freizugeben. + + + Gibt das -Objekt einmal frei. + Die vorherige Anzahl von . + Die aktuelle Instanz wurde bereits freigegeben. + Der hat bereits seine maximale Größe erreicht. + + + Gibt das -Objekt eine festgelegte Anzahl von Malen frei. + Die vorherige Anzahl von . + Die Anzahl von Malen, die das Semaphor freigegeben werden soll. + Die aktuelle Instanz wurde bereits freigegeben. + + ist kleiner als 1. + Der hat bereits seine maximale Größe erreicht. + + + Blockiert den aktuellen Thread, bis er in eintreten kann. + Die aktuelle Instanz wurde bereits freigegeben. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei das Timeout mit einer 32-Bit-Ganzzahl mit Vorzeichen angegeben wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Timeouts verwendet und ein überwacht wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + wurde abgebrochen. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die Instanz wurde freigegeben, oder die erstellten freigegeben wurde. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei ein überwacht wird. + Das zu überwachende -Token. + + wurde abgebrochen. + Die aktuelle Instanz wurde bereits freigegeben.- oder - Die erstellten bereits freigegeben wurde. + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei ein zum Angeben des Timeouts verwendet wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + Die semaphoreSlim-Instanz wurde freigegeben + + + Blockiert den aktuellen Thread, bis er in die Warteschlange von eingereiht werden kann, wobei eine den Timeout angibt und ein überwacht wird. + true, wenn der aktuelle Thread erfolgreich in die Warteschlange von eingereiht wurde, andernfalls false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende . + + wurde abgebrochen. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + Die semaphoreSlim-Instanz wurde freigegebenDie , die erstellt hat, wurde bereits freigegeben. + + + Wartet asynchron auf den Eintritt in . + Eine Aufgabe, die abgeschlossen wird, wenn das Semaphor eingegeben wurde. + + + Wartet asynchron auf den Zutritt zum , wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Wartet asynchron auf den Zutritt zum , wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird, während ein beobachtet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das zu überwachende . + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Die aktuelle Instanz wurde bereits freigegeben. + + wurde abgebrochen. + + + Wartet asynchron auf den Zutritt zum , während ein ein beobachtet wird. + Eine Aufgabe, die abgeschlossen wird, wenn das Semaphor eingegeben wurde. + Das zu überwachende -Token. + Die aktuelle Instanz wurde bereits freigegeben. + + wurde abgebrochen. + + + Wartet asynchron auf den Zutritt zum unter Verwendung einer zum Messen des Zeitintervalls. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Die aktuelle Instanz wurde bereits freigegeben. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. - oder - Timeout ist größer als . + + + Wartet asynchron auf den Zutritt zum unter Verwendung einer zum Messen des Zeitintervalls, während ein beobachtet wird. + Eine Aufgabe, die mit dem Ergebnis true abgeschlossen wird, wenn der aktuelle Thread erfolgreich in gewechselt ist, andernfalls mit dem Ergebnis false. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + Das zu überwachende -Token. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an.- oder - Timeout ist größer als . + + wurde abgebrochen. + + + Stellt eine Methode dar, die aufgerufen werden muss, wenn eine Nachricht an einen Synchronisierungskontext gesendet werden soll. + Das an den Delegaten übergebene Objekt. + 2 + + + Stellt einen sich gegenseitig ausschließenden Sperrprimitiven bereit, wobei ein Thread, der versucht, die Sperre abzurufen, wiederholt in einer Schleife wartet, bis die Sperre verfügbar wird. + + + Initialisiert eine neue Instanz der -Struktur mit der Option, Thread-IDs nachzuverfolgen, um das Debuggen zu vereinfachen. + Gibt an, ob Thread-IDs zu Debugzwecken erfasst und verwendet werden. + + + Ruft die Sperre zuverlässig ab, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + Das -Argument muss vor dem Aufrufen von Enter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Hebt die Sperre auf. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread ist nicht Besitzer dieser Sperre. + + + Hebt die Sperre auf. + Ein boolescher Wert, der angibt, ob eine Arbeitsspeicherumgrenzung ausgegeben werden soll, um den Beendigungsvorgang sofort für andere Threads zu veröffentlichen. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread ist nicht Besitzer dieser Sperre. + + + Ruft einen Wert ab, der angibt, ob die Sperre zurzeit von einem Thread verwendet wird. + True, wenn die Sperre zurzeit von einem Thread verwendet wird, andernfalls false. + + + Ruft einen Wert ab, der angibt, ob die Sperre vom aktuellen Thread verwendet wird. + True, wenn die Sperre vom aktuellen Thread verwendet wird, andernfalls false. + Die Threadbesitznachverfolgung wird deaktiviert. + + + Ruft einen Wert ab, der angibt, ob die Threadbesitznachverfolgung für diese Instanz aktiviert ist. + True, wenn die Threadbesitznachverfolgung für diese Instanz aktiviert ist, andernfalls false. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Versucht, die Sperre zuverlässig abzurufen, sodass auch bei einer Ausnahme innerhalb des Methodenaufrufs zuverlässig untersucht werden kann, um zu bestimmen, ob die Sperre abgerufen wurde. + Eine -Struktur, die die Anzahl der zu wartenden Millisekunden angibt, oder eine -Struktur, die -1 Millisekunden zum unendlichen Warten angibt. + True, wenn die Sperre abgerufen wird, andernfalls false. muss vor dem Aufrufen dieser Methode mit false initialisiert werden. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als Millisekunden. + Das -Argument muss vor dem Aufrufen von TryEnter mit false initialisiert werden. + Die Threadbesitznachverfolgung wird aktiviert, und der aktuelle Thread hat diese Sperre bereits abgerufen. + + + Stellt Unterstützung für Spin-basierte Wartevorgänge bereit. + + + Ruft die Anzahl von -Aufrufen für diese Instanz ab. + Gibt eine ganze Zahl zurück, die angibt, wie häufig für diese Instanz aufgerufen wurde. + + + Ruft einen Wert ab, der angibt, ob der nächste Aufruf von den Prozessor ergibt und einen erzwungenen Kontextwechsel auslöst. + Gibt an, ob der nächste Aufruf von den Prozessor ergibt und einen erzwungenen Kontextwechsel auslöst. + + + Setzt die Spin-Anzahl zurück. + + + Führt einen Spin-Vorgang aus. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Das -Argument ist Null. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird oder das angegebene Timeout abgelaufen ist. + True, wenn die Bedingung innerhalb des Timeouts erfüllt wird, andernfalls false. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Die Anzahl von Millisekunden, die gewartet wird, oder (-1) für Warten ohne Timeout. + Das -Argument ist Null. + + ist eine negative Zahl, aber nicht -1. Der Wert -1 gibt einen Endlostimeout an. + + + Führt Spin-Vorgänge aus, bis die angegebene Bedingung erfüllt wird oder das angegebene Timeout abgelaufen ist. + True, wenn die Bedingung innerhalb des Timeouts erfüllt wird, andernfalls false. + Ein Delegat, der immer wieder ausgeführt wird, bis true zurückgegeben wird. + Ein , das die Wartezeit in Millisekunden darstellt, oder ein TimeSpan-Wert, der -1 Millisekunden für Warten ohne Timeout darstellt. + Das -Argument ist Null. + + ist eine negative Zahl ungleich -1 Millisekunden, die ein unendliches Timeout darstellt, - oder - Timeout ist größer als . + + + Stellt die Grundfunktionen für die Weitergabe eines Synchronisierungskontexts in unterschiedlichen Synchronisierungsmodellen bereit. + 2 + + + Erstellt eine neue Instanz der -Klasse. + + + Erstellt beim Überschreiben in einer abgeleiteten Klasse eine Kopie des Synchronisierungskontexts. + Ein neues -Objekt. + 2 + + + Ruft den Synchronisierungskontext für den aktuellen Thread ab. + Ein -Objekt, das den aktuellen Synchronisierungskontext darstellt. + 1 + + + Antwortet beim Überschreiben in einer abgeleiteten Klasse auf die Benachrichtigung, dass ein Vorgang abgeschlossen wurde. + + + Antwortet beim Überschreiben in einer abgeleiteten Klasse auf die Benachrichtigung, dass ein Vorgang gestartet wurde. + + + Sendet beim Überschreiben in einer abgeleiteten Klasse eine asynchrone Meldung an einen Synchronisierungskontext. + Der aufzurufende -Delegat. + Das an den Delegaten übergebene Objekt. + 2 + + + Sendet beim Überschreiben in einer abgeleiteten Klasse eine synchrone Meldung an einen Synchronisierungskontext. + Der aufzurufende -Delegat. + Das an den Delegaten übergebene Objekt. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Legt den aktuellen Synchronisierungskontext fest. + Das festzulegende -Objekt. + 1 + + + + + + Die Ausnahme, die ausgelöst wird, wenn der Aufrufer für eine Methode über eine Sperre für einen bestimmten Monitor verfügen muss und die Methode von einem Aufrufer aufgerufen wird, der nicht über diese Sperre verfügt. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardeigenschaften. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + Stellt einen lokalen Datenspeicher eines Threads bereit. + Gibt den für jeden Thread gespeicherten Datentyp an. + + + Initialisiert die -Instanz. + + + Initialisiert die -Instanz. + Ob alle Werte, die für die Instanz festgelegt werden, verfolgt werden und über die -Eigenschaft verfügbar gemacht sollen. + + + Initialisiert die -Instanz mit der angegebenen -Funktion. + Das , das aufgerufen wird, um einen verzögert initialisierten Wert zu erzeugen, wenn versucht wird, ohne vorherige Initialisierung abzurufen. + + ist ein NULL-Verweis (Nothing in Visual Basic). + + + Initialisiert die -Instanz mit der angegebenen -Funktion. + Das , das aufgerufen wird, um einen verzögert initialisierten Wert zu erzeugen, wenn versucht wird, ohne vorherige Initialisierung abzurufen. + Ob alle Werte, die für die Instanz festgelegt werden, verfolgt werden und über die -Eigenschaft verfügbar gemacht sollen. + + ist ein null-Verweis (Nothing in Visual Basic). + + + Gibt alle von der aktuellen Instanz der -Klasse verwendeten Ressourcen frei. + + + Gibt die von dieser -Instanz verwendeten Ressourcen frei. + Ein boolescher Wert, der angibt, ob diese Methode aufgrund eines Aufrufs von aufgerufen wird. + + + Gibt die von dieser -Instanz verwendeten Ressourcen frei. + + + Ruft einen Wert ab, der angibt, ob für den aktuellen Thread initialisiert wurde. + True, wenn erfolgreich im aktuellen Thread initialisiert wurde, andernfalls false. + Die -Instanz wurde freigegeben. + + + Erstellt eine Zeichenfolgendarstellung dieser Instanz für den aktuellen Thread und gibt sie zurück. + Das Ergebnis des Aufrufs von für . + Die -Instanz wurde freigegeben. + Der für den aktuellen Thread ist ein NULL-Verweis (Nothing in Visual Basic). + Die Initialisierungsfunktion versuchte, auf rekursiv zu verweisen. + Kein Standardkonstruktor wird bereitgestellt, und keine Wertfactory wird angegeben. + + + Ruft den Wert dieser Instanz für den aktuellen Thread ab oder legt ihn fest. + Gibt eine Instanz des Objekts zurück, für dessen Initialisierung dieser ThreadLocal zuständig ist. + Die -Instanz wurde freigegeben. + Die Initialisierungsfunktion versuchte, auf rekursiv zu verweisen. + Kein Standardkonstruktor wird bereitgestellt, und keine Wertfactory wird angegeben. + + + Ruft eine Liste aller Werte ab, die aktuell von allen Threads, die auf diese Instanz zugegriffen haben, gespeichert werden. + Eine Liste aller Werte, die aktuell von allen Threads, die auf diese Instanz zugegriffen haben, gespeichert sind. + Die -Instanz wurde freigegeben. + + + Enthält Methoden für die Durchführung von Vorgängen für flüchtigen Speicher. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Wert des angegebenen Felds.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der gelesene Wert.Dieser Wert entspricht dem letzten von einem Prozessor im Computer geschriebenen Wert, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + + + Liest den Objektverweis aus dem angegebenen Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn nach dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht vor diese Methode verschoben werden. + Der Verweis auf , der gelesen wurde.Dieser Verweis entspricht dem letzten von einem Prozessor im Computer geschriebenen Verweis, unabhängig von der Anzahl der Prozessoren und dem Zustand des Prozessorcaches. + Das zu lesende Feld. + Der Typ des zu lesenden Felds.Dabei muss es sich um einen Verweistyp und keinen Werttyp handeln. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Arbeitsspeichervorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Wert in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Wert geschrieben wird. + Der zu schreibende Wert.Der Wert wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + + + Schreibt den angegebenen Objektverweis in das angegebene Feld.Auf Systemen, auf denen dies erforderlich ist, wird eine Arbeitsspeicherbarriere eingefügt, die verhindert, dass der Prozessor Arbeitsspeichervorgänge wie folgt neu anordnet: Wenn vor dieser Methode im Code ein Lese- oder Schreibvorgang ausgeführt wird, kann dieser vom Prozessor nicht hinter diese Methode verschoben werden. + Das Feld, in das der Objektverweis geschrieben wird. + Der zu schreibende Objektverweis.Der Verweis wird sofort geschrieben, sodass er für alle Prozessoren im Computer sichtbar ist. + Der Typ des zu schreibenden Felds.Dabei muss es sich um einen Verweistyp und keinen Werttyp handeln. + + + Die Ausnahme, die ausgelöst wird, wenn versucht wird, einen nicht vorhandenen Systemmutex oder ein nicht vorhandenes Semaphor zu öffnen. + 2 + + + Initialisiert eine neue Instanz der -Klasse mit Standardwerten. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + + + Initialisiert eine neue Instanz der -Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat. + Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird. + Die Ausnahme, die die Ursache der aktuellen Ausnahme ist.Wenn der -Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/es/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/es/System.Threading.xml new file mode 100644 index 000000000..3431de9eb --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/es/System.Threading.xml @@ -0,0 +1,1803 @@ + + + + System.Threading + + + + Excepción que se produce cuando un subproceso adquiere un objeto que otro subproceso ha abandonado al salir sin liberarlo. + 1 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con un índice especificado para la exclusión mutua abandonada, si es aplicable, y un objeto que representa la exclusión mutua. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con un mensaje de error y una excepción interna especificados. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado, la excepción interna, el índice para la exclusión mutua abandonada, si es aplicable, y un objeto que representa la exclusión mutua. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado, el índice de la exclusión mutua abandonada, si es aplicable, y la exclusión mutua abandonada. + Mensaje de error que explica la razón de la excepción. + Índice de la exclusión mutua abandonada en la matriz de identificadores de espera si la excepción se produce para el método , o –1 si la excepción se produce para los métodos o . + Objeto que representa la exclusión mutua abandonada. + + + Obtiene la exclusión mutua abandonada que produjo la excepción, si se conoce. + Objeto que representa la exclusión mutua abandonada o null si no se han podido identificar las exclusiones mutuas abandonadas. + 1 + + + Obtiene el índice de la exclusión mutua abandonada que produjo la excepción, si se conoce. + Índice, en la matriz de identificadores de espera que se ha pasado al método , del objeto que representa la exclusión mutua abandonada, o –1 si no se puede determinar el índice de la exclusión mutua abandonada. + 1 + + + Representa datos ambiente locales de un flujo de control asincrónico determinado, por ejemplo, un método asincrónico. + Tipo de los datos ambiente. + + + Crea una instancia que no recibe las notificaciones de cambio. + + + Crea una instancia local que recibe notificaciones de cambio. + Delegado al que se llama cuando cambia el valor actual en cualquier subproceso. + + + Obtiene o establece el valor de los datos ambiente. + Valor de los datos ambiente. + + + Clase que proporciona información de cambio de datos a las instancias que se registran para las notificaciones de cambios. + Tipo de los datos. + + + Obtiene el valor actual de los datos. + Valor actual de los datos. + + + Obtiene el valor anterior de los datos. + Valor anterior de los datos. + + + Devuelve un valor que indica si el valor cambia debido a un cambio de contexto de ejecución. + true si el valor cambió debido a un cambio de contexto de ejecución; de lo contrario, false. + + + Notifica que se ha producido un evento a un subproceso en espera.Esta clase no puede heredarse. + 2 + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + true para establecer el estado inicial en señalado; false para establecer el estado inicial en no señalado. + + + Habilita varias tareas para que cooperen en un algoritmo en paralelo a través de varias fases. + + + Inicializa una nueva instancia de la clase . + Número de subprocesos que participan. + + es menor que 0 o mayor que 32,767. + + + Inicializa una nueva instancia de la clase . + Número de subprocesos que participan. + + que se ejecutará después de cada fase. null (Nothing en Visual Basic) se puede pasar para indicar que no se realiza ninguna acción. + + es menor que 0 o mayor que 32,767. + + + Notifica a que va a haber un participante adicional. + Número de fase de la barrera en la que primero participarán los nuevos participantes. + La instancia actual ya se ha eliminado. + Agregar un participante haría que el recuento de participantes de la barrera superase los 32.767.O bienEl método se invocó desde dentro de una acción posterior a la fase. + + + Notifica a que va a haber participantes adicionales. + Número de fase de la barrera en la que primero participarán los nuevos participantes. + Número de participantes adicionales que se van a agregar a la barrera. + La instancia actual ya se ha eliminado. + + es menor que 0.O bienAgregar haría que el recuento de participantes de la barrera superase los 32.767. + El método se invocó desde dentro de una acción posterior a la fase. + + + Obtiene el número de la fase actual de la barrera. + Devuelve el número de la fase actual de la barrera. + + + Libera todos los recursos usados por la instancia actual de la clase . + El método se invocó desde dentro de una acción posterior a la fase. + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto los recursos administrados como los no administrados; es false para liberar únicamente los recursos no administrados. + + + Obtiene el número total de participantes de la barrera. + Devuelve el número total de participantes de la barrera. + + + Obtiene el número de participantes de la barrera que no aún no se han señalado en la fase actual. + Devuelve el número de participantes de la barrera que no aún no se han señalado en la fase actual. + + + Notifica a que va a haber un participante menos. + La instancia actual ya se ha eliminado. + La barrera ya tiene 0 participantes.O bienEl método se invocó desde dentro de una acción posterior a la fase. + + + Notifica a que va a haber menos participantes. + Número de participantes adicionales que se van a quitar de la barrera. + La instancia actual ya se ha eliminado. + + es menor que 0. + La barrera ya tiene 0 participantes.O bienEl método se invocó desde dentro de una acción posterior a la fase. O bienel recuento del participante actual es menor que el participantCount especificado + El recuento del participante total es menor que el especificado + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera. + La instancia actual ya se ha eliminado. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + Si una excepción se produce de la acción de fase de envío de una barrera después de todos los subprocesos hayan llamado a SignalAndWait, la excepción se ajustará en una BarrierPostPhaseException y se producirá en todos los subprocesos que participan. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera usando un entero de 32 bits con signo para medir el tiempo de espera. + si todos los participantes alcanzaron la barrera dentro del tiempo especificado; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + Si una excepción se produce de la acción de fase de envío de una barrera después de todos los subprocesos hayan llamado a SignalAndWait, la excepción se ajustará en una BarrierPostPhaseException y se producirá en todos los subprocesos que participan. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes la alcancen también usando un entero de 32 bits con signo para medir el tiempo de espera mientras se observa un token de cancelación. + si todos los participantes alcanzaron la barrera dentro del tiempo especificado; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen la barrera mientras se observa un token de cancelación. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes alcancen también la barrera usando un objeto para medir el intervalo de tiempo. + Es true si todos los demás participantes alcanzaron la barrera; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o es mayor de 32.767. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Señala que un participante ha alcanzado la barrera y espera a que todos los demás participantes la alcancen también usando un objeto para medir el intervalo de tiempo, mientras se observa un token de cancelación. + Es true si todos los demás participantes alcanzaron la barrera; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo que representa un tiempo de espera infinito. + El método se invocó desde dentro de una acción posterior a la fase, la barrera tiene actualmente 0 participantes, o la barrera la señalan más subprocesos de los que están registrados como participantes. + + + Excepción que se inicia cuando se produce un error en la acción posterior a la fase de + + + Inicializa una nueva instancia de la clase con un mensaje proporcionado por el sistema que describe el error. + + + Inicializa una nueva instancia de la clase con la excepción interna especificada. + La excepción que es la causa de la excepción actual. + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado que describe el error. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que esta cadena se ha traducido para la actual referencia cultural del sistema. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Representa un método al que se va a llamar dentro de un nuevo contexto. + Objeto que contiene la información que va a utilizar el método de devolución de llamadas cada vez que se ejecute. + 1 + + + Representa una primitiva de sincronización que está señalada cuando su recuento alcanza el valor cero. + + + Inicializa una nueva instancia de la clase con el recuento especificado. + Número de señales necesarias inicialmente para establecer . + + es menor que 0. + + + Incrementa en uno el recuento actual de . + La instancia actual ya se ha eliminado. + La instancia actual ya está establecida.O bien es mayor o igual que . + + + Incrementa en un valor especificado el recuento actual de . + Valor en que se va a aumentar . + La instancia actual ya se ha eliminado. + + es menor o igual que 0. + La instancia actual ya está establecida.O bien es igual o mayor que después de incrementar la cuenta en + + + Obtiene el número de señales restantes necesario para establecer el evento. + El número de señales restantes necesario para establecer el evento. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto los recursos administrados como los no administrados; es false para liberar únicamente los recursos no administrados. + + + Obtiene los números de señales que se necesitan inicialmente para establecer el evento. + El número de señales que se necesitan inicialmente para establecer el evento. + + + Determina si se establece el evento. + Es true si se establece el evento; de lo contrario, es false. + + + Restablece en el valor de . + La instancia actual ya se ha eliminado. + + + Restablece la propiedad según un valor especificado. + Número de señales necesario para establecer . + La instancia actual ya se ha eliminado. + El valor de es menor que 0. + + + Registra una señal con y disminuye el valor de . + Es true si la señal hizo que el recuento alcanzara el valor cero y se estableció el evento; de lo contrario, falso. + La instancia actual ya se ha eliminado. + La instancia actual ya está establecida. + + + Registra varias señales con reduciendo el valor de según la cantidad especificada. + Es true si las señales hicieron que el recuento alcanzara el valor cero y se estableció el evento; de lo contrario, falso. + Número de señales que se va a registrar. + La instancia actual ya se ha eliminado. + + es menor que 1. + La instancia actual ya está establecida. -o bien- es mayor que . + + + Intenta incrementar en uno. + Es true si el incremento se realizó correctamente; en caso contrario, es false.Si ya está en el valor cero, este método devolverá false. + La instancia actual ya se ha eliminado. + + es igual a . + + + Intenta incrementar en un valor especificado. + Es true si el incremento se realizó correctamente; en caso contrario, es false.Si ya está en el valor cero, se devolverá false. + Valor en que se va a aumentar . + La instancia actual ya se ha eliminado. + + es menor o igual que 0. + La instancia actual ya está establecida.O bien + es igual o mayor que . + + + Bloquea el subproceso actual hasta que se establezca el objeto . + La instancia actual ya se ha eliminado. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un entero de 32 bits con signo para medir el tiempo de espera. + Es true si se estableció el objeto ; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un entero de 32 bits con signo para medir el tiempo de espera, mientras se observa un token . + Es true si se estableció el objeto ; de lo contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que se establezca el objeto , mientras se observa un token . + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un objeto para medir el tiempo de espera. + Es true si se estableció el objeto ; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Bloquea el subproceso actual hasta que se establezca el objeto , usando un objeto para medir el tiempo de espera, mientras se observa un token . + Es true si se estableció el objeto ; de lo contrario, es false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + Se ha cancelado . + La instancia actual ya se ha eliminado. o bien, que creó sido eliminado. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Obtiene un objeto que se usa para esperar a que se establezca el evento. + Objeto que se usa para esperar a que se establezca el evento. + La instancia actual ya se ha eliminado. + + + Indica si un objeto se restablece automática o manualmente después de recibir una señal. + 2 + + + El objeto , cuando está señalado, se restablece automáticamente después de haber liberado un único subproceso.Si hay ningún subproceso en espera, el objeto permanece señalado hasta que un subproceso se bloquea y se restablece después de haber liberado el subproceso. + + + El objeto , cuando está señalado, libera todos los subprocesos en espera y permanece señalado hasta que se restablece manualmente. + + + Representa un evento de sincronización de subprocesos. + 2 + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente y si se restablece automática o manualmente. + Es true para establecer el estado inicial en señalado; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente y el nombre de un evento de sincronización del sistema. + Es true para establecer el estado inicial en señalado si el evento con nombre se crea como resultado de esta llamada; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + Nombre de un evento de sincronización para todo el sistema. + Se ha producido un error de Win32. + El evento con nombre existe y tiene seguridad de control de acceso, pero el usuario carece de . + No se puede crear el evento con nombre, quizás porque un identificador de espera de un tipo diferente tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Inicializa una nueva instancia de la clase , especificando si el identificador de espera se señala inicialmente cuando se crea como resultado de esta llamada, si se restablece automática o manualmente, el nombre de un evento de sincronización del sistema y una variable booleana cuyo valor después de la llamada indica si se ha creado el evento del sistema con nombre. + Es true para establecer el estado inicial en señalado si el evento con nombre se crea como resultado de esta llamada; es false para establecerlo en no señalado. + Uno de los valores de que determina si el evento se restablece de forma automática o manual. + Nombre de un evento de sincronización para todo el sistema. + Cuando este método devuelve un resultado, contiene true si se ha creado un evento local (es decir, si es null o una cadena vacía) o si se ha creado el evento del sistema con nombre especificado; es false si el evento del sistema con nombre especificado ya existía.Este parámetro se pasa sin inicializar. + Se ha producido un error de Win32. + El evento con nombre existe y tiene seguridad de control de acceso, pero el usuario carece de . + No se puede crear el evento con nombre, quizás porque un identificador de espera de un tipo diferente tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Abre el evento de sincronización con nombre especificado, si ya existe. + Un objeto que representa el evento del sistema con nombre. + Nombre del evento de sincronización que se va a abrir. + + es una cadena vacía. O bien tiene más de 260 caracteres. + + es null. + El evento del sistema con nombre no existe. + Se ha producido un error de Win32. + El evento con nombre existe, pero el usuario no tiene el acceso de seguridad exigido para utilizarlo. + 1 + + + + + + Establece el estado del evento en no señalado, haciendo que los subprocesos se bloqueen. + true si la operación se realiza correctamente; en caso contrario, false. + No se ha llamado previamente al método en este . + 2 + + + Establece el estado del evento en señalado, permitiendo que uno o varios subprocesos en espera continúen. + true si la operación se realiza correctamente; en caso contrario, false. + No se ha llamado previamente al método en este . + 2 + + + Abre el evento de sincronización con nombre especificado, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si el evento de sincronización con nombre se abrió correctamente; si no, false. + Nombre del evento de sincronización que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa el evento de sincronización con nombre si la llamada se realizó correctamente, o null si se produjo un error en la llamada.Este parámetro se trata como sin inicializar. + + es una cadena vacía.O bien tiene más de 260 caracteres. + + es null. + Se ha producido un error de Win32. + El evento con nombre existe, pero el usuario no tiene el acceso de seguridad deseado. + + + Administra el contexto de ejecución del subproceso actual.Esta clase no puede heredarse. + 2 + + + Captura el contexto de ejecución del subproceso actual. + Objeto que representa el contexto de ejecución del subproceso actual. + 1 + + + Ejecuta un método en un contexto de ejecución especificado en el subproceso actual. + Contexto de ejecución que se va a establecer. + Delegado que representa el método que se va a ejecutar en el contexto de ejecución proporcionado. + Objeto que se pasa al método de devolución de llamada. + + es null.O bien no se adquirió a través de una operación de captura. O bien ya se ha utilizado como argumento de una llamada a . + 1 + + + + + + Proporciona operaciones atómicas para las variables compartidas por varios subprocesos. + 2 + + + Agrega dos enteros de 32 bits y reemplaza el primer entero por la suma, como una operación atómica. + Nuevo valor almacenado en . + Variable que contiene el primer valor que se va a agregar.La suma de los dos valores se almacena en . + Valor que se va a agregar al entero en . + The address of is a null pointer. + 1 + + + Agrega dos enteros de 64 bits y reemplaza el primer entero por la suma, como una operación atómica. + Nuevo valor almacenado en . + Variable que contiene el primer valor que se va a agregar.La suma de los dos valores se almacena en . + Valor que se va a agregar al entero en . + The address of is a null pointer. + 1 + + + Compara dos números de punto flotante de precisión doble para comprobar si son iguales y, si lo son, reemplaza el primero de los valores. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos enteros de 32 bits con signo para comprobar si son iguales y, si lo son, reemplaza el primer valor. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos enteros de 64 bits con signo para comprobar si son iguales y, si lo son, reemplaza el primer valor. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos identificadores o punteros específicos de plataforma para comprobar si son iguales y, si lo son, reemplaza el primero. + Valor original de . + Estructura de destino, cuyo valor se compara con el valor de y que posiblemente se reemplace por . + Estructura que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Estructura que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos objetos para comprobar si sus referencias son iguales y, si lo son, reemplaza el primero de los objetos. + Valor original de . + Objeto de destino que se compara con y que posiblemente se reemplace. + Objeto que reemplaza el objeto de destino si la comparación da como resultado la igualdad de ambos parámetros. + Objeto que se compara con el objeto que hay en . + The address of is a null pointer. + 1 + + + Compara dos números de punto flotante de precisión sencilla para comprobar si son iguales y, si lo son, reemplaza el primero de los valores. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace. + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + The address of is a null pointer. + 1 + + + Compara dos instancias del tipo de referencia especificado para comprobar si son iguales y, si lo son, reemplaza la primera. + Valor original de . + Destino, cuyo valor se compara con y que posiblemente se reemplace.Este es un parámetro de referencia (ref en C#, ByRef en Visual Basic). + Valor que reemplaza el valor de destino si la comparación da como resultado una igualdad. + Valor que se compara con el valor que hay en . + Tipo que se va a utilizar para , y .Este tipo debe ser un tipo de referencia. + The address of is a null pointer. + + + Disminuye el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor reducido. + Variable cuyo valor se va a reducir. + The address of is a null pointer. + 1 + + + Disminuye el valor de la variable especificada y almacena el resultado, como una operación atómica. + Valor reducido. + Variable cuyo valor se va a reducir. + The address of is a null pointer. + 1 + + + Establece un número de punto flotante de precisión doble en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un entero de 32 bits con signo en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un entero de 64 bits con signo en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un puntero o identificador específico de plataforma en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un objeto en un valor especificado y devuelve una referencia al objeto original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece un número de punto flotante de precisión sencilla en un valor especificado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado. + Valor en el que está establecido el parámetro . + The address of is a null pointer. + 1 + + + Establece una variable del tipo especificado en un valor determinado y devuelve el valor original, como una operación atómica. + Valor original de . + Variable que se va a establecer en el valor especificado.Este es un parámetro de referencia (ref en C#, ByRef en Visual Basic). + Valor en el que está establecido el parámetro . + Tipo que se va a utilizar para y .Este tipo debe ser un tipo de referencia. + The address of is a null pointer. + + + Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor incrementado. + Variable cuyo valor se va a incrementar. + The address of is a null pointer. + 1 + + + Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica. + Valor incrementado. + Variable cuyo valor se va a incrementar. + The address of is a null pointer. + 1 + + + Sincroniza el acceso a la memoria de la siguiente forma: el procesador que ejecuta el subproceso actual no puede reordenar instrucciones de forma que los accesos a la memoria anteriores a la llamada a se ejecuten después de los accesos a memoria que siguen a la llamada a . + + + Devuelve un valor de 64 bits, cargado como una operación atómica. + Valor cargado. + Valor de 64 bits que se va a cargar. + 1 + + + Proporciona rutinas de inicialización diferida. + + + Inicializa un tipo de referencia de destino con su constructor predeterminado si aún no se ha inicializado el destino. + Referencia de tipo que se ha inicializado. + Referencia de tipo que se va a inicializar si aún no se ha inicializado. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino o tipo de valor con su constructor predeterminado si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia o valor de tipo que se va a inicializar si aún no se ha inicializado. + Referencia a un valor booleano que determina si ya se ha inicializado el destino. + Referencia a un objeto que se usa como bloqueo mutuamente excluyente para la inicialización de .Si es null, se creará una instancia de un nuevo objeto. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino o tipo de valor utilizando la función especificada si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia o valor de tipo que se va a inicializar si aún no se ha inicializado. + Referencia a un valor booleano que determina si ya se ha inicializado el destino. + Referencia a un objeto que se usa como bloqueo mutuamente excluyente para la inicialización de .Si es null, se creará una instancia de un nuevo objeto. + Función que se llama para inicializar la referencia o el valor. + Tipo de referencia que se va a inicializar. + Faltaban los permisos para tener acceso al constructor de tipo . + El tipo no contiene un constructor predeterminado. + + + Inicializa un tipo de referencia de destino utilizando la función especificada si aún no se ha inicializado. + Valor inicializado de tipo . + Referencia de tipo que se va a inicializar si aún no se ha inicializado. + Función que se llama para inicializar la referencia. + Tipo de referencia que se va a inicializar. + El tipo no contiene un constructor predeterminado. + + devuelve un valor NULL (Nothing en Visual Basic). + + + Excepción que se inicia cuando la entrada recursiva en un bloqueo no es compatible con la directiva de recursividad del bloqueo. + 2 + + + Inicializa una nueva instancia de la clase con un mensaje proporcionado por el sistema que describe el error. + 2 + + + Inicializa una nueva instancia de la clase con un mensaje de error especificado que describe el error. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que la cadena se ha traducido para la referencia cultural actual del sistema. + 2 + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje que describe la excepción.El llamador de este constructor debe asegurarse de que la cadena se ha traducido para la referencia cultural actual del sistema. + Excepción que ha producido la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + 2 + + + Especifica si el mismo subproceso puede entrar varias veces en un bloqueo. + + + Si un subproceso intenta entrar en un bloqueo de forma recursiva, se inicia una excepción.Algunas clases pueden permitir cierta recursividad cuando se aplica esta configuración. + + + Un subproceso puede entrar en un bloqueo de forma recursiva.Algunas clases pueden limitar esta posibilidad. + + + Notifica que se ha producido un evento a uno o varios subprocesos en espera.Esta clase no puede heredarse. + 2 + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + true para establecer el estado inicial de señalado; false para establecer el estado inicial en no señalado. + + + Proporciona una versión reducida de . + + + Inicializa una nueva instancia de la clase con el estado inicial establecido en no señalado. + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado. + Es true para establecer el estado inicial en señalado; es false para establecer el estado inicial en no señalado. + + + Inicializa una instancia de la clase con un valor booleano que indica si hay que establecer el estado inicial en señalado y con el recuento circular especificado. + Es true para establecer el estado inicial en señalado; es false para establecer el estado inicial en no señalado. + Número de esperas circulares que se van a producir antes de una operación de espera basada en kernel. + + is less than 0 or greater than the maximum allowed value. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados que usa el objeto y, de forma opcional, libera los recursos administrados. + true para liberar tanto los recursos administrados como los no administrados; false para liberar únicamente los recursos no administrados. + + + Obtiene un valor que indica si se ha establecido el evento. + Es true si se ha establecido el evento; de lo contrario, es false. + + + Establece el estado del evento en no señalado, por lo que se bloquean los subprocesos. + The object has already been disposed. + + + Establece el estado del evento en señalado, lo que permite la continuación de uno o varios subprocesos que están esperando en el evento. + + + Obtiene el número de esperas circulares que se producirán antes de una operación de espera basada en kernel. + Devuelve el número de esperas circulares que se producirán antes de una operación de espera basada en kernel. + + + Bloquea el subproceso actual hasta que se establezca el objeto actual. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, usando un entero de 32 bits con signo para medir el intervalo de tiempo. + Es true si se estableció ; en caso contrario, es false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, usando un entero de 32 bits con signo para medir el intervalo de tiempo, mientras se observa un token . + true si se estableció ; en caso contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Bloquea el subproceso actual hasta que el actual reciba una señal, mientras se observa un token . + + que se va a observar. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Bloquea el subproceso actual hasta que se establezca el actual, utilizando un objeto para medir el intervalo de tiempo. + true si se estableció ; en caso contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloquea el subproceso actual hasta que se establezca el , usando un objeto para medir el intervalo de tiempo, mientras se observa un token . + true si se estableció ; en caso contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Obtiene el objeto para este . + Objeto de evento subyacente de este . + + + Proporciona un mecanismo que sincroniza el acceso a los objetos. + 2 + + + Adquiere un bloqueo exclusivo en el objeto especificado. + Objeto en el que se va a adquirir el bloqueo de monitor. + El parámetro es null. + 1 + + + Adquiere un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a esperar. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo.Nota   Si no se produce ninguna excepción, el resultado de este método siempre es true. + La entrada es true. + El parámetro es null. + + + Libera un bloqueo exclusivo en el objeto especificado. + Objeto en el que se va a liberar el bloqueo. + El parámetro es null. + El subproceso actual no posee el bloqueo para el objeto especificado. + 1 + + + Determina si el subproceso actual mantiene el bloqueo en el objeto especificado. + Es true si el subproceso actual mantiene el bloqueo en ; en caso contrario, es false. + Objeto que se va a probar. + El valor de es null. + + + Notifica un cambio de estado del objeto bloqueado al subproceso que se encuentra en la cola de espera. + Objeto que está esperando un subproceso. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + 1 + + + Notifica un cambio de estado del objeto a todos los subprocesos que se encuentran en espera. + Objeto que envía el pulso. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + 1 + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + El parámetro es null. + 1 + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado durante el número de segundos especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + Número de milisegundos durante los que se va a esperar para adquirir el bloqueo. + El parámetro es null. + + es negativo y no es igual a . + 1 + + + Intenta, durante el número especificado de milisegundos, adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Número de milisegundos durante los que se va a esperar para adquirir el bloqueo. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + + es negativo y no es igual a . + + + Intenta adquirir un bloqueo exclusivo en el objeto especificado durante el período de tiempo especificado. + Es true si el subproceso actual adquiere el bloqueo; en caso contrario, es false. + Objeto en el que se va a adquirir el bloqueo. + + que representa el período de tiempo que se va a esperar para adquirir el bloqueo.Un valor de –1 milisegundo especifica una espera infinita. + El parámetro es null. + El valor de en milisegundos es negativo y no es igual a (– 1 milisegundo), o es mayor que . + 1 + + + Intenta, durante el periodo de tiempo indicado, adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se realizó el bloqueo. + Objeto en el que se va a adquirir el bloqueo. + Tiempo que se va a esperar el bloqueo.Un valor de –1 milisegundo especifica una espera infinita. + Resultado del intento de adquirir el bloqueo, pasado por referencia.La entrada debe ser false.El resultado es true si se adquiere el bloqueo; en caso contrario, el resultado es false.El resultado se establece aunque se produzca una excepción durante el intento de adquirir el bloqueo. + La entrada es true. + El parámetro es null. + El valor de en milisegundos es negativo y no es igual a (– 1 milisegundo), o es mayor que . + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo. + Es true si la llamada fue devuelta porque el llamador volvió a adquirir el bloqueo para el objeto especificado.Este método no devuelve ningún resultado si el bloqueo no vuelve a adquirirse. + Objeto en el que se va a esperar. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + 1 + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo.Si transcurre el intervalo de tiempo de espera especificado, el subproceso entra en la cola de subprocesos listos. + Es true si se volvió a adquirir el bloqueo antes de que transcurriera el período de tiempo especificado; es false si se volvió a adquirir el bloqueo después de que transcurriera el período de tiempo especificado.El método no devuelve ningún resultado hasta que se vuelva a adquirir el bloqueo. + Objeto en el que se va a esperar. + Número de milisegundos que se va a estar a la espera antes de que el subproceso entre en la cola de subprocesos listos. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + El valor de la parámetro es negativo y no es igual a . + 1 + + + Libera el bloqueo en un objeto y bloquea el subproceso actual hasta que vuelve a adquirir el bloqueo.Si transcurre el intervalo de tiempo de espera especificado, el subproceso entra en la cola de subprocesos listos. + Es true si se volvió a adquirir el bloqueo antes de que transcurriera el período de tiempo especificado; es false si se volvió a adquirir el bloqueo después de que transcurriera el período de tiempo especificado.El método no devuelve ningún resultado hasta que se vuelva a adquirir el bloqueo. + Objeto en el que se va a esperar. + + que representa la cantidad de tiempo que se va a esperar antes de que el subproceso entre en la cola de subprocesos listos. + El parámetro es null. + El subproceso que realiza la llamada no posee el bloqueo del objeto especificado. + El subproceso que invoca Wait se interrumpe más adelante desde el estado de espera.Esto sucede cuando otro subproceso llame a este subproceso método. + El valor de la parámetro en milisegundos es negativo y no representa (– 1 milisegundo), o es mayor que . + 1 + + + Primitiva de sincronización que puede usarse también para la sincronización entre procesos. + 1 + + + Inicializa una nueva instancia de la clase con propiedades predeterminadas. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua. + true para otorgar la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada, de lo contrario, false. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua y una cadena que representa el nombre de la exclusión mutua. + true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false. + Nombre del objeto .Si el valor es null, no tiene nombre. + La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene . + Se ha producido un error de Win32. + No se puede crear la exclusión mutua con nombre; posiblemente porque un identificador de espera de otro tipo tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Inicializa una nueva instancia de la clase con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua, una cadena que es el nombre de la exclusión mutua y un valor booleano que, cuando se devuelva el método, indicará si se concedió la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada. + true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false. + Nombre del objeto .Si el valor es null, no tiene nombre. + Cuando se devuelve este método, contiene un valor booleano que es true si se creó una exclusión mutua local (es decir, si es null o una cadena vacía) o si se creó la exclusión mutua del sistema con nombre especificada; el valor es false si la exclusión mutua del sistema con nombre especificada ya existía.Este parámetro se pasa sin inicializar. + La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene . + Se ha producido un error de Win32. + No se puede crear la exclusión mutua con nombre; posiblemente porque un identificador de espera de otro tipo tiene el mismo nombre. + + tiene más de 260 caracteres. + + + Abre la exclusión mutua con nombre especificada, si ya existe. + Objeto que representa la exclusión mutua del sistema con nombre. + Nombre de la exclusión mutua del sistema que se va a abrir. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + La excepción mutua con nombre no existe. + Se ha producido un error de Win32. + La exclusión mutua con nombre existe, pero el usuario no dispone del acceso de seguridad exigido para utilizarla. + 1 + + + + + + Libera una vez la instancia de . + El subproceso que realiza la llamada no posee la exclusión mutua. + 1 + + + Abre la exclusión mutua con nombre especificada, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si la exclusión mutua con nombre se abrió correctamente; si no, false. + Nombre de la exclusión mutua del sistema que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa la exclusión mutua con nombre si la llamada se realizó correctamente, o null si se produjo un error en la llamada.Este parámetro se trata como sin inicializar. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + Se ha producido un error de Win32. + La exclusión mutua con nombre existe, pero el usuario no dispone del acceso de seguridad exigido para utilizarla. + + + Representa un bloqueo que se utiliza para administrar el acceso a un recurso y que permite varios subprocesos para la lectura o acceso exclusivo para la escritura. + + + Inicializa una nueva instancia de la clase con los valores de propiedad predeterminados. + + + Inicializa una nueva instancia de la clase especificando la directiva de recursividad de bloqueo. + Uno de los valores de enumeración que especifica la directiva de recursividad de bloqueo. + + + Obtiene el número total de subprocesos únicos que han entrado en el bloqueo en modo de lectura. + Número de subprocesos únicos que han entrado en el bloqueo en modo de lectura. + + + Libera todos los recursos usados por la instancia actual de la clase . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Intenta entrar en el bloqueo en modo de lectura. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Reduce el recuento de recursividad para el modo de lectura y sale del modo de lectura si el recuento resultante es 0 (cero). + The current thread has not entered the lock in read mode. + + + Reduce el recuento de recursividad para el modo de actualización y sale del modo de actualización si el recuento resultante es 0 (cero). + The current thread has not entered the lock in upgradeable mode. + + + Reduce el recuento de recursividad para el modo de escritura y sale del modo de escritura si el recuento resultante es 0 (cero). + The current thread has not entered the lock in write mode. + + + Obtiene un valor que indica si el subproceso actual ha entrado en el bloqueo en modo de lectura. + true si el subproceso actual entró en modo Lectura; en caso contrario, false. + 2 + + + Obtiene un valor que indica si el subproceso actual entró en el bloqueo en modo de actualización. + true si el subproceso actual entró en modo de actualización; en caso contrario, false. + 2 + + + Obtiene un valor que indica si el subproceso actual ha entrado en el bloqueo en modo de escritura. + true si el subproceso actual entró en modo de escritura; en caso contrario, false. + 2 + + + Obtiene un valor que indica la directiva de recursividad del objeto actual. + Uno de los valores de enumeración que especifica la directiva de recursividad de bloqueo. + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de lectura, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo Lectura, 1 si el subproceso entró en modo Lectura pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el bloqueo n - 1 veces. + 2 + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de actualización, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo de actualización, 1 si el subproceso entró en modo de actualización pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el modo de actualización n - 1 veces. + 2 + + + Obtiene el número de veces que el subproceso actual ha entrado en el bloqueo en modo de escritura, como una indicación de recursividad. + 0 (cero) si el subproceso actual no entró en modo de escritura, 1 si el subproceso entró en modo de escritura pero no lo hizo de forma recursiva o n si el subproceso entró de forma recursiva en el modo de escritura n - 1 veces. + 2 + + + Intenta entrar en el bloqueo en modo de lectura, con un tiempo de espera entero opcional. + true si el subproceso que realiza la llamada entró en modo Lectura; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de lectura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo Lectura; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de actualización; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de actualización, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de actualización; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de escritura; en caso contrario, false. + Número de milisegundos de espera o -1 () para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Intenta entrar en el bloqueo en modo de escritura, con tiempo de espera opcional. + true si el subproceso que realiza la llamada entró en modo de escritura; en caso contrario, false. + Intervalo de espera, o -1 milisegundo para esperar indefinidamente. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de lectura. + Número total de subprocesos que están a la espera de entrar en modo de lectura. + 2 + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de actualización. + Número total de subprocesos que están a la espera de entrar en modo de actualización. + 2 + + + Obtiene el número total de subprocesos que están a la espera de entrar en el bloqueo en modo de escritura. + Número total de subprocesos que están a la espera de entrar en modo de escritura. + 2 + + + Limita el número de subprocesos que pueden tener acceso a un recurso o grupo de recursos simultáneamente. + 1 + + + Inicializa una nueva instancia de la clase , que especifica el número inicial de entradas y el número máximo de entradas simultáneas. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + + es mayor que . + + es menor que 1.o bien es menor que 0. + + + Inicializa una nueva instancia de la clase , que especifica el número inicial de entradas y el número máximo de entradas simultáneas, y especificando de forma opcional el nombre de un objeto semáforo de sistema. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + Nombre de un objeto de semáforo del sistema con nombre. + + es mayor que .o bien tiene más de 260 caracteres. + + es menor que 1.o bien es menor que 0. + Se ha producido un error de Win32. + El semáforo con nombre existe y tiene seguridad de control de acceso y el usuario no tiene . + No se puede crear el semáforo con nombre, probablemente porque tiene el mismo nombre que un identificador de espera de otro tipo. + + + Inicializa una instancia nueva de la clase , especificando el número inicial de entradas y el número máximo de entradas simultáneas, especificando de forma opcional el nombre de un objeto semáforo de sistema y especificando una variable que recibe un valor que indica si se creó un semáforo del sistema nuevo. + Número inicial de solicitudes para el semáforo que se puede satisfacer simultáneamente. + Número máximo de solicitudes para el semáforo que se puede satisfacer simultáneamente. + Nombre de un objeto de semáforo del sistema con nombre. + Cuando este método devuelve un resultado, contiene true si se creó un semáforo local (es decir, si es null o una cadena vacía) o si se creó el semáforo del sistema con nombre especificado; es false si el semáforo del sistema con nombre especificado ya existía.Este parámetro se pasa sin inicializar. + + es mayor que . o bien tiene más de 260 caracteres. + + es menor que 1.o bien es menor que 0. + Se ha producido un error de Win32. + El semáforo con nombre existe y tiene seguridad de control de acceso y el usuario no tiene . + No se puede crear el semáforo con nombre, probablemente porque tiene el mismo nombre que un identificador de espera de otro tipo. + + + Abre el semáforo con nombre especificado, si ya existe. + Objeto que representa el semáforo del sistema con nombre. + Nombre del semáforo del sistema que se va a abrir. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + El semáforo con nombre no existe. + Se ha producido un error de Win32. + El semáforo con nombre existe, pero el usuario no tiene el acceso de seguridad necesario para utilizarlo. + 1 + + + + + + Sale del semáforo y devuelve el recuento anterior. + Recuento en el semáforo antes de la llamada al método . + El recuento del semáforo ya está en el valor máximo. + Error de Win32 con un semáforo con nombre. + El semáforo actual representa un semáforo de sistema con nombre, pero el usuario no tiene .o bienEl semáforo actual representa un semáforo de sistema con nombre, pero no se abrió con . + 1 + + + Sale del semáforo un número especificado de veces y devuelve el recuento anterior. + Recuento en el semáforo antes de la llamada al método . + Número de veces que se abandona el semáforo. + + es menor que 1. + El recuento del semáforo ya está en el valor máximo. + Error de Win32 con un semáforo con nombre. + El semáforo actual representa un semáforo de sistema con nombre, pero el usuario no tiene derechos.o bienEl semáforo actual representa un semáforo de sistema con nombre, pero no se abrió con derechos. + 1 + + + Abre el semáforo con nombre especificado, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente. + true si el semáforo con nombre se abrió correctamente; si no, false. + Nombre del semáforo del sistema que se va a abrir. + Cuando este método vuelve, contiene un objeto que representa el semáforo con nombre si la llamada se realizó correctamente o null si se produjo un error en la misma.Este parámetro se trata como sin inicializar. + + es una cadena vacía.o bien tiene más de 260 caracteres. + El valor de es null. + Se ha producido un error de Win32. + El semáforo con nombre existe, pero el usuario no tiene el acceso de seguridad necesario para utilizarlo. + + + Excepción que se produce cuando se llama al método en un semáforo cuyo recuento ya ha alcanzado el valor máximo. + 2 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Representa una alternativa ligera a que limita el número de subprocesos que puede obtener acceso a la vez a un recurso o a un grupo de recursos. + + + Inicializa una nueva instancia de la clase , especificando el número inicial de solicitudes que se pueden conceder simultáneamente. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + + es menor que 0. + + + Inicializa una nueva instancia de la clase , especificando el número inicial y máximo de solicitudes que se pueden conceder simultáneamente. + Número inicial de solicitudes del semáforo que se pueden conceder simultáneamente. + Número máximo de solicitudes del semáforo que se pueden conceder simultáneamente. + + es menor que 0, o es mayor que , o es igual o menor que 0. + + + Devuelve un objeto que se puede usar para esperar en el semáforo. + + que se puede usar para esperar en el semáforo. + Se ha eliminado . + + + Obtiene el número de subprocesos restantes que puede introducir el objeto . + Obtiene el número de subprocesos restantes que pueden entrar en el semáforo. + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos no administrados utilizados por el objeto y, de forma opcional, libera los recursos administrados. + Es true para liberar tanto recursos administrados como no administrados; es false para liberar únicamente recursos no administrados. + + + Libera una vez el objeto . + Recuento anterior de . + La instancia actual ya se ha eliminado. + El ya se ha alcanzado su tamaño máximo. + + + Libera el objeto un número especificado de veces. + Recuento anterior de . + Número de veces que se abandona el semáforo. + La instancia actual ya se ha eliminado. + + es menor que 1. + El ya se ha alcanzado su tamaño máximo. + + + Bloquea el subproceso actual hasta que pueda introducir . + La instancia actual ya se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , usando un entero de 32 bits con signo que especifica el tiempo de espera. + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + + + Bloquea el subproceso actual hasta que pueda introducir , usando un entero de 32 bits con signo que especifica el tiempo de espera mientras se observa un elemento . + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + se ha cancelado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + El se ha eliminado la instancia, o la que creó se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , mientras se observa un elemento . + Token que se va a observar. + + se ha cancelado. + La instancia actual ya se ha eliminado.o bienEl que creó ya se ha eliminado. + + + Bloquea el subproceso actual hasta que pueda introducir , usando para especificar el tiempo de espera. + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + es un número negativo distinto de-1 milisegundo, que representa un tiempo de espera infinito o - tiempo de espera es mayor que . + Se ha eliminado la instancia de semaphoreSlim + + + Bloquea el subproceso actual hasta que pueda introducir , usando un que especifica el tiempo de espera mientras se observa un elemento . + true si el subproceso actual introdujo correctamente ; de lo contrario, false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + + que se va a observar. + + se ha cancelado. + + es un número negativo distinto de-1 milisegundo, que representa un tiempo de espera infinito o - tiempo de espera es mayor que . + Se ha eliminado la instancia de semaphoreSlimEl que creó ya se ha eliminado. + + + De forma asincrónica espera que se introduzca . + Tarea que se completará cuando se entre en el semáforo. + + + De forma asincrónica espera que se introduzca , usando un entero de 32 bits para medir el intervalo de tiempo. + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + + + De forma asincrónica, espera introducir , usando un entero de 32 bits para medir el intervalo de tiempo, mientras observa un elemento . + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + + que se va a observar. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito. + La instancia actual ya se ha eliminado. + + se ha cancelado. + + + De forma asincrónica, espera introducir , mientras observa un elemento . + Tarea que se completará cuando se entre en el semáforo. + Token que se va a observar. + La instancia actual ya se ha eliminado. + + se ha cancelado. + + + De forma asincrónica, espera introducir , usando un para medir el intervalo de tiempo. + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + La instancia actual ya se ha eliminado. + + es un número negativo distinto de -1, que representa el tiempo de espera infinito o bien tiempo de espera es mayor que . + + + De forma asincrónica, espera introducir , usando un para medir el intervalo de tiempo, mientras observa un elemento . + Tarea que se completará con un resultado true si el subproceso actual introdujo correctamente ; de lo contrario, el resultado será false. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + Token que se va a observar. + + es un número negativo distinto de -1, que representa el tiempo de espera infinitoo bientiempo de espera es mayor que . + + se ha cancelado. + + + Representa el método al que hay que llamar cuando se va a enviar un mensaje a un contexto de sincronización. + Objeto que se ha pasado al delegado. + 2 + + + Proporciona una primitiva de bloqueo de exclusión mutua donde un subproceso que intenta adquirir el bloqueo espera en un bucle repetidamente comprobando hasta que haya un bloqueo disponible. + + + Inicializa una nueva instancia de la estructura con la opción de realizar el seguimiento de los identificadores de subprocesos para mejorar la depuración. + Indica si se han de capturar y utilizar identificadores de subprocesos con fines de depuración. + + + Adquiere el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + El argumento se debe inicializar en false antes de llamar a Enter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Libera el bloqueo. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual no es el propietario de este bloqueo. + + + Libera el bloqueo. + Valor booleano que indica si una barrera de memoria debe emitirse para publicar inmediatamente la operación de salida a otros subprocesos. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual no es el propietario de este bloqueo. + + + Obtiene un valor que indica si un subproceso mantiene actualmente el bloqueo. + Es true si cualquier subproceso mantiene actualmente el bloqueo; de lo contrario, es false. + + + Obtiene un valor que indica si el subproceso actual mantiene actualmente el bloqueo. + Es true si el subproceso actual mantiene el bloqueo; de lo contrario, es false. + El seguimiento de propiedad de subprocesos está deshabilitado. + + + Obtiene un valor que indica si el seguimiento de propiedad de subprocesos está habilitado para esta instancia. + Es true si se ha habilitado el seguimiento de propiedad de subprocesos para esta instancia; de lo contrario, es false. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Intenta adquirir el bloqueo de manera confiable de modo que, incluso si se produce una excepción en la llamada al método, se pueda examinar de manera confiable para determinar si se adquirió el bloqueo. + Estructura que representa el número de milisegundos de espera o estructura que representa -1 milisegundos para esperar indefinidamente. + Es true si se adquiere el bloqueo; de lo contrario, es false. se debe inicializar en false antes de llamar a este método. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que milisegundos. + El argumento se debe inicializar en false antes de llamar a TryEnter. + El seguimiento de propiedad de subprocesos está habilitado, y el subproceso actual ya ha adquirido este bloqueo. + + + Proporciona compatibilidad con la espera basada en ciclos. + + + Obtiene el número de veces que se ha llamado a en esta instancia. + Devuelve un entero que representa el número de veces que se ha llamado en esta instancia. + + + Obtiene si la llamada siguiente a da paso al procesador, lo que activa un cambio de contexto forzado. + Si la llamada siguiente a da paso al procesador, lo que activa un cambio de contexto forzado. + + + Restablece el contador de ciclos. + + + Realiza un único ciclo. + + + Itera en ciclos hasta que se satisface la condición especificada. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + El argumento de es nulo. + + + Itera en ciclos hasta que se satisface la condición especificada o se agota el tiempo de espera indicado. + Es true si la condición se satisface dentro del tiempo de espera; de lo contrario, es false. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + Número de milisegundos de espera o (-1) para esperar indefinidamente. + El argumento de es nulo. + + es un número negativo distinto de -1 que representa un tiempo de espera infinito. + + + Itera en ciclos hasta que se satisface la condición especificada o se agota el tiempo de espera indicado. + Es true si la condición se satisface dentro del tiempo de espera; de lo contrario, es false. + Delegado que se va a ejecutar una y otra vez hasta que devuelva true. + Estructura que representa el número de milisegundos de espera o TimeSpan que representa -1 milisegundo para esperar indefinidamente. + El argumento de es nulo. + + es un número negativo distinto de -1 milisegundo, que representa un tiempo de espera infinito, o el tiempo de espera es mayor que . + + + Proporciona la funcionalidad básica para propagar un contexto de sincronización en varios modelos de sincronización. + 2 + + + Crea una nueva instancia de la clase . + + + Cuando se invalida en una clase derivada, crea una copia del contexto de sincronización. + Un nuevo objeto . + 2 + + + Obtiene el contexto de sincronización del subproceso actual. + Objeto que representa el contexto de sincronización actual. + 1 + + + Cuando se invalida en una clase derivada, responde a la notificación de que se ha completado una operación. + + + Cuando se invalida en una clase derivada, responde a la notificación de que se ha iniciado una operación. + + + Cuando se invalida en una clase derivada, envía un mensaje asincrónico a un contexto de sincronización. + Delegado de al que se va a llamar. + Objeto que se ha pasado al delegado. + 2 + + + Cuando se invalida en una clase derivada, envía un mensaje sincrónico a un contexto de sincronización. + Delegado de al que se va a llamar. + Objeto que se ha pasado al delegado. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Establece el contexto de sincronización actual. + Objeto que se va a establecer. + 1 + + + + + + Excepción que se produce cuando un método requiere que el llamador sea propietario del bloqueo en un Monitor dado y un llamador al que no pertenece ese bloqueo llama al método. + 2 + + + Inicializa una nueva instancia de la clase con propiedades predeterminadas. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + Proporciona almacenamiento local de los datos de un subproceso. + Especifica el tipo de datos que se almacena por subproceso. + + + Inicializa la instancia de . + + + Inicializa la instancia de . + Si se va a hacer un seguimiento de todos los valores establecidos en la instancia y exponerlos a través de la propiedad . + + + Inicializa una instancia de con la función especificada por el parámetro . + + que se invoca para generar un valor de inicialización diferida cuando se intenta recuperar sin que se haya inicializado anteriormente. + + es una referencia nula (Nothing en Visual Basic). + + + Inicializa una instancia de con la función especificada por el parámetro . + + que se invoca para generar un valor de inicialización diferida cuando se intenta recuperar sin que se haya inicializado anteriormente. + Si se va a hacer un seguimiento de todos los valores establecidos en la instancia y exponerlos a través de la propiedad . + + es una referencia null (Nothing en Visual Basic). + + + Libera todos los recursos usados por la instancia actual de la clase . + + + Libera los recursos utilizados por esta instancia de . + Valor booleano que indica si se llama a este método debido a una llamada a . + + + Libera los recursos utilizados por esta instancia de . + + + Obtiene un valor que indica si se inicializa en el subproceso actual. + Es true si se inicializa en el subproceso actual; en caso contrario, es false. + La instancia de se ha eliminado. + + + Crea y devuelve una representación de cadena de esta instancia del subproceso actual. + Resultado de llamar al método en . + La instancia de se ha eliminado. + La propiedad del subproceso actual es una referencia nula (Nothing en Visual Basic). + La función de inicialización intentó hacer referencia de forma recursiva a . + No se proporciona ningún constructor predeterminado y no se proporciona ningún generador de valor. + + + Obtiene o establece el valor de esta instancia del subproceso actual. + Devuelve una instancia del objeto que ThreadLocal es responsable de inicializar. + La instancia de se ha eliminado. + La función de inicialización intentó hacer referencia de forma recursiva a . + No se proporciona ningún constructor predeterminado y no se proporciona ningún generador de valor. + + + Obtiene una lista de todos los valores almacenados actualmente por todos los subprocesos que han tenido acceso a esta instancia. + Lista de todos los valores almacenados actualmente por todos los subprocesos que han tenido acceso a esta instancia. + La instancia de se ha eliminado. + + + Contiene los métodos para realizar operaciones de memoria volátil. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee el valor del campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Valor que se ha leído.El valor es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + + + Lee la referencia al objeto desde el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura tras este método en el código, el procesador no puede moverla antes de este método. + Referencia al que se ha leído.Esta referencia es el último que haya escrito cualquier procesador del equipo, independientemente del número de procesadores y del estado de la memoria caché del procesador. + Campo que se va a leer. + Tipo del campo que se va a leer.Debe ser un tipo de referencia, no un tipo de valor. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de memoria antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe el valor especificado en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe el valor. + Valor que se va a escribir.El valor se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + + + Escribe la referencia de objeto especificada en el campo especificado.En los sistemas que lo requieren, inserta una barrera de memoria que impide que el procesador reordene las operaciones de memoria del modo siguiente: si aparece una operación de lectura o de escritura antes de este método en el código, el procesador no puede moverla después de este método. + Campo donde se escribe la referencia de objeto. + Referencia de objeto que se va a escribir.La referencia se escribe inmediatamente de manera que sea visible para todos los procesadores del equipo. + Tipo del campo que se va a escribir.Debe ser un tipo de referencia, no un tipo de valor. + + + Excepción que se produce cuando se intenta abrir una exclusión mutua o semáforo del sistema que no existe. + 2 + + + Inicializa una nueva instancia de la clase con valores predeterminados. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado. + Mensaje de error que explica la razón de la excepción. + + + Inicializa una nueva instancia de la clase con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción. + Mensaje de error que explica la razón de la excepción. + La excepción que es la causa de la excepción actual.Si el parámetro no es null, la excepción actual se produce en un bloque catch que controla la excepción interna. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/fr/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/fr/System.Threading.xml new file mode 100644 index 000000000..6bbaf9759 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/fr/System.Threading.xml @@ -0,0 +1,1833 @@ + + + + System.Threading + + + + Exception levée lorsqu'un thread acquiert un objet qu'un autre thread a abandonné en se terminant sans le libérer. + 1 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un index spécifié pour le mutex abandonné, le cas échéant, et un objet qui représente le mutex. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur qui indique la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur et une exception interne spécifiés. + Message d'erreur qui indique la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié, l'exception interne, l'index pour le mutex abandonné, le cas échéant, et un objet qui représente le mutex. + Message d'erreur qui indique la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié, l'index du mutex abandonné, le cas échéant, et le mutex abandonné. + Message d'erreur qui indique la raison de l'exception. + Index du mutex abandonné dans le tableau des handles d'attente si l'exception est levée pour la méthode , ou -1 si l'exception est levée pour les méthodes ou . + Objet qui représente le mutex abandonné. + + + Obtient le mutex abandonné qui a provoqué l'exception, s'il est connu. + Objet qui représente le mutex abandonné ou null si les mutex abandonnés n'ont pas pu être identifiés. + 1 + + + Obtient l'index du mutex abandonné qui a provoqué l'exception, s'il est connu. + Index, dans le tableau de handles d'attente passés à la méthode , de l'objet qui représente le mutex abandonné ou -1 si l'index du mutex abandonné n'a pas pu être déterminé. + 1 + + + Représente les données ambiantes qui sont locales à un flux de contrôle asynchrone donné, par exemple une méthode asynchrone. + Type des données ambiantes. + + + Instancie une instance de qui ne reçoit pas de notifications de modification. + + + Instancie une instance locale de qui ne reçoit pas de notifications de modification. + Le délégué est appelé à chaque modification de la valeur actuelle sur n'importe quel thread. + + + Obtient ou définit la valeur des données ambiantes. + Valeur des données ambiantes. + + + Classe qui fournit les informations de modification des données aux instances de qui s'inscrivent pour les notifications de modification. + Type des données. + + + Obtient la valeur actuelle des données. + Valeur actuelle des données. + + + Obtient la valeur précédente des données. + Valeur précédente des données. + + + Retourne une valeur qui indique si la valeur est modifiée en raison d'un changement du contexte d'exécution. + true si la valeur est modifiée en raison d'un changement du contexte d'exécution ; sinon, false. + + + Avertit un thread en attente qu'un événement s'est produit.Cette classe ne peut pas être héritée. + 2 + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé". + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + + + Permet à plusieurs tâches de travailler en parallèle de manière coopérative sur un algorithme via plusieurs phases. + + + Initialise une nouvelle instance de la classe . + Nombre de threads participants. + + est inférieur à 0 ou supérieur à 32,767. + + + Initialise une nouvelle instance de la classe . + Nombre de threads participants. + + à exécuter après chaque phase. null (nothing en Visual Basic) peut être passé pour indiquer qu'aucune action n'est effectuée. + + est inférieur à 0 ou supérieur à 32,767. + + + Signale à qu'il y aura un participant supplémentaire. + Numéro de la phase du cloisonnement à laquelle les nouveaux participants participeront en premier. + L'instance actuelle a déjà été supprimée. + L'ajout d'un participant provoquerait l'augmentation du nombre de participants du cloisonnement au-delà de 32 767.ouLa méthode a été appelée à partir d'une action post-phase. + + + Signale à qu'il y aura des participants supplémentaires. + Numéro de la phase du cloisonnement à laquelle les nouveaux participants participeront en premier. + Nombre de participants supplémentaires à ajouter au cloisonnement. + L'instance actuelle a déjà été supprimée. + + est inférieur à 0.ouL'ajout de participants () provoquerait l'augmentation du nombre de participants du cloisonnement au-delà de 32 767. + La méthode a été appelée à partir d'une action post-phase. + + + Obtient le numéro de la phase actuelle du cloisonnement. + Retourne le numéro de la phase actuelle du cloisonnement. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + La méthode a été appelée à partir d'une action post-phase. + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le nombre total de participants au cloisonnement. + Retourne le nombre total de participants au cloisonnement. + + + Obtient le nombre de participants au cloisonnement qui n'ont pas encore été signalés dans la phase actuelle. + Retourne le nombre de participants au cloisonnement qui n'ont pas encore été signalés dans la phase actuelle. + + + Signale à qu'il y aura un participant en moins. + L'instance actuelle a déjà été supprimée. + La barrière a déjà 0 participant.ouLa méthode a été appelée à partir d'une action post-phase. + + + Signale à qu'il y aura moins de participants. + Nombre de participants supplémentaires à supprimer du cloisonnement. + L'instance actuelle a déjà été supprimée. + + est inférieur à 0. + La barrière a déjà 0 participant.ouLa méthode a été appelée à partir d'une action post-phase. oule nombre de participant actuel est inférieur au participantCount spécifié + Le nombre total de participants est inférieur au spécifié + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement. + L'instance actuelle a déjà été supprimée. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + Si une exception est levée par l'action de post-phase d'un cloisonnement après que tous les threads participants aient appelé SignalAndWait, l'exception sera incluse dans un wrapper dans une BarrierPostPhaseException et levée pour tous les threads participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un entier signé 32 bits pour mesurer le délai d'attente. + si tous les participants ont atteint le cloisonnement dans le délai spécifié ; sinon false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + Si une exception est levée par l'action de post-phase d'un cloisonnement après que tous les threads participants aient appelé SignalAndWait, l'exception sera incluse dans un wrapper dans une BarrierPostPhaseException et levée pour tous les threads participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un entier signé 32 bits pour mesurer le délai d'attente, tout en observant un jeton d'annulation. + si tous les participants ont atteint le cloisonnement dans le délai spécifié ; sinon false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, tout en observant un jeton d'annulation. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un objet qui mesure l'intervalle de temps. + true si tous les autres participants ont atteint le cloisonnement ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini, ou sa valeur est supérieure à 32 767. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + Signale qu'un participant a atteint le cloisonnement et qu'il attend que tous les autres participants atteignent également le cloisonnement, à l'aide d'un objet qui mesure l'intervalle de temps, tout en observant un jeton d'annulation. + true si tous les autres participants ont atteint le cloisonnement ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini. + La méthode a été appelée à partir d'une action post-phase, le cloisonnement comporte actuellement 0 participants, ou il est signalé par un nombre de threads plus important que celui enregistré en tant que participants. + + + L'exception levée lorsque l'action post-phase d'un échoue. + + + Initialise une nouvelle instance de la classe avec un message système qui décrit l'erreur. + + + Initialise une nouvelle instance de la classe avec l'exception interne spécifiée. + Exception qui constitue la cause de l'exception actuelle. + + + Initialise une nouvelle instance de la classe avec un message spécifié décrivant l'erreur. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture du système en cours. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Représente une méthode à appeler dans un nouveau contexte. + Objet contenant les informations que la méthode de rappel doit utiliser à chacune de ses exécutions. + 1 + + + Représente une primitive de synchronisation qui est signalée lorsque son décompte atteint zéro. + + + Initialise une nouvelle instance de la classe à l'aide du décompte spécifié. + Nombre de signaux initialement requis pour définir . + + est inférieur à 0. + + + Incrémente de un le décompte actuel de . + L'instance actuelle a déjà été supprimée. + L'instance actuelle est déjà définie.ou est supérieur ou égal à . + + + Incrémente d'une valeur spécifiée le décompte actuel de . + Valeur d'incrément de . + L'instance actuelle a déjà été supprimée. + + est inférieur ou égal à 0. + L'instance actuelle est déjà définie.ou est égal à ou supérieur à une fois le nombre été incrémenté par + + + Obtient le nombre de signaux restants requis pour définir l'événement. + Nombre de signaux restants requis pour définir l'événement. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient le nombre de signaux initialement requis pour définir l'événement. + Nombre de signaux initialement requis pour définir l'événement. + + + Détermine si l'événement est défini. + true si l'événement est défini ; sinon, false. + + + Réinitialise avec la valeur . + L'instance actuelle a déjà été supprimée. + + + Définit la propriété spécifiée sur la valeur indiquée. + Nombre de signaux requis pour définir . + L'instance actuelle a déjà été supprimée. + + est inférieur à 0. + + + Enregistre un signal avec le , en décrémentant la valeur de . + true si le décompte a atteint zéro en raison du signal et que l'événement a été défini ; sinon, false. + L'instance actuelle a déjà été supprimée. + L'instance actuelle est déjà définie. + + + Inscrit plusieurs signaux avec , en décrémentant la valeur de selon la valeur spécifiée. + true si le décompte a atteint zéro en raison des signaux et que l'événement a été défini ; sinon, false. + Nombre de signaux à inscrire. + L'instance actuelle a déjà été supprimée. + + est inférieur à 1. + L'instance actuelle est déjà définie. - ou - Ou est supérieur à . + + + Essaie d'incrémenter par un. + true si l'incrémentation a réussi ; sinon, false.Si est déjà à zéro, cette méthode retourne la valeur false. + L'instance actuelle a déjà été supprimée. + + est égal à . + + + Essaie d'incrémenter par une valeur spécifiée. + true si l'incrémentation a réussi ; sinon, false.Si est déjà à zéro, la valeur false est retournée. + Valeur d'incrément de . + L'instance actuelle a déjà été supprimée. + + est inférieur ou égal à 0. + L'instance actuelle est déjà définie.ou + est supérieur ou égal à . + + + Bloque le thread actuel jusqu'à ce que soit défini. + L'instance actuelle a déjà été supprimée. + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un entier signé 32 bits permettant de mesurer le délai d'attente. + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce que soit défini, à l'aide d'un entier signé 32 bits permettant de mesurer le délai d'attente, tout en observant un . + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce que soit défini, tout en observant un . + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un permettant de mesurer le délai d'attente. + true si a été défini ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Bloque le thread actuel jusqu'à ce que le soit défini, à l'aide d'un permettant de mesurer le délai d'attente, tout en observant un . + true si a été défini ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée. - ou - le qui a créé a déjà été supprimé. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Obtient un qui est utilisé pour attendre l'événement à définir. + + qui est utilisé pour attendre l'événement à définir. + L'instance actuelle a déjà été supprimée. + + + Indique si un est réinitialisé automatiquement ou manuellement après la réception d'un signal. + 2 + + + Une fois signalé, le se réinitialise automatiquement après avoir libéré un seul thread.Si aucun thread n'attend, le conserve l'état signalé jusqu'à ce qu'un thread se bloque et se réinitialise après l'avoir libéré. + + + Lorsqu'il est signalé, le libère tous les threads en attente et conserve l'état signalé jusqu'à sa réinitialisation manuelle. + + + Représente un événement de synchronisation de threads. + 2 + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement et s'il se réinitialise automatiquement ou manuellement. + true pour définir l'état initial comme étant signalé ; false pour le définir comme étant non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement s'il a été créé à la suite de cet appel, s'il se réinitialise automatiquement ou manuellement, ainsi que le nom d'un événement de synchronisation du système. + true pour définir l'état initial comme signalé si l'événement nommé est créé en conséquence de cet appel ; false pour le définir comme non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + Nom d'un événement de synchronisation à l'échelle du système. + Une erreur Win32 s'est produite. + L'événement nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + L'événement nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + dépasse 260 caractères. + + + Initialise une nouvelle instance de la classe , en spécifiant si le handle d'attente est signalé initialement s'il a été créé à la suite de cet appel, s'il se réinitialise automatiquement ou manuellement, ainsi que le nom d'un événement de synchronisation du système et une variable booléenne dont la valeur après l'appel indique si l'événement système nommé a été créé. + true pour définir l'état initial comme signalé si l'événement nommé est créé en conséquence de cet appel ; false pour le définir comme non signalé. + L'une des valeurs qui déterminent si l'événement se réinitialise automatiquement ou manuellement. + Nom d'un événement de synchronisation à l'échelle du système. + Cette méthode retourne true si un événement local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si l'événement système nommé spécifié a été créé ; false si l'événement système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + Une erreur Win32 s'est produite. + L'événement nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + L'événement nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + dépasse 260 caractères. + + + Ouvre l'événement de synchronisation nommé spécifié s'il existe déjà. + Objet qui représente l'événement système nommé. + Nom de l'événement de synchronisation système à ouvrir. + + est une chaîne vide. ou dépasse 260 caractères. + + a la valeur null. + L'événement de système nommé n'existe pas. + Une erreur Win32 s'est produite. + L'événement nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Définit l'état de l'événement comme étant non signalé, entraînant le blocage des threads. + true si l'opération aboutit ; sinon, false. + La méthode a été précédemment appelée sur ce . + 2 + + + Définit l'état de l'événement comme étant signalé, ce qui permet à un ou plusieurs threads en attente de continuer. + true si l'opération aboutit ; sinon, false. + La méthode a été précédemment appelée sur ce . + 2 + + + Ouvre l'événement de synchronisation nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si l'événement de synchronisation nommé a été ouvert ; sinon, false. + Nom de l'événement de synchronisation système à ouvrir. + Lorsque cette méthode est retournée, contient un objet qui représente l'événement de synchronisation nommé si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme non initialisé. + + est une chaîne vide.ou dépasse 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + L'événement nommé existe, mais l'utilisateur n'a pas l'accès de sécurité voulu. + + + Gère le contexte d'exécution du thread actuel.Cette classe ne peut pas être héritée. + 2 + + + Capture le contexte d'exécution du thread actuel. + Objet capturant le contexte d'exécution du thread actuel. + 1 + + + Exécute une méthode dans un contexte d'exécution spécifié sur le thread actuel. + + à définir. + Délégué représentant la méthode à exécuter dans le contexte d'exécution fourni. + Objet à passer à la méthode de rappel. + + a la valeur null.ouLe n'a pas été acquis à l'aide d'une opération de capture. ouLe a déjà été utilisé comme argument pour un appel . + 1 + + + + + + Fournit des opérations atomiques pour des variables partagées par plusieurs threads. + 2 + + + Ajoute deux entiers 32 bits et remplace le premier entier par la somme, sous la forme d'une opération atomique. + La nouvelle valeur stockée à . + Variable qui contient la première valeur à ajouter.La somme des deux valeurs est stockée dans . + Valeur à ajouter à l'entier à . + The address of is a null pointer. + 1 + + + Ajoute deux entiers 64 bits et remplace le premier entier par la somme, sous la forme d'une opération atomique. + La nouvelle valeur stockée à . + Variable qui contient la première valeur à ajouter.La somme des deux valeurs est stockée dans . + Valeur à ajouter à l'entier à . + The address of is a null pointer. + 1 + + + Compare deux nombres à virgule flottante double précision et remplace le premier en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux entiers signés de 32 bits et remplace la première valeur en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux entiers signés de 64 bits et remplace la première valeur en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux handles ou pointeurs spécifiques à la plateforme et remplace le premier en cas d'égalité. + Valeur d'origine dans . + + de destination, dont la valeur est comparée à celle de et qui peut être remplacée par . + + qui remplace la valeur de destination si la comparaison conclut à une égalité. + + comparée à la valeur de . + The address of is a null pointer. + 1 + + + Compare deux objets et remplace le premier en cas d'égalité des références. + Valeur d'origine dans . + Objet de destination comparé à et qui peut être remplacé. + Objet qui remplace l'objet de destination si la comparaison conclut à une égalité. + Objet qui est comparé à l'objet se trouvant à . + The address of is a null pointer. + 1 + + + Compare deux nombres à virgule flottante simple précision et remplace le premier en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée à et qui peut être remplacée. + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + The address of is a null pointer. + 1 + + + Compare deux instances du type référence spécifié et remplace la première en cas d'égalité. + Valeur d'origine dans . + Destination, dont la valeur est comparée avec et qui peut être remplacée.C'est un paramètre référence (ref en C#, ByRef en Visual Basic). + Valeur qui remplace la valeur de destination si la comparaison conclut à une égalité. + Valeur comparée à celle de . + Type à utiliser pour , et .Ce type doit être un type référence. + The address of is a null pointer. + + + Décrémente une variable spécifiée et stocke le résultat, sous la forme d'une opération atomique. + Valeur décrémentée. + Variable dont la valeur doit être décrémentée. + The address of is a null pointer. + 1 + + + Décrémente la variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur décrémentée. + Variable dont la valeur doit être décrémentée. + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un nombre à virgule flottante double précision, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte un entier signé 32 bits à une valeur spécifiée, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un entier signé 64 bits, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un handle ou un pointeur spécifique à la plateforme, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un objet, puis retourne une référence à l'objet d'origine sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à un nombre à virgule flottante simple précision, puis retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée. + Valeur affectée au paramètre . + The address of is a null pointer. + 1 + + + Affecte une valeur spécifiée à une variable du type spécifié et retourne la valeur d'origine, sous la forme d'une opération atomique. + Valeur d'origine de . + Variable à laquelle affecter la valeur spécifiée.C'est un paramètre référence (ref en C#, ByRef en Visual Basic). + Valeur affectée au paramètre . + Type à utiliser pour et .Ce type doit être un type référence. + The address of is a null pointer. + + + Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur incrémentée. + Variable dont la valeur doit être incrémentée. + The address of is a null pointer. + 1 + + + Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. + Valeur incrémentée. + Variable dont la valeur doit être incrémentée. + The address of is a null pointer. + 1 + + + Synchronise l'accès à la mémoire comme suit : le processeur qui exécute le thread actuel ne peut pas réorganiser les instructions de sorte que les accès à la mémoire avant l'appel de s'exécutent après les accès à la mémoire postérieurs à l'appel de . + + + Retourne une valeur 64 bits chargée sous la forme d'une opération atomique. + Valeur chargée. + Valeur 64 bits à charger. + 1 + + + Fournit des routines d'initialisation tardives. + + + Initialise un type référence cible avec le constructeur par défaut du type s'il n'a pas déjà été initialisé. + Référence initialisée de type . + Référence de type à initialiser si elle ne l'a pas déjà été. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible ou un type valeur avec son constructeur par défaut s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence ou valeur de type à initialiser si elle ne l'a pas déjà été. + Référence à une valeur booléenne qui détermine si la cible a déjà été initialisée. + Référence à un objet utilisé comme verrou mutuellement exclusif pour l'initialisation de .Si est null null, un nouvel objet est instancié. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible ou un type valeur à l'aide d'une fonction spécifiée s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence ou valeur de type à initialiser si elle ne l'a pas déjà été. + Référence à une valeur booléenne qui détermine si la cible a déjà été initialisée. + Référence à un objet utilisé comme verrou mutuellement exclusif pour l'initialisation de .Si est null null, un nouvel objet est instancié. + Fonction appelée pour initialiser la référence ou la valeur. + Type de la référence à initialiser. + Autorisations pour accéder au constructeur de type manquant. + Le type n'a pas de constructeur par défaut. + + + Initialise un type référence cible à l'aide d'une fonction spécifiée s'il n'a pas déjà été initialisé. + Valeur initialisée de type . + Référence de type à initialiser si elle ne l'a pas déjà été. + Fonction appelée pour initialiser la référence. + Type référence de la référence à initialiser. + Le type n'a pas de constructeur par défaut. + + a retourné null (Nothing en Visual Basic). + + + L'exception levée lorsque l'entrée récursive dans un verrou n'est pas compatible avec la stratégie de récurrence pour le verrou. + 2 + + + Initialise une nouvelle instance de la classe avec un message système qui décrit l'erreur. + 2 + + + Initialise une nouvelle instance de la classe avec un message spécifié décrivant l'erreur. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture système en cours. + 2 + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message qui décrit l'exception.L'appelant de ce constructeur doit vérifier que cette chaîne a été localisée pour la culture système en cours. + Exception qui a provoqué l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + 2 + + + Spécifie si un verrou peut être entré plusieurs fois par le même thread. + + + Si un thread essaie d'entrer un verrou de manière récursive, une exception est levée.Certaines classes peuvent autoriser certaines récurrences lorsque ce paramètre est appliqué. + + + Un thread peut entrer un verrou de manière récursive.Certaines classes peuvent restreindre cette fonction. + + + Avertit un ou plusieurs threads en attente qu'un événement s'est produit.Cette classe ne peut pas être héritée. + 2 + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini comme signalé. + true pour définir un état initial signalé ; false pour définir un état initial non signalé. + + + Fournit une version allégée de . + + + Initialise une nouvelle instance de la classe avec l'état initial "non signalé". + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé". + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + + + Initialise une nouvelle instance de la classe avec une valeur booléenne indiquant si l'état initial doit être défini à "signalé" et un nombre de spins spécifié. + true pour définir l'état initial à "signalé" ; false pour le définir à "non signalé". + Nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + + is less than 0 or greater than the maximum allowed value. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par et éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour libérer uniquement les ressources non managées. + + + Obtient une valeur qui indique si l'événement est défini. + true si l'événement a été défini ; sinon, false. + + + Définit l'état de l'événement à "non signalé", ce qui entraîne le blocage des threads. + The object has already been disposed. + + + Définit l'état de l'événement à "signalé", ce qui permet à un ou plusieurs threads en attente sur l'événement de continuer à s'exécuter. + + + Obtient le nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + Retourne le nombre d'attentes de spins qui se produiront avant de revenir à une opération d'attente basée sur le noyau. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps. + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps, tout en observant un . + true si a été défini ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel reçoive un signal, tout en observant un . + + à observer. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un pour mesurer l'intervalle de temps. + true si a été défini ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde pour un délai d'attente infini. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Bloque le thread actuel jusqu'à ce que le actuel soit défini, à l'aide d'un pour mesurer l'intervalle de temps, tout en observant un . + true si a été défini ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde pour un délai d'attente infini. + + à observer. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Obtient l'objet sous-jacent pour ce . + Objet d'événement sous-jacent pour ce . + + + Fournit un mécanisme qui synchronise l'accès aux objets. + 2 + + + Acquiert un verrou exclusif sur l'objet spécifié. + Objet sur lequel acquérir le verrou du moniteur. + Le paramètre a la valeur null. + 1 + + + Acquiert un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel attendre. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou.Remarque   Si aucune exception ne se produit, la sortie de cette méthode est toujours true. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + + Libère un verrou exclusif sur l'objet spécifié. + Objet sur lequel libérer le verrou. + Le paramètre a la valeur null. + Le thread en cours ne possède pas le verrou pour l'objet spécifié. + 1 + + + Détermine si le thread actuel détient le verrou sur l'objet spécifié. + true si le thread actuel détient le verrou sur  ; sinon, false. + Objet à tester. + + a la valeur null. + + + Avertit un thread situé dans la file d'attente en suspens d'un changement d'état de l'objet verrouillé. + Objet attendu par un thread. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + 1 + + + Avertit tous les threads en attente d'un changement d'état de l'objet. + Objet qui envoie l'impulsion. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + 1 + + + Essaie d'acquérir un verrou exclusif sur l'objet spécifié. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + Le paramètre a la valeur null. + 1 + + + Tente d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + + Tentatives d'acquisition d'un verrou exclusif sur l'objet spécifié au cours du nombre spécifié de millisecondes. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou en millisecondes. + Le paramètre a la valeur null. + + est négatif et différent de . + 1 + + + Tente, pendant le nombre spécifié de millisecondes, d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou en millisecondes. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + + est négatif et différent de . + + + Tentatives d'acquisition d'un verrou exclusif sur l'objet spécifié au cours de la période spécifiée. + true si le thread actuel acquiert le verrou ; sinon, false. + Objet sur lequel acquérir le verrou. + + représentant le délai d'attente du verrou.Une valeur de –1 milliseconde spécifie une attente infinie. + Le paramètre a la valeur null. + La valeur en millisecondes de est négative et différente de (–1 milliseconde), ou elle est supérieure à . + 1 + + + Tente, pendant le délai spécifié, d'acquérir un verrou exclusif sur l'objet spécifié et définit de manière atomique une valeur qui indique si le verrou a été pris. + Objet sur lequel acquérir le verrou. + Délai d'attente du verrou.Une valeur de –1 milliseconde spécifie une attente infinie. + Résultat de la tentative d'acquisition du verrou, passé par la référence.L'entrée doit avoir la valeur false.La sortie a la valeur true si un verrou est acquis ; sinon, elle a la valeur false.La sortie est définie même si une exception se produit lors de la tentative d'acquisition du verrou. + L'entrée du paramètre a la valeur true. + Le paramètre a la valeur null. + La valeur en millisecondes de est négative et différente de (–1 milliseconde), ou elle est supérieure à . + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou. + true si l'appel est retourné car l'appelant a de nouveau acquis le verrou pour l'objet spécifié.Cette méthode ne retourne rien si le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + 1 + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou.Si le délai d'attente spécifié est écoulé, le thread intègre la file d'attente opérationnelle. + true si le verrou a fait l'objet d'une nouvelle acquisition avant l'expiration du délai spécifié ; false si le verrou a fait l'objet d'une nouvelle acquisition après l'expiration du délai spécifié.La méthode ne retourne pas de valeur tant que le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + Nombre de millisecondes à attendre avant que le thread intègre la file d'attente opérationnelle. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + La valeur du paramètre est négative et différente de . + 1 + + + Libère le verrou d'un objet et bloque le thread actuel jusqu'à ce qu'il acquière à nouveau le verrou.Si le délai d'attente spécifié est écoulé, le thread intègre la file d'attente opérationnelle. + true si le verrou a fait l'objet d'une nouvelle acquisition avant l'expiration du délai spécifié ; false si le verrou a fait l'objet d'une nouvelle acquisition après l'expiration du délai spécifié.La méthode ne retourne pas de valeur tant que le verrou n'est pas acquis à nouveau. + Objet sur lequel attendre. + + qui représente le temps à attendre avant que le thread n'intègre la file d'attente opérationnelle. + Le paramètre a la valeur null. + Le thread appelant ne possède pas le verrou pour l'objet spécifié. + Le thread qui appelle Wait quitte ensuite l'état d'attente.Cela se produit lorsqu'un autre thread appelle la méthode de ce thread. + La valeur en millisecondes du paramètre est négative et ne représente pas (–1 milliseconde) ou est supérieure à . + 1 + + + Primitive de synchronisation qui peut également être utilisée pour la synchronisation entre processus. + 1 + + + Initialise une nouvelle instance de la classe avec des propriétés par défaut. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex. + true pour accorder au thread appelant la propriété initiale du mutex ; sinon, false. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, et une chaîne représentant le nom du mutex. + true pour donner au thread appelant la propriété initiale du mutex système nommé si celui-ci est créé en réponse à cet appel ; sinon, false. + Nom du .Si cette valeur est null, est sans nom. + Le mutex nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + Une erreur Win32 s'est produite. + Le mutex nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + est plus de 260 caractères. + + + Initialise une nouvelle instance de la classe avec une valeur booléenne qui indique si le thread appelant doit avoir la propriété initiale du mutex, une chaîne qui représente le nom du mutex et une valeur booléenne qui, quand la méthode retourne son résultat, indique si la propriété initiale du mutex a été accordée au thread appelant. + true pour donner au thread appelant la propriété initiale du mutex système nommé si celui-ci est créé en réponse à cet appel ; sinon, false. + Nom du .Si cette valeur est null, est sans nom. + Cette méthode retourne une valeur booléenne qui est true si un mutex local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si le mutex système nommé spécifié a été créé ; false si le mutex système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + Le mutex nommé existe et possède la sécurité du contrôle d'accès, mais l'utilisateur ne possède pas . + Une erreur Win32 s'est produite. + Le mutex nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + est plus de 260 caractères. + + + Ouvre le mutex nommé spécifié, s'il existe déjà. + Objet qui représente le mutex système nommé. + Nom du mutex système à ouvrir. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Le mutex nommé n'existe pas. + Une erreur Win32 s'est produite. + Le mutex nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Libère l'objet une seule fois. + Le thread appelant ne possède pas le mutex. + 1 + + + Ouvre le mutex nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si le mutex nommé a été ouvert ; sinon, false. + Nom du mutex système à ouvrir. + Quand cette méthode est retournée, contient un objet qui représente la structure mutex nommée si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme étant non initialisé. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + Le mutex nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + + + Représente un verrou utilisé pour gérer l'accès à une ressource, en autorisant plusieurs threads pour la lecture ou un accès exclusif en écriture. + + + Initialise une nouvelle instance de la classe avec des valeurs de propriété par défaut. + + + Initialise une nouvelle instance de la classe , en spécifiant la stratégie de récurrence du verrou. + Une des valeurs d'énumération qui spécifie la stratégie de récurrence du verrou. + + + Obtient le nombre total de threads uniques qui ont entré le verrou en mode lecture. + Nombre de threads uniques qui ont entré le verrou en mode lecture. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Essaie d'entrer le verrou en mode lecture. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Réduit le nombre de récurrences pour le mode lecture, et quitte le mode lecture si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in read mode. + + + Réduit le nombre de récurrences pour le mode pouvant être mis à niveau, et quitte le mode pouvant être mis à niveau si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in upgradeable mode. + + + Réduit le nombre de récurrences pour le mode écriture, et quitte le mode écriture si le nombre résultant est 0 (zéro). + The current thread has not entered the lock in write mode. + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode lecture. + true si le thread actuel a entré le verrou en mode lecture ; sinon, false. + 2 + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode pouvant être mis à niveau. + true si le thread actuel a entré le verrou en mode pouvant être mis à niveau ; sinon, false. + 2 + + + Obtient une valeur qui indique si le thread actuel a entré le verrou en mode écriture. + true si le thread actuel a entré le verrou en mode écriture ; sinon, false. + 2 + + + Obtient une valeur qui indique la stratégie de récurrence pour l'objet actuel. + Une des valeurs d'énumération qui spécifie la stratégie de récurrence du verrou. + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode lecture, comme une indication de récurrence. + 0 (zéro) si le thread actuel n'a pas entré le verrou en mode lecture, 1 si le thread a entré le verrou en mode lecture mais pas de façon récursive, ou n si le thread a entré le verrou de façon récursive n - 1 fois. + 2 + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode pouvant être mis à niveau, comme une indication de récurrence. + 0 si le thread actuel n'a pas entré le verrou en mode pouvant être mis à niveau, 1 si le thread a entré le verrou en mode pouvant être mis à niveau mais pas de façon récursive, ou n si le thread a entré le verrou en mode pouvant être mis à niveau de façon récursive n - 1 fois. + 2 + + + Obtient le nombre de fois où le thread actuel a entré le verrou en mode écriture, comme une indication de récurrence. + 0 si le n si le thread a entré le verrou en mode écriture de façon récursive n - 1 fois. + 2 + + + Essaie d'entrer le verrou en mode lecture, avec un délai d'attente entier facultatif. + true si le thread appelant est entré en mode lecture, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode lecture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode lecture, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode de mise à niveau, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode pouvant être mis à niveau, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode de mise à niveau, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode écriture, sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Essaie d'entrer le verrou en mode écriture, avec un délai d'attente facultatif. + true si le thread appelant est entré en mode écriture, sinon, false. + Intervalle d'attente, ou -1 milliseconde pour un délai d'attente infini. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode lecture. + Nombre total de threads qui attendent pour entrer en mode lecture. + 2 + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode pouvant être mis à niveau. + Nombre total de threads qui attendent pour entrer en mode pouvant être mis à niveau. + 2 + + + Obtient le nombre total de threads qui attendent pour entrer le verrou en mode écriture. + Nombre total de threads qui attendent pour entrer en mode écriture. + 2 + + + Limite le nombre des threads qui peuvent accéder simultanément à une ressource ou un pool de ressources. + 1 + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est supérieur à . + + est inférieur à 1.ou est inférieur à 0. + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées, et en spécifiant en option le nom d'un objet sémaphore système. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nom d'un objet de sémaphore système nommé. + + est supérieur à .ou est plus de 260 caractères. + + est inférieur à 1.ou est inférieur à 0. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe et possède la sécurité du contrôle d'accès, et l'utilisateur n'a pas . + Le sémaphore nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + + Initialise une nouvelle instance de la classe en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées, en spécifiant en option le nom d'un objet sémaphore système et en spécifiant une variable qui reçoit une valeur indiquant si un sémaphore système a été créé. + Nombre initial de demandes pour le sémaphore qui peut être satisfait simultanément. + Nombre maximal de demandes pour le sémaphore qui peut être satisfait simultanément. + Nom d'un objet de sémaphore système nommé. + Cette méthode retourne true si un sémaphore local a été créé (en d'autres termes, si est null ou une chaîne vide) ou si le sémaphore système nommé spécifié a été créé ; false si le sémaphore système nommé spécifié existait déjà.Ce paramètre est passé sans être initialisé. + + est supérieur à . ou est plus de 260 caractères. + + est inférieur à 1.ou est inférieur à 0. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe et possède la sécurité du contrôle d'accès, et l'utilisateur n'a pas . + Le sémaphore nommé ne peut pas être créé, peut-être parce qu'un handle d'attente d'un type différent possède le même nom. + + + Ouvre le sémaphore nommé spécifié s'il existe déjà. + Objet qui représente le sémaphore système nommé. + Nom du sémaphore système à ouvrir. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Le sémaphore nommé n'existe pas. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + 1 + + + + + + Quitte le sémaphore et retourne le compteur antérieur. + Compteur du sémaphore avant appel de la méthode . + Le compteur du sémaphore est déjà à la valeur maximale. + Une erreur Win32 s'est produite avec un sémaphore nommé. + Le sémaphore actuel représente un sémaphore système nommé, mais l'utilisateur ne détient pas de droits .ouLe sémaphore actuel représente un sémaphore système nommé, mais il n'a pas été ouvert avec des droits . + 1 + + + Quitte le sémaphore un nombre spécifié de fois et retourne le compteur précédent. + Compteur du sémaphore avant appel de la méthode . + Nombre de fois où quitter le sémaphore. + + est inférieur à 1. + Le compteur du sémaphore est déjà à la valeur maximale. + Une erreur Win32 s'est produite avec un sémaphore nommé. + Le sémaphore actuel représente un sémaphore système nommé, mais l'utilisateur ne détient pas de droits .ouLe sémaphore actuel représente un sémaphore système nommé, mais il n'a pas été ouvert avec des droits . + 1 + + + Ouvre le sémaphore nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi. + true si le sémaphore nommé a été ouvert ; sinon, false. + Nom du sémaphore système à ouvrir. + Quand cette méthode est retournée, contient un objet qui représente le sémaphore nommé si l'appel a réussi, ou null si l'appel a échoué.Ce paramètre est traité comme étant non initialisé. + + est une chaîne vide.ou est plus de 260 caractères. + + a la valeur null. + Une erreur Win32 s'est produite. + Le sémaphore nommé existe, mais l'utilisateur ne possède pas l'accès de sécurité requis pour l'utiliser. + + + Exception levée lorsque la méthode est appelée sur un sémaphore dont le compteur est déjà au maximum. + 2 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Représente une alternative légère à qui limite le nombre de threads pouvant accéder simultanément à une ressource ou à un pool de ressources. + + + Initialise une nouvelle instance de la classe , en spécifiant le nombre initial de demandes qui peuvent être accordées simultanément. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est inférieur à 0. + + + Initialise une nouvelle instance de la classe , en spécifiant le nombre initial et le nombre maximal de demandes qui peuvent être accordées simultanément. + Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément. + Nombre maximal de demandes pour le sémaphore qui peuvent être accordées simultanément. + + est inférieur à 0 ou est supérieur à ou est inférieur ou égal à 0. + + + Retourne un qui peut être utilisé pour l'attente sur le sémaphore. + + qui peut être utilisé pour l'attente sur le sémaphore. + + a été supprimé. + + + Obtient le nombre de threads restants qui peuvent accéder à l'objet . + Nombre de threads restants qui peuvent accéder au sémaphore. + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources non managées utilisées par le , et libère éventuellement les ressources managées. + true pour libérer les ressources managées et non managées ; false pour ne libérer que les ressources non managées. + + + Libère l'objet une seule fois. + Décompte précédent de . + L'instance actuelle a déjà été supprimée. + Le a déjà atteint sa taille maximale. + + + Libère l'objet un nombre de fois déterminé. + Décompte précédent de . + Nombre de fois où quitter le sémaphore. + L'instance actuelle a déjà été supprimée. + + est inférieur à 1. + Le a déjà atteint sa taille maximale. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à . + L'instance actuelle a déjà été supprimée. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un entier signé 32 bits qui spécifie le délai d'attente. + true si le thread actuel a accédé avec succès à  ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un entier signé 32 bits qui spécifie le délai d'attente, tout en observant un . + true si le thread actuel a accédé avec succès à  ; sinon, false. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + a été annulé. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + Le instance a été supprimée, ou qui créé a été supprimé. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , tout en observant un . + Jeton à observer. + + a été annulé. + L'instance actuelle a déjà été supprimée.ouLes créés a déjà été supprimé. + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un pour spécifier le délai d'attente. + true si le thread actuel a accédé avec succès à  ; sinon, false. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde de seconde, pour attendre indéfiniment. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + L'instance de semaphoreSlim a été supprimée + + + Bloque le thread actuel jusqu'à ce qu'il puisse accéder à , à l'aide d'un qui spécifie le délai d'attente, tout en observant un . + true si le thread actuel a accédé avec succès à  ; sinon, false. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente -1 millième de seconde, pour attendre indéfiniment. + + à observer. + + a été annulé. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + L'instance de semaphoreSlim a été suppriméeLe qui a créé a déjà été supprimé. + + + Attend de façon asynchrone avant d'accéder à . + Tâche qui se termine après l'accès au sémaphore. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps. + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps, tout en observant un . + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + + à observer. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + L'instance actuelle a déjà été supprimée. + + a été annulé. + + + Attend de façon asynchrone d'accéder à , tout en observant un . + Tâche qui se termine après l'accès au sémaphore. + Jeton à observer. + L'instance actuelle a déjà été supprimée. + + a été annulé. + + + Attend de façon asynchrone d'accéder à , à l'aide d'un pour mesurer l'intervalle de temps. + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + + qui représente le nombre de millisecondes à attendre ou qui représente -1 milliseconde de seconde, pour attendre indéfiniment. + L'instance actuelle a déjà été supprimée. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. ou délai d'attente supérieur à . + + + Attend de façon asynchrone d'accéder à , à l'aide d'un pour mesurer l'intervalle de temps, tout en observant un . + Tâche qui se termine avec une valeur true si le thread actuel accède correctement à , sinon la valeur false est retournée. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente -1 millième de seconde, pour attendre indéfiniment. + Jeton à observer. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini.oudélai d'attente supérieur à . + + a été annulé. + + + Représente une méthode à appeler lorsqu'un message doit être distribué à un contexte de synchronisation. + Objet passé au délégué. + 2 + + + Fournit une primitive de verrou d'exclusion mutuelle où un thread qui tente d'acquérir le verrou attend dans une boucle en vérifiant de manière répétée jusqu'à ce que le verrou devienne disponible. + + + Initialise une nouvelle instance de la structure de avec l'option permettant de suivre les ID de thread afin d'améliorer le débogage. + Indique s'il faut capturer et utiliser des ID de thread à des fins de débogage. + + + Acquiert le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + L'argument doit être initialisé sur false avant d'appeler ENTRÉE. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Libère le verrou. + Le suivi de la propriété du thread est autorisé, et le thread actuel n'est pas le propriétaire de ce verrou. + + + Libère le verrou. + Valeur booléenne qui indique si une barrière mémoire doit être émise pour publier immédiatement l'opération de sortie sur d'autres threads. + Le suivi de la propriété du thread est autorisé, et le thread actuel n'est pas le propriétaire de ce verrou. + + + Obtient une valeur qui indique si le verrou est actuellement détenu par un thread. + True si le verrou est actuellement détenu par un thread ; sinon, false. + + + Obtient une valeur qui indique si le verrou est détenu par le thread actuel. + True si le verrou est détenu par le thread actuel ; sinon, false. + Le suivi de la propriété du thread est désactivé. + + + Obtient une valeur qui indique si le suivi de la propriété des threads est activé pour cette instance. + True si le suivi de la propriété du thread est autorisé pour cette instance ; sinon, false. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Tente d'acquérir le verrou de façon fiable, de sorte que même si une exception se produit dans l'appel de méthode, peut être examiné de façon fiable pour déterminer si le verrou a été acquis. + + qui représente le nombre de millièmes de secondes à attendre ou qui représente - 1 millième de seconde, pour attendre indéfiniment. + True si le verrou est acquis ; sinon, false. doit être initialisé avec la valeur false avant l'appel à cette méthode. + + est un nombre négatif autre que -1 milliseconde, qui représente un délai d'attente infini - ou - le délai d'attente est supérieur à millisecondes. + L'argument doit être initialisé sur false avant d'appeler TryEnter. + Le suivi de la propriété du thread est activé et le thread actuel a déjà acquis ce verrou. + + + Fournit une prise en charge de l'attente basée sur les spins. + + + Obtient le nombre de fois où a été appelé sur cette instance. + Retourne un entier qui représente le nombre d'appels de sur cette instance. + + + Obtient une valeur qui indique si l'appel suivant à générera le processeur, en déclenchant un changement de contexte forcé. + Indique si l'appel suivant à générera le processeur, en déclenchant un changement de contexte forcé. + + + Réinitialise le compteur de spins. + + + Exécute un seul spin. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + L'argument a la valeur null. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite ou jusqu'à ce que le délai d'attente expire. + True si la condition est satisfaite dans le délai d'attente ; sinon, false. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + Nombre de millisecondes à attendre, ou (-1) pour un délai d'attente infini. + L'argument a la valeur null. + + est un nombre négatif autre que -1, qui représente un délai d'attente infini. + + + Effectue des spins jusqu'à ce que la condition spécifiée soit satisfaite ou jusqu'à ce que le délai d'attente expire. + True si la condition est satisfaite dans le délai d'attente ; sinon, false. + Délégué à exécuter de façon répétée jusqu'à ce qu'il retourne la valeur true. + + qui représente le nombre de millièmes de secondes à attendre, ou TimeSpan qui représente -1 millième de seconde pour attendre indéfiniment. + L'argument a la valeur null. + + est un nombre négatif autre que -1 millisecondes, qui représente un délai d'expiration infini - ou - le délai d'attente est supérieur à . + + + Fournit les fonctionnalités de base pour propager un contexte de synchronisation dans plusieurs modèles de synchronisation. + 2 + + + Crée une instance de la classe . + + + En cas de substitution dans une classe dérivée, crée une copie du contexte de synchronisation. + Nouvel objet . + 2 + + + Obtient le contexte de synchronisation du thread actuel. + Objet représentant le contexte de synchronisation actuel. + 1 + + + Lors d'une substitution dans une classe dérivée, répond à la notification selon laquelle une opération est terminée. + + + Lors d'une substitution dans une classe dérivée, répond à la notification selon laquelle une opération est lancée. + + + Lors d'une substitution dans une classe dérivée, distribue un message asynchrone à un contexte de synchronisation. + Délégué à appeler. + Objet passé au délégué. + 2 + + + Lors d'une substitution dans une classe dérivée, distribue un message synchrone à un contexte de synchronisation. + Délégué à appeler. + Objet passé au délégué. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Définit le contexte de synchronisation actuel. + Objet à définir. + 1 + + + + + + Exception levée lorsqu'une méthode exige de l'appelant qu'il possède un verrou sur un objet Monitor donné et que la méthode est appelée par un appelant qui ne possède pas ce verrou. + 2 + + + Initialise une nouvelle instance de la classe avec des propriétés par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + Fournit le stockage local des données de thread. + Spécifie le type de données stockées par thread. + + + Initialise l'instance de . + + + Initialise l'instance de . + Indique s'il faut suivre toutes les valeurs définies dans l'instance et les exposer via la propriété . + + + Initialise l'instance de avec la fonction spécifiée. + + appelé pour produire une valeur initialisée tardivement lorsqu'une tentative est effectuée pour récupérer sans qu'il ait été précédemment initialisé. + + est une référence null (Nothing en Visual Basic). + + + Initialise l'instance de avec la fonction spécifiée. + + appelé pour produire une valeur initialisée tardivement lorsqu'une tentative est effectuée pour récupérer sans qu'il ait été précédemment initialisé. + Indique s'il faut suivre toutes les valeurs définies dans l'instance et les exposer via la propriété . + + est une référence null (Nothing en Visual Basic). + + + Libère toutes les ressources utilisées par l'instance actuelle de la classe . + + + Libère les ressources utilisées par cette instance de . + Valeur booléenne qui indique si cette méthode est appelée en raison d'un appel à . + + + Libère les ressources utilisées par cette instance de . + + + Obtient une valeur qui indique si est initialisé sur le thread actuel. + True si est initialisé sur le thread actuel ; sinon, false. + L'instance de a été supprimée. + + + Crée et retourne une représentation sous forme de chaîne de cette instance pour le thread actuel. + Résultat de l'appel à sur . + L'instance de a été supprimée. + Le du thread actuel est une référence null (Nothing en Visual Basic). + La fonction d'initialisation a tenté de référencer de manière récursive. + Aucun constructeur par défaut n'est fourni et aucune fabrique de valeurs n'est fournie. + + + Obtient ou définit la valeur de cette instance pour le thread actuel. + Retourne une instance de l'objet dont ce ThreadLocal est chargé de l'initialisation. + L'instance de a été supprimée. + La fonction d'initialisation a tenté de référencer de manière récursive. + Aucun constructeur par défaut n'est fourni et aucune fabrique de valeurs n'est fournie. + + + Obtient une liste de toutes les valeurs actuellement stockées par tous les threads qui ont accès à cette instance. + Liste de toutes les valeurs actuellement stockées par tous les threads qui ont accès à cette instance. + L'instance de a été supprimée. + + + Contient des méthodes permettant d'effectuer des opérations de mémoire volatile. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la valeur du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Valeur qui a été lue.Il s'agit de la dernière valeur écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + + + Lit la référence d'objet à partir du champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît après cette méthode dans le code, le processeur ne peut pas la déplacer avant cette méthode. + Référence à qui a été lue.Il s'agit de la dernière référence écrite par un processeur de l'ordinateur, quel que soit le nombre de processeurs ou l'état du cache de processeur. + Champ à lire. + Type du champ à lire.Il doit s'agir d'un type référence, et non d'un type valeur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de mémoire apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la valeur spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la valeur est écrite. + Valeur à écrire.La valeur est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + + + Écrit la référence d'objet spécifiée dans le champ spécifié.Sur les systèmes le nécessitant, insère une barrière de mémoire qui empêche le processeur de réorganiser les opérations de mémoire comme suit : si une opération de lecture ou d'écriture apparaît avant cette méthode dans le code, le processeur ne peut pas la déplacer après cette méthode. + Champ dans lequel la référence d'objet est écrite. + Référence d'objet à écrire.La référence est écrite immédiatement, de sorte qu'elle est visible pour tous les processeurs de l'ordinateur. + Type du champ dans lequel écrire.Il doit s'agir d'un type référence, et non d'un type valeur. + + + Exception levée lors d'une tentative d'ouverture d'un mutex système ou d'un sémaphore qui n'existe pas. + 2 + + + Initialise une nouvelle instance de la classe avec les valeurs par défaut. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié. + Message d'erreur indiquant la raison de l'exception. + + + Initialise une nouvelle instance de la classe avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception. + Message d'erreur indiquant la raison de l'exception. + Exception qui constitue la cause de l'exception actuelle.Si le paramètre n'est pas null, l'exception en cours est levée dans un bloc catch qui gère l'exception interne. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/it/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/it/System.Threading.xml new file mode 100644 index 000000000..3446f031d --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/it/System.Threading.xml @@ -0,0 +1,1800 @@ + + + + System.Threading + + + + Eccezione generata quando un thread acquisisce un oggetto che un altro thread ha abbandonato uscendo senza rilasciarlo. + 1 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un indice specificato per il mutex abbandonato, se applicabile, e un oggetto che rappresenta il mutex. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo o –1 se l'eccezione viene generata per i metodi o . + Oggetto che rappresenta il mutex abbandonato. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore che spiega il motivo dell'eccezione. + + + Inizializza una nuova istanza della classe con il messaggio di errore e l'eccezione interna specificati. + Messaggio di errore che spiega il motivo dell'eccezione. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente verrà generata in un blocco catch che gestisce l'eccezione interna. + + + Inizializza una nuova istanza della classe con il messaggio di errore, l'eccezione interna, l'indice per il mutex abbandonato, se applicabile, specificati e un oggetto che rappresenta il mutex. + Messaggio di errore che spiega il motivo dell'eccezione. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente verrà generata in un blocco catch che gestisce l'eccezione interna. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo , –1 se l'eccezione viene generata per il metodo o . + Oggetto che rappresenta il mutex abbandonato. + + + Inizializza una nuova istanza della classe con il messaggio di errore, l'indice del mutex abbandonato, se applicabile, e il mutex abbandonato specificati. + Messaggio di errore che spiega il motivo dell'eccezione. + Indice del mutex abbandonato nella matrice degli handle di attesa se l'eccezione viene generata per il metodo , –1 se l'eccezione viene generata per il metodo o . + Oggetto che rappresenta il mutex abbandonato. + + + Ottiene il mutex abbandonato che ha causato l'eccezione, se noto. + Oggetto che rappresenta il mutex abbandonato oppure null se il mutex abbandonato non è stato identificato. + 1 + + + Ottiene l'indice del mutex abbandonato che ha causato l'eccezione, se noto. + Nella matrice degli handle in attesa passati al metodo , indice dell'oggetto che rappresenta il mutex abbandonato oppure –1 se l'indice del mutex abbandonato non è stato determinato. + 1 + + + Rappresenta dati di ambiente locali rispetto a un flusso di controllo asincrono specificato, ad esempio un metodo asincrono. + Tipo dei dati di ambiente. + + + Crea un'istanza dell'istanza di che non riceve notifiche di modifica. + + + Crea un'istanza dell'istanza di locale che riceve notifiche di modifica. + Delegato chiamato ogni volta che il valore corrente cambia in qualsiasi thread. + + + Ottiene o imposta il valore dei dati di ambiente. + Valore dei dati di ambiente. + + + Classe che fornisce le informazioni di modifica dei dati alle istanze di registrate per le notifiche di modifica. + Tipo di dati. + + + Ottiene il valore corrente dei dati. + Valore corrente dei dati. + + + Ottiene il valore precedente dei dati. + Valore precedente dei dati. + + + Restituisce un valore che indica se il valore cambia a seguito di una modifica del contesto di esecuzione. + true se il valore è cambiato a seguito di una modifica del contesto di esecuzione; in caso contrario, false. + + + Notifica a un thread in attesa che si è verificato un evento.La classe non può essere ereditata. + 2 + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato. + true per impostare lo stato iniziale su segnalato; false per impostare lo stato iniziale su non segnalato. + + + Consente a più attività di funzionare cooperativamente in un algoritmo in parallelo tramite più fasi. + + + Inizializza una nuova istanza della classe . + Numero di thread che partecipano. + + è minore di 0 o maggiore di 32,767. + + + Inizializza una nuova istanza della classe . + Numero di thread che partecipano. + Oggetto da eseguire dopo ogni fase. Può essere passato Null (Nothing in Visual Basic) per indicare che non è stata intrapresa alcuna azione. + + è minore di 0 o maggiore di 32,767. + + + Notifica all'oggetto che sarà presente un partecipante aggiuntivo. + Numero di fase della barriera in corrispondenza di cui parteciperanno inizialmente i nuovi partecipanti. + L'istanza corrente è già stata eliminata. + L'aggiunta di un partecipante provocherebbe il superamento del conteggio del partecipante della barriera di 32.767.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Notifica all'oggetto che saranno presenti partecipanti aggiuntivi. + Numero di fase della barriera in corrispondenza di cui parteciperanno inizialmente i nuovi partecipanti. + Numero di partecipanti aggiuntivi da aggiungere alla barriera. + L'istanza corrente è già stata eliminata. + + è minore di 0.- oppure -L'aggiunta di partecipanti provocherebbe il superamento del conteggio del partecipante della barriera di 32.767. + Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Ottiene il numero di fase corrente della barriera. + Restituisce il numero di fase corrente della barriera. + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo quelle non gestite. + + + Ottiene il numero totale di partecipanti nella barriera. + Restituisce il numero totale di partecipanti nella barriera. + + + Ottiene il numero di partecipanti nella barriera che non hanno ancora eseguito la segnalazione nella fase corrente. + Restituisce il numero di partecipanti nella barriera che non hanno ancora eseguito la segnalazione nella fase corrente. + + + Notifica all'oggetto che sarà presente un partecipante in meno. + L'istanza corrente è già stata eliminata. + La barriera dispone già di 0 partecipanti.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. + + + Notifica all'oggetto che saranno presenti meno partecipanti. + Numero di partecipanti aggiuntivi da rimuovere dalla barriera. + L'istanza corrente è già stata eliminata. + + è minore di 0. + La barriera dispone già di 0 partecipanti.- oppure -Il metodo è stato richiamato dall'interno di un'azione post-fase. - oppure -il conteggio del partecipante corrente è minore del conteggio del partecipante specificato + Il conteggio totale dei partecipanti è minore del specificato + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti. + L'istanza corrente è già stata eliminata. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + Se un'eccezione viene generata da un'azione post-fase di una Barriera dopo che tutti thread che partecipano hanno chiamato SignalAndWait, l'eccezione verrà sottoposta a wrapping in un BarrierPostPhaseException e sarà generata su tutti i thread che partecipano. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un Signed Integer a 32 bit per misurare il timeout. + true se tutti i partecipanti raggiungono la barriera entro il tempo specificato; in caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + Se un'eccezione viene generata da un'azione post-fase di una Barriera dopo che tutti thread che partecipano hanno chiamato SignalAndWait, l'eccezione verrà sottoposta a wrapping in un BarrierPostPhaseException e sarà generata su tutti i thread che partecipano. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un Signed Integer a 32 bit per misurare il timeout, al contempo osservando un token di annullamento. + true se tutti i partecipanti raggiungono la barriera entro il tempo specificato; in caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, al contempo osservando un token di annullamento. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un oggetto per misurare l'intervallo di tempo. + true se tutti gli altri partecipanti hanno raggiunto la barriera. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito, oppure è più grande di 32.767. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Segnala che un partecipante ha raggiunto la barriera e attende che venga raggiunta anche da tutti gli altri partecipanti, utilizzando un oggetto per misurare l'intervallo di tempo, al contempo osservando un token di annullamento. + true se tutti gli altri partecipanti hanno raggiunto la barriera. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito. + Il metodo viene richiamato dall'interno di un'azione post-fase, la barriera dispone attualmente di 0 partecipanti o la barriera viene segnalata da più thread registrati come partecipanti. + + + Eccezione generata quando l'azione post-fase di un oggetto non viene eseguita correttamente. + + + Inizializza una nuova istanza della classe con un messaggio fornito dal sistema in cui viene descritto l'errore. + + + Inizializza una nuova istanza della classe con l'eccezione interna specificata. + Eccezione causa dell'eccezione corrente. + + + Inizializza una nuova istanza della classe con un messaggio specifico in cui viene descritto l'errore. + Messaggio in cui viene descritta l'eccezione.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio in cui viene descritta l'eccezione.È necessario che il chiamante del costruttore assicuri che la stringa sia stata localizzata per le impostazioni cultura correnti del sistema. + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Rappresenta un metodo da chiamare all'interno di un nuovo contesto. + Oggetto contenente informazioni che devono essere utilizzate dal metodo di callback ogni volta che viene eseguito. + 1 + + + Rappresenta un primitiva di sincronizzazione segnalata quando il relativo conteggio raggiunge lo zero. + + + Inizializza una nuova istanza della classe con il conteggio specificato. + Numero di segnali inizialmente richiesti per impostare l'oggetto . + + è minore di 0. + + + Incrementa di uno il conteggio corrente di . + L'istanza corrente è già stata eliminata. + L'istanza corrente è già impostata.- oppure - è maggiore di o uguale a . + + + Incrementa di un valore specificato il conteggio corrente di . + Valore che indica l'incremento di . + L'istanza corrente è già stata eliminata. + + è minore o uguale a 0. + L'istanza corrente è già impostata.- oppure - è uguale o maggiore a dopo che il conteggio è incrementato da + + + Ottiene il numero di segnali restanti necessari per impostare l'evento. + Numero di segnali restanti necessari per impostare l'evento. + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite utilizzate dall'oggetto ed eventualmente rilascia le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite, false per rilasciare solo quelle non gestite. + + + Ottiene il numero di segnali necessari inizialmente per impostare l'evento. + Numero di segnali necessari inizialmente per impostare l'evento. + + + Determina se l'evento è impostato. + true se l'evento è impostato, altrimenti false. + + + Reimposta sul valore di . + L'istanza corrente è già stata eliminata. + + + Reimposta la proprietà al valore specificato. + Numero di segnali necessari per impostare l'oggetto . + L'istanza corrente è già stata eliminata. + + è minore di 0. + + + Registra un segnale con l'oggetto , decrementando il valore di . + true se il conteggio ha raggiunto lo zero a causa del segnale e l'evento è stato impostato. In caso contrario, false. + L'istanza corrente è già stata eliminata. + L'istanza corrente è già impostata. + + + Registra più segnali con l'oggetto , decrementandone il valore di della quantità specificata. + true se il conteggio ha raggiunto lo zero a causa dei segnali e l'evento è stato impostato. In caso contrario, false. + Numero di segnali da registrare. + L'istanza corrente è già stata eliminata. + + è minore di 1. + L'istanza corrente è già impostata. oppure è maggiore di . + + + Tenta di incrementare di uno. + true se l'incremento ha avuto esito positivo. In caso contrario, false.Se è già zero, questo metodo restituirà false. + L'istanza corrente è già stata eliminata. + + è uguale a . + + + Tenta di incrementare in base a un valore specificato. + true se l'incremento ha avuto esito positivo. In caso contrario, false.Se è già zero, verrà restituito false. + Valore che indica l'incremento di . + L'istanza corrente è già stata eliminata. + + è minore o uguale a 0. + L'istanza corrente è già impostata.- oppure - + è uguale o maggiore di . + + + Blocca il thread corrente finché l'oggetto non viene impostato. + L'istanza corrente è già stata eliminata. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un intero con segno a 32 bit per misurare il timeout. + true se è stato impostato. In caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un intero con segno a 32 bit per misurare il timeout e al contempo osservando un oggetto . + true se è stato impostato. In caso contrario, false. + Numero di millisecondi di attesa oppure, per un'attesa indefinita, (-1). + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, al contempo osservando un oggetto . + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un oggetto per misurare il timeout. + true se è stato impostato. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Blocca il thread corrente finché l'oggetto non viene impostato, utilizzando un oggetto per misurare il timeout e al contempo osservando un oggetto . + true se è stato impostato. In caso contrario, false. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata. oppure l'oggetto aveva creato è già stato eliminato. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Ottiene un oggetto utilizzato per attendere l'impostazione dell'evento. + Oggetto utilizzato per attendere l'impostazione dell'evento. + L'istanza corrente è già stata eliminata. + + + Indica se verrà reimpostato automaticamente o manualmente dopo la ricezione di un segnale. + 2 + + + Con la segnalazione, viene reimpostato automaticamente dopo il rilascio di un singolo thread.Se non sono presenti thread in attesa, resta segnalato fino al blocco di un thread e viene reimpostato dopo il rilascio del thread. + + + Con la segnalazione, rilascia tutti i thread in attesa e resta segnalato finché non viene reimpostato manualmente. + + + Rappresenta un evento di sincronizzazione dei thread. + 2 + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato e se la reimpostazione viene eseguita automaticamente o manualmente. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato se creato a seguito di questa chiamata e se la reimpostazione viene eseguita automaticamente o manualmente e indicando il nome di un evento di sincronizzazione di sistema. + true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato in seguito a questa chiamata; false per impostare lo stato su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + Nome di un evento di sincronizzazione a livello di sistema. + Si è verificato un errore Win32. + L'evento denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non possiede i diritti . + Non è possibile creare l'evento denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è di lunghezza superiore a 260 caratteri. + + + Inizializza una nuova istanza della classe , specificando se l'handle di attesa è inizialmente segnalato se creato a seguito di questa chiamata e se la reimpostazione viene eseguita automaticamente o manualmente e indicando il nome di un evento di sincronizzazione di sistema e una variabile Boolean il cui valore dopo la chiamata specifica se l'evento di sistema denominato è stato creato. + true per impostare lo stato iniziale su segnalato se l'evento denominato viene creato in seguito a questa chiamata; false per impostare lo stato su non segnalato. + Uno dei valori di che determina se l'evento viene reimpostato automaticamente o manualmente. + Nome di un evento di sincronizzazione a livello di sistema. + Quando questo metodo viene restituito, contiene true se è stato creato un evento locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato l'evento di sistema denominato specificato; false se l'evento di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + Si è verificato un errore Win32. + L'evento denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non possiede i diritti . + Non è possibile creare l'evento denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è di lunghezza superiore a 260 caratteri. + + + Apre l'evento di sincronizzazione denominato specificato, se esistente. + Oggetto che rappresenta l'evento di sistema denominato. + Nome dell'evento di sincronizzazione del sistema da aprire. + + è una stringa vuota. In alternativa è di lunghezza superiore a 260 caratteri. + + è null. + L'evento di sistema denominato non esiste. + Si è verificato un errore Win32. + L'evento denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread. + true se l'operazione ha esito positivo; in caso contrario, false. + Il metodo non è stato chiamato precedentemente in questo oggetto . + 2 + + + Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa di procedere. + true se l'operazione ha esito positivo; in caso contrario, false. + Il metodo non è stato chiamato precedentemente in questo oggetto . + 2 + + + Apre l'evento di sincronizzazione denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è stata completata. + true se l'evento di sincronizzazione denominato è stato aperto correttamente; in caso contrario, false. + Nome dell'evento di sincronizzazione del sistema da aprire. + Quando viene eseguita la restituzione del metodo, contiene un oggetto di che rappresenta l'evento di sincronizzazione denominato se la chiamata ha esito positivo, o null se la chiamata ha esito negativo.Questo parametro viene trattato come non inizializzato. + + è una stringa vuota.In alternativa è di lunghezza superiore a 260 caratteri. + + è null. + Si è verificato un errore Win32. + L'evento denominato esiste, ma l'utente non dispone dell'accesso di sicurezza desiderato. + + + Gestisce il contesto di esecuzione per il thread corrente.La classe non può essere ereditata. + 2 + + + Acquisisce il contesto di esecuzione dal thread corrente. + Oggetto che rappresenta il contesto di esecuzione per il thread corrente. + 1 + + + Esegue un metodo in un contesto di esecuzione specifico sul thread corrente. + Oggetto da impostare. + Delegato che rappresenta il metodo da eseguire nel contesto di esecuzione fornito. + Oggetto da passare al metodo di callback. + + è null.- oppure - non è stato acquisito tramite un'operazione di acquisizione. - oppure - è stato già utilizzato come argomento per una chiamata . + 1 + + + + + + Fornisce operazioni atomiche per variabili condivise da più thread. + 2 + + + Somma due interi a 32 bit e sostituisce il primo intero con la somma, come operazione atomica. + Nuovo valore archiviato in . + Variabile contenente il primo valore da sommare.La somma dei due valori viene archiviata in . + Valore da sommare all'intero in corrispondenza di . + The address of is a null pointer. + 1 + + + Somma due interi a 64 bit e sostituisce il primo intero con la somma, come operazione atomica. + Nuovo valore archiviato in . + Variabile contenente il primo valore da sommare.La somma dei due valori viene archiviata in . + Valore da sommare all'intero in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due numeri a virgola mobile e precisione doppia per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due interi con segno a 32 bit per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due interi con segno a 64 bit per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due puntatori o handle specifici della piattaforma per verificarne l'uguaglianza; se sono uguali, sostituisce il primo elemento. + Valore originale in . + Oggetto di destinazione, il cui valore viene confrontato con il valore di e, se possibile, sostituito da . + Oggetto che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Oggetto confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due oggetti per verificarne l'uguaglianza dei riferimenti; se sono uguali, sostituisce il primo oggetto. + Valore originale in . + Oggetto di destinazione confrontato con e, se possibile, sostituito. + Oggetto che sostituisce l'oggetto di destinazione se il confronto rileva l'uguaglianza. + Oggetto confrontato con l'oggetto in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due numeri a virgola mobile e precisione singola per verificarne l'uguaglianza; se sono uguali, sostituisce il primo valore. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito. + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + The address of is a null pointer. + 1 + + + Confronta due istanze del tipo di riferimento specificato per verificarne l'uguaglianza; se sono uguali, sostituisce la prima istanza. + Valore originale in . + Destinazione, il cui valore viene confrontato con e, se possibile, sostituito.Rappresenta un parametro di riferimento (ref in C#, ByRef in Visual Basic). + Valore che sostituisce il valore di destinazione se il confronto rileva l'uguaglianza. + Valore confrontato con il valore in corrispondenza di . + Tipo da usare per , e .Questo tipo deve essere un tipo di riferimento. + The address of is a null pointer. + + + Diminuisce una variabile specificata e archivia il risultato, come operazione atomica. + Valore diminuito. + Variabile il cui valore deve essere diminuito. + The address of is a null pointer. + 1 + + + Diminuisce la variabile specificata e archivia il risultato, come operazione atomica. + Valore diminuito. + Variabile il cui valore deve essere diminuito. + The address of is a null pointer. + 1 + + + Imposta un numero a virgola mobile e precisione doppia su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un intero con segno a 32 bit su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un intero con segno a 64 bit su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un puntatore o un handle specifico della piattaforma su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un oggetto su un valore specificato e restituisce un riferimento all'oggetto originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta un numero a virgola mobile e precisione singola su un valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato. + Valore su cui è impostato il parametro . + The address of is a null pointer. + 1 + + + Imposta una variabile del tipo indicato sul valore specificato e restituisce il valore originale, come operazione atomica. + Valore originale di . + Variabile da impostare sul valore specificato.Rappresenta un parametro di riferimento (ref in C#, ByRef in Visual Basic). + Valore su cui è impostato il parametro . + Tipo da usare per e .Questo tipo deve essere un tipo di riferimento. + The address of is a null pointer. + + + Aumenta una variabile specificata e archivia il risultato, come operazione atomica. + Valore aumentato. + Variabile il cui valore deve essere aumentato. + The address of is a null pointer. + 1 + + + Aumenta una variabile specificata e archivia il risultato, come operazione atomica. + Valore aumentato. + Variabile il cui valore deve essere aumentato. + The address of is a null pointer. + 1 + + + Sincronizza l'accesso alla memoria come segue: il processore che esegue il thread corrente non può riordinare le istruzioni in modo tale che gli accessi alla memoria prima della chiamata al metodo vengano eseguiti dopo quelli successivi alla chiamata al metodo . + + + Restituisce un valore a 64 bit, caricato come operazione atomica. + Valore caricato. + Valore a 64 bit da caricare. + 1 + + + Fornisce routine di inizializzazione differita. + + + Inizializza un tipo di riferimento di destinazione con il relativo costruttore predefinito se non è già stato inizializzato. + Riferimento inizializzato di tipo . + Riferimento di tipo da inizializzare se non è già stato inizializzato. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento o di valore di destinazione con il relativo costruttore predefinito se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento o valore di tipo da inizializzare se non è già stato inizializzato. + Riferimento a un valore booleano che determina se la destinazione è già stata inizializzata. + Riferimento a un oggetto utilizzato come blocco a esclusione reciproca per l'inizializzazione di .Se è null, verrà creata un'istanza di un nuovo oggetto. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento o di valore di destinazione utilizzando una funzione specificata se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento o valore di tipo da inizializzare se non è già stato inizializzato. + Riferimento a un valore booleano che determina se la destinazione è già stata inizializzata. + Riferimento a un oggetto utilizzato come blocco a esclusione reciproca per l'inizializzazione di .Se è null, verrà creata un'istanza di un nuovo oggetto. + Funzione chiamata per inizializzare il riferimento o il valore. + Tipo del riferimento da inizializzare. + Le autorizzazioni per accedere al costruttore di tipo erano mancanti. + Il tipo non dispone di un costruttore predefinito. + + + Inizializza un tipo di riferimento di destinazione utilizzando una funzione specificata se non è già stato inizializzato. + Valore inizializzato di tipo . + Riferimento di tipo da inizializzare se non è già stato inizializzato. + Funzione chiamata per inizializzare il riferimento. + Tipo del riferimento da inizializzare. + Il tipo non dispone di un costruttore predefinito. + + restituisce null (Nothing in Visual Basic). + + + Eccezione generata quando una voce ricorsiva in un blocco non è compatibile con i criteri di ricorsione per tale blocco. + 2 + + + Inizializza una nuova istanza della classe con un messaggio fornito dal sistema in cui viene descritto l'errore. + 2 + + + Inizializza una nuova istanza della classe con un messaggio specifico in cui viene descritto l'errore. + Messaggio in cui viene descritta l'eccezione.Il chiamante di questo costruttore deve assicurare che la stringa sia stata localizzata in base alle impostazioni cultura correnti del sistema. + 2 + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio in cui viene descritta l'eccezione.Il chiamante di questo costruttore deve assicurare che la stringa sia stata localizzata in base alle impostazioni cultura correnti del sistema. + Eccezione che ha causato l'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + 2 + + + Specifica se lo stesso thread può accedere a un blocco più volte. + + + Se un thread tenta di accedere a un blocco in modo ricorsivo, viene generata un'eccezione.È possibile che alcune classi consentano particolari ricorsioni quando questa impostazione è attivata. + + + Un thread può accedere a un blocco in modo ricorsivo.Alcune classi possono limitare questa funzionalità. + + + Notifica a uno o più thread in attesa che si è verificato un evento.La classe non può essere ereditata. + 2 + + + Consente l'inizializzazione di una nuova istanza della classe con un valore Booleano che indica se lo stato iniziale deve essere impostato su segnalato. + Viene restituito true per impostare lo stato iniziale su segnalato; false per impostare lo stato iniziale su non segnalato. + + + Fornisce una versione più snella di . + + + Inizializza una nuova istanza della classe con uno stato iniziale di non segnalato. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se impostare lo stato iniziale su segnalato e un conteggio rotazioni specificato. + true per impostare lo stato iniziale su segnalato; false per impostarlo su non segnalato. + Numero di attese di rotazione che devono verificarsi prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + + is less than 0 or greater than the maximum allowed value. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dall'oggetto e facoltativamente rilascia le risorse gestite. + True per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Ottiene un valore che indica se l'evento è impostato. + true se l'evento è impostato; in caso contrario, false. + + + Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread. + The object has already been disposed. + + + Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa dell'evento di procedere. + + + Ottiene il numero di attese di rotazione che si verificheranno prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + Restituisce il numero di attese di rotazione che si verificheranno prima di eseguire il fallback su un'operazione di attesa basata sul kernel. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un intero con segno a 32 bit per misurare l'intervallo di tempo. + true se l'oggetto è stato impostato; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un intero con segno a 32 bit per misurare l'intervallo di tempo e osservando un oggetto . + true se l'oggetto è stato impostato; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non riceve un segnale, osservando un oggetto . + Oggetto da osservare. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un oggetto per misurare l'intervallo di tempo. + true se l'oggetto è stato impostato; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Blocca il thread corrente finché l'oggetto corrente non viene impostato, usando un oggetto per misurare l'intervallo di tempo e osservando un oggetto . + true se l'oggetto è stato impostato; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Ottiene l'oggetto sottostante per questo oggetto . + Oggetto evento sottostante per questo oggetto . + + + Fornisce un meccanismo che sincronizza l'accesso agli oggetti. + 2 + + + Acquisisce un blocco esclusivo sull'oggetto specificato. + Oggetto sui cui acquisire il blocco del monitoraggio. + Il valore del parametro è null. + 1 + + + Acquisisce un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto per il quale attendere. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco.Nota   Se non si verifica alcuna eccezione, l'output di questo metodo è sempre true. + L'input di è true. + Il valore del parametro è null. + + + Viene rilasciato un blocco esclusivo sull'oggetto specificato. + Oggetto sul quale rilasciare il blocco. + Il valore del parametro è null. + Il blocco per l'oggetto specificato non è di proprietà del thread corrente. + 1 + + + Determina se il thread corrente specificato contiene il blocco sull'oggetto specificato. + true se il thread corrente è responsabile del blocco su ; in caso contrario, false. + Oggetto da testare. + + è null. + + + Notifica a un thread della coda di attesa che lo stato dell'oggetto bloccato è stato modificato. + Oggetto atteso da un thread. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + 1 + + + Notifica a tutti i thread in attesa che lo stato dell'oggetto è stato modificato. + Oggetto che invia l'impulso. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + 1 + + + Prova ad acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Il valore del parametro è null. + 1 + + + Prova ad acquisire un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + + + Viene eseguito, per un numero specificato di millisecondi, il tentativo di acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Tempo di attesa espresso in millisecondi prima che si verifichi il blocco. + Il valore del parametro è null. + + è negativo e non è uguale a . + 1 + + + Prova ad acquisire, per il numero di millisecondi specificato, un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Tempo di attesa espresso in millisecondi prima che si verifichi il blocco. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + + è negativo e non è uguale a . + + + Viene eseguito, per una quantità di tempo specificata, il tentativo di acquisire un blocco esclusivo sull'oggetto specificato. + true se il thread corrente acquisisce il blocco; in caso contrario, false. + Oggetto sul quale acquisire il blocco. + Oggetto che rappresenta la durata di attesa del blocco.Un valore di –1 millisecondo specifica un'attesa infinita. + Il valore del parametro è null. + Il valore di in millisecondi è negativo ed è diverso da (–1 millisecondi) oppure è maggiore di . + 1 + + + Prova ad acquisire, per la quantità di tempo specificata, un blocco esclusivo sull'oggetto specificato e imposta atomicamente un valore che indica se il blocco è stato ottenuto. + Oggetto sul quale acquisire il blocco. + Quantità di tempo che rappresenta la durata di attesa del blocco.Un valore di –1 millisecondo specifica un'attesa infinita. + Risultato del tentativo di acquisizione del blocco passato dal riferimento.L'input deve essere false.L'output è true se il blocco viene acquisito; in caso contrario, l'output è false.L'output viene impostato anche se si verifica un'eccezione durante il tentativo di acquisire il blocco. + L'input di è true. + Il valore del parametro è null. + Il valore di in millisecondi è negativo ed è diverso da (–1 millisecondi) oppure è maggiore di . + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco. + true se la chiamata è stata restituita perché il chiamante ha riacquisito il blocco per l'oggetto specificato.Non viene restituito alcun valore se il blocco non viene riacquisito. + Oggetto per il quale attendere. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + 1 + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco.Allo scadere dell'intervallo di timeout specificato, il thread viene inserito nella coda di thread pronti. + true se il blocco è stato riacquisito prima che sia trascorso il tempo specificato; false se il blocco è stato riacquisito dopo che è trascorso il tempo specificato.Il metodo non restituisce alcun valore finché il blocco non viene riacquisito. + Oggetto per il quale attendere. + Numero di millisecondi da attendere prima che il thread venga inserito nella coda di thread pronti. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + Il valore del parametro è negativo e non è uguale a . + 1 + + + Rilascia il blocco su un oggetto e interrompe il thread corrente finché riacquisisce il blocco.Allo scadere dell'intervallo di timeout specificato, il thread viene inserito nella coda di thread pronti. + true se il blocco è stato riacquisito prima che sia trascorso il tempo specificato; false se il blocco è stato riacquisito dopo che è trascorso il tempo specificato.Il metodo non restituisce alcun valore finché il blocco non viene riacquisito. + Oggetto per il quale attendere. + Oggetto che rappresenta il tempo di attesa prima che il thread venga inserito nella coda di thread pronti. + Il valore del parametro è null. + Il thread chiamante non è il proprietario del blocco per l'oggetto specificato. + Il thread da cui è stato richiamato Wait viene interrotto in seguito dallo stato di attesa.L'interruzione si verifica quando il metodo di questo thread viene chiamato da un altro thread. + Il valore del parametro in millisecondi è negativo e non rappresenta (–1 millisecondo) oppure è maggiore di . + 1 + + + Primitiva di sincronizzazione che può essere usata anche per la sincronizzazione interprocesso. + 1 + + + Inizializza una nuova istanza della classe con le proprietà predefinite. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex; in caso contrario, false. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex e con una stringa che rappresenta il nome del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex di sistema denominato, se questo è stato creato come risultato della chiamata; in caso contrario, false. + Nome di .Se il valore è null, l'oggetto è senza nome. + Il mutex denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non dispone dei diritti . + Si è verificato un errore Win32. + Non è possibile creare il mutex denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è più lungo di 260 caratteri. + + + Inizializza una nuova istanza della classe con un valore booleano che indica se il thread chiamante deve avere la proprietà iniziale del mutex, con una stringa che rappresenta il nome del mutex e con un valore booleano che, quando il metodo viene restituito, indichi se al thread chiamante era stata concessa la proprietà iniziale del mutex. + true per concedere al thread chiamante la proprietà iniziale del mutex di sistema denominato, se questo è stato creato come risultato della chiamata; in caso contrario, false. + Nome di .Se il valore è null, l'oggetto è senza nome. + Quando questo metodo viene restituito, contiene un valore booleano che è true se è stato creato un mutex locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato il mutex di sistema denominato specificato; false se il mutex di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + Il mutex denominato esiste e dispone della sicurezza del controllo di accesso, ma l'utente non dispone dei diritti . + Si è verificato un errore Win32. + Non è possibile creare il mutex denominato, probabilmente perché esiste un handle di attesa di diverso tipo con lo stesso nome. + + è più lungo di 260 caratteri. + + + Apre il mutex denominato specificato, se esistente. + Oggetto che rappresenta il mutex di sistema denominato. + Nome del mutex di sistema da aprire. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Il mutex denominato non esiste. + Si è verificato un errore Win32. + Il mutex denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Rilascia l'oggetto una volta. + Il thread chiamante non ha la proprietà del mutex. + 1 + + + Apre il mutex denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è stata completata. + true se il mutex denominato è stato aperto correttamente; in caso contrario, false. + Nome del mutex di sistema da aprire. + Quando questo metodo viene restituito, contiene un oggetto di che rappresenta il mutex denominato se la chiamata ha esito positivo o null se la chiamata ha esito negativo.Questo parametro viene trattato come non inizializzato. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Si è verificato un errore Win32. + Il mutex denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + + + Rappresenta un blocco usato per gestire l'accesso a una risorsa, consentendo a più thread l'accesso in lettura o l'accesso esclusivo in scrittura. + + + Inizializza una nuova istanza della classe con i valori predefiniti delle proprietà. + + + Inizializza una nuova istanza della classe , specificando i criteri di ricorsione del blocco. + Uno dei valori di enumerazione che specifica i criteri di ricorsione del blocco. + + + Ottiene il numero complessivo di thread univoci per i quali è stato attivato il blocco in modalità lettura. + Numero di thread univoci per i quali è stato attivato il blocco in modalità lettura. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Prova ad attivare il blocco in modalità lettura. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Riduce il numero di ricorsioni per la modalità lettura ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in read mode. + + + Riduce il numero di ricorsioni per la modalità aggiornabile ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in upgradeable mode. + + + Riduce il numero di ricorsioni per la modalità scrittura ed esce da questa modalità se il numero risultante è 0 (zero). + The current thread has not entered the lock in write mode. + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità lettura. + true se per il thread corrente è stata attivata la modalità lettura; in caso contrario, false. + 2 + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità aggiornabile. + true se per il thread corrente è stata attivata la modalità aggiornabile; in caso contrario, false. + 2 + + + Ottiene un valore che indica se per il thread corrente è stato attivato il blocco in modalità scrittura. + true se per il thread corrente è stata attivata la modalità scrittura; in caso contrario, false. + 2 + + + Ottiene un valore che indica i criteri di ricorsione per l'oggetto corrente. + Uno dei valori di enumerazione che specifica i criteri di ricorsione del blocco. + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità lettura, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità lettura, 1 se per il thread è stata attivata la modalità lettura ma non in modo ricorsivo o n se per il thread è stato attivato il blocco in modo ricorsivo n - 1 volte. + 2 + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità aggiornabile, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità aggiornabile, 1 se per il thread è stata attivata la modalità aggiornabile ma non in modo ricorsivo o n se per il thread è stata attivata la modalità aggiornabile in modo ricorsivo n - 1 volte. + 2 + + + Ottiene il numero di volte in cui per il thread corrente è stato attivato il blocco in modalità scrittura, come indicazione della ricorsione. + 0 (zero) se per il thread corrente non è stata attivata la modalità scrittura, 1 se per il thread è stata attivata la modalità scrittura ma non in modo ricorsivo o n se per il thread è stata attivata la modalità scrittura in modo ricorsivo n - 1 volte. + 2 + + + Prova ad attivare il blocco in modalità lettura con un timeout intero facoltativo. + true se il thread chiamante è passato in modalità lettura; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità lettura con un timeout facoltativo. + true se il thread chiamante è passato in modalità lettura; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile con un timeout facoltativo. + true se il thread chiamante è passato in modalità aggiornabile; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità aggiornabile con un timeout facoltativo. + true se il thread chiamante è passato in modalità aggiornabile; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura con un timeout facoltativo. + true se il thread chiamante è passato in modalità scrittura; in caso contrario, false. + Numero di millisecondi di attesa oppure -1 () per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Prova ad attivare il blocco in modalità scrittura con un timeout facoltativo. + true se il thread chiamante è passato in modalità scrittura; in caso contrario, false. + Intervallo di attesa oppure -1 millisecondi per un'attesa indefinita. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità lettura. + Numero complessivo di thread in attesa di attivazione della modalità lettura. + 2 + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità aggiornabile. + Numero complessivo di thread in attesa di attivazione della modalità aggiornabile. + 2 + + + Ottiene il numero complessivo di thread in attesa di attivazione del blocco in modalità scrittura. + Numero complessivo di thread in attesa di attivazione della modalità scrittura. + 2 + + + Limita il numero di thread che possono accedere a una risorsa o a un pool di risorse contemporaneamente. + 1 + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + + è maggiore di . + + è minore di 1.-oppure- è minore di 0. + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei, nonché indicando facoltativamente il nome di un oggetto semaforo di sistema. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + Nome di un oggetto semaforo di sistema denominato. + + è maggiore di .-oppure- è più lungo di 260 caratteri. + + è minore di 1.-oppure- è minore di 0. + Si è verificato un errore Win32. + Il semaforo denominato esiste ed è dotato di sicurezza del controllo di accesso e l'utente non dispone di . + Non è possibile creare il semaforo denominato, probabilmente a causa di un handle di attesa di tipo diverso con lo stesso nome. + + + Inizializza una nuova istanza della classe , specificando il numero di accessi iniziale e il numero massimo di accessi contemporanei, indicando facoltativamente il nome di un oggetto semaforo di sistema e specificando una variabile che riceve un valore che indica se è stato creato un nuovo semaforo di sistema. + Numero iniziale di richieste per il semaforo che possono essere soddisfatte contemporaneamente. + Numero massimo di richieste per il semaforo che possono essere soddisfatte contemporaneamente. + Nome di un oggetto semaforo di sistema denominato. + Quando questo metodo viene restituito, contiene true se è stato creato un semaforo locale (ovvero, se il valore di è null o una stringa vuota) oppure se è stato creato il semaforo di sistema denominato specificato; false se il semaforo di sistema denominato specificato è già esistente.Questo parametro viene passato non inizializzato. + + è maggiore di . -oppure- è più lungo di 260 caratteri. + + è minore di 1.-oppure- è minore di 0. + Si è verificato un errore Win32. + Il semaforo denominato esiste ed è dotato di sicurezza del controllo di accesso e l'utente non dispone di . + Non è possibile creare il semaforo denominato, probabilmente a causa di un handle di attesa di tipo diverso con lo stesso nome. + + + Apre il semaforo denominato specificato, se esistente. + Oggetto che rappresenta il semaforo di sistema denominato. + Nome del semaforo di sistema da aprire. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Il semaforo denominato non esiste. + Si è verificato un errore Win32. + Il semaforo denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + 1 + + + + + + Esce dal semaforo e restituisce il conteggio precedente. + Conteggio del semaforo prima della chiamata del metodo . + Il conteggio del semaforo ha già raggiunto il valore massimo. + Si è verificato un errore Win32 relativo a un semaforo denominato. + Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente non dispone di .-oppure-Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con . + 1 + + + Esce dal semaforo il numero di volte specificato e restituisce il conteggio precedente. + Conteggio del semaforo prima della chiamata del metodo . + Numero di uscite dal semaforo. + + è minore di 1. + Il conteggio del semaforo ha già raggiunto il valore massimo. + Si è verificato un errore Win32 relativo a un semaforo denominato. + Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente non dispone di diritti .-oppure-Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con i diritti . + 1 + + + Apre il semaforo denominato specificato, se esistente, e restituisce un valore che indica se l'operazione è riuscita. + true se l'apertura del semaforo denominato è riuscita; in caso contrario, false. + Nome del semaforo di sistema da aprire. + Quando viene eseguita la restituzione del metodo, quest'ultimo contiene un oggetto che rappresenta il semaforo denominato se la chiamata è riuscita o null se la chiamata non è riuscita.Questo parametro viene trattato come non inizializzato. + Il parametro è una stringa vuota.-oppure- è più lungo di 260 caratteri. + + è null. + Si è verificato un errore Win32. + Il semaforo denominato esiste, ma l'utente non dispone dell'accesso di sicurezza necessario per utilizzarlo. + + + Eccezione generata quando il metodo viene chiamato su un semaforo il cui conteggio ha già raggiunto il valore massimo. + 2 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Rappresenta un'alternativa semplificata a che limita il numero di thread che possono accedere simultaneamente a una risorsa o a un pool di risorse. + + + Inizializza una nuova istanza della classe specificando il numero iniziale di richieste che possono essere concesse simultaneamente. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + + è minore di 0. + + + Inizializza una nuova istanza della classe specificando il numero iniziale e massimo di richieste che possono essere concesse simultaneamente. + Numero iniziale di richieste per il semaforo che possono essere concesse simultaneamente. + Numero massimo di richieste per il semaforo che possono essere concesse simultaneamente. + + è minore di 0, o è maggiore di o è uguale o minore di 0. + + + Restituisce un oggetto che può essere usato per attendere il semaforo. + Oggetto che può essere usato per attendere il semaforo. + L'interfaccia è stata eliminata. + + + Ottiene il numero di thread rimanenti che possono accedere all'oggetto . + Numero di thread rimanenti che possono accedere al semaforo. + + + Rilascia tutte le risorse usate dall'istanza corrente della classe . + + + Rilascia le risorse non gestite usate dall'oggetto e, facoltativamente, le risorse gestite. + true per rilasciare sia le risorse gestite sia quelle non gestite; false per rilasciare solo le risorse non gestite. + + + Rilascia l'oggetto una volta. + Numero precedente di . + L'istanza corrente è già stata eliminata. + + ha già raggiunto la dimensione massima. + + + Rilascia l'oggetto un numero di volte specificato. + Numero precedente di . + Numero di uscite dal semaforo. + L'istanza corrente è già stata eliminata. + + è minore di 1. + + ha già raggiunto la dimensione massima. + + + Blocca il thread corrente finché non può immettere . + L'istanza corrente è già stata eliminata. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un intero con segno a 32 bit che specifica il timeout. + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un intero con segno a 32 bit che specifica il timeout e osservando un oggetto . + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + Il istanza è stata eliminata, o che ha creato è stato eliminato. + + + Blocca il thread corrente finché non può accedere all'oggetto osservando un oggetto . + Token da osservare. + + è stato annullato. + L'istanza corrente è già stata eliminata.-oppure-Il creato è già stato eliminato. + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un oggetto per specificare il timeout. + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + L'istanza semaphoreSlim è stata eliminata + + + Blocca il thread corrente finché non può accedere all'oggetto , usando un oggetto che specifica il timeout e osservando un oggetto . + true se il thread corrente ha immesso correttamente ; in caso contrario, false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Oggetto da osservare. + + è stato annullato. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + L'istanza semaphoreSlim è stata eliminataL'oggetto che ha creato è già stato eliminato. + + + Attende in modo asincrono di immettere . + Attività che verrà completata quando si accede al semaforo. + + + Attende in modo asincrono di accedere all'oggetto , usando un intero con segno a 32 bit per misurare l'intervallo di tempo. + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Attende in modo asincrono di accedere all'oggetto , usando un intero con segno a 32 bit per misurare l'intervallo di tempo e osservando un oggetto . + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + Oggetto da osservare. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + L'istanza corrente è già stata eliminata. + + è stato annullato. + + + Attende in modo asincrono di accedere all'oggetto , osservando un oggetto . + Attività che verrà completata quando si accede al semaforo. + Token da osservare. + L'istanza corrente è già stata eliminata. + + è stato annullato. + + + Attende in modo asincrono di accedere all'oggetto , usando un oggetto per misurare l'intervallo di tempo. + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + L'istanza corrente è già stata eliminata. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. -oppure- timeout è maggiore di . + + + Attende in modo asincrono di accedere all'oggetto , usando un oggetto per misurare l'intervallo di tempo e osservando un oggetto . + Attività che verrà completata con un risultato true se il thread corrente ha immesso correttamente , in caso contrario, con un risultato false. + Oggetto che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + Token da osservare. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato.-oppure-timeout è maggiore di . + + è stato annullato. + + + Rappresenta un metodo da chiamare quando un messaggio deve essere inviato a un contesto di sincronizzazione. + Oggetto passato al delegato. + 2 + + + Fornisce un primitiva di blocco a esclusione reciproca in cui un thread che tenta di acquisire il blocco attende in un ciclo eseguendo controlli ripetuti finché il blocco non diventa disponibile. + + + Inizializza una nuova istanza della struttura con l'opzione di rilevamento degli ID dei thread per migliorare il debug. + Valore che indica se acquisire e utilizzare gli ID dei thread per scopi di debug. + + + Acquisisce il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + È necessario inizializzare l'argomento su False prima della chiamata a Enter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Rilascia il blocco. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente non è il proprietario di questo blocco. + + + Rilascia il blocco. + Valore booleano che indica se generare un limite di memoria per pubblicare immediatamente l'operazione di uscita agli altri thread. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente non è il proprietario di questo blocco. + + + Ottiene un valore che indica se attualmente il blocco è mantenuto da un thread. + true se attualmente il blocco è mantenuto da un thread; in caso contrario, false. + + + Ottiene un valore che indica se il blocco è mantenuto dal thread corrente. + true se il blocco è mantenuto dal thread corrente; in caso contrario, false. + Il rilevamento della proprietà dei thread è disabilitato. + + + Ottiene un valore che indica se per questa istanza è abilitato il rilevamento della proprietà dei thread. + true se per questa istanza è abilitato il rilevamento della proprietà dei thread; in caso contrario, false. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Tenta di acquisire il blocco in modo affidabile, in modo tale che anche se si verifica un'eccezione all'interno della chiamata al metodo, è possibile esaminare l'oggetto in maniera affidabile per determinare se il blocco è stato acquisito. + + che rappresenta il numero di millisecondi di attesa oppure che rappresenta -1 millisecondi per un'attesa indefinita. + True se il blocco è stato acquisito. In caso contrario, False.Prima di chiamare questo metodo è necessario inizializzare su False. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito o il timeout è più grande di millisecondi. + È necessario inizializzare l'argomento su False prima della chiamata a TryEnter. + Il rilevamento della proprietà dei thread è abilitato e il thread corrente ha già acquisito questo blocco. + + + Fornisce il supporto per l'attesa basata su rotazione. + + + Ottiene il numero di chiamate di su questa istanza. + Restituisce un intero che rappresenta il numero di volte in cui è stato chiamato su questa istanza. + + + Ottiene un valore che indica se la chiamata successiva a comporterà la cessione del processore, attivando un cambio imposto di contesto. + Valore che indica se la chiamata successiva a comporterà la cessione del processore, attivando un cambio imposto di contesto. + + + Reimposta il contatore delle rotazioni. + + + Esegue una sola rotazione. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata. + Delegato da eseguire ripetutamente finché non restituisce true. + L'argomento è null. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata o fino allo scadere del timeout specificato. + True se la condizione viene soddisfatta entro lo scadere del timeout. In caso contrario, False. + Delegato da eseguire ripetutamente finché non restituisce true. + Numero di millisecondi di attesa oppure (-1) per un'attesa indefinita. + L'argomento è null. + + è un numero negativo diverso da -1 che rappresenta un timeout indeterminato. + + + Esegue rotazioni finché non è stata soddisfatta la condizione specificata o fino allo scadere del timeout specificato. + True se la condizione viene soddisfatta entro lo scadere del timeout. In caso contrario, False. + Delegato da eseguire ripetutamente finché non restituisce true. + Oggetto che rappresenta il numero di millisecondi di attesa. In alternativa, per un'attesa indefinita, oggetto TimeSpan che rappresenta -1 millisecondi. + L'argomento è null. + + è un numero negativo diverso da -1 millisecondi che rappresenta un timeout infinito - o - il timeout è più grande di . + + + Fornisce la funzionalità di base per propagare un contesto di sincronizzazione in vari modelli di sincronizzazione. + 2 + + + Crea una nuova istanza della classe . + + + Quando ne viene eseguito l'override in una classe derivata, crea una copia del contesto di sincronizzazione. + Nuovo oggetto . + 2 + + + Ottiene il contesto di sincronizzazione per il thread corrente. + Oggetto che rappresenta il contesto di sincronizzazione corrente. + 1 + + + Quando ne viene eseguito l'override in una classe derivata, risponde alla notifica di completamento di un'operazione. + + + Quando ne viene eseguito l'override in una classe derivata, risponde alla notifica di avvio di un'operazione. + + + Quando ne viene eseguito l'override in una classe derivata, invia un messaggio asincrono a un contesto di sincronizzazione. + Delegato di da chiamare. + Oggetto passato al delegato. + 2 + + + Quando ne viene eseguito l'override in una classe derivata, invia un messaggio sincrono a un contesto di sincronizzazione. + Delegato di da chiamare. + Oggetto passato al delegato. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Imposta il contesto di sincronizzazione corrente. + Oggetto da impostare. + 1 + + + + + + Eccezione generata quando un metodo richiede che il chiamante sia il proprietario del blocco su un Monitor specifico, e tale metodo viene richiamato da un chiamante che non è proprietario del blocco. + 2 + + + Consente l'inizializzazione di una nuova istanza della classe con le proprietà predefinite. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + Consente l'archiviazione dei dati nella memoria locale dei thread. + Specifica il tipo di dati archiviati per thread. + + + Inizializza l'istanza . + + + Inizializza l'istanza . + Se tenere traccia di tutti i valori impostati sull'istanza ed esporli mediante la proprietà di . + + + Inizializza l'istanza di con la funzione specificata. + Oggetto richiamato per produrre un valore con inizializzazione differita quando si tenta di recuperare l'oggetto senza che sia stato inizializzato in precedenza. + + è un riferimento null (Nothing in Visual Basic). + + + Inizializza l'istanza di con la funzione specificata. + Oggetto richiamato per produrre un valore con inizializzazione differita quando si tenta di recuperare l'oggetto senza che sia stato inizializzato in precedenza. + Se tenere traccia di tutti i valori impostati sull'istanza ed esporli mediante la proprietà di . + + è un riferimento null (Nothing in Visual Basic). + + + Rilascia tutte le risorse utilizzate dall'istanza corrente della classe . + + + Rilascia le risorse utilizzate da questa istanza di . + Valore booleano che indica se questo metodo viene chiamato a causa di una chiamata a . + + + Rilascia le risorse utilizzate da questa istanza di . + + + Ottiene un valore che indica se l'oggetto è inizializzato sul thread corrente. + true se viene inizializzato sul thread corrente; in caso contrario, false. + L'istanza di è stata eliminata. + + + Crea e restituisce una rappresentazione di stringa di questa istanza per il thread corrente. + Risultato della chiamata di su . + L'istanza di è stata eliminata. + L'oggetto per il thread corrente è un riferimento Null (Nothing in Visual Basic). + La funzione di inizializzazione tenta di fare riferimento in modo ricorsivo a . + Non è fornito alcun costruttore predefinito e non è fornito alcun valore di factory. + + + Ottiene o imposta il valore di questa istanza per il thread corrente. + Restituisce un'istanza dell'oggetto della cui inizializzazione è responsabile questo oggetto ThreadLocal. + L'istanza di è stata eliminata. + La funzione di inizializzazione tenta di fare riferimento in modo ricorsivo a . + Non è fornito alcun costruttore predefinito e non è fornito alcun valore di factory. + + + Ottiene un elenco di tutti i valori attualmente archiviati da tutti i thread che hanno eseguito l'accesso a questa istanza. + Elenco di tutti i valori attualmente archiviati da tutti i thread che hanno eseguito l'accesso a questa istanza. + L'istanza di è stata eliminata. + + + Contiene metodi per l'esecuzione di operazioni relative alla memoria volatile. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il valore del campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Valore letto.Questo valore è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + + + Legge il riferimento a un oggetto dal campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare dopo questo metodo nel codice, il processore non potrà spostarla in una posizione precedente al metodo stesso. + Riferimento a che è stato letto.Questo riferimento è l'ultimo che è stato scritto da un processore qualsiasi nel computer, indipendentemente dal numero di processori o dallo stato della cache del processore. + Campo da leggere. + Tipo di campo da leggere.Deve essere un tipo di riferimento, non un tipo di valore. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di memoria compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il valore specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il valore. + Valore da scrivere.Il valore viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + + + Scrive il riferimento a un oggetto specificato nel campo specificato.Nei sistemi in cui è richiesto, inserisce una barriera di memoria che impedisce al processore di riordinare le operazioni di memoria nel modo seguente: se un'operazione di lettura o di scrittura compare prima di questo metodo nel codice, il processore non potrà spostarla in una posizione successiva al metodo stesso. + Campo in cui viene scritto il riferimento a un oggetto. + Riferimento a un oggetto da scrivere.Il riferimento viene scritto immediatamente, in modo da essere reso visibile a tutti i processori nel computer. + Tipo di campo da scrivere.Deve essere un tipo di riferimento, non un tipo di valore. + + + Eccezione generata durante il tentativo di aprire un semaforo o un mutex di sistema inesistente. + 2 + + + Inizializza una nuova istanza della classe con valori predefiniti. + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + + + Inizializza una nuova istanza della classe con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente. + Messaggio di errore nel quale viene indicato il motivo dell’eccezione + Eccezione causa dell'eccezione corrente.Se il parametro non è null, l'eccezione corrente viene generata in un blocco catch in cui viene gestita l'eccezione interna. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/ja/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/ja/System.Threading.xml new file mode 100644 index 000000000..1e2f71c3a --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/ja/System.Threading.xml @@ -0,0 +1,1950 @@ + + + + System.Threading + + + + スレッドが、別のスレッドが解放せずに終了することによって放棄した オブジェクトを取得したときにスローされる例外。 + 1 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 放棄されたミューテックスのインデックスを指定する場合はそのインデックスと、ミューテックスを表す オブジェクトを指定して、 クラスの新しいインスタンスを初期化します。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列内における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + + クラスの新しいインスタンスを、指定したエラー メッセージと内部例外を使用して初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null ではない場合、現在の例外は内部例外を処理する catch ブロックで発生します。 + + + エラー メッセージ、内部例外、放棄されたミューテックスのインデックスを指定する場合はそのインデックス、およびミューテックスを表す オブジェクトを指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null ではない場合、現在の例外は内部例外を処理する catch ブロックで発生します。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + エラー メッセージ、放棄されたミューテックスのインデックスを指定する場合はそのインデックス、および放棄されたミューテックスを指定して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + メソッドで例外がスローされる場合は、待機ハンドルの配列における放棄されたミューテックスのインデックス。 メソッドまたは メソッドで例外がスローされる場合は -1。 + 放棄されたミューテックスを表す オブジェクト。 + + + 例外の原因となった、放棄されたミューテックスがわかっている場合は、そのミューテックスを取得します。 + 放棄されたミューテックスを表す オブジェクト。放棄されたミューテックスを識別できなかった場合は null。 + 1 + + + 例外の原因となった、放棄されたミューテックスがわかっている場合は、そのミューテックスのインデックスを取得します。 + 放棄されたミューテックスを表す オブジェクトの、 メソッドに渡された待機ハンドルの配列内でのインデックス。放棄されたミューテックスのインデックスが識別できなかった場合は –1。 + 1 + + + 非同期メソッドなど、特定の非同期制御フローに対してローカルなアンビエント データを表します。 + アンビエント データの型。 + + + 変更通知を受信しない インスタンスをインスタンス生成します。 + + + 変更通知を受信する ローカル インスタンスをインスタンス生成します。 + どのスレッド上であっても現在の値が変更されたなら必ず呼び出されるデリゲート。 + + + アンビエント データの値を取得または設定します。 + アンビエント データの値。 + + + 変更通知のために登録する インスタンスに対するデータ変更情報を提供するクラス。 + データの型。 + + + データの現在の値を取得します。 + データの現在の値。 + + + データの前の値を取得します。 + データの前の値。 + + + 実行コンテキストの変更が原因で値が変更されたかどうかを示す値を返します。 + 実行コンテキストの変更が原因で値が変更された場合は true、それ以外の場合は false。 + + + イベントが発生したことを待機中のスレッドに通知します。このクラスは継承できません。 + 2 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + +初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + 複数のタスクが、複数のフェーズを通じて 1 つのアルゴリズムで並行して協調的に動作できるようにします。 + + + + クラスの新しいインスタンスを初期化します。 + 参加しているスレッドの数。 + + が 0 より小さいか、または 32,767 を超えています。 + + + + クラスの新しいインスタンスを初期化します。 + 参加しているスレッドの数。 + 各フェーズ後に実行する 。null (Visual Basic の場合は Nothing) は操作が行われないことを示すために渡されることがあります。 + + が 0 より小さいか、または 32,767 を超えています。 + + + 参加要素が 1 つ追加されることを に通知します。 + 新しい参加要素が最初に参加するバリアのフェーズ番号。 + 現在のインスタンスは既に破棄されています。 + 参加要素を追加すると、バリアの参加要素数が 32,767 を超えます。またはメソッドは、フェーズ後アクション内から呼び出されました。 + + + 複数の参加要素が追加されることを に通知します。 + 新しい参加要素が最初に参加するバリアのフェーズ番号。 + バリアに追加する追加の参加要素の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。または 参加要素を追加すると、バリアの参加要素数が 32,767 を超えます。 + メソッドは、フェーズ後アクション内から呼び出されました。 + + + バリアの現在のフェーズの番号を取得します。 + バリアの現在のフェーズの番号を返します。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + メソッドは、フェーズ後アクション内から呼び出されました。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + バリア内の参加要素の合計数を取得します。 + バリア内の参加要素の合計数を返します。 + + + 現在のフェーズでまだ通知していないバリア内の参加要素の数を取得します。 + 現在のフェーズでまだ通知していないバリア内の参加要素の数を返します。 + + + 参加要素が 1 つ削除されることを に通知します。 + 現在のインスタンスは既に破棄されています。 + バリアでは、既に 0 個の参加要素があります。またはメソッドは、フェーズ後アクション内から呼び出されました。 + + + 複数の参加要素が削除されることを に通知します。 + バリアから削除する追加の参加要素の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。 + バリアでは、既に 0 個の参加要素があります。またはメソッドは、フェーズ後アクション内から呼び出されました。 または現在の参加要素数が、指定された participantCount より小さい値です + 参加要素の総数が、指定した より小さくなっています。 + + + 参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 現在のインスタンスは既に破棄されています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + すべての参加しているスレッドが SignalAndWait を呼び出した後に、バリアのフェーズ後のアクションから例外がスローされた場合、その例外は BarrierPostPhaseException にラップされ、参加しているすべてのスレッドでスローされます。 + + + 32 ビット符号付き整数を使用してタイムアウトを計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 指定した時間内にすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + すべての参加しているスレッドが SignalAndWait を呼び出した後に、バリアのフェーズ後のアクションから例外がスローされた場合、その例外は BarrierPostPhaseException にラップされ、参加しているすべてのスレッドでスローされます。 + + + 取り消しトークンを観察すると同時に、32 ビット符号付き整数を使用してタイムアウトを計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 指定した時間内にすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + 取り消しトークンを観察すると同時に、参加要素がバリアに到達し、他のすべての参加要素がバリアに到達するまで待機することを通知します。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + + オブジェクトを使用して時間間隔を計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 他のすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが 32,767 を超えています。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + 取り消しトークンを観察すると同時に、 オブジェクトを使用して時間間隔を計測し、参加要素がバリアに到達し、他のすべての参加要素もバリアに到達するまで待機することを通知します。 + 他のすべての参加要素がバリアに到達した場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。 + メソッドがフェーズ後アクション内から呼び出されたか、バリア内に参加要素が含まれていないか、または参加要素として登録されているよりも多くのスレッドによってバリアがシグナル状態です。 + + + + のフェーズ後アクションに失敗したときにスローされる例外。 + + + エラーを説明するシステム提供のメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + + + 指定した内部例外を使用して、 クラスの新しいインスタンスを初期化します。 + 現在の例外の原因である例外。 + + + エラーを説明する指定したメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元では、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + 新しいコンテキスト内で呼び出すメソッドを表します。 + コールバック メソッドが実行されるたびに使用する情報を格納したオブジェクト。 + 1 + + + カウントが 0 になったときに通知される同期プリミティブを表します。 + + + 指定されたカウントを使用して クラスの新しいインスタンスを初期化します。 + + の設定に最初に必要な通知の数。 + + が 0 未満です。 + + + + の現在のカウントを 1 つインクリメントします。 + 現在のインスタンスは既に破棄されています。 + 現在のインスタンスは既に設定されています。または が 以上です。 + + + + の現在のカウントを指定された値だけインクリメントします。 + + を増やす値。 + 現在のインスタンスは既に破棄されています。 + + が 0 以下です。 + 現在のインスタンスは既に設定されています。またはカウントが ずつインクリメントされた後、 が 以上です + + + イベントの設定に必要な残りの通知の数を取得します。 + イベントの設定に必要な残りの通知の数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + イベントの設定に最初に必要な通知の数を取得します。 + イベントの設定に最初に必要な通知の数。 + + + イベントが設定されているかどうかを判断します。 + イベントが設定されている場合は true。それ以外の場合は false。 + + + + を の値にリセットします。 + 現在のインスタンスは既に破棄されています。 + + + + プロパティを指定した値にリセットします。 + + の設定に必要な通知の数。 + 現在のインスタンスは既に破棄されています。 + + が 0 未満です。 + + + 通知を に登録して、 の値をデクリメントします。 + 通知によってカウントが 0 になり、イベントが設定された場合は true。それ以外の場合は false。 + 現在のインスタンスは既に破棄されています。 + 現在のインスタンスは既に設定されています。 + + + 複数の通知を に登録して、 の値を指定された量だけデクリメントします。 + 通知によってカウントが 0 になり、イベントが設定された場合は true。それ以外の場合は false。 + 登録する通知の数。 + 現在のインスタンスは既に破棄されています。 + + が 1 未満です。 + 現在のインスタンスは既に設定されています。-または- または、 が より大きいです。 + + + + を 1 つインクリメントすることを試みます。 + インクリメントが正常に行われた場合は true。それ以外の場合は false。 が既に 0 の場合、このメソッドは false を返します。 + 現在のインスタンスは既に破棄されています。 + + と が等価です。 + + + + を指定した値だけインクリメントすることを試みます。 + インクリメントが正常に行われた場合は true。それ以外の場合は false。 が既に 0 の場合、これは false を返します。 + + を増やす値。 + 現在のインスタンスは既に破棄されています。 + + が 0 以下です。 + 現在のインスタンスは既に設定されています。または + は、 以上です。 + + + + が設定されるまで、現在のスレッドをブロックします。 + 現在のインスタンスは既に破棄されています。 + + + 32 ビット符号付き整数を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、32 ビット符号付き整数を使用してタイムアウトを計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、 が設定されるまで、現在のスレッドをブロックします。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + + + を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + + を観察すると同時に、 を使用してタイムアウトを計測し、 が設定されるまで、現在のスレッドをブロックします。 + + が設定された場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または、 を作成した が破棄されています。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + イベントの設定を待機するために使用する を取得します。 + イベントの設定を待機するために使用する 。 + 現在のインスタンスは既に破棄されています。 + + + シグナルを受信した後で が自動的にリセットされるか、または手動でリセットされるかを示します。 + 2 + + + シグナルを受信すると、 は 1 つのスレッドを解放した後で自動的にリセットされます。待機しているスレッドがない場合、 はスレッドがブロックされるまでシグナル状態のままとなり、そのスレッドを解放した後でリセットされます。 + + + シグナルを受信すると、 は待機しているスレッドをすべて解放し、手動でリセットされるまでシグナル状態のままとなります。 + + + スレッドの同期イベントを表します。 + 2 + + + 待機ハンドルの初期状態をシグナル状態に設定するかどうか、および、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるかを指定して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + + + この呼び出しの結果として待機ハンドルが作成された場合に待機ハンドルの初期状態をシグナル状態に設定するかどうか、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるか、およびシステムの同期イベントの名前を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きイベントが作成された場合に初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + システム全体で有効な同期イベントの名前。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きイベントが存在しますが、ユーザーに がありません。 + 名前付きイベントを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + が 260 文字を超えています。 + + + この呼び出しの結果として待機ハンドルが作成された場合に待機ハンドルの初期状態をシグナル状態に設定するかどうか、待機ハンドルが自動的にリセットされるかまたは手動でリセットされるか、システム同期イベントの名前、および、呼び出し後の値によって名前付きイベントが作成されたかどうかを示すブール変数を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きイベントが作成された場合に初期状態をシグナル状態に設定する場合は true。非シグナル状態に設定する場合は false。 + イベントが自動的にリセットされるかまたは手動でリセットされるかを指定する 値の 1 つ。 + システム全体で有効な同期イベントの名前。 + このメソッドから制御が戻るときに、ローカル イベントが作成された場合 ( が null または空の文字列の場合)、または指定した名前付きシステム イベントが作成された場合は true が格納されます。指定した名前付きシステム イベントが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きイベントが存在しますが、ユーザーに がありません。 + 名前付きイベントを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + が 260 文字を超えています。 + + + 既に存在する場合は、指定した名前付き同期イベントを開きます。 + 名前付きシステム イベントを表すオブジェクト。 + 開くシステム同期イベントの名前。 + + が空の文字列です。または が 260 文字を超えています。 + + は null なので、 + 名前付きシステム イベントが存在しません。 + Win32 エラーが発生しました。 + 名前付きイベントは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + イベントの状態を非シグナル状態に設定し、スレッドをブロックします。 + 正常に操作できた場合は true。それ以外の場合は false。 + この で メソッドが既に呼び出されています。 + 2 + + + イベントの状態をシグナル状態に設定し、待機している 1 つ以上のスレッドが進行できるようにします。 + 正常に操作できた場合は true。それ以外の場合は false。 + この で メソッドが既に呼び出されています。 + 2 + + + 既に存在する場合は、指定した名前付き同期イベントを開き操作が成功したかどうかを示す値を返します。 + 名前付きの同期イベントが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム同期イベントの名前。 + このメソッドから制御が戻るときに、呼び出しに成功した場合は名前付き同期イベントを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または が 260 文字を超えています。 + + は null なので、 + Win32 エラーが発生しました。 + 名前付きイベントは存在しますが、必要なセキュリティ アクセスがユーザーにありません。 + + + 現在のスレッドの実行コンテキストを管理します。このクラスは継承できません。 + 2 + + + 現在のスレッドから実行コンテキストをキャプチャします。 + 現在のスレッドの実行コンテキストを表す オブジェクト。 + 1 + + + 現在のスレッドで指定した実行コンテキストを使用してメソッドを実行します。 + 設定する 。 + 指定した実行コンテキストで実行するメソッドを表す デリゲート。 + コールバック メソッドに渡すオブジェクト。 + + は null なので、またはキャプチャ操作で が取得されませんでした。または は、 呼び出しの引数として既に使用されています。 + 1 + + + + + + 複数のスレッドで共有される変数に分割不可能な操作を提供します。 + 2 + + + 分割不可能な操作として、2 つの 32 ビット整数を加算し、最初の整数を合計で置き換えます。 + + に格納された新しい値。 + 加算する最初の値を含む変数。2 つの値の合計は、 に格納されます。 + + にある整数に加算する値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、2 つの 64 ビット整数を加算し、最初の整数を合計で置き換えます。 + + に格納された新しい値。 + 加算する最初の値を含む変数。2 つの値の合計は、 に格納されます。 + + にある整数に加算する値。 + The address of is a null pointer. + 1 + + + 2 つの倍精度浮動小数点数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つの 32 ビット符号付き整数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つの 64 ビット符号付き整数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 2 つのプラットフォーム固有のハンドルまたはポインターが等しいかどうかを比較します。等しい場合は、最初の 1 つを置き換えます。 + + の元の値。 + 値を の値と比較し、場合によっては によって置き換える、比較先の 。 + 比較した結果が等しい場合に比較先の値を置き換える 。 + + にある値と比較する 。 + The address of is a null pointer. + 1 + + + 2 つのオブジェクトの参照が等値であるかどうかを比較します。等しい場合は、最初のオブジェクトを置き換えます。 + + の元の値。 + + と比較し、場合によっては置き換える比較先のオブジェクト。 + 比較した結果が等しい場合に比較先のオブジェクトを置き換えるオブジェクト。 + + にあるオブジェクトと比較するオブジェクト。 + The address of is a null pointer. + 1 + + + 2 つの単精度浮動小数点数が等しいかどうかを比較します。等しい場合は、最初の値を置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + The address of is a null pointer. + 1 + + + 指定した参照型 の 2 つのインスタンスが等しいかどうかを比較します。等しい場合は、最初の 1 つを置き換えます。 + + の元の値。 + 値を と比較し、場合によっては置き換える比較先。これは参照パラメーターです (C# では ref、Visual Basic では ByRef)。 + 比較した結果が等しい場合に比較先の値を置き換える値。 + + にある値と比較する値。 + + 、、および に使用する型。この型は、参照型である必要があります。 + The address of is a null pointer. + + + 分割不可能な操作として、指定した変数をデクリメントし、結果を格納します。 + デクリメントされた値。 + 値がデクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した変数をデクリメントしてその結果を格納します。 + デクリメントされた値。 + 値がデクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を倍精度浮動小数点数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を 32 ビット符号付き整数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を 64 ビット符号付き整数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、プラットフォーム固有のハンドルまたはポインターに指定した値を設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値をオブジェクトとして設定し、元のオブジェクトへの参照を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した値を単精度浮動小数点数として設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。 + + パラメーターに設定される値。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した型 の変数に指定した値を設定し、元の値を返します。 + + の元の値。 + 指定した値に設定する変数。これは参照パラメーターです (C# では ref、Visual Basic では ByRef)。 + + パラメーターに設定される値。 + + 、および に使用する型。この型は、参照型である必要があります。 + The address of is a null pointer. + + + 分割不可能な操作として、指定した変数をインクリメントし、結果を格納します。 + インクリメントされた値。 + 値がインクリメントされる変数。 + The address of is a null pointer. + 1 + + + 分割不可能な操作として、指定した変数をインクリメントし、結果を格納します。 + インクリメントされた値。 + 値がインクリメントされる変数。 + The address of is a null pointer. + 1 + + + メモリ アクセスを同期します。現在のスレッドを実行中のプロセッサは、 を呼び出す前のメモリ アクセスを の呼び出し後のメモリ アクセスより後に実行するように命令を並べ替えることはできなくなります。 + + + 分割不可能な操作として 64 ビット値を読み込んで返します。 + 読み込まれた値。 + 読み込む 64 ビット値。 + 1 + + + 限定的な初期化ルーチンを提供します。 + + + まだ初期化されていない場合、型の既定のコンストラクターを使用してターゲット参照型を初期化します。 + 型 の初期化された参照。 + まだ初期化されていない場合は、初期化する型 の参照。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、既定のコンストラクターを使用してターゲット参照または値型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照または値。 + ターゲットが既に初期化されているかどうかを判断するブール値への参照。 + + を初期化するために相互排他的ロックとして使用されるオブジェクトへの参照。 が null の場合、新しいオブジェクトがインスタンス化されます。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、指定された関数を使用してターゲット参照または値型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照または値。 + ターゲットが既に初期化されているかどうかを判断するブール値への参照。 + + を初期化するために相互排他的ロックとして使用されるオブジェクトへの参照。 が null の場合、新しいオブジェクトがインスタンス化されます。 + 参照または値を初期化するために呼び出される関数。 + 初期化される参照の型。 + 型 のコンストラクターにアクセスするためのアクセス許可がありませんでした。 + 型 には既定のコンストラクターがありません。 + + + まだ初期化されていない場合、指定された関数を使用してターゲット参照型を初期化します。 + 型 の初期化された値。 + まだ初期化されていない場合は、初期化する型 の参照。 + 参照を初期化するために呼び出される関数。 + 初期化される参照の参照型。 + 型 には既定のコンストラクターがありません。 + + null (Visual Basic の場合は Nothing) を返しました。 + + + 再帰的にロックに入る処理が、ロックの再帰ポリシーと互換性がない場合にスローされる例外です。 + 2 + + + エラーを説明するシステム提供のメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 2 + + + エラーを説明する指定したメッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元は、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 2 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外を説明するメッセージ。このコンストラクターの呼び出し元は、この文字列が現在のシステムのカルチャに合わせてローカライズ済みであることを確認しておく必要があります。 + 現在の例外を引き起こした例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + 2 + + + 同じスレッドが複数回ロックに入れるかどうかを指定します。 + + + スレッドが、再帰的にロックに入ろうとすると、例外がスローされます。クラスによっては、この設定が適用されている場合に、特定の再帰が認められることがあります。 + + + スレッドが再帰的にロックに入ることができます。クラスによっては、この機能が制限されていることがあります。 + + + イベントが発生したことを、1 つ以上の待機中のスレッドに通知します。このクラスは継承できません。 + 2 + + + 初期状態をシグナル状態に設定するかどうかを示す Boolean 型の値を使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + + の規模を小さくしたバージョンを提供します。 + + + 初期状態を非シグナル状態にして、 クラスの新しいインスタンスを初期化します。 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + + + 初期状態をシグナル状態に設定するかどうかを示すブール値および指定されたスピン カウントを使用して、 クラスの新しいインスタンスを初期化します。 + 初期状態をシグナル状態に設定する場合は true。初期状態を非シグナル状態に設定する場合は false。 + カーネル ベースの待機操作に戻る前に発生するスピン待機の数。 + + is less than 0 or greater than the maximum allowed value. + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true、アンマネージ リソースだけを解放する場合は false。 + + + イベントが設定されているかどうかを取得します。 + イベントが設定されている場合は true。それ以外の場合は false。 + + + イベントの状態を非シグナル状態に設定し、スレッドをブロックします。 + The object has already been disposed. + + + イベントの状態をシグナル状態に設定して、イベント上で待機している 1 つ以上のスレッドが進行できるようにします。 + + + カーネル ベースの待機操作に戻る前に発生するスピン待機の数を取得します。 + カーネル ベースの待機操作に戻る前に発生するスピン待機の数を返します。 + + + 現在の が設定されるまで、現在のスレッドをブロックします。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 32 ビット符号付き整数を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + を観察すると同時に、32 ビット符号付き整数を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + + を観察すると同時に、現在の が信号を受信するまで、現在のスレッドをブロックします。 + 観察する 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + + を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + を観察すると同時に、 を使用して時間間隔を計測し、現在の が設定されるまで、現在のスレッドをブロックします。 + + が設定されている場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + この の オブジェクトを取得します。 + この の基になる イベント オブジェクト。 + + + オブジェクトへのアクセスを同期する機構を提供します。 + 2 + + + 指定したオブジェクトの排他ロックを取得します。 + モニター ロックを取得する対象となるオブジェクト。 + + パラメーターが null です。 + 1 + + + 指定したオブジェクトの排他ロックを取得し、ロックが取得されたかどうかを示す値をアトミックに設定します。 + 待機を行うオブジェクト。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。メモ   例外が発生しない場合、このメソッドの出力は常に true です。 + + への入力は true です。 + + パラメーターが null です。 + + + 指定したオブジェクトの排他ロックを解放します。 + ロックを解放する対象となるオブジェクト。 + + パラメーターが null です。 + 現在のスレッドが、指定したオブジェクトのロックを所有していません。 + 1 + + + 現在のスレッドが指定したオブジェクトのロックを保持しているかどうかを判断します。 + 現在のスレッドが のロックを保持している場合は true。それ以外の場合は false。 + テストするオブジェクト。 + + は null です。 + + + ロックされたオブジェクトの状態が変更されたことを、待機キュー内のスレッドに通知します。 + スレッドが待機するオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + 1 + + + オブジェクトの状態が変更されたことを、待機中のすべてのスレッドに通知します。 + パルスを送るオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + 1 + + + 指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + + パラメーターが null です。 + 1 + + + 指定したオブジェクトの排他ロックの取得を試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + + 指定したミリ秒間に、指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + ロックを待機するミリ秒単位の時間。 + + パラメーターが null です。 + + が負で、 と等価でありません。 + 1 + + + 指定したオブジェクトの排他ロックの取得を指定したミリ秒間試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを待機するミリ秒単位の時間。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + が負で、 と等価でありません。 + + + 指定した時間内に、指定したオブジェクトの排他ロックの取得を試みます。 + 現在のスレッドがロックを取得した場合は true。それ以外の場合は false。 + ロックの取得が行われるオブジェクト。 + ロックを待機する時間を表す 。–1 ミリ秒という値は、無期限の待機を指定します。 + + パラメーターが null です。 + + の値 (ミリ秒) が負で、かつ (-1 ミリ秒) と等価でありません。または より大きい値です。 + 1 + + + 指定したオブジェクトの排他ロックの取得を指定した時間にわたって試み、ロックが取得されたかどうかを示す値をアトミックに設定します。 + ロックの取得が行われるオブジェクト。 + ロックを待機する時間。–1 ミリ秒という値は、無期限の待機を指定します。 + ロックを取得しようとした結果で、参照渡しです。入力は false でなければなりません。ロックが取得された場合、出力は true になります。それ以外の場合、出力は false です。ロックを取得しようとしている間に例外が発生した場合でも、出力は設定されます。 + + への入力は true です。 + + パラメーターが null です。 + + の値 (ミリ秒) が負で、かつ (-1 ミリ秒) と等価でありません。または より大きい値です。 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。 + 指定したオブジェクトのロックを呼び出し元が再取得したために、呼び出しが戻った場合は true。このメソッドは、ロックが再取得されないと制御を戻しません。 + 待機を行うオブジェクト。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + 1 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。指定されたタイムアウト期限を過ぎると、スレッドは実行待ちキューに入ります。 + 指定した時間が経過する前にロックが再取得された場合は true。指定した時間が経過した後にロックが再取得された場合は false。このメソッドは、ロックが再取得されるまで制御を戻しません。 + 待機を行うオブジェクト。 + スレッドが実行待ちキューに入るまでの待機時間 (ミリ秒)。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + + パラメーターの値が負で、 と等しくありません。 + 1 + + + オブジェクトのロックを解放し、現在のスレッドがロックを再取得するまでそのスレッドをブロックします。指定されたタイムアウト期限を過ぎると、スレッドは実行待ちキューに入ります。 + 指定した時間が経過する前にロックが再取得された場合は true。指定した時間が経過した後にロックが再取得された場合は false。このメソッドは、ロックが再取得されるまで制御を戻しません。 + 待機を行うオブジェクト。 + スレッドが実行待ちキューに入るまでの時間を表す 。 + + パラメーターが null です。 + 呼び出し元のスレッドは、指定したオブジェクトのロックを所有していません。 + Wait を呼び出したスレッドは、後で待機中の状態を中断されます。これは、別のスレッドがこのスレッドの メソッドを呼び出すと発生します。 + + パラメーターのミリ秒単位の値が負で、かつ (–1 ミリ秒) ではありません。または より大きい値です。 + 1 + + + 同期プリミティブは、プロセス間の同期にも使用できます。 + 1 + + + + クラスの新しいインスタンスを、既定のプロパティを使用して初期化します。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値を使用して、 クラスの新しいインスタンスを初期化します。 + 呼び出し元スレッドにミューテックスの初期所有権を与える場合は true。それ以外の場合は false。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値と、ミューテックスの名前を表す文字列を使用して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きシステム ミューテックスが作成された場合に、呼び出し元スレッドに名前付きシステム ミューテックスの初期所有権を付与する場合は true。それ以外の場合は false。 + + の名前。値が null の場合、 は無名になります。 + アクセス制御セキュリティを使用した名前付きミューテックスが存在しますが、ユーザーに がありません。 + Win32 エラーが発生しました。 + 名前付きミューテックスを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + 260 文字を超えています。 + + + 呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値、ミューテックスの名前を表す文字列、およびメソッドから戻るときにミューテックスの初期所有権が呼び出し元のスレッドに付与されたかどうかを示すブール値を指定して、 クラスの新しいインスタンスを初期化します。 + この呼び出しの結果として名前付きシステム ミューテックスが作成された場合に、呼び出し元スレッドに名前付きシステム ミューテックスの初期所有権を付与する場合は true。それ以外の場合は false。 + + の名前。値が null の場合、 は無名になります。 + このメソッドから制御が戻るとき、ローカル ミューテックスが作成された場合 (つまり が null または空の文字列の場合) または指定した名前付きシステム ミューテックスが作成された場合は、ブール値 true が格納されます。指定した名前付きシステム ミューテックスが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + アクセス制御セキュリティを使用した名前付きミューテックスが存在しますが、ユーザーに がありません。 + Win32 エラーが発生しました。 + 名前付きミューテックスを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + 260 文字を超えています。 + + + 既に存在する場合は、指定した名前付きミューテックスを開きます。 + 名前付きシステム ミューテックスを表すオブジェクト。 + 開くシステム ミューテックスの名前。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + 名前付きミューテックスが存在しません。 + Win32 エラーが発生しました。 + 名前付きミューテックスは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + + を一度解放します。 + 呼び出し元のスレッドはミューテックスを所有していません。 + 1 + + + 既に存在する場合は、指定した名前付きミューテックスを開き操作が成功したかどうかを示す値を返します。 + 名前付きミューテックスが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム ミューテックスの名前。 + このメソッドから戻るときに、呼び出しに成功した場合は名前付きミューテックスを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + Win32 エラーが発生しました。 + 名前付きミューテックスは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + + + リソースへのアクセス管理に使用するロックを表し、複数のスレッドによる読み取りや排他アクセスでの書き込みを実現します。 + + + + クラスの新しいインスタンスを既定のプロパティ値で初期化します。 + + + ロック再帰ポリシーを指定して、 クラスの新しいインスタンスを初期化します。 + ロック再帰ポリシーを指定する列挙値のいずれか。 + + + 読み取りモードでロックに入った一意のスレッドの総数を取得します。 + 読み取りモードでロックに入った一意のスレッドの数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 読み取りモードでロックに入ることを試みます。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + アップグレード可能モードでロックに入ることを試みます。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 書き込みモードでロックに入ることを試みます。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 読み取りモードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合には読み取りモードを終了します。 + The current thread has not entered the lock in read mode. + + + アップグレード可能モードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合にはアップグレード可能モードを終了します。 + The current thread has not entered the lock in upgradeable mode. + + + 書き込みモードの再帰カウントを減らし、結果のカウントが 0 (ゼロ) の場合には書き込みモードを終了します。 + The current thread has not entered the lock in write mode. + + + 現在のスレッドが読み取りモードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在のスレッドがアップグレード可能モードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在のスレッドが書き込みモードでロックに入ったかどうかを示す値を取得します。 + 現在のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 2 + + + 現在の オブジェクトの再帰ポリシーを示す値を取得します。 + ロック再帰ポリシーを指定する列挙値のいずれか。 + + + 現在のスレッドが読み取りモードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドは読み取りモードに入っていません。1 の場合、現在のスレッドは読み取りモードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回ロックに入りました。 + 2 + + + 現在のスレッドがアップグレード可能モードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドはアップグレード可能モードに入っていません。1 の場合、現在のスレッドはアップグレード可能モードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回アップグレード可能モードに入りました。 + 2 + + + 現在のスレッドが書き込みモードでロックに入った回数を、再帰を示す値として取得します。 + 0 (ゼロ) の場合、現在のスレッドは書き込みモードに入っていません。1 の場合、現在のスレッドは書き込みモードに入ったが、再帰はしていません。n の場合、現在のスレッドは再帰的に n - 1 回書き込みモードに入りました。 + 2 + + + オプションのタイムアウトを表す整数を指定して、読み取りモードでロックに入ることを試みます。 + 呼び出し元のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、読み取りモードでロックに入ることを試みます。 + 呼び出し元のスレッドが読み取りモードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + オプションのタイムアウトを指定して、アップグレード可能モードでロックに入ることを試みます。 + 呼び出し元のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、アップグレード可能モードでロックに入ることを試みます。 + 呼び出し元のスレッドがアップグレード可能モードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + オプションのタイムアウトを指定して、書き込みモードでロックに入ることを試みます。 + 呼び出し元のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + オプションのタイムアウトを指定して、書き込みモードでロックに入ることを試みます。 + 呼び出し元のスレッドが書き込みモードに入った場合は true、それ以外の場合は false。 + 待機する間隔。無制限に待機する場合は -1 ミリ秒。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 読み取りモードでロックに入るのを待機しているスレッドの総数を取得します。 + 読み取りモードに入るのを待機しているスレッドの総数。 + 2 + + + アップグレード可能モードでロックに入るのを待機しているスレッドの総数を取得します。 + アップグレード可能モードに入るのを待機しているスレッドの総数。 + 2 + + + 書き込みモードでロックに入るのを待機しているスレッドの総数を取得します。 + 書き込みモードに入るのを待機しているスレッドの総数。 + 2 + + + リソースまたはリソースのプールに同時にアクセスできるスレッドの数を制限します。 + 1 + + + エントリ数の初期値と同時実行エントリの最大数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + + が より大きくなっています。 + + 1 より小さい値です。または が 0 未満です。 + + + エントリ数の初期値と同時実行エントリの最大数を指定し、オプションでシステム セマフォ オブジェクトの名前を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + 名前付きシステム セマフォ オブジェクトの名前。 + + が より大きくなっています。または 260 文字を超えています。 + + 1 より小さい値です。または が 0 未満です。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きセマフォが存在しており、ユーザーに がありません。 + 名前付きセマフォを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + + エントリ数の初期値と同時実行エントリの最大数を指定し、オプションでシステム セマフォ オブジェクトの名前を指定し、新しいシステム セマフォが作成されたかどうかを示す値を受け取る変数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に満たされるセマフォの要求の初期数。 + 同時に満たされるセマフォの要求の最大数。 + 名前付きシステム セマフォ オブジェクトの名前。 + このメソッドから制御が戻るときに、ローカル セマフォが作成された場合 ( が null または空の文字列の場合)、または指定した名前付きシステム セマフォが作成された場合は true が格納されます。指定した名前付きシステム セマフォが既に存在する場合は false が格納されます。このパラメーターは初期化せずに渡されます。 + + が より大きくなっています。または 260 文字を超えています。 + + 1 より小さい値です。または が 0 未満です。 + Win32 エラーが発生しました。 + アクセス制御セキュリティを使用した名前付きセマフォが存在しており、ユーザーに がありません。 + 名前付きセマフォを作成できません。別の型の待機ハンドルに同じ名前が付けられていることが原因として考えられます。 + + + 既に存在する場合は、指定した名前付きセマフォを開きます。 + 名前付きシステム セマフォを表すオブジェクト。 + 開くシステム セマフォの名前。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + 名前付きセマフォが存在しません。 + Win32 エラーが発生しました。 + 名前付きセマフォは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + 1 + + + + + + セマフォから出て、前のカウントを返します。 + + メソッドが呼び出される前のセマフォのカウント。 + セマフォのカウントは既に最大値です。 + 名前付きセマフォで Win32 エラーが発生しました。 + 現在のセマフォは名前付きシステム セマフォを表していますが、ユーザーに がありません。または現在のセマフォは名前付きシステム セマフォを表していますが、 で開かれませんでした。 + 1 + + + 指定した回数だけセマフォから出て、前のカウントを返します。 + + メソッドが呼び出される前のセマフォのカウント。 + セマフォから出る回数。 + + 1 より小さい値です。 + セマフォのカウントは既に最大値です。 + 名前付きセマフォで Win32 エラーが発生しました。 + 現在のセマフォは名前付きシステム セマフォを表していますが、ユーザーに 権限がありません。または現在のセマフォは名前付きシステム セマフォを表していますが、 権限で開かれませんでした。 + 1 + + + 既に存在する場合は、指定した名前付きセマフォを開き操作が成功したかどうかを示す値を返します。 + 名前付きのセマフォが正常に開かれた場合は true。それ以外の場合は false。 + 開くシステム セマフォの名前。 + このメソッドから制御が戻るときに、呼び出しに成功した場合は名前付きセマフォを表す オブジェクトが格納されます。呼び出しに失敗した場合は null が格納されます。このパラメーターは初期化前として処理されます。 + + が空の文字列です。または 260 文字を超えています。 + + は null です。 + Win32 エラーが発生しました。 + 名前付きセマフォは存在しますが、それを使用するために必要なセキュリティ アクセスがユーザーにありません。 + + + カウントが既に最大値であるセマフォに対して メソッドが呼び出された場合にスローされる例外。 + 2 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + リソースまたはリソースのプールに同時にアクセスできるスレッドの数を制限する の軽量版を表します。 + + + 同時に許可される要求の初期数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + + が 0 未満です。 + + + 同時に許可される要求の初期数および最大数を指定して、 クラスの新しいインスタンスを初期化します。 + 同時に許可されるセマフォの要求の初期数。 + 同時に許可されるセマフォの要求の最大数。 + + が 0 より小さいか、 が を超えているか、または が 0 以下です。 + + + セマフォの待機に使用できる を返します。 + セマフォの待機に使用できる です。 + + は破棄されています。 + + + + オブジェクトに入る、残りのスレッド数を取得します。 + セマフォに入る、残りのスレッド数。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + + が使用しているアンマネージ リソースを解放します。オプションとして、マネージ リソースを解放することもできます。 + マネージ リソースとアンマネージ リソースの両方を解放する場合は true。アンマネージ リソースだけを解放する場合は false。 + + + + のオブジェクトを一度解放します。 + + の前のカウント。 + 現在のインスタンスは既に破棄されています。 + + は、既にその最大サイズに達しました。 + + + 指定された回数だけ、 オブジェクトを解放します。 + + の前のカウント。 + セマフォから出る回数。 + 現在のインスタンスは既に破棄されています。 + + 1 より小さい値です。 + + は、既にその最大サイズに達しました。 + + + + に入れるようになるまで、現在のスレッドをブロックします。 + 現在のインスタンスは既に破棄されています。 + + + タイムアウト値を 32 ビット符号付き整数で指定して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + + を観察すると同時に、タイムアウト値を 32 ビット符号付き整数で指定して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が取り消されました。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + インスタンスが破棄されている、または 作成 破棄されています。 + + + + を観察すると同時に、 に入れるようになるまで、現在のスレッドをブロックします。 + 観察する トークン。 + + が取り消されました。 + 現在のインスタンスは既に破棄されています。または 作成 既に破棄されています。 + + + + を使用してタイムアウトを指定し、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + semaphoreSlim インスタンスが破棄されました。 + + + + を観察すると同時に、タイムアウトを指定する を使用して、 に入れるようになるまで、現在のスレッドをブロックします。 + 現在のスレッドが に正常に入った場合は true。それ以外の場合は false。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する 。 + + が取り消されました。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + semaphoreSlim インスタンスが破棄されました。 を作成した は既に破棄されています。 + + + + に移行するために非同期に待機します。 + セマフォに入っているときに完了するタスク。 + + + 32 ビット符号付き整数を使用して時間間隔を測定しながら、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + 32 ビット符号付き整数を使用して時間間隔を測定しながら、 を観察すると同時に、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + 観察する 。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + 現在のインスタンスは既に破棄されています。 + + が取り消されました。 + + + + を観察すると同時に、 に移行するために非同期に待機します。 + セマフォに入っているときに完了するタスク。 + 観察する トークン。 + 現在のインスタンスは既に破棄されています。 + + が取り消されました。 + + + + を使用して時間間隔を測定しながら、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 現在のインスタンスは既に破棄されています。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します または タイムアウトは より大きい値です。 + + + + を使用して時間間隔を測定しながら、 を観察すると同時に、 に移行するために非同期に待機します。 + 現在のスレッドが正常に を入力した場合は true、それ以外の場合は false で完了するタスク。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + 観察する トークン。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表しますまたはタイムアウトは より大きい値です。 + + が取り消されました。 + + + メッセージを同期コンテキストにディスパッチするときに呼び出すメソッドを表します。 + デリゲートに渡されたオブジェクト。 + 2 + + + ロックが使用可能になるまで、ロックを取得しようとするスレッドがループの繰り返しチェック内で待機する相互排他ロック プリミティブを提供します。 + + + デバッグを向上させるためにスレッド ID を追跡するオプションを使用して、 構造体の新しいインスタンスを初期化します。 + デバッグのためにスレッド ID をキャプチャして使用するかどうか。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックを取得します。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + 引数は、Enter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + ロックを解放します。 + スレッドの所有権の追跡が有効で、現在のスレッドはこのロックの所有者ではありません。 + + + ロックを解放します。 + 終了操作を他のスレッドに直ちに発行するためにメモリ フェンスを発行する必要があるかどうかを示すブール値。 + スレッドの所有権の追跡が有効で、現在のスレッドはこのロックの所有者ではありません。 + + + ロックが現在いずれかのスレッドによって保持されているかどうかを取得します。 + ロックが現在いずれかのスレッドによって保持されている場合は true。それ以外の場合は false。 + + + ロックが現在のスレッドによって保持されているかどうかを取得します。 + ロックが現在のスレッドによって保持されている場合は true。それ以外の場合は false。 + スレッドの所有権の追跡が無効です。 + + + このインスタンスに対してスレッド所有権の追跡が有効になっているかどうかを取得します。 + このインスタンスに対してスレッド所有権の追跡が有効になっている場合は true。それ以外の場合は false。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + メソッド呼び出し内で例外が発生した場合でも、 を確実に確認して、ロックが取得されたかどうかを判断できるような信頼性の高い方法で、ロックの取得を試みます。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す 。 + ロックが取得された場合は true。それ以外の場合は false。このメソッドを呼び出す前に、 を false に初期化する必要があります。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが ミリ秒を超えています。 + + 引数は、TryEnter を呼び出す前に false に初期化する必要があります。 + スレッドの所有権の追跡が有効で、現在のスレッドは既にこのロックを取得しています。 + + + スピンベースの待機のサポートを提供します。 + + + このインスタンスで が呼び出された回数を取得します。 + このインスタンスで が呼び出された回数を表す整数を返します。 + + + 次に を呼び出したときにプロセッサが生成され、強制的にコンテキストが切り替えられるかどうかを取得します。 + 次に を呼び出したときにプロセッサが生成され、強制的にコンテキストが切り替えられるかどうか。 + + + スピン カウンターをリセットします。 + + + 単一のスピンを実行します。 + + + 指定した条件が満たされるまで回転します。 + true を返すまで繰り返し実行されるデリゲート。 + + 引数が null です。 + + + 指定した条件が満たされるか、指定したタイムアウトが経過するまで回転します。 + タイムアウト内に条件が満たされた場合は true。それ以外の場合は false。 + true を返すまで繰り返し実行されるデリゲート。 + 待機するミリ秒数。無制限に待機する場合は (-1)。 + + 引数が null です。 + + が -1 以外の負数です。-1 は無制限のタイムアウトを表します。 + + + 指定した条件が満たされるか、指定したタイムアウトが経過するまで回転します。 + タイムアウト内に条件が満たされた場合は true。それ以外の場合は false。 + true を返すまで繰り返し実行されるデリゲート。 + 待機するミリ秒数を表す 。無制限に待機する場合は、-1 ミリ秒を表す TimeSpan。 + + 引数が null です。 + + が -1 ミリ秒以外の負数です。-1 は無制限のタイムアウトを表します。または、タイムアウトが を超えています。 + + + 同期コンテキストをさまざまな同期モデルに反映させるための基本機能を提供します。 + 2 + + + + クラスの新しいインスタンスを作成します。 + + + 派生クラスでオーバーライドされた場合、同期コンテキストのコピーを作成します。 + 新しい オブジェクト。 + 2 + + + 現在のスレッドの同期コンテキストを取得します。 + 現在の同期コンテキストを表す オブジェクト。 + 1 + + + 派生クラスでオーバーライドされた場合、操作の完了を伝える通知に応答します。 + + + 派生クラスでオーバーライドされた場合、操作の開始を伝える通知に応答します。 + + + 派生クラスでオーバーライドされた場合、非同期メッセージを同期コンテキストにディスパッチします。 + 呼び出す デリゲート。 + デリゲートに渡されたオブジェクト。 + 2 + + + 派生クラスでオーバーライドされた場合、同期メッセージを同期コンテキストにディスパッチします。 + 呼び出す デリゲート。 + デリゲートに渡されたオブジェクト。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 現在の同期コンテキストを設定します。 + 設定する オブジェクト + 1 + + + + + + 指定した Monitor でロックを所有していることが呼び出し元の条件となるメソッドを、そのロックを所有していない呼び出し元が呼び出した場合にスローされる例外です。 + 2 + + + + クラスの新しいインスタンスを既定のプロパティを使用して初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + データのスレッド ローカル ストレージを提供します。 + スレッド単位で格納されるデータの型を指定します。 + + + + インスタンスを初期化します。 + + + + インスタンスを初期化します。 + インスタンスに設定されているすべての値を追跡し、それらの値を プロパティを通じて公開するかどうか。 + + + + 関数を指定して、 インスタンスを初期化します。 + 前もって初期化せずに を取得しようとすると、後で初期化された値を生成するために が呼び出されます。 + + が null 参照 (Visual Basic の場合は Nothing) です。 + + + + 関数を指定して、 インスタンスを初期化します。 + 前もって初期化せずに を取得しようとすると、後で初期化された値を生成するために が呼び出されます。 + インスタンスに設定されているすべての値を追跡し、それらの値を プロパティを通じて公開するかどうか。 + + が null 参照 (Visual Basic の場合は Nothing) です。 + + + + クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。 + + + この インスタンスによって使用されているリソースを解放します。 + + が呼び出されたことが原因でこのメソッドが呼び出されているかどうかを示すブール値。 + + + この インスタンスによって使用されているリソースを解放します。 + + + 現在のスレッドで が初期化されているかどうかを取得します。 + + が現在のスレッドで初期化される場合は true。それ以外の場合は false。 + + インスタンスは破棄されています。 + + + 現在のスレッドのこのインスタンスの文字列形式を作成して返します。 + + で を呼び出した結果。 + + インスタンスは破棄されています。 + 現在のスレッドの は null 参照 (Visual Basic での Nothing) です。 + 初期化関数が、 を再帰的に参照しようとしました。 + 既定のコンストラクターが指定されず、値ファクトリが指定されていません。 + + + 現在のスレッドのこのインスタンスの値を取得または設定します。 + この ThreadLocal が初期化するオブジェクトのインスタンスを返します。 + + インスタンスは破棄されています。 + 初期化関数が、 を再帰的に参照しようとしました。 + 既定のコンストラクターが指定されず、値ファクトリが指定されていません。 + + + このインスタンスにアクセスした全スレッドによって現在格納されているすべての値のリストを取得します。 + このインスタンスにアクセスした全スレッドによって現在格納されているすべての値のリスト。 + + インスタンスは破棄されています。 + + + 不揮発性メモリの操作を実行するためのメソッドが含まれます。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定されたフィールドの値を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた値。この値は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + + + 指定したフィールドからオブジェクト参照を読み取ります。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの後に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの前へ移動できなくなります。 + 読み取られた への参照。この参照は、プロセッサの数やプロセッサ キャッシュの状態にかかわらず、コンピューター内のいずれかのプロセッサによって書き込まれた最新の値です。 + 読み取るフィールド。 + 読み取るフィールドの型。この型は、値型ではなく、参照型である必要があります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前にメモリ操作が配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定した値を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + 値を書き込むフィールド。 + 書き込む値。値は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + + + 指定したオブジェクト参照を指定したフィールドに書き込みます。これが求められるシステムにおいて、プロセッサがメモリ操作を並べ替えるのを防止するメモリ バリアを挿入します。つまり、コード内でこのメソッドの前に読み取りまたは書き込みが配置されている場合、プロセッサはその操作をこのメソッドの後へ移動できなくなります。 + オブジェクト参照を書き込むフィールド。 + 書き込むオブジェクト参照。参照は即座に書き込まれるため、コンピューター内のすべてのプロセッサに対して可視になります。 + 書き込むフィールドの型。この型は、値型ではなく、参照型である必要があります。 + + + 存在しないシステム ミューテックスまたはシステム セマフォを開こうとしたときにスローされる例外。 + 2 + + + + クラスの新しいインスタンスを既定値で初期化します。 + + + 指定したエラー メッセージを使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + + + 指定したエラー メッセージと、この例外の原因である内部例外への参照を使用して、 クラスの新しいインスタンスを初期化します。 + 例外の原因を説明するエラー メッセージ。 + 現在の例外の原因である例外。 パラメーターが null でない場合は、内部例外を処理する catch ブロックで現在の例外が発生します。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/ko/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/ko/System.Threading.xml new file mode 100644 index 000000000..dd5f63d87 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/ko/System.Threading.xml @@ -0,0 +1,1952 @@ + + + + System.Threading + + + + 스레드가 다른 스레드에서 해제하지 않고 종료하여 중단한 개체를 가져오면 throw되는 예외입니다. + 1 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 중단된 뮤텍스의 지정된 인덱스 및 뮤텍스를 나타내는 개체(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 내부 예외를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 지정된 오류 메시지, 내부 예외, 중단된 뮤텍스의 인덱스 및 뮤텍스를 나타내는 개체(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 지정된 오류 메시지, 중단된 뮤텍스의 인덱스 및 중단된 뮤텍스(해당 사항이 있을 경우)를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + 메서드에 대해 예외가 throw되면 대기 핸들의 배열에서 중단된 뮤텍스의 인덱스이고, 또는 메서드에 대해 예외가 throw되면 –1입니다. + 중단된 뮤텍스를 나타내는 개체입니다. + + + 예외의 발생시킨 중단된 뮤텍스를 가져옵니다. + 중단된 뮤텍스를 나타내는 개체이며, 중단된 뮤텍스를 식별할 수 없는 경우에는 null입니다. + 1 + + + 예외의 발생시킨 중단된 뮤텍스를 가져옵니다. + + 메서드에 전달된 대기 핸들의 배열에서 중단된 뮤텍스를 나타내는 개체의 인덱스이고, 중단된 뮤텍스의 인덱스를 식별할 수 없는 경우에는 –1입니다. + 1 + + + 비동기 메서드와 같은 지정된 비동기 제어 흐름에 로컬인 앰비언트 데이터를 나타냅니다. + 앰비언트 데이터의 형식입니다. + + + 변경 알림을 받지 않는 인스턴스를 인스턴스화합니다. + + + 변경 알림을 받는 로컬 인스턴스를 인스턴스화합니다. + 스레드에서 현재 값이 변경될 때마다 호출되는 대리자입니다. + + + 앰비언트 데이터의 값을 가져오거나 설정합니다. + 앰비언트 데이터의 값입니다. + + + 변경 알림을 등록하는 인스턴스에 데이터 변경 정보를 제공하는 클래스입니다. + 데이터 형식입니다. + + + 데이터의 현재 값을 가져옵니다. + 데이터의 현재 값입니다. + + + 데이터의 이전 값을 가져옵니다. + 데이터의 이전 값입니다. + + + 실행 컨텍스트가 변경되어 값이 변경되었는지 여부를 나타내는 값을 반환합니다. + 실행 컨텍스트가 변경되어 값이 변경되었으면 true이고, 그렇지 않으면 false입니다. + + + 대기 중인 스레드에 이벤트가 발생했음을 알립니다.이 클래스는 상속될 수 없습니다. + 2 + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + + + 여러 작업이 여러 단계에 걸쳐 특정 알고리즘에서 병렬로 함께 작동할 수 있도록 합니다. + + + + 클래스의 새 인스턴스를 초기화합니다. + 참여 스레드의 수입니다. + + 가 0보다 작거나 32,767보다 큰 경우 + + + + 클래스의 새 인스턴스를 초기화합니다. + 참여 스레드의 수입니다. + 각 단계 후에 실행할 입니다. 아무 작업도 수행되지 않았음을 나타내기 위해 null(Visual Basic의 경우 Nothing)이 전달될 수 있습니다. + + 가 0보다 작거나 32,767보다 큰 경우 + + + 추가 참가자가 있음을 에 알립니다. + 새 참가자가 처음으로 참여할 장벽의 단계 번호입니다. + 현재 인스턴스가 이미 삭제된 경우 + 참가자를 추가하면 해당 장애물 참가자 수가 32,767을 초과하게 됩니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 추가 참가자가 있음을 에 알립니다. + 새 참가자가 처음으로 참여할 장벽의 단계 번호입니다. + 장벽에 추가할 추가 참가자의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우.또는 참가자를 추가하면 해당 장애물 참가자 수가 32,767을 초과하게 됩니다. + 이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 장벽의 현재 단계 번호를 가져옵니다. + 장벽의 현재 단계 번호를 반환합니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + 이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 장벽에 있는 참가자의 총 수를 가져옵니다. + 장벽에 있는 참가자의 총 수를 반환합니다. + + + 현재 단계에서 아직 신호를 받지 않은 장벽의 참가자 수를 가져옵니다. + 현재 단계에서 아직 신호를 받지 않은 장벽의 참가자 수를 반환합니다. + + + 참가자가 하나 감소함을 에 알립니다. + 현재 인스턴스가 이미 삭제된 경우 + 해당 장애물에 이미 0 참가자가 있습니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. + + + 참가자가 감소함을 에 알립니다. + 장벽에서 제거할 추가 참가자의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우. + 해당 장애물에 이미 0 참가자가 있습니다.또는이 메서드는 사후 단계 작업 내에서 호출되었습니다. 또는현재 참가자 수가 지정된 participantCount보다 작습니다. + 총 참가자 수가 지정된 보다 작습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 현재 인스턴스가 이미 삭제된 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + 모든 참가 스레드가 SignalAndWait를 호출한 후에 Barrier의 단계 후 작업에서 예외가 throw되는 경우 예외가 BarrierPostPhaseException에서 래핑되고 모든 참가 스레드에서 throw됩니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 부호 있는 32비트 정수로 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 지정된 시간 내에 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + 모든 참가 스레드가 SignalAndWait를 호출한 후에 Barrier의 단계 후 작업에서 예외가 throw되는 경우 예외가 BarrierPostPhaseException에서 래핑되고 모든 참가 스레드에서 throw됩니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 부호 있는 32비트 정수로 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 지정된 시간 내에 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 개체를 사용하여 시간 간격을 측정하여 다른 참가자도 장벽에 도달할 때까지 기다립니다. + 다른 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 없거나, 32,767보다 큰 경우. + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + 참가자가 장벽에 도달했다는 신호를 보내고 취소 토큰을 확인하면서 개체를 사용하여 시간 제한을 측정하여 다른 모든 참가자도 장벽에 도달할 때까지 기다립니다. + 다른 모든 참가자가 장벽에 도달했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수인 경우 + 메서드는 사후 단계 작업 내에서 호출되며 현재 장애물에 0 참가자가 있거나 장애물이 참가자로 등록된 것보다 많은 스레드에서 신호를 받습니다. + + + + 의 사후 단계 작업이 실패할 경우 throw되는 예외입니다. + + + 오류를 설명하는 시스템 제공 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 내부 예외를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 현재 예외의 원인이 되는 예외입니다. + + + 오류를 설명하는 지정된 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 맞게 지역화되었는지 확인하는 데 필요합니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 새 컨텍스트 내에서 호출될 메서드를 나타냅니다. + 콜백 메서드가 실행될 때마다 사용할 정보가 포함된 개체입니다. + 1 + + + 수가 0에 도달하는 경우 신호를 받는 동기화 기본 형식을 나타냅니다. + + + 지정된 수를 사용하여 클래스의 새 인스턴스를 초기화합니다. + + 를 설정하는 데 처음 필요한 신호의 수입니다. + + 가 0보다 작은 경우 + + + + 의 현재 수를 1씩 늘립니다. + 현재 인스턴스가 이미 삭제된 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는가 보다 크거나 같은 경우 + + + + 의 현재 수를 지정된 값만큼 늘립니다. + + 를 늘릴 값입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작거나 같은 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는개수가 만큼 증가된 후에 가 보다 크거나 같은 경우 + + + 이벤트를 설정하는 데 필요한 남아 있는 신호의 수를 가져옵니다. + 이벤트를 설정하는 데 필요한 남아 있는 신호의 수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제합니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 이벤트를 설정하는 데 처음으로 필요한 신호의 수를 가져옵니다. + 이벤트를 설정하는 데 처음으로 필요한 신호의 수입니다. + + + 이벤트가 설정되었는지 여부를 확인합니다. + 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + + + + 를 의 값으로 다시 설정합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + + 속성을 지정된 값으로 재설정합니다. + + 를 설정하는 데 필요한 신호의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작은 경우 + + + + 의 값을 줄이면서 신호를 에 등록합니다. + 신호로 인해 수가 0에 도달하고 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 현재 인스턴스가 이미 삭제된 경우 + 현재 인스턴스가 이미 설정되어 있습니다. + + + 지정된 양만큼 값을 줄이면서 여러 신호를 에 등록합니다. + 신호로 인해 수가 0에 도달하고 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 등록할 신호의 수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 1보다 작은 경우. + 현재 인스턴스가 이미 설정되어 있습니다. -또는- 가 보다 큰 경우 + + + 하나씩 를 증가하려고 시도했습니다. + 늘렸으면 true이고 그렇지 않으면 false입니다.가 이미 0이면 이 메서드에서 false를 반환합니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 와 같은 경우 + + + 지정된 값만큼 를 증가하려고 시도했습니다. + 늘렸으면 true이고 그렇지 않으면 false입니다.가 이미 0이면 false를 반환합니다. + + 를 늘릴 값입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 가 0보다 작거나 같은 경우 + 현재 인스턴스가 이미 설정되어 있습니다.또는 + 가 보다 크거나 같은 경우 + + + + 가 설정될 때까지 현재 스레드를 차단합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + 부호 있는 32비트 정수로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을 확인하면서 부호 있는 32비트 정수로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을 확인하면서 가 설정될 때까지 현재 스레드를 차단합니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + + + 으로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + + 을 확인하면서 으로 시간 제한을 측정하여 가 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우 -또는- 을 만든 가 이미 삭제되었습니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + 이벤트가 설정될 때까지 대기하는 데 사용되는 을 가져옵니다. + 이벤트가 설정될 때까지 대기하는 데 사용되는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + + + 이 신호를 받은 후 자동이나 수동으로 다시 설정되는지 여부를 나타냅니다. + 2 + + + 신호를 받으면 이 스레드 하나를 해제한 후 자동으로 다시 설정됩니다.대기 중인 스레드가 없으면 은 스레드가 차단될 때까지 신호를 받은 상태로 유지되다가 스레드를 해제한 후 다시 설정됩니다. + + + 신호를 받으면 이 대기하는 스레드를 모두 해제하고 수동으로 다시 설정될 때까지 신호를 받은 상태로 유지됩니다. + + + 스레드 동기화 이벤트를 나타냅니다. + 2 + + + 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부와 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + + + 이 호출의 결과로 만들어진 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부, 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부 및 시스템 동기화 이벤트의 이름을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 이벤트가 만들어진 경우 초기 상태를 신호 받음으로 설정하려면 true를 사용하고, 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + 시스템 차원의 동기화 이벤트의 이름입니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 이벤트를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 이 260자보다 긴 경우 + + + 이 호출의 결과로 만들어진 대기 핸들의 초기 상태를 신호 받음으로 설정할지 여부, 대기 핸들을 자동으로 다시 설정할지 수동으로 다시 설정할지 여부, 시스템 동기화 이벤트의 이름 및 호출 후 명명된 시스템 이벤트가 만들어졌는지 여부를 나타내는 부울 변수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 이벤트가 만들어진 경우 초기 상태를 신호 받음으로 설정하려면 true를 사용하고, 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + 이벤트를 자동으로 다시 설정할지 수동으로 다시 설정할지 결정하는 값 중 하나입니다. + 시스템 차원의 동기화 이벤트의 이름입니다. + 이 메서드가 반환될 때 로컬 이벤트가 만들어지거나(이 null 또는 빈 문자열) 명명된 지정 시스템 이벤트가 만들어지면 true가 포함되고 명명된 지정 시스템 이벤트가 이미 있으면 false가 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 이벤트를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 이 260자보다 긴 경우 + + + 이미 있는 경우 지정한 명명된 동기화 이벤트를 엽니다. + 명명된 시스템 이벤트를 나타내는 개체입니다. + 열려는 시스템 동기화 이벤트의 이름입니다. + + 이 빈 문자열인 경우 또는이 260자보다 긴 경우 + + 가 null입니다. + 명명된 시스템 이벤트가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 이벤트가 있지만 사용자에게 이 이벤트를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + 1 + + + + + + 스레드가 차단되도록 이벤트 상태를 신호 없음으로 설정합니다. + 작업이 성공적으로 수행되면 true이고, 그렇지 않으면 false입니다. + + 메서드가 이 에 대해 이전에 호출된 경우 + 2 + + + 하나 이상의 대기 중인 스레드가 계속 진행되도록 이벤트 상태를 신호 받음으로 설정합니다. + 작업이 성공적으로 수행되면 true이고, 그렇지 않으면 false입니다. + + 메서드가 이 에 대해 이전에 호출된 경우 + 2 + + + 지정된 명명된 synchronization 이벤트(이미 존재하는 경우)를 열고 작업이 성공적으로 수행되었는지를 나타내는 값을 반환합니다. + 명명된 동기화 이벤트를 열었으면 true이고, 그렇지 않으면 false입니다. + 열려는 시스템 동기화 이벤트의 이름입니다. + 이 메서드가 반환될 때 호출이 성공적으로 실행된 경우 이름이 지정된 동기화 이벤트를 나타내는 개체를 포함하고 호출에 실패한 경우는 null을 포함해야 합니다.이 매개 변수는 초기화되지 않은 것으로 취급됩니다. + + 이 빈 문자열인 경우또는이 260자보다 긴 경우 + + 가 null입니다. + Win32 오류가 발생한 경우 + 명명된 이벤트가 있지만 사용자에게 원하는 보안 액세스가 없는 경우 + + + 현재 스레드의 실행 컨텍스트를 관리합니다.이 클래스는 상속될 수 없습니다. + 2 + + + 현재 스레드에서 실행 컨텍스트를 캡처합니다. + 현재 스레드의 실행 컨텍스트를 나타내는 개체입니다. + 1 + + + 현재 스레드의 지정된 실행 컨텍스트에서 메서드를 실행합니다. + 설정할 입니다. + 제공된 실행 컨텍스트에서 실행할 메서드를 나타내는 대리자입니다. + 콜백 메서드로 전달할 개체입니다. + + 가 null입니다.또는캡처 작업을 통해 를 가져오지 않은 경우 또는가 이미 호출의 인수로 사용된 경우 + 1 + + + + + + 다중 스레드에서 공유하는 변수에 대한 원자 단위 연산을 제공합니다. + 2 + + + 원자 단위 연산으로 두 32비트 정수를 더하고 첫 번째 정수를 합계로 바꿉니다. + + 에 저장된 새 값입니다. + 더할 첫 번째 값이 있는 변수입니다.두 값의 합계는 에 저장됩니다. + + 에서 정수에 더할 값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 두 64비트 정수를 더하고 첫 번째 정수를 합계로 바꿉니다. + + 에 저장된 새 값입니다. + 더할 첫 번째 값이 있는 변수입니다.두 값의 합계는 에 저장됩니다. + + 에서 정수에 더할 값입니다. + The address of is a null pointer. + 1 + + + 두 배 정밀도 부동 소수점 숫자가 같은지 비교하여 같으면 두 값 중 하나를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 개의 부호 있는 32비트 정수가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 개의 부호 있는 64비트 정수가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 두 플랫폼별 핸들이나 포인터가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 값과 비교되어 로 바뀔 수 있는 값을 가진 대상 입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 입니다. + + 의 값과 비교할 입니다. + The address of is a null pointer. + 1 + + + 두 개체의 참조가 같은지 비교하여 같으면 첫 번째 개체를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 대상 개체입니다. + 비교한 결과 같은 경우 대상 개체를 바꾸는 개체입니다. + + 의 개체와 비교할 개체입니다. + The address of is a null pointer. + 1 + + + 두 단정밀도 부동 소수점 숫자가 같은지 비교하여 같으면 첫 번째 값을 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + The address of is a null pointer. + 1 + + + 지정된 참조 형식 의 두 인스턴스가 같은지 비교하여 같으면 두 값 중 하나를 바꿉니다. + + 의 원래 값입니다. + + 와 비교되어 바뀔 수 있는 값을 가진 대상입니다.이것은 참조 매개 변수입니다. C#에서는 ref이고, Visual Basic에서는 ByRef입니다. + 비교 결과가 같은 경우 대상 값을 바꿀 값입니다. + + 의 값과 비교할 값입니다. + + , 및 에 사용될 형식입니다.이 형식은 참조 형식이어야 합니다. + The address of is a null pointer. + + + 원자 단위 연산으로 지정된 변수를 감소시키고 결과를 저장합니다. + 감소한 값입니다. + 값을 감소시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 변수를 감소시키고 결과를 저장합니다. + 감소한 값입니다. + 값을 감소시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 배정밀도 부동 소수점 숫자를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 부호 있는 32비트 정수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 부호 있는 64비트 정수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 플랫폼별 핸들 또는 포인터를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 개체를 지정된 값으로 설정하고 참조를 원래 개체로 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 단정밀도 부동 소수점 숫자를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다. + + 매개 변수의 설정값입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 형식 의 변수를 지정된 값으로 설정하고 원래 값을 반환합니다. + + 의 원래 값입니다. + 지정된 값으로 설정할 변수입니다.이것은 참조 매개 변수입니다. C#에서는 ref이고, Visual Basic에서는 ByRef입니다. + + 매개 변수의 설정값입니다. + + 및 에 사용될 형식입니다.이 형식은 참조 형식이어야 합니다. + The address of is a null pointer. + + + 원자 단위 연산으로 지정된 변수를 증가시키고 결과를 저장합니다. + 증가한 값입니다. + 값을 증가시킬 변수입니다. + The address of is a null pointer. + 1 + + + 원자 단위 연산으로 지정된 변수를 증가시키고 결과를 저장합니다. + 증가한 값입니다. + 값을 증가시킬 변수입니다. + The address of is a null pointer. + 1 + + + 다음과 같이 메모리 액세스를 동기화합니다. 현재 스레드를 실행하는 프로세서는 에 대한 호출 이전의 메모리 액세스가 에 대한 호출 이후의 메모리 액세스 뒤에 실행되는 방식으로 명령을 다시 정렬할 수 없습니다. + + + 원자 단위 연산으로 로드된 64비트 값을 반환합니다. + 로드된 값입니다. + 로드될 64비트 값입니다. + 1 + + + 초기화 지연 루틴을 제공합니다. + + + 아직 초기화되지 않은 경우 형식의 기본 생성자를 사용하여 대상 참조 형식을 초기화합니다. + 초기화된 형식의 참조입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조입니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 해당 기본 생성자를 사용하여 대상 참조 또는 값 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조 또는 값입니다. + 대상이 이미 초기화되었는지 여부를 결정하는 부울 값에 대한 참조입니다. + + 을 초기화할 때 상호 배타적인 잠금으로 사용할 개체에 대한 참조입니다.이 null이면 새 개체를 인스턴스화할 수 있습니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 지정된 함수를 사용하여 대상 참조 또는 값 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조 또는 값입니다. + 대상이 이미 초기화되었는지 여부를 결정하는 부울 값에 대한 참조입니다. + + 을 초기화할 때 상호 배타적인 잠금으로 사용할 개체에 대한 참조입니다.이 null이면 새 개체를 인스턴스화할 수 있습니다. + 참조 또는 값을 초기화하기 위해 호출되는 함수입니다. + 초기화할 참조의 형식입니다. + 형식 의 생성자에 액세스할 수 있는 권한이 없습니다. + 형식 에 기본 생성자가 없는 경우 + + + 아직 초기화되지 않은 경우 지정된 함수를 사용하여 대상 참조 형식을 초기화합니다. + 초기화된 형식의 값입니다. + 아직 초기화되지 않은 경우 초기화할 형식의 참조입니다. + 참조를 초기화하기 위해 호출되는 함수입니다. + 초기화할 참조의 참조 형식입니다. + 형식 에 기본 생성자가 없는 경우 + + 가 null을 반환합니다(Visual Basic의 경우 Nothing). + + + 잠금에 대한 재귀 정책과 맞지 않는 방식으로 잠금을 재귀적으로 시작할 때 throw되는 예외입니다. + 2 + + + 오류를 설명하는 시스템 제공 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 2 + + + 오류를 설명하는 지정된 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 따라 지역화되었는지 확인해야 합니다. + 2 + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외를 설명하는 메시지입니다.이 생성자의 호출자는 이 문자열이 현재 시스템 문화권에 따라 지역화되었는지 확인해야 합니다. + 현재 예외를 발생시킨 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + 2 + + + 동일한 스레드에서 잠금을 여러 번 시작할 수 있는지 여부를 지정합니다. + + + 스레드에서 잠금을 재귀적으로 시작하려고 하면 예외가 throw됩니다.이 설정을 적용하는 경우 일부 클래스에서 특정 재귀가 허용될 수도 있습니다. + + + 스레드에서 잠금을 재귀적으로 시작할 수 있습니다.일부 클래스에서는 이 기능이 제한될 수 있습니다. + + + 하나 이상의 대기 중인 스레드에 이벤트가 발생했음을 알립니다.이 클래스는 상속될 수 없습니다. + 2 + + + 초기 상태를 신호 받음으로 설정할지 여부를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true를 사용하고 초기 상태를 신호 없음으로 설정하려면 false를 사용합니다. + + + + 의 슬림 다운 버전을 제공합니다. + + + 신호 없음을 초기 상태로 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true이고 초기 상태를 신호 없음으로 설정하려면 false입니다. + + + 초기 상태를 신호 받음으로 설정할지를 나타내는 부울 값과 지정된 회전 수를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 초기 상태를 신호 받음으로 설정하려면 true이고 초기 상태를 신호 없음으로 설정하려면 false입니다. + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수입니다. + + is less than 0 or greater than the maximum allowed value. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true이고, 관리되지 않는 리소스만 해제하려면 false입니다. + + + 이벤트가 설정되었는지를 가져옵니다. + 이벤트가 설정되었으면 true이고, 그렇지 않으면 false입니다. + + + 스레드가 차단되도록 이벤트 상태를 신호 없음으로 설정합니다. + The object has already been disposed. + + + 이벤트에서 대기 중인 하나 이상의 스레드가 계속 진행되도록 이벤트 상태를 신호 받음으로 설정합니다. + + + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수를 가져옵니다. + 커널 기반의 대기 작업으로 대체하기 전에 수행되는 회전 대기 수를 반환합니다. + + + 현재 이 설정될 때까지 현재 스레드를 차단합니다. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 부호 있는 32비트 정수로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + 을 확인하면서 부호 있는 32비트 정수로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + + 을 확인하면서 현재 이 신호를 받을 때까지 현재 스레드를 차단합니다. + 확인할 입니다. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + + 으로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + + 을 확인하면서 으로 시간 간격을 측정하여 현재 이 설정될 때까지 현재 스레드를 차단합니다. + + 가 설정되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 이 의 내부 개체를 가져옵니다. + 이 에 대한 내부 이벤트 개체입니다. + + + 개체에 대한 액세스를 동기화하는 메커니즘을 제공합니다. + 2 + + + 지정된 개체의 단독 잠금을 가져옵니다. + 모니터 잠금을 가져올 개체입니다. + + 매개 변수가 null인 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정합니다. + 대기할 개체입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다.예외가 발생하지 않는 경우 이 메서드의 출력은 항상 true입니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + + 지정된 개체의 단독 잠금을 해제합니다. + 잠금을 해제할 개체입니다. + + 매개 변수가 null인 경우 + 현재 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 현재 스레드에 지정된 개체에 대한 잠금이 있는지 여부를 확인합니다. + 현재 스레드에 에 대한 잠금이 있으면 true이고, 그렇지 않으면 false입니다. + 테스트할 개체입니다. + + 가 null인 경우 + + + 대기 중인 큐에 포함된 스레드에 잠겨 있는 개체의 상태 변경을 알립니다. + 스레드에서 기다리는 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 대기 중인 모든 스레드에 개체 상태 변경을 알립니다. + 펄스를 보내는 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + + 매개 변수가 null인 경우 + 1 + + + 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + + 지정된 시간(밀리초) 동안 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + 잠금을 기다릴 밀리초 수입니다. + + 매개 변수가 null인 경우 + + 이 음수이고 와 같지 않은 경우 + 1 + + + 지정된 시간(밀리초) 동안 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 기다릴 밀리초 수입니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + 이 음수이고 와 같지 않은 경우 + + + 지정된 시간 동안 지정된 개체의 단독 잠금을 가져오려고 했습니다. + 현재 스레드에서 잠금을 가져오면 true이고, 그렇지 않으면 false입니다. + 잠금을 가져올 개체입니다. + 잠금을 기다리는 시간을 나타내는 입니다.-1밀리초 값은 무한 대기를 지정합니다. + + 매개 변수가 null인 경우 + + 값(밀리초)이 음수이고 (–1밀리초)와 같지 않거나 보다 큰 경우 + 1 + + + 지정된 시간 동안 지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정하려고 시도합니다. + 잠금을 가져올 개체입니다. + 잠금을 대기할 시간입니다.-1밀리초 값은 무한 대기를 지정합니다. + 잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다.입력은 false여야 합니다.잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다.잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다. + + 에 대한 입력이 true인 경우 + + 매개 변수가 null인 경우 + + 값(밀리초)이 음수이고 (–1밀리초)와 같지 않거나 보다 큰 경우 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다. + 지정된 개체 잠금을 호출자가 다시 가져와 호출이 반환되면 true입니다.잠금을 다시 가져오지 않으면 이 메서드는 반환하지 않습니다. + 대기할 개체입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + 1 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다.지정된 시간 제한 간격이 지나면 스레드가 준비된 큐에 들어갑니다. + 지정된 시간이 경과하기 전에 잠금을 다시 가져오면 true이고, 지정된 시간이 경과한 후에 잠금을 다시 가져오면 false입니다.이 메서드는 잠금을 다시 가져올 때까지 반환하지 않습니다. + 대기할 개체입니다. + 스레드가 준비된 큐에 들어가기 전에 대기할 밀리초 수입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + + 매개 변수의 값이 음이고 와 같지 않은 경우 + 1 + + + 개체의 잠금을 해제한 다음 잠금을 다시 가져올 때까지 현재 스레드를 차단합니다.지정된 시간 제한 간격이 지나면 스레드가 준비된 큐에 들어갑니다. + 지정된 시간이 경과하기 전에 잠금을 다시 가져오면 true이고, 지정된 시간이 경과한 후에 잠금을 다시 가져오면 false입니다.이 메서드는 잠금을 다시 가져올 때까지 반환하지 않습니다. + 대기할 개체입니다. + 스레드가 준비된 큐에 들어가기 전에 대기할 시간을 나타내는 입니다. + + 매개 변수가 null인 경우 + 호출한 스레드가 지정된 개체 잠금을 소유하지 않는 경우 + Wait를 호출하는 스레드가 나중에 대기 상태에서 중단된 경우.이는 다른 스레드에서 이 스레드의 메서드를 호출할 때 발생합니다. + + 매개 변수의 값(밀리초)이 음수이고 (-1밀리초)를 나타내지 않거나 보다 큰 경우 + 1 + + + 프로세스 간 동기화에 사용할 수도 있는 동기화 기본 형식입니다. + 1 + + + 기본 속성을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 호출한 스레드에 뮤텍스의 초기 소유권을 부여하면 true이고, 그렇지 않으면 false입니다. + + + 호출 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값과 뮤텍스 이름인 문자열을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 시스템 뮤텍스가 만들어지는 경우 호출한 스레드에 명명된 시스템 뮤텍스의 초기 소유권을 부여하려면 true이고, 그렇지 않으면 false입니다. + + 의 이름입니다.값이 null이면 이(가) 명명되지 않습니다. + 명명된 뮤텍스가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 260 자 보다 깁니다. + + + 호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값, 뮤텍스의 이름인 문자열 및 메서드에서 반환할 때 호출한 스레드에 뮤텍스의 초기 소유권이 부여되었는지를 나타내는 부울 값을 사용하여 클래스의 새 인스턴스를 초기화합니다. + 이 호출의 결과로 명명된 시스템 뮤텍스가 만들어지는 경우 호출한 스레드에 명명된 시스템 뮤텍스의 초기 소유권을 부여하려면 true이고, 그렇지 않으면 false입니다. + + 의 이름입니다.값이 null이면 이(가) 명명되지 않습니다. + 이 메서드가 반환될 때 로컬 뮤텍스가 만들어진 경우(즉, 이(가) null이거나 빈 문자열인 경우)나 지정된 명명된 시스템 뮤텍스가 만들어진 경우에는 true인 부울이 포함되고, 지정된 명명된 시스템 뮤텍스가 이미 있는 경우에는 false이(가) 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + 명명된 뮤텍스가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + 260 자 보다 깁니다. + + + 이미 있는 경우 지정한 명명된 뮤텍스를 엽니다. + 명명된 시스템 뮤텍스를 나타내는 개체입니다. + 열려는 시스템 뮤텍스의 이름입니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + 명명된 뮤텍스가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스가 있지만 사용자에게 이 뮤텍스를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + 1 + + + + + + + 을(를) 한 번 해제합니다. + 호출한 스레드가 뮤텍스를 소유하지 않은 경우 + 1 + + + 지정한 명명된 뮤텍스(이미 존재하는 경우)를 열고 작업이 수행되었는지를 나타내는 값을 반환합니다. + 명명된 뮤텍스를 열었으면 true이고, 그렇지 않으면 false입니다. + 열려는 시스템 뮤텍스의 이름입니다. + 이 메서드가 반환될 때 호출이 성공적으로 실행된 경우 이름이 지정된 뮤텍스를 나타내는 개체를 포함하고 호출에 실패한 경우는 null을(를) 포함해야 합니다.이 매개 변수는 초기화되지 않은 것으로 처리됩니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + Win32 오류가 발생한 경우 + 명명된 뮤텍스가 있지만 사용자에게 이 뮤텍스를 사용하는 데 필요한 보안 액세스 권한이 없는 경우 + + + 여러 스레드에서 읽을 수 있도록 허용하거나 쓰기를 위한 단독 액세스를 허용하여 리소스에 대한 액세스를 관리하는 데 사용되는 잠금을 나타냅니다. + + + 기본 속성 값으로 클래스의 새 인스턴스를 초기화합니다. + + + 잠금 재귀 정책을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 잠금 재귀 정책을 지정하는 열거형 값 중 하나입니다. + + + 읽기 모드로 잠금을 시작한 고유 스레드의 총 개수를 가져옵니다. + 읽기 모드로 잠금을 시작한 고유 스레드의 총 개수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 읽기 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 쓰기 모드로 잠금을 시작하려고 합니다. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 읽기 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 읽기 모드를 종료합니다. + The current thread has not entered the lock in read mode. + + + 업그레이드 가능 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 업그레이드 가능 모드를 종료합니다. + The current thread has not entered the lock in upgradeable mode. + + + 쓰기 모드의 재귀 횟수를 줄이고, 결과 횟수가 0이 되면 쓰기 모드를 종료합니다. + The current thread has not entered the lock in write mode. + + + 현재 스레드에서 읽기 모드로 잠금을 시작했는지를 나타내는 값을 가져옵니다. + 현재 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 스레드에서 업그레이드 가능 모드로 잠금을 시작했는지 여부를 나타내는 값을 가져옵니다. + 현재 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 스레드에서 쓰기 모드로 잠금을 시작했는지를 나타내는 값을 가져옵니다. + 현재 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 2 + + + 현재 개체에 대한 재귀 정책을 나타내는 값을 가져옵니다. + 잠금 재귀 정책을 지정하는 열거형 값 중 하나입니다. + + + 재귀를 확인하기 위해 현재 스레드에서 읽기 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 읽기 모드를 시작하지 않았으면 0이고, 스레드에서 읽기 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 잠금을 n-1회 시작했으면 n입니다. + 2 + + + 재귀를 확인하기 위해 현재 스레드에서 업그레이드 가능 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 업그레이드 가능 모드를 시작하지 않았으면 0이고, 스레드에서 업그레이드 가능 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 업그레이드 가능 모드를 n-1회 시작했으면 n입니다. + 2 + + + 재귀를 확인하기 위해 현재 스레드에서 쓰기 모드로 잠금을 시작한 횟수를 가져옵니다. + 현재 스레드에서 쓰기 모드를 시작하지 않았으면 0이고, 스레드에서 쓰기 모드를 시작했지만 재귀적으로 시작하지 않았으면 1이고, 스레드에서 재귀적으로 쓰기 모드를 n-1회 시작했으면 n입니다. + 2 + + + 제한 시간(정수)을 선택적으로 적용하여 읽기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 읽기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 읽기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 업그레이드 가능 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 업그레이드 가능 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 쓰기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 -1()입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 제한 시간을 선택적으로 적용하여 쓰기 모드로 잠금을 시작하려고 합니다. + 호출하는 스레드에서 쓰기 모드가 시작되었으면 true이고, 그렇지 않으면 false입니다. + 대기할 간격이거나, 무기한 대기하려는 경우 -1밀리초입니다. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 읽기 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 읽기 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 업그레이드 가능 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 업그레이드 가능 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 쓰기 모드로 잠금을 시작하려고 대기 중인 스레드의 총 개수를 가져옵니다. + 쓰기 모드를 시작하려고 대기 중인 스레드의 총 개수입니다. + 2 + + + 리소스 또는 리소스 풀에 동시에 액세스할 수 있는 스레드 수를 제한합니다. + 1 + + + 초기 항목 수 및 최대 동시 항목 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + + 가 보다 큰 경우 + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + + + 초기 항목 수 및 최대 동시 항목 수를 지정하고 선택적으로 시스템 세마포 개체의 이름을 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + 명명된 시스템 세마포 개체의 이름입니다. + + 가 보다 큰 경우또는 260 자 보다 깁니다. + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 세마포를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + + 초기 항목 수 및 최대 동시 항목 수를 지정하고, 선택적으로 시스템 세마포 개체의 이름을 지정하고, 새 시스템 세마포가 만들어졌는지 여부를 나타내는 값을 받을 변수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 동시에 충족될 수 있는 세마포의 초기 요청 수입니다. + 동시에 충족될 수 있는 세마포의 최대 요청 수입니다. + 명명된 시스템 세마포 개체의 이름입니다. + 이 메서드가 반환될 때 로컬 세마포가 만들어진 경우(즉, 이 null이거나 빈 문자열인 경우) 또는 지정한 명명된 시스템 세마포가 만들어진 경우에는 true가 포함되고, 지정한 명명된 시스템 세마포가 이미 있는 경우에는 false가 포함됩니다.이 매개 변수는 초기화되지 않은 상태로 전달됩니다. + + 가 보다 큰 경우 또는 260 자 보다 깁니다. + + 1 보다 작으면입니다.또는가 0보다 작은 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 존재하고 액세스 제어 보안이 있지만 사용자에게 이 없는 경우 + 명명된 세마포를 만들 수 없는 경우. 다른 형식의 대기 핸들이 같은 이름을 가지고 있기 때문인 것 같습니다. + + + 이미 있는 경우 지정한 명명된 세마포를 엽니다. + 명명된 시스템 세마포를 나타내는 개체입니다. + 열려는 시스템 세마포의 이름입니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + 명명된 세마포가 없는 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 있지만 사용자에게 이 세마포를 사용하는 데 필요한 보안 액세스가 없는 경우 + 1 + + + + + + 세마포를 종료하고 이전 카운트를 반환합니다. + + 메서드가 호출되기 전의 세마포 카운트입니다. + 세마포 카운트가 이미 최대값인 경우 + 명명된 세마포에서 Win32 오류가 발생한 경우 + 현재 세마포가 명명된 시스템 세마포를 나타내지만 사용자에게 가 없는 경우또는현재 세마포가 명명된 시스템 세마포를 나타내지만 세마포가 를 사용하여 열리지 않은 경우 + 1 + + + 지정된 횟수만큼 세마포를 종료하고 이전 카운트를 반환합니다. + + 메서드가 호출되기 전의 세마포 카운트입니다. + 세마포를 종료할 횟수입니다. + + 1 보다 작으면입니다. + 세마포 카운트가 이미 최대값인 경우 + 명명된 세마포에서 Win32 오류가 발생한 경우 + 현재 세마포가 명명된 시스템 세마포를 나타내지만 사용자에게 권한이 없는 경우또는현재 세마포가 명명된 시스템 세마포를 나타내지만 세마포가 권한을 사용하여 열리지 않은 경우 + 1 + + + 지정한 명명된 세마포(이미 존재하는 경우)를 열고 작업이 성공했는지를 나타내는 값을 반환합니다. + 명명된 세마포를 열었으면 true이고, 그 열지 않았으면 false입니다. + 열려는 시스템 세마포의 이름입니다. + 이 메서드가 반환될 때 호출에 성공한 경우에는 명명된 세마포를 나타내는 개체를 포함하고 호출에 실패한 경우에는 null을 포함합니다.이 매개 변수는 초기화되지 않은 것으로 처리됩니다. + + 이 빈 문자열인 경우또는 260 자 보다 깁니다. + + 가 null인 경우 + Win32 오류가 발생한 경우 + 명명된 세마포가 있지만 사용자에게 이 세마포를 사용하는 데 필요한 보안 액세스가 없는 경우 + + + 카운트가 이미 최대값에 도달한 세마포에서 메서드를 호출하면 throw되는 예외입니다. + 2 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 리소스 또는 리소스 풀에 동시에 액세스할 수 있는 스레드 수를 제한하는 대신 사용할 수 있는 간단한 클래스를 나타냅니다. + + + 동시에 부여할 수 있는 초기 요청 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + + 가 0보다 작은 경우 + + + 동시에 부여할 수 있는 초기 및 최대 요청 수를 지정하여 클래스의 새 인스턴스를 초기화합니다. + 세마포에 동시에 부여할 수 있는 초기 요청 수입니다. + 세마포에 동시에 부여할 수 있는 최대 요청 수입니다. + + 가 0보다 작거나 가 보다 크거나 가 0보다 작거나 같은 경우. + + + 세마포에서 대기하는 데 사용할 수 있는 을(를) 반환합니다. + 세마포에서 대기하는 데 사용할 수 있는 입니다. + + 가 삭제된 경우 + + + + 개체에 들어갈 수 있는 남아 있는 스레드의 수를 가져옵니다. + 세마포에 들어갈 수 있는 남아 있는 스레드의 수입니다. + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + + 에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다. + 관리되는 리소스와 관리되지 않는 리소스를 모두 해제하려면 true로 설정하고, 관리되지 않는 리소스만 해제하려면 false로 설정합니다. + + + + 개체를 한 번 해제합니다. + + 의 이전 횟수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 이미 최대 크기에 도달했습니다. + + + + 개체를 지정된 횟수만큼 해제합니다. + + 의 이전 횟수입니다. + 세마포를 종료할 횟수입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 1 보다 작으면입니다. + + 이 이미 최대 크기에 도달했습니다. + + + 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 인스턴스가 이미 삭제된 경우 + + + 제한 시간을 지정하는 부호 있는 32비트 정수를 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을(를) 확인하면서 제한 시간을 지정하는 부호 있는 32비트 정수를 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 취소되었습니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + 인스턴스가 삭제 또는 만든 가 삭제 되었습니다. + + + + 을(를) 확인하면서 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 확인할 토큰입니다. + + 이 취소되었습니다. + 현재 인스턴스가 이미 삭제된 경우또는 만든 이미 삭제 되었습니다. + + + + (으)로 제한 시간을 지정하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + semaphoreSlim 인스턴스가 삭제되었습니다 + + + + 을(를) 확인하면서 제한 시간을 지정하는 을(를) 사용하여 현재 스레드가 에 진입할 수 있을 때까지 스레드를 차단합니다. + 현재 스레드가 에 진입했으면 true이고, 그렇지 않으면 false입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 입니다. + + 이 취소되었습니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + semaphoreSlim 인스턴스가 삭제되었습니다을 만든 가 이미 삭제되었습니다. + + + + (으)로 전환될 때까지 비동기적으로 기다립니다. + 세마포가 입력되었을 때 완료될 작업입니다. + + + 32비트 부호 있는 정수를 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + + 을(를) 관찰하는 동안 32비트 부호 있는 정수를 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 확인할 입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + 현재 인스턴스가 이미 삭제된 경우 + + 이 취소되었습니다. + + + + 을(를) 관찰하는 동안 (으)로 전환될 때까지 비동기적으로 기다립니다. + 세마포가 입력되었을 때 완료될 작업입니다. + 확인할 토큰입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 취소되었습니다. + + + + 을(를) 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 현재 인스턴스가 이미 삭제된 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 또는 제한 시간이 보다 큰 경우 + + + + 을 관찰하는 동안 을(를) 사용하여 시간 간격을 측정하여 (으)로 전환될 때까지 비동기적으로 기다립니다. + 현재 스레드가 성공적으로 에 들어온 경우 true의 결과로 완료되는 작업이고, 그렇지 않으면 false의 결과로 완료되는 작업입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 확인할 토큰입니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우또는제한 시간이 보다 큰 경우 + + 이 취소되었습니다. + + + 메시지가 동기화 컨텍스트로 디스패치될 때 호출할 메서드를 나타냅니다. + 대리자에 전달된 개체입니다. + 2 + + + 잠금을 얻으려는 스레드가 잠금을 사용할 수 있을 때까지 루프에서 반복적으로 확인하면서 대기하는 기본적인 상호 배타 잠금을 제공합니다. + + + 디버깅을 향상시키기 위해 스레드 ID를 추적하는 옵션을 사용하여 구조체의 새 인스턴스를 초기화합니다. + 디버깅 용도로 스레드 ID를 캡처하고 사용할지 여부입니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으며 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 인수는 Enter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 잠금을 해제합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이 잠금의 소유자가 아닙니다. + + + 잠금을 해제합니다. + 종료 작업을 다른 스레드에 즉시 게시하기 위해 메모리 펜스를 실행할지 여부를 나타내는 부울 값입니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이 잠금의 소유자가 아닙니다. + + + 스레드에서 현재 잠금을 보유하고 있는지 여부를 가져옵니다. + 스레드에서 현재 잠금을 보유하고 있으면 true이고, 그렇지 않으면 false입니다. + + + 현재 스레드에서 잠금을 보유하고 있는지 여부를 가져옵니다. + 현재 스레드에서 잠금을 보유하고 있으면 true이고, 그렇지 않으면 false입니다. + 스레드 소유권 추적을 사용할 수 없습니다. + + + 이 인스턴스에 대해 스레드 소유권 추적이 사용되는지 여부를 가져옵니다. + 이 인스턴스에 대해 스레드 소유권 추적이 사용되면 true이고, 그렇지 않으면 false입니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 메서드 호출에서 예외가 발생하는 경우에도 안정적인 방식으로 잠금을 얻으려고 시도합니다. 잠금을 얻었는지 확인하기 위해 을 안정적으로 검사할 수 있습니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 입니다. + 잠금을 얻었으면 true이고, 그렇지 않으면 false입니다.이 메서드를 호출하기 전에 을 false로 초기화해야 합니다. + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 밀리초보다 큰 경우. + + 인수는 TryEnter를 호출하기 전에 false로 초기화해야 합니다. + 스레드 소유권 추적 기능을 사용할 수 있으며 현재 스레드가 이미 이 잠금을 획득했습니다. + + + 회전 기반 대기를 지원합니다. + + + 이 인스턴스에서 가 호출된 횟수를 가져옵니다. + 이 인스턴스에서 가 호출된 횟수를 나타내는 정수를 반환합니다. + + + 다음 호출이 프로세서를 생성하여 강제 컨텍스트 전환을 트리거할지 여부를 가져옵니다. + 다음 호출이 프로세서를 생성하여 강제 컨텍스트 전환을 트리거할지 여부입니다. + + + 회전 수를 다시 설정합니다. + + + 단일 회전을 수행합니다. + + + 지정된 조건이 충족될 때까지 회전합니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + + 인수가 null인 경우 + + + 지정된 조건이 충족되거나 지정된 제한 시간이 만료될 때까지 회전합니다. + 제한 시간 내에 지정된 조건이 충족되면 true이고, 그렇지 않으면 false입니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + 대기할 시간(밀리초)이거나, 무기한 대기할 경우 (-1)입니다. + + 인수가 null인 경우 + + 이 무기한 시간 제한을 나타내는 -1 이외의 음수인 경우 + + + 지정된 조건이 충족되거나 지정된 제한 시간이 만료될 때까지 회전합니다. + 제한 시간 내에 지정된 조건이 충족되면 true이고, 그렇지 않으면 false입니다. + true를 반환할 때까지 계속 실행되는 대리자입니다. + 대기할 시간(밀리초)을 나타내는 이거나, 무한 대기하도록 -1밀리초를 나타내는 TimeSpan입니다. + + 인수가 null인 경우 + + 이 무기한 시간 제한을 나타내는 -1밀리초 이외의 음수이거나 시간 제한이 보다 큰 경우. + + + 다양한 동기화 모델에서 동기화 컨텍스트를 전파하기 위한 기본 기능을 제공합니다. + 2 + + + + 클래스의 새 인스턴스를 만듭니다. + + + 파생 클래스에서 재정의된 경우 동기화 컨텍스트의 복사본을 만듭니다. + 새 개체입니다. + 2 + + + 현재 스레드의 동기화 컨텍스트를 가져옵니다. + 현재 동기화 컨텍스트를 나타내는 개체입니다. + 1 + + + 파생 클래스에서 재정의되면 작업이 완료되었음을 알리는 메시지에 응답합니다. + + + 파생 클래스에서 재정의되면 작업이 시작되었음을 알리는 메시지에 응답합니다. + + + 파생 클래스에서 재정의될 때 비동기 메시지를 동기화 컨텍스트로 디스패치합니다. + 호출할 대리자입니다. + 대리자에 전달된 개체입니다. + 2 + + + 파생 클래스에서 재정의될 때 동기 메시지를 동기화 컨텍스트로 디스패치합니다. + 호출할 대리자입니다. + 대리자에 전달된 개체입니다. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 현재 동기화 컨텍스트를 설정합니다. + 설정할 개체입니다. + 1 + + + + + + 메서드가 지정된 Monitor에 대해 잠금을 소유하도록 호출자에게 요구하지만 해당 잠금을 소유하지 않는 호출자가 해당 메서드를 호출할 때 throw되는 예외입니다. + 2 + + + 기본 속성을 사용하여 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + 데이터의 스레드 로컬 저장소를 제공합니다. + 스레드별로 저장되는 데이터의 형식을 지정합니다. + + + + 인스턴스를 초기화합니다. + + + + 인스턴스를 초기화합니다. + 인스턴스에 설정된 모든 값을 추적하고 해당 값을 속성을 통해 노출할지 여부 + + + 지정된 함수를 사용하여 의 인스턴스를 초기화합니다. + + 를 이전에 초기화하지 않고 검색하려고 하는 경우 lazily-initialized 값을 생성하기 위해 호출되는 입니다. + + 는 null 참조(Visual Basic의 경우 Nothing)입니다. + + + 지정된 함수를 사용하여 의 인스턴스를 초기화합니다. + + 를 이전에 초기화하지 않고 검색하려고 하는 경우 lazily-initialized 값을 생성하기 위해 호출되는 입니다. + 인스턴스에 설정된 모든 값을 추적하고 해당 값을 속성을 통해 노출할지 여부 + + 이 null 참조(Visual Basic의 경우 Nothing)인 경우 + + + + 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다. + + + 이 인스턴스에서 사용하는 리소스를 해제합니다. + + 호출로 인해 이 메서드가 호출되는지 여부를 나타내는 부울 값입니다. + + + 이 인스턴스에서 사용하는 리소스를 해제합니다. + + + + 가 현재 스레드에서 초기화되었는지 여부를 가져옵니다. + 현재 스레드에서 가 초기화되었으면 true이고, 그렇지 않으면 false입니다. + + 인스턴스가 삭제된 경우 + + + 현재 스레드에 대한 이 인스턴스의 문자열 표현을 만들고 반환합니다. + + 에서 을 호출한 결과입니다. + + 인스턴스가 삭제된 경우 + 현재 스레드의 는 null 참조입니다(Visual Basic에서는 Nothing). + 초기화 함수는 를 재귀적으로 참조하려고 했습니다. + 기본 생성자가 제공되지 않으며 값 팩터리가 제공되지 않습니다. + + + 현재 인스턴스에 대한 이 인스턴스의 값을 가져오거나 설정합니다. + 이 ThreadLocal이 초기화를 담당하는 개체의 인스턴스를 반환합니다. + + 인스턴스가 삭제된 경우 + 초기화 함수는 를 재귀적으로 참조하려고 했습니다. + 기본 생성자가 제공되지 않으며 값 팩터리가 제공되지 않습니다. + + + 이 인스턴스에 액세스한 모든 스레드가 현재 저장한 모든 값의 목록을 가져옵니다. + 이 인스턴스에 액세스한 모든 스레드가 현재 저장한 모든 값의 목록입니다. + + 인스턴스가 삭제된 경우 + + + 휘발성 메모리 작업을 수행하기 위한 메서드가 포함되어 있습니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드의 값을 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 값입니다.이 값은 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + + + 지정된 필드에서 개체 참조를 읽습니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 뒤에 나타나는 경우 프로세서가 이 메서드 앞으로 읽기 또는 쓰기를 이동할 수 없습니다. + 읽은 에 대한 참조입니다.이 참조는 프로세서 수나 프로세서 캐시의 상태에 관계없이 컴퓨터의 어떠한 프로세서에서든 마지막으로 쓴 것입니다. + 읽을 필드입니다. + 읽을 필드의 형식입니다.이 형식은 값 형식이 아니라 참조 형식이어야 합니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 메모리 작업이 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 메모리 작업을 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 값을 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 값을 쓴 필드입니다. + 쓸 값입니다.컴퓨터의 모든 프로세서에서 값을 볼 수 있도록 값을 즉시 씁니다. + + + 지정된 필드에 지정된 개체 참조를 씁니다.필요한 시스템에서는 프로세서가 메모리 작업을 다시 정렬하는 것을 막는 메모리 차단을 다음과 같이 삽입합니다. 코드에서 읽기 또는 쓰기가 이 메서드 앞에 나타나는 경우 프로세서가 이 메서드 뒤로 읽기 또는 쓰기를 이동할 수 없습니다. + 개체 참조를 쓴 필드입니다. + 쓸 개체 참조입니다.컴퓨터의 모든 프로세서에서 참조를 볼 수 있도록 참조를 즉시 씁니다. + 쓸 필드의 형식입니다.이 형식은 값 형식이 아니라 참조 형식이어야 합니다. + + + 존재하지 않는 시스템 뮤텍스 또는 세마포를 열려고 시도할 때 throw되는 예외입니다. + 2 + + + 기본값으로 클래스의 새 인스턴스를 초기화합니다. + + + 지정된 오류 메시지를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + + + 지정된 오류 메시지와 해당 예외의 근본 원인인 내부 예외에 대한 참조를 사용하여 클래스의 새 인스턴스를 초기화합니다. + 예외에 대한 이유를 설명하는 오류 메시지입니다. + 현재 예외의 원인이 되는 예외입니다. 매개 변수가 null이 아니면 현재 예외는 내부 예외를 처리하는 catch 블록에서 발생합니다. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/ru/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/ru/System.Threading.xml new file mode 100644 index 000000000..6ca30336b --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/ru/System.Threading.xml @@ -0,0 +1,1761 @@ + + + + System.Threading + + + + Исключение вызывается, когда некоторый поток получает объект , брошенный другим потоком путем выхода без высвобождения. + 1 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса , используя конкретиый индекс брошенного мьютекса, (если применимо), а также объект , представляющий мьютекс. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причины исключения. + + + Выполняет инициализацию нового экземпляра класса с указанным сообщением об ошибке и внутренним исключением. + Сообщение об ошибке с объяснением причины исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение вызывается в блоке catch, обрабатывающем внутреннее исключение. + + + Инициализирует новый экземпляр класса , используя указанное сообщения об ошибке, внутреннее исключение, индекс брошенного мьютекса (если применимо), а также объект , представляющего мьютекс. + Сообщение об ошибке с объяснением причины исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение вызывается в блоке catch, обрабатывающем внутреннее исключение. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Инициализирует новый экземпляр класса указанным сообщением об ошибке, индексом брошенного мьютекса (если применимо), а также брошенным мьютексом. + Сообщение об ошибке с объяснением причины исключения. + Индекс брошенного мьютекса в массиве дескрипторов ожидания, если выдается исключение для метода , или –1, если исключение выдается для методов или . + Объект , представляющий брошенный мьютекс. + + + Получает брошенный мьютекс, вызвавший исключение (если он известен). + Объект , представляющий брошенный мьютекс, или null, если брошенный мьютекс не может быть идентифицирован. + 1 + + + Получает индекс брошенного мьютекса, вызвавшего исключение (если он известен). + Индекс в массиве дескрипторов ожидания, передаваемый в метод , объекта , представляющего брошенный мьютекс, или же -1, если индекс брошенного мьютекса невозможно определить. + 1 + + + Представляет внешние данные, локальные для данного асинхронного потока управления, такие как асинхронный метод. + Тип внешних данных. + + + Создает экземпляр экземпляра , который не получает уведомления об изменениях. + + + Создает экземпляр локального экземпляра , который получает уведомления об изменениях. + Делегат, который вызывается при каждом изменении текущего значения в любом потоке. + + + Получает или задает значение внешних данных. + Значение внешних данных. + + + Класс, предоставляющий сведения об изменениях данных экземплярам , которые зарегистрированы для получения уведомлений об изменениях. + Тип данных. + + + Получает текущее значение данных. + Текущее значение данных. + + + Получает предыдущее значение данных. + Предыдущее значение данных. + + + Возвращает значение, указывающее, изменяется ли значение из-за изменения контекста выполнения. + Значение true, если значение изменено из-за изменения контекста выполнения; в противном случае — значение false. + + + Уведомляет ожидающий поток о том, что произошло событие.Этот класс не наследуется. + 2 + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение. + + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + + + Позволяет нескольким задачам параллельно работать с алгоритмом, используя несколько фаз. + + + Инициализирует новый экземпляр класса . + Количество участвующих потоков. + + меньше 0 или больше 32,767. + + + Инициализирует новый экземпляр класса . + Количество участвующих потоков. + + для исполнения после каждой фазы. Значение null (Nothing in Visual Basic) может быть передано, чтобы указать, что действия не предпринимаются. + + меньше 0 или больше 32,767. + + + Уведомляет о добавлении дополнительного участника. + Номер фазы барьера, в которой сначала участвуют новые участники. + Текущий экземпляр уже был удален. + Добавление участника приведет к превышению 32 767 счетчиком участников барьера.– или –Метод был вызван из действия после этапа. + + + Уведомляет барьер о добавлении дополнительных участников. + Номер фазы барьера, в которой сначала участвуют новые участники. + Число дополнительных участников, которых необходимо добавить в барьер. + Текущий экземпляр уже был удален. + Значение параметра меньше 0.– или –Добавление участников приведет к превышению 32 767 счетчиком участников барьера. + Метод был вызван из действия после этапа. + + + Получает номер текущей фазы барьера. + Возвращает номер текущего этапа барьера. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + Метод был вызван из действия после этапа. + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает общее количество участников в барьере. + Возвращает общее количество участников в барьере. + + + Получает количество участников в барьере, которые еще не создали сигнал в текущей фазе. + Возвращает количество участников в барьере, которые еще не создали сигнал на текущем этапе. + + + Уведомляет о удалении одного участника. + Текущий экземпляр уже был удален. + Барьер уже содержит 0 участников.– или –Метод был вызван из действия после этапа. + + + Уведомляет барьер об удалении нескольких участников. + Число дополнительных участников, которых необходимо удалить из барьера. + Текущий экземпляр уже был удален. + Значение параметра меньше 0. + Барьер уже содержит 0 участников.– или –Метод был вызван из действия после этапа. – или –текущее количество участников меньше указанного participantCount + Общее число участников меньше указанного + + + Сообщает, что участник достиг барьера и ожидает достижения барьера другими участниками. + Текущий экземпляр уже был удален. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + Если создается исключение из действия следующего этапа барьера после того, как все участвующие потоки вызвали SignalAndWait, исключение будет вставлено в BarrierPostPhaseException и создано для всех участвующих потоков. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя 32-разрядное знаковое целое число для измерения времени ожидания. + Значение true, если все участники достигли барьера за указанное время; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + Если создается исключение из действия следующего этапа барьера после того, как все участвующие потоки вызвали SignalAndWait, исключение будет вставлено в BarrierPostPhaseException и создано для всех участвующих потоков. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя 32-разрядное знаковое целое число для измерения времени ожидания. Кроме того, метод контролирует токен отмены. + Значение true, если все участники достигли барьера за указанное время; в противном случае — значение false + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками. Кроме того, метод контролирует токен отмены. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя объект для измерения интервала времени. + Значение true, если все остальные участники достигли барьера; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + + является отрицательным числом, отличным от значения -1 миллисекунды, которое представляет неограниченное время ожидания, или превышает 32767. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Сообщает, что участник достиг барьера и ожидает достижения барьера всеми другими участниками, используя объект для измерения интервала времени. Кроме того, метод контролирует токен отмены. + Значение true, если все остальные участники достигли барьера; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. + + является отрицательным числом, отличным от значения -1, которое представляет неограниченное время ожидания. + Метод был вызван из действия после этапа, барьер в настоящий момент имеет 0 участников или барьер получает сигналы от большего числа потоков, чем зарегистрировано участников. + + + Исключение, которое возникает при сбое действия барьера , выполняемого в конце фазы + + + Инициализирует новый экземпляр класса системным сообщением, содержащим описание ошибки. + + + Инициализирует новый экземпляр класса с указанным внутренним исключением. + Исключение, которое вызвало текущее исключение. + + + Инициализирует новый экземпляр класса с использованием заданного сообщения, содержащего описание ошибки. + Сообщение с описанием исключения.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение с описанием исключения.Вызывающий оператор этого конструктора необходим, чтобы убедиться, локализована ли данная строка для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Представляет метод, вызываемый в новом контексте. + Объект, содержащий информацию, используемую всякий раз методом обратного вызова при каждом выполнении. + 1 + + + Представляет примитив синхронизации, на который отправляется сигнал при достижении его подсчетом нуля. + + + Инициализирует новый экземпляр класса указанным количеством. + Количество сигналов, первоначально необходимое для задания объекта . + Значение параметра меньше 0. + + + Увеличивает текущий подсчет на один. + Текущий экземпляр уже был удален. + Текущий экземпляр уже задан.– или –Значение параметра больше или равно значению свойства . + + + Увеличивает текущее количество в объекте на указанное значение. + Значение, на которое нужно увеличить . + Текущий экземпляр уже был удален. + Значение меньше или равно 0. + Текущий экземпляр уже задан.– или – равно или больше после увеличения счета параметром + + + Получает количество сигналов, оставшееся до установки события. + Количество сигналов, оставшееся до установки события. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает количество сигналов, изначально нужное для установки события. + Количество сигналов, изначально нужное для установки события. + + + Определяет, установлено ли событие. + Значение true, если событие установлено; в противном случае — значение false. + + + Сбрасывает свойство на значение свойства . + Текущий экземпляр уже был удален. + + + Присваивает свойству заданное значение. + Количество сигналов, необходимое для установки объекта . + Текущий экземпляр уже был удален. + Значение параметра меньше 0. + + + Регистрирует сигнал с событием , уменьшая значение свойства . + Значение true, если после сигнала подсчет стал равен нулю и было создано событие; в противном случае — значение false. + Текущий экземпляр уже был удален. + Текущий экземпляр уже задан. + + + Регистрирует несколько сигналов с объектом , уменьшая значение свойства на указанное число. + Значение true, если после сигналов подсчет стал равен нулю и было создано событие; в противном случае — значение false. + Количество сигналов, которое необходимо зарегистрировать. + Текущий экземпляр уже был удален. + Значение параметра меньше 1. + Текущий экземпляр уже задан. - или- Или значение больше . + + + Попытка увеличить на единицу. + Значение true, если увеличение выполнено успешно; в противном случае — значение false.Если значение свойства уже равно нулю, метод возвращает значение false. + Текущий экземпляр уже был удален. + + равно . + + + Пытается увеличить на указанное значение. + Значение true, если увеличение выполнено успешно; в противном случае — значение false.Если значение свойства уже равно нулю, возвращается значение false. + Значение, на которое нужно увеличить . + Текущий экземпляр уже был удален. + Значение меньше или равно 0. + Текущий экземпляр уже задан.– или –Значение свойства + больше или равно значению свойства . + + + Блокирует текущий поток до установки . + Текущий экземпляр уже был удален. + + + Блокирует текущий поток до тех пор, пока не установлен объект , используя 32-разрядное знаковое целое число для измерения времени ожидания. + Значение true, если установлено событие ; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток до тех пор, пока не будет установлен объект , используя 32-разрядное знаковое целое число для измерения времени ожидания. Кроме того, метод контролирует токен . + Значение true, если установлено событие ; в противном случае — значение false. + Время ожидания в миллисекундах или значение (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток, пока не будет установлено , в то же время контролируя . + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + + + Блокирует текущий поток до тех пор, пока не будет установлен объект , используя значение для измерения времени ожидания. + Значение true, если установлено событие ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Блокирует текущий поток, пока не будет установлен объект , используя значение для измерения времени ожидания. Кроме того, метод контролирует токен . + Значение true, если установлено событие ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален. — или — , создавший , был удален. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Получает дескриптор , используемый для ожидания установки события. + Дескриптор , используемый для ожидания установки события. + Текущий экземпляр уже был удален. + + + Указывает, сбрасывается ли автоматически или вручную после получения сигнала. + 2 + + + При получении сигнала сбрасывается автоматически после освобождения одиночного потока.При отсутствии ожидающих потоков остается сигнальным до тех пор, пока поток не блокируется и не сбрасывается после освобождения потока. + + + При получении сигнала, высвобождает все ожидающие потоки и остается сигнальным до тех пор, пока не сбрасывается вручную. + + + Представляет синхронизированное событие потока. + 2 + + + Выполняет инициализацию нового экземпляра класса , определяя, получает ли сигнал, ожидающий дескриптор, и производится ли сброс автоматически или вручную. + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + + + Выполняет инициализацию нового экземпляра класса , определяющего получает ли сигнал дескриптор ожидания, если он был создан в результате данного вызова, сбрасывается ли он автоматически или вручную, а также имя системного события синхронизации. + true, чтобы задать сигнальное начальное состояние, если создано названное событие в результате этого вызова; false, чтобы задать несигнальное начальное состояние. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + Имя общесистемного события синхронизации. + Произошла ошибка Win32. + Именованное событие существует, имеет настройки управления доступом, а пользователь не имеет прав . + Именованное событие не может быть создано, видимо потому что дескриптор ожидания другого типа имеет то же имя. + Длина параметра превышает 260 символов. + + + Выполняет инициализацию нового экземпляра класса , определяющего, является ли дескриптор ожидания изначально сигнальным, если он был создан в результате данного вызова, происходит ли сброс автоматически или вручную, имя системного события синхронизации и логическую переменную, значение которой показывает, было ли создано системное именованное событие. + true, чтобы задать сигнальное начальное состояние, если создано названное событие в результате этого вызова; false, чтобы задать несигнальное начальное состояние. + Одно из значений определяет, сбрасывается ли событие автоматически или вручную. + Имя общесистемного события синхронизации. + Когда данный метод возвращает значение, он содержит true, если было создано локальное событие (то есть, если имеет значение null или пустую строку) или было создано системное событие с заданным именем; либо значение false, если указанное именованное событие уже существовало.Этот параметр передается без инициализации. + Произошла ошибка Win32. + Именованное событие существует, имеет настройки управления доступом, а пользователь не имеет прав . + Именованное событие не может быть создано, видимо потому что дескриптор ожидания другого типа имеет то же имя. + Длина параметра превышает 260 символов. + + + Открывает указанное именованное событие синхронизации, если оно уже существует. + Объект, представляющий именованное системное событие. + Имя системного события синхронизации для открытия. + Параметр содержит пустую строку. -или-Длина параметра превышает 260 символов. + Параметр имеет значение null. + Именованное системное событие не существует. + Произошла ошибка Win32. + Именованное событие существует, но у пользователя нет необходимых для его использования прав доступа. + 1 + + + + + + Задает несигнальное состояние события, вызывая блокирование потоков. + true, если операция прошла успешно; в противном случае — false. + Для данного объекта ранее вызывался метод . + 2 + + + Задает сигнальное состояние события, позволяя одному или нескольким ожидающим потокам продолжить. + true, если операция прошла успешно; в противном случае — false. + Для данного объекта ранее вызывался метод . + 2 + + + Открывает указанное именованное событие синхронизации, если оно уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованное событие синхронизации было успешно открыто; в противном случае — значение false. + Имя системного события синхронизации для открытия. + Когда выполнение этого метода завершается, содержит объект , представляющий именованное событие синхронизации, если вызов завершился успешно, или значение null, если вызов завершился ошибкой.Этот параметр обрабатывается как неинициализированный. + Параметр содержит пустую строку.-или-Длина параметра превышает 260 символов. + Параметр имеет значение null. + Произошла ошибка Win32. + Именованное событие существует, но у пользователя нет требуемых прав доступа. + + + Управляет контекстом выполнения текущего потока.Этот класс не наследуется. + 2 + + + Перехватывает контекст выполнения из текущего потока. + Объект , представляющий контекст выполнения хоста для текущего потока. + 1 + + + Выполняет метод в указанном контексте выполнения в текущем потоке. + Задаваемый . + Делегат , представляющий выполняемый метод в предоставленном контексте выполнения. + Данный объект передается в метод обратного вызова. + Параметр имеет значение null.– или – не был получен во время операции отслеживания. – или – уже использовался в качестве аргумента в вызове . + 1 + + + + + + Предоставляет атомарные операции для переменных, используемых совместно несколькими потоками. + 2 + + + Добавляет два 32-разрядных целых числа и заменяет первое число на сумму в виде атомарной операции. + Новое значение сохраняется в . + Переменная, содержащая первое добавляемое значение.Сумма двух значений сохраняется в . + Значение, добавляемое к целому в . + The address of is a null pointer. + 1 + + + Добавляет два 64-разрядных целых числа и заменяет первое число на сумму в виде атомарной операции. + Новое значение сохраняется в . + Переменная, содержащая первое добавляемое значение.Сумма двух значений сохраняется в . + Значение, добавляемое к целому в . + The address of is a null pointer. + 1 + + + Сравнивает два числа с плавающей запятой двойной точности на равенство и, если они равны, заменяет первое значение. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два 32-разрядных целых числа со знаком на равенство и, если они равны, заменяет первое. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два 64-разрядных целых числа со знаком на равенство и, если они равны, заменяет первое. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два зависящих от платформы обработчика или указателя на равенство и, если они равны, заменяет первое из значений. + Исходное значение в . + Целевое значение , которое будет сравниваться со значением параметра и, возможно, будет заменено . + Значение , которое заменит целевое значение, если результатом сравнения будет равенство. + Значение , которое сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два объекта на равенство ссылок и, если они равны, заменяет первый объект. + Исходное значение в . + Целевой объект, который будет сравниваться со значением параметра и, возможно, будет заменен. + Объект, который заменит целевой объект, если результатом сравнения будет равенство. + Объект, который сравнивается с объектом в . + The address of is a null pointer. + 1 + + + Сравнивает два числа с плавающей запятой с обычной точностью на равенство и, если они равны, заменяет первое значение. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено. + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + The address of is a null pointer. + 1 + + + Сравнивает два экземпляра указанного ссылочного типа на равенство и, если это так, заменяет первый из них. + Исходное значение в . + Целевое значение, которое будет сравниваться со значением параметра и, возможно, будет заменено.Это ссылочный параметр (ref в C#, ByRef в Visual Basic). + Значение, которое заменит целевое значение, если результатом сравнения будет равенство. + Значение сравнивается со значением . + Тип, используемый для , и .Этот тип должен быть ссылочным типом. + The address of is a null pointer. + + + Уменьшает значение заданной переменной и сохраняет результат в виде атомарной операции. + Уменьшаемое значение. + Переменная, у которой уменьшается значение. + The address of is a null pointer. + 1 + + + Уменьшает значение заданной переменной и сохраняет результат в виде атомарной операции. + Уменьшаемое значение. + Переменная, у которой уменьшается значение. + The address of is a null pointer. + 1 + + + Задает число с плавающей запятой с двойной точностью указанным значением в виде атомарной операции и возвращает исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Присваивает 32-разрядному целому числу со знаком заданное значение и возвращает исходное значение в виде атомарной операции. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Присваивает 64-разрядному целому числу со знаком заданное значение и возвращает исходное значение в виде атомарной операции. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает указатель или обработчик, зависящий от платформы в виде атомарной операции, и возвращает ссылку на исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает объект указанным значением в виде атомарной операции и возвращает ссылку на исходный объект. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает число с плавающей запятой с одинарной точностью указанным значением в виде атомарной операции и возвращает исходное значение. + Исходное значение параметра . + Переменная, которая задается указанным значением. + Значение, в которое задан параметр . + The address of is a null pointer. + 1 + + + Задает определенное значение для переменной указанного типа и возвращает исходное значение (атомарная операция). + Исходное значение параметра . + Переменная, которая задается указанным значением.Это ссылочный параметр (ref в C#, ByRef в Visual Basic). + Значение, в которое задан параметр . + Тип, используемый для и .Этот тип должен быть ссылочным типом. + The address of is a null pointer. + + + Увеличивает значение заданной переменной и сохраняет результат в виде атомарной операции. + Увеличиваемое значение. + Переменная, у которой увеличивается значение. + The address of is a null pointer. + 1 + + + Увеличивает значение заданной переменной и сохраняет результат в виде атомарной операции. + Увеличиваемое значение. + Переменная, у которой увеличивается значение. + The address of is a null pointer. + 1 + + + Синхронизирует доступ к памяти следующим образом: процессор, выполняющий текущий поток, не способен упорядочить инструкции так, чтобы обращения к памяти до вызова метода выполнялись после обращений к памяти, следующих за вызовом метода . + + + Возвращает 64-разрядное значение, загруженное в виде атомарной операции. + Загруженное значение. + Загружаемое 64-разрядное значение. + 1 + + + Обеспечивает процедуры неактивной инициализации. + + + Инициализирует целевой ссылочный тип его конструктором типа по умолчанию, если он еще не инициализирован. + Инициализируемая ссылка типа . + Ссылка типа , которую необходимо инициализировать, если она еще не инициализирована. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип или тип значения его конструктором по умолчанию, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка или значение типа , которое необходимо инициализировать, если оно еще не инициализировано. + Ссылка на логическое значение, определяющее, инициализирована ли цель. + Ссылка на объект, используемый как взаимоисключающая блокировка для инициализации параметра .Если равно null, то нового объект будет создан экземпляр. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип или тип значения с использованием указанной функцией, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка или значение типа , которое необходимо инициализировать, если оно еще не инициализировано. + Ссылка на логическое значение, определяющее, инициализирована ли цель. + Ссылка на объект, используемый как взаимоисключающая блокировка для инициализации параметра .Если равно null, то нового объект будет создан экземпляр. + Функция, которая вызывается для инициализации ссылки или значения. + Тип инициализируемой ссылки. + Разрешения на доступ к конструктору типа отсутствовали. + Тип не имеет конструктора по умолчанию. + + + Инициализирует целевой ссылочный тип с использованием указанной функцией, если он еще не инициализирован. + Инициализированное значение типа . + Ссылка типа , которую необходимо инициализировать, если она еще не инициализирована. + Функция, которая вызывается для инициализации ссылки. + Ссылочный тип инициализируемой ссылки. + Тип не имеет конструктора по умолчанию. + + вернул значение NULL (Nothing в Visual Basic). + + + Исключение генерируется, когда рекурсивная запись блокировки не совпадает с рекурсивной политикой блокировки. + 2 + + + Инициализирует новый экземпляр класса системным сообщением, содержащим описание ошибки. + 2 + + + Инициализирует новый экземпляр класса с использованием заданного сообщения, содержащего описание ошибки. + Сообщение с описанием исключения.Вызывающему объекту этого конструктора необходимо убедиться, что эта строка локализована для текущего языка и региональных параметров системы. + 2 + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение с описанием исключения.Вызывающему объекту этого конструктора необходимо убедиться, что эта строка локализована для текущего языка и региональных параметров системы. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + 2 + + + Указывает, можно ли несколько раз войти в блокировку из одного и того же потока. + + + Если поток пытается войти в блокировку рекурсивно, выдается ошибка.Некоторые классы могут допускать определенные виды рекурсий при активированном параметре. + + + Допускается рекурсивный вход потока в блокировку.Некоторые классы могут игнорировать эту возможность. + + + Уведомляет один или более ожидающих потоков о том, что произошло событие.Этот класс не наследуется. + 2 + + + Инициализирует новый экземпляр класса логическим значением, показывающим наличие сигнального состояния. + Значение true для задания начального состояния сигнальным; false для задания несигнального начального состояния. + + + Предоставляет уменьшенную версию . + + + Инициализирует новый экземпляр класса начальным состоянием nonsignaled. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение. + значение true для задания начального сигнального состояния; значение false для задания начального несигнального состояния. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, нужно ли для начального состояния задать сигнальное значение, а также указанным числом прокруток. + Значение true для задания начального сигнального состояния; значение false для задания начального несигнального состояния. + Число ожиданий прокруток до возврата к операции ожидания на основе ядра. + + is less than 0 or greater than the maximum allowed value. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые (а при необходимости и управляемые) ресурсы, используемые объектом . + Значение true, чтобы освободить управляемые и неуправляемые ресурсы; значение false, чтобы освободить только неуправляемые ресурсы. + + + Получает значение, указывающее, установлено ли событие. + Значение true, если событие установлено; в противном случае — значение false. + + + Задает несигнальное состояние события, вызывая блокирование потоков. + The object has already been disposed. + + + Устанавливает несигнальное состояние события, позволяя продолжить выполнение одному или нескольким потокам, ожидающим событие. + + + Получает число ожиданий прокруток, которые произойдут до возврата к операции ожидания на основе ядра. + Возвращает число ожиданий прокруток, которые произойдут до возврата к операции ожидания на основе ядра. + + + Блокирует текущий поток до установки текущего объекта . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не установлен текущий объект , используя 32-разрядное знаковое целое число для измерения интервала времени. + Значение true, если выполнялась установка ; в противном случае — false. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не будет установлен текущий объект , используя 32-разрядное знаковое целое число для измерения интервала времени. Кроме того, метод контролирует токен . + Значение true, если выполнялась установка ; в противном случае — значение false. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Блокирует текущий поток до получения сигнала текущим объектом . Кроме того, метод контролирует токен . + Токен отмены , который следует контролировать. + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + Блокирует текущий поток, пока не будет установлен текущий объект , используя объект для измерения интервала времени. + Значение true, если выполнялась установка ; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + Блокирует текущий поток до тех пор, пока не будет установлен текущий объект , используя значение для измерения интервала времени. Кроме того, метод контролирует токен . + Значение true, если был задан; в противном случае — значение false. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + Возвращает базовый объект для данного . + Базовый объект события для данного объекта . + + + Предоставляет механизм для синхронизации доступа к объектам. + 2 + + + Получает эксклюзивную блокировку указанного объекта. + Объект, для которого получается блокировка монитора. + Параметр имеет значение null. + 1 + + + Получает монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, в котором следует ожидать. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение.Примечание. Если исключение не возникает, выходное значение этого метода всегда true. + Входное значение параметра — true. + Параметр имеет значение null. + + + Освобождает эксклюзивную блокировку указанного объекта. + Объект, блокировка которого освобождается. + Параметр имеет значение null. + Данный поток не владеет блокировкой для указанного объекта. + 1 + + + Определяет, содержит ли текущий поток блокировку указанного объекта. + Значение true, если текущий поток владеет блокировкой в ; в противном случае — значение false. + Объект для тестирования. + Свойство имеет значение null. + + + Уведомляет поток в очереди готовности об изменении состояния объекта с блокировкой. + Объект, ожидаемый потоком. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + 1 + + + Уведомляет все ожидающие потоки об изменении состояния объекта. + Объект, посылающий импульс. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + 1 + + + Пытается получить эксклюзивную блокировку указанного объекта. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Параметр имеет значение null. + 1 + + + Пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + + + Пытается получить эксклюзивную блокировку указанного объекта на заданное количество миллисекунд. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Количество миллисекунд, в течение которых ожидать блокировку. + Параметр имеет значение null. + Значение параметра отрицательно и не равно . + 1 + + + В течение заданного количества миллисекунд пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Количество миллисекунд, в течение которых ожидать блокировку. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + Значение параметра отрицательно и не равно . + + + Пытается получить эксклюзивную блокировку указанного объекта в течение заданного количества времени. + Значение true, если текущий поток получает блокировку; в противном случае — значение false. + Объект, блокировка которого получается. + Класс , представляющий количество времени, в течение которого ожидается блокировка.Значение –1 миллисекунды обозначает бесконечное ожидание. + Параметр имеет значение null. + Значение в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + 1 + + + В течение заданного периода времени пытается получить монопольную блокировку указанного объекта и единым блоком задает значение, указывающее, была ли выполнена блокировка. + Объект, блокировка которого получается. + Период времени, в течение которого ожидается блокировка.Значение -1 обозначает бесконечное ожидание. + Результат попытки получить блокировку, переданную по ссылке.Входное значение должно равняться false.Выходное значение true, если блокировка получена; в противном случае — выходное значение false.Выходное значение задается, даже если при попытке получить блокировку возникает исключение. + Входное значение параметра — true. + Параметр имеет значение null. + Значение в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова. + true, если вызов осуществил возврат из-за того, что вызывающий поток заново получил блокировку заданного объекта.Этот метод не осуществляет возврат, если блокировка вновь не получена. + Объект, в котором следует ожидать. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + 1 + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова.Если указанные временные интервалы истекают, поток встает в очередь готовности. + Значение true, если блокировка была получена заново до истечения заданного времени; значение false, если блокировка была получена заново по истечении заданного времени.Этот метод не осуществляет возврат, если блокировка не была получена. + Объект, в котором следует ожидать. + Количество миллисекунд для ожидания постановки в очередь готовности. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + Значение параметра отрицательно и не равно . + 1 + + + Освобождает блокировку объекта и блокирует текущий поток до тех пор, пока тот не получит блокировку снова.Если указанные временные интервалы истекают, поток встает в очередь готовности. + Значение true, если блокировка была получена заново до истечения заданного времени; значение false, если блокировка была получена заново по истечении заданного времени.Этот метод не осуществляет возврат, если блокировка не была получена. + Объект, в котором следует ожидать. + Класс , представляющий количество времени, до истечения которого поток поступает в очередь ожидания. + Параметр имеет значение null. + Вызывающий поток не владеет блокировкой для указанного объекта. + Поток, который вызывает Wait, позже прерывается из состояния ожидания.Это происходит, когда другой поток вызывает метод данного потока. + Значение параметра в миллисекундах отрицательно и не равно (–1 миллисекунда), или больше чем . + 1 + + + Примитив синхронизации, который также может использоваться в межпроцессной синхронизации. + 1 + + + Инициализирует новый экземпляр класса стандартными свойствами. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса. + Значение true для предоставления вызывающему потоку изначального владения мьютексом; в противном случае — false. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, а также иметь строку, являющуюся именем мьютекса. + Значение true для предоставления вызывающему потоку изначального владения именованным системным мьютексом, если этот мьютекс создан данным вызовом; в противном случае — значение false. + Имя .Если значение равно null, у объекта нет имени. + Именованный мьютекс существует, имеет безопасность управления доступом, а пользователь не имеет прав . + Произошла ошибка Win32. + Именованный мьютекс не может быть создан; вероятно, дескриптор ожидания другого типа имеет то же имя. + + длиннее 260 символов. + + + Инициализирует новый экземпляр класса логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, иметь строку, являющуюся именем мьютекса, и логическое значение, которое при возврате метода показывает, предоставлено ли вызывающему потоку изначальное владение мьютексом. + Значение true для предоставления вызывающему потоку изначального владения именованным системным мьютексом, если этот мьютекс создан данным вызовом; в противном случае — значение false. + Имя .Если значение равно null, у объекта нет имени. + При возврате из метода содержит логическое значение true, если был создан локальный мьютекс (то есть, если параметр имеет значение null или содержит пустую строку) или был создан именованный системный мьютекс; значение false, если указанный именованный системный мьютекс уже существует.Этот параметр передается неинициализированным. + Именованный мьютекс существует, имеет безопасность управления доступом, а пользователь не имеет прав . + Произошла ошибка Win32. + Именованный мьютекс не может быть создан; вероятно, дескриптор ожидания другого типа имеет то же имя. + + длиннее 260 символов. + + + Открывает указанный именованный мьютекс, если он уже существует. + Объект, представляющий именованный системный мьютекс. + Имя системного мьютекса для открытия. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Именованный мьютекс не существует. + Произошла ошибка Win32. + Именованный мьютекс существует, но у пользователя нет необходимой для его использования безопасности доступа. + 1 + + + + + + Освобождает объект один раз. + Вызывающий поток не является владельцем мьютекса. + 1 + + + Открывает указанный именованный мьютекс, если он уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованный мьютекс был успешно открыт; в противном случае — значение false. + Имя системного мьютекса для открытия. + Когда выполнение этого метода завершается, содержит объект , представляющий именованный мьютекс, если вызов завершился успешно, или значение null, если произошел сбой вызова.Этот параметр обрабатывается как неинициализированный. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Произошла ошибка Win32. + Именованный мьютекс существует, но у пользователя нет необходимой для его использования безопасности доступа. + + + Представляет блокировку, используемую для управления доступом к ресурсу, которая позволяет нескольким потокам производить считывание или получать монопольный доступ на запись. + + + Инициализирует новый экземпляр класса значениями свойств по умолчанию. + + + Инициализирует новый экземпляр класса с указанием политики рекурсии блокировок. + Одно из значений перечисления, определяющее политику рекурсии блокировки. + + + Получает общее количество уникальных потоков, вошедших в блокировку в режиме чтения. + Количество уникальных потоков, вошедших в блокировку в режиме чтения. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + Пытается выполнить вход в блокировку в режиме чтения. + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + Пытается выполнить вход в блокировку в обновляемом режиме. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Пытается выполнить вход в блокировку в режиме записи. + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + Уменьшает счетчик глубины рекурсии для режима чтения и выходит из режима чтения, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in read mode. + + + Уменьшает счетчик глубины рекурсии для обновляемого режима и выходит из обновляемого режима, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in upgradeable mode. + + + Уменьшает счетчик глубины рекурсии для режима записи и выходит из режима записи, если счетчик принял значение 0 (нуль). + The current thread has not entered the lock in write mode. + + + Получает значение, указывающее, вошел ли текущий поток в блокировку в режиме чтения. + Значение true, если текущий поток вошел в режим чтения; в противном случае false. + 2 + + + Возвращает значение, указывающее, вошел ли текущий поток в блокировку в обновляемом режиме. + Значение true, если текущий поток вошел в обновляемый режим; в противном случае false. + 2 + + + Получает значение, указывающее, вошел ли текущий поток в блокировку в режиме записи. + Значение true, если текущий поток вошел в режим записи; в противном случае false. + 2 + + + Возвращает значение, указывающее политику рекурсии для текущего объекта . + Одно из значений перечисления, определяющее политику рекурсии блокировки. + + + Получает количество раз, которые текущий поток входил в блокировку в режиме чтения, как показатель рекурсии. + 0 (нуль), если текущий поток не вошел в режим чтения, 1, если поток вошел в режим чтения, но не рекурсивно, или n, если поток вошел в блокировку рекурсивно n - 1 раз. + 2 + + + Получает количество раз, которые текущий поток входил в блокировку в обновляемом режиме, как показатель рекурсии. + 0 (нуль), если текущий поток не вошел в обновляемый режим, 1, если поток вошел в обновляемый режим, но не рекурсивно, или n, если поток вошел в обновляемый режим рекурсивно n - 1 раз. + 2 + + + Получает количество раз, которые текущий поток входил в блокировку в режиме записи, как показатель рекурсии. + 0 (нуль), если текущий поток, не вошел в режим записи, 1, если поток вошел в режим записи, но не рекурсивно, или n, если поток вошел в режим записи рекурсивно n - 1 раз. + 2 + + + Пытается войти в блокировку в режиме чтения с необязательным указанием времени ожидания целым числом. + Значение true, если вызывающий поток вошел в режим чтения; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в режиме чтения с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим чтения; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Пытается войти в блокировку в обновляемом режиме с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в обновляемый режим; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в обновляемом режиме с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в обновляемый режим; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Пытается войти в блокировку в режиме записи с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим записи; в противном случае false. + Время ожидания в миллисекундах или -1 () в случае неограниченного времени ожидания. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + Пытается войти в блокировку в режиме записи с необязательным указанием времени ожидания. + Значение true, если вызывающий поток вошел в режим записи; в противном случае false. + Период ожидания или значение -1 миллисекунда для ожидания в течение неограниченного времени. + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + Получает общее количество потоков, ожидающих вхождения в блокировку в режиме чтения. + Общее количество потоков, ожидающих вхождения в режим чтения. + 2 + + + Получает общее количество потоков, ожидающих входа в блокировку в обновляемом режиме. + Общее количество потоков, ожидающих входа в обновляемый режим. + 2 + + + Получает общее количество потоков, ожидающих входа в блокировку в режиме записи. + Общее количество потоков, ожидающих входа в режим записи. + 2 + + + Ограничивает число потоков, которые могут одновременно получать доступ к ресурсу или пулу ресурсов. + 1 + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + Значение больше значения . + + имеет значение меньше 1.-или-Значение параметра меньше 0. + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов, а также при необходимости имя объекта системного семафора. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + Имя объекта именованного системного семафора. + Значение больше значения .-или- длиннее 260 символов. + + имеет значение меньше 1.-или-Значение параметра меньше 0. + Произошла ошибка Win32. + Именованный семафор существует, имеет параметры безопасности управления доступом, а пользователь не имеет прав . + Именованный семафор не может быть создан, видимо потому что дескриптор ожидания другого типа имеет то же имя. + + + Инициализирует новый экземпляр класса , задающий начальное количество входов и максимальное количество одновременных входов, а также при необходимости задающий имя объекта системного семафора и переменную, получающую значение, которое указывает, был ли создан новый системный семафор. + Начальное количество запросов семафора, которое может быть удовлетворено одновременно. + Максимальное количество запросов семафора, которое может быть удовлетворено одновременно. + Имя объекта именованного системного семафора. + При возврате этот метод содержит значение true, если был создан локальный семафор (то есть если параметр имеет значение null или содержит пустую строку) или был создан заданный именованный системный семафор; значение false, если указанный именованный семафор уже существовал.Этот параметр передается неинициализированным. + Значение больше значения . -или- длиннее 260 символов. + + имеет значение меньше 1.-или-Значение параметра меньше 0. + Произошла ошибка Win32. + Именованный семафор существует, имеет параметры безопасности управления доступом, а пользователь не имеет прав . + Именованный семафор не может быть создан, видимо потому что дескриптор ожидания другого типа имеет то же имя. + + + Открывает указанный именованный семафор, если он уже существует. + Объект, представляющий именованный системный семафор. + Имя системного семафора для открытия. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Именованный семафор не существует. + Произошла ошибка Win32. + Именованный семафор существует, но у пользователя нет необходимых для его использования прав доступа. + 1 + + + + + + Выходит из семафора и возвращает последнее значение счетчика. + Счетчик семафора перед вызовом метода . + Счетчик семафора уже имеет максимальное значение. + Произошла ошибка Win32, связанная с именованным семафором. + Текущий семафор представляет именованный системный семафор, но пользователь не имеет прав .-или-Текущий семафор представляет именованный системный семафор, но он не был открыт с правами доступа . + 1 + + + Выходит из семафора указанное число раз и возвращает последнее значение счетчика. + Счетчик семафора перед вызовом метода . + Количество требуемых выходов из семафора. + + имеет значение меньше 1. + Счетчик семафора уже имеет максимальное значение. + Произошла ошибка Win32, связанная с именованным семафором. + Текущий семафор представляет именованный системный семафор, но пользователь не имеет прав .-или-Текущий семафор представляет именованный системный семафор, но он не был открыт с правами . + 1 + + + Открывает указанный именованный семафор, если он уже существует, и возвращает значение, указывающее, успешно ли выполнена операция. + Значение true, если именованный семафор был успешно открыт; в противном случае — значение false. + Имя системного семафора для открытия. + При возврате этот метод содержит объект , представляющий именованный семафор, если вызов завершился успешно, или значение null, если вызов завершился неудачно.Этот параметр обрабатывается как неинициализированный. + Параметр равен пустой строке.-или- длиннее 260 символов. + Свойство имеет значение null. + Произошла ошибка Win32. + Именованный семафор существует, но у пользователя нет необходимых для его использования прав доступа. + + + Исключение, выдаваемое при вызове метода для семафора, значение счетчика которого уже равно максимальному. + 2 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Представляет упрощенную альтернативу семафору , ограничивающему количество потоков, которые могут параллельно обращаться к ресурсу или пулу ресурсов. + + + Инициализирует новый экземпляр класса , указывая первоначальное число запросов, которые могут выполняться одновременно. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Значение параметра меньше 0. + + + Инициализирует новый экземпляр класса , указывая изначальное и максимальное число запросов, которые могут выполняться одновременно. + Начальное количество запросов для семафора, которое может быть обеспечено одновременно. + Максимальное количество запросов семафора, которое может быть обеспеченно одновременно. + + меньше 0 или больше, чем , или меньше или равен 0. + + + Возвращает дескриптор , который можно использовать для ожидания семафора. + Дескриптор , который можно использовать для ожидания семафора. + Объект удален. + + + Возвращает количество оставшихся потоков, которым разрешено входить в объект . + Количество оставшихся потоков, которым разрешено входить в семафор. + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает неуправляемые ресурсы, используемые журналом , и при необходимости освобождает также управляемые ресурсы. + Значение true позволяет освободить как управляемые, так и неуправляемые ресурсы; значение false освобождает только неуправляемые ресурсы. + + + Освобождает объект один раз. + Предыдущее количество в семафоре . + Текущий экземпляр уже был удален. + + уже достиг максимального размера. + + + Освобождает объект указанное число раз. + Предыдущее количество в семафоре . + Количество требуемых выходов из семафора. + Текущий экземпляр уже был удален. + + имеет значение меньше 1. + + уже достиг максимального размера. + + + Блокирует текущий поток, пока он не сможет войти в . + Текущий экземпляр уже был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя 32-разрядное целое число со знаком, которое определяет время ожидания. + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя 32-разрядное целое число со знаком, которое определяет время ожидания, и контролирует токен . + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + + был отменен. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + Экземпляр был удален, или создания был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , и контролирует токен . + Токен , который следует контролировать. + + был отменен. + Текущий экземпляр уже был удален.-или- Создания уже был удален. + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя значение для определения времени ожидания. + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + Экземпляр semaphoreSlim был уничтожен + + + Блокирует текущий поток до тех пор, пока он не сможет войти в , используя значение , которое определяет время ожидания, и контролирует токен . + Значение true, если текущий поток успешно вошел в ; в противном случае — значение false. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Токен отмены , который следует контролировать. + + был отменен. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + Экземпляр semaphoreSlim был уничтоженКласс , создавший , уже удален. + + + Асинхронно ожидает входа в . + Задача, которая завершается при входе в семафор. + + + Асинхронно ожидает входа в , используя 32-разрядное целое число со знаком для измерения интервала времени. + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Асинхронно ожидает входа в , используя 32-разрядное целое число со знаком для измерения интервала времени, контролируя . + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Время ожидания в миллисекундах или (-1) для неограниченного времени ожидания. + Токен отмены , который следует контролировать. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Текущий экземпляр уже был удален. + + был отменен. + + + Асинхронно ожидает входа в , контролируя . + Задача, которая завершается при входе в семафор. + Токен , который следует контролировать. + Текущий экземпляр уже был удален. + + был отменен. + + + Асинхронно ожидает входа в , используя для измерения интервала времени. + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Текущий экземпляр уже был удален. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. -или- Время ожидания больше . + + + Асинхронно ожидает входа в , используя для измерения интервала времени и контролируя . + Задача, которая будет завершаться с результатом true, если текущий поток успешно вошел в , и с результатом false в противном случае. + Период , представляющий время ожидания в миллисекундах, или период , представляющий -1 миллисекунду для неограниченного ожидания. + Токен , который следует контролировать. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания.-или-Время ожидания больше . + + был отменен. + + + Указывает метод, вызываемый при отправке сообщения в контекст синхронизации. + Передаваемый делегату объект. + 2 + + + Предоставляет примитив взаимно исключающей блокировки, в котором поток, пытающийся получить блокировку, ожидает в состоянии цикла, проверяя доступность блокировки. + + + Инициализирует новый экземпляр структуры параметром для отслеживания идентификаторов потоков для повышения качества отладки. + Следует ли перенаправлять и использовать идентификаторы потоков для отладки. + + + Получает блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Аргумент должен быть инициализирован в false до вызова Enter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Снимает блокировку. + Включено отслеживание владения потоков и текущий поток не является владельцем этой блокировки. + + + Снимает блокировку. + Логическое значение, указывающее, следует ли выпустить барьер памяти, чтобы немедленно опубликовать операцию выхода для других потоков. + Включено отслеживание владения потоков и текущий поток не является владельцем этой блокировки. + + + Получает значение, определяющее, имеет ли какой-либо поток блокировку в настоящий момент. + Значение true, если в настоящее время блокировка удерживается каким-либо потоком; в противном случае — значение false. + + + Получает значение, определяющее, имеет ли текущий поток блокировку. + Значение true, если блокировка удерживается текущим потоком; в противном случае — значение false. + Отслеживание владения потоков отключено. + + + Получает значение, указывающее, включено ли отслеживание владельца потока для данного экземпляра. + Значение true, если для данного экземпляра включено отслеживание владельца потока; в противном случае — значение false. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Пытается получить блокировку надежным способом, то есть даже если в вызове метода возникает исключение, можно надежно изучить и определить, была ли получена блокировка. + Объект , представляющий время ожидания в миллисекундах, или объект , представляющий -1 миллисекунду для неограниченного ожидания. + Значение true, если блокировка получена; в противном случае — значение false.Перед вызовом этого метода необходимо инициализировать параметр . + + является отрицательным числом, отличным от значения -1 миллисекунды, которое представляет неограниченное время ожидания - или - время ожидания больше . + Аргумент должен быть инициализирован в false до вызова TryEnter. + Включено отслеживание владения потоками, и текущий поток уже получил эту блокировку. + + + Предоставляет поддержку ожидания на основе прокруток. + + + Получает число раз, которое был вызван для этого экземпляра. + Возвращает целое число, представляющее количество вызовов метода для данного экземпляра. + + + Получает значение, показывающее, даст ли следующий вызов к доступ к процессору, запуская обязательное переключение контекста. + Даст ли следующий вызов к доступ к процессору, запуская обязательное переключение контекста. + + + Сбрасывает подсчет прокруток. + + + Выполняет одну прокрутку. + + + Выполняет прокрутки до удовлетворения заданного условия. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Аргументом параметра является null. + + + Выполняет прокрутки до удовлетворения заданного условия или истечения заданного времени ожидания. + Значение true, если условие удовлетворено до истечения времени ожидания; в противном случае — значение false. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Время ожидания в миллисекундах или функция (-1) в случае неограниченного времени ожидания. + Аргументом параметра является null. + Параметр является отрицательным числом, отличным от -1, которое представляет неограниченное время ожидания. + + + Выполняет прокрутки до удовлетворения заданного условия или истечения заданного времени ожидания. + Значение true, если условие удовлетворено до истечения времени ожидания; в противном случае — значение false. + Делегат для циклического выполнения до возврата этим делегатом значения true. + Объект , указывающий время ожидания в миллисекундах, или TimeSpan, представляющий значение -1 миллисекунда, в случае неограниченного ожидания. + Аргументом параметра является null. + + является отрицательным числом отличный значение -1 миллисекунд, которое представляет неограниченное время ожидания - или - время ожидания больше . + + + Обеспечивает базовую функциональность для распространения контекста синхронизации в различных моделях синхронизации. + 2 + + + Создает новый экземпляр класса . + + + При переопределении в производном классе создает копию контекста синхронизации. + Новый объект . + 2 + + + Получает контекст синхронизации для текущего потока + Объект , представляющий текущий контекст синхронизации. + 1 + + + При переопределении в производном классе отвечает на уведомление о завершении операции. + + + При переопределении в производном классе отвечает на уведомление о запуске операции. + + + При переопределении в производном классе отправляет асинхронное сообщение в контекст синхронизации. + Вызываемый делегат . + Передаваемый делегату объект. + 2 + + + При переопределении в производном классе отправляет синхронное сообщение в контекст синхронизации. + Вызываемый делегат . + Передаваемый делегату объект. + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + Задает текущий контекст синхронизации. + Задаваемый объект . + 1 + + + + + + Исключение, которое выдается в то время, когда методу требуется вызвавший его объект для получения блокировки данного Monitor, а метод вызван объектом, не являющимся владельцем блокировки. + 2 + + + Инициализирует новый экземпляр класса со стандартными свойствами. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + Предоставляет хранилище для данных, локальных для потока. + Задает тип данных, хранимых для каждого потока. + + + Инициализирует экземпляр . + + + Инициализирует экземпляр . + Следует ли отслеживать все значения, заданные в экземпляре, и представлять их с помощью свойства . + + + Инициализирует экземпляр с заданной функцией . + Объект , вызываемый для получения неактивно инициализированного значения при совершении попытки получить без предварительной инициализации. + + является пустой ссылкой (Nothing в Visual Basic). + + + Инициализирует экземпляр с заданной функцией . + Объект , вызываемый для получения неактивно инициализированного значения при совершении попытки получить без предварительной инициализации. + Следует ли отслеживать все значения, заданные в экземпляре, и представлять их с помощью свойства . + Параметр является пустой (null) ссылкой (Nothing в Visual Basic). + + + Освобождает все ресурсы, используемые текущим экземпляром класса . + + + Освобождает ресурсы, используемые данным экземпляром . + Логическое значение, указывающее, вызывается ли данный метод из-за вызова метода . + + + Освобождает ресурсы, используемые данным экземпляром . + + + Получает значение, указывающее, инициализирован ли объект в текущем потоке. + Значение true, если инициализируется в текущем потоке; в противном случае — значение false. + Экземпляр класса был удален. + + + Создает и возвращает строковое представление данного экземпляра для текущего потока. + Результат вызова метода для свойства . + Экземпляр класса был удален. + + для текущего потока представляет пустую ссылку (Nothing в Visual Basic). + Инициализация попыталась создать рекурсивную ссылку . + Не предоставляются конструктор по умолчанию и значение фабрики. + + + Получает или задает значение данного экземпляра для текущего потока. + Возвращает экземпляр объекта, за инициализацию которого ответственен данный ThreadLocal. + Экземпляр класса был удален. + Инициализация попыталась создать рекурсивную ссылку . + Не предоставляются конструктор по умолчанию и значение фабрики. + + + Получает список всех значений, хранящихся в настоящий момент всеми потоками, которые получили доступа к данному экземпляру. + Список всех значений, хранящихся в настоящий момент всеми потоками, которые получили доступа к данному экземпляру. + Экземпляр класса был удален. + + + Содержит методы для выполнения операций энергозависимой памяти. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает значение указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанное значение.Это значение является последним, записанным любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + + + Считывает ссылку на объект из указанного поля.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется после данного метода в коде, процессор не сможет переместить ее перед этим методом. + Прочитанная ссылка на объект .Эта ссылка является последней, записанной любым процессором компьютера, независимо от количества процессоров и от состояния кэша процессоров. + Считываемое поле. + Тип считываемого поля.Должен быть ссылочным типом или типом значения. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция памяти появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданное значение в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается значение. + Записываемое значение.Значение записывается немедленно, так что оно становится видимым для всех процессоров компьютера. + + + Записывает заданную ссылку на объект в указанное поле.В системах, которым это необходимо, вставляет барьер памяти, не позволяющий процессору изменять порядок операций памяти следующим образом: если операция чтения или записи появляется перед данным методом в коде, процессор не сможет поместить ее после этого метода. + Поле, в которое записывается ссылка на объект. + Записываемая ссылка на объект.Ссылка записывается немедленно, так что она становится видимой для всех процессоров компьютера. + Тип поля, в которое выполняется запись.Должен быть ссылочным типом или типом значения. + + + Исключение, которое выдается при попытке открыть не существующий в системе семафор или мьютекс. + 2 + + + Инициализирует новый экземпляр класса значениями по умолчанию. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке. + Сообщение об ошибке с объяснением причин исключения. + + + Инициализирует новый экземпляр класса с указанным сообщением об ошибке и ссылкой на внутреннее исключение, вызвавшее это исключение. + Сообщение об ошибке с объяснением причин исключения. + Исключение, которое вызвало текущее исключение.Если значение параметра не равно null, текущее исключение сгенерировано в блоке catch, обрабатывающем внутреннее исключение. + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/zh-hans/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/zh-hans/System.Threading.xml new file mode 100644 index 000000000..7c174ad66 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/zh-hans/System.Threading.xml @@ -0,0 +1,1854 @@ + + + + System.Threading + + + + 当某个线程获取由另一个线程放弃（即在未释放的情况下退出）的 对象时引发的异常。 + 1 + + + 使用默认值初始化 类的新实例。 + + + 用被放弃的互斥体的指定索引（如果可用）和表示该互斥体的 对象初始化 类的新实例。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误消息。 + + + 用指定的错误信息和内部异常初始化 类的新实例。 + 解释异常原因的错误消息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 用指定的错误信息、内部异常、被放弃的互斥体的索引（如果可用）以及表示该互斥体的 对象初始化 类的新实例。 + 解释异常原因的错误消息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 用指定的错误信息、被放弃的互斥体的索引（如果可用）以及被放弃的互斥体初始化 类的新实例。 + 解释异常原因的错误消息。 + 如果对 方法引发异常，则为等待句柄数组中被放弃的互斥体的索引，如果对 或 方法引发异常，则为 –1。 + 一个 对象，表示被放弃的互斥体。 + + + 获取导致异常的被放弃的互斥体（如果已知的话）。 + 如果未能识别被放弃的互斥体，则为表示该被放弃的互斥体的 对象或 null。 + 1 + + + 获取导致异常的被放弃的互斥体的索引（如果已知的话）。 + 如果未能确定被放弃的互斥体的索引，则为传递给 方法的等待句柄数组中的索引、表示该被放弃的互斥体的 对象的索引或 –1。 + 1 + + + 表示对于给定异步控制流（如异步方法）是本地数据的环境数据。 + 环境数据的类型。 + + + 实例化不接收更改通知的 实例。 + + + 实例化接收更改通知的 本地实例。 + 只要当前值在任何线程上发生更改时便会调用的委托。 + + + 获取或设置环境数据的值。 + 环境数据的值。 + + + 向针对更改通知进行了注册的 实例提供数据更改信息的类。 + 数据的类型。 + + + 获取数据的当前值。 + 数据的当前值。 + + + 获取数据的上一个值。 + 数据的上一个值。 + + + 返回一个值，该值指示是否由于执行上下文更改而更改了值。 + 如果由于执行上下文更改而更改了值，则为 true；否则为 false。 + + + 通知正在等待的线程已发生事件。此类不能被继承。 + 2 + + + 使用 Boolean 值（指示是否将初始状态设置为终止的）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + + + 使多个任务能够采用并行方式依据某种算法在多个阶段中协同工作。 + + + 初始化 类的新实例。 + 参与线程的数量。 + + 小于 0 或大于 32,767。 + + + 初始化 类的新实例。 + 参与线程的数量。 + 在每个阶段之后要执行的 。可以传递 null (在 Visual Basic 中为 Nothing) 以指示不执行任何操作。 + + 小于 0 或大于 32,767。 + + + 通知 ，告知其将会有另一个参与者。 + 新参与者将首先参与的屏障的阶段编号。 + 当前实例已被释放。 + 添加参与者将导致屏障的参与者计数超过 32,767。- 或 -该方法从阶段后操作中调用。 + + + 通知 ，告知其将会有多个其他参与者。 + 新参与者将首先参与的屏障的阶段编号。 + 要添加到屏障的其他参与者的数量。 + 当前实例已被释放。 + + 小于 0。- 或 -添加 参与者将导致屏障的参与者计数超过 32,767。 + 该方法从阶段后操作中调用。 + + + 获取屏障的当前阶段的编号。 + 返回屏障的当前阶段的编号。 + + + 释放由 类的当前实例占用的所有资源。 + 该方法从阶段后操作中调用。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。 + + + 获取屏障中参与者的总数。 + 返回屏障中参与者的总数。 + + + 获取屏障中尚未在当前阶段发出信号的参与者的数量。 + 返回屏障中尚未在当前阶段发出信号的参与者的数量。 + + + 通知 ，告知其将会减少一个参与者。 + 当前实例已被释放。 + 屏障已经有 0 个参与者。- 或 -该方法从阶段后操作中调用。 + + + 通知 ，告知其将会减少一些参与者。 + 要从屏障中移除的其他参与者的数量。 + 当前实例已被释放。 + + 小于 0。 + 屏障已经有 0 个参与者。- 或 -该方法从阶段后操作中调用。 - 或 -当前的参与者计数小于指定 participantCount + 参与者总数小于指定的 + + + 发出参与者已达到屏障并等待所有其他参与者也达到屏障。 + 当前实例已被释放。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + 在所有参与线程调用了 SignalAndWait 之后，如果关卡的后期阶段操作中引发了异常，该异常将包装在 BarrierPostPhaseException 中并在所有参与线程上引发。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，同时使用 32 位带符号整数测量超时。 + 如果所有参与者都已在指定时间内达到屏障，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + 在所有参与线程调用了 SignalAndWait 之后，如果关卡的后期阶段操作中引发了异常，该异常将包装在 BarrierPostPhaseException 中并在所有参与线程上引发。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，使用 32 位带符号整数测量超时，同时观察取消标记。 + 如果所有参与者都已在指定时间内达到屏障，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者达到屏障，同时观察取消标记。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，同时使用 对象测量时间间隔。 + 如果所有其他参与者已达到屏障，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 32,767。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + 发出参与者已达到屏障的信号，并等待所有其他参与者也达到屏障，使用 对象测量时间间隔，同时观察取消标记。 + 如果所有其他参与者已达到屏障，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。 + + 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 + 该方法从阶段后操作中调用，当前屏障具有 0 个参与者，或该屏障被注册为参与者的更多线程终止。 + + + + 阶段后操作失败时引发的异常。 + + + 使用由系统提供的用来描述错误的消息初始化 类的新实例。 + + + 使用指定的内部异常初始化 类的新实例。 + 导致当前异常的异常。 + + + 使用指定的描述错误的消息初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 表示要在新上下文中调用的方法。 + 一个对象，包含回调方法在每次执行时要使用的信息。 + 1 + + + 表示在计数变为零时处于有信号状态的同步基元。 + + + 使用指定计数初始化 类的新实例。 + 设置 时最初必需的信号数。 + + 小于 0。 + + + 将 的当前计数加 1。 + 当前实例已被释放。 + 当前实例已设置 。- 或 - 等于或大于 。 + + + 将 的当前计数增加指定值。 + + 的增量值。 + 当前实例已被释放。 + + 小于或等于零。 + 当前实例已设置 。- 或 -在计数由 递增后， 大于或等于 。 + + + 获取设置事件时所必需的剩余信号数。 + 设置事件时所必需的剩余信号数。 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。 + + + 获取设置事件时最初必需的信号数。 + 设置事件时最初必需的信号数。 + + + 确定是否设置了事件。 + 如果设置了事件，则为 true；否则为 false。 + + + 将 重置为 的值。 + 当前实例已被释放。 + + + 将 属性重新设置为指定值。 + 设置 时所必需的信号的数量。 + 当前实例已被释放。 + + 小于 0。 + + + 向 注册信号，同时减小 的值。 + 如果信号导致计数变为零并且设置了事件，则为 true；否则为 false。 + 当前实例已被释放。 + 当前实例已设置 。 + + + 向 注册多个信号，同时将 的值减少指定数量。 + 如果信号导致计数变为零并且设置了事件，则为 true；否则为 false。 + 要注册的信号的数量。 + 当前实例已被释放。 + + 小于 1。 + 当前实例已设置 。- 或 - 大于 。 + + + 增加一个 的尝试。 + 如果成功增加，则为 true；否则为 false。如果 已为零，则此方法将返回 false。 + 当前实例已被释放。 + + 等于 。 + + + 增加指定值的 的尝试。 + 如果成功增加，则为 true；否则为 false。如果 已为零，则此方法将返回 false。 + + 的增量值。 + 当前实例已被释放。 + + 小于或等于零。 + 当前实例已设置 。- 或 - + 大于等于 。 + + + 阻止当前线程，直到设置了 为止。 + 当前实例已被释放。 + + + 阻止当前线程，直到设置了 为止，同时使用 32 位带符号整数测量超时。 + 如果设置了 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直到设置了 为止，并使用 32 位带符号整数测量超时，同时观察 。 + 如果设置了 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直到设置了 为止，同时观察 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + + 阻止当前线程，直到设置了 为止，同时使用 测量超时。 + 如果设置了 ，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 阻止当前线程，直到设置了 为止，并使用 测量超时，同时观察 。 + 如果设置了 ，则为 true；否则为 false。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 的 已被释放。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 获取用于等待要设置的事件的 。 + 用于等待要设置的事件的 。 + 当前实例已被释放。 + + + 指示在接收信号后是自动重置 还是手动重置。 + 2 + + + 当终止时， 在释放一个线程后自动重置。如果没有等待的线程， 将保持终止状态直到一个线程阻止，并在释放此线程后重置。 + + + 当终止时， 释放所有等待的线程，并在手动重置前保持终止状态。 + + + 表示一个线程同步事件。 + 2 + + + 初始化 类的新实例，并指定等待句柄最初是否处于终止状态，以及它是自动重置还是手动重置。 + 如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + + + 初始化 类的新实例，并指定在此调用后创建的等待句柄最初是否处于终止状态，它是自动重置还是手动重置，以及系统同步事件的名称。 + 如果命名事件是通过此调用创建的，则 true 将初始状态设置为终止；false 将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + 系统范围内同步事件的名称。 + 发生了一个 Win32 错误。 + 命名事件存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名事件，原因可能是与另一个不同类型的等待句柄同名。 + + 的长度超过 260 个字符。 + + + 初始化 类的新实例，并指定在此调用后创建的等待句柄最初是否处于终止状态，它是自动重置还是手动重置，系统同步事件的名称，以及一个 Boolean 变量（其值在调用后表示是否创建了已命名的系统事件）。 + 如果命名事件是通过此调用创建的，则 true 将初始状态设置为终止；false 将初始状态设置为非终止。 + + 值之一，它确定事件是自动重置还是手动重置。 + 系统范围内同步事件的名称。 + 在此方法返回时，如果创建了本地事件（即，如果 为 null 或空字符串）或指定的命名系统事件，则包含 true；如果指定的命名系统事件已存在，则为 false。该参数未经初始化即被传递。 + 发生了一个 Win32 错误。 + 命名事件存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名事件，原因可能是与另一个不同类型的等待句柄同名。 + + 的长度超过 260 个字符。 + + + 打开指定名称为同步事件（如果已经存在）。 + 一个对象，表示已命名的系统事件。 + 要打开的系统同步事件的名称。 + + 是空字符串。- 或 - 的长度超过 260 个字符。 + + 为 null。 + 命名的系统事件不存在。 + 发生了一个 Win32 错误。 + 已命名的事件存在，但用户不具备使用它所需的安全访问权限。 + 1 + + + + + + 将事件状态设置为非终止状态，导致线程阻止。 + 如果该操作成功，则为 true；否则，为 false。 + 之前已对此 调用 方法。 + 2 + + + 将事件状态设置为终止状态，允许一个或多个等待线程继续。 + 如果该操作成功，则为 true；否则，为 false。 + 之前已对此 调用 方法。 + 2 + + + 打开指定名称为同步事件（如果已经存在），并返回指示操作是否成功的值。 + 如果命名同步事件成功打开，则为 true；否则为 false。 + 要打开的系统同步事件的名称。 + 当此方法返回时，如果调用成功，则包含表示命名同步事件的 对象；否则为 null。该参数未经初始化即被处理。 + + 是空字符串。- 或 - 的长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的事件存在，但用户不具备所需的安全访问权限。 + + + 管理当前线程的执行上下文。此类不能被继承。 + 2 + + + 从当前线程捕获执行上下文。 + 一个 对象，表示当前线程的执行上下文。 + 1 + + + 在当前线程上的指定执行上下文中运行某个方法。 + 要设置的 。 + 一个 委托，表示要在提供的执行上下文中运行的方法。 + 要传递给回调方法的对象。 + + 为 null。- 或 - 不是通过捕获操作获取的。- 或 - 已用作 调用的参数。 + 1 + + + + + + 为多个线程共享的变量提供原子操作。 + 2 + + + 对两个 32 位整数进行求和并用和替换第一个整数，上述操作作为一个原子操作完成。 + 存储在 处的新值。 + 一个变量，包含要添加的第一个值。两个值的和存储在 中。 + 要添加到整数中的 位置的值。 + The address of is a null pointer. + 1 + + + 对两个 64 位整数进行求和并用和替换第一个整数，上述操作作为一个原子操作完成。 + 存储在 处的新值。 + 一个变量，包含要添加的第一个值。两个值的和存储在 中。 + 要添加到整数中的 位置的值。 + The address of is a null pointer. + 1 + + + 比较两个双精度浮点数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个 32 位有符号整数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个 64 位有符号整数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较两个平台特定的句柄或指针是否相等，如果相等，则替换第一个。 + + 中的原始值。 + 其值与 的值进行比较并且可能被 替换的目标 。 + 比较结果相等时替换目标值的 。 + 与位于 处的值进行比较的 。 + The address of is a null pointer. + 1 + + + 比较两个对象是否相等，如果相等，则替换第一个对象。 + + 中的原始值。 + 其值与 进行比较并且可能被替换的目标对象。 + 在比较结果相等时替换目标对象的对象。 + 与位于 处的对象进行比较的对象。 + The address of is a null pointer. + 1 + + + 比较两个单精度浮点数是否相等，如果相等，则替换第一个值。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + The address of is a null pointer. + 1 + + + 比较指定的引用类型 的两个实例是否相等，如果相等，则替换第一个。 + + 中的原始值。 + 其值将与 进行比较并且可能被替换的目标。这是一个引用参数（在 C# 中是 ref，在 Visual Basic 中是 ByRef）。 + 比较结果相等时替换目标值的值。 + 与位于 处的值进行比较的值。 + 用于 , 和 的类型。此类型必须是引用类型。 + The address of is a null pointer. + + + 以原子操作的形式递减指定变量的值并存储结果。 + 递减的值。 + 其值要递减的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式递减指定变量的值并存储结果。 + 递减的值。 + 其值要递减的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将双精度浮点数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将 32 位有符号整数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将 64 位有符号整数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将平台特定的句柄或指针设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将对象设置为指定的值并返回对原始对象的引用。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将单精度浮点数设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。 + + 参数被设置为的值。 + The address of is a null pointer. + 1 + + + 以原子操作的形式，将指定类型 的变量设置为指定的值并返回原始值。 + + 的原始值。 + 要设置为指定值的变量。这是一个引用参数（在 C# 中是 ref，在 Visual Basic 中是 ByRef）。 + + 参数被设置为的值。 + 用于 和 的类型。此类型必须是引用类型。 + The address of is a null pointer. + + + 以原子操作的形式递增指定变量的值并存储结果。 + 递增的值。 + 其值要递增的变量。 + The address of is a null pointer. + 1 + + + 以原子操作的形式递增指定变量的值并存储结果。 + 递增的值。 + 其值要递增的变量。 + The address of is a null pointer. + 1 + + + 按如下方式同步内存存取：执行当前线程的处理器在对指令重新排序时，不能采用先执行 调用之后的内存存取，再执行 调用之前的内存存取的方式。 + + + 返回一个以原子操作形式加载的 64 位值。 + 加载的值。 + 要加载的 64 位值。 + 1 + + + 提供延迟初始化例程。 + + + 在目标引用或值类型尚未初始化的情况下，使用其默认构造函数初始化目标引用或值类型。 + 类型 的初始化引用。 + 在类型尚未初始化的情况下，要初始化的类型 的引用。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用或值类型尚未初始化的情况下，使用其默认构造函数初始化目标引用或值类型。 + 类型 的初始化值。 + 在尚未初始化的情况下要初始化的类型 的引用或值。 + 对布尔值的引用，该值确定目标是否已初始化。 + 对用作相互排斥锁的对象的引用，用于初始化 。如果 为 null，则新的对象将被实例化。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用或值类型尚未初始化的情况下，使用指定函数初始化目标引用或值类型。 + 类型 的初始化值。 + 在尚未初始化的情况下要初始化的类型 的引用或值。 + 对布尔值的引用，该值确定目标是否已初始化。 + 对用作相互排斥锁的对象的引用，用于初始化 。如果 为 null，则新的对象将被实例化。 + 调用函数以初始化该引用或值。 + 要初始化的引用的类型。 + 缺少访问类型 的构造函数的权限。 + 类型 没有默认的构造函数。 + + + 在目标引用类型尚未初始化的情况下，使用指定函数初始化目标引用类型。 + 类型 的初始化值。 + 在类型尚未初始化的情况下，要初始化的类型 的引用。 + 调用函数以初始化该引用。 + 要初始化的引用的引用类型。 + 类型 没有默认的构造函数。 + + 返回 null（在 Visual Basic 中为 Nothing）。 + + + 当进入锁定状态的递归与此锁定的递归策略不兼容时引发的异常。 + 2 + + + 使用由系统提供的用来描述错误的消息初始化 类的新实例。 + 2 + + + 使用指定的描述错误的消息初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方必须确保此字符串已针对当前系统区域性进行了本地化。 + 2 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 描述该异常的消息。此构造函数的调用方必须确保此字符串已针对当前系统区域性进行了本地化。 + 引发当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + 2 + + + 指定同一个线程是否可以多次进入一个锁定状态。 + + + 如果线程尝试以递归方式进入锁定状态，将引发异常。某些类可能会在此设置生效时允许使用特定的递归方式。 + + + 线程可以采用递归方式进入锁定状态。某些类可能会限制此功能。 + + + 通知一个或多个正在等待的线程已发生事件。此类不能被继承。 + 2 + + + 用一个指示是否将初始状态设置为终止的布尔值初始化 类的新实例。 + 如果为 true，则将初始状态设置为终止；如果为 false，则将初始状态设置为非终止。 + + + 提供 的简化版本。 + + + 使用非终止初始状态初始化 类的新实例。 + + + 使用 Boolean 值（指示是否将初始状态设置为终止状态）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + + + 使用 Boolean 值（指示是否将初始状态设置为终止或指定的旋转数）初始化 类的新实例。 + 若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为 false。 + 在回退到基于内核的等待操作之前发生的自旋等待数量。 + + is less than 0 or greater than the maximum allowed value. + + + 释放由 类的当前实例占用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 为 true 则释放托管资源和非托管资源；为 false 则仅释放非托管资源。 + + + 获取是否已设置事件。 + 如果设置了事件，则为 true；否则为 false。 + + + 将事件状态设置为非终止，从而导致线程受阻。 + The object has already been disposed. + + + 将事件状态设置为有信号，从而允许一个或多个等待该事件的线程继续。 + + + 获取在回退到基于内核的等待操作之前发生的自旋等待数量。 + 返回在回退到基于内核的等待操作之前发生的自旋等待数量。 + + + 阻止当前线程，直到设置了当前 为止。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到设定 ，使用 32 位已签名整数测量时间间隔。 + 如果已设置 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到设定 ，使用 32 位已签名整数测量时间间隔，同时观察 。 + 如果已设置 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 阻止当前线程，直到 接收到信号，同时观察 。 + 要观察的 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + 阻止当前线程，直到当前 已设定，使用 测量时间间隔。 + 如果已设置 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 阻止当前线程，直到当前 已设定，使用 测量时间间隔，同时观察 。 + 如果已设置 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 获取此 的基础 对象。 + 此 的基础 事件对象。 + + + 提供同步访问对象的机制。 + 2 + + + 在指定对象上获取排他锁。 + 在其上获取监视器锁的对象。 + + 参数为 null。 + 1 + + + 获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 要在其上等待的对象。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。注意   如果没有发生异常，则此方法的输出始终为 true。 + 对 的输入是 true。 + + 参数为 null。 + + + 释放指定对象上的排他锁。 + 在其上释放锁的对象。 + + 参数为 null。 + 当前线程不拥有指定对象的锁。 + 1 + + + 确定当前线程是否保留指定对象上的锁。 + 如果当前线程持有 锁，则为 true；否则为 false。 + 要测试的对象。 + + 为 null。 + + + 通知等待队列中的线程锁定对象状态的更改。 + 线程正在等待的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 1 + + + 通知所有的等待线程对象状态的更改。 + 发送脉冲的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 1 + + + 尝试获取指定对象的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + + 参数为 null。 + 1 + + + 尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 在其上获取锁的对象。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + + 在指定的毫秒数内尝试获取指定对象上的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + 等待锁所需的毫秒数。 + + 参数为 null。 + + 为负且不等于 。 + 1 + + + 在指定的毫秒数内尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。 + 在其上获取锁的对象。 + 等待锁所需的毫秒数。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + 为负且不等于 。 + + + 在指定的时间内尝试获取指定对象上的排他锁。 + 如果当前线程获取该锁，则为 true；否则为 false。 + 在其上获取锁的对象。 + + ，表示等待锁所需的时间量。值为 -1 毫秒表示指定无限期等待。 + + 参数为 null。 + + 值（以毫秒为单位）为负且不等于 （-1 毫秒），或者大于 。 + 1 + + + 在指定的一段时间内尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获得了该锁。 + 在其上获取锁的对象。 + 用于等待锁的时间。值为 -1 毫秒表示指定无限期等待。 + 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。 + 对 的输入是 true。 + + 参数为 null。 + + 值（以毫秒为单位）为负且不等于 （-1 毫秒），或者大于 。 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。 + 如果调用由于调用方重新获取了指定对象的锁而返回，则为 true。如果未重新获取该锁，则此方法不会返回。 + 要在其上等待的对象。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + 1 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果已用指定的超时时间间隔，则线程进入就绪队列。 + 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。 + 要在其上等待的对象。 + 线程进入就绪队列之前等待的毫秒数。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + + 参数值为负且不等于 。 + 1 + + + 释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果已用指定的超时时间间隔，则线程进入就绪队列。 + 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。 + 要在其上等待的对象。 + + ，表示线程进入就绪队列之前等待的时间量。 + + 参数为 null。 + 调用线程不拥有指定对象的锁。 + 调用 Wait 的线程稍后从等待状态中断。当另一个线程调用此线程的 方法时会发生这种情况。 + + 参数值（以毫秒为单位）为负且不表示 （-1 毫秒），或者大于 。 + 1 + + + 还可用于进程间同步的同步基元。 + 1 + + + 使用默认属性初始化 类的新实例。 + + + 使用 Boolean 值（指示调用线程是否应具有互斥体的初始所有权）初始化 类的新实例。 + 如果给调用线程赋予互斥体的初始所属权，则为 true；否则为 false。 + + + 使用 Boolean 值（指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称）初始化 类的新实例。 + 如果为 true，则给予调用线程已命名的系统互斥体的初始所属权（如果已命名的系统互斥体是通过此调用创建的）；否则为 false。 + + 的名称。如果值为 null，则 是未命名的。 + 命名的互斥体存在并具有访问控制安全性，但用户不具有 。 + 发生了一个 Win32 错误。 + 无法创建命名的互斥体，原因可能是与其他类型的等待句柄同名。 + + 长度超过 260 个字符。 + + + 使用可指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称的 Boolean 值和当线程返回时可指示调用线程是否已赋予互斥体的初始所有权的 Boolean 值初始化 类的新实例。 + 如果为 true，则给予调用线程已命名的系统互斥体的初始所属权（如果已命名的系统互斥体是通过此调用创建的）；否则为 false。 + + 的名称。如果值为 null，则 是未命名的。 + 在此方法返回时，如果创建了局部互斥体（即，如果 为 null 或空字符串）或指定的命名系统互斥体，则包含布尔值 true；如果指定的命名系统互斥体已存在，则为 false。此参数未经初始化即被传递。 + 命名的互斥体存在并具有访问控制安全性，但用户不具有 。 + 发生了一个 Win32 错误。 + 无法创建命名的互斥体，原因可能是与其他类型的等待句柄同名。 + + 长度超过 260 个字符。 + + + 打开指定的已命名的互斥体（如果已经存在）。 + 表示已命名的系统互斥体的对象。 + 要打开的系统互斥体的名称。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 命名的 mutex 不存在。 + 发生了一个 Win32 错误。 + 已命名的互斥体存在，但用户不具备使用它所需的安全访问权限。 + 1 + + + + + + 释放 一次。 + 调用线程不拥有互斥体。 + 1 + + + 打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。 + 如果命名互斥体成功打开，则为 true；否则为 false。 + 要打开的系统互斥体的名称。 + 当此方法返回时，如果调用成功，则包含表示命名互斥体的 对象；否则为 null。该参数未经初始化即被处理。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的互斥体存在，但用户不具备使用它所需的安全访问权限。 + + + 表示用于管理资源访问的锁定状态，可实现多线程读取或进行独占式写入访问。 + + + 使用默认属性值初始化 类的新实例。 + + + 在指定锁定递归策略的情况下初始化 类的新实例。 + 枚举值之一，用于指定锁定递归策略。 + + + 获取已进入读取模式锁定状态的独有线程的总数。 + 已进入读取模式锁定状态的独有线程的数量。 + + + 释放 类的当前实例所使用的所有资源。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 尝试进入读取模式锁定状态。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 尝试进入可升级模式锁定状态。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 尝试进入写入模式锁定状态。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 减少读取模式的递归计数，并在生成的计数为 0（零）时退出读取模式。 + The current thread has not entered the lock in read mode. + + + 减少可升级模式的递归计数，并在生成的计数为 0（零）时退出可升级模式。 + The current thread has not entered the lock in upgradeable mode. + + + 减少写入模式的递归计数，并在生成的计数为 0（零）时退出写入模式。 + The current thread has not entered the lock in write mode. + + + 获取一个值，该值指示当前线程是否已进入读取模式的锁定状态。 + 如果当前线程已进入读取模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前线程是否已进入可升级模式的锁定状态。 + 如果当前线程已进入可升级模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前线程是否已进入写入模式的锁定状态。 + 如果当前线程已进入写入模式，则为 true；否则为 false。 + 2 + + + 获取一个值，该值指示当前 对象的递归策略。 + 枚举值之一，用于指定锁定递归策略。 + + + 获取当前线程进入读取模式锁定状态的次数，用于指示递归。 + 如果当前线程未进入读取模式，则为 0（零）；如果线程已进入读取模式但却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入锁定模式 n - 1 次，则为 n。 + 2 + + + 获取当前线程进入可升级模式锁定状态的次数，用于指示递归。 + 如果当前线程没有进入可升级模式，则为 0；如果线程已进入可升级模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入可升级模式 n - 1 次，则为 n。 + 2 + + + 获取当前线程进入写入模式锁定状态的次数，用于指示递归。 + 如果当前线程没有进入写入模式，则为 0；如果线程已进入写入模式却不是以递归方式进入的，则为 1；或者如果线程已经以递归方式进入写入模式 n - 1 次，则为 n。 + 2 + + + 尝试进入读取模式锁定状态，可以选择整数超时时间。 + 如果调用线程已进入读取模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入读取模式锁定状态，可以选择超时时间。 + 如果调用线程已进入读取模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 尝试进入可升级模式锁定状态，可以选择超时时间。 + 如果调用线程已进入可升级模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入可升级模式锁定状态，可以选择超时时间。 + 如果调用线程已进入可升级模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 尝试进入写入模式锁定状态，可以选择超时时间。 + 如果调用线程已进入写入模式，则为 true；否则为 false。 + 等待的毫秒数，或为 -1 ()，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 尝试进入写入模式锁定状态，可以选择超时时间。 + 如果调用线程已进入写入模式，则为 true；否则为 false。 + 等待的间隔；或为 -1 毫秒，表示无限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 获取等待进入读取模式锁定状态的线程总数。 + 等待进入读取模式的线程总数。 + 2 + + + 获取等待进入可升级模式锁定状态的线程总数。 + 等待进入可升级模式的线程总数。 + 2 + + + 获取等待进入写入模式锁定状态的线程总数。 + 等待进入写入模式的线程总数。 + 2 + + + 限制可同时访问某一资源或资源池的线程数。 + 1 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + + 大于 。 + + 为小于 1。- 或 - 小于 0。 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数，可以选择指定系统信号量对象的名称。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + 命名系统信号量对象的名称。 + + 大于 。- 或 - 长度超过 260 个字符。 + + 为小于 1。- 或 - 小于 0。 + 发生了一个 Win32 错误。 + 命名信号量存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名的信号量，可能是因为存在同名但类型不同的等待句柄。 + + + 初始化 类的新实例，并指定初始入口数和最大并发入口数，还可以选择指定系统信号量对象的名称，以及指定一个变量来接收指示是否创建了新系统信号量的值。 + 可以同时满足的信号量的初始请求数。 + 可以同时满足的信号量的最大请求数。 + 命名系统信号量对象的名称。 + 在此方法返回时，如果创建了本地信号量（即，如果 为 null 或空字符串）或指定的命名系统信号量，则包含 true；如果指定的命名系统信号量已存在，则为 false。此参数未经初始化即被传递。 + + 大于 。- 或 - 长度超过 260 个字符。 + + 为小于 1。- 或 - 小于 0。 + 发生了一个 Win32 错误。 + 命名信号量存在并具有访问控制安全性，但用户不具有 。 + 无法创建命名的信号量，可能是因为存在同名但类型不同的等待句柄。 + + + 打开指定名称为信号量（如果已经存在）。 + 一个对象，表示已命名的系统信号量。 + 要打开的系统信号量的名称。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 命名的信号量不存在。 + 发生了一个 Win32 错误。 + 已命名的信号量存在，但用户不具备使用它所需的安全访问权。 + 1 + + + + + + 退出信号量并返回前一个计数。 + 调用 方法前信号量的计数。 + 信号量计数已是最大值。 + 发生已命名信号量的 Win32 错误。 + 当前信号量表示一个已命名的系统信号量，但用户不具备 。- 或 -当前信号量表示一个已命名的系统信号量，但它未用 打开。 + 1 + + + 以指定的次数退出信号量并返回前一个计数。 + 调用 方法前信号量的计数。 + 退出信号量的次数。 + + 为小于 1。 + 信号量计数已是最大值。 + 发生已命名信号量的 Win32 错误。 + 当前信号量表示一个已命名的系统信号量，但用户不具备 权限。- 或 -当前信号量表示一个已命名的系统信号量，但它不是以 权限打开的。 + 1 + + + 打开指定名称为信号量（如果已经存在），并返回指示操作是否成功的值。 + 如果命名信号量成功打开，则为 true；否则为 false。 + 要打开的系统信号量的名称。 + 当此方法返回时，如果调用成功，则包含表示命名信号的 对象；否则为 null。该参数未经初始化即被处理。 + + 是一个空字符串。- 或 - 长度超过 260 个字符。 + + 为 null。 + 发生了一个 Win32 错误。 + 已命名的信号量存在，但用户不具备使用它所需的安全访问权。 + + + 对计数已达到最大值的信号量调用 方法时引发的异常。 + 2 + + + 使用默认值初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 对可同时访问资源或资源池的线程数加以限制的 的轻量替代。 + + + 初始化 类的新实例，以指定可同时授予的请求的初始数量。 + 可以同时授予的信号量的初始请求数。 + + 小于 0。 + + + 初始化 类的新实例，同时指定可同时授予的请求的初始数量和最大数量。 + 可以同时授予的信号量的初始请求数。 + 可以同时授予的信号量的最大请求数。 + + 小于 0，或 大于 ，或 小于等于 0。 + + + 返回一个可用于在信号量上等待的 。 + 可用于在信号量上等待的 。 + 已释放了 。 + + + 获取可以输入 对象的剩余线程数。 + 可以输入信号量的剩余线程数。 + + + 释放 类的当前实例所使用的所有资源。 + + + 释放由 占用的非托管资源，还可以另外再释放托管资源。 + 若要释放托管资源和非托管资源，则为 true；若仅释放非托管资源，则为 false。 + + + 释放 对象一次。 + + 的前一个计数。 + 当前实例已被释放。 + + 已达到其最大大小。 + + + 释放 对象指定的次数。 + + 的前一个计数。 + 退出信号量的次数。 + 当前实例已被释放。 + + 为小于 1。 + + 已达到其最大大小。 + + + 阻止当前线程，直至它可进入 为止。 + 当前实例已被释放。 + + + 阻止当前线程，直至它可进入 为止，同时使用 32 位带符号整数来指定超时。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 阻止当前线程，直至它可进入 为止，并使用 32 位带符号整数来指定超时，同时观察 。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 已取消。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + 实例已被释放，或 创建 已被释放。 + + + 阻止当前线程，直至它可进入 为止，同时观察 。 + 要观察的 标记。 + + 已取消。 + 当前实例已被释放。- 或 - 创建 已释放。 + + + 阻止当前线程，直至它可进入 为止，同时使用 来指定超时。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + semaphoreSlim 实例已处理 + + + 阻止当前线程，直至它可进入 为止，并使用 来指定超时，同时观察 。 + 如果当前线程成功进入 ，则为 true；否则为 false。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 。 + + 已取消。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + semaphoreSlim 实例已处理 创建了 的 已经被释放。 + + + 输入 的异步等待。 + 输入信号量时完成任务。 + + + 输入 的异步等待，使用 32 位带符号整数度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 在观察 时，输入 的异步等待，使用 32 位带符号整数度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 要观察的 。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 当前实例已被释放。 + + 已取消。 + + + 在观察 时，输入 的异步等待。 + 输入信号量时完成任务。 + 要观察的 标记。 + 当前实例已被释放。 + + 已取消。 + + + 输入 的异步等待，使用 度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 当前实例已被释放。 + + 是一个非 -1 的负数，而 -1 表示无限期超时 - 或 - 超时大于 。 + + + 在观察 时，输入 的异步等待，使用 度量时间间隔。 + 如果当前线程成功输入了 ，则为将通过 true 的结果一起完成的任务，否则将通过 false 的结果完成。 + 表示等待毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 要观察的 标记。 + + 是一个非 -1 的负数，而 -1 表示无限期超时- 或 -超时大于 。 + + 已取消。 + + + 表示在消息即将被调度到同步上下文时要调用的方法。 + 传递给委托的对象。 + 2 + + + 提供一个相互排斥锁基元，在该基元中，尝试获取锁的线程将在重复检查的循环中等待，直至该锁变为可用为止。 + + + 使用用于跟踪线程 ID 以改善调试的选项初始化 结构的新实例。 + 是否捕获线程 ID 并将其用于调试目的。 + + + 采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + 在调用 Enter 之前， 参数必须初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 释放锁。 + 启用线程所有权跟踪，当前线程不是此锁的所有者。 + + + 释放锁。 + 一个布尔值，该值指示是否应发出内存界定，以便将退出操作立即发布到其他线程。 + 启用线程所有权跟踪，当前线程不是此锁的所有者。 + + + 获取锁当前是否已由任何线程占用。 + 如果锁当前已由任何线程占用，则为 true；否则为 false。 + + + 获取锁是否已由当前线程占用。 + 如果锁已由当前线程占用，则为 true；否则为 false。 + 禁用线程所有权跟踪。 + + + 获取是否已为此实例启用了线程所有权跟踪。 + 如果已为此实例启用了线程所有权跟踪，则为 true；否则为 false。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 尝试采用可靠的方式获取锁，这样，即使在方法调用中发生异常的情况下，都能采用可靠的方式检查 以确定是否已获取锁。 + 表示等待的毫秒数的 ，或表示 -1 毫秒（无限期等待）的 。 + 如果已获取锁，则为 true，否则为 false。调用此方法前，必须将 始化为 false。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 毫秒。 + 在调用 TryEnter 之前， 参数必须在初始化为 false。 + 线程所有权跟踪已启用，当前线程已获取此锁定。 + + + 提供对基于自旋的等待的支持。 + + + 获取已对此实例调用 的次数。 + 返回一个整数，该整数表示已对此实例调用 的次数。 + + + 获取对 的下一次调用是否将产生处理器，同时触发强制上下文切换。 + 对 的下一次调用是否将产生处理器，同时触发强制上下文切换。 + + + 重置自旋计数器。 + + + 执行单一自旋。 + + + 在指定条件得到满足之前自旋。 + 在返回 true 之前重复执行的委托。 + + 参数为 null。 + + + 在指定条件得到满足或指定超时过期之前自旋。 + 如果条件在超时时间内得到满足，则为 true；否则为 false + 在返回 true 之前重复执行的委托。 + 等待的毫秒数，或为 (-1)，表示无限期等待。 + + 参数为 null。 + + 是一个非 -1 的负数，而 -1 表示无限期超时。 + + + 在指定条件得到满足或指定超时过期之前自旋。 + 如果条件在超时时间内得到满足，则为 true；否则为 false + 在返回 true 之前重复执行的委托。 + 一个 ，表示等待的毫秒数；或者一个 TimeSpan，表示 -1 毫秒（无限期等待）。 + + 参数为 null。 + + 是 -1 毫秒之外的负数，表示无限超时或者超时大于 。 + + + 提供在各种同步模型中传播同步上下文的基本功能。 + 2 + + + 创建 类的新实例。 + + + 在派生类中重写时，创建同步上下文的副本。 + 一个新 对象。 + 2 + + + 获取当前线程的同步上下文。 + 一个 对象，它表示当前同步上下文。 + 1 + + + 在派生类中重写时，响应操作已完成的通知。 + + + 在派生类中重写时，响应操作已开始的通知。 + + + 在派生类中重写时，将异步消息分派到同步上下文。 + 要调用的 委托。 + 传递给委托的对象。 + 2 + + + 在派生类中重写时，将同步消息分派到同步上下文。 + 要调用的 委托。 + 传递给委托的对象。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 设置当前同步上下文。 + 要设置的 对象。 + 1 + + + + + + 当某个方法请求调用方拥有给定 Monitor 上的锁时将引发该异常，而且由不拥有该锁的调用方调用此方法。 + 2 + + + 使用默认属性初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + 提供数据的线程本地存储。 + 指定每线程的已存储数据的类型。 + + + 初始化 实例。 + + + 初始化 实例。 + 是否要跟踪实例上的所有值集并通过 属性将其公开。 + + + 使用指定的 函数初始化 实例。 + 如果在 之前尚未初始化的情况下尝试对其进行检索，则会调用 生成延迟初始化的值。 + + 是 null 引用（在 Visual Basic 中为 Nothing）。 + + + 使用指定的 函数初始化 实例。 + 如果在 之前尚未初始化的情况下尝试对其进行检索，则会调用 生成延迟初始化的值。 + 是否要跟踪实例上的所有值集并通过 属性将其公开。 + + 为 null 引用（在 Visual Basic 中为 Nothing）。 + + + 释放由 类的当前实例占用的所有资源。 + + + 释放此 实例使用的资源。 + 一个布尔值，该值指示是否由于调用 的原因而调用此方法。 + + + 释放此 实例使用的资源。 + + + 获取是否在当前线程上初始化 。 + 如果在当前线程上初始化 ，则为 true；否则为 false。 + 已释放 实例。 + + + 创建并返回当前线程的此实例的字符串表示形式。 + 对 调用 的结果。 + 已释放 实例。 + 当前线程的 为 null 引用（Visual Basic 中为 Nothing）。 + 初始化函数尝试以递归方式引用 。 + 没有提供默认构造函数，且没有提供值工厂。 + + + 获取或设置当前线程的此实例的值。 + 返回此 ThreadLocal 负责初始化的对象的实例。 + 已释放 实例。 + 初始化函数尝试以递归方式引用 。 + 没有提供默认构造函数，且没有提供值工厂。 + + + 获取当前由已经访问此实例的所有线程存储的所有值的列表。 + 访问此实例由所有线程存储的当前的所有值的列表。 + 已释放 实例。 + + + 包含用于执行易失内存操作的方法。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 读取指定字段的值。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 读取的值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。 + 要读取的字段。 + + + 从指定的字段读取对象引用。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之后，则处理器无法将其移至此方法之前。 + 对读取的 的引用。无论处理器的数目或处理器缓存的状态如何，该引用都是由计算机的任何处理器写入的最新引用。 + 要读取的字段。 + 要读取的字段的类型。此类型必须是引用类型，而不是值类型。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入如下所示的防止处理器重新对内存操作进行排序的内存栅：如果内存操作出现在代码中的此方法之前，则处理器不能将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的值写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将值写入的字段。 + 要写入的值。立即写入一个值，以使该值对计算机中的所有处理器都可见。 + + + 将指定的对象引用写入指定字段。在需要进行此操作的系统上，插入防止处理器重新对内存操作进行排序的内存屏障，如下所示：如果读取或写入操作在代码中出现在此方法之前，则处理器无法将其移至此方法之后。 + 将对象引用写入的字段。 + 要写入的对象引用。立即写入一个引用，以使该引用对计算机中的所有处理器都可见。 + 要写入的字段的类型。此类型必须是引用类型，而不是值类型。 + + + 在尝试打开不存在的系统互斥体或信号量时引发的异常。 + 2 + + + 使用默认值初始化 类的新实例。 + + + 使用指定的错误消息初始化 类的新实例。 + 解释异常原因的错误信息。 + + + 使用指定错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。 + 解释异常原因的错误信息。 + 导致当前异常的异常。如果 参数不为 null，则当前异常将在处理内部异常的 catch 块中引发。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/netstandard1.3/zh-hant/System.Threading.xml b/packages/System.Threading.4.3.0/ref/netstandard1.3/zh-hant/System.Threading.xml new file mode 100644 index 000000000..9ff1745d9 --- /dev/null +++ b/packages/System.Threading.4.3.0/ref/netstandard1.3/zh-hant/System.Threading.xml @@ -0,0 +1,1885 @@ + + + + System.Threading + + + + 當一個執行緒取得另一個執行緒已放棄，但是結束時並未釋放的 物件時，所擲回的例外狀況。 + 1 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用已放棄 Mutex 的指定索引 (若適用的話) 以及表示此 Mutex 的 物件，初始化 類別的新執行個體 。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和內部例外狀況初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 使用指定的錯誤訊息、內部例外狀況、已放棄 Mutex 的索引 (若適用的話)，以及表示此 Mutex 的 物件，初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 以指定的錯誤訊息、已放棄 Mutex 的索引 (若適用的話) 以及放棄的 Mutex 初始化 類別的新執行個體。 + 解釋發生例外狀況原因的錯誤訊息。 + 如果針對 方法擲回例外狀況，則為等候控制代碼陣列中已放棄 Mutex 的索引；如果針對 或 方法擲回例外狀況，則為 -1。 + + 物件，表示放棄的 Mutex。 + + + 取得造成例外狀況的已放棄 Mutex (若為已知)。 + + 物件，表示已放棄的 Mutex；若無法識別已放棄的 Mutex，則為 null。 + 1 + + + 取得造成例外狀況之已放棄 Mutex 的索引 (若為已知)。 + 等候控制代碼陣列中的索引 (已傳遞給 物件的 方法)，表示已放棄的 Mutex；如果無法判斷已放棄 Mutex 的索引，則為 -1。 + 1 + + + 表示對於指定的非同步控制流程為本機的環境資料，例如非同步方法。 + 環境資料的類型。 + + + 具現化不會接收變更告知的 執行個體。 + + + 具現化會接收變更告知的 本機執行個體。 + 每當在任何執行緒上變更目前的值就會呼叫委派。 + + + 取得或設定環境資料的值。 + 環境資料的值。 + + + 會提供資料變更資訊給 執行個體的的類別，該執行個體會註冊變更告知。 + 資料的類型。 + + + 取得資料目前的值。 + 資料目前的值。 + + + 取得資料先前的值。 + 資料先前的值。 + + + 傳回值，指出值是否會因為執行內容的變更而變更。 + 如果值會因為執行內容的變更而變更，則為 true；否則為 false。 + + + 向等候的執行緒通知發生事件。此類別無法被繼承。 + 2 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值，初始化 類別的新執行個體。 + true 表示初始狀態設定為已收到信號，false 表示初始狀態設定為未收到信號。 + + + 允許多項工作在多個階段中以平行方式來合作處理某個演算法。 + + + 初始化 類別的新執行個體。 + 參與執行緒的數目。 + + 小於 0 或大於 32,767。 + + + 初始化 類別的新執行個體。 + 參與執行緒的數目。 + 要在每個階段之後執行的 。可以傳遞 null (在 Visual Basic 中為 Nothing) 表示不執行任何動作。 + + 小於 0 或大於 32,767。 + + + 通知 ，表示還會有一個其他參與者。 + 新參與者將第一次參與其中的屏障階段編號。 + 目前的執行個體已經處置。 + 加入參與者會造成屏障的參與者計數超過 32,767。-或-此方法是從 post-phase 動作中叫用。 + + + 通知 ，表示還會有多個其他參與者。 + 新參與者將第一次參與其中的屏障階段編號。 + 要加入至屏障的其他參與者數目。 + 目前的執行個體已經處置。 + + 小於 0。-或-加入 參與者會造成屏障的參與者計數超過 32,767。 + 此方法是從 post-phase 動作中叫用。 + + + 取得屏障目前階段的編號。 + 傳回屏障目前階段的編號。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + 此方法是從 post-phase 動作中叫用。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示同時釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得在屏障中的參與者總數。 + 傳回在屏障中的參與者總數。 + + + 取得在目前階段中尚未發出訊號的屏障中參與者數目。 + 傳回在目前階段中尚未發出訊號的屏障中參與者數目。 + + + 通知 ，表示會減少一個參與者。 + 目前的執行個體已經處置。 + 屏障已經有 0 個參與者。-或-此方法是從 post-phase 動作中叫用。 + + + 通知 ，表示會減少一些參與者。 + 要從屏障中移除的其他參與者數目。 + 目前的執行個體已經處置。 + + 小於 0。 + 屏障已經有 0 個參與者。-或-此方法是從 post-phase 動作中叫用。 -或-目前的參與者計數少於指定的 participantCount + 參與者總計數小於指定的 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障。 + 目前的執行個體已經處置。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + 所有參與執行緒皆已呼叫 SignalAndWait 後，如果從 Barrier 的階段後動作擲回例外，會將例外狀況包裝在 BarrierPostPhaseException 中，並擲回所有參與執行緒。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障 (使用 32 位元帶正負號的整數以測量逾時)。 + 如果所有參與者已在指定時間內達到屏障則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + 所有參與執行緒皆已呼叫 SignalAndWait 後，如果從 Barrier 的階段後動作擲回例外，會將例外狀況包裝在 BarrierPostPhaseException 中，並擲回所有參與執行緒。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達 (使用 32 位元帶正負號的整數以測量逾時)，同時觀察取消語彙基元。 + 如果所有參與者已在指定時間內達到屏障則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達，同時觀察取消語彙基元。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達屏障 (使用 物件以測量時間間隔)。 + 如果所有其他參與者已達到屏障則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 32,767 的逾時。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 發出訊號，表示參與者已到達屏障，並且在等候所有其他參與者到達 (使用 物件以測量時間間隔)，同時觀察取消語彙基元。 + 如果所有其他參與者已達到屏障則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時。 + 此方法是從 post-phase 動作中叫用，屏障目前有 0 個參與者，或者使用該屏障的執行緒數量多於註冊為參與者的數量。 + + + 在 的後續階段動作失敗時所擲回的例外狀況。 + + + 以系統提供的錯誤說明訊息，初始化 類別的新執行個體。 + + + 使用指定的內部例外狀況，初始化 類別的新執行個體。 + 導致目前例外狀況的例外。 + + + 使用指定的錯誤說明訊息，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已經為目前系統的文化特性當地語系化。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 表示要在新內容裡面呼叫的方法。 + 物件，它包含回呼方法所使用的資訊。 + 1 + + + 代表當計數到達零時收到訊號的同步處理原始物件。 + + + 使用指定的計數，初始化 類別的新執行個體。 + 設定 時最初所需的訊號次數。 + + 小於 0。 + + + 將 目前的計數遞增一。 + 目前的執行個體已經處置。 + 目前的執行個體已經設定。-或- 等於或大於 。 + + + 將 目前的計數遞增所指定的值。 + + 所要增加的值。 + 目前的執行個體已經處置。 + + 小於或等於 0。 + 目前的執行個體已經設定。-或-計數遞增 後， 會等於或大於 + + + 取得設定事件時需要的剩餘訊號次數。 + 設定事件時需要的剩餘訊號次數。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示同時釋放 Managed 和 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得設定事件一開始時所需要的訊號次數。 + 設定事件一開始時所需要的訊號次數。 + + + 判斷事件是否已設定。 + 如果已設定事件則為 true，否則為 false。 + + + 將 重設為 的值。 + 目前的執行個體已經處置。 + + + 將 屬性重設為指定的值。 + 設定 時所需的訊號次數。 + 目前的執行個體已經處置。 + + 小於 0。 + + + 向 註冊訊號，並遞減 的值。 + 如果訊號使計數到達零且設定事件則為 true，否則為 false。 + 目前的執行個體已經處置。 + 目前的執行個體已經設定。 + + + 向 註冊多個訊號，並將 的值遞減指定的數量。 + 如果信號使計數到達零且設定事件則為 true，否則為 false。 + 要註冊的訊號數。 + 目前的執行個體已經處置。 + + 小於 1。 + 目前的執行個體已經設定。或 大於 。 + + + 嘗試將 遞增一。 + 如果遞增成功則為 true，否則為 false。如果 已經位於零，這個方法將傳回 false。 + 目前的執行個體已經處置。 + + 等於 。 + + + 嘗試以指定的值遞增 。 + 如果遞增成功則為 true，否則為 false。如果 已經為零，這將傳回 false。 + + 所要增加的值。 + 目前的執行個體已經處置。 + + 小於或等於 0。 + 目前的執行個體已經設定。-或- + 等於或大於 。 + + + 封鎖目前的執行緒，直到設定了 為止。 + 目前的執行個體已經處置。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 32 位元帶正負號的整數以測量逾時)。 + 如果已設定 則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 32 位元帶正負號的整數以測量逾時)，同時觀察 。 + 如果已設定 則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到設定了 為止，同時觀察 。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 以測量逾時)。 + 如果已設定 則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 封鎖目前的執行緒，直到設定了 為止 (使用 以測量逾時)，同時觀察 。 + 如果已設定 則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + 目前的執行個體已經處置。-或者-已處置建立 的 。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 取得用來等候事件獲得設定的 。 + + ，其會用於等候事件獲得設定。 + 目前的執行個體已經處置。 + + + 表示收到信號之後，是否會自動或手動重設 。 + 2 + + + 收到信號通知時， 在釋放單一執行緒後會自動重設。如果沒有任何執行緒在等待，則 會保持收到信號的狀態，直到有執行緒被封鎖為止，接著就釋放這個執行緒並將自己重設。 + + + 收到信號通知時， 會釋放所有正在等待的執行緒，並保持收到信號的狀態，直到被手動重設為止。 + + + 表示執行緒同步處理事件。 + 2 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號，以及是以自動還是手動方式來重設。 + true 表示初始狀態設定為已收到信號，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號 (如果它是因這個呼叫而建立)、是以自動還是手動方式進行重設，以及系統同步處理事件的名稱。 + true 表示初始狀態設定為已收到信號 (如果具名事件是因這個呼叫而建立)，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + 整個系統的同步處理事件名稱。 + 發生 Win32 錯誤。 + 具名的事件已存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的事件，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 長度超過 260 個字元。 + + + 初始化 類別的新執行個體、指定等候控制代碼是否一開始就會收到信號 (如果它是因這個呼叫而建立)、是以自動還是手動方式進行重設、系統同步處理事件的名稱，以及呼叫之後的布林變數值 (此值可指示是否已建立具名系統事件)。 + true 表示初始狀態設定為已收到信號 (如果具名事件是因這個呼叫而建立)，false 表示初始狀態設定為未收到信號。 + 其中一個 值，判斷是以自動還是手動方式重設事件。 + 整個系統的同步處理事件名稱。 + 這個方法傳回時，如果已建立本機事件 (也就是說，如果 為 null 或空字串)，或是已建立指定的已命名系統事件，則會包含 true；如果指定的已命名系統事件已存在則為 false。這個參數會以未初始化的狀態傳遞。 + 發生 Win32 錯誤。 + 具名的事件已存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的事件，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 長度超過 260 個字元。 + + + 開啟指定的具名同步處理事件 (如果已經存在)。 + 表示具名系統事件的物件。 + 要開啟的系統同步處理事件的名稱。 + + 為空字串。-或- 長度超過 260 個字元。 + + 為 null。 + 具名系統事件不存在。 + 發生 Win32 錯誤。 + 具名事件存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 將事件的狀態設定為未收到信號，會造成執行緒封鎖。 + 如果作業成功，則為 true，否則為 false . + 之前在這個 上呼叫 方法。 + 2 + + + 將事件的狀態設定為未收到信號，讓一個或多個等候執行緒繼續執行。 + 如果作業成功，則為 true，否則為 false . + 之前在這個 上呼叫 方法。 + 2 + + + 開啟指定的具名同步處理事件 (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名同步處理事件，則為 true，否則為 false。 + 要開啟的系統同步處理事件的名稱。 + 這個方法傳回時，如果呼叫成功，則包含物件，此物件代表具名同步處理事件，如果呼叫失敗，則為null。這個參數會被視為未初始化。 + + 為空字串。-或- 長度超過 260 個字元。 + + 為 null。 + 發生 Win32 錯誤。 + 具名事件已存在，但是使用者沒有所需的安全性存取權。 + + + 管理目前執行緒的執行內容。此類別無法被繼承。 + 2 + + + 從目前的執行緒擷取執行內容。 + + 物件，表示目前執行緒的執行內容。 + 1 + + + 在目前執行緒上的指定執行內容中執行方法。 + 要設定的 。 + + 委派，表示要在所提供執行內容中執行的方法。 + 要傳遞至回呼 (Callback) 方法的物件。 + + 為 null。-或- 不是透過擷取作業取得。-或-已經將 當做 呼叫的引數使用。 + 1 + + + + + + 為多重執行緒共用的變數提供不可部分完成的作業 (Atomic Operation)。 + 2 + + + 將兩個 32 位元整數加相，並以總和取代第一個整數，成為不可部分完成的作業。 + 新值儲存於 。 + 包含要加入的第一個值的變數。這兩個值的總和會存放在 中。 + 要加入 的整數的值。 + The address of is a null pointer. + 1 + + + 將兩個 64 位元整數加相，並以總和取代第一個整數，成為不可部分完成的作業。 + 新值儲存於 。 + 包含要加入的第一個值的變數。這兩個值的總和會存放在 中。 + 要加入 的整數的值。 + The address of is a null pointer. + 1 + + + 比較兩個雙精確度浮點數是否相等；如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個 32 位元帶正負號的整數是否相等，如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個 64 位元帶正負號的整數是否相等，如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較兩個平台特定的控制代碼或指標是否相等；如果相等，則取代第一個。 + + 中的原始值。 + 目的端 ，其值會與 的值進行比較，且可能被 所取代。 + + ，當比較的結果相等時會取代目的端值。 + + ，會與 的值相比較。 + The address of is a null pointer. + 1 + + + 比較兩個物件的參考是否相等；如果相等，則取代第一個物件。 + + 中的原始值。 + 目的端物件，此物件會與 進行比較且可能被取代。 + 當比較的結果相等時，會取代目的端物件的物件。 + 與 的物件相比較的物件。 + The address of is a null pointer. + 1 + + + 比較兩個單精確度浮點數是否相等；如果相等，則取代第一個值。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + The address of is a null pointer. + 1 + + + 比較指定參考類型 的兩個執行個體是否相等；如果相等，則取代第一個。 + + 中的原始值。 + 目的端，其值會與 進行比較且可能已被取代。此為參考參數 (在 C# 中為 ref，在 Visual Basic 中為 ByRef)。 + 當比較的結果相等時，會取代目的端值的值。 + 與 的值比較的值。 + 要用於 、 和 的類型。此類型必須是參考類型。 + The address of is a null pointer. + + + 遞減特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞減後的值。 + 值會被遞減的變數。 + The address of is a null pointer. + 1 + + + 遞減特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞減後的值。 + 值會被遞減的變數。 + The address of is a null pointer. + 1 + + + 將雙精確度浮點數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將 32 位元帶正負號的整數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將 64 位元帶正負號的整數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將平台特定的控制代碼或指標設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將物件設定為指定值，然後傳回原始物件的參考，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將單精確度浮點數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。 + + 參數要設定成的值。 + The address of is a null pointer. + 1 + + + 將指定類型 的變數設定為指定值，然後傳回原始值，成為不可部分完成的作業。 + + 的原始值。 + 要設定為特定值的變數。此為參考參數 (在 C# 中為 ref，在 Visual Basic 中為 ByRef)。 + + 參數要設定成的值。 + 要用於 和 的類型。此類型必須是參考類型。 + The address of is a null pointer. + + + 遞增特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞增後的值。 + 值會被遞增的變數。 + The address of is a null pointer. + 1 + + + 遞增特定變數並將結果儲存起來，成為不可部分完成的作業。 + 遞增後的值。 + 值會被遞增的變數。 + The address of is a null pointer. + 1 + + + 同步處理記憶體存取，如下所示：執行目前執行緒的處理器無法以下列方式重新排列指示：呼叫 之前的記憶體存取在呼叫 後的記憶體存取之後執行。 + + + 傳回 64 位元的值 (載入為不可部分完成的作業)。 + 載入的值。 + 要載入的 64 位元值。 + 1 + + + 提供延遲初始化常式。 + + + 如果目標參考型別尚未初始化，則使用該型別的預設建構函式來進行初始化。 + 型別 的已初始化參考。 + 要初始化 (如果尚未初始化) 的型別 的參考。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用其預設建構函式來初始化目標的參考型別或實值型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考或實值。 + 布林值的參考，這個值可判斷目標是否已初始化。 + 物件的參考，這個物件用來當做初始化 時的互斥鎖定。如果 為 null，則具現化新的物件。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用指定的函式來初始化目標的參考或實值型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考或實值。 + 布林值的參考，這個值可判斷目標是否已初始化。 + 物件的參考，這個物件用來當做初始化 時的互斥鎖定。如果 為 null，則具現化新的物件。 + 呼叫來初始化參考或值的函式。 + 要初始化之參考的型別。 + 缺少存取型別 之建構函式的使用權限。 + + 型別沒有預設的建構函式。 + + + 如果目標型別尚未初始化，則使用指定的函式來初始化目標的參考型別。 + 型別 的已初始化實值。 + 要初始化 (如果尚未初始化) 的型別 的參考。 + 呼叫來初始化參考的函式。 + 要初始化之參考的參考型別。 + + 型別沒有預設的建構函式。 + + 傳回 null (在 Visual Basic 中為 Nothing)。 + + + 當遞迴進入鎖定與鎖定的遞迴原則不相符時，擲回的例外狀況。 + 2 + + + 以系統提供的錯誤說明訊息，初始化 類別的新執行個體。 + 2 + + + 使用指定的錯誤說明訊息，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已針對目前系統的文化特性，執行過當地語系化。 + 2 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 說明例外狀況的訊息。這個建構函式的呼叫端必須確保這個字串已針對目前系統的文化特性，執行過當地語系化。 + 造成目前例外狀況的例外狀況。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + 2 + + + 指定相同的執行緒是否可以多次進入鎖定。 + + + 如果執行緒嘗試遞迴地進入鎖定，則會擲回例外狀況。某些類別可能會在此設定有效時允許特定的遞迴。 + + + 執行緒可以遞迴地進入鎖定。某些類別可能會限制此功能。 + + + 告知一個以上的等候中執行緒已發生事件。此類別無法被繼承。 + 2 + + + 使用布林值 (Boolean) 來初始化 類別的新執行個體，指出初始狀態是否設定為信號狀態。 + 如果初始狀態設定為信號狀態，為 true；初始狀態設定為非信號狀態則為 false。 + + + 提供 的精簡版本。 + + + 使用未收到訊號的初始狀態來初始化 類別的新執行個體。 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值，初始化 類別的新執行個體。 + true 表示會將初始狀態設定為已收到訊號，false 表示會將初始狀態設定為未收到訊號。 + + + 使用表示是否要將初始狀態設定為已收到訊號的布林值以及指定的微調計數，初始化 類別的新執行個體。 + true 表示會將初始狀態設定為已收到訊號，false 表示會將初始狀態設定為未收到訊號。 + 在回到以核心為基礎的等候作業之前進行微調等候的次數。 + + is less than 0 or greater than the maximum allowed value. + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 與 Unmanaged 資源，false 表示只釋放 Unmanaged 資源。 + + + 取得值，表示事件是否已設定。 + 如果已設定事件則為 true，否則為 false。 + + + 將事件的狀態設定為未收到信號，會造成執行緒封鎖。 + The object has already been disposed. + + + 將事件的狀態設定為已收到訊號，讓正在等候該事件的一或多個執行緒繼續執行。 + + + 取得在回到以核心為基礎的等候作業之前進行微調等候的次數。 + 傳回在回到以核心為基礎的等候作業之前進行微調等候的次數。 + + + 封鎖目前的執行緒，直到設定了目前的 為止。 + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止 (使用 32 位元帶正負號的整數以測量時間間隔)。 + 如果設定了 ，則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 32 位元帶正負號的整數以測量時間間隔，同時觀察 。 + 如果設定了 ，則為 true，否則為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + was canceled. + + is a negative number other than -1, which represents an infinite time-out. + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 封鎖目前的執行緒，直到目前的 收到訊號為止，同時觀察 。 + 要觀察的 。 + The maximum number of waiters has been exceeded. + + was canceled. + The object has already been disposed or the that created has been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 以測量時間間隔。 + 如果設定了 ，則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed. + + + 封鎖目前的執行緒，直到設定了目前的 為止，並使用 以量測時間間隔，同時觀察 。 + 如果設定了 ，則為 true，否則為 false。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 要觀察的 。 + + was canceled. + + is a negative number other than -1 milliseconds, which represents an infinite time-out. -or-The number of milliseconds in is greater than . + The maximum number of waiters has been exceeded. + The object has already been disposed or the that created has been disposed. + + + 取得這個 的基礎 物件。 + 這個 的基礎 事件物件。 + + + 提供一套機制，同步處理物件的存取。 + 2 + + + 取得指定物件的獨佔鎖定。 + 要從其上取得監視器鎖定的物件。 + + 參數為 null。 + 1 + + + 取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要等候的物件。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。注意：如果沒有發生例外狀況，這個方法的輸出一律為 true。 + + 的輸入為 true。 + + 參數為 null。 + + + 釋出指定物件的獨佔鎖定。 + 要從其上釋出鎖定的物件。 + + 參數為 null。 + 目前執行緒沒有指定物件的鎖定。 + 1 + + + 判斷目前執行緒是否保持鎖定指定的物件。 + 如果目前的執行緒持有 的鎖定，則為 true；否則為 false。 + 要測試的物件。 + + 為 null。 + + + 通知等候佇列中的執行緒，鎖定物件的狀態有所變更。 + 執行緒正等候的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 1 + + + 通知所有等候中的執行緒，物件的狀態有所變更。 + 送出 Pulse 的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 1 + + + 嘗試取得指定物件的獨佔鎖定。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + + 參數為 null。 + 1 + + + 嘗試取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + + 嘗試取得指定物件的獨佔鎖定 (在指定的毫秒數時間內)。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + 等候鎖定的毫秒數。 + + 參數為 null。 + + 為負，且不等於 。 + 1 + + + 嘗試在指定的毫秒數內取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 等候鎖定的毫秒數。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + 為負，且不等於 。 + + + 嘗試取得指定物件的獨佔鎖定 (在指定的時間內)。 + 如果目前執行緒取得鎖定，則為 true；否則為 false。 + 要取得鎖定的物件。 + + ，代表等候鎖定的時間量。-1 毫秒的值會指定無限期等候。 + + 參數為 null。 + + 的毫秒值為負且不等於 (-1 毫秒) 或大於 。 + 1 + + + 嘗試在指定的時間內取得指定之物件的獨佔鎖定，並且完整設定值，指出是否採用鎖定。 + 要取得鎖定的物件。 + 等候鎖定的時間長度。-1 毫秒的值會指定無限期等候。 + 嘗試取得鎖定的結果 (以傳址方式傳遞)。輸入必須是 false。如果已取得鎖定，輸出就是 true；否則輸出為 false。嘗試取得鎖定期間，即使發生例外狀況，仍然會設定輸出。 + + 的輸入為 true。 + + 參數為 null。 + + 的毫秒值為負且不等於 (-1 毫秒) 或大於 。 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。 + 如果由於呼叫端重新取得指定物件的鎖定而傳回呼叫，則為 true。如果鎖定不被重新取得，則這個方法不會傳回。 + 要等候的物件。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + 1 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。如果超過指定的逾時間隔時間，執行緒會進入就緒序列。 + 如果在經過指定的時間之前重新取得鎖定，則為 true；如果在經過指定的時間之後重新取得鎖定，則為 false。要等到重新取得鎖定之後，此方法才會傳回。 + 要等候的物件。 + 在執行緒進入就緒佇列之前要等候的毫秒數。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + + 參數的值為負，且不等於 。 + 1 + + + 釋出物件的鎖並且封鎖目前的執行緒，直到這個執行緒重新取得鎖定為止。如果超過指定的逾時間隔時間，執行緒會進入就緒序列。 + 如果在經過指定的時間之前重新取得鎖定，則為 true；如果在經過指定的時間之後重新取得鎖定，則為 false。要等到重新取得鎖定之後，此方法才會傳回。 + 要等候的物件。 + + ，代表在執行緒進入就緒佇列之前要等候的時間量。 + + 參數為 null。 + 呼叫執行緒沒有指定物件的鎖定。 + 叫用 Wait 的執行緒稍後會從等候狀態被插斷。這會當另一個執行緒呼叫這個執行緒的 方法時發生。 + + 參數的毫秒值為負，且不表示 (-1 毫秒)，或大於 。 + 1 + + + 同步處理原始物件，該物件也可用於進行處理序之間的同步處理。 + 1 + + + 使用預設屬性，初始化 類別的新執行個體。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值，初始化 類別的新執行個體。 + true 表示將 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值，以及代表 Mutex 名稱的字串，初始化 類別的新執行個體。 + true 表示如果這個呼叫的結果建立了具名系統 Mutex，則將具名系統 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + 的名稱。如果值是 null，則 未命名。 + 具名的 Mutex 存在，而且具有存取控制安全性，但是使用者沒有 。 + 發生 Win32 錯誤。 + 無法建立具名的 Mutex，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 长度超过 260 个字符。 + + + 使用表示呼叫執行緒是否應該具有 Mutex 的初始擁有權的布林值、代表 Mutex 名稱的字串，以及當方法傳回時表示是否將 Mutex 的初始擁有權授與呼叫執行緒的布林值，初始化 類別的新執行個體。 + true 表示如果這個呼叫的結果建立了具名系統 Mutex，則將具名系統 Mutex 的初始擁有權授與呼叫執行緒，否則為 false。 + + 的名稱。如果值是 null，則 未命名。 + 當這個方法傳回時，如果已建立本機 Mutex (也就是說，如果 為 null 或空字串)，或是已建立指定的具名系統 Mutex，則會包含 true 的布林值；如果指定的具名系統 Mutex 已存在，則為 false。這個參數會以未初始化的狀態傳遞。 + 具名的 Mutex 存在，而且具有存取控制安全性，但是使用者沒有 。 + 發生 Win32 錯誤。 + 無法建立具名的 Mutex，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + 长度超过 260 个字符。 + + + 開啟指定的具名 mutex (如果已經存在)。 + 表示具名系統 Mutex 的物件。 + 要開啟的系統 Mutex 的名稱。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 具名 Mutex 不存在。 + 發生 Win32 錯誤。 + 具名 Mutex 存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 釋出 一次。 + 呼叫執行緒並不擁有 Mutex。 + 1 + + + 開啟指定的具名 mutex (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名 Mutex，則為 true，否則為 false。 + 要開啟的系統 Mutex 的名稱。 + 當這個方法傳回時，如果呼叫成功，則包含代表具名 Mutex 的 物件；如果呼叫失敗，則為 null。這個參數會被視為未初始化。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 發生 Win32 錯誤。 + 具名 Mutex 存在，但是使用者並沒有使用它所需的安全性存取權。 + + + 代表鎖定，用來管理資源存取，允許多個執行緒的讀取權限或獨佔寫入權限。 + + + 使用預設屬性值，初始化 類別的新執行個體。 + + + 指定鎖定遞迴原則，初始化 類別的新執行個體。 + 一個列舉值，指定鎖定遞迴原則。 + + + 取得已進入讀取模式鎖定狀態的唯一執行緒總數。 + 已進入讀取模式鎖定狀態的唯一執行緒數目。 + + + 釋放 類別目前的執行個體所使用的全部資源。 + + is greater than zero. -or- is greater than zero. -or- is greater than zero. + 2 + + + 嘗試進入讀取模式的鎖定。 + The property is and the current thread has already entered read mode. -or-The current thread may not acquire the read lock when it already holds the write lock. -or-The recursion number would exceed the capacity of the counter.This limit is so large that applications should never encounter it. + The object has been disposed. + + + 嘗試進入可升級模式的鎖定狀態。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 嘗試進入寫入模式的鎖定。 + The property is and the current thread has already entered the lock in any mode. -or-The current thread has entered read mode, so trying to enter the lock in write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The object has been disposed. + + + 減少讀取模式遞迴的計數，如果得出的計數為 0 (零)，則結束讀取模式。 + The current thread has not entered the lock in read mode. + + + 減少可升級模式遞迴的計數，如果得出的計數為 0 (零)，則結束可升級模式。 + The current thread has not entered the lock in upgradeable mode. + + + 減少寫入模式遞迴的計數，如果得出的計數為 0 (零)，則結束寫入模式。 + The current thread has not entered the lock in write mode. + + + 取得值，表示目前執行緒是否已進入讀取模式的鎖定。 + 如果目前執行緒已進入讀取模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前執行緒是否已進入可升級模式的鎖定。 + 如果目前執行緒已進入可升級模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前執行緒是否已進入寫入模式的鎖定。 + 如果目前執行緒已進入寫入模式，則為 true；否則為 false。 + 2 + + + 取得值，表示目前 物件的遞迴原則。 + 一個列舉值，指定鎖定遞迴原則。 + + + 取得目前執行緒已進入讀取模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入讀取模式，則為 0 (零)；如果執行緒已進入讀取模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入鎖定 n - 1 次，則為 n。 + 2 + + + 取得目前執行緒已進入可升級模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入可升級模式，則為 0；如果執行緒已進入可升級模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入可升級模式 n - 1 次，則為 n。 + 2 + + + 取得目前執行緒已進入寫入模式鎖定的次數，做為遞迴的表示。 + 如果目前執行緒尚未進入寫入模式，則為 0；如果執行緒已進入寫入模式，但是尚未遞迴進入該模式，則為 1；如果執行緒已遞迴進入寫入模式 n - 1 次，則為 n。 + 2 + + + 嘗試以選用的整數逾時，進入讀取模式的鎖定狀態。 + 如果呼叫執行緒已進入讀取模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在讀取模式下進入鎖定狀態。 + 如果呼叫執行緒已進入讀取模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 嘗試以選用的逾時，在可升級模式下進入鎖定狀態。 + 如果呼叫執行緒已進入可升級模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在可升級模式下進入鎖定狀態。 + 如果呼叫執行緒已進入可升級模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter upgradeable mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 嘗試以選用的逾時，在寫入模式下進入鎖定狀態。 + 如果呼叫執行緒已進入寫入模式，則為 true；否則為 false。 + 要等候的毫秒數；若要永遠等候，則為 -1 ()。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to (-1), which is the only negative value allowed. + The object has been disposed. + + + 嘗試以選用的逾時，在寫入模式下進入鎖定狀態。 + 如果呼叫執行緒已進入寫入模式，則為 true；否則為 false。 + 等待的間隔，或 -1 毫秒無限期等待。 + The property is and the current thread has already entered the lock. -or-The current thread initially entered the lock in read mode, and therefore trying to enter write mode would create the possibility of a deadlock. -or-The recursion number would exceed the capacity of the counter.The limit is so large that applications should never encounter it. + The value of is negative, but it is not equal to -1 milliseconds, which is the only negative value allowed.-or-The value of is greater than milliseconds. + The object has been disposed. + + + 取得等待進入讀取模式鎖定狀態的執行緒總數。 + 等待進入讀取模式的執行緒總數。 + 2 + + + 取得等待進入可升級模式鎖定狀態的執行緒總數。 + 等待進入可升級模式的執行緒總數。 + 2 + + + 取得等待進入寫入模式鎖定狀態的執行緒總數。 + 等待進入寫入模式的執行緒總數。 + 2 + + + 限制可以同時存取資源或資源集區的執行緒數目。 + 1 + + + 初始化 類別的新執行個體，以及指定並行項目的最大數目及選擇性地保留某些項目。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + + 大於 。 + + 为小于 1。-或- 小於 0。 + + + 初始化 類別的新執行個體，然後指定初始項目數目與並行項目的最大數目，以及選擇性地指定系統號誌物件的名稱。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + 具名系統號誌物件的名稱。 + + 大於 。-或- 长度超过 260 个字符。 + + 为小于 1。-或- 小於 0。 + 發生 Win32 錯誤。 + 具名的號誌存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的號誌，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + + 初始化 類別的新執行個體，然後指定初始項目物件數目與並行項目的最大數目，選擇性地指定系統號誌物件的名稱，以及指定接收值的變數，指出是否已建立新的系統號誌。 + 可以同時滿足之號誌要求的初始數目。 + 可以同時滿足之號誌要求的最大數目。 + 具名系統號誌物件的名稱。 + 這個方法傳回時，如果已建立本機號誌 (也就是說，如果 為 null 或空字串)，或是已建立指定的已命名系統號誌，則會包含 true；如果指定的已命名系統號誌已存在則為 false。這個參數會以未初始化的狀態傳遞。 + + 大於 。-或- 长度超过 260 个字符。 + + 为小于 1。-或- 小於 0。 + 發生 Win32 錯誤。 + 具名的號誌存在，而且具有存取控制安全性，但是使用者沒有 。 + 無法建立具名的號誌，可能是因為不同類型的等候控制代碼擁有相同名稱。 + + + 開啟指定的具名號誌 (如果已經存在)。 + 表示具名系統號誌的物件。 + 要開啟之系統號誌的名稱。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 具名號誌不存在。 + 發生 Win32 錯誤。 + 具名號誌存在，但是使用者並沒有使用它所需的安全性存取權。 + 1 + + + + + + 結束號誌，並傳回上一個計數。 + 呼叫 方法之前，號誌上的計數。 + 號誌計數已達到最大值。 + 具名號誌中發生 Win32 錯誤。 + 目前的號誌代表具名系統號誌，但是使用者沒有 。-或-目前的號誌代表具名系統號誌，但是並未以 開啟。 + 1 + + + 以指定的次數結束號誌，並回到上一個計數。 + 呼叫 方法之前，號誌上的計數。 + 結束號誌的次數。 + + 为小于 1。 + 號誌計數已達到最大值。 + 具名號誌中發生 Win32 錯誤。 + 目前的號誌代表具名系統號誌，但是使用者沒有 權限。-或-目前的號誌代表具名系統號誌，但是並未以 權限開啟。 + 1 + + + 開啟指定的具名號誌 (如果已經存在)，並傳回值，指出作業是否成功。 + 如果已成功開啟具名號誌，則為 true；否則為 false。 + 要開啟之系統號誌的名稱。 + 這個方法傳回時，如果呼叫成功，則包含 物件，此物件代表具名信號，如果呼叫失敗，則為null。這個參數會被視為未初始化。 + + 為空字串。-或- 长度超过 260 个字符。 + + 為 null。 + 發生 Win32 錯誤。 + 具名號誌存在，但是使用者並沒有使用它所需的安全性存取權。 + + + 在已經達到最大計數的號誌上呼叫 方法時，所擲回的例外狀況。 + 2 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 代表 的輕量型替代品，限制可同時存取一項資源或資源集區的執行緒數目。 + + + 指定可同時授與的初始要求數目，初始化 類別的新執行個體。 + 可同時授與給號誌的初始要求數目。 + + 小於 0。 + + + 指定可同時授與的初始要求數目及最大數目，初始化 類別的新執行個體。 + 可同時授與給號誌的初始要求數目。 + 可以同時授與之號誌要求的最大數目。 + + 小於 0，或者 大於 ，或者 等於或小於 0。 + + + 傳回可用來等候號誌的 。 + 可用來等候號誌的 。 + + 已經處置。 + + + 取得可以進入 物件的剩餘執行緒數目。 + 可以進入號誌的剩餘執行緒數目。 + + + 釋放 類別目前的執行個體所使用的全部資源。 + + + 釋放 所使用的 Unmanaged 資源，並選擇性釋放 Managed 資源。 + true 表示釋放 Managed 和 Unmanaged 資源，false 則表示只釋放 Unmanaged 資源。 + + + 釋出 物件一次。 + + 的先前計數。 + 目前的執行個體已經處置。 + + 已經達到其大小上限。 + + + 釋出 物件指定的次數。 + + 的先前計數。 + 結束號誌的次數。 + 目前的執行個體已經處置。 + + 为小于 1。 + + 已經達到其大小上限。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止。 + 目前的執行個體已經處置。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 32 位元帶正負號的整數來指定逾時。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + 要等候的毫秒數；若要無限期等候，則為 (-1)。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 32 位元帶正負號的整數來指定逾時，同時觀察 。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + 要等候的毫秒數；若要無限期等候，則為 (-1)。 + 要觀察的 。 + + 已取消。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + 实例已被释放，或 创建 已被释放。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，同時觀察 。 + 要觀察的 語彙基元。 + + 已取消。 + 目前的執行個體已經處置。-或- 创建 已释放。 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 來指定逾時。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + semaphoreSlim 執行個體已經處置 + + + 封鎖目前的執行緒，直到這個執行緒可以進入 為止，並使用 來指定逾時，同時觀察 。 + 如果目前的執行緒成功進入 ，則為 true，否則為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 要觀察的 。 + + 已取消。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + semaphoreSlim 執行個體已經處置 已處置建立 的 。 + + + 以非同步方式等候進入 。 + 將會在號誌 (Semaphore) 輸入後完成的工作。 + + + 以非同步方式等候進入 ，並使用 32 位元帶正負號的整數來測量時間間隔。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 目前的執行個體已經處置。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 以非同步方式等候進入 ，並使用 32 位元帶正負號的整數來測量時間間隔，同時觀察 。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 要觀察的 。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + 目前的執行個體已經處置。 + + 已取消。 + + + 以非同步方式等候進入 ，同時觀察 。 + 將會在號誌 (Semaphore) 輸入後完成的工作。 + 要觀察的 語彙基元。 + 目前的執行個體已經處置。 + + 已取消。 + + + 以非同步方式等候進入 ，並使用 來測量時間間隔。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 目前的執行個體已經處置。 + + 是不等於 -1 的負數，-1 表示等候逾時為無限 -或- 逾時大於 。 + + + 以非同步方式等候進入 ，並使用 來測量時間間隔，同時觀察 。 + 如果目前的執行緒成功進入 ，則工作會完成且結果為 true，否則結果為 false。 + + ，代表等候毫秒數；或是 ，代表無限期等候的 -1 毫秒。 + 要觀察的 語彙基元。 + + 是不等於 -1 的負數，-1 表示等候逾時為無限-或-逾時大於 。 + + 已取消。 + + + 表示要將訊息分派至同步處理內容時，所要呼叫的方法。 + 傳送至委派的物件。 + 2 + + + 提供互斥鎖定基本作業，在這個作業中，嘗試取得鎖定的執行緒會用迴圈方式等候，並重複檢查，直到鎖定可用為止。 + + + 使用可追蹤執行緒 ID 以改善偵錯的選項，初始化 結構的新執行個體。 + 是否要擷取並使用執行緒 ID 以進行偵錯。 + + + 以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 引數必須在呼叫 Enter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 釋放鎖定。 + 已啟用執行緒擁有權追蹤，且目前的執行緒不是這個鎖定的擁有者。 + + + 釋放鎖定。 + 布林值，表示是否應該發出記憶體柵欄，以便立即將結束作業發行至其他執行緒。 + 已啟用執行緒擁有權追蹤，且目前的執行緒不是這個鎖定的擁有者。 + + + 取得值，這個值表示此鎖定目前是否由任何執行緒持有。 + 如果此鎖定目前由任何執行緒持有則為 true，否則為 false。 + + + 取得值，表示此鎖定是否由目前執行緒持有。 + 如果此鎖定由目前執行緒持有則為 true，否則為 false。 + 已停用執行緒擁有權追蹤。 + + + 取得值，表示這個執行個體是否已啟用執行緒擁有權追蹤。 + 如果這個執行個體已啟用執行緒擁有權追蹤則為 true，否則為 false。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 嘗試以可靠的方式取得鎖定，例如即使方法呼叫中發生例外狀況，還是能可靠地檢查 以判斷是否已取得鎖定。 + + ，表示要等候的毫秒數，或是 ，表示無限期等候的 -1 毫秒。 + 如果取得鎖定則為 true，否則為 false。 必須在呼叫這個方法之前初始化為 false。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 毫秒的逾時。 + + 引數必須在呼叫 TryEnter 之前初始化為 False。 + 已啟用執行緒擁有權追蹤，且目前的執行緒已經取得這個鎖定。 + + + 提供微調式等候支援。 + + + 取得已在這個執行個體上呼叫 的次數。 + 傳回整數，表示已在這個執行個體上呼叫 的次數。 + + + 取得值，這個值表示下一次呼叫 時是否讓出處理器，並觸發強制的環境切換。 + 下一次呼叫 時是否讓出處理器，並觸發強制的環境切換。 + + + 重設微調計數器。 + + + 執行單一微調。 + + + 執行微調，直到滿足指定的條件為止。 + 會重複執行直到傳回 true 為止的委派。 + + 引數為 null。 + + + 執行微調，直到滿足指定的條件或是指定的逾時過期為止。 + 如果滿足條件則為 true，否則為 false。 + 會重複執行直到傳回 true 為止的委派。 + 要等候的毫秒數，如果要無限期等候，則為 (-1)。 + + 引數為 null。 + + 是一個不等於 -1 的負數，-1 表示等候逾時為無限。 + + + 執行微調，直到滿足指定的條件或是指定的逾時過期為止。 + 如果滿足條件則為 true，否則為 false。 + 會重複執行直到傳回 true 為止的委派。 + + ，表示要等候的毫秒數，或是 TimeSpan，表示無限期等候的 -1 毫秒。 + + 引數為 null。 + + 是除了 -1 毫秒以外的負數，表示無限逾時，或是大於 的逾時。 + + + 提供在各種同步處理模式中傳播同步處理內容的基本功能。 + 2 + + + 建立 類別的新執行個體。 + + + 在衍生類別中覆寫時，會建立同步處理內容的複本。 + 新的 物件。 + 2 + + + 取得目前執行緒的同步處理內容。 + + 物件，代表目前的同步處理內容。 + 1 + + + 在衍生類別中覆寫時，會回應作業已經完成的通知。 + + + 在衍生類別中覆寫時，會回應作業已經啟動的通知。 + + + 在衍生類別中覆寫時，會將非同步訊息分派至同步處理內容。 + 要呼叫的 委派。 + 傳送至委派的物件。 + 2 + + + 在衍生類別中覆寫時，會將同步訊息分派至同步處理內容。 + 要呼叫的 委派。 + 傳送至委派的物件。 + The method was called in a Windows Store app.The implementation of for Windows Store apps does not support the method. + 2 + + + 設定目前的同步處理內容。 + 要設定的 物件。 + 1 + + + + + + 方法要求呼叫端擁有指定 Monitor 的鎖定，但是不擁有鎖定的呼叫端叫用方法時所擲回的例外狀況。 + 2 + + + 使用預設屬性來初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + 提供資料的執行緒區域儲存區。 + 指定依個別執行緒儲存的資料型別。 + + + 初始化 執行個體。 + + + 初始化 執行個體。 + 是否要追蹤所有在執行個體上設定的值，並透過屬性將它們公開。 + + + 使用指定的 函式來初始化 的執行個體。 + 當嘗試擷取未事先初始化的 時，系統會叫用 來產生延遲初始化的值。 + + 是 Null 參考 (在 Visual Basic 中為 Nothing)。 + + + 使用指定的 函式來初始化 的執行個體。 + 當嘗試擷取未事先初始化的 時，系統會叫用 來產生延遲初始化的值。 + 是否要追蹤所有在執行個體上設定的值，並透過屬性將它們公開。 + + 為 null 參考 (在 Visual Basic 中為 Nothing)。 + + + 將 類別目前的執行個體所使用的資源全部釋出。 + + + 釋放這個 執行個體所使用的資源。 + 布林值，表示是否會因為呼叫 而呼叫這個方法。 + + + 釋放這個 執行個體所使用的資源。 + + + 取得值，這個值表示 是否已在目前執行緒中完成初始化。 + 如果已在目前執行緒上初始化 則為 true，否則為 false。 + 已處置 執行個體。 + + + 建立並傳回目前執行緒的這個執行個體的字串表示。 + 在 上呼叫 的結果。 + 已處置 執行個體。 + 目前執行緒的 是 Null 參考 (在 Visual Basic 中為 Nothing)。 + 初始化函式會嘗試遞迴參考 。 + 沒有提供任何預設的建構函式，也沒有提供任何値 Factory。 + + + 取得或設定目前執行緒的這個執行個體的值。 + 傳回這個 ThreadLocal 負責初始化之物件的執行個體。 + 已處置 執行個體。 + 初始化函式會嘗試遞迴參考 。 + 沒有提供任何預設的建構函式，也沒有提供任何値 Factory。 + + + 取得清單，其中包含已存取這個執行個體的所有執行緒目前所儲存的所有值。 + 已存取這個執行個體的所有執行緒目前所儲存之所有值的清單。 + 已處置 執行個體。 + + + 包含用來執行動態記憶體作業的方法。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 讀取指定之欄位的值。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取的值。這個值是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + + + 從指定的欄位讀取物件參考。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之後出現讀取或寫入，處理器便無法在這個方法之前移動它。 + 已讀取之 的參考。這個參考是由電腦中的任何處理器最新寫入的，與處理器的數目或處理器快取的狀態無關。 + 要讀取的欄位。 + 要讀取之欄位的型別。此型別必須是參考型別，不得為實值型別。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現記憶體作業，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的值寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入此值的欄位。 + 要寫入的值。立即寫入此值，好讓電腦中的所有處理器都可以看到此值。 + + + 將指定的物件參考寫入指定的欄位。在需要它的系統上，以如下方式插入可防止處理器重新排序記憶體作業的記憶體屏障：如果程式碼中這個方法之前出現讀取或寫入，處理器便無法在這個方法之後移動它。 + 寫入物件參考的欄位。 + 要寫入的物件參考。立即寫入此參考，好讓電腦中的所有處理器都可以看到此參考。 + 要寫入之欄位的型別。此型別必須是參考型別，不得為實值型別。 + + + 當嘗試開啟不存在的系統 Mutex 或號誌時，所擲回的例外狀況。 + 2 + + + 使用預設值，初始化 類別的新執行個體。 + + + 使用指定的錯誤訊息，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + + + 使用指定的錯誤訊息和造成這個例外狀況原因的內部例外狀況參考，初始化 類別的新執行個體。 + 解釋例外狀況原因的錯誤訊息。 + 導致目前例外狀況的例外。如果 參數不是 null，則目前的例外狀況會在處理內部例外的 catch 區塊中引發。 + + + \ No newline at end of file diff --git a/packages/System.Threading.4.3.0/ref/portable-net45+win8+wp8+wpa81/_._ b/packages/System.Threading.4.3.0/ref/portable-net45+win8+wp8+wpa81/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/win8/_._ b/packages/System.Threading.4.3.0/ref/win8/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/wp80/_._ b/packages/System.Threading.4.3.0/ref/wp80/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/wpa81/_._ b/packages/System.Threading.4.3.0/ref/wpa81/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/xamarinios10/_._ b/packages/System.Threading.4.3.0/ref/xamarinios10/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/xamarinmac20/_._ b/packages/System.Threading.4.3.0/ref/xamarinmac20/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/xamarintvos10/_._ b/packages/System.Threading.4.3.0/ref/xamarintvos10/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/ref/xamarinwatchos10/_._ b/packages/System.Threading.4.3.0/ref/xamarinwatchos10/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/System.Threading.4.3.0/runtimes/aot/lib/netcore50/System.Threading.dll b/packages/System.Threading.4.3.0/runtimes/aot/lib/netcore50/System.Threading.dll new file mode 100644 index 0000000000000000000000000000000000000000..88d53725e9c2ed0c1b47a81ea4a3a218e5e0990c GIT binary patch literal 23232 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 literal 0 HcmV?d00001

ml z`+3l)A9d}+0~`_QGGMrOLFT_bQ>bc_?8LpB7_F%;bu7c-@|wAkBsxgl5Mjkt-U}I% zc>`M8P7)gG1Uv@58~MAfKqEp^khkN9u!_O6=K~O3R@UemyQ;MjB3V}>yDQ24U zwl-_}Zn2w+%Lsm(H_C??jb!cCW!!MHIf2*L`XKDlqa=nuU@4X5-7E8sJ=*4_SwMl6 zAkabJ9;#e~Od(>~-@e$p<0QH*L^% zJXOudyy}KtAWz=xPD(5p8YzP3-@H(4UG%Y|oaIty>?^0^Go@Asx4D6Aj498=2}Ht) zi4i~5LSw5XThOh)IT0ohF}DF)#L)o!^yykpNTKI($j;6TkcU?SI4AXo7VJXtbE*?d zKm0xUI{a|5pEx?#4U+{+5}s%;SopLL%nhq<<*Ehs&}#!U?_oAhAa&A+aqXigm8~db zOExXy{gRvhQE~zt3L~1rz6atBmyo7dJb|^{dCKFamv*4o%Bw_-4e_dj7-`>@O3gGo z1w+QZ8EzyvE)%;n7n7=dM2<-%i8k8JOf>_a zD<)zaI(O)&fOlKOPS6IE7@WMNOzd-wK-E-N%{#VFZ?Fo4+_Ui}p?$&g`@TKs{yD7u zZ5}w>h0xgSo6l-;;uo?6=sV_Lfwag)uz-G5eq4>S^&1wP$GP8ID@KY*j17UU=X~~KBVI8AwS)MCRt8e>`u$sg-S+OMwdWi zYrGm0SK1i&GlLKd;NYmoULRnIzni(;JQ?KJZ2RYYCUDxm{5~ia*Adz^zP3Rz1A}t= z64-+euS^8JmPx#;m^5YGXq_s4%pmihem*jMSv4Zrp#Urh6d(Yx#`nNd=9tna6W;zs zZh9n7@z%=^{}IC`+40!wx$*hMv>C|E#0orp<$qHxab-)Di2jAmhs?=dxaiIN1E40& zI8hlqDrnY>FmO_F=!Eu{pCq+DYEvXRo`(v&Zg{63!|wzfxI#!EWhs+?zuRA8G$ok z%<~fpuB=7Wo<&A~o~Cj199>K4>s=PP6!Vb*RGrhpux9&NS@OZfx7OjZV_BZQC8&wrzH7 z+jidAw%xJ*d^7(X%)uP(^QY>mx@+(2TB{5RcbvmA)CFAqDX`T+RO}gep{~yTC|g9G z;ie)`&grWd0paIKeM~Bti>Q+kGhl$1=kA12BAT=h{ylApQ>IivO?pfVjCG7)c=tPM zc<+hQ!sKpZ)vFWn=79?7E~O9J+#d42l$MjjI&21J+rEvhghT>G)@=TI)d$LrbI_zK zJVz93P{IPJi4t&3R=3K)FC^|k#5Xfml4Ti`v1I_3?e8xt9NC&(4FxH_Rrilq#lj1% ztu3F)d?rV&Kj&Xe9E`evPhai)B@R_ZQ=e#yK~!YIZ3x^1!%5_D_kxA%>X!uFLSpB? z%~yza)?d@J^2;a-vE%fDw-EUhFGX2Q($Y?}4P~gc%3{`K8UnsPGRw7t$L46S(rjyW zGyJiVs~)!IrEeSu*tf^$B;zOVr5e4LIUo?K&)J6JA|4TfG2(qv#aT z;an#%JDHum03CwaE)Qt)@N=+U;|opu-^3IEc7WLV|c)0K{%Ne_XnMSwZ^WZh;?Gg@r(Z-7zmevd(-bZB`9`q%+4__T0 zN7G>@Gu?)M@T{c3B_%51VG83$vw{O|y|C1E^37Dux?owadL7H|?w@-S^-f~(q&BHf zViVgotip`@{u$3}Hl=)ZWEA+GckHuD>YYjiup^iNMvBEIH=fHos`{CDg*x>);KtoU ziI<6kr%S3F#;=c^IuPWjI-)?RN~V7zh1%k#OD&GFLaEhIky(6)*!T2T!xw_;nfxsf zIGeJ^U44BEoO-}x$hgrix0eQHlI3iJVt}Gt2**hJipahtays;`z7hZ9_6$Mu@y8qV zcNk5l+{2OP{p*L^XcyrFZ0eMNxGQhlT{uyle-e>;2-TkMvZU4~^GXKF>%6G*7(las z0PKso(SEZ1cE-95hTOdmAvCPmr(KuIOF#K~ zyaXL*O~pT*1>a7LjWt@XCytSvWqoXt z`^=*sSiu5RpVo|V&QD=SLG%EL!7QBv{Yxu=c?F~;YV9@_2-|y_fE#}C9M_ON*zLV% z2j{VDmh_>ixxZW#IYI`Cjv^zkcoio0qlgb>ix(wFBn{pM;ASQqz(EtY?2;d%+$khc zZ(+%7(rh1h(`9Kj8b+~f!}-G8rfBR2ZE^~~Lk_pIEq0ZuBt3~nmT|tXS2)(NsA3-4 z6Ja^?fhqZK81x9mr}0>^KsMFgOPF)R>`XGJbc})pPhy@3-u=B8ydj@cF&t+JNS3T3 zlvu@l z2!mZ}M$=*8YNotw$d=E`V-g^_(c#d)T$rP{zaY9(qSnIyfh6152}&b2q*-2W_Kc%8 z!cAgKgUqbTSHEQSPFcS2f^o%9IQi+|2qoWECk%qJ&Ef6l zu}%;1V(q13^`&4+vlg>#ykrcrpz&3BND)bH5P}?(js;t%Z(ihFj~UuX=NAPlZjbjS!N}SV9HbhO0*w_xe&lxy z?P)ktqr$(-ea`CxYkBvY82tu}9!ESyY}}^kEM| z?4+hduFdM-zBY?HT|Z*R27XLDX50-TV55lGNqdmE@KT>9=)CzLt}&#}Ch9uR@R*rO zGe4H58MAO>|EFq(g}(D;pwJ#);b{BhSdpe&nWo(F&>C^0ZZHpd?YBozp=bXXcmaT} zDH73G;`VUQ7QwoU;`Wr`JoAa}v2Iw{R_n^3xHKLwqtNiYHpF*7#Jd9s?18(I;R;;wgq$>!Fs=_WVw{jcupPv?QuRSc!$-O9qw6) z#L7nldMG$!0-N^$R!m0J{#tw?mkOmL8WE*_HXDsi_ojAf*NUFZLH(W#p$v?KoiXF8 zb0d121~i68;z>%vC=R+%=}CmyBF}r`wozMPAjdlH5XK1P9;yI?i~HWRQ7SlE7Ln(j z0^fs+%&U|XhChKYSLHh14Ua|w%Af%0SSsuA&!v3Mgy5ETy!@HBaAl|yt8H8BuelsPm>|G8y& zJYY9PStQ1=G=+drKUQ z3ZxVG1grOpKmVETx%keO0T}^B5S|+h{GvVrqo?6kHX&Bq;I*fRurC_G)7)#*g*jVR zFJ9Orp{_$5#^i;zk<@l+7ikN1(;CoxcJ1{Q>Un!yur=qZ_h0DRBOWvE(VH(>xfcvZ z$>E4{qbDbaAcy;wx5lgJk1-16Y4MGwAhvIopt2d2@*GmvX^Nj8buP1+))KDz(G2SJtv8KAwKo^eC+mb z2L(K^Jq8S|p~7W~GL+rbE)e5=V!BH5k>tVkes6znow~&le(i1CtOo6T8;0#WwM_s9 z@lP^-K>gBoLG8G0Ker1Q=g{;jgr}G*lPKmzPB^&o^c3!n*X&LVEeiXn_KP$C2tDOZ zBP)~W0H`qSuZfe3b9=`H_X!Jx(up1NPH<86yK!g1$<9@kVw6n5qcd+)Cp#XCl6C(hUd_nd)?v1*(pehsUJ{e zY?%wf{1`7bqwf)x4;m2vLH8>6W@A$+gMkOxUwby4qh5DJs}aIgAiq(7q7Jb`gbk!np699>PoZkiX&)7H4xhL^(33) zc~scON>p1Af`evpeqTkTBE;3wTZyK5CK}*r3vFZecNin9btAke5HsezAZ%3c-qjjg zpq=_V%3ISlx~z3}&95G9PHFb37kFQ#HRI~+Xc`_2HUa9O2dgn>qgXEsnD1;P;?q1) zVr#zkA*(XEz{c>u-D!W{g5&ssI^oO}qq)3-{gU`9XKD<(C~JlFf$}vt@W`GQH@lq! zk=*-Fca#zRqhJ>>)6K7R6bkGLmUBXWGbw#cgXd=YCev3JMdR%_AeVe;z+LWYyUuJP z?;;^Q<@XAsxB&tAN5^H@Lltm2dvj*8{AL}Tw)TAaBPI<2hkC3*lp99x%5DCKxukRk ziMiC(SwTxnjxR8)O*oHUKmrZDuSgA(@0-yxv4WiX1A7jl_(e}m8IwUFUsR^sG4T|I z#J`VPN4c|@NzpAu1%BVqlok^v`0eVXYb-aoS1r7n$j)Wa`Hl23J_)sn+fY14O zi;)#At;JMo7T1Lx*Ty1q8wPksW6i=5l4Fb14>xsZv&L(D@)5xiOUkZP42``VRhZ?7 zQTY4bbxUYup9kx&dC2#J2FlRP6k(c2MUw>1vsemyPr=Zzj>APk4-NfT=&Rats?W&0 zFvp!cuz4YoHYP&Qu|Z2+eu~hhEirbT9ane>%u7qF^*?qhy+)ZvD_%mb>Dwp(I&S{_r{fp6JM5ct+@@K6uDSYD;JC}I^s0j@M5 zpXqvpawt68jD$Jy`>nA*O`=V+VaU)I%97zL*~O z>%KJ?f?td}z0Mi%f5)B7+#l?))N#ft80t&3EL3;pmx6K(lp>R+ab<&@v$IlxkX)lb=%#Z4De`)Is0rf()8-6O5K9aV|n!l*BYwAzEn+kwnj`wC*$T(;uER+Mu;%+nHQO zF$h6w@u*aTxR^+@0a?6oy6o_8|Ep95xBApt1vb%QgwNqNV@AYmW0PWFzLFQD%zVK^ zC6G8mk>DeJmF}?G&e`mup+ukgb92YK7j0@GS*4FC*&9=nzQA)WBr@Q@B1urJP<8|ZrbXwu`E!ja}&2_wrZ*jK3 z9CDQaJ#PBCS+{xu%~gdCkEu2?$qD4m2Ul*;yE6hPy1uKDO5cT_>1-ri%~o#8a?0Mr zjZOS^I+m#F!miHi@?pG`TB`HTdu^TnE${O?1*rA4t|BGxG5Ku)@fTHe+;2%&=5@f>UBD+l?91GJ5_?-2-FNbB@@Fsd_p+H$E-HNE!TJ$o_{#U<}tpE6}7 zo2pYG4fgY(YwB_fPt*S3`yf%fYQ^0|W{B+8llpb!_JZ?M!!z zojX%gi|VyI$=l0D78|E+jIuiIu&Tyv5ued;5p1)gTC&m039522+p|?WpCS^}Sog(3 z#ni9>l{k2o5Hb^d5a9ZP{QUQF9=M*uy)m_QArp!Qg+)O{4!eM3nd3ho%&#l@Mw$(y zXQRgWr_mMN#t<4EqBMVyYe8K@Y>@bM{7SNx+4C`VKs%7m5z8fH@5wv=7+Hj!!KKo+O~g_tsO25Az3Mjn>6ztBds8wi@uea7mxrG1L9V%fI+iDuYP7*wdl z?OKZ81`RlM6@HSO2ng5XxT{2jJZrQO5_-vyH)B z4nzai_X^wttMLaOhMvB*J zHjA6KKWfh0iK35rSUkws=GA92 zN|omGJ74V=uj#58qT`bTV2|4dF;M=*Bp(SV>AVO7AQ*x3sKW>z8Kb zx@>WLsi~w^RI9O^(CW0;ywMbDEB%gCL=b%|sTO}|V67n(MsOX|GWDv;N5+VnsK3*W z6TLPQR#WMt+Bwy!PrDr8ybElR77c@ZmTiXpb+}LA0Abp{(!L@iAP*hOFFapgq zlE9p*2pm^gn-})GqexrMB%NtkO3?)Rak}5r&zX#KDK3m1amnPVWo>tXXz&eS$)QRL z7l%4f42=F{TXna>Tka`EW9^O3ZBQ9tV)MiO-U4HWQ z06`7BG#nGUO|(oKfx!N0qJQ*KR&A!iA(7SeYlvHBCa9#bhbOY|W%w9k1?y27B`Rbp zY1%QFy7<@hh=W>yMZ5xu=9@XKd@B0gH=zo+!nOXXEbQa)zILdvDbgAuo(5BfD?7p~ z0{8K2c_TSAp9hBM8uv}M2Y2Z(hXa63JG7DKizhkcvEl8tmiKv8vu4^1cqgW#Q=mUG z*B+ckz{lA{H|9|{PKvP%+v6Kh9nunWk)-cu(>qfo-C*y(>_pPK%s~z3r-2$!TFPD{ zj_Ln28$gsM*(W--yxx03` zyD?JB10jm%5N5xA#Oh)husUA2rnfRO;K#5juVs$WC2h}BtVamIS%vm7?8%&?j~Hq$ z>nM@s$d;M$0$UDOncyPa6n4Or!U@GAk)nX7ERJX-MaJG=5%wD)eHC2KnQh|?pBJh3 z$u)2YeA*qPT9crC^}>A(SuV3WqKs$SLI(R_Bu^@pW;W%%ML0&v^HTWvu5o+m_6=j1 znFU4$$x~&ts+x)I=YDhds;|E{olU7Jyx(<{F<>zK=FV-(i`0_*w<5TziX+-ABnoqg z8kd`^ZguB^b$ry}a5>L2Hp$haUD!71mw4}iHU@pFg2-*+Y&0fYsAS5~6y{~Utm;l& zyNTBtKc)>|+YudvfP8zBGpGKp!D*|k;AUbqY^V48dSge^4IJ~iF|@xt(gkkh2a~LU z&PXSM?=z%iFbv&1EsQVXPy9+JW<-H4#}j1?8DDZciHT%*&_av;6GU5#^d9f%PaI|q zUEdPBirM812@huMEYmMz;fDG`L8s3@P-6*1YS*KH+5^Q|o85v8ch$MMU00jr9#oU(>a@fjN+rnz(re^`7xYE!K;e?WVbJ^8H* z@BL?dV57&i_*f3I5Y$TJ*34cvhi4luOh-Yw=0Fh_J+>X0{A3wbLKMgZeR22pZ@^6( zNC5j7@83#Ai$WFRa_WpV2$#RlP_`tmc3r7|!JXB2BeaoO*NL($*+2e(V<^u6-#|fb zs(e~4X#O36UcpOTr9z*R%ISYm{fCqPh<1wDHc@V~Sn?-ntRaBZwg@7u;#z?hidX)C z3s-O;JIy~58U3L>pzW`5e@S^UupAo~e1M>DFs)&|Vzo>NzuXoS7t$p(sw@qt(R-K% z_74i(w2?R6!e3wHQZH(MJR+g~`j)2HYG8y7&X)uBQ-q@+!hW_g4qk=pLE62+|EcXXpTn87 zbIP(B0cth0Caf$FqpnhrB{5Svq`+`uU$CjJr;WA zEOm*yN3wCa$kAc|{Di;D=IH<}U^XwQrd_Aiuxtl~4M1P%csv(0IvI$OpNj&-J{RYPfUPM$F>U=0?MWy0(aV5GM0hCSC3?VI@fYMIRhtl!l5ndKJ}V~aEhPKt zBhu6(ASQ1iMa3G_%Ucx#1fGKk~ z!K(55?csiIsG@onfY$zZIyKBGMjU)q^fp=Y`1GC&>1$iA|Jl3`u0pJOT6r(IU`2d<=P%Z z{h)VO<4L%WNv(MaY%0x`dvW6HTQ0vHg&#u%bc%BtDse~a&`IJ&FQxiK_He0d7=xf< za!3JWoEUe6O$%&%$_u!?xtHt)+R3@1bTBe~#J4;8?XM=?5LOOpAB`ihc-aO)&=5k{ zf+1F@2+URpzz9a=+zGmCn#;&OYi`N()>!WI zHC*Bo`B|RhzyRqr=?Kf+e1@A{q7WA?G9Sn- z5#N;ecgheoE!FCKRZVtWcD7M+-@5U~@w>HG?31|t$FADdUxHGdYW)W}z^i%z5kKA| zz1fy?!sV4==~ec`K0<(TnpVd#)zKWAokbjRb>CYR)>lcx;fbTq8go$-q2(5U^_Mnl zOhI6E(u{JIG{Dp#)Kbo-|NFzOdtzXPSE zeWbia2|*nX5)QH&B+~Bw{M6u1rW^S+0dDELUodf$4*xZp7>H<1 zFd1<2l1-|RW+9qx-W!+TnU9lsC@ST^y~dG8J)lSIEsP85bJ-q7JKNKH{hGTG@jE0Sha0PZb%H6^eVewfjWz1M|$rbxrw4lPh-A$5;Y}?#j?NNsAwhC z72`)H)PK$yFvTWF@B+dCku9`L6RD&^VDQv%)F9&hD94vBv4JB!lkeV+9FB3JJ?G1} zXb04@IB=D3(s16>j9r;-2=vPu2xA!Q-4cu_Z7aei-{BcDE&7@(VmAOiCAP&sXjUls zo6SDAJ_B)RG$nQ&PXS}}I{D5%;O@}>O~J{;d0UKmIU8mk`AnPc*JCZexMo&aF^rJ5 zkluvkV_{4$40=@V0|lX8l{JN<%1H*MIS9-;4r5k(GmE|HbEX&K6>nOMGFRwbrp%bR zhd*DU@= zGfW~1_ExPaW*_?gf;Hb8gB>J3{Jh0;6=7wzlSce|Y$@!X|FnN0lkZIU zd{d^vUy3>DbP*-k1%taEN>(=!Y2t?2QvEtNXUxbKNk&5JZUU;iY;|e%XL!zw12O!& z+;fu@#=re~w-g`8GHM@_&v|5>Cc}WcMXPiR5jz&A+}<>nk$n93W^2EnjhKuhP@HRm ztbV)KaN?Ma2slbH%@$X|fe&r`<0^o?yr}VA@e|jXA@4-v1S-j#!8SH|f6JT%P06iu zB#0NnY>k2-`6jYc|Hl;j3sVNncJKUcGFfWJ8ETBJp%SgJKtpPaLW2Fby5w?`l9ddR zQ%YdqT9-Ng%OOO<+QDQP^yGo_D^Gm?um55uY^B^kZ%;C1c%V_cZhJVKzv=Vix7BlY z>>QbNEvZm=FnigQVp(a!R;?}Z=Gq2d6{)=o!Q#&miP9h4EC76;i z=xE1eg&yVtwn*Aw%qNCdA3!mplDm5VM(NyR`-{iNG4H;Q;|JJL|b(p=+lPPTwnV3h4xsRLTVTEcPO^iR2^9g8ipcO)k3z;D&ZJ_Swq3YFCe-UIQG zw-$_7QFLbo-=SV2sX$O#7$h&H9ASBur7o7(JTvKM6~9EQ+y;m$Q}AkBWVr{_ryINl zN+@r9GD5MON%O<+ZPx?X4s9?)!k`z}-StRNW~q@$@2{ZM_eCOf>xhCZpu!`k%AN;U z{)~Wa63f?+scvL}7ZVQ~ZE2P~43nJWn}b{I$0Uy=wc-vPH#zk?IXHe|^EgKQJJyyv z=L^|n3K>$3Ons;fLwB{9v`5c$D5iZ#PLgqA7m83F+|r>wM911%7#jrG1E%l`iYq+g z8(DVF8TLZptIas=iw`ygb!-NqZ-lJZE;qOi6yv9A_=C2|v}sJPLxpGG%vBQoy`leB zRd5c~QvAMUo!TmV6F?X(o>pvM>*l-_OnTDj9U#Bh%o%R)%jA!J7QlCU(Q>~kfb2b` z7r@~X;JcRuSMMj*Mja-;85n!fz=3ITat74{SszT#%1$2+4IbZcujyeai2LM?#`ccc$!t`Wa1}`0m)bq>f3c^1815Cy`>U{^G5oRtF zM6BN1klC|;BsaEW&(feT=DNfm=*1rfnegBE3ZBDzuEKv1QUt%R@47}Gu0|j12p`?I z4_==RUJq_Od2jB#-|s$LP#(j#N#9aQ-yCin&h9=KcH6_I%{)bJkbNeRKW%Ot&yYWB zh&*qcex}^dbpHR-<&4?Ki}~|^`UmV-09LaZ)r+8XK$`e7!Ny9!l_zMVcffW;+00b9 z(BdRiLHvxX5T;SRECu}Nx;*e-cSjE~#+lqSy7$>(2lYinsGc}vZB@%kE|wMzg|&ff z!CmpL6%ov8OtgrexGpmN_vcZF;!zMqQ9Fhhxt)iGP4AOyZJD0PA~pH$IuEiSaHuxC z0OWg64^m_5Ha01%S%Z)4G)*Es(BGAEVaC+RM-|S-MviSy5bQ9q5xH6_oRvw{0I+xx zlq#O%W<**6r+?pwP5howUdYRHj1zQkvV9$AU6<$vW}S2;9%iFV|PR(dI|-P*17Czn0)0A%lQ6Q*(3$hBGO-1M<`0}$EoR-N^pzZZ`kW_u@jZd~Oy zb9%PMnD5s2%a8%#A*itcGNI2_;{tE^ij@)*1Zj3<25s0|TVaN3V5j;chE!wsXV+24 z@h`2$g2-6S&0%V6$YrSzM>-7kcOOkKVGnj#A>lXw{|4HH4+=ACO8^1IqyL{kJ5#6s z186s%xG9#p>oavsXt0L)v$!B3M^{}!Sres5qR?_;r5JB$9|ygi3Wfm=t|P;yqiy^O z;C@7mj{S8yTcSN}I7RVY^0U&|3R_isz9riO)I6o=xYRXpKPF z!5e{h{F(jAd;H?S_8n1*OgFqY%FN$-9n4{W==~a=8aK~1pVn!DfU0eJOM}4$4g0Yw z`7sOa%|#p)bo%nnxMcRQmG>?TZzCl-T>)eG@wU00J(59j>_JU8t>H@l>atDAEJOZIBP) zMCS#nt_UPk5z$-x>%$}6_j9T0{!%|Z?+Yjn@*_$&5CZA$t#$SR*w~}tu*UDYGh9X* zgVh`I`w&7?2&!jnUPhRU15_j^46g-lH^ZaP9Po$8XcVu8V$bl8PbqwegCDF1tKcDv zVBX5NGM;E(so_nZ-7O|;>d2S*NBd3x#?cq!M zxi9<&eR#S$pQppaznRfJm^~&Zl9S%APyXxHUdC{g#{rXBT>Y?YB7XZ`L4Wzd;#vIF z+QUR&zkjEXt8MvPhL(`H#M`WWakoaLXpyJGgTbF77Sjh@k?=}3g|XoBD6YV6cMV-I zLRo$!=fl$@m#l%@rT7tk8=#FwiLY_4)7Z53`g1(&>;Ht2C|?p>iO1_3w`i%WufvET z9o`34spzwjtTj^WCK3^x0y+W@SP794Qais)`xUp4q(PBlmXIY3gK0xGk*2Dw&Z47G zc~1m`-+^qe^yXuM0JpLJDY^PE|)=K6xL477`4CfSQZau`cm~ z%3v_PL&q#%qzAUBL6bs(AZc-j7%$*G_>F)p$JB%q&?gKwq(PbpEeM0;a2FICVrTAh z__*_!3oq3f;o7^Nx7!|OTlxEZO+*aR&+0TdDBgsx8AXjq$S^|PW_A5u(osk4FdkXs=gpLqpj?i|^d z4I>CUnDGE^q~Z^=0RJ%{EdIM;7Jq&PlS$a+ygHb9=O6vJosZkU)12O-)&eS~=P=qs zL^#!Ww$(+?F8SS+q7^h8*(i)cVI4ypB3U@kiEPwCXi`DKnq6)vHQqFEx(h-{YR@=b z6LLQ*_kB=U7GDtW`#`U_gQ!D0{_Xeo9UGXPHzMN0L^275GlYahpq_aSdM;3%ePx1M z*l~Tb8EB9e1DXM0t0W;|LkQC$VA3E$FtnRFBaXJPX0SS6O0Yu+hS*TE$n~^WuMl)K%?qAD&@qnfx(ur-s{Ir4@3 z7d#gYlRlj3wte=0c1S(86jS3RJo3gx@%OMbem9SyH((+mT75u6tS8yv<5)5j(uJ-0 znMI}Q{;wE)-H9euRw*XG-$+7d?zlbR=z$Pr^ehTTOZ&8n^g)Ii6;2sEruZ-@)uvmE z;(gfF;I_HSshjge6#F#O$|i`yqM(hZXGoZg7`6#g6z&tNi;`5OXy$$I7};uuT95$H zyzagXwgJ1S7^A;i&tmxN+6iC$ z4b=rOh+LE)X2^`f1_<$hF-SO2`ZVnWxSEK-h6%xW1rEV0Iy$~mijs9s@vdDyd7;`J zq_+pfbiHBp2I}X-(Qa?hwmZPKeNartK=gFKjr)!F1;7Oi zuSKd^{HLAl7%_?erpYgr1^U~BCP#*AWo#0_v?Gy;S0x&z$d1}iSp++HFyxAPh`bo~ z#w02UKfqE-C=Iqd^wDyGo$ZGL*TD~>Q}89E%KhD-tca#Ev=2VJ9m?KUAGXoFEE3Oc zIEq7UnwDt24-@wo8WaXIl6h`{*6;+A3d)Fywws3Dxx2vm)CWe%t+Dca(|Up9$;paQ zs41nQ)wOfNn$se`6gYj(DgDPc7k+e*a`8&i`po73Zu>B6FelmByRST;gtnjc3K@cT ztZux#fz41WLGDoy-m`!}CDfR`pr$%G!h-YSiU%2p6?3QI%Y83n-) zXdETKWyYFAV=4B0C#Z)6aWFG^+b_c@I74zID>d*yHD$++%KjkV@dz#hbUL5#B3tzW z;1Nbs%Z8iapLe}B$P=a=G$nx|XMa^Q5j@6>P`L{AVF>FW*ZoV1$GD{#G|$X|F%0N+ zWbHr|5uepkn!0+{n|!Q`!F@?70-eOxS72x-H7a#~2xnmaqk;{ghjKp;iIIsdyTya$ z{3px~(pYC;!{0f47_`rA>^q!kMu~9gH~3c#Gp(+BmD$k4oYT38bia{#gJYj}=iNDn z&t_rJz~nAMpUO16y=EfN2(4r0+hc#GZure)*cSqJo>_J!dhIu`8Km}@f->mhaHrnR*fX;4Vosl-IRJf>ihj zC?wNd{SH6E3OJXTy7#*oTm_<<)HbS3c|d(H)it~xslt_>10icR5(f;x>m<1=1MP_ z>7QY8op^I<@KaxS?c_K<;u+bCS62Ljz=oma5GBn5mZ{x&UqYs08iPO-e;v19lSK7! z4u3~QOpy;OY%^G&fn~r)x2Z;(AqrS~by|yxM`6CI3<|je+}&M1wGnt-G`3Q7cQbwW zrCUG*6k_2-ec_83(|Gg69+gv}IJre@)0MqY`X0Rxdc6C3!XhjENYOTbI84$r7P*r+ z&O=6mQ2Ku0GJLXB99eyaCgnGQUcWUH{6An55=cll;4@wKtu`7jFIb~UjfJ`Sj&J5( ztH{4lyR@U}+;WGeh(f&N zbUybg^zV_c<@ugEd<0Nh&t{bzuKLqH;t9~38ijm-Xgr|%6Kh)%tP{yu{h{ul2$FOws1^&q~7uZVdnN>4Mj36)~pnR*O6YkE#cr z-c^x&#Q+)5Nbo_Yxr9XZsJ2Gy+C;#@hnJtQ#B&O6n{A5sP;b+zaf)nW?=^@()@m_p z^F@Ut{M!po^3FNDV0!&kLAT2Dl=t9k6XJsXJQVg6f+!ozgR=+1^ILm;u*u7KlM~$c z=qn;rW;iBO)Zh;X^%WUQ<{~rt1p8vcn{HZjBl}{lO1Vy{KP2|9rVc9X+>BOYq#0G6 zn&H9V4p8E%#uEoO)cm$o6hwt4A-tJb8d;Lm_^-7=yrPX!0>q^${1_*I7^@fM?@r0z zJZELCnu{_m_Xs9Z{I$-aV%eG9t5AU&#zhl1?4|5)^rD2N3eS4l`4M5)*>bE(E;^4* zS$5Gnh!)bgbk+F;xIj@w^FyQLAyweXF2>e%{weWLr}Z$97XpQg(H{pk$=U2clj}C} z&n&I3OhpX-6jnzRfo_%@ZF;n=u>w0n7aMw~XKNizE<=+I!o8cC(;CCp1rVFsV%0{( z$?35AS#g{Fh&yd z8^<p_ZG5nw%{rB%^DjI`43!d2#o|wzTpx(>m3=gKS`WE}QxT z4FH?H9Gso=?@HjI=mKekxLUbXsgpbgcsw?;5h!zG0#82&FLm9=XaJ|jb}b!3#3M&k zk&T|HVCv{U@IQg$Qsm?6AB~#r*35Yvi|Wzy4Be+c#+ckeAdW&Q5khC50m*YPj1YSr zd>g@p>4#@nU1r(_(c;G{7dl{4Bb$&B-tiV(lH}bohq;ecpI@VsayY34o*;B6Opv%j z&WZ7S%)#6Zbj^U%&Z}w6T3qvsUobNcw_BRvNwyEtE|X3fOrL9_gGunQ zLL-k6kqLIRaXv-bi34sNCljx^fvNGyZavi%lr93I-hRFj2+px zE~wdD2MboYn(X^w*5crIQMWTVhmEZNF~M+Ms-QMi?9sHsh7~yytE8q+Ct=VUDz7QnjWi}Vw^`rMoizac(q@HTxht;EX)k8qyxz^&hAMGW zSwKX7M%{)!pe%hqbhZGqmmwt!T11(ABsh`JVJ19qooJ{RJ)wwn`+nKL zo?RApC3v@K1kY#++z~XDYkEcQE68~>Q34uMo&1@e^ zxikKgF~BjH(Rdlt)m#yylQ)cr7iw(d%-{dt;d|DqqhCwcO}0BOuk$`cYZPv@|l?|R5{ol}zUUs>+0 zF<*J}ptc`rEXPr(sQa?aqZ{aAFjjht+L$1^2fFkl^~_L$$gt#il%gwpyWnR6wXTYl}cR`aR%Z8UUkxSV<9sSZ0$7L{ganax!T z(>8SDNM{_HSj=&j)k=Yq)uBv^_(KgtjJ&EM*}0Gl*D6kaRCvVb^Fk#L*bi`?R9rza z0CS6ui3%?k5@Nxb?|tjE)O+CJ;yaTPegl=2cr?N#(528aHS*1wDN8$EEfa<2ylK#W zX0^dcpVH$eMhB=3oOu+$@Ya?BW_cH;!M{$*B{*S=*^CbfFH1R46NmnoIc@8AW_rqY zvFSmuAqhT&grj;6_Pz2M3NQHYa*YGWwutBnWlS>n zNBs{Z>ssH`(|06*A9TSr>oY+o5d~_acWETS2Py#wllH3SVr94#NLLp);t$lyDBp%| zjyI&xTv9AVfgy_g#pd_`JJmCAl@G&<8~GxI`n%fCA%kLcrhzEF7i-t4PE((f4zBPY zv|o2{;hEVS?VLK(K`v43s?;wFqxZaWW-B!5$HrJp=q^bgwpyP*Ysrq3wK)1O&`5b2 zF8OwUlf(lQu+PN0GCTzb06m`eh>S3o{Hv>2vO%M1Y^)D^{PKyT@w|RARsV&S2i^d`F1KMv*! zlQwnOrTB*quj%M&%+>z!EEr*dkDzg+}=N60IeR`%rjDa?z>)KLhUZd zqrtXY+~~ij-!fPj*su>t;)x=csU}mWeY|gm>B4KbjE|1YT1E(S;txh zrj}4OD)|%nqER+)x>D<(=yiiv+)rWo)g%jNu)`ms(M=Qolw7Kw!Jf@zE*bbY3dDN& zey=^MYqa{@5NA1yPK;lry zb$h~k0vdN$7^aWE!}Iml-|aQ}YzBaCK0HDc&MjtcG51WG2HpAO>?s(#AAD`yY2a`3 zbGQGN*Y_K|`Mi@C2c+m6oqi=e&>3LX6+aV~*EQ7WNNAwCsfnOxk@ukQxWrBfzk zI{AK*54%HfQQ@Kz5z>s}-_OF?;e{5kcZVxX9UT~oqElWd3~?L5*T=7?(GeQM>U>V5 zC9tSDuP?DBAl&|juJg(~hY#*husdi%4X~zJHoSpeilxV?FgP5Shqdm?E>Wfj@Az zRye63zpN8m4X)2xAbm^;*|X)m1*c<=^3BnSgP86>_U^eJspw{wi6DUtxCM*<^_Wy5 z6M@a@h@Dl807sTmQ?mE;7Vh~ntvYBI3vvm}5SMKC2(A5M99fFRW^j<`VJEv8iz6ZM z8~pOSmOE+^dpZ1iA}O{x|8TSoOy>S;S5wfi0A zh6MCb|3A9Uu}PGuNw;m=w%vW&wr$(CZQHi{v~AnAZM%EUJ8|!aiHZ4AyZ*qgs9gEv zN^=zh1C)cMwWp6)(7JJ9nMBElJNoAv-Ggc|9H`*y@hY;ndK>Ne(Be*4{_Ge7=f$^2 z>EB695Z$4^Ke%yQU=^0THJlpN{*({HO!|f(2(l;xZ4GDcgr5t8lGbG9HNuln;W8Wj z)R~VY)}m-M>61c~Srg824pPMlpNZyJu&oE9alGYq-Ha%e>@o(mCnwnbB)q=wk*08kbC74 zlO38P_(#}lB;7{OTsjUV@sbz-P~B=>N9ai6=WO{a=TTc|jb)ypai27I^{_`uq4=qV%ExYZw9yFDk)_7*hW}u1GEIC@U<3?`gl-m{dU`zX$eAlUHR2T4;(8?~c zDeMaS=v3UwU|k-8`(^qyBjzV;K`NsrcuF!${9Iq|?r~MLg3*`|O?&BlJF^L|FMNmq zNXG^%H_Z$8cR9Ss!&{OOw{;Du?CcaG*SPU*$-WEp+Q@PnIp-2)AN#TToL=`c=9q;) zMGTFAGG&)g=!++Xf@#z^es42CV)8DO_Xmb+#c$U>Yum!ADwz1?l(SHTr&wa6IXMI{ zd6AsU_M3Xw2A3ToY z-|oKOk9zs#_WSMswq7h(g0U9_V=0ghv+SFf#wGVZ{5?Be%c8R|r(7^G8awibOklzn zaqAEaOv(2GM+g7neJ{&+G=5h7y6=~(+gw9VeY-*D0j6S0%3fSfyu9@R2Z<`L42xG* ziRK?2VVk?{I=ZRdC<8<)zb{yE`7`-qRhz0B#)dP_I)VD8>N3XrAd)_Fob#C)0}`q<3g`_xjlDiNMAN;(jXy2Lf6A z#((&Bi{#L1RDG-@uhFn-rEuEL7U~8g6=N)+td3&Knq!YXing4nVg#DUI9n4cLARQt z*NsuVH2|vVbynul@g#|7o^WL%Z?lHj2hO3{$JJW{slRfL&J@bZMb7JXO zi=1cj4hOc4>0#7lu1As1zVjY<)H!HpAzFz%Wm=dA^+1$hSw)!~Btd49;~Z;ivxdcw zF=aggEQ&C>WlP;vPOT9$*r?Nd3_C`|@JcVy9?L3n-T8cAHF#MmqRuLcODMulMG#FW zcBvXfpBu&TH8hkU=pT2*QpAr++7kRFhN3 z`Q&cV{?XW>mavi%%7BLUX1dMJ{a4D#K>{36y`d*K1)J<2DG_84cDk;0*rDVY8sZJF zWl)q3MYB7ZSa|NVX}Z9mcu7o6=Tk-Z?LR#J^?|<-AOa7In0C5a%6H*rYbki)XM*kn z>j5V9p}7o6LANwqUdm z`q|}4r@8Q%SF=>~su3>W2T3_DZuLrvEMG_2c&oC%{F*4m#mNhsL~}Aso~t;iMNYEz zkl#du_26Un#z!QDa|2Q>rvokL9k!p`D*wzv14r8=(yojg+r_f8t&c8FLeX8~vOtp$ z{Ze-IiABl#kZLn+R#Rw{(_kgod1AuTypR^mm@;BKiy?l@0UZ&d5H>Ab5&@h9jG~my z%W%_%$jyUY);)wqz8|udzy7CY9}48=_#5yN(LPx8Ag7{&+i%EO{;!O+!cVvUpcRrH zx``C=atqh3l;QAMJZ*et4|;DKyOB^eg1zIAgmO+1nUdj(&fNx>)E+xPD1iR;2Oa^ym~lelP-<0ZGFPvkaZhHVZ;rt6>b z?MesG!s6a5H_zvvVd&GDDvIvl#tk6#OV%OLj5{>!0J0YybOWicnLb1ZH%oV7k*!6H za~iZuoeGRDB!_f*iY$v#-uF`C3$)w!H9b5(xo{%9)R8u&r6r_MK~XAZ6pgBGA3@UM{s>PX#*1FNYdoK8TwQ1+lS+E>|i2rhne zaq24fhh#+Q7X_hZDr_XtjbuY0mDd}8rtHQ$DY^xqezzX#X*1!O9oh-o0SGF*GTc;R zitzuKD%)oCcTS}h=qQswF5d}jR@(q8!BPj|^#{TqRZ@)M!cbF3 z*trZx>++EpOtnbHi=k`C26NU4Xb>@;#L*xwov4FboO?0FlX_oU>A%HJaY5~~vWy=l zRE2pM$n?p0S+SXL&w}_vp5caLbaQ_Iy1O10zu9U6LrQ<#Q61G~#!p6@U?+(-fcS4Q zyfF)tj@Iv{CYPY?=Ff=@7WEu6YL&N%r>==f=~pShTpp4b_;Bp`9kT;xV&M;*O}>|( z<&{A6rM9Wn`Az>e4F+DKyL@aErj;*DB|Ei=1U?#AGBBkSA9n=P5~40@3BF(*`FlWn zDp-hwnW9QKCGKC-t$3UiPBTc(Dt#qC(Cr*>;1T$q|L*fJp7$p8*0Lu`hrlqHFm(s# z>^cDm&;jJ}uOs9Yr)_D}$^8&%vC}{l#%(!`8L$Ut?MQMvGF62L>iRoG7{o$ki5k2K zoyFb7!8qX{v)~sID?)%kchAI|v?(&QnAkCv@>MeMxW6LhLiL*eph zCPD?2R+_+%fNel*7aa~{x%fy`Lye8Z2Q1Ok6($E9Z-o+-{%a_MBXmX^u?p6}|N1T7 z>*kTaR7}>MwvYCniK^J^8<-?Zat7zjqo69{G%ocHM zX%ISF)+~3Gifhyu@K)4=fr=5PGzxaDBtlygUJ-ew%nkp6N$hMUc~Pb|+niBl<&S62 zTL(HO4=lVA0ptg@xB*J=K5pa+46nd{=OAf$msL_6h}K8W;lkhV(|#v9In&z@$9iHpdxl}YO4-Q_CTA2$BKYIQL^Uu$YIz%fd6cOGG*M-iGk#0X;1H69W zDrQY2*Z?))!rlb-$Z>L?{;A;u#WE~t`(Am$*ahXBu~Log5aNarsnY^4dBm_KnnJsr zUVqRhMl=#DfuTS~@!h4T8+Ply^|@>nl!xj4IRjLvI6;5~Gm+eGXS3tddb~7*3-%zR zHNzkKo9W+lxbMv+;E|0eM7b>*4f;6`1o-<3BP!V9+@}1`DBk#!fQvi=`SPD=x$QRd zPnf)`$?`{HSZ5<`f$$evFI4%f|78EP8W}r{U$&6guOu}X;u*RGWnOX^JfpOw#FZmW zn0PuSM-bn}6Bpe=Z|m^P-_lGNsv&>^u#`xjpr~Gk(!58sQlhgGL#>$noE6`n4t&#A zZ(Q5o`~ZT3d2gJTr4y7 zO|rXFa?Cn2FH_lizhU3(u%&I+$Yi`MXyWMXpH~jByA{3BHN*sJTuk;M+jKGk8L{SM zT+#NG%i%u-IJ4NPVX4w@0?XtW? zEL?-fBL&c|i$MFjMmAYQ9S;Os(uzvD&yxr-z9@+ncwNI3-$HdRM#Q#X+SH3BFSXc% zBwNdHu{fCtPym<8PY0gSnA(l4aL2ePQEnf=jFy$trR#Lm70gW=X zzmBNnUWOXbLt*Lj2+}C9&b5SPL?mP;O{0`YzuXKOC?TbRwxaq|ofYD#IA+$W4RPe2 z@1WQl)AESd8>#r>_ly3sn?WCStx}*4v1a;LYopSzCF)X-F$hT(mQ`d56$LE)4GYu~ zq4jAy*^N3vzQ-o~g^hI^zVt*cL`QSh+GOE`Rij4IZ^_=2Z_VnO3wkfNM(|Y;LiLL< zwICy_?v*A+-eZm=YR>zrZX5E_FBjqQRF`Xndl?%*g9jBF?Znd{R;9V^$aymV{IN9i zQjgkCbkqVjYnW!&fq~r)uvvulo(vjk$M@2sg3uMnAgaAKy*V-P!P4ZWN^IJv30ldw zD!!7zP?Ds0Yt|q2Cx+Ks>NV6QZ{bjiJ?&5>Za7k+ICs@HNMB(;8MJ(u{ohEFydHK0H=PyuY;{Y!|lnayL zD~Op}Ahb^ODvN`WU-X)-8y{xVH|)mv8BP=e_C@4sk>E8`Gl3@FdB^ycx4Ugkum%Dt zt6h4X!mC=LH8l^a8{vV&*p-MD$!}nt0l(w}Z=@J8U~f=$_WIZ~i5T*-X{$oVO(YsQ zB%j2a)~F!cAVwCFs@Rgc|4^-86gO?e#R>(D$APlczm)k-GN^xd`k9xF`y=xYw&X0(bX1UJQvthZ@NNZR--;O<<_bs`$mPM z$_&JHl^(5wd``fI;C#O-RI7Z|1m;MmC+9ATiCpG#v4#wchfXMW^7MtpOU*fqDSO+P zonFP8u~uZab%~*w!Zr#MZK|VePML$u1tRvO;854`lM0Hq!A=JcYz?Kxp7LxeWRW2i zQ0c~A6LidokB`Ee&2jYQh2OJ>vX@AZ7aG}Ro!mWr<}{Ys*s42~+9k_s-Kc0zCq{qX85|nfXO68amPD(d=jW|eJ?m+=1>@3y(`qHa zTVCreOjSLIDY*@OLG%QxhnJQ)ja@y`c#S>AF6F^5Mz~@&s6SM4J~{}&IM*7@>EdE0 zMEHCI*hXwr=0jVHriU)cb@|Y0_4KUZDpLh>loSWsvk(p{(2ZqurzBEk8m!A2tUY}RS)FxIgINmN@z@N zBktKX1PA*Rr4@UASf;{!Q}Pg|NN<5`sNL6+UH!qg2KJBwi?9y-fzf^7t}wz#&VvLs zRG4ZV@@ry2nBdk}O9I^tYL8CQ7vq6d`=s#?iBC!m*um?=Lv`JdKZ}J`y#zc9uNHRc|1$_SDIzo20%IF6!Ham zN$RPI09V2jSsae=5F1_zCl{m;!1LPGFx!6yfQ(`5zL0^i>%_aV$TX;8G-fP{5%5@` z(hKSZj4&HWgzC_;S|slO;AjCdU8q}M2-A?qey#MjNhcke0T8{v`)l0H>J9oeHRfuN zZO@M>u=oGt<;sx-7v}R|2f-l*$-MiuY4+AS)IOwCnG%5fI59PEI{rUgj3^9yhBIN& zKYgh_1jou$bM>ab1HIy;CF5HjE=3q(8HZB{J`GB6=<{GKqy=nAy0Bay7yUf?yo?w> zIAadcs+zd#UaegbStB=QCbn@(qFQa-5fGEHW*fq?=V$~8gfU4O+=y#X3krZ{;GYmW zs79AiNd%lE0>;i?NZS#*_i2ApW_4w>= zV`hgR_b_?o$7&B>vc*X=s7|$hMtbZC_YHXN`5qj5i7xu5f4c*!IH<{rnXKi5?^(QZ z$V5nuC8$8aaBdfoY!uPRO!h-5p&_=Fgk|2&WUFA`Fc{l0H^6w1+!UBCaNV^nX;oc> z+>C*3e4i7Q&2`qt%CrA*ZC1vsj(~5K^ecy>DM08E!32Z9&l^we4e4tn^Sum?q}1YJ z_aY%ipF?XaX&9;s{IF0$1v_KB&bf3-d-Kp+ycHe|_-;6L%?$y2X?Am`>3b+||Ijx3 z_dm34{oiPt8TEgm?J|K!_+HK)x3A|Quh-by>1^aV#Kv?!7!R-x0t#ch29LeY-x0N? zp8Nf;O}lmcEk5qH-?G}?{nwwjGGfMOELDyUzawtwHBjqwpEiBM&b=LpBgBIf@XrO; z1_PL9TJRE@eHY!kE*6xT;~#4{+Goxz#qN<>Q;Y?*SE7@HJPV2aqkd`$}DX zl~18Xp_dm=E64`Sa)VZXk|^iGQ%&qMYv`At`|#&4bhc21}AZfui^+0#5Gmbw&4u` z*%V1?x3+0UO5`MhTcWYgP>bDx--kDPMpv&9X)w#bS|-VM(3J~Ng(T0DuoXo7EZP|l zIu9>x8s(-8T+~LAH6~~^P%mKG&PH)dOd_DEACPj|YhI@3e9LN0|Lj)pcYjfTCZr-s zFNG^zb)`+G=~eNeA}#Ez6RoP$F%V@g zo7os%bf~8A6M-Rt=E*ENfVzeF6C;OhMBZjTe>sN^K&CtOOu^HvpT3+1WMQOAUlwu> zU7h8^s|%F=&8+vz1l1Mn`-mtf!$*}mQxcQeb>-9Qbu&;?oFPr5wa6xWudoKXJ)#*3D&cXC;x|((sEL0z>&e#bMLU-3G zPl3;{*9d{Wo*It*v?BjbUe2s=8!oWi0hWm!4>FpJyxKu)D#}24=<96u=W^H;A8LWV zI%Rma)bF1he&=ZA&7n0j_0H_$Q!-=0Q@X3ry$*6^_hDGKA2fx*WO%NAgh{#$hmy(x zJ18ql-PSnq;t;EraKZMvP1F~2?6Y9@keYgnY|5P`Q0H^Yjf$6k$yt?gn3_gK&XHNu z%G8<-b8tOuj`>7WakdG!&H$KCuif^=-mGDCOS*P*Ea0ZWdntOk zz^hC+w@&T$urp4ZtERxL_JJOfw#mOb!(UzXPsHru%M zNv%Hh%UYiAHykerdDKRngkMT`qrBi6kZoVf-e)kMXbnG&%IDf)?cytC<+i;HHNR$B z$$9?77{7Zs`!QedKyY1!_QS(G%5i>^;7Xs{TPcQ-+x(!_y)ZhzW%X~9Px~B9xB9cm zaefLgy!5kN4Q`T#<4iq$q|K!RiB)6e0Ku)c-`NevB`TJ z^J)w4I(H=07AP5hn6u^g+7S1(rX1dZYUu{fHM^n$j*m*NM;;F<f2H#!z}fjQQsw2K3SVm2-K z)wTT`C-sI$!&HdRDSG$po;KI$1!~gB%R*L$}c_eY9WCO!+ZF5UwdYm zW-+nzw@}#dbFGrGGRO*X0lPMEWwZWNTJv9mU+*4wC~#Hp8ok#viQ!G~?9^Ixn(=7- zEOjGB;&CA#pqc$z$I;Y_m910I$eE~yHgkLzoN;R8^DTs$yK^YCPxIPc5NP%#ablqn z)L86x$9)-n;{JI}er2}tDXU?VbK%D0v=y*VbrGdK^0rBKfVPSi+H*~xx|2Pr=7#9! z-0M4MBruveP1iu;AKQIwAlb zxfb%36zcor?cPTe*j$p$mf*=)N|NANFZE>7*H)Z%fGush$u5SIt~&(??*J`p7w0gz z9o8=91apc9PRMLG8I6;*?8@UpYy0#7Ycd%dL1ZAC9pSa(Q|& zU&DZ<&yS$(QQ<=?C^eMvW=~Mfod_~`&sNn5?Ezy4MSSeQ32UN<7P?-@lc9a79*}Qh zbplgQ54Rt0glr*>NoA?{Tp}=8Ug{GK!X|cFeg`izPvU zB|q28SAXeY%cokai{}&XBZC2-LZ2*?xr}BC;uTQw&g27CGQe{L6|Q|P<0s9g z1lUK{;~^d}@G4M)qS-$n{bxyleBgEPflUSkBflSWE7)jlzmpnE#2 zT6kOt&&qod$CEzsIC?v4G=;WgRy<(wDa6uy+8uTPdwW=reWp6XioE}*x2dMoFOK>houa$YC45X#(FAG!kop8Xy-j||iq`p2`El3zf!Dl>G9lSa z(f=!MTJs`tw{v{DNM~1+ZH|XqRZEG=+9tLT12(n?$KXKTTG0^EaDPnzCCYLI zZD#5rp;=qbh!hKl9=D?T4r|gnHHPql3G--K!I0(bYfz$1%3Wz#aC~;%>l=~%0UEl$ zW^A_R&xOnoycco%hRXiB6jNV6Xy?ytIpF|1RBjWNK9W`FqP-Tg5Bgct_uZ@O{gZv* zb(jE6xq+tnA>@0i`gRwd^ExF<$oa-11dLl$cnj~DX2w)10EbWvO>zMPBLMi>*JW*X zdmh=*q|8?oLqqasYL+f6o;(HHuaa_P!wdJgTQRq7{pfyQkB!muJeKCF!eT|N;b6OZ zB5W*?^=ZM^$;xiTVo-K*FrC0^%1rXL z>KIj2P;?t8aZm~ys!QR&LF3Ei=T&{(jlUzFCZdKh!a=+e#I^S@Zz1a22qDifMV?Sw zk?{!!oi&t3T*o>=%+Y`s+7h1(TO?`Eh|PovNv*1rYeCd6ukE`OjHjm9c7T# zN-(jupyDdLA-GRiykD@ULA%DIsS+Dfg;`#;5N@0PYNT8B&GjZr{x*rH$(TAsp<@LDrrc#zy zhsLNKD__`{cc%ZwobI1*2_0-4IuqMS;=Zn2XV9*b{qAG?oi1=~o7BO$ho7`-HUN)7 zcI_)g;Br>l`b`a%uNFyCJNI(OLhqj|kOC>d12s|nPHbwkaUrFstW~`L=-{+EA?YRu z;pXt%xr-#1fS0YQw`U{&Sd&H0OWtRGTGP;em_Ed}q=IC1^Mz`Ny zvYPuvGyGJARNTPgZzGGY6}GnA7j#3(SgQzd*fW_!z*-BrouR>*GvnD7Z{>O0eG2Y+ z)sl^s_GdZT+l235)$=s+%5D4$N3?BCA31(j3SaYVB5T{B>wfbnzEy)@de$DYDJ16B z5v2clt)1RRb)Sy|PX`dZPOK5`1i4y8wkieOM}n{QenYWUdVU}{2|b$O8_xhA%PeBZ zi#}_L(FDrKc_8jaZ2^F3xk3MY0GLA;bWdY&S2FrZ^$l-CrS0=V7Mr9f#p0?&3}U18 zzK{kqQ~QI6NX*wRkSaeLEdoZfa_>)7uGz-CzMl42lJV+vGAdYk)QC!|8HI+MfsGJw zr|f`Y__k(>ds`l!HHh0#SRqDoQXBfiU5+;Oigt&@WLgyvDmf6h?M5-~iatUn{_=P@s;T$`Da_+19!;pXq9W$N%Pu7Dfn5e|B2m{-de z%Iymd|C1s~o_9H@W?x<_2Aq6f$N18fK-;;&8Wsk+L*B#S)}pFX+%c=9Y%KX|aqAK8 zJ|VIz1iOn)Bdi=^lN)8gjEA1YxexxQ&AvEP+%E3aQ4pf$U!EpW?fQaK$>rkBD%8_k zd%uo--~(4Fd$|R_W4mipg{GCLLUxKaVbr4Y>OjXsr@AE_5-UqEnF6%@9tJYde&*TK zAA(SUN2{qH)jAWC7HQQA%N>hd+E>$NtZoGlauh6WbU7xJuV#)@*8R0TySD&2;Y`|V z+#G*4?RUcKPI@jaN~(Nrq6Dow}4#kh24H8si(~|fgLtjRBK!w6e?~x z-@SmW{(n8r4fZUF5>EF~6*XhG5Qz)jOj6H*SFLyTM)Vhc}#OHBv}XmwmmfyZQ<+ zKe7YVu}*P9TL^JRN{0yBqX$ciFW8vFZ?qX4SsjJek>LK`cI%5@>YL9zW2SNTGrh$6 zYrD*-E86!QC;C? zN^RZiWYVbBHSdIaaOw1TBd|%kb4;8yDns0OBU3eI`@w9gO~Uh1%h-s@R*7XTXNGdp z%x>`3v@7_9JN!WymPH=fVBamnWFVDX;Glj#=tgJXZ>c~=ql9*#USo8k&sM^H^!6!K zB(uODAv}oS8e>p92e2|!l;%I|a&@_e(+cXYdvQ$hL%tYW&J%Kl#}lrF++myO?Ql#* z>bN6^j2OyzS^E(~>)YlMMtQLh3 zvnSz}iOIFAz!@T`%r^A9a@g5oStGV#P6}Ft6Y13zwA%@ovc1LGUWV2NB#BjzUmXKA zC6%S+0Mc@Un<&jE;5@)FMpmOJGg~#dNKx{Y&o9eBs3kp-1F~5U8@OoPT^&C$n8%bN zCHhOcRST>L5=wa8FB@%=lyHfqG>rv5((xUge#QhC;D zpah+8@w?bt|BTG(J8o)UFA6f_vY@;jV@u5;sL4V(QjOK4NTd3(%w3{Zl3+*ccYjqUZdzumd-&TvWu%~!h*Bb;5pAb;#G!1DJy zq^<<@VgG&6dI5ihhrjtfzqEVn=KDDxYfr4g+2(W11-$}laV9!($kR2*NuM-Ox$no$ zCh8PSKPLZPa9v`79aHS)M@@@lM(}WHv0AF%slXqyv$Tci61gt?x zv?S0IHMbm%Edv`thnJ$m7KJNkW$(ql=cKe`IuFxSjfBl<6&bX|TA7C=Cn87b5i*x8MYeS`H)kFH9nRcKr z6Ax6ucR48T_s4dZkXg?sGB+-x@f@sCixZg#$wTA`iy^3|fhu?f`CLT4%DCYV_aILaN-O%!)X@ z@TXP7S?VJQ#5pY900UxImv1Yg^OiBA#TgR^iA??EEYwkK%$#V1!?@Qg4ct-)^;2Kv z32aats(Dck_|AYR9YTs+#;y0tNgwRq)n&iQ7DN!oG!M6{D)C_fI(Kn{rmnV`MP$;F z!)fsPU|DFjN2BmBt86>k1N&|}-J{BPgM9>b#_MHWMgaHXK3yN}8W>+h?LSA1;m9Xj z9;hX0_Bh3{@V^}bNK28}Qa1g9(MEw(ZvCrFBkyR0t zY&bs&1)qNi6`^Rp@j5pNvQ*uV_B&cj8R952fhvkJ*T=BsL(2t}1+OEqHnmB#+ZCce zU}@0qc=oMVq5L&*T3oF$v|2q*jF<*b!I(Gcjy^|;Qd1<24in$0TgCC{!BjwD z)sJ!J`&zBx)}Ark=|=i=C-z$u{uI&>YGr- zV)BRCa>@!;C!l3)S}5`a7rTCRE*$=~OO{d8@9cjoNjy9ar1J*5h7hFO?-L=ExyGx+ zJ0=~|lp*;3C1QpPL<(6)8|)>%=eC19R#!-68cwP7J+AfNz#Az%xU zaLa1w01G$pqDk#e27QYNkkcR!;|0KK9dGUjVHdHYc*vah=A-rlv}wEMGi;Ith8KE5 zX9V7k@P12NzrkjyU?AQ+-{$%eZY)`84blWgD?vw7;{|~wqj#r$pe-rxgl&B!4iA5Q zumzU~wwcGcf5#C#qbtleYh1A}U_n@R3hEP_Ig9|HInZ!mxI!QcwC8I4QRIfW)r<&B z(#ALA2-i8$)%}&+MUQJ*Ues5Yk-vZ}h)LKRq0Znu)PJNpMy8T0_Xd`Kw@40n;Us(v zo?-*Y$O}9F21lloYxDkN|9)9Zrk!j5Zo2mnWcUByvY2z@Jp@m%{in>5$c+Y$vjQjY zrjN$c4QCo2jk5fcYkSXf` zKq1WBQ8n8s(_M7H0yr*wLT?GT|Gk>Uz0j7shda%*XY8;LKk6Dsu_!6eRfg=c$`}uv zWgV~SVUqm<+RuKuvc#CimqvtQz}f z5pT|as5cIe7&}AEv+$Fq;4Zi`D5#q{&%*SRHRmq4Hz=sL514)GB_qj=f7^?HyR7}$ z;=D2!Jb;XN#frf9E+W1Uva@AFssbmk-nOe2*?pOMdvra#9`c5VkC}yu8(Kd~Opkv9 zNKhv^osQ-sXU?5_tDAf4K2LJz;~*tt=9On&=|Z|CZygFA0goKX)I0b-N>87Acsp~Lte@BaJL7^2s2|Y%Zqn!71wr>$g%&Zxpu9g_!)4YT)FFV z%hl=Gr#;%x(ER=mc|V7zc>?ks7+{dhyIYmwSDali@BIYew$TR48ugV9pZrf%Hm4Lt zGmT(|-1Cp*az}z%lWfmtvX`7A|8x(}yVT^beSLMjY|0n0DO*W3+MRs>Uvd7+o+w>) z3@a?RLwb+V6TxGsu!QW;k9G01#>(sz&fJpBUxPelrOm_|Sc#6KJ1~WbBwG~u z(P9zKVq#Y=GoRonP8N;uPMMPwH;CdLnZ?0g!p{o^nk9lysKgPF5 zug4*9xj7yC%uvHmGO3Z1=xMp>Wp&Fu?_TPJ235zF z1L%4OuZuN|R@V*nz2pXr|B@Fn09j;B2(;FLPga5LIgl~Hs67ge5JL-4C4?3@rvm}c zpU4i)hM3-ungr6#`9$MaIa?Yv7DAPVfTCVagM)#8u0ej(htmh5~k#E zPV$&#HOu!H&~&1JMoc+<$A&d6b0;(_gX8{iaDr8Cdk|hCzUgMj7-#nv8L^beFD1qp z(BwwikT9G(jpH8G#v@ausWnA&r3mXcErpvbC z8Vv9Ur%!IK1voFD?e*!JpnOGM)$>~O?T$TWf89pEB|{wP6(@BY-2p~W;;@tTA&qa_ z>!Y*_Oc1ke?U$oydgN~&K+gUQbi*c2dP>(M{)S{*(jJm*e=6^s8B87ugall+Okr_T z3w|h2lbM0hUZO6@-My0Tl2fB_@(M^4a1W?B9?s{OP1C`2t+~kE1%U7&C`7S6zR3a( ziB~#k|4_0jVHZkD8Ci??7?8Z20MQ_w;%y+SoA0BQwXNvD6PkrxgH&dl0K2rc{V=?S zmtEBa9;PuS80K~E{EbGCd>1s+Thbb}NK1A+k7?iYC9_^_JJ5Pw|kg7euZN}3@nygKEnIc;t; zRr`}AowJ8~!|M|WFA=EHHW6LIub~FDNRUzxU%E789()lt8tqANEQp9nogj_v586A8 zWT|;WK7>KD6#i79#g720Y!$wOhTbf<_n;n@?|l%q@c}~Hi?(#$@aedoulL((??w#+ zb$Gg~Ewm!(b;lgspdoPlcP2Y?TRX2O#i zeh*)k7-JpE7e%}P;?}ZcrP?T7L6Ja9Q1HNA06bZJ%ed!FMamvu)AvHM(WF!vQ-DUv zGU4WpII@}k)cm==kgq%1@E3(-7Bm>`|A@y3Z+jPRCzK8p_VdwWQ z5D4RDlv@4x5ux6j#nE3V=uq>V+;#yXuy|<=EZhj;V*2=5+C6Wu74wUvFh$XBgUyNb zI82#}^)NFk@19E`0cx&iltqBT#DI6LpHW%+5xH`Oiver%o#6qlHsjtVm z5YU&6t$xQGBXwjDa73C2&vtcfkAiy6MB;gao0}QGu-Optx?$B13^25E9=F3abXKQl zTy3_!3*g#paE${cQvuIMyB*NW9%fhczwl#`3C<4C0``y8S{8rUp2oqiMCNhI5tr5i zW3Z>5A!ZU5=uG|5c9+re^x7gslwU|iJcy)12RbO_`x9}QV^Dy8WqoGzfC2GDF(boo zi`FfqYmEZn}7I z`ATl&_!CuJ0ld*+VD*w+$O>}1_2E^`_Ca;~3lZ`C?vZ1Tm7Llhc;z()8hDJwqNPeJ zz7`SI-J0S7t(Lq_{QKT>A?vr+lXZw4eOhz+s9BE+CXAAFgZ6a&X(x>T?rRU!62B_M zS(c3k&kSPaZ)^9pR{5I9f9K8WUniD$3ie})4ur5Fv#^WDzBX%Vd-nz64qC;}(SPI< zj)ucq0;*4cPfk*EkY7H)=Bd;D$jJi;iK+;_T>az-I$7zBs=Om#!!4J~7vy%mnoaMU zShMmxuR@>!^7}w*kyWEPY`&30jOW6PT{j9KuRWpCL`_$ zuu4{^=lp9@0Z&Hy4$3HtsGe@a-s$)mQH48zy9Ee!Kq@~NgI=3_!y(WK@^+&MPT#nC zhD~ram7W}feoSxCcwOd9;vV4JsYVLfTy+2!-I#3mVHrRp+_}*rba+Y~dWh<~qk^JN zeA&1sU4(*5N_uahV6?5?ds1x+xhnHd z)?=cuifn4NGr=H;mXA$46iP3mKQK)cKhX_xv7#fUeTp(G<;du_J1B?WoMgNBT@ZLK zqfH1gZ6d2a%(rOSDy0l8OcOf(-LmBt{ggvdggiGce*l9Ip9i!X;U~Ske8*Mrr=3EqqQs=tf2=m!(h1z7a*2B zVwe;dWQP)nK}Z-Q%85_Hi0*2-mp0;>H@`Cefa{oI)!+3hEi(V9OShv-LYy${xG(YE zXc4z>$0-QOX2yH;`Q1Slh-q!Gx=I{iv~O6Kp9QBO|3E0ZH+p$@pn?a7+z%adBBm2d zeiobjqWYjU;G6sie#`BLsdFU#hx=F_b8>%CxoP7K{BrV=}2EKmNWYmC#BaoYsYzxBC;G zcmTX3GG56G7O9JQ3cO|&dK(t1f@aDBU%VGfvhtGy)=b%`flXc4W;Z#!fgKG6)tEin z3e_s|4RN_MPxlS17}7f@q}nmOK6qVekNd5AtL=FCQqiCL(2J)`eWP=^^7rC z`BmYV;HY@X*`MgD=g~`uw`pgv8;JxFYTHsVrYcK`1{@6vw_56X7r3z1Pm*v48*6qF z3^s?8lBFyVscv+40glItL`3|8hY#r2lifkVOeJ`%39eb}Sr3i)!g2O#s2fEaCbo!` z7&oGuFf*wrq2*KzX1LN?NN+xk8!s(Pt%aN^bNtX()FBr{LN(F=55IWevKmb|Z0Y@*c*^)jZK#cKZuFDbE9S^3~ zGIYLWmFb@~U7GDCkOZ3w8#@BNuud~tlnkwFo<=zy#4Wm*sn&d~Hm#0o2FpKHwW?vd zVA75>)(G#i%|B?BY6kNdiWiWWQ|7lB8n1^da|e+$k};SztK(T#y=@*frMqiYS*LhU znpZ04R1LT<9|-*aMb|k5i4rwfy6ji4Y}>YN+qP}nwr$(CZQFchP5s@`Gcge}n~YrL z>Mm{`e8;v~t9Ma@d-f2*Wsp-7(kEm+vkq74Ah>hH`L52>*>zi5*Vc7BL zk4gq*P(oix#Jr{-X(4^?&D~!)kSB~xY=tf}z6<5e(yDee_Lt0f8|~!)(brUe3XVt+g?wmfp&0MlTN~bm%~h_Ywm2`< zD(^B{1}f!vv!L~_ElEMVd+H;?FLwS(AjOs*d-PP;-YW~R|DD`lb~ zbA;FUa7%=~PJ`xiOs_r4Nfwo49e8&WAeRUqndzj$pCcMjIw?`sTD)5-EqHP}trdxO z66<-k1?7JVYuyrPE$UT@77U2(6q1xBkA>+|is4uKDnK0Z-qSHr$nP7FUHAYEK=~Ga zurwR-y~FmOP?g-y$i@vzsC%F#8bn`y`e6i2Dy|2y}_BfaTyh2%w9E zL-3t4I;*If;)utc#-;W7*)96KxV(21N1EQABUuM#WY=Yo%8%s`Mn6vI-EEVIc`E9kKg=kM zYd67bpz3PeuoMfXC2uuMlzOz&hZ}A;@1PLmPst^-2`;vi<30x9kXinQsYR|K9}p0% zDwD{5aV^3}qgx$$Wn>H&nsHjkfos7QBA`BAFgup*8DdDitU03?1W%bJmOdgH=TAJW zykbURvJ0U9f>jhPyfacK#pWQG_*qz8iDD}wZR`pJoQ z9NL;1wzZF17e?-Tk>GEFG#@DSYgw83H3pqlF~2KY?|7%3M1kd67~d0deV&NnD4WN_ z3&|B6W7ymsx&OXbNTnCqrvuWQ_?%(g3mcd%Ku!wd7Mh+;k;BbnIU(n0;b z3QkluK%h6Zujl>@l6lko4kf5{@T=rBbBP^TCj>u2q2oD4CzdnOw2_snc zvE3h3j?Ktuf^S&~n%k1%7xG@g^S*kgIQ`t4GixN}Jj>^$>X&i+ZLzbin}tWEjG2X} zr9cF{f+C=Lt?%?cTep<4T~PzoPP7+w62nWLScfs%<&H|cHi=6$4cjt@Z|?)V9V~U3 z!+&@mBu(OH3+k7|4ZEKQ%8935`~0=qvYo6kdC$vP!#b4}7M2eBNaz9}^N!4EQCM?D z*zr&L2NExUc_z)d1cYSSYSm@vsOa{9ouMiY)XRfXE`wJaVf)H*Z&X_)7D1ZuIe5Ux zW_ciNzn3eMg)0<=%l-DSx8JWCi_631#%2%OUU{1c2jX!xpuMNCzlcZ*56Z?ZKXV}fl5HG z(I>{(O%P{+-RX81@EGW|chkD`o!Y^J+8=L|TnInXZ9IQw4g#`ZzB7){uUd^>YhvaE zu&eL4z4TA(&l1S5AfYs6G$$kD)fdCMgYdE{b5&P!Ct>|k&eJ467d+bC!mbY8j1qG= z-t>%_GPjTD`dFjTa;0qpON@lv7=XMkB7|L$`PKzd`^OrX%m2&^l4L}+|o!Y z^cDugp+J23#aXd@tFVuQtz&;HE;E=J@qVF~=g+X281Eo&gQ1@?Cz~c{{4G1^RXxJy z(TKn8XT|Gkd~8;5LF)j8w)+r=N;g=k>L90Pl!!Ewe_V3}oU!b>Ua>=L=(20gV1O!* zVkAgpqz!d*MO%ud7PQAZE>ip^1|&hEga|m-Zct>5TgNHGF;n>+3N1w;Wx3&2C8?Yw z<8F60GjGz8rQ)-A*j4TNgp#i`0zk|+Pg8`y>5hv$&OKxmLbJy;F<`N*{YEbN+{?~x zXpqLU!o%qGxq$SCnPU)^bbEe)=1t|_IfeKVgP3MPDRR9Dn5m&oI|eC`3oV-QY5F>3 z;~*Y_mu~)sktUn>b68M929JWIg=v|+CRAKBIT4d7P5hux6{F~TTP7#77KM2f)JD|? z;e?JV>71Hx#ZdiJ)XP|~UP>f{DC73scV7a?my-6bf<*VUW57C>UGc^ggyU2&4`h`yf*+3>(?`<^Y-_0`5&%fG$bpx*_S!G?c-lE&W1*_ zXI(wBcHASuyr$u43%SmS|E^hofiFgGU+d2 zB#CLtuS#q*V=7*-PeD0-#9J#~?zJBLin9i*Ft!B!2k~TuEZWsN88}T?h zcSytRMBR|fWqfBL?FbPFY-Cdm?8-Xq_r<@O0qj@8l%xiaJXo&2#?_RGZ7|*ee)nox zC6=lP_<9iQteg0xz-_0QcDzzj)eoy>myj9EL@ZDle`_wzi~Iv&5>iMXXLPKR{ff|k zQ;hsVo)#7`8IM||tJlg7?pLps`1!7-kO-x(5Tu=;x-}T#XJ+=Et(4f#n);7f8_LaF z(XNKl4O_B}jf`vrU?}XMI*X*cspG5oax!y`OQpe*d464I$FxI?`vKXZ1<2xnxY=|D>$5v&IR?wCfgk=098MY5-onn(v4#>=GiVo+G)cm8W=X091U?}x- z<)v%^-FKDgtHD)Mh)t)>D}ZR8$0Bw{X}f(vy4S@fan-Q2CuF4 z5JxC7mm>g}ZAVD5n^w5WSw_}+h{Y-AXRtw7Pbptlp2{ao_}f-A_XA{}vGSD}KM}rG zWk1DINw+)%K+xSBI9}MZpe0rkf84dUlS`HL30o23hVJ1@a{8~{(5hB|f77bW%xgjo zt)98f9#}uP|0ZDKI}5yT-04&%Ksi>R=B_jeY!iGFlPh|jikM*$QF^A?q(G- zIQ6G|SZ6jy$F|N~)NN*SG1Hy7hl(_dqMSWp0nAKgJ6(5TkxnY~@ZoCc+v!~)+Kmq^ zk=>LTtA)YzIAob49V$kpXtg@N`=9qK=*iS{8lbUtUkLjefAM#HS!J;Gq!#Fv%PYq~ zi()eM7)oSui4ZjWC>sueWMp^--^QB6iPV!CO*u?tBR>J)yt5W|N1W{hT9@BXdfhBs zru5kL{wl-tGA{8(caqt~Y^wU%7iiAUr5{1f*25(g6t_&*a!qn!9A@xVHB@`V?PGDI zU~|oLUs>wEj2DlR>q`ilaDFz|8$Yz+b8VE;%E?JiB5YPtL{+1?8!q(BQOqP>)-iDD z548%_GJgP@!E{%2Q}WOC7kLlB)5hRzmFvDJh93w`6_V#Kl*7T7NJDS~|04J?p7SMz zC<#Xc3;68U$O7sbC7u1AEWnXquJRKEdu+dM=pc_9$4C{8pmBle`a@-wwZ?T=)EwCM z6ZaTqGW-QTKR`LtyfC{qF$ZGKElJMdNOL|=R^(j-v*y^E4(dH*d0Vh-C!bY8SyW4h z%k;I|Y|z|Hmst?=)h3hx*(l=U}i^ z%+I%e^j(10`a{IA#^w}k=we1>EeIrJ?ya&e5qUQ)q^o9~QA4UANKPCyn1(eg-3`65 z$v%rzM&QUDwJ4H(ThRAXV>K@*9%~U(wp6UaO-HFy?fRg8&kfneDhCfGkkN($ug4RE!-Ixm zcnFr-d&PT-GLa@~A3jhP$p^3n2yj9gMi!gqQg<7q+iee>Z4e zW#r!h_rzHk?6up5ua?gw5?!*fhOlJU6PxRj?lN4+8x5K8j+bPObuJI)=WO-bp{xZ8 zo#D{P-Y8L+GbO%c0#6YWM)s%FM$xFcu@-XlopO1ixPJMGmu^HgH9l03mpLdO zvS7<)*B&@44FC4)OTNjWYNO>TdP}N`ZZf<^O5W42Miv*j=Xu5LO7nyh5oYiX2QAa{ zDerR9;}{jAl2s~t^pryFYRb8CudW%%r4)W*6%$~6X(D?l;0Z|ys?8afQ^6WL_(gw~!#hzo-{sXpt}&z1-+6F)=ds`6SJLeX zMhB+SY5CLKgy=MbN#B{a!72$pCXGIdCZf<9y*;sq$d0r>{cM-euY}245f=L6gPcrYU!QJKH`)_O=t9G9V%QaG4I1kS7AL)G4^K1W za6*Ts)~jJRV%V^yi3%kG+O)U|yNv$sh*sr*H30oq1^t(&(cD?d2wE ztibK;(lVdv0ESI%_yFW6x{jIJ1`p;`W?{`O#*u-_G~jH+#(mbPyq<$*RL_2b?{tnQ{{CjrDJ{ zp@BT!Z{2|Iz;aG^G;J|cH%zW}DXpte6A19q#v=6bXh6Q)qiEn&tuRocn{21}+?_3o zdJk{*;+J$+Az)*Pt0E4&!wvtHlR#>a*9G&LZ=ob?GHwhxe+Ch9ehcJ*y}r>D$xJfi z^k&EAJKGMmyvRn))ihJH3HN5bh_#-_<=*xB`{%L7UQ)@>x5#Bx+Fx=Vs0|%tLt#mh zVj=;Yw;hLuPhbp_idk3@%z>^L{&M10}|KSc1}J_o2=>tqM=lYI|bK zYwe8WvC{nooOX_ePE$p*GvA}m8@^Pd!%GKm_TGzKz0olMo2ypD*`W_zGd$otkQk`G zcA3avwFLbJ#d1XDcJi~Mo(Rl!*hF+b`7fnD%O*fAAp7wS+8`dZVpa*oi(qY_ob^Hm zLYRXPx#l04-HZt3Kp%6d<|e)o7kg3~bT(0URneIWLCf%E<~13J(4kYRP^lY-fZ#uC z@BR&sQwo=>?%CAGsU4AHtC|}P!*3hKGQK@@VM6Kc7-RKk!7h2|)mzl9`qI>ZlFO*` z6&~d>IS26y-O{UxxLA;V;C*k4qMyE_JYqPrTIig1N0G8+4r#w_WMmq=xrIox3C!S+ zL0KjEkW$?Pi`qtG!1tDtZiFXemSj)05h1P2Ftv<(+Q>_bZaEe4G|QB6jew$pB5K6J zW?EXj%ooV7U@O)te99;KIAf=ZG5VsI^zrFhH%doD>8bG$I^?~bhzPgjxCFRG7l*eQ zt476VT|HEssrK%*FJCWfHp9 zRTm8At8dAl! zjiyzS_OP$k99J<{W~k|SJId4Kk7v@AY>mdV1wGfcDI`@8qT&bEbfmrx`t_YU9{xCY z3Ba0gu`pU$cYKEr$Sa5}__($d??kzU0||}IrSCvjAPH~si|=MYerU7%q%N{;NT1xd zO2u1I7$%otSHV*q4wdO4*_8F z^Wys{OSoI?M^p*JsBE6@Hup?_bm?{8z)m$#M?tV ze&R5I%DkvWPJgCyUE&a7!n-K0;M9NmGNT}|SzVZ)?%7l%B58rN)k@u#iahG!}JFDdXlkFlAJ^BVW1ki-yB~g9cr(tO&sB6tVbVv#BCCup?t6_5tkBkaml44qN z38&1?#Hd{-*?iFp#0DjOuj3?@a)}DAu>eyw>%SqxvlS4g8rpr|YqnvQHLXZk-?oO% zyfU)gFB3<42Ym6%P<~aD|0k>fg&YRjSR@rb`{l9?lV5|&4(C8XiKz0pru@Ci-(xs{ z%t|uLDPy~1QwbHJlKL=G1jfo$yJhMWNYiiPU`GivM@F@C7J5Eids<&-B#D%rAaGH! zb3Kx_>0?@>Yh?7el+~43Vgp*%-*@0}Q#m4~zMMd(DA@ozW|fNTwfo-2xXBp#>V+A)6<>Tjcxmd4U% z=UVRDl^&8tF@B`V%|fJMG(bi}G|S8EY^T%dVZ}tR@F+n%VT|cCg5~#52NF+?Gh-nu zM8%sFP>~`Vy;W}4i@3Sjam4g$q@uM)Lx}std-{|KSs|6N^h+lgDKo5p*Bm2c%yINS<>{IexLahSo$=k*nuFSPErLQQOxS37{4FlQ6QT< z!j?OczNbV9(h0!5#FW-`q=`yn9=6Up0P(>KXP zm&Ye89<7b%5Stynpj=V(ZIf7EZ}qsIChEF70&1RY;hkF=3#*oinFj9dnj>6H!{N%u zz^Ydot1<|DW!FqiCHTFJ)J9Ym?Yf|Cbo%9BaA#3rjFB|ZBcSB{hoC$FU#ij85h(8N zQ)(^_va6E>Rt3-Sg24sE5`ma075m1Bqn_5wUEYwSg1;gK!0f82RdNF4OH)XHEk;laD z23Yc({~8_GtAb36^7rMi_t}&0lkMShbGutU4E_5TMnu+@aLnf6d`?({KXv1B)_nub?-_ zQxg3}foyQY%O00b{KsUn-=Q{X3csb)@ywvSYsZym?LIqHZ;sZe{RVQfr@=hVlS%KD zyIIOxZi{i%YrQ7T&>g(iVfGjFG^~>_j44g|_^|^UM{JUsBUb0xt~C`Jib@tz0iJ%l zyD$HA&s5CJUy@7J1C$Efy#qMGUI-5&Y`_kY^$zeYG2!SJxE$vc4yd+aqig{aQRPL( zGmR;+jX=W%b6R5NTjIbyXiTeOIlPvN|8z9jGTlOa*M|Kd89r*k*ed!iRDf_Uu$7eQ z%hmrHJ?&PDB{F!X+$WA^q)UyYl7MEA4}8uNr4ayN0qgNJdofxxwJH9}0CaVRZbrvy zY1f~akgw{1wnIN@|H2WRMi=7Z``#B-Nze9PM9rA;gCA&soPC;YUQDo~!V;3+lX_U; z4ru&NvpR)GhB%a343*lLJiZJbov0XKq^@?gLf5HO+m;krYZWir!g=!fBn?d{Ct%N+ z$$eJ6YpgJe*(P+3u10~2++!$ZY>y*ws6#;&$q5{=+*D2$r=kcRor9NEGruf?mt3Zl zYYDG(Se#dxh%Ir{R3`>LXuZ_sQmR2eX$fN5sy`oW-FSIp_cx#Zo5z$IIU?s>SDjfr zq4WvHYkpxVl1^{W3wF&X6H>GaaXw^awTt{rT-<-i&zIlNd&ef@E(q`|dI&OQdmJ<)B27LRPl5oB z`o4Yd9KgmtJ*1Y#Y+McivXA`uRzFg3W?FqAX}*Lw?GX};47=(Si(Gtbk*{hF(>arnz*Cl9|=BtT+5qn$9 zk)W4HOsX@JqBoMxO7wwu(!hT~b-|koRneTotypqF78jQz_X~*i=kkX2 zui42ChX3yL!C81H*yCVGX2_^3gs!nOFP{b<^-2bllC0M8#Y9N@=Op%kU_Jm?8nMZ6 zU!_p}1g3p+)#h~~Jl@~(Zg^E%Cb13nkTw!bC3IHtejVzGI7KlWs|VD;E(C#RVf;dwq?awxg{*+D`=zl8;~M8YTdw2~n?13jxjY%rP2VAby$u$hQ{8Wv zrfrgR4jTT8EhX2bca7j}xao7M^^H-zzCL6^jvLrHkY!DnQ%7O9+Hsg6iq*&TtMP-(@}Ex5X8_ZP@uY9jWZyX09R3jPAi{+@SI zo9rR03o_E@Rh zmya^=lm*}y5_s39wOfBU-D#O!dUhU-!$PDUUIn+NL05qwTJ7gh>Y5*aQm$GF%&nns|&~ILu3SB5o0>mRW9VBC1x=ezzk7%{t~nC z`f+x=xA5r`wjy>7a5>m@_)-9F=W`0@{&9brYaDZF#Z`oSUtUMruk<%>{}7Bhjdw#y zl=q&03S9G3#6Lk52@(LEUG{+xYC=cZ9f=6^P0?CIibjl%sBiNt?UDK&jp%YynWm?R zer5o2Zw-~W?Y@nNA|EwAg~zQ6BKtB0*8k#*Gqaw&MrL`uz1aAIbxm)!uIiGe?ZV4VRwW`P3*Ot>7@x@< zX1aZBze5hKFF42s-&>NW_pz~0hpP(kl6401Lm{Q>x0@WSw);1b4R`P9HUQABnK840 z6n(pH3iUdw>)YMwFj)n&=3&vV1c_+ z?BZoUN9K^d!{i$z4CiI;9AT9~Z8nt z%{7*w3fMLeRKrWch7n8E<+!pL>N>l&8Cz$`W5pcY^@I=R6y87Jvc!&Bb|~&FM0H)H zfMF%AJ{ok?o4c31^u8JBz%b&P9$#MtfAQ?5r_T6znvW{T&&LfC!a-+|q6^s*a7M%G zMZs^w%g$Fx)L_l=u}8BhrEcP7Ec5>X8L!?ZjHrmknv+&^V>A&LaJO=0~ zEo$T1VuJw0$HllO^^#>_m-YgEy@>*l{NJq_k^Bh#QoJ2Rn*_A0Q!lqUL%bacJQWx5 z?>U!2tY}P$U{H-BGe6N4e=znnBs*fR1D$!kX*LZZUehw(ahy5)F7hj7pu_wyW_JOsy& zNWi6jiHmp-dYt91{GD8>gAJ5=w}NfbOY`O@6exXrn(ahjMm)CAgO%LY?Rgmm)v|iV zqx`W~R_{|OdE9AtRWZcdRt?TyTk{qqQ7IPlwC8q|40NkE;p=WPc7Lw7WLA9s3N)O` zZ_{5;7}HtvG`l_?U2_%j{0TIgM~c-k6z1~#hzuFP!RH<5nTlGe5!jk}=u3}HSy zB2U&xDW7K1u9DH_py2=`2ltcF;`wBdK!;H1xj4a?m!`|4&&Q~p(cLW3Xjj18X&u!u zPJy{gu%tn4u8rXIU-W)Y^Hn&CT7W{MREms~EC)irZWYw7GX@UpunNPHoU|uRR}UWp zf<0z@Y)~@hDKzcjils) zmq8F07$<%CW$jErA^X}FhkpVb>_WRjVrEf@|Dc(_h#fh33pAQnZmu79%0C3u%hY)C zUvg|HwL`!!Q1)?3l(-gCrjp`QGrx1We~rSK1#$^ev#y3WnS3{3bcN`fJ&f$Ml9tz- z>#2CT{EsJMa*dp1%=2NjAs(joocPFme0eo-V(F~03-0AiHeJO`_^IGYk{EvM-g-BiGixH~6lX-Xsc z`=(tmyaGMP#L;H3TFiMxwkM!*x;ZZl?X}M(aZjs;L9OCk%UJji$%0wA>vdNY+L+R) z*SZmCkA9B$1gXnKjMeU_hkI$h;dONe%gXNLw1eV`m?Vk5>p+Yy-a|+SHIzu76RjgtRH`J5Le+cr#O=&7o867%@HKE?zw$s}QU%RFeWvPhj zE?Vve?&8fe_BJgN)5Hzjh9lH8ld^56Lbphg=skZEjgQ0t<6wa`T1?ZNpUo|Uh z5zn;_Q{D=}Z#WFvg`-%@N}r>qne$R_qtx(;BDKO#wCxNAD68;djZ?Lh1~R>@r2!r* znhpXNId>5~gvw;eZP6MNUhfdvs!4NI;ejc&J#>{%zzH~GckbqOJsXdEx#wr;)8QiP zE1RC}+1UaHm$M5$TasN^;~gf!-eLvxbPS(NGS`LDyK)8rXSdq`WAsmu8P2iFqu%`K ztm^XvQPhdk!WQoBy;eZ!jLv!oH)EdUen(vv3Cc6U{7g2uHCOsTz;}>ECYA(rB%tX` zfzksZ*ng-Z_`_6IGWBoe96`oJG9YAQG{zgkuYw`Nek0#VJip@1r-`<-X3CyUBtycC zIK4McIkmQjlEM%hH3)(LD2x}NU_3EWrqD6(xkZW#-oTvA_VhYbZitlr4ntY2r@)3W zfb&cLhZrj=D?!<>+s+7)_9EZR3L-8vx4)&0yr?BP844GLA{2gcH}BAH@OrMGc0mu@;t*bNcf1MS%ab_5ZQT)5x%{W zLVtvs#%*Mq#%bT`N6lv)=p8esjKpTv4Q25C!AD|YrmuIsQ@-YQ*vsnFKo1f;TM73w zdf}qfJuD%Z5CdyggV9LY0_y;dgt*8#9BNipKTUPBjqtYX{mc!h`G#kb&R6h1iXI1Y zI%B*B_*6v7q6im7e=-$&@04-NK+W3sH!!w~sx0FFi9CQ6((QP@13#{lcY!34PzW!L z_aLlM^~&6vdmz?rQ57VjP66P)Rrq+v{Q0pL;BN8EdavoCLa){+&idExD?;BDzRCDc z?}SqTq9q420#1k67pcD~e?G*;mm0r@s<62Pya;U|>Ye;(MC}l?L*%BldOd@wl|U~? zcie~Qa|pn0Ay%Hm?;FlSqgqlxpZdHPYM<_#sn>&A@Vc&D$RbQ%e8m8`2k+3%9Ap_s z3{#+nk}E;jiipg!gYdxv3TiV`h47uE*$zS1nMGX|qei*#nq#Aex}}n!+0&{krG0vg z6hpnX`R!`vcw%km0 z?RjL5q*0h_X8$?5IfrO6mL^&<=ij0G^<*>5fZWRu%Xm&)tfqBZt_-?gPyA#jZ+qAQow3PNa#qd7g9mhp1tkpg!0Z7J?5$@+`yAweK zfsGH!u#ThUsOo0-?Q%9xQ$Jxm1SaY4pYn$=j5;nvkVY3Tt1FO#GbSyKJzFAHK52uW z4);~&F0d}x1d4Zh@Q$t&=f7GO&VR$}>3sZBJOV(X%!GZyRnp!q43BSAW(n_WPz+Cr zjH|6Li*yKyO9Y;4)=DO3c#u$#nQDwImW)VrEIKeS&QDcM#4srfW%XdhT30=Xef3WV z4bFapeqq9g;|U}R%*AzD9hu9MnyxvW3RA4rvO_~S?urAQ&-jpnje6Z^Twrzxm-7mih4KEH5 zPK>q?F@%~Cid@i|@0<28O$LwjWqY+M*+LT2`F|&?d<(AZZ?1uX?9~9}*i-Ikg-d;t z`wD|~S97>VJz-y1p?BUCu!V2Q(v|=NZYgdF*$YeqK=MqWX|qhi0@`;>$Dgk{OfR4v z9v-CjsEVd^*{z#$CnRmk{|4Za3>*oU_|h6JGrriOz2co^^W8fU>X^=tTW%?Lr7``$ zG3#x>?c_NDQ(yRsR*=$H;lq%s+Ad@!%|QK(N+YOIkpRPdcO8w{i1P@Fa@p~5eQSwN z=bLQURSf;AUQ-l*PgfVVDJv?bN!l4zhOPQ zs&Ghb-Vew9gMqa;yk2g1b_ZA{fG959kf2&D+j<9GgAo9?xx>iF?mYjG7%~o+uzB+T z)>QF@4#?c%0513Yv$E>mHnp!woD zhL)IRuLN5k?x`C@{ji81CWOc!O~2jsWGsI;dX3OEDQ3yCgzEO zpV|$0g3?j+A2UJQ0I;}5cA7h%l2)6xBr<=ugWo&FPaF%hQOU05;(|#+;{@x*&Z+g* zb0&>DL!SBIV-dJyvyC0YxCi_`-&tfmW@ej_YGqsv*XI4*D%Rs&WiZa}v2ml^PUUTa zhRDlUkF&_O&%==ryP1+t<6SZb*3{C%Z}RU#g*Q1IKMDle!W1$#|Gn-BS3#}|lq@VE z%kh}qGU#nn!51$-ZWIO@PS6w<+xiIqm^g#9-jjeh$d3houZP#unM?|u4HjzRPr91h zbC&WS^}GCn1YF!{NHtXUc1n5H1&BUr^Zu~D-pdz$EQl-Q;SEXo$tKbnHuv|8zE9Nr zr&I5h^&6pI`Di2xx?3uuB zN8v(0UB{*@`LcjO=?}H#c0p?tY@d#|@LUc5oE?9xIarj-Qxh&}>^dA$0)wGrK$mN7BSet7edMB~cRsdu$WdGQQhqHC ze`bje?%6kauf@6lFjJ-I}y7_tqx#2uhr=s;J>en zC6eq%B}~H^_%_0ZWp++zPaXA)mY8zaB$3n;coQIQ;7RjL?GS(32!d&XX zjlw}v$+xLB?F=Hu!@Hk5*SL&!b{tCp>a1b(4*1p)#uTIfa-Yz;S13a%Y*Yv?iR?&* z?sW`Xa|ByFk{uLnZ>{wh!~EY1#hb5uFPO#)anoqr$+lOI$qUBRYUbvkjh))AU;khD zXL(qw0yx4`o>VfDH*HdSjDZ_T*|4iV4Wbd^hG8JrPtCE^Dz9OsPHwh)N`}yImGAnfBmp)!wF)g!ri1sfF3UY)<3&HlATiMY>f>lXb_CS6V z+A$REev|}tDf_n*dg>nuloWYF`3KG-{XX=-r`Qa6Xso}oPyBh?kvI7!ygaPfE7@${ z@aPczU623` zCc!~{mLk=j^G&DNplCbZ#WmigH?m<-uV^RU!!^M}H~748l<+=gsIzeBV>$JI-hM;r zZlVX<@(13jBZN;eOP!HRo?P#kA_v>*2f?-?zJp@jo#NfMqM^SpoYLKeqxwZV+r>Nc z$8-v}Hww3Bj%eeqqhl|>xoPj`!`Q!>V=A&O*%L5gYmip>Pofq&jLf*{)&LXBilpwm zD>h9wPRMJ@0j^b`H>667HD&T&2z>mBq7XRrs~>VtonVj|;FuK_c<(930|3Z(?2TWL z`r0$0mvXP}kF{aM(%xr(;v5mW9(z7ut*st5$fHkq!o-dG8} zS;QwnI>PTy#a0N_Z&}nE3q1>dm=T`DmN;dXbiLm~SMUW1AHc}y{vX9bJ4~|0K`E&M$5eWu=93)_H0U6uaeQHr+ zu`mSIU}Fvs{i(h@_Uc1-!Un8g=Xc`XbBJ6#Q(5$v1oSyXJO>*biis-5EL~V1Q~&Z; zf7$h+kM1h{!TrBMP>L0H1iNAY07fT+Kn0D(6!`1Q8A`t#EJGyC`FpF0kiWKI!5Ob!+|hmRZ5of*cgkkiu< z*(?q2=lfZ1&iCri!yr}8zz<0OUn=RhPlB%e+`ZGV>9@tkOs2!f!^g`YMz5#P+Vj8oBMs>@CPdrs|Cy(rs zHaR_MGHu2|C^1&q8Y@d*$igHGsyU8&)`B74h}6)N5!Fcc z{mS{s-xYb7wCjSVmyv_$uVT(_m2S`h!=RN2Lpp% z+VVGw_gJni0Pd)A*iSv6wu|B_Qf1b-GPmflIBy>G7?Vp;H zpD{vSS^RSIuEBeP_U0E`fwfz_jf-h*gJ5R?unQ_TNm|%t6B}iQ*2Ws0=rJ{M|Nzn@-$L@->6G<{gj?XyhXxhH$S6+Wy*OS-l8I zR7OIe4aFC0NvY>FEFjqR5dkh7jGAKg3PRg0AslG{Fq*OliG$F+9s2@x4cZ~Rt_W09 zy&cMY*ZxMjqP90DFu6KopM2G!zHlJck>&?e{I&}2~y?bPJq zlov26U-d>X{*I`!S$f+n*?Tw)dK>!`06u!7g#F#%BpMP;z!85RpYOaOqGpvRo^Dka zLERg6-MVE?EP(TAs)-gOiTD~39%$qWUx@Z24MUB@B7-<4zv=&oN@(xX-2Fz2&h060JtEmHUiQ>S)40(=x40;J!K=XE!uS*kw;6P(I zwA*%sw}#{QYM|;4FRAs54dvy2$Q$sy>|^YLFj{+r=BFTR@NH`n@)HseD^UAGGsq<^ zKH*0OQp^Oi|F=A>L>z0q0s06#6SVH17rwzcZ{7#JyswShAtAJ*573auu<2|<<-b{8?$1eGFN)P)arqZzCCR&&M0C2a(QAZgSIzqX z$Ao`i88985R!aa+bqHsN+Y109o8vNRmO)SxU;WQbMMczN*AaA&;6z1{jrxTHAG5O$wdvO`D^$3xz@o#oT-v@C$r#7SZnCgp8L7$)sP{oVV z?`|Wp*Ud^TqabgyON}Ii1icXDV)C>Ha~kRHlFiwKtWI5^ZegD&5Z|BKFO>F^B>xIN z469g?FMC^dgBXtxt z4e|zrCBo)-q8E_9S@=Q%6c-3A`M%6x(>fqJ2mvLAT~3-G&2T5}o&HUlmSxdC&%Wm@ z;_y8kXNDLBgZ~AgKwiH@VE%|-{ud&pSc>eIzaar#<`I$)BUT(Q&|M*x@C|%kx@=i^ zh3GWLy_0VkL?RpqNNg@puHllGps1{!BcM*;$qCpfzG=Wo|41Whz`rvw6$=(+CvlFP z;7vZ~32`Dt^oW!A7^la|eh*lWYn!>eBVgk>!u@TYy}f*o?Awz?6I6Wil|3QB0H*=V zkJK*_JOq7iPQE(%^S9qjzJL5Z?96Os@C%!?sQ&6rua3X37wfDCWdH7(rCb7_*{3F- zQ5xfnp-cnehj$e(l+gh61!C--B^jh6BM#o6$LK!DpKCZWQs_sKg6R-E2a242CAko> zNG0Sg7XjKCK*eZ}gWw9M2y9m4r9D8beKwoDD|XQ+)H{23ER>T%pJ5D4c|1tpDo_X+ zG8_*MFP6=YErW`P28seM*eBi#VEbWd~1lVZHJ1T^6*Uk#}ofV3B0JHT>nL@vcy zPM8t~*V3%*M(DF(4@10x(J4~#xi?fQcaY^-MovE99B~4B$}>SqCGLt@ZsXEkhfpo| z0-f5y+rjEL;I;sbDki1%WL2Q|7czV%-6XkY?TP1;>T_*s{*2BAU$E?YllzY@8sDPy z>z{KThR)F@mYr{}5rb`9eR|FKx4xKn6%o~e%Ck6QGBv_s!O@zu-gVjaT%Mkjr|Uu1nfYYU>JmE+Cw9$O}^~#xRto%rgt<9n*~6}OMcr{lE7GQ z82t1aD1cYRlMIC-M$n~}F9J;U!fMZoy}zdd zqd<9?N7@hHCqd|;GXSSip)2GTxWJcR)uAcO)RJKyt8dE(2}{x7|tyRp5}uAlYQH3=2MCLZ5QP z1FF}aDbPxfIYgSPeKiCeHbStilKi&FcVdi3RU3}m25ayX86zB%1>b%XT!@S;u(?R{ z1nngrP_|yf#bE z<-Tnt#rm_ba@(aeo6yM-_2q9xq{_9~#MZQ4RuMsc3GSSpmzm}FA3XZ%5H%bhh?SB9 zNTp1&2vhZ_TtQ%y1?02AgGZGdT}*s`Iv4P>=kcGo z*8#Y%(qV!n0HkCiFOM;(zBElp@UX;gBP_^}0f$kX3?WYJ%}&es)wT4ff|xpULS19h zCxO8*VY#X!%Ibwmb?-`~NCQ$9`vKVX$b5E;`HUpH63GIy zJX`qVu{)!VHM;!O0c4Vgt)HoT1*`~V?j@3Ycg@ScH>KEn&wdOF<7%o_rqwHpPTS7v zDfx`LDQErH20`nrSf|__qRF52)JSYVO`7!+0vh0mx)xZS*uqu9kbX9rW;8Ow8b-M9 zrt5&ba)V~=$XthDuA>e*ikMC!W|SZ+NRWQc<%&e8Z%rK5IGH>4iL+B%Fttm9MCEiT zl+H3)b~jWVUG>D9?<`yoY;R*vs>PRR7^DK%lIi}rP!O8&bef1vc7vfNQ=5j4)-ATv zjI$kH&0ROWX`5~_E8ww(@?ARtuGfLBBaFAuXSOFoYRJaD(Xi}@ul7mvuE^{QKK|uj zL3~W{4N#SIj}XbMRf0Nf8F(e=W0>~?=NHo)6f%4g^Fj%pj1rcmP?Q~YF#nqA1{A6$ zS@yh`<{@ZdMy3k-grdZ4;=p!W;PylcZ~I}{B{UJ2JQ1=Wg@ry^#j64RAY`oscgOH) zAV$@xWvP3?9eS6#QD#r;QU~}l$Dgg+*w?4%t8N~ETNiBlr(I|_C~2}g`jN{dNEQR0;~o)Wcu#zWEY(=YXBEuGhqe zXR}#d(a-!b8kCYQwI-Mz<4Wt-eK#Gn zV@;%%qoCGgstQqA3Kbcu+LSd!3WBP9?z8TC)ruux+;(kv2c9*|32&`D+oS1?Roc~S zI(0PIepFcyjicudLYaNnUax?=43zYY`=Ifo&ihlH^y%ZoT$L2)6sh#SIFVt?IXNW! z;m0)zlG+t|du{4Iy6efUG%wol_S9KUOIF4XsN+KbyHzPIKo5L-k;GuKb8LCI7Vt2* zUR7>eQw{4(*m}vh1*>&$G}7tT3}l&P;zcGIqD13HULIG$nN=@p0vd%@8kLJ^MFRI2 zC0)Ai77DDJ>LOiHf#t3?CwAGZYG-P=bFW;F9m2|WZIcaQVFw1MaFSx_nxzbil};P% zb@5WE(C8A)sQGM56muP%Em-V;I9uyws4{l!A)&6PUnQo42+KL6WDpn_6vo&2WDKWeO<#KNbV$o#=PUI0pJm@tZTipzxnfn* z{?RPfRMi$Ob=<128fD}KW4Df-FILi;TxX&zALT60lc~H!w&Y8Oui~LP!@z7SHrwh8 zh&#)ucb+$Ijj@ibVq_JYAh3pB7q_nItX8+ZN5;zGmSOL|m9tI(a+msJY?=-KvDEZx zuZ!FC0u9szV(*#Aowc40mpP5P)Tm31l4AwQ(H;Up$?<#GMA$U@y))yqRzqN#Z0eYZ zT{Q}lt$K--1oLOiBcO9nXAMd1}UjH$#sWDuK{MT8)qj zSf0gmppB`TjE%vtsAzzKg&`r%jnUP=vJOfm&iU?mh}rEP-<}JXVwAdnDtLL8)MOQ4 z$(Aw=up;PS39L-N*G0&f;E!4OQtiTMIgLY)?SVf^B@>a7#j9+P>QIU?>!{XYt-dbj zmYY!@;-2GFx6ie%*srdm{kmQgPHp(Y61xb->N#$J9B?1ZNEI&hSsOwYDfEL#haG$J z9$n$1lKXsh*q8@cb5R3PpvO`v9l$NZR+TzcQ^iGujh1P9aAHzq#-QCmsV~>`S4$11 zIyb9aq`(fDEW-+%uv_(;9!HHVv|};&nQTO0s)DSP`B)nka*rIl>YFY8)~W*1@8BD` zSGWR9pKDj12# z0Ev}hDY2`PP(4v& zPBuZqXJegUx6|x7f4cw#vdy12vZ)ZA;zERyY7#G5O|TyAg27X!@RGDE1(rQD}ih83l;M|E|L<sp-0co8K`Mge)J z1f=63N9gm}8~*9&=^tdnEw@5MpG7CmPe>xsFLfZJgiY2SspB0F?#Ig|rQxULnz#mD ziSBJo6OW2kddob{*jL*7?D=vF+B;LCBucf@irt7u`{bms!K?d&1Xj^PPr_>fOb%Z_ zyc7jj^x@{Hu8iu+sIIu`3PSwFXMhm=vAy5zvqe&-;)*lNN6y5L3R3P6Oen{1npsC% z4A$oCML?nE07Z}I87Lr&MDz+lu8aZ|_DdmW7E*ssY~r{P{ONL(H$d;bkAp&GlbqpI zvn)a0ClRi1&C^cGf+}OTMZ-PC{v|B5kg!_nQcPb(+>)>+e%rBWDLnZOH8J4GadgHr z8y`-Kzew}r$x&Ir6i=k)m&Nbkoar=9LUAz(J_2KgUp@Ke_~G%lj~_lfemDtEsBtfU z67f7sSU3sZt+8)x#k`ModA&!NejioBe9Vx?6PIV*+;~ zkWGbR{EesDu*Jp{_!?Xx#U>M3S`4sohFKI*G|c!(Vg#VSTl|Pa`-ns5$xXdxSL2Q< zUiZ43hSB{dL1E&iQ*KqgTh-oWG*kD5DI4=e$g_^ESh{Yu$n=6wX0bcwWc4A(!z-Qk z>HtKLg~pXo@|%%kji6k7KoXASRj~4hx_M@=4S^s1v~I zd;&P7N76R}e;v=jfZF^WQ|1pxkDkG+Gt4XPT|?rdqtBr8QiiG=nc!ix{~ZYzd82M6 zl}eHVDw`^DCiiS575w;>ar%?%C;#O?^@IcX&rH;Lofc!p>s#SmGr#wXn?gWpCqlo#`ffp!hxHZc| zP9Ld(Q!%gzdxUnlMO)PI3eBu>w;*0kV52RiT~9Olk%uU8+AAyEDJV6lRLnk+;u^>^ z;_8-IBrMgW#TwZTk#;pY4%f4D8eJv~ z2SrUu(5&a$@lg0F_KXPQ>7V$_!xCR2siF)s7>SVvP(Y9gAj;@SGxfimiKR$+Y0BiW zZ^qGveL)IG&@ilB*F?qG+FiZOaP-52s!wVjkQ5HZYcjuTLah zSp+P>)o9(lp{Y>HXk-bH;8LitcA3U8D2kNuNRdXPxmG;<^rOiLuxCi=gXo~DIz&Qx zS1Q551%X7xx}`N@_Q<;Iv4P7ksoq3)M=QQxjLwqN)B8wtTZz7@+O& zo?n788BOgPo^!x&Hk*NrON02b`E!9t118P8MNFGUoL`-34TtrQzq7Ia@pm1u{_%Gs z){j`fM_7Ln&ta>0l54ER(-iPy3<8%M5|BT-KlvyEbdt*?rpB0n0#u=gRIwDGECI&P zW5Os-9#)Y`Ee&)sAqO*Re?StUyAE6UU4;U3*nW%7AF8sUzJ6ljCohSWO@yQH27q@Z zs6F_A6!Rlm>XEK-akIu$%9VyrCV4=$X*}Kqi)L~<3HeG*vO{rZtUvBSB&ctcz*S@d z&8$rq4XbIFF;?ARk*ISOEuSuqU_M_ubn*EW=(PIryH2Pc1+7(EbE#CxuA0_oBTbGp zInrcrnk=i2t-53@O)AZDq{)#cN19xTCf{X=O_cDX`%^nvE^@k`1V^2!{88=87Ah?l zblEIpG+=rVTIHeabADUY+T>i9VAEq6X1(dUF(ME=@CzP8^`)A#aOAblu*_ zK{m-jq+|VeuAjXb|Le#qRQkqkbBZ!8Y+0JyIpa2%il#~1 zA=dJ-i|=oi8f#KJ4vZMj;5o}bC4Y2(8puB-TfU4As!{PC#bzH${pqJi_ka57;qNB! zU-+L6MlTgC%k)I5z?#`ou-c{WoFHJ=39dn-G;meSP1*EaAktD-q9Sp!1o->7IGpk1 zA11-`oA>gEk0J#q2G3b4rY&9g?-IFZHw$iW;2a2=a2Y^MIXH-;jf+m|t(l-YFVMMd zodPSVhcCI#_@jo06^epeGuz!MhP4hG`cV%9bv@)h_VXk5_S2c?cIm%0V8gzCzw$zTmy5wTnt*MKlNNVVx>|rOwQg*Iq3S}SN9)N@xiw$B- zQw}tTjH)rJ(;d;dVXKDRe$mR%{1Hn$g#GO_{)mKN2GQWn^*96(2kb-%dDVaAH_Lg5U`g6bVsdhyecG zIYjV`q-mKDH|!&3@}oohh>K;n$ANc^0sF4LCO|M={b61GYd(*Yo98S^1W$a`oJEtO zplJTW&{&`2tAfdUrB)aJD3f|(dPoJexom>rnaXJzu;6K6W7M>k5+0IVR)&KFnqyyv z3?(Qob`|PAzQWyu%u-NI-F3$S*0B>>Jv`(LvFM6Lv2GkCWV7?1bNH43IVX3sRQnnB z+x=!RwXFUge%DUl@4b!3w5M@`y_KZiv^q8GCHfGvvkMgZauHvDk|Bu3)7Rh?`*L$C zThEIxUQ#i=4U#y|glx58HPzDXH!e|)@N^mKd$*+x9lwauJmJM}W?G$YACBNnEb?Tm z5<};qoGdwwkx(=8>4Ao+W}s5*GS!g8nu}R(E>?>p@2wp;FX4Xb)%?~8vn;v7o{{g} z12)(Vs9P7`mmS{Q&(&3H<)I7f(#Lu#n6C*{sy)6qwfavq_Q?cmqlS8|(ftICE?I<3cq?40C9xdD29cP6Ita zHlaPi<&H|Ki!pY>nufXb%b|x3)hwBRjV&H3Ql`RN~D=F#-e@cdskzzsEdU_)25K`-;jZJ$TehelR7vcg?r zg%wBXONKMhZjPS5)c9*GN9vd9T)7BKs#zx?T3XN?YYTe zoHci#D*a`zn$fI2YP7y15Nsbab}Ila()CsV zqs`&ulKklDYqPd@MH-l(iRl;^mE^J*J<#(~U55yTci`06nVzW#L|BX&NU=hJG*ub~ zDfLwR^aV?)TOtpvQL8|8)Nz;Tn1!&XP_%lUw~r`VRWJ|j4CY|NZaK-o&AsrX#F_h+ z3D49*n(PeR7t2$oMunKiy7ovvOr&#dyU3C3g&e{yT`TxWI<125j5nuflvcMok4qED zx2OWG5rdAf100xMyLWI!^4z%rjRu>cw>G?f7l&ec;|q*B6OPS9Ocms$xMpGZScj%g z*2_5b;A`VXUv}E)@tfHE#2q$6mFf5>Lu^2}W>1CcpfvJ%JQs z;o&q#L_kg=^sFtk=-?7FSTkgarOF7cAgN)?&cJKHFqYv&n7&c7jxamR7mGN_(k94# zh}y5V0wLQ08ZPswF$`ErqbEQbC zv&Y)C2|#yp`p42N?V$H4^_EHK_B-xK^isObx)^>21l1IeC!>pNlL=8hjpz#0i9ff#aUH` zWr&%W*)@xThe4bKR~WfLcNzXBgY(YWXED#`Xn@6^_$(mb;sB0)FWIO$t-gdi0f;{Z z6EOp8k`f>jk%IcjF|R$Nk#3<0HW{;O0GinhLstjwz|zgZts^6DOB2vJezyU$wakG7 z&Vs>_(Nsw}yf*QCTz$BWu*n&Yj`X9a=bEbZa_HaiE=s?qoKfeHHkI3J#6aqPu=L^S z?>gSuY3iS+{5CT~P?!Dzv}%T=UFOki>a6`@k14W)VCwD79Is`4wKJVDxjd#n2G=YF zmW4~-1Q(pE;0!#zDb}^+S=;Uy;QG1SgJAwyAs}n9A8s{j6`mk0mEgR_xHY;thLoN4 z>9TI^+O2PN19XZLl|9$<94U?Y>IyDJG`;@iKZ3R8hEu5^onMV?Zk1T)xuuD~?IC#L z%it5kXkSXiPDGAN10DE?eD4?vUg-Tcli`-HcY^AN4A?ew3_{K}7pe66t4Ui+)F&w? zfx}|mq~V$eF(Wxwk)`Dzi3mfHavZ*xo{Kq;bH{kF{wyq3peBe~`}eqB)pBs>lrSKB zH{O5n=qoiV^qyJ_6bzYC;Bom6Z8i9gTU2Pt8S2~+CYTM%fOzm|5`4M_CK@DMmDj=> zh%54JK?aLGz|#(v6)|#(Vu+J9@0CSUw1x1~GzIm5nF$y&G5UX(da-VMu7JpE{f&%i zEyiSTby@*<$7$T&o5Hj&b?v@{&w7g1JVdVQ5OqC6tnMAR@Chh?s+Q@=SVqQti;Ni^ zU+C-ViFRjko=hbf08lfT^$e?ZLl$%5ZHk8-mk5cNV)!oCt^+>VEGyqVc656Lv>SYI zq~mUM4D9)A;rAHtkQ&$c8Fd6&@BmH3Olx0_T*L+fI-U}%50T@k>a4kSTl>Kycg5SY zEwf%~i@oc#s}2)9h?57%Knk{LFXJ1*QQDOg7W1jeWOo5#eg0@qk2`$TX`9S$|IOL~ z`Qe?mau1ca?w&rnBWmF&TXsdZ^!)N2)aScKRZ+zKo*H~NgjKt;U28EKY!<^Sm<^N3 ztO-?)u^tO=5)+y=shIRmY_>;~)wghrRdJ0Stf+PebPM=tu7-yC`@msCHZ{FdvF_gdwUj6f6hg!52jKyR1bkAHHIyau}6j<5P2cF(p*p(3zOfHQFN0H5(aa* zWhy%wpmp_WF&>UL)$HINtv&|Z?K9YLP32A^172HTR8-xQPNsa-Wib`^WE43dTOQ>- zF@Q2PL#$&7IVoBZ<*hWgkjCD8=Ztiq_qtQ2>}X7#De;^$gH$R3gPRR6SW4wwSm0_` zn7;zOdXZ;N$$(TpU)=-wjDLc&Y6Z9efK>3+*J{+*&|0CiX30JPwSqW@opj<>4Fxl> z1MqHy|G+jC9lwb)_J99||92+M5qnjtHe!KU+1h7Ov!@y|;x&Vz0gEF9R`3JZ4KFmL zz3rXV)hYs1Ut2{x+#L0)#C3F#I`(rrT!pafSs3<0Ff6?gf$&$r`cZ3LjFLJiHc1cffyM;8K1?CC z{}^?i+;p@v-z8Yq2B$65*LC%s4$_DfW|9$k0|}c#sq!i0yN0f}f(Km;*){RvwhY?7 zw?EpoE7`T9{W&}})|M4WgH(-jP_;?LG&Gy&O3|}P!(HAjCf}Nrdrnc@LO%ynDIsq$ z_D6BThg5k~s!9?&EMc~l^u<>? z`wiBfQ#fAja-IC7Th*k>S){8dQ(-$NIdnzJaD_iq0dbr3Kk8efzBO|0jd1Q&`LUhD zUmp%I4X*4+w4KndS{oE1N=c}BN2Wz+?mLgS@c9?8^QXI$|a zjR`3Z!v&7uBzEXd+esYx^NKyTXIX!=S(xqRVj!>qFfmFd(j#0&*EHU2UzO%StJwt2 zYvK?Ag`-pqZZ++4n4|{zt#Hbfn{BXSSqswERpS8dZdX0>?~#As3jbbPS#CtO!;bUR z3#TTB<|v;=`Lwcp8l+4%D+S3$*)__pQFg8D^O3B>BC#QyKJm`F>wSfldB#6`o$fgB z2WLHEazar^S#;&Khv($fRaZJgm21B84&f#BMov?I8N;SzJ|1xk!%7H}day&t?E;o! z>P(9Or$>JSp=cTyq>Aw7?WYKbf}2?tu(@Jz zb7co@pKS>A_L=|F>(;d5xrMoz+r7hptIrf;1$~V_a7y}Z-@9aT2rYysY)M3O1r?bhO5vUK z2u6K~Se{+u1a&^Ej8{K3AU1FXse!N#crm1zz(>O<`4@@P5_GY$d{puN1mr0kEYD1T zpJD}U7K5WO{c`pU=j4G5IhGqdk&Da2zZX~6S$g~uz@~n$dKUER>hTu--#Yi1ZwQ?n zC;CSbfy`f3vn={GoM12f>^XnC03FO$FyBax*BWjJFUv?{`7US}#0Ay_%4oNauBa=5 zO<&Wu?4YqQVKSP*P2$cBlT^5~iq6+5g^EZ-VJnSe2=nNQaO9iE4}s_s++`w$Xoc00 zWp~M8*i#lh>CeFp*Z1vgQZ+)#A-IX${j~^EKQHHr9!*O;KTX-LY7?VW=^#~{E?crU z&>Q|qX0+(ps&PHCn9}JQQm~Rh%D~2kF?3Bd;+O~b<0TM{|5=h!eW+y)X6m{NUb@dz7cJs@E?W$-4p%@ z+!vn#81Sq6t#;b8g&)kWzdq#_VRmTZ<&n4zjG)brZOa0$oMHh3iPozvq2~%uo7{8u zEmj!k@dL>?9}IW*E4a10p&)s(H%Q7p_KAE?;?HjJs1@Zv6H^b1rfr0wT0lgc)IN0L zQ%ON4NNgoxyjG$MJoye=wxl?8`HW{a5}X!)k$U=*qq1x%o=D9vi{HUHF_;yKi%IZN z&UJqB&GEzIZy!H=c>Hh@oPf#)$9od-98^0{wBF?xp_u+NzoBM`PcFXyp8ab2tH+Oi z^X+&1;je#lq^CnaIeK&yybReDZ0SP;iYdF|vy*s6NNNuDweMuB@x=EWw5ycYIgX1F znY}ednt6>gFMACtd$w4Fh`_?>q*)gTx-MG_g^{q`Ks0^wJh`bCG1U&s^pd~tTyN1c z3Aht9tsj_a4bn6Dm|&vjsAgpT-7V$08Wjfl(;82<5&} z%J&>|V*Z$5A7qU9Q(sw+?6GL5DE-OF#>Gw1JYwqMZkoXo#>tt*Y@$cLa-@0YOnWU} z5g6RdfCVuix#HJFff2^&r)Z4ABWp+dd?(+0EYk~b?Q|4UPzWokDQIy!=S{xOr`RsHpgV*9_r}nhe!@;RyTkX zaH*kyJuTN%YIXR2pQxs%mA3biPIAh2!@qT(Q!EvVG*#76it6$RexAyv{etqXtYjHr z@M6iFY7b2Ih-dH=YIcfBn-r8HJ$Tp;t~XNH3su#%y-DN7mT=sj!ETMC*H~^+5eGo` zUTS*R3@%I57MtpddT3L_9}Cp;b@l%OS1u<7tp0@$i>n0wy4jD=Z`(f6#b_C-hq-sN zROO3*!QV8N?-KbqUBJN_MF^kUf8a%Vx6y{Q&^Qivbs`Ot~rS9 z%&dDIhqIKP`GlvYhl-_*(9t6(KE-)BQ$r`@mf3<$0gZ4t1^tXT$`b$pKqkb*F$57P zMIlSBxSadI3Ns!4bWKY}95h`xrFtK>IOMdX6;&K-4u(5NMw38HtF+`#4nw3`Tj^WqZeAw@YdtVti$Q5i)% zsCBa0aOB5F>RXBW=y&VVT)ojZ65NIe&R$lEvXSiegzP?xtU=Jd7qfh7+lRIVD|C)| zMR&w54jjGNGbVku_A{xyo=UP&t??fQ_febvY9kg+4Tht-<|7YF+1nuOyXhN!ufbM3 z4&g4!0)2qQg4!Etl0kj%!HA+mxP*eS4>0`A3;xqo)4=a}IBW1%)dk5^L14Mub4XW} zj-@q!is?@=FMsS8R~y2M(ESQL9O;&B!!e$^%v)LQPVCR@^2Hd&bW7LKs8u zXS|SE5NU$Amf;O#p-Q7WNRCPHsJc$KS236@^9k^8vEIE*S*TsK0ZR4~QSbnEM$q38 z3SDw1IB*;IV@sBuKq7ZT{V~b0D^^0MPAl&RdRbwi+dwWOD|Z63tljiStHMkg6sL-1 zZv~;c8lAdBuhzD8UPWztw!V=(T?nSz)=&q47}TjLCV5gaTE8CMCX*9$zEtgs@58I7 z5B6#zW{M(Isn3H)!TtUXB)(F8(TlFSDygPVU+uf)MczlRZDV5-+{_XifZ#5>cH)A4 ztE5hlsTW9JbQW@>VCG8TD)gQEnLK#()g<_IEvDDF9KtM)!W;7~wNdOo^U3cZK6vMK z9p`N79kwp>+-0t5T3eku?aC_L(H-Mb$Mt$Nr5f4Z;j+D~C#!SuEA7F;G*r88#mU0z z*3`+_+MVW^9yjlBil<}EZI6Mj?#Uf>&;4b>rI$<-iRP&8M1K_ajXv5to|Ia%zF<9sEh1Ok6WCVvmNT3VCu1)QAnxOxO!nDOSCQKEC{>D zq@jSK!{tcp#U6T0MQ8@9+hBV)`N!=v%G_E0)3o_p?z&kZSam7_6&K86J=L*&Dnh_( zI(7CMgfr+&wxNL5j$(_pKS@vmYr-zbPhHA zr(wj8*;2UuDL>8Ns2}vx{k`qZ`q{2R6O0d}9*+nnN6A(qy3=qfkxbZW5;yaQnt?o<c#=0ax$ z)vKrd=4{4ezpbj%jI8gLS>Fl+fp4D$4!!N$VTL`&8k!dyM;rFCDOa6tm4AJ@5Qb-2Cjsn%mRU6RWcm*B+JFbkcU8?Y0gM zxHCthk&3U-#BPc3wot5m9c1Ba&pHuED=byu3T>r~mq<8|NvXxN{Qa;0&NbEan0>ew z)V0QA9@_0|2uQF4Uk2Wc5+cSzj(Y}bvW;WJNQ?su4^6;=JC8Lrh2Gw+R-*a9CoPs* zaM0#6oRJDzFWF1$BCwSTO22f; zT}T|=xW{LUxy&^Pa|`taow0}eGl~uXk4mXj+s-}SG8#_;pOosIl2bfeUC#M4nzUCW zspEC1$x{jDQq!{~6Cw89DT2m6iRJo!x_K$A6}5a?{pF!(2>bbdG`@R0KBo{j2HXz53rPjRGSc5xgsEiq^ue zgHS35Z=4cT88Y6wkNP`ZPZHhY4Dl++hSkc{(X^OVIn_SdYL03h5_NT{UONX~5gP(N zsboJ-?9ZuBwFydDGY+3Pl0Ii7{Y34abYbRMlz#nl4maZ*ODC9?*NDTo1`vI0iq`9? zPmd_BV`XqtemFwALt$ zr2f>K-FHQtR(op@G-?XO-v(}NK4`vuB;AuR{r*u3YL6bmc#i%g=9{i_DP+|t@_f=W z#eB{&l(fDq-#*H%54%iNy^4z>ociHOM zSxcV;kQcEaO;vV7mMKSD&&}UbKgAXM#0}BEYt{0Rnyz>hA=dIp^;Ig8{$~u^F_q)! z&Zwms&oIHYCTVA2a;fHYoUmw$)&YK#@^$x~q5>YoXoxTM65V!D0Yn|c9I11C>U8P} zD}e9lhVkAQlAOB!UIigk8(dgb1te$%*w+Oli~3&%FWLg9icr$5Nqn2J2M6h4(9Do0+BM01op|>?v^;vooO?{PBGL6Jcsb?vO ziUe~J;C5FJ1~lbDJj15P)Z!R{1{j*)KdD)AW|c3bLP@C&CPNs=v^xG9;j}%+B=X$3 zNb>~M^ibyMnE4bL_U~E?^eQ<#5m+OJNVx@ZIq`|h%0>>sGr9i}*u9NZREc~=9eZ#1 zz@Q5CA@h{BP6a#8RCZ6d-eul0)Kr)rjJfY8H*1*;Fh{I~yY3!C-3>n2sMfYIp`8d$ zY+Xy)e_Ch=3~W`C=oJcRF)$8T7r3MTxg8?;omL)nG}Cs7Iki)(dc!uvcJ{%>8IUt= zD~2#~xxM6ayQWX=GON>^ZfHigN7|m3>Y~}(VIbeS&pq!iRv0uHPiVSqZ3PQzT*P9%IP7D+s1x-$kManUX!BfyiO z`Z*V=aE4Q}Lb4%f#Waj%?=y}Uq8rg;`S$`iWF}1DyjVguhgzzyV3R1}ox#~#q$}{a ztpXZq7`yZbNI~+*`P(hxMBk0>5Q9DOR0lYOM#yCeBjV{5z~}Tw_=l-wm692LA15k% zXvQz{tG0wY9$^W$+{D{Y5l_w&peQPJ{OIe`S6nDBx^3~mzn^p(FG$?zt*lkYsPE1zi}@M2t8LWgR7f4e;SrJ0Dcvx$0vfL5^PZ(fSJ)$b=gA7ukVtTXf9P> zl)UvJY$HRgpS{I!rb^VHTCdVI>qB61U6VK_;YS9 z2FjB%qMX*Qx=cvqWD(58^(g`}Z~4(D#3u{+@@khVB}5?Q}uM%2{Z}y%pRX z-Ai+M*`lO;CX(dT9L>nR)ALRaVkjAF{`oTYWpQwea4In~ zrrXK{0IIa1fnm|uqhP)u&2yFOLUuzW$Lx}!f_g>gLwC8(;l4H$Ni<1}^W>(peth0! zrHy*>s3&h!Pu7?^s>(H_>tslcbUYLt?@=nzfwP=l^trDVC>@#St})MY^mXK)L-9`& znY1YN@M4oA>)mRVQ#?e4lk?e;lkYGmuZe!ubWSsoNo=y4FBWm4+V6&%sxMfI&;(c~ zai+quy<&ki-V5B&ajy=y>SoJWTO+z?ef-DUNR_a`5nN|OlZ&F%Tv=BtG%;J*PEiGI zSJ|N9efBt-%9hu6@X?pw@Xs0j0EGQN#A>cko7~czh6rI`o2_(uOfUlU=-sqN{ZUC8jhn?Nx(JF80|xIBm0+)jDosz?%b=3SOp>LBOJ?jM7DsvbC1gv8Aro ze%%krK{)nCIHv6c{%zr4j!pk6rCjsiV__tqS{k%d;?^qqB(JfUQM zs>=>>j(8?RDdc64rCrLKi4_M{Ug4&w*&O&RW63s;%a%*Ay<=iEO|^AEwbDlGy0RqI zr|GT(4Jx^DD{_je$M!m$wjoZos@Xmjrcz|2ip+Err&;g3t&*SaSB@v#$tyqH8xOkc z@^9koOh!7K3cPcW9CMys$FtxQOTqLCLq0>`vfz(kWyGJ-;EY_NAYG2}VS!8&Sti|m z5MQn?wJzhN`jIr4#XLpMr6V&SNqL($dRUC4$R7d4Z@Fxnt}_2$JV*0B=PfgH-QHa^ zh31Mx__8rV*4AfcOoaoyMAA`1fhXUg4~Jq907Tn#JT3krS;&(kwZAhAe8M8f#S^Ld zW%0X7Fi!zCp}3d?A2~%zpL}!t@c7%u4<8;soCGI%2znKN67f7sSU3sZ6_`_fS<_NPqXqBT!N5RXGUBQ-4WaZ+EB`~~b%3)Rci+3?B zb%T&HC;i%Y)HRLDQt3n02W4_m%%F3-29|OWXiaLdg^+jr!VWskcn~aDw$5md( zXn7ZH%;QPGWs;0qUkV8Nii{n~ih<%Y_+8}_tND}<#W5_n;=1GT%r!maKW0cayAxLRDKPGEpu2f_Z@ zvrYt9`7@1LmWVCmw6Z2(9!n<{oapa={r4gfY|SFro>!n{rFm!{?j+!{Va6q>iPGG| z?70GjGLMcCvj9ecyJLAOcWOP>RTysgic4P;5inniPZw;t`4DHskZC239{K7>ac5nG zwqm5{)13sqMb(*%JdhRnilxITr`I}DL_dhWcNTaqqfc?S2Xo}V0AX18)1zjt$`TM4 zU^OU~$^{6KOyETUBIt_55Le0+;wI?LWHG3d5TmXe8e|qRm z2=U)Qt4UnB1gT$`$V4?ib%`f^$#7pcGM%k^Dv9%MqfvrKRU5KYNfj8Gp-0$G28*M> zqljIiaB&(!nw}*Im=6n{loGG|-nTqHr|xXmQh%0tbJk|)Co`@1%K(A@`gmLAYGlyO zma-@)g8Ogc>>AF5JNqb75PiXOmWt_D0|eGPpzmZ=ellY7?ql=*GwcH=N!4Vssl^0d z2}dI{5ow&HMHe7B`#h}nr0iipY+7Ye=j+o_qwb{Tn(+Sor`3H;o3&dp)imdD>q(@l zZWxI%j->Cwsyt|R()tlYZhJTt=B2>=hA)j6x5XRi8mCiTmj=pOlb{f zy3Z73&_AK!y=hHas!pn@VUeIO4x;K-R>GQnx%0+g9SG_79E3Ky{heK{N6!A6^k@lh z`f3SHr)lUW^U6||aWYj|5j9HZC8He9Vu!k77BpO7uuPk`W6m$bCi`{-^9{#L5L`^? za1C-`3grXe#U!f~7>m{>FJ#9@W;bx0%2Xjfqon5F@<+_>#N}u4A}-mp5hXfyElj5*!|jakfN9fOq4FnJ!G)nM%u zBZ#R0ZA_hJzQ{A4OvvwDZL7S&$e5($ z6T+k!8rXnlmDHVKu=^(CBWjPReSoO_W1L@vBXW<(eTc|?8fA|jkGMVJ_F>}ox8IDo zJ>vFZ;`Zb3M%*58`!I3)U6zcdGYyi_07EFg#qL1wo?huYrw_AL2d{WRv;Y@UV~{ zN*(`EV}+K-dQWY-o{8#T)xSC&6-%@#I5Fbh6XT!v9eO`InNzVpE5-SZ4uVrhN^6sI zIRoCI9w@AdlW;{$C$Y~c&?j);2=CauF<)7o%C{@A&slG|$HDJ>oSCCA#?0rv z=tBV>XARPl&aHmU>%zXVs-x(kAxLfUMo;$_@2jy-b#?En#$C$gu_=w=rca7fkKfPp ziNn>=9%nvXPBpp}Y`)aC)q3Tr$LB}o9%m+9jZxcGspRLyKWYnDgI&X2IyCvmNfQmR1U(?d@3s=LZ! zyQ))dRwhszgR7${ugqq|STZs_(JuDc->acE$jQrCU9U(I-=Y3b{h(T~@(tQ{F_70LSBz=27 z!rp*}*f`c4&~3&Ac@}*vbJ6ZBoe-PFlRHEbe)L#aGZs3814_sd@uJI?g;8&@(kA(Q zlQapsbg|0U^%+qgK_ZnK)S_{++(b0w#y*HXIi)k%%^sTGEe`Dh(8p;&j8XL7`Ld$ql^C!?R670V~OTL55^L zqd%N=EyfujXn6B*$5a|$)$*g|JHqxd?A*ZCx?#&~N#V}H30?H!v&Y-Q7Y@yM-s*Ju zLF}$b#>aN;DKuPpF0$@~8{T}PAG1A;$K-61HDU7lJJHi9alA|N_$XeBWGrgC-0UWyjcCexk0vitOh{yHGl z0}`j78V2S8EWrR2N^S@av4Ve<9x7`T#)$}THLPk{b+vqJwnQD zgOin*N_8#qsaMDjFCIF`^hLm*Ao&fBRD5O&Cq3(Y5*oVx1eNebL@~FVYcyee&uT`* z`enI3NNo)qezzfmrrfjyTTv0`I2Z~wEBJ?A;~W-4INpp^-2M`E?v_BQmYMYu@# z;Hj}KBBpD!?@{&#e?lW2>{}AavBQ_^bN@o5y$nyh;H#7CR`S~GJ9h`?eWk}ZqZPKQ zH|GhO0&b!|Fhf$Strs_{7B>hmjbxDEe0iPq9GxJmU3*#9J#0Z`v<+4_pxjV#L*()# z=b4u%Cv|PDK%WEWKcs5#~&AY2xY#eUi@}oeU38|8Hnt zdKM;Wv5dTcxKr_Jv35Vx)17xL7yc=b?uDEfu2i@sXS-BP; z4x{)md9iL6o=m}Yb$=fc;;8k{XP|vidVj^5#R+=9Ed$x;y84J~_$C8;rC#!yUH)4bWji zMOkQ!VVwOyb0M6uS3I&Uf?*(17t8C=(#>+o_SC?Bx0P5Y2O8Gh8J03OOi##)p5yGi z#j~CGs!-7Ypnq~-Su$lSA1p3@{*J3@?kyc?ANDuy1COV+|@ z?@KtSLbks_!$!8CcRkP~OQI@WF29A-bjEA`$pxiJvG| zPXE{W^=NVMEbmvH3DBUDkZRHy3j<}0X4u^tvs zOxURw?AN@fP88X@bh&e5YP_&IYbJdbmdv3F5J}_d(*)0+B{r%|r^xFD_1@u%$dy=Z zQ0uvWjnbPTQMFgbXlX(O!EVna8kl_wqK9jfy(1QeFz8|=<}9izfM^*&NkR}NNQm&* zXn3^%&TEEuo-_XZ068#lX_U@52v6S3vtjw$1#zdd{>4V-4M3>~K&tI4A#l3k;o-V* zk>R?+K_5i{a+Ej9O!%A&ZqbxcqMyaK?wpBFs^^^*{muO)*ScoVai-WW3n4o$1O4tu#d3guZFVDOQjN_F)5Tr&T zPIg6!k}rZz?AAE548J;Br@UunWHyt&Po6uNmyAqL(me2dYHrVNTczltJrXkcnMjp; z0?cNJDwgfi7CFf40x?^VYtQj!I52tmouaH9DBDewh{*vqI^PMPO?s0gYO|ag`Z1n9 z@|9gNG!{@8c+E`o)nDvfB2DZMBJ&*Q`rvBhW6jEK zJs5!pIDmf`akaWbkX>p)#RsqZZ6QcI`wDbE-e>4joq0lA;p#Rt5DwhK^m$zW=G1rU zUwQU%>0CfRP%hwZmJa8-PUmgM^5&-I+13GD-E$RtofE{OpH&*9-s=6{IynuH8r~it z5Y`Eu#>%TB$jP5TChC>HT6@adF**FzaHNWuy#Nz$)*NR@R;P%iN{GAwGW;VApa7~O zo?#MT1ZF1mWq?ua*7xhvn+wflZMgq1xW-X+#_18;gmR*j_^qABEx6OPp>+&7HS8!_ z?-s?X?yVL8aL&378-`mn8tB6$=hWEum(VgJsf`K^q=sO`8pLChJPUz?+{(!st-tw< z*6_;j*>&3fHYi`6u=5Ng;1WBqJeN+JBAv-I0dqjl>L}mkKw9sYX3x_W6xnpO0lVXe z6cc7F{9S_&H}CQno+fFDvrPtItn8v4cdIA|Ax(EbFGOR>snCGZuGt612-T?LY8lF% z<)D||Wn81j5S}ZxkiP*8$q>G1e;e5H5JlsK9h{?)@QMf)bUW2lnB!Yi`~&if`@w;m zY>4}a0H!3vk0YH|WY)oIW8CoaJC-&V6@!rtB%c^DD3K7OfYcfBY+8@|#DFQ7Zb-L-pB!l@e0(FpcvUFBcT zg*lV~fF|j$Vr>{fPA|&%O?}N8 z`xZ_nKb+bWgjjK7^^Xk;LkjdlO`DCr8cJQSpp!|l*BI4K-&CQ&Hd;FsX1m9h&8VwC z!H6}Z`^JZsTi7JP-%tBZ1x+G|zdFiuUQvc}cs#gvja&*+mpw&eB~*r7Ld!>q!HEB1 zfMG;(?6cVmV4OJx$?-pw__51-1b>(QP*v~rkYeHdyxFd%Q;`9#Ym``=4X8Xn+m!R` z;G~zL0^(aHTz&6G+abrx3Q)ma*!x9vm<(>&Im8`(%qtJ3N#4McZK>V}Pd*ss;3Lh% zI^U~*4%viv5p{hIF$zglG=or2#z#~u}AHzQc1hHx+6 zI)*s@Ks6Yb(#IVuZr54YA5MuI3Q1kmJeuNh>aG}rw*#Gb;Gm)&@3AD)*<5VKxq$pD z#=9kl{ib<-UL7JGR&+y^bpEU%{E**x(Il^`%@oD_d5mx}D^J4HTx4uVC5PqG|D+QX zrd^J};9OMGz?$Y!D#V>b2mX3M^ckbgT(4v??VQYeuffU&e-M{)anIsS|LIo*W%suaPUBl4`e|So~DG z#s|^s`m)%#GW@AY`DkL%&LlNGnl3v z6l9s`hSnb|bX(UK(b?SRPmyUHGWm71SB9}xh%@jCPKD1w`N_jSB8;wlj}$~ zTzJ_)LLdvUsdH=K=!_=NP^G6iqpb$hFb~t02(zok*iS86{{2SA^yZ-#7*>)-x-{%2 zN(N?&fS_lMx_=;EG8ZbRWM+-qaf70O8%^CLdjMpEa0H5&i0nXTr(y(TMI3}nUpnrg zkuLaXH@EsCjmy}BFwtH;=lNIlA{H9!ke0~u*si*6*S0s^J{NUQXm8++Y|rDg0p)+c zRXGe;Z%0Ris1%m46@};D*c32ckYsM)fs8JF-2veQZ+jpTkB@(Oz!C`%OMr9jJNcE) zU&fhRcqGBnY&c=CR**$9wb}rdZbWhYa;CJqcaYsyio+6^boOgtF5NOk=Z0TH{&k^= zbW3}u*xCLVh)|xk+>7C9)((T0+S&Pi3K@CxdvD(71;Q|nHcR%26y=Sx-h;P4x) zHenMnBWU!wwoN0vh8?qk)dSbFlm5a2^EiA!>zk@>C!D)bZ&z^DWDzRGg{YDtevgUf_LhjTg@a& zzKOUAdQ1w_Q8tGzmydzi%?-yuZEgV`vWd*yoJBL+w>n+d5;&`&?ea}kjU1r7@udu` zy0yFKyxOk=NJ^xBUIG`trE&6z5I*=Q(du2Cf!TIhLSn)FkEvvX>M1z2tr5Ct(Oa2U z87=B?g^3z_AX+US5(31?&g~OoOjuvdfU(GHS!6I|_o0A89X~4g97lrakK%Bxk0+zMd3J;dBs@5>VZ3-=U0JPZiq^CzhBWC(i^R85(m{Lx7Se;O?k-{lSf>BmBqt$xOY z4$N6Sft$J}h*iZYQ?dMZ>AJi1-!4;HE3j94;(j>+XDl+d5G^=qqx8&7X-tE_t_y$mR(D zwrAVeQNql+E_fMYX|aYr+7eEDFfE4K*vl8dvay?y~$rF7Bk+3csNVcc+l8A z>9(m1K`&E)<7n_)NlV)nym{$Zok$;q`yzN%cr~T^4St;D)vfCZTu;J!Ds-Z_%|S^bLYNxY>Ut>p;8Z&V z5|pBN@xHyf6Ylq8N>=uy@sqilk0qd36Y?neBxA1l8T>0oX#N9i_b=IlF5SNrxs%89 z2C^PtG;q zdndgb-N%Z<{k#RjFA4j;JH|Tr|C@Jg6@TN&=7?>6R5785m&{TFk5P)&;9vEuPiz_= zyCTj6`k24MVXq8!>ak*#m$xOIZRLz6;X*#?SaOdjEA*cy2|9#=f3fF@&g@NyaqgD^ zr4pGUp4!B8%N_M^21a>B<}~Q*jaV^^ZsPqxg%_5z>XRgt7Nb z)t@~Uy;_;iW+QcQqNrwk8bLKs0#z^BX!&5Zojo`vww|Y)6NCNIFW1G1%brU1*l+$zfLAZgHwOc5lot!5_?-QRt-F$R{$Hug0z)iCy5!!GXOeO%OIegm15?}YK8@& zAfGPkuHsf?`063Id?_t$9dX@V#Ie1rO`2&=tGMz(B?7_+C{X@QT%Lh_QRYb z%z%=mXrg+s zD{Bgl0w-}9=rJ=y{*uM*Cy(sWtO?TlQ6k9z8Oy0FQo?iO(|3n6t9$%&KP5{mWZ$J> zUmKn@7BbF+PjH-%o&wqL`X;vOsVbY;t^wfy2*xDa+W6g$__}FaBzRS1F1fGbRA165 z=@xDjVFMAXn*}1&;2X4J*Rc72ycWwQ=Bz-t{))_eU3_(2QJ78-IO}co+Wel1o2!!Uamr?an zGO1JRn8u%Q^a6nS_7gBw=Bg({+-M18nqoF*(IB&Iop*ZgiWC$69omhi$X5jLx_Y-0E4Xwmz zeW!>3Yt9dabR%kv7marNoE}nPt-b5+v}7~etG`$R33h0Dz+MlUH(9V19uwG9ZLNE7 z4~{CnW&6ab3k;otlmq83Sa*zpHxgvJ`r_n_!PJQz4_XUJd5>l>{{GQKl?%B=@2-jN z$RJA+;INx+&>oEdEl@GipcJu|6v2rdoIcK_@i#r~4KtrlAtU9=sq80LIVP#*H!6q< zXCfQd7cp0*)^V08|HeT6E0e_dCqyi%6pAy4YEJqt8CfUb7n6c*Jh*UHkfiov%irccw;U4#CJhiAJZ2qC)_dsfe+TWI0|s-Icr z9DK6y{xcWU9g}`kVp>iR;-~Ow7Er{zB1e~cSPoEYL_fjY4#+|<_r3M8U7UrpUM( zB`6d9F|H`tL;KJPd_m}egHP50-elxz!OVV1iyal-Wf!q>iG&$h#bG|Fom<0Vf{mCZ z1XZY1?GHob6MMBo(8XGXjt!J1W^j?wdOl($R=_B9t;&8Kv@t)W5*e7IY(%{vW2}S& zO@B+1r)a%Eft`o`d9I(Y^V~~gn-!NvMEalziwi^(7r>!>5h;O1M6e(ZLI;VbUrmVJ zFc=fCxkjt$S>Wh|kr#>$9(0?3a=Q=aN}7uP)e4UkE##Ix5C$$8fpS*MAXZ9+Cg}O3 z2Tb}|%t`B;o&!jIdh&ShCVJe>`3!or*wB{DFd4zC+bx2gadTG#e(-Rj?g@txAPw1{U=kyKg>w$%V(ZY1(NQF0M7=1Ed*OCU*`hQriQS zlgc9)WI+R#UZF?zz;aY{Yvs=INnw-uxo0%R%(v4nJ%DS~*LBvjrDp?2aP*D!NK5;_ zJA7;UpD2t-<4?eq#ZkSNZhE`Y%t?0#oLKPk1i=Nm({pPvVPh6^JWx_DH7$}gg)kL( zHUgUsy#6O5+;!2W&AqM3=Op`%*0FQ|sY3f&r_vN5H0yoygK6mH>S)-EeyH0FV)4C~ zMEo(5AL2-@!L^M?lqi`yq`ktHI@@i%4b7gp*X!ZsOm6jdOzR2CeF)gj!zPsdZrP35 z77MI*C1!;+j8M`uQcGF!V*;xc0@CAd#uw+~?#rW-A({K!(~lpEcwD8-%=@-%?%41( z+=ksW&>ML)t2+?Fjphqv4w?vXM0 zrl}X!*X6BxE9vMe*I${vmYgnygJo$*bC*YJ>~wK$tiHGbd@!ZA(?6o;NLxX2;419? zFx(~)&Mgn4M8RlSxaMkc8jrSGoWT&W=>dMY_*!j##k4g>8<0+FNOtZU?H>C=2k0Hz z*bKy2)6r(6k8}X&z8J*1%pU*pNkEKqQsD?i$?bKoIK}?#1j&~uVLFmrVq{|^_l@CJ z#@X04(80)*+uczD|K0nGnssfgD~yV4;SP4ZPvK+0uAOdylP=JNj->RULHN~x}$j$?))Vfv$c^87{uG^f_Ll?y!B3X830lErJ%`4O7=Lj9eGD3BUr3f0NbNYXAjd*1QE z57HajlC zBj{u7l(5IHRwkH*c9-p0O?w~>XDl*PwY-o&8!JJZ({v8J6?u>w-4tsA8snUQO22(X zLwZo6O%64`uDFaz(^$N*$%t21QUC??RLrkr&%a3LkbY1=ljO53ue~L#2bJY^mYKjR zOaBOf%$GxAUF#GN)v7rO{mH(b5iHnW@Hp(ij>?foYfuVVJ^a+6WNseHOxhMQEevmv ziLcUFlYwMiHJwNl$NzDEb@onkR*soGGC1)>?%zlvK_Wzow;}{Ay{j z69dic%2eHf39Q$;ow*MBomE|r`PL@HHsb<;dxA_&@C<5}@mT*89uUReibz9f6yw+3 z-DjHCZ^0hH^X@PDiR)dKxf1{YFkFba(yR7WFZ=&%Ix%b~_3whGBDK3khs1A^>j+U$ z?(jneJ|tUV*d(<~@Wj-kM#5gB=Skx>e-@$B3G~lY0}J6Qt+GQ{HwJ4-d zud+a5Fnn^K2p*%U*E-@+RfS0s;QLcqS|j>lg*)%V0r)Qjm!W*P05Q#fD0!6zb&y$3l5ExnE&hLke3#CLj*noCv=JY7;gC=$xD&}7qH3CH=QDH zsgp3$XWwN!9u5iDp!TzR3Y5g5*C|WXx8Wpc~ zn$`x^iQ{OF&Px)$fzEnwQ^dKAq{;D2i{ItOp!eyMhv;HTd5w9*W!O06C+`q!(TD|{ zO=@7$g;hyxB;nlKFy78G;Y|Qj0p5SHvhnrwqRlvATT9Vbx#)Sb#-iJ+Bte8=&x)Y7 zi_-b)Svs6PBD{LI*NdA=6p!3!QpePn-YGZK(kLd#e0aijhn>2)gQRP(z1S7W23?f_ z_=lbfJilj41_+h%8N|XKdV2rPuu0mb|e00q2?!mC_baX^22ziu3CvlgRGkuOOi&Sbvj8=A73Ha!*fNOQ_Y zyDl93;_x9w6s8eQZ}o`GpwN{F-e3mTZcLyH!mab~$ApiSj5Gsaozdq$A9K}g9LsOh z0l8%)RDKR+ttZex;TrBS+g!MBR2p&Cc^)H@#j#wOLP9a%5J>Gd+54r(nLI+lY0?g< zd5dWXvYu>DzcieamREk5`Qm)VJ#1=TXAp2_k?JTQuqi)p4&S2#me&=wEc9AsU?ayVft8z5!kr!*j9~)p~K~2Aj|iYZ6r4}(pH5V zq-2g3;_oi%W8%V5_0%xu@HF0*XkPIFr);JXcU{R<05?h_+Va0S+I9y6Nf+;97@swB znO^mTCj6<0_yI9mtAUH1owIHX@MjUMybN>~03E(4H30%stxClX0-?M3AVA=2KP>u! zMMN~`BG2yx*s+|xP`Df)Ni5i1FfChkd{~a_F5F2xQj)E23ow3YFTU#?>p5!ENWYn; zOa1D!QNbhI$asRHKzc0)%v_Z65cSl$jAy}WC2yAsny&#AoKXqrdUG7oZZ-W^(N09A zffWqtj(Wpul*qOMhGWWFmPnfw8U>g$gqwz-ZlCpRcTyX@yqN}X8gtinYGJ^|DlWj} zrx||Lp~!JPa{7O1)Ntq^{-ULkpdy>p!*%u(HbzHm_r{O_oOa#LN{>1rEpQ+z?xz}G zZZJaz&)d9xW(s-x1;xkpygwGsPMjd3&OHtzq zG7b=}6D}c5u)9d@EY0z=r49tiX4~ogJ!UxyxwaZl3u=rN?I-Wen z_{QMOj!WRGfr`Q)`=6+!n-W6!n!Ge%f39u)wUVNCY?s5GQ8yLyqprapA|gUV+#(=a zKbA?+r;3t;92kQs%{q(1$m>#Yau6MHU`&bZpht(U9_t5?`})n?V{+IT8x6?RZZx4x zBl!yr$392<4K4&+se@G>uTqT;eNOtuBB>q4#};|Qw|hYR{R)zZeKg&WHk;>wOClJJ zTBCMx#B^aw38OZtLmBd-x^bdCFbA=D z<`lfMs+FJOn#W5Xqy1KaY9=w5>fzG|38rdK8*~_Lw(>D@oowyE&lO~UzB3CZE%Mw9 ziYhVJg?F{e=Geu1BkS#j&d2xvNbCq7s<^Kt>Bx)CLgq4BB6!&PDm`nrNMb)yKm z9UF9u(3T?GgzIp!0dIwn+4B;U@$h748d4JJevpJsEvHw(4%Dj#vK|M1C^PZ!d9Cu2$(Bb_YyAFKfq zfPCrSjLD%zW#+2J=Vz&15%CBD5wbTgi#0uo%5Py@wGG`e0Hw8!w0b_Sgmkz{xf1)m z{SHmL5Sn62{qV;wvWXD>SrIVR$NaNgIo4=yv(`!c3s=t`Z)M8R=_ce+*Kbl{H7}z{ zI|uW}@L}S3k*C1Zb70}JnbGuG%{}fS^xnZ)Zj4Y7tBFi>bc$gCtf`cr-9`(_wA>2L zX4Jo6s*~YA*3+8CQe{fjB*S77km5mGt|9Zs9*gT6P999)Que-EAjxl{bs`f2W8E%y zG=YX@04GIMxJgrXI-11A;j2=$yELrITx{}G8S9$PvQ)OFbne%*qlrc#RX@nX{4H_p zwC!!TNK5?*_QrKD$KgM%AE?nxd5u}Qgu#vcHw`-fz{ZBcNkj+mP?qnqULO|J`G>}L z%W3A*#c(ob_gTi8a?g$U0bIV|R*znF;r28SI{=&l+3O=*#k5yWS>a|JBW#V|({@pxLKVAR;wW8~BGK4M)%e0yr;W$- zh+YQXW^s|6bW&X0DU@S1M2PKXFoH3*-?eD(@yw=at#!+UL zs>rM1PLqW{+~Y>SE8mkIo^N+DES#Y;i97@3x{R{oWXzHv>g*Su+hrBgWDN!IBM8h3 z#S8u(HBELRa@8e$7)A;~2JvQrkTzL_HgjkFHO)6;9Oq5@RV8Qkkje2R&g#0Mh;qv8 zTWLBI(3y2Ig*3I?%M%PT*qbv~ZW!GdYC?xD->&$XDPlf0Aez<>K&yu}q8s@TvInr0 zqSPNc7MpF-dxayRhTjbcBPJXvnJSq}sX>BzdlK-BD;xF0h@{=-z;Z%`7|Zx(%lLlQ zi<}NAuaYXeQL5b5*e;im>iiR8JeOwbY^Za=KVgoe(#T*`L+)0ppa@L@eqz!*8p3aN zqQB(TO6IThDtyy&xBQY?EJ=X($e;uzLxQNmi?~c0*(O_(YxyE~7Dt}&;UCFNt}9sh^WPq} z4=eTK;;yZy^JD8&*7fo@nB5WZrMiQ}#zgrpW%4 zh~WB(3LRW&Ot2FtM1w66Z!TAqJwu|j0sScEgBM@9_F(WIFUMB;9p6beDCWpko1^2& zHm!VT3jQks^K6>GCKr*1K?X#)Th2uwCR3TmRzzIENgXm#Pm}kQH!0m?t+F99x{dgL zl4(gNb@!9H@U<$K?R)$-+$iVy&IDe>bM_Es{s%W9t?Kqm@+*X1Y%Hln)zOHMeh-xY zD!^JIl88KD_~>OAiQr~Kl9{}Xgq8XrQ*bKf2U!On8|AaV0K`t*sx1>C8>(S*H~*@K z6^T=@48*2RL6ZqMYnG4<=VsNMA924Jg+E@`1*Lm^3UDMV6 zqHds(kbY^ej%sEJ9BBx6{G;<#p4i80xNSnSuI|h45!5RNa6-IuE6Q$f ziGsR}t`{a_tO;$9btOZSo8V##u3G*v`6A5%dK8)b8@(e6`!dtA$8Z zHQWp$L|ATHEkxnmza}u~~ScCtIY3xGSgX zU|~}?IR9|cui2mb$wA-oAwJS9Huekz5qDaF8-s~py2){nnQfXbiqHiC?2dJKdSF>S zs(8rWc|WmTUrMJcZ74$Hzl9s6p&8~C84z<=o8NwjV)!lmT!?3A=7!P5G9s6@XPtQ9 zBj~|-+YRRi5P>vj?Ic-pq0L*7IZYhA7S_%Jxfxh+eNm>1ybIp$z-9p9gd7oNer?b% zbqWX@K?dE2h_`8cl?>E``ch-OpZ6BlTR1mza^g&5)CCYw+)7B-+$#F-D)Mc@ypK!& zQw*YeIKDYIHAIT4sb=O8{QM=7+?UNh##7W<)b+e^oKpGf8e&PgC6|&b@kj zYC}D;6N&E==e^pGL7I{8UozLslCO+ECMzeO9;`=SQ7_JReIGdw)Q%>tB!HO%9Cu+m ztC2_@bnDz}D{|Ng7-#)f;OTtI%_0<)>r`#=LlDjef#;RI^n@;>i-*6POp_5^ByAx} zD9Uj2DdfN#o62!(y@+x^E?k}9D?Fu;rzmhQu@B=r0E|`P{&@InK-B_lXDqIhX7{Af#aTK z#LH$nrj8(eNi?Ndk!rSR?O29fE-O>D4dzd4g#M<>VQ`mSZKy#O-DX|8g|Ambsq2m8 zfJ{4u`NP2AeAePTOl_~{6tmQn($R6Q9+x-HOY4iNhU%vByh9?&2$Zp-MCfp3td}V! zpx1wQ(kc8(6-+uI5s2uNeY^qwBMlc+8Mqhec6F<$p4PHgr!95zE*#8hdnBUO0WnRr+Tu;W3>;5O%fS z(FpyXS|AgE#~FT_)AHEV=(|EvSp~608k--B>@A78WTOIt!*w-L2@+eX5u`*Ja?QFP zjO^A4veL+gL-#$Lq%r*s;@maNVlFI{jvZimA&lp*0dZ?i(!LUJ+owZ?N=DX&4r1Ju zR9(9^xJVSO8p8G#;D;nibxbeojWzosGlJd-v^=eqwe*}uyjoV9S7asj&j}&X#Y+T? zTDpxTEb|XjjB!ntYYi^NOtAF3KC$^U-EqP5q*}DSxAF<{Pd1^BLyi`x1Ipf!aISbR zt)#(3P4zw0j_sYe?+j>pjGyHf1q@B)1d=+T?n)^+MiQqApU>Xzvip7}#)C$Ye=3cPBztUa~NI2hX&o#h6GF zdA6PWYow+cfK#=Wy^uE|iVfc+kB2^*LCfMEHqt_fdMf3GtK@v;)EJ+JH#MYQ)=?@E z(u8Bvm9>LZ@UOROPuywxg$ex$p+aIUvvNrJ7%2a?VoW8$khKuvEf}CXGr}do;YunM zpY%mJ<-JF{yifHEz!d$Pg3*>vt5}3d5`jb3VL{HxD(6Zl^e!!CA8@kX*5@%Yub+CZ zGQWKlKzEciJGE7WUJc!+dHQ^9dN*oa8KBZL>x%WSz~GQ{3aif(4rUExldp5frMB>2EhT4;34L;QtMMeb5g$foZhU5LokW;6N!s>cApP!FFBZ$n zIRyVIbN!Xv;$GsX1R18wWNF(Y7<&v#WUPyiTUhXXpnD7@=oIz5XSIEDpk{S_lTYy9 z9$O&As*oI`qJc?P?SuVVR8XpfB{xGvOwFL6hxORW)DEBpb@D*TO*{I2xsvmHM!$hG zuy(ntb#F(=;?g+<4%yj@YS%>m7U2GL&zWQ_&^7SIr;SO>^+WS0cUkuP3^~Q^j>I}A zzJYDoLJH&N4ME*x9n*Niiy>Ux(eN`0W3C7iHzX~_t0kKDHOtk##_hZIFh*s8__vEg zse(nl5!ZTG$=H}MXi;S5@T5P^#lr{<-7)&!xRoZ(JPXVPDAq>qI^_sb=IqRNOs-U! z^f>ZG3#Q0pz7moh8-mRv0F^^A46)Rnolgu-e-RR2Apj@S1p{Y&0B& zh-p`riOGn@(2+nAgb}2>lB`cv!*+djew?&C4nkH~y5!ezwXj6$f|!@u%hrwZpIm~;4Z z>fr~G`0799&9vudHZyc}HDDU$B5;`6H+|89G#t5u;Yqg$P**%h>6)>*;lQzBrpN94 zPpI%s$*XnC(jp3z+j`4nL+#ZyV6J$*gyr!2j$37(tKvnp^vJ+AE3zlrQ|Z?`#NK%r z(dNbHQx1e5i-|A!t==<9xOWix8Py2)CunDiOzgM+Y^p74&(s~;{xx=+%US-b06J+` z&UW*oNl&}Wf4p4nLSYse8$X@rhwLGl>hakkTAz{7JQ4EAw+Rnlx$m<&v^{{Vkw_3i zPJaKNK8B8pY~%eek2vB)1m#5&R<#A2ubHw`iYjXX%;OR;#bS12j>#HP6+do1Z~7=Z zPk@hW-=|Do#}V>F4@Fx$3mOxyO?wrzXbwr$(CrfqxLwmEHM``$&e$?l)ZN##_k zQmNEA@AE!rN|$wU-6gm9;5F;g9dVy#dQE?ZIO_Hy7r}2j_EBmdEs}FL?lgk_3yji7 zQE0hvgZ$(QOY-I9sck&sY}H12w2H_IvEvxLIwBq9wrsuvy|sPOFhtrJvl>)#OGwEg z>9d(*(uir9gOe#t5m|$bP`3iF+40nR4Hts{1CUYo!4}(n{Y&12+j0Q0k z9*N>dKpCym7X(aTjqnu9Y-Wb7YXJ>gNP4~V?59q9rS&gZPAgSdpsG74O@GQx%}yjW z0}H{@w_fvEaDH)dE?ctIaXTUmpPI=W^X}0j&^&m%_wG?7hu8nPmd@(wY+;{Ry{1b9 z3Ph8JQWkAasbdaN$*fq)!(GilQ zW5Z-dRTi-_M3*JJ7iv6DeR&{;zgN#JE{MQyKm9$X*vdkQ-KH%4p4- z;u%gDz*y&4+>Viho9%(!d1_2IbpC-!iJHdDtO{672`c(Ht+B685kA~Pd{IvnbW0Wl z%}a6J2sIP4tk*w05BlSv)E)NQFtd1yRot-UQw9niu@@X~-f)M;*z{nei_-F*IN!SR z31$)E#!QCla94M1FFm0XXLkVSPulMHRPH_^GtoA@8%9w$T^>29AsEDSycfC;Ik2Cok6YK5I4tBooynoHwX||WjIhNh6O{Tq9XCe|4!PL^_NVJkyMo_rmd!xS>^5bpe9W+}j{7d1(kE-gqsyK}VvbacGUx)kTqP&r z3f|a5lJq-_3Fre<@(j7ddvUK*ig$-gOuBjV{|7u8VsJb6{EqPGV}JO!phviS;?@Y~ z%Z&TV)_L2BtfjdzO~ecqi)MD*yC*?E~azp)y8Wxb#lN* z4-U2OEiG^dZ670@Y1ans{)`FvKuhF*l_t*c%%A_QOnfIxAC)tHN|VRE#vmG>oppz; zW|X=3-Y{LdK0P93!5bIQonzknfgECYU0oZ!vaO)_c`XS9>izm~^2y(?&MKDd`TDmK zUx3zJ2|uURT0d|+IcEtfm7(N>0wvY*KOq9e*&|6wt&GgocWEwSGLnNHi2q7&oyWxO zvU=sBkg+-_ul7`O@*GTfW%YT9USZ=cH8mpa|7572Bm@IEBf=uDwm37mTtlsK1tiOe z0g0ny#8l`e)EyP{F131|@C?=_5LD6@*-N-yd%UDiRDNO+sOrH)TL^nVW zIuygXn^w;b6@StHE+|7NVDD~h+T|6-a zLLs>HM2yh2NN-6J$g4YlE)lG@e=m01XyvwE!^5kS;sa3*yvn4uZFv{}U0vZ=!uhW< zuq8tCYRmZQDmuNq*`h)=63P6qMC}kHMtG9OF|$|Kj@P>$(|(W%Ci)?B;hc*t3{--7 zC--a}RDZa#2qwh3j*m)S&fLL*x#S+osxFzjFlJx*y_dPB=2JwfzPwDM9?UFg7V;Bh z^pyFe7wGN?!9YY+!XT9!I!`z`%2PT6S}cB_fL$aWY6Slk!@{?3HS)-s`#N~JR1Ts| z;RU9FC4IHPV<6XP-bk@@;OZ~gzXynZBfSu3;abyFuSmtAp{0tUl;@Q)gv2v-hrf`$ z!4}Uijk;BWfD*t|-;98uY!8uTb7$8EpJ2PMu&TcK?P@@CG?QJ8EQguZbi2zYatNF2 zuok{G(xjEU`*+H)QJ3CuCwiAkO~$*;s887(u3iUlWHKjW@msJ)DJyg~XN#KNqI8zY zK8SjVBdV{e<%iD5$wF26WH0E9PQNHsoAe-C8^(Oth)!z_=&VJ}Px{g=Th$bWu7cg= z=I4+4jH$|$8Rtw763hp#c1bq)t|xn3$-%cju$Hg&OejWWvJmVeT+NA9vhxu=~Vhw<*cZjB`G)?MN|5e z5pz`X)K?~5uIy+q2C9~f#T?4|kL$oqLi&smchniJ75Dq@=l>c1xFpG#Gvy3BW3c7q zP#+orqM+$0nkArX1fDoYoG}(OADlz^Blu#O3WkF*m7W4!;*5qvNP z5B`78{fxZujisWf=%}UMkFy3LdtQ&@NkgV5#;jp#Cv+GKTjL_fYiY)3=23UyYK#s% zgU(DOtyPRBnu}ya*K;N;!RMo-!WiGO9zJk8HfYd5;|2x-`1)=Kq=g>alZRDX^_6-l_9#-d=8Ej5g!cC3>KWC z^#jU*MS%a7>RVk%ll-<(03%xBq^Aw~H)nW^xqc2|JImG7(d`adKL!>GbqXo|=Gl(P zbTpKVsvHYBQE&v(JusQ>X>=Y@F$($^@2|t~O}|s9_Cc%gZ{qq--keayrFNc zGs@GJ5n%dkn@5x;`X~DBkf&;s#Xz9^m!OEKtP>%n+J-RLBF41b4W)fNX&}d79$9iP zQSZ%9z8L1e;==PER3eGayD}F~jb(lgh@0o97anp(*<@1BCSMhveN1(Ed%=X|ccWDX zd|QR}g$S%L%jB_d7{SplgnfSlDI#-gXE4Evn`jDm@@N09U8N)cIMk_vcHfqCbo={- zZ-J*@qm-stiva%07xQbRK53k&7(kNfF;5^=*jZv|l+x+nkactIl<%{;dl_EwWZO<7>{Sl*-7*0_A+{YU*unli@RgPBr{&t0|B&4mIfaAf)2j$A(o>@oTCX1>5YM z@6t*LGw1C_Lj#e;%jb&s0thIa{QqmAWo`HWvCy)0LRHT^eb#pQ7RG!B zKgSsjh0AD1Z%ks8gm00~_cuBBjf%&u=4m`!g58yoO#$wAsn;~ zOoeWKGQ2BpRlZ|hd*nLFJ#%f9=`YbuI?9`(NT2gF%zA9k-rs%ue$66&f1T?nc2=ub zhB%(R1e}dmfM)7Vq?yB%NRJ{eT4N%9zxD0-J?wmMgs~j)zQ&dMq*tjuw!;pCe~9p> zIXb4*bNAU7(ehHK~fh&unLhbwz$4RJEeH7<~kP@Dt_tHskF* zYt!8PWwm0{`c@@-KU`>5yM5jL+xob7llAKl$PVB3{8Y^Q$eo#Ai|ELb3!VNP19e(R z6<2=ubHegP^VC)C?H147O5xfzQx@*XWUX3OO>!O9bLPlZSmv4zbKYh81xL&gd1L)J z;?9BfA9jZZh3d1ESE&LWsznU`%&!~1Q4Tnre~Ru@1#Z-=4;0_@`ZVfjjF(r=(JMUN zGx}4@JO`RcNL@1!ee=D`Y|B|-U&mU?EOxY($Lk2Mi+0X?GEmJ^*C-h^--m{Nk0p>g zC|g%TPcP$2SEmWkE1iC0=vKXyb(oLB)SG~2#_JZ=gB|uaj(;~k-9(fc+1%W_mm4bzcUxE^JOd<2u$B-B60pCvNjL%ChvJQDfFFh%=w|%fS$bS&G_*TDg#ZA=d;pWesOHgGvdr3c z+X>I@v;IvdV3+d3KjdO=>-%a*-L^FGk7!zm8-Dm zF=R^18W5IvHiX}qv;Z@pQjo|(7Ins%bz1W77(j|>ybevOGdk7o*vW&&dj zW!b|9&5;+{O;ssTipsb6ek(nX7j0dQ+l~Z?)-BPLSm6+9UEnbANc9AoU0<+sidutT;-s%aI@Wg)zJu={5*l7kRn&^w1bb2uVPSfQbvz9M?y*;B3Goa2uctsQ3Yp-<0=%4xk7Kn-8O_MOTfQk)j@?>}5Mzg=Ik3jbJYn$c zm)6j3)`8X5sK+jW-<`+7q)tO^9?`&gBLBU^kdiY4-$y3&M`AlML$u5_^Y39v1 z^>gl(Zcl+LtgG)qFxvM|qgsunBopyRt=DS3CF?vrip4?zab*Y!A5sdQkUbDJ*2eNz zdC~P;V*4KuBH`FaSZxZMWg`-c(VaH4?G8|q(2D3|TS5`%(?IdWNRap^dK!qlb5#7sLEhmY7#iQOjY}02FFm0uVm0H~<7G%oAG}RMGz_NvA~Vuc{V9eP}OA zjLm1y>kCE4>M7#E6BAYye56m0Nfj-78di%rSi7Btgw34K$`sV z+MPkf3!QhUn7MF-!pi-!HQ*lUds_~0p%9HITAxpzAb(I^SG23>EAslhPdtNMagVow z@8$cJ9rQ}Dx<~9itkb4G=B_0~C6_pnL{iqAb@AYC`|071)ju zxE3+$?2spp{uZM_sgI{V2fk7W#$c3_mXU7Ih z9Cso{8G$8+rj`-0`hpL~a5Y=@?ywRxvoU)8u3Hq$1oeSlMzMHieH$>>hXU@LA}a~uy5dhadO+Q8j4-4#aMkIl zmN$tm<$hQ@EiDswaAh^(?XXU)C$EFMi8+(aYy=($Vo_6D$0C%K9Qeyp%aG?6u*;ArY z|7c?cozoXG`5oochO4oCE)cl1Td~F*L;K8KF2UQ7X1VvLAIewiM6e2Lb!eoXtR-u+xJHjIe5{DS=Bx#H30ga}`=XRfCvgN!+w4S_;r7&jh5C(KWe~~>3S<`m zC(|=5p71anq?Rb1rY@^%FwS(z&N@k+HvD>=!v4<=wF`cLkLJAvlt(Fj@b#``s{ zgPZ?Xj}D{XI$3GXa_`c${sj=ee)w^K<1{ZFn@ks+muzu|2#4E#|nAbmYIhsj)A z+c3zJ^v8c3gVYpky&4eOQ5pLW2**~Gz=5?xLQ*yZ24vyy&jyRnd&B@iVAM$Wf-JDp zUIN`LdjB+5dq|ZVG&<^O(XbK^g)k&T6=k##9^x|zHHzlNYk}wGy1q1tN zEmH--wvYYQI#hY^GN^=L+P!R}Q5y?!qrd+;D@DOOR2jc4VHNAXh3Ft&^EmB}|11%D zngX{0bQG(KU775JJ&VyB)3@Pc@aY(H(MuvqLshVURf;LOX2MFmq|yr_{|chy@uqZ2 zMVYM$?R;8mPtlu$6Df-o4@EWx3(;ixJ#zc~{P7;@x?zWyC2a~o*W%hm1c*((>qBdG zLzc!JmXg+fXaoB&xq0M~|6B{(4i@F9 z+3w;$gs6A-3*0Ct2?nOHl6ZpsRUfmjVad=mQj3)quMYW936q-v$=wjL$K0-hW&z*? zgN>o?TI$8Xa@;cXdZ-yBFu?xpn~o`31kgp~5kcW)CE{U~|JnNFiiT?@g& z9kCAC7dXE@juBhJl>yiu0Dq=(S1|TlC2$w ziY2cYUFz`=n!@^>dk$e+xXpO=HE$f^7o@~?*9bIRN_xnx`iKMQTA})dewFBhd(d#- zvwPT$ih31D*eMWVFf0JpQYp}l4M#dvH+jn;md22)5Ix9>>w?`tVfeD=N1vcj{yue? ztMpY6!Hk$cBd_@k<+lc|e~16F5kJ}fTV$c)4XUpqIcx*z%gg&03tP^7L1P<_;ajep zS^!i{XZ48X)>Z}EL#Sen&a0SzP~+xvPn}#MQ^xqXDx?(HrBZHxSc7?)QLLJHQVAC$ z>ES8Uy}Ae3kjnmm5c%O`;!#S^ZI#ZOEeOa+fcbjsc&T&BhUF=~A*}h=WLcji5OxIg z>SZR^f=1)R`)!j)sP-XQ;qzG8og|EnkxFz~G_ffhRTX4ng;J4)WlTvMR1XcX!|nSI z6i^N`uMW`|&bvtAM<5@aa7sJBK}Z^$flVR`WleBAAx0BQYqd^Kz#`U?OFavh7!d%< zg;;a(OSI|F*m>v<%Qb%hpKh7Z#bFSMb9!zl-aLNtYgIc+cHEGpy_!3asf4VrPF+g( zK;x0D@+%&qr_Q@UOz+S~bSjh-`9n2ENBCuCy8|IFkJ6Fb{cX+5g_BA`*?NMEdF=s* zozBIMMFGx=m9P)8X}o6)EM5i2RY%qYl#}ONvHZv!yvRteC@#g1Cs_ zD2R5r50!ywK~2se19>J~L?rrgyz#ALrGWH+92pmR56e0ZqbmeL4-|@uT1{8 z{*)qdqvr!tMrRxBNkJ0iqXxbzGdqtWsFwCTR~*SL#eKVIlW5t-ri_I^axyQ8QjA1b z?$KZ}vrc3*Z{djOl|2)9F!Ed(R=X@0wr-a)QAm`gQ4Sbr@U(f7vBgsIT!VN$R$xotB+ECYoqb`v-Pl&Ho~*>PnQI?0b}5$qrQOmZY?o}edk^|%3-I{q5@5T>;bnnHmGmTT%W*VRT^)+< z1%KSxjcT#V1*b&)5yYFI$4WM0}bdn5!~_Z7^Gglfdp9gZ2usd ztT|)JyHNjCDbWIE$qnv=YXL@aJgc31+9;vB0Qt#Dlk8@algD;&m8g4u7atxcq1az6 zbx1eJ(vVAh0fP0L@tRCmALZZB&>m+cvCWWG%4yVIv*ikm1EZd(vymf?I6F6SvX6UBtS?DEktxi=54WMO4te~*yh}i-$1t@oBHeN?fRl$FbA zPj0B|I&Av2Xt0&b`%BbrRo(X?@e7lNQtW$Ix06faQ3bcpc zLi&9QAqSZJFGSB(A9b;^-^Zu#Z;L;H>Vln9VqAlRMTz%DWVL|jG2Jy<>U%`{}VGhZ3qz?e+lwnN+%Fc%4z;Z3hCM!PNI zyRQCN9;B7zREtn+<2dUR8rbc~qA<#7U)?LZCZ0?UlKKvXiCMLYl7SVh-)6@9Lbc(J z8)K=uVdc4!JWJq38LH6=1sX;bByN^LNRd@#ZyT~SGOQlmYIxm+>JcXJ4=VP4X&~Fx zJb~yrV>NZPs}my}VEvR&iz^G}9Js|j;AWCdEhq!~pOr7`1~}`8MTXsg2MQ>ch=UX& z3Npw6`K<07yM1@^M0WC#t;AJjn2*-yw#I9PSz!&P1k%7-lpLIc97`Vbl#yMiGI6tj zLmC(L{<{{9dUXoe$%a@mA?H|aH-A1x`53#9tmfb}5wFLsr2+U*}MxH~9QC~P8x-dqaw}F~W zI9bEh%a^YxHgg&av1vI4A`_T~q8)l9W-FFx%zP{6DS~&< z+x3-{DW?bMZChzmLt4}sefQcy>+S@V)|yobk-3g`#q#w~^)|E@RVr&q-D$6qH}51= zj(@lUK8l-ZRB??kr=S0|!}J3Ab=}AB{IUJ6GP6M)mi@@+%YW_&_~%CO^mU&lfgOsV zMA-=_Wt*8EY=9)3H1J;+E=mew4^It*wt5U#gT<&sIA88DC$dk9!8Z; z{NLQkBzT_$QNYU-9Ty4bQ;!7L=ysgY&tW#4h%~TU6pV7h$)ut_NmBy;2<*0#Iboqg z6#1d(Lox#mAh&bsTrY2KKG(M4@6U2@jS8PRi*(aEuE_97a{(+53dP8EYg_buz=shG zp|8AxKS)k|9A5fPCQa3hNz3%-ATj(|!~^ViE$bl7-F!@AW3CD5$iA@Ee3JywInA&j zOtdA~;Eq-TMkw_u9Ie7kXk!WWLHZx%RDVas?bdJFr`W>2G#NoPV|*tbi;+(`ADA3k z1)-v$K-XY9*&c=D6O-qd=yT@E4M>#}6%bH1fPAIXX(0BJsY;q+4&+i!g{nv+DdCa4 zUhs-vn^E<*_4hT;fy*F*ObBPp*B0F`|Ao^_mX4%`xVhZ>m`OD*bSt+|BAF7uEP~ie zSNWLVNt%KHGJHR#_nh^LgZI`(Lf#j%$f&g|`a~u3QE!Z(W)Gl2y^?DrrKLjrSAt(4 zn)4gp`7#WRX#FpKZYuo;XGp{|wtI`4(Y(-=rNarox%JOk{KXKlGpVim^S6KEbSk`4lPACugn?hkZ3tT`K& zYdf%k*Wc{sN9$ijf`K!4+#a!yto<4p#cV6|@=PjzbM^yybz)KVut9OW<;bPNTg6;T z#=56b1*2%YfOzJ35q+jF`D0x z?$hKKS`5OMa1CLRs}o*T;o-JB*nl}FeF=5Jy$tZLhkqD!0r9XQhu zkD(h+o!2J!9h8j)bocN5^3;wvdry;E+4+*JmuKt=Y1j)X($0FQ{DY*DW_sG6^2Q#W zGkqZwfw_J`OJh<{?gDt$c`?21{3fZrVGP0V5b-;iU%i&rJF!Xy#&ekT%F}ijMtCq# z@-M^rYpU)VI4O>M3n_7h*4jj}szaamkK2tzN3c-2;2i_RZnsUtm_}5Zjd{z6po2XF z_V16R+?wy26`Rc4G9kCMDI1Fc=11-v~e_~ zf^ihjt@?O|*I0JBc&v0kNy9i&sd~y2`aUL+6IR6fbvHp$Sos9h8Dw%&H|Pm2QvS{- z<10W9?Vl8Q6}S4|H{4b_?m|W!zfQH(iCn)UYw#NZg%Lz8{FhkPtl4|Fh;m!)-zMmV zv^mo_f!=F_;z+f!8i?Q~8zk3I^*)VbIoi=RKrEkU_%NUrijg(21%1z1qF=$vsI&F7 zwzNrf{fWYj3uiS~bD?PND;;O4=m;4XSkvfyMw130NlOsXck|oKIX@Y~Bv1qHoe@`f zNF%R0bpN|+*QLXMk(oek2u{3{;n)zbudvm*?PFBiEez-O$FBZ}t)ce216&m!Owo3O zrxAGOU2CL6?~QhmokD;?d*`La-^p%B_||`UdUeYT9oJ&63EbPDBYd?Y2m)&^s@d9g zQm{&BmZuLPtK$sit#!vpUq71=_laN6ND;6))V|j|loYns{`TSBu2e+<%N2qv1P?MJ zFZkZ`i4W4aMPgy@!WGf&2Y#M6krF-;O$XA@ItPTm{dXpfn_Jn@w;7CX6NtI$r<=Wwl#pFf6EarVr%xmm>h(eYDxwH&QihM zvpDA$(gLv^&M_~LqL;_463_ka;*ZV^2v0Du=;;iG*jx6fdK!t8)`+vN=oq#H^@!Vo z^>`LnEXb3EM^-VQ06$G*adV=ued|b0cO7}@8XZ%JF*ZV&ccU?17MW5P?yv8dgUT8@!ZrWnyqYaWE}58hxehf?mWE z9dsZ7Jc!~7YV!Z!{(pc6cVG>DI4$fUfC21|yQGiKyB07y9NCnMtjCjXOi2;`|3&>{ z8H{FvMM9HQU3zWWEh(8f&C?9F|4u_rEYoGLSd2da$pzE8c7AtJvOL+$!AF3aekf*5 zt3soOe9~E9I(HXO*N-k3l>%!F@|h+=UpM{@TXW$y@FY*)~g_SBv~5x z`xc#O^^6zhpTvu0QvHJIRQP*b53+KE&2xicj$q3}EX9_QM+}+{Euya>H6=FOd7BnJ zau}dGnO_Hm-cz3-}I+jszM z6bDM!X)qfZn-R){4mMV!fKjZeIU`DEk%*pdk0P(5KI}Rqig@!ukwYfzxNT7a_-po? zdQp*frz1~t`6v(6{N>$gotS701kGxEL}jJRKlWJJokeWYbk%lDdd>2bhzNW2ai+t84qLfRV7>PsZFtL83N7Jdk; zI#WrH%hUg0b4<5cDs4J1F3up&eKBh?Q#X?BPrWPHB6=aikX${t&&w#H%YowY)zVtr zIm3Me2ftdbnB-y*()}X#)q$NQiEPq(m)iKT$eB;6wCXnn>`qu{x)FoK;drYV&CTMP zC?4ONr3>z$k#3#EQV4|1J2^7BeVZ_KZZLw`Y<5!>^9T1KD<&gLQG&dA6?)J<;^Gf; zYEwNlJf_0dLGq+Qd#J6!SDupd=eargdhw#I&KJyfgxcEGS6k3h$p2|{AXK*{*SR%mr#}|a zJaAlE*Q&b!XOfti7#^T5jQ4)X4*?dj;T;401g;d_9f7ES7FNvnscod)H6PgPM6LSh zL&65wF!x&FHiO>n=ZCAK^L6aV6(zY#;jKDhv!~C}CEqongIv@pb_Z<=h|W}_rJe${ zq@TE158Je)95&;k?3YAd^aPWr=(Z~-gur)v;xKHOr zwgM&e`l0^F6z|%kHS(y9xs(~y9u21KgH!Yd*JVFDwLh0+t5Jyz;kZ(-WIIP$PefQV z(ZVrZ_hjDThC}h%TacXEyMTeWpG4jR355cHsdl{W8puRC;-ZGj-A7S4$!re1@Uhz8 zzBhOOtX(pX~ag7l3Fp`2jVQw zM^)8{3k6Ok#+pl-i`j8^R0yw`iB^1Y;P^m{+;lc zC8aS4MdOx^qB9N>&s-wl1HoZ2;E~@m&yR$E4Bb6b3p{Mdnio~xl@d=JYnbh zln$bO0<3eq8I`369GWsY{5Fkv{RLS(UsBn+kxE5HM+))&me9|%38>&RAw=|v$${V| z>mYuu><3vIibQx?+USlMP}*reXqMt-J{_4*89&jn9DJ=+jWM5GW&VyUuTRPT^5S@JAtkwV@N;ob?7yNX2qX9cM z@WA>-G>Fa)Zp-6Zzh{78Yg_{T5gzB3Oq(Lqh0?J-k@Vh;x zVS`zN@&zrlK3jPK_L;Y6wtu?IykwY#(GFcpcncw;`*I`NP_OL-EL_Rs1*@@Xz$UYO zwQDj`rb<@-q$;%hO{7*0N!tVvCF!@3pUbOIXfN14E2-7@3_AZ z)?_IlaqW^;snJcXKc!e60H)Q;thW7HdgH_IbSh@;hxq& zJBZUGpC4SCIxb{>j;{ipV5=k2*6_@O4PGERz+Av#(>>|b+hjT{3D{sGIX9HA<$nI zpNkzl?HNaT-P5klLoOF%2N89N5v)RB4{MqZ7K(lwy>Y{%O4G_%*_b%j{hHbJ>~g0O z@-az<;)*GQECsBnB$|Jv?r%`DeGapcr`J@qk&*Og*O5msysIzd^vRBlyCb1>w@ua5 z6zev91Pqp28Q#D$t1Ips6xMK>umYrg)Toa_A|TncVq7-to8BIUGvBWjW>&gM;bBkv zkR{wFhJ2DBhb;RmxCr#tkYma@7{ruXtkmez3mr87<7^4gBG$u=Wua90YdP`?l}eAB z_`X5@H|KN7yCbaVX|bOrQ;9z@-dt>_G7Nthqa;}G1-NXpF|S-pe|<;R!fEMePfn|o{~>f^md!5SEuSY41Fc@322D_hV%ih5+Ufl>4$9BKk{?2dE*e@St;}V%mQ6E zWuFK*16?;C-Xw1MdGCMmk*x~RKePeN z7v_kmw=5V;*8`CxVxDmx{)lG~pI>uf0eHDZtT}4VrzOW_9Ht`m$kFgDh}H~S%??!m zJ;u4>>Nt6T8g4WuBbIi!hz<@a+d^4iZlJ4Iob@ld|DkWYC%MpAYbFPSlLIHARDRN1 zNzg;;cO-_P+sp>wLWkz-X&W=N~(e_!x!0 zAM%T(-GQaxLL0q#U`we8s$jD}uYwBEq_wuH`}yM94ZJrG93FYGfyK12p7xh1$7Hki z&iQ9^xGb#xmI$5^Ghc8LhbmG#S$=a7X#a&coHyK8x33d=EWVMqM(dgT^He1B=|m8h zVx0;UX6O#@2B7XUP%rTx2l3ZQM*2S7+rXR8VM^VGh-LCY^wc$u)Y>UsK4czKyV`|R zeM90KsKw_VQX*ss4CnY-IT>`%D8Ls3QRJG_{}zdTQLcThz8vy5@Lf@iXJss${zVG& z)g6*wD8n&>>R8>GT;L9bEb@r2RONM-V?(+Kd~YAetwoMG9b%*=%0Eo|^R7)tl1nDe zAt-_Y?-JfRbt_nVoG(Q`7$MeIkF_@l@yQgkdP1?>MwvT~F1p9rzm}#3@P6quv!|{> zD5Kg=?cg;kwU+H40!y&y_>d!nL^SH1%vEX4fN31JKRVeJ`z-1PD=+bU&E$6Ous`G! zPlr%8_yXyf>61IKl>BxmUkKhM8ZaO*W-w0^>O1k4YILU*Y3{3ygeH8b!!k|0#$tVn z!3**yeodpqtr{a{nSvh!0WPut6Ae2OBN=kHg7Wvdg@Y`Ml0i14f?r61BUk^J-*Do4 zcA3bM0TEq)cIB-Y{i7Hufi|pDz#BPh)Jl7;UEXDGiNz!y)-fr`!&T{YexYI09kJd$ z$T%*Rn-5_{VcqgDpol0lleW*1aXDyEZ!iyRkOsT8D8N=p&VO(=`@YM6Prw13iVQs( znGhmBA?O>Z9=zwI;2Py%7``TD5A0~pwAcwG;Hk4BNx(uFMC~c_o#0$ide)~ba-)?? zDUnq7JopQS{~DALK{w9@cT7*9p6-+dKaW#W2JBo6XV_1xr@wOv;=7~S7h(1%pqs(F zgZi^jZkDn^_X1uP6mCkxAyL;#Vofoko*WH zhdu|{EIwM5{VIgwH&xY#;u;~nP{R=-hOqb%CSP%dIYGhFmkcg^meCAkI~UKFC+wT* zc8E#97#6-mqKf4Urtm`mLhx8r!Cj!vez3#jFLo8FYu{hMfMI?J7F;$40Qz z=ut;BR(AKRUIX3kwRV#*30K!{uG&sb8dZfk9QwA6`7TkNS|6NhDNWJlu?(}-qK8Rg zWo!x4V!M8Lm4;~~;1MBJgcNkP`Ybvjvs{@yxKr-Rkvq_%;cmkh*=PM;d1X9$jgj#$ zJG$~WlH(ndNJ(wIgGJ2fKKhc;U@ecIbgc6W$1EdxOkW9R9~n7JsY-(|F%s(?62Dlv zvJJ4L;zi8(OaLNuB2Ti;Ze|>ppwRL8EsWa$q9zDtv7Uce9%hi2&{RmBO8tTn_gy8k zBR;GEgW5_&5^j19U1Z>{8)|LbtzI%Z{S$)sKTof>mJ%S zKWG#Fz~pPG>auEOOw->NK7KcbGyU}F`{WAD@ax=%wb*W%dzRJMa&1DnD{B-G8sw8& z)Z3}iU~>C9H(YNc1r4re3+*fx{LlPQyT2O~e*t4$n) zD}Aj7&yvnHLfEHiNB}7c&B-?Q71Gp|>^$UfMoYT*n{Dv2PW^Oc5cz`D1?N98R~_dOjNyA~oLkD#!*;@?id;(r-31)G^{Z0U zvYbY#ldXMBMz+kMWcdRRBRDb!vT*bbr@x3iHti;2+;eM!CoDL)clP}(T+R$H+7e8P z3^KcZ@*ljwk9tMdOvafCD3|;jndXy=h;bpUnU4Zw_OfI`E*XZed)jQ!VTQ143t&*gj=w3Uv;yiRGWp;)fcdaw@?Al>icO_8E|O(PFfkF7kK-7Q zSTf+Lj!{}{nv?#1$dq2h1~O}g&m*mY)~S(b(iV^#-)XH>+{x_igP6afFcgqbXMji9 zQ8sEtD9*#B)9Wa4zmLK<`D8~O1{$~492-?XOh=`BwYaVO9uPZH;%1L~oDl&Er}Npu z2{7j(lhx2oL`PIpnEBf=Uy9X}ni9;?mJ4x7{|8&=6e~&>HtB8Kwr$(CZQHi(vu)e9 zZQHha_MC5$$z=Y_O<$~Zy06yiPQ6c6O|ufS?KbPd?D#ANSwEj;&Dtj}>u+8Mb1v}mG#qr_Orggja^Et!GJs{TX=^0Q@*X@% z*!U*g2}NXqXIFnw6<}Zhp`&9!A1UA=DR3lW)Se*gCp4!%q3+HzbDr=avd$EI2$ftB zRT-ksKQUWZ%fbt9(w<@adBqwWu+ij6VS2EML?~oZU6gf0rJB9c6T0t^Cg7q>f>f=J z6kWACDvyO71oc2mF?QE$WZ^w`4xR9#*mO*nM=QuHYWPk=MgugvD|26`e%3 zr0LUK-d4D{PM_oYdXmr`fF$iHthb@bcd}Tt!-f(&?Tt?n6M>_=ByA-jRWfScKOQ~ML~CmF@$OWs5JDvU%G$D* zgNGiXHp$VnnqoANhZF+2U}KL%GVVta1#SsZ_2^73I@hPV%NJsZWMQNC8wg=PuVUOV zBOqg-d(pE9V_c_u?Hz0w*)yBufj9ahTUgYAf_5BsX(Q5Sro{9W$*1qcdu@6Sx7*Dp z;8eWc!k3ui95`J#s;b1nMxug!^Y@Sp5z-~?8SEqDKy*ZX6C+^p8grHzd(1j6HY;U9DzCTQQuAqS&PjzHQSEDmYvoa*zyuBhVu5m(ZC)DQKA%qe{sWiv%<}_%x=GtmXA?G33@nhL#P5@<$iJ&%IWR ztUy%nP^tjy!3{Htv72lds9Q!AziX-v^TGEF3`k|)XNG{n1@~MNX3?c@ws&DX|m`npkAc$`<|L1|y~dW_}bKe%pdhwJ+fGryLs5jDzlaXyD0j zAYLB)nlz7Wc46jqYOeTAE^c(^C@(b!+iY@x487ME6B+zsrsWc|#hPsuN-q>3H9P5nGK z-?y!%${!B6G0*-uevIvS_%|^g3R9&nwT!UY!o(mTty=QZxMygV=y8PYjs!#WW&d}A z(N<%nYh=;^N9!;Qk@NpCh-=t6@9Bvg0mSzeN0UOR_4fsq7Hh`(S*cZUI6c0b2mK67 zcx9~$n2$f5DXjuC4-h#j3m+)tx67F0>K>6N8ew`yO5x9c%IQ^Fq&}k#>1B{!+pHHu zi)Jc1+1>Z&VQ$On=3*2_=*m+ua;g1gp}!1ZxtsOR95ib_H=R;;BMP+4 zv9bC(kI#vYL0>FFbw`PMcvO-H*#^CxpJQNaY_+Bn8nci>Z6YNtI9PzngILi0ifq;K zkVFKSH7A6te=bR&=G|(owxh+UeY2Z|Ix3bRzx!8iCW?}diq*nQ#pnnx4)Uk$AM$A} zX)dWH;-#8FKq-TtjgLcCm!e_alAn)CZNrx5d6l~NF5rW^z@BwVYt4f2M9^gz%fXaFEaE* zTk|_dOP89){u$q!cpNmf51{$r0uD_%rf@q3ORjQa#UYnn{a25Ew!B_|gNU(bPza8K zbj!-wuxFMu)t5*SYfn6fCPQEpu;6t9sOm{L4C!xKOZXisBF5SyU+I z6bphpGLw1DSw_okQ(dEa;cf`V2GSO1+f=XEeX# zY9>|)zA()RFiGN;SfVA!Z6LuNc`PtRqm|!jC_k)FDUH|hT%ND_6k|fQ%{WqS{+uNt zz9B?n+KroT00@ zO-({EHid*f_Q%sQ#II!viM4$08=4~+`1(QCmc6S|ytxU%iQ2Bqzum(dqBYH6KXP z%$TTF)DP6>OR}k1y*k_*bl=TuRhx3=IaQmt0jtY|A;M8i4$Cqe>V)}hWlJ^ zWLO`#e*Qx_oL@dZnC@`}6Z!b7tew4VTX~9fCsbQ_G`skUP^GlwzJv={lzWv{W)W?r z)|{T6lJ6Y=F<8z|JU+EPjC>ef8gv}xl~&9qy;P}Ft+i5X)vFRMfpHcl4oPU@fJA+N zSZyXNEBqC0WIwW##)DX53Dnz=?I)(wUu=dy)a1ipR<%THQmA z7i>17y;T~l8pK+jIZbo_w1)eiCc2z0-!}wnx*s+UEQ<$~y_8d>It~qZJ4>c%uB-+v z1}ik%1=yoCqf2CzXGlbziPl-DWjh)lduOlp(ff$U%No=iA0#bzRbXKb?CZ(tx>O^4 z5}mh8=;!YZPXO&`HN5THRNfJ|w85C?`ug(0MMjk(Zl(To=nLmwX)Lmd zVj3)AKI73t;py4MLTd{-t!$~ciLLYRV}I+GOwn%B^?x9iNS6A>Z%YW{7`lll;WGck zrdia!Of|>`ZrsK|zoKApEESd%3CBO%A&VkiJLQo4mQXeF#%EsLuN6QPANBa(xNZXuV`;+~QbxhNK~ePwkxM z#wiZv%oY!u^X?I|MPVyJCWc0T_y2@i@v1NLO{hY9Y7syiK6rMpL30)8(_f&>dl02x z#L%mSk7Xwcx`7gg^=$18eRHb5P5y{&lrJ^KQI8oZObSE!p1Tb*UalkrFRv8ipfkE{ z=eXcEsEiw&y=WGM(Ac2BQ(V?`bT=idny9d_2)Z_K<`Wczm)BYjltA@>$QD?MU88cR zrTN9i26|(D5ofH|PIiUd8?ZR_%IHcTP?bZ(p=96?kQiHo=S+%Fx9^mn_>?F6;)U5 zKlB&rs79tgpQ^8iF$2^djszs_-VE%n_85G^lI|&%-Tbf8>msdSfnggG5q&hpcv07T#m1G`R^6$}9VZIS>Ohpdzf+!la%j2!;P)wbJNV0;3~m zcD{s$CuBrq^#1i{e+_+{$}F%d1g+8C)N25KlYB0Teh>wsX~*Vg1xy*O9op;$-P`b3{pmtD4H6)r zZ=;d4FTElPl?6rMfHU8u@ipzFs8g_I(q5yT)E|0_>#1#3Edov)?IlFb;0v@%cng)) z&yxa!*}Bg_0sG40Azzs9!79OR2mXj&C4q5E)#VSTJ5irSZLPCjd3uEBRZN#WPt?sv z!WI4LW}ywo(6k3a^kN}HN!qx|N7rvVcv%p8?b;{1LerfqIw5;_H9-EWbK9>$^4>h} zC06{VL&_n+HOm0-lM$q_c<+I?@BBzIR2HWSiOS?K;&s&kBQ;@O0M-b)l~>pvre8d@ z-*2r>pTaZ)&(M9t$bE9j=5qtg05b@_F$ljGiSRwlz!=6rd`}*sN7%k`%)Yr*D$Ecw z48A%H|DO*dFTSS^s)FO;D+sOg#8>c-+mda?CTpof=>=P}Ute;S9ga1(nxK67*W6 z=_LpbPcYCd+v&bcRysAj#{w*VMP6^O^O-Gnz@oW+6)2apH~jiyQ=)7XYZR&?qf5ir zMicY`uZxQ8mA71A1 zuG#oVNVH9^LHU0|?g@vsVC>%jb{jcHAuo)>x-f5V0k=!yULYTo!#XfeZ(*l-y^h-u zxwK5vvkY&`4Q?CWM5lRQ|Mm{(ybbS!G^k~CryE}9V?f8zo_7IpPcmpHRV~VkX|Ob~+N&b1^*;7nYXQ8~_RNK)@`u4X;LX7#ZZLnKIbA4HZ zaks|h-j0w4-)-Y$-Z3oD#ex+W21IN?TtNS?1xJZL>7+sVof>g}0s@8+d;h_}+cOC8iJ8rXauI~m`f`0(RBm7<#Z)fV_>|$tVV(4VTNXJ0$Ivk&9O^vHr zkEl16PA~yK%cFFX96?6Ylx-wYXJgAx@{yiO~9(&*G3b+4RlUK_e2(DkUZPr$w)6wa4 zAcN3uaqC&=^naPwy4(H8%l@e2|DyjL(|&P_{mCQnsM@>ck}Mq zf>uwvrEwpm`o7SvI~aQhue0=jScUpx_s)5D{$vcO)8}nIN9_0EOTp{{`+A{q5TiE^4JLA_L@$1M90ar185$-p+_aXAD$oEsgPdn$| zyLx zP4ssMpJRCq@{ToG*G=lr8(>?A+R$Hn(y!dxx9=Z|+I5jj31iN63)i7JD{@6Umd~sH zZVxqUG4k)C-D2zq-GAPk_of!(t$N(XJh|J4=QjMl7U;h2s9%w@0dg<-w#ESFOuxO| zAnFY6t`*$I=EmapTiuHIx;kLpz%I;lMQE?lfL@n>^p~f5F zT1QV96~8W`HA#aF22c2f3$n2PMm<^^d(J7>hn#Kf+Y9goMCSpz-S3{ZJIC>MG_1^_J3ZH4fVwcplY?3}yN;A{u!4t|9}uxN9EZW|!w zZ`7{dI7de!{(iVw>&^r8{^Z5~Ju2+PIP0oG)rt<}m21q#u1WC7Qe$3-%arv1>9XwB zc;lr%dfTA&*XA4GGzpdrzMM1*5^3|seccHS$qINt_TGW>{-GxE=P2TRrSxX4|Gfjr z32ZjO2k}TJCc|KRvn*ACQ7@Tz_R#a7>^Vt2Scc4?5vo2QYog zu2qyk`5-;(@tcW5WX!I4=iE6R@4V#uX7L-P&jil!T>&r?_ul|4B>X}y9w60KlY%O^FYN4sb{8dh1o^|~k~^&QEFQR<83v-yZ^GZW zMOr-ST^ia@wXzz9(G6dA4*?jLC_S%b%|`8swy(0N$YnQ(ckhysUPG&X9&&)1Wn&nB zL60CQsm^xG=Qt)l7L}S@_IdFgC1UYNty4C^kox_mnjw(Pqa^BduCaI+MHJ8WB!X=( z=mC8=tc5V9-7Q<|b%_*}?ZKR&bSiq60nfuBXH^r<2k#pV;>-Rdj9)VcXtJkxOYShepWjXax{XDu3>`M1END~s zRkfI?IG-;9uJb7{$WVE(!l=h|@)zh;+YU=3sKi%c6Rv}>of;)RN+Ik1=DrqpZ0S7}ipa%EuIFV%0oBYs9p_6v z-^(`sXfA~}jz5@ufW^HE5y<%4gx1`ez z`@7%UW+|q4jj}Tq@{i^-y}yarm7BmPDiD?f$j`7w@Bv2t-|Kp*OL;+~fDOCSTKO$R zuii8I!P&MT7m6|r9bp-8T7|<1Y|N>4WlHc#!g3iiIqJTW$gSkmxL8Rew|P;#66nCm z!CezDcJ;r}^$o@o6Lv!-*hX%X471Xbr4qK%a;1iCe5hM6548>*^aB6-=5q>JgDxgZ zljw&HD2Yt4G7_a0Ut{TXwXa+T)#%wvvU*jb$DNg5{L#D>04wRdz}UGD zg2lXRvhsF9qsC+Iv$-X>Bk!R2ZClR-^}AN>7<1ak{7+!eiePX6_#0Kb6zhm~%rncf zeT=h}C3s0758?pp>vF-vTYC6hqq?j`C%NFHG!L^V z*5DRsJYvLF_$JvkLh^g}^Wu9O{y5kD3uYoU_|>ZOrM?d9amQznanSwPQ#nSq>S4Jv zVh>27i3B8g^%aBE@9%qudr0s99za+C)3TO#+!`u5zk^tgM}?~GoM8au7UR;@S-@Gx?a6MC<9*eBe$M<@0Q+xsmr`bGB`7lU;-;JFqA%4dh)EvAN zk=s{F#51sH!`6AkXPDeinPVk#S}dqu7ckt=rS4x&Y|m=_&HVptH+ zN0P+FSwFv(bf~^-+}Gy?5IzK`DViJZUYdUXi`gje4)LjLQF!L9@yr)Wgu}IvcCVMX z;q|;-SqIW{RM|57r)#a8RjsOKx8)U!fKj;#etzi*^lb%}K^T)R+|T4!EEn`da|RoK zUGH6igKVaS>7lQ6FyUxa>u$71o8T2U<0TN)uT3qwUpVQ9`raNCy*RL0(mgg$uUEzM zXcF7T*GaHs&y95G@y!2%?Li)0)xzG&-JAVS)lR~!Y?sfN-MO}jxui(Sb?v2KJs8Sf zCA>kF^UwQ5QtTcA8N{sL{4H(M5)@X=evz1a%_hulg&TH@^Q}j~rH0zq>34t~0F^pQIISf%cv6&D zxq!73Gnwl@KXdY5(OAAr56*j7j5ylSYP9SE)*Kf4QQ;6 z-G>NMhvVBXoOO>rOJ@w=P^S=4R0EHbFr1ZTI?O%GW@uik!+U83XX`e)B=q)1uvNDKDTUH!($N63SQ%iEvfD6(K|G^%KvYh38J+@N znvNS!juk zPneGAF5B1yK6LFQLh3Ix>0&KMGSSwWZ#aRpU~wQ%0T$2nlw!P>h?7LwI?$mJq62}d z$p+oUHO∓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ℑSFQlX8%jlQWQ# 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%0AKNWFd?nXbD~i4; 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