alexa-tracking

Class yang paling kocak gan

Main Content

1024
1024
KASKUS
51
244
https://www.kaskus.co.id/thread/51608f5c582acfaf49000001/class-yang-paling-kocak-gan
Class yang paling kocak gan
Gini gan, agan yang pernah lihat bahasa pemrograman pasti tau namanya Class. Nah ada nih gan, class bawaan framework microsoft yang bikin ane ngakak emoticon-Ngakak
namanya gan: Lazy<T>
keterangannya:
Quote:Use lazy initialization to defer the creation of a large or resource-intensive object, or the execution of a resource-intensive task, particularly when such creation or execution might not occur during the lifetime of the program.

To prepare for lazy initialization, you create an instance of Lazy<T>. The type argument of the Lazy<T> object that you create specifies the type of the object that you want to initialize lazily. The constructor that you use to create the Lazy<T> object determines the characteristics of the initialization. Lazy initialization occurs the first time the Lazy<T>.Value property is accessed.

In most cases, choosing a constructor depends on your answers to two questions:

Will the lazily initialized object be accessed from more than one thread? If so, the Lazy<T> object might create it on any thread. You can use one of the simple constructors whose default behavior is to create a thread-safe Lazy<T> object, so that only one instance of the lazily instantiated object is created no matter how many threads try to access it. To create a Lazy<T> object that is not thread safe, you must use a constructor that enables you to specify no thread safety.
Caution noteCaution

Making the Lazy<T> object thread safe does not protect the lazily initialized object. If multiple threads can access the lazily initialized object, you must make its properties and methods safe for multithreaded access.

Does lazy initialization require a lot of code, or does the lazily initialized object have a default constructor that does everything you need and doesn't throw exceptions? If you need to write initialization code or if exceptions need to be handled, use one of the constructors that takes a factory method. Write your initialization code in the factory method.

The following table shows which constructor to choose, based on these two factors:

Object will be accessed by


If no initialization code is required (default constructor), use


If initialization code is required, use

Multiple threads


Lazy<T>()


Lazy<T>(Func<T>emoticon-Wink

One thread


Lazy<T>(Boolean) with isThreadSafe set to false.


Lazy<T>(Func<T>, Boolean) with isThreadSafe set to false.

You can use a lambda expression to specify the factory method. This keeps all the initialization code in one place. The lambda expression captures the context, including any arguments you pass to the lazily initialized object's constructor.

Exception caching When you use factory methods, exceptions are cached. That is, if the factory method throws an exception the first time a thread tries to access the Value property of the Lazy<T> object, the same exception is thrown on every subsequent attempt. This ensures that every call to the Value property produces the same result and avoids subtle errors that might arise if different threads get different results. The Lazy<T> stands in for an actual T that otherwise would have been initialized at some earlier point, usually during startup. A failure at that earlier point is usually fatal. If there is a potential for a recoverable failure, we recommend that you build the retry logic into the initialization routine (in this case, the factory method), just as you would if you weren’t using lazy initialization.

Alternative to locking In certain situations, you might want to avoid the overhead of the Lazy<T> object's default locking behavior. In rare situations, there might be a potential for deadlocks. In such cases, you can use the Lazy<T>(LazyThreadSafetyMode) or Lazy<T>(Func<T>, LazyThreadSafetyMode) constructor, and specify LazyThreadSafetyMode.PublicationOnly. This enables the Lazy<T> object to create a copy of the lazily initialized object on each of several threads if the threads call the Value property simultaneously. The Lazy<T> object ensures that all threads use the same instance of the lazily initialized object and discards the instances that are not used. Thus, the cost of reducing the locking overhead is that your program might sometimes create and discard extra copies of an expensive object. In most cases, this is unlikely. The examples for the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors demonstrate this behavior.
Important noteImportant

When you specify PublicationOnly, exceptions are never cached, even if you specify a factory method.

Equivalent constructors In addition to enabling the use of PublicationOnly, the Lazy<T>(LazyThreadSafetyMode) and Lazy<T>(Func<T>, LazyThreadSafetyMode) constructors can duplicate the functionality of the other constructors. The following table shows the parameter values that produce equivalent behavior.

To create a Lazy<T> object that is


For constructors that have a LazyThreadSafetyMode mode parameter, set mode to


For constructors that have a Boolean isThreadSafe parameter, set isThreadSafe to


For constructors with no thread safety parameters

Fully thread safe; uses locking to ensure that only one thread initializes the value.


ExecutionAndPublication


true


All such constructors are fully thread safe.

Not thread safe.


None


false


Not applicable.

Fully thread safe; threads race to initialize the value.


PublicationOnly


Not applicable.


Not applicable.

Other capabilities For information about the use of Lazy<T> with thread-static fields, or as the backing store for properties, see Lazy Initialization.
NoteNote

The HostProtectionAttribute attribute applied to this type or member has the following Resources property value: Synchronization | ExternalThreading. The HostProtectionAttribute does not affect desktop applications (which are typically started by double-clicking an icon, typing a command, or entering a URL in a browser). For more information, see the HostProtectionAttribute class or SQL Server Programming and Host Protection Attributes.

kalau di translate jadi :
malas
lazy, indolent, slothful, inert, lethargic, sluggish
culas
deceitful, clumsy, slow, lazy
emoticon-Ngakak
ajarin dong gan, supaya ane ngerti bahasa pemogramannya,, ane masih awam..
lucunya darimana gan?? emoticon-Bingung (S)
ane belum kenal ama class gituan gan, ane baru kenal ama class public class gan emoticon-Malu (S) emoticon-Ngakak (S)
wow.. joke ente adalah joke tingkat dewa emoticon-Matabelo

ane ngga ngerti gan emoticon-Amazed
apa ini gan ? ane g ngerti
ga mudeng gsn walaupun jurusan kuliah ane SI emoticon-Hammer
gak ngerti gan emoticon-Bingung (S)
ora mudeng gan emoticon-Big Grin
gak ngarti ahh gan emoticon-Bingung (S)
emoticon-Bingung
mskd TS apa si?
ane gak mudeng
ane gak nerti gan.,
ane gak paham bahasa pemrograman gan hahaa

Quote:Cek dagangan ane gan
Gitar Epiphone Les Paul Studio China (klik disini)

Class yang paling kocak gan
reserved dlu gan
Ora paham inyong..
Maksute opo yak..
emoticon-Bingung
joke tingkat Dewa..
ane gak paham gan...emoticon-Bingung
apa sih ini? ga paham ane emoticon-Malu (S)
yang ngerti cuma TS nya yang kepintarannya udah diatas rata rata.
klo ane sihemoticon-Bingung (S)
wah, ini sih kelas buat pemalas banget gan via PHP emoticon-Ngakak
Gan, anak mana? Keren ey threadnya.