init
NSOperation
object.
初期化されたNSOperation
オブジェクトを返します。
Availability 有効性
Technology
@interface NSOperation : NSObject
Because the NSOperation
class is an abstract class, you do not use it directly but instead subclass or use one of the system-defined subclasses (NSInvocation
or NSBlock
) to perform the actual task. Despite being abstract, the base implementation of NSOperation
does include significant logic to coordinate the safe execution of your task. The presence of this built-in logic allows you to focus on the actual implementation of your task, rather than on the glue code needed to ensure it works correctly with other system objects.
NSOperation
クラスは抽象クラスであるので、あなたはそれを直接に使いません、そうしないで代わりにサブクラスを作成するかまたはシステム定義のサブクラス(NSInvocation
またはNSBlock
)の1つを使って実際のタスクを実行します。抽象的であるにもかかわらず、NSOperation
の基礎実装は、あなたのタスクの安全な遂行をうまく調整するための重大な論理を含んでいます。この組み込みの論理の存在は、あなたをあなたのタスクの実際の実装に集中させます、それが他のシステムオブジェクトと正しく仕事するのを確実にするために必要とされるグルー(糊)コードにではなく。
An operation object is a single-shot object—that is, it executes its task once and cannot be used to execute it again. You typically execute operations by adding them to an operation queue (an instance of the NSOperation
class). An operation queue executes its operations either directly, by running them on secondary threads, or indirectly using the libdispatch
library (also known as Grand Central Dispatch). For more information about how queues execute operations, see NSOperation
.
オペレーションオブジェクトは単発オブジェクトです — すなわち、それはそれのタスクをただ一度だけ遂行します、そしてそれは再び遂行するために使用されることは出来ません。あなたは概してオペレーションを、それらをオペレーションキュー(NSOperation
クラスのインスタンス)に加えることによって遂行します。あるオペレーションキューは、それのオペレーションを、それらを副次スレッド上で実行することによって直接に、またはlibdispatch
ライブラリ(またGrand Central Dispatchとしても知られる)を使って間接的にのどちらかで遂行します。どのようにキューがオペレーションを遂行するかについてのさらなる情報として、NSOperation
を見てください。
If you do not want to use an operation queue, you can execute an operation yourself by calling its start
method directly from your code. Executing operations manually does put more of a burden on your code, because starting an operation that is not in the ready state triggers an exception. The ready
property reports on the operation’s readiness.
あなたがオペレーションキューを使いたくないならば、あなたはstart
メソッドを直接にあなたのコードから呼び出すことによってあなた自身でオペレーションを遂行できます。手動でのオペレーション遂行は、あなたのコードにさらに多くの負担をかけます、なぜなら準備ができた状態にないオペレーションを開始することは例外を引き起こすからです。ready
プロパティは、オペレーションの準備ができていることを報告します。
Dependencies are a convenient way to execute operations in a specific order. You can add and remove dependencies for an operation using the add
and remove
methods. By default, an operation object that has dependencies is not considered ready until all of its dependent operation objects have finished executing. Once the last dependent operation finishes, however, the operation object becomes ready and able to execute.
依存関係は、オペレーションそれらをある特定の順序で実行する便利な方法です。あなたは、あるオペレーションに対する依存関係をadd
およびremove
メソッドを使って追加および除去できます。初期状態では、依存関係を持つあるオペレーションオブジェクトは、それの依存しているオペレーションオブジェクトの全てが実行を終了してしまうまで準備ができているとみなされません。いったん最後の依存オペレーションが終了すれば、しかしながら、そのオペレーションオブジェクトは準備ができて実行が可能になります
The dependencies supported by NSOperation
make no distinction about whether a dependent operation finished successfully or unsuccessfully. (In other words, canceling an operation similarly marks it as finished.) It is up to you to determine whether an operation with dependencies should proceed in cases where its dependent operations were cancelled or did not complete their task successfully. This may require you to incorporate some additional error tracking capabilities into your operation objects.
NSOperation
によってサポートされる依存関係は、依存するオペレーションが成功または不成功に終わったかどうかについて区別しません。(言い換えれば、オペレーションをキャンセルすることは同様にそれを終了したと印します。)依存関係を持つあるオペレーションが、それの依存オペレーションがキャンセルされたかそれらのタスクがうまく完了しなかった場合において、続行すべきかどうかを決定するのはあなた次第です。これは、あなたにいくつかの追加のエラー追跡能力をあなたのオペレーションオブジェクトに組み込むことを要求するかもしれません。
The NSOperation
class is key-value coding (KVC) and key-value observing (KVO) compliant for several of its properties. As needed, you can observe these properties to control other parts of your application. To observe the properties, use the following key paths:
NSOperation
クラスは、それのプロパティのいくつかに対してキー値コーディング(KVC)とキー値監視(KVO)準拠です。必要ならば、あなたはそれらのプロパティを監視して、あなたのアプリケーションの他の部分を制御できます。プロパティを監視するには、以下のキーパスを使ってください:
is
- read-only
is
- read-only
is
- read-only
is
- read-only
is
- read-only
dependencies
- read-only
queue
- readable and writable
completion
- readable and writable
Although you can attach observers to these properties, you should not use Cocoa bindings to bind them to elements of your application’s user interface. Code associated with your user interface typically must execute only in your application’s main thread. Because an operation may execute in any thread, KVO notifications associated with that operation may similarly occur in any thread. あなたがオブザーバーをこれらプロパティに添付できるとはいえ、あなたはCocoaバインディングを使ってそれらをあなたのアプリケーションのもつユーザインターフェイスにバインドすべきではありません。あなたのユーザインターフェイスに結びつけられたコードは、概してあなたのアプリケーションのもつメインスレッドにおいてのみ遂行されなければなりません。あるオペレーションがどんなスレッドで遂行してもかまわないことから、そのオペレーションと結びつけられたKVO通知は同様にどんなスレッドに発生してもかまいません。
If you provide custom implementations for any of the preceding properties, your implementations must maintain KVC and KVO compliance. If you define additional properties for your NSOperation
objects, it is recommended that you make those properties KVC and KVO compliant as well. For information on how to support key-value coding, see Key-Value Coding Programming Guide. For information on how to support key-value observing, see Key-Value Observing Programming Guide.
あなたが前述のプロパティに対してあつらえの実装を提供するならば、あなたの実装はKVCおよびKVO準拠を保守しなければなりません。あなたが追加のプロパティをあなたのNSOperation
オブジェクトに対して定義するならば、あなたがそれらプロパティを同じくKVCおよびKVO準拠させることは推奨されます。どのようにキー値コーディングをサポートするかに関する情報として、Key-Value Coding Programming Guideを見てください。どのようにキー値監視をサポートするかに関する情報として、Key-Value Observing Programming Guideを見てください。
The NSOperation
class is itself multicore aware. It is therefore safe to call the methods of an NSOperation
object from multiple threads without creating additional locks to synchronize access to the object. This behavior is necessary because an operation typically runs in a separate thread from the one that created and is monitoring it.
NSOperation
クラスは、それ自身マルチコアを万事心得ています。したがってNSOperation
オブジェクトのメソッドを複数のスレッドから追加のロックを作成してそのオブジェクトへのアクセスを同期することなしに呼び出すのは安全です。この挙動は不可欠です、なぜならあるオペレーションは通常は作成されたものとは独立したスレッドにおいて動作して、それを監視するからです。
When you subclass NSOperation
, you must make sure that any overridden methods remain safe to call from multiple threads. If you implement custom methods in your subclass, such as custom data accessors, you must also make sure those methods are thread-safe. Thus, access to any data variables in the operation must be synchronized to prevent potential data corruption. For more information about synchronization, see Threading Programming Guide.
あなたがNSOperation
のサブクラスを作成する場合、あなたはあらゆるオーバーライドされたメソッドを複数のスレッドからの呼び出しに対して安全なままであることを確実にしなければなりません。あなたがあつらえのメソッドをあなたのサブクラスにおいて実装するならば、たとえばあつらえのデータアクセッサなど、あなたはまたそれらメソッドがスレッド安全であることを確実にしなければなりません。したがって、そのオペレーションにおけるあらゆるデータ変数それらへのアクセスは、同期されることで潜在的なデータ汚染を防止されなければなりません。同期についてのさらなる情報として、Threading Programming Guideを見てください。
If you plan on executing an operation object manually, instead of adding it to a queue, you can design your operation to execute in a synchronous or asynchronous manner. Operation objects are synchronous by default. In a synchronous operation, the operation object does not create a separate thread on which to run its task. When you call the start
method of a synchronous operation directly from your code, the operation executes immediately in the current thread. By the time the start
method of such an object returns control to the caller, the task itself is complete.
あなたがあるオペレーションオブジェクトを手動で遂行する計画を立てるならば、それをキューに追加する代わりに、あなたはあなたのオペレーションを同期または非同期の流儀で遂行するように設計できます。オペレーションオブジェクトは、省略時には同期的です。同期的オペレーションにおいて、オペレーションオブジェクトは、それの上でそれのタスクを実行することになる独立したスレッドを作成しません。あなたが同期的オペレーションのstart
メソッドを直接にあなたのコードから呼び出す場合、そのオペレーションは直ぐに現在のスレッドにおいて遂行します。そのようなオブジェクトのstart
メソッドが制御をその呼び出し側に返すまでに、タスクそれ自体は完了します。
When you call the start
method of an asynchronous operation, that method may return before the corresponding task is completed. An asynchronous operation object is responsible for scheduling its task on a separate thread. The operation could do that by starting a new thread directly, by calling an asynchronous method, or by submitting a block to a dispatch queue for execution. It does not actually matter if the operation is ongoing when control returns to the caller, only that it could be ongoing.
あなたが非同期的オペレーションのstart
メソッドを呼び出す場合、そのメソッドは対応しているタスクが完了される前に返るかもしれません。非同期的オペレーションオブジェクトは、別個のスレッド上でのそれのタスクを予定することに対して責任があります。オペレーションはそれを行えます、新しいスレッドを直接に開始することによって、非同期的メソッドを呼び出すことによって、または遂行のためのディスパッチ(派遣、発送)キューに対してあるブロックを提出することによって。それは実際は問題ではありません、もし制御が呼び出し側に返る時にオペレーションが進行中であるならば、ただそれは進行中のままでよいだけです。
If you always plan to use queues to execute your operations, it is simpler to define them as synchronous. If you execute operations manually, though, you might want to define your operation objects as asynchronous. Defining an asynchronous operation requires more work, because you have to monitor the ongoing state of your task and report changes in that state using KVO notifications. But defining asynchronous operations is useful in cases where you want to ensure that a manually executed operation does not block the calling thread. あなたが常にキューを使ってあなたのオペレーションそれらを遂行するよう計画するならば、それらを同期的に定義するのがより簡単です。あなたがオペレーションを手動で遂行するならば、そうはいうものの、あなたはあなたのオペレーションオブジェクトを非同期的に定義したいかもしれません。非同期オペレーションの定義はさらなる仕事を要求します、なぜならあなたはあなたのタスクの進行状態を監視してその状態の変化をKVO通知を使って報告しなければならないからです。しかし非同期オペレーションを定義することは、手動遂行オペレーションがその呼び出しているスレッドを封鎖しないことをあなたが確実にしたい場合に役に立ちます。
When you add an operation to an operation queue, the queue ignores the value of the asynchronous
property and always calls the start
method from a separate thread. Therefore, if you always run operations by adding them to an operation queue, there is no reason to make them asynchronous.
あなたがあるオペレーションをオペレーションキューに加える場合、そのキューはasynchronous
プロパティの値を無視します、そして常にstart
メソッドを別個のスレッドから呼び出します。それゆえに、あなたが常にオペレーションの実行を、それらをオペレーションキューに加えることによってするならば、それらを非同期的にする理由はありません。
For information on how to define both synchronous and asynchronous operations, see the subclassing notes. どのように同期的にそして非同期的にオペレーションを定義するかに関する情報として、サブクラス作成の注意を見てください。
The NSOperation
class provides the basic logic to track the execution state of your operation but otherwise must be subclassed to do any real work. How you create your subclass depends on whether your operation is designed to execute concurrently or non-concurrently.
NSOperation
クラスは、あなたのオペレーションの遂行状態を追跡するための基本的な論理を提供します、しかしそれ以外は何らの本当の仕事をするサブクラスが作成されなければなりません。どのようにあなたがあなたのサブクラスを作成するかは、あなたのオペレーションが並行にまたは非並行に遂行するように設計されるかどうかに依存します。
For non-concurrent operations, you typically override only one method: 非並行オペレーションに対して、あなたは概してただ1つのメソッドをオーバーライドします:
Into this method, you place the code needed to perform the given task. Of course, you should also define a custom initialization method to make it easier to create instances of your custom class. You might also want to define getter and setter methods to access the data from the operation. However, if you do define custom getter and setter methods, you must make sure those methods can be called safely from multiple threads. このメソッドへと、あなたは与えられたタスクを実行するのに必要とされるコードを置きます。もちろん、あなたはまたあつらえの初期化メソッドを定義して、あなたのあつらえのクラスのインスタンスを作成することをより簡単にするべきです。あなたはまた、そのオペレーションからデータにアクセスするためにゲッターおよびセッターメソッドを定義したいかもしれません。しかしながら、あなたがあつらえのゲッターおよびセッターメソッドを定義するならば、あなたはそれらのメソッドが安全に複数のスレッドから呼び出されることが可能であるのを確実にしなければなりません。
If you are creating a concurrent operation, you need to override the following methods and properties at a minimum: あなたが並行オペレーションを作成しているならば、あなたは少なくとも以下のメソッドとプロパティをオーパーライドする必要があります:
In a concurrent operation, your start
method is responsible for starting the operation in an asynchronous manner. Whether you spawn a thread or call an asynchronous function, you do it from this method. Upon starting the operation, your start
method should also update the execution state of the operation as reported by the executing
property. You do this by sending out KVO notifications for the executing
key path, which lets interested clients know that the operation is now running. Your executing
property must also provide the status in a thread-safe manner.
ある並行オペレーションにおいて、あなたのstart
メソッドはオペレーションを非同期流儀で開始する責任を持ちます。あなたがあるスレッドを生み出そうともまたはある非同期関数を呼び出そうとも、あなたはそれをこのメソッドから行います。オペレーションの開始に関して、あなたのstart
メソッドはまた、オペレーションの遂行状態をexecuting
プロパティによって報告されるとおりに更新すべきです。あなたはこれをKVO通知をexecuting
キーパスに対して送り出すことで行います、それは興味を持ったクライアントにそのオペレーションが今実行中であることを知らせます。あなたのexecuting
プロパティはまた、その状態をスレッド安全な流儀で提供しなければなりません。
Upon completion or cancellation of its task, your concurrent operation object must generate KVO notifications for both the is
and is
key paths to mark the final change of state for your operation. (In the case of cancellation, it is still important to update the is
key path, even if the operation did not completely finish its task. Queued operations must report that they are finished before they can be removed from a queue.) In addition to generating KVO notifications, your overrides of the executing
and finished
properties should also continue to report accurate values based on the state of your operation.
このタスクの完了または取り消しにおいて、あなたの並行オペレーションオブジェクトはKVO通知をis
およびis
キーパスの両方に対して生成して、あなたのオペレーションに対する状態の最終変更であると印しなければなりません。(取り消しの場合において、is
キーパスの更新は依然として重要です、たとえそのオペレーションがそれのタスクを完全に終了しないとしてもです。キューに入れられたオペレーションは、それらが終了されることを報告しなければなりません、それらがキューから除去可能になる前にです。)KVO通知を生成することに加えて、executing
およびfinished
プロパティのあなたのオーバーライドは同様に、あなたのオペレーションの状態に基づく精度の高い値の報告を継続すべきです。
For additional information and guidance on how to define concurrent operations, see Concurrency Programming Guide. どのように並行オペレーションを定義するかに関する追加の情報と案内として、Concurrency Programming Guideを見てください。
Important 重要
At no time in your start
method should you ever call super
. When you define a concurrent operation, you take it upon yourself to provide the same behavior that the default start
method provides, which includes starting the task and generating the appropriate KVO notifications. Your start
method should also check to see if the operation itself was cancelled before actually starting the task. For more information about cancellation semantics, see Responding to the Cancel Command.
決してあなたのstart
メソッドにおいてすべきでないのは、あなたが一度でもsuper
を呼び出すことです。あなたがstart
オブジェクトを使ってコピー、移動、リンク、または除去操作を始める時、ファイルマネージャはそれの委任先に、操作がそもそも始まるべきかどうかそしてそれはエラー発生の時に続けるべきか尋ねます。あなたのstart
メソッドはまた、オペレーションそれ自身が本当にタスクを開始する前に取り消されたかどうか見るために調べるべきです。取り消し意味論についてのさらなる情報として、Responding to the Cancel Commandを見てください。
Even for concurrent operations, there should be little need to override methods other than those described above. However, if you customize the dependency features of operations, you might have to override additional methods and provide additional KVO notifications. In the case of dependencies, this would likely only require providing notifications for the is
key path. Because the dependencies
property contains the list of dependent operations, changes to it are already handled by the default NSOperation
class.
並行オペレーションに対してさえ、上で記述されたものの他にメソッドをオーバーライドする必要はほとんどないはずです。しかしながら、あなたがオペレーションの依存関係特徴をカスタマイズするならば、あなたは追加のメソッドをオーバーライドして、そして追加のKVO通知を提供する必要があるかもしれません。依存関係に関しては、これはis
キーパスに対する通知を提供することを要求するだけの可能性が高いでしょう。なぜならdependencies
プロパティは依存オペレーションのリストを含むからです、それに対する変化は、既に省略時のNSOperation
クラスによって取り扱われます。
Operation objects maintain state information internally to determine when it is safe to execute and also to notify external clients of the progression through the operation’s life cycle. Your custom subclasses maintains this state information to ensure the correct execution of operations in your code. The key paths associated with an operation's states are: オペレーションオブジェクトは状態情報を内部的に保守することで、遂行するのにそしてまた外部クライアントに進捗を通知するのに安全である場合をそのオペレーションのもつライフサイクルを通して決定します。あなたのあつらえのサブクラスは、この状態情報を保守して、あなたのコードにおいてオペレーションの正しい遂行を保証します。オペレーションのもつ状態と結びつけられるキーパスは以下のものがあります:
isReady
The is
key path lets clients know when an operation is ready to execute. The ready
property contains the value true
when the operation is ready to execute now or false
if there are still unfinished operations on which it is dependent.
is
キーパスは、クライアントにオペレーションが遂行するための準備ができる場合に知らせます。ready
プロパティは、値true
をオペレーションがいま遂行する準備ができている場合に、またはfalse
をもしまだ終了されないそれが依存するオペレーションがあるならば含みます。
In most cases, you do not have to manage the state of this key path yourself. If the readiness of your operations is determined by factors other than dependent operations, however—such as by some external condition in your program—you can provide your own implementation of the ready
property and track your operation’s readiness yourself. It is often simpler though just to create operation objects only when your external state allows it.
ほとんどの場合、あなたはこのキーパスの状態をあなた自身で管理する必要はありません。しかしながら、あなたのオペレーションの準備状況が依存オペレーションの他の要因で決定されるならば — たとえばあなたのプログラムでの何らかの外部状態によって — あなたはready
プロパティのあなた独自の実装を提供して、そしてあなたのオペレーションのもつ準備状態を追跡することができます。しばしばより簡単なのはしかし単にオペレーションオブジェクトをあなたの外部状態がそれを許す場合にのみ作成することです。
In macOS 10.6 and later, if you cancel an operation while it is waiting on the completion of one or more dependent operations, those dependencies are thereafter ignored and the value of this property is updated to reflect that it is now ready to run. This behavior gives an operation queue the chance to flush cancelled operations out of its queue more quickly. macOS 10.6以降では、あなたがあるオペレーションをそれが1つまたはそれ以上の依存オペレーションの完了を待っている間にキャンセルするならば、それら依存関係はそれ以降は無視されます、そしてこのプロパティの値は更新されてそれがいま実行する準備ができていることを反映します。この挙動は、あるオペレーションキューにそれら取り消されたオペレーションをそれのキューの外へより素早く一掃する機会を与えます。
isExecuting
The is
key path lets clients know whether the operation is actively working on its assigned task. The executing
property must report the value true
if the operation is working on its task or false
if it is not.
is
キーパスは、クライアントにオペレーションが活発にそれの割り当てられたタスクに取り組んでいるかどうかを知らせます。executing
プロパティは、値true
をオペレーションがそれのタスクに取り組んでいるならば、またはfalse
をそうでないならば報告しなければなりません。
If you replace the start
method of your operation object, you must also replace the executing
property and generate KVO notifications when the execution state of your operation changes.
あなたがあなたのオペレーションオブジェクトのstart
メソッドを置き換えるならば、あなたはまたexecuting
プロパティを置き換えて、そしてKVO通知をあなたのオペレーションの遂行状態が変化する場合に生成しなければなりません。
isFinished
The is
key path lets clients know that an operation finished its task successfully or was cancelled and is exiting. An operation object does not clear a dependency until the value at the is
key path changes to true
. Similarly, an operation queue does not dequeue an operation until the finished
property contains the value true
. Thus, marking operations as finished is critical to keeping queues from backing up with in-progress or cancelled operations.
is
キーパスは、クライアントにあるオペレーションがそれのタスクを成功裏に終了したかまたは取り消されたそして退出していることを知らせます。オペレーションオブジェクトは、ある依存関係をis
キーパスでの値がtrue
に変わるまで清算しません。同様に、オペレーションキューはあるオペレーションをfinished
プロパティが値true
を含むまではデキューしません。したがって、オペレーションを終了したと印することは、進行中にまたは取り消されたオペレーションで、キューのバックアップを防ぐために重大なことです。
If you replace the start
method or your operation object, you must also replace the finished
property and generate KVO notifications when the operation finishes executing or is cancelled.
あなたがstart
メソッドまたはあなたのオペレーションオブジェクトを置き換えるならば、あなたはまたfinished
プロパティを置き換えて、そしてKVO通知をオペレーションが遂行を終了するまたは取り消される場合に生成しなければなりません。
isCancelled
The is
key path lets clients know that the cancellation of an operation was requested. Support for cancellation is voluntary but encouraged and your own code should not have to send KVO notifications for this key path. The handling of cancellation notices in an operation is described in more detail in Responding to the Cancel Command.
is
キーパスは、クライアントにあるオペレーションの取り消しが要請されたことを知らせます。取り消しに対するサポートは自主的です、しかし推奨されます、そしてあなた独自のコードはこのキーパスに対するKVO通知を送らなければならないことはあるべきではありません。オペレーションにおける取り消し警告の取り扱いは、さらに詳細に取り消しコマンドに応答するで記述されます。
Once you add an operation to a queue, the operation is out of your hands. The queue takes over and handles the scheduling of that task. However, if you decide later that you do not want to execute the operation after all—because the user pressed a cancel button in a progress panel or quit the application, for example—you can cancel the operation to prevent it from consuming CPU time needlessly. You do this by calling the cancel
method of the operation object itself or by calling the cancel
method of the NSOperation
class.
一旦あなたがあるオペレーションをキューに加えたならば、そのオペレーションはあなたの手の外です。キューが引き継いで、そのタスクの予定を取り扱います。しかしながら、オペレーションを遂行することを全くあなたが望まないことをあなたが後で決定するならば — ユーザがキャンセルボタンを進捗パネルにおいて押したまたはそのアプリケーションを終了したために、例えば — あなたはそのオペレーションを取り消してそれがCPU時間を必要なく消費することを防止できます。あなたはこれをそのオペレーションオブジェクトそれ自身のcancel
メソッドを呼び出すことによってまたはNSOperation
クラスのcancel
メソッドを呼び出すことによって行います。
Canceling an operation does not immediately force it to stop what it is doing. Although respecting the value in the cancelled
property is expected of all operations, your code must explicitly check the value in this property and abort as needed. The default implementation of NSOperation
includes checks for cancellation. For example, if you cancel an operation before its start
method is called, the start
method exits without starting the task.
あるオペレーションを取り消すことは、直ぐにそれにそれがしていることを停止するよう強要しません。cancelled
プロパティの中の値を尊重することが全てのオペレーションに期待されるとはいえ、あなたのコードは明示的にこのプロパティの値を調べてそして必要に応じて終了しなければなりません。NSOperation
の省略時の実装は、取り消しに対する確認を含みます。例えば、あなたがあるオペレーションをそれのstart
メソッドが呼び出される前に取り消すならば、start
メソッドはそのタスクを開始することなく退出します。
Note 注意
In macOS 10.6 and later, if you call the cancel
method on an operation that is in an operation queue and has unfinished dependent operations, those dependent operations are subsequently ignored. Because the operation is already cancelled, this behavior allows the queue to call the operation’s start
method to remove the operation from the queue without calling its main
method. If you call the cancel
method on an operation that is not in a queue, the operation is immediately marked as being cancelled. In each case, marking the operation as ready or finished results in the generation of the appropriate KVO notifications.
macOS 10.6以降では、あなたがcancel
メソッドをあるオペレーションキューの中にありそして依存オペレーションを終了し終わっていないオペレーション上で呼び出すならば、それら依存オペレーションはその後は無視されます。そのオペレーションがすでに取り消されることから、この挙動はキューにオペレーションのもつstart
メソッドを呼び出してそのオペレーションをキューからそれのmain
メソッドを呼び出すことなく取り除くことを許可します。あなたがcancel
メソッドをキューの中にないオペレーション上で呼び出すならば、そのオペレーションは直ぐに取り消されていると印されます。それぞれの場合において、オペレーションを準備できているまたは終了したと印することは、適切なKVO通知の生成という結果になります。
You should always support cancellation semantics in any custom code you write. In particular, your main task code should periodically check the value of the cancelled
property. If the property reports the value YES
, your operation object should clean up and exit as quickly as possible. If you implement a custom start
method, that method should include early checks for cancellation and behave appropriately. Your custom start
method must be prepared to handle this type of early cancellation.
あなたは常に取り消し意味論をあなたが書くあらゆるあつらえのコードにおいてサポートするべきです。とりわけ、あなたのメインタスクコードは定期的にcancelled
プロパティの値を検査すべきです。そのプロパティが値YES
を報告するならば、あなたのオペレーションオブジェクトは可能な限りすばやくクリーンアップして退出すべきです。あなたがあつらえのstart
メソッドを実装するならば、そのメソッドは取り消しに対する早期の検査を含んで、適切に振る舞うべきです。あなたのあつらえのstart
メソッドは、この種の早期の取り消しを取り扱う用意がなければなりません。
In addition to simply exiting when an operation is cancelled, it is also important that you move a cancelled operation to the appropriate final state. Specifically, if you manage the values for the finished
and executing
properties yourself (perhaps because you are implementing a concurrent operation), you must update those properties accordingly. Specifically, you must change the value returned by finished
to YES
and the value returned by executing
to NO
. You must make these changes even if the operation was cancelled before it started executing.
オペレーションが取り消される場合に単純に退出することに加えて、あなたがある取り消されたオペレーションを適切な最終状態へと移動することはまた重要です。特に、あなたがfinished
とexecuting
プロパティに対する値をあなた自身で管理するならば(おそらくはあなたが並列オペレーションを実装しているために)、あなたはこれらプロパティをそれ相応に更新しなければなりません。特に、あなたがfinished
によって返される値をYES
に、そしてexecuting
によって返される値をNO
に変更しなければなりません。あなたはそれらを変更しなければなりません、たとえオペレーションがキャンセルされたそれが遂行を開始するより前にとしてもです。
init
NSOperation
object.
初期化されたNSOperation
オブジェクトを返します。
- start
- main
completionBlock
- cancel
cancelled
executing
finished
concurrent
asynchronous
ready
name
- addDependency:
- removeDependency:
dependencies
qualityOfService
threadPriority
queuePriority
- waitUntilFinished
NSOperationQueuePriority
NSQualityOfService
NSOperationQueue
NSBlockOperation
NSInvocationOperation