YieldInstructions from unmanaged land e.g. WaitForSeconds. Possible?

Your question is very vague what exactly you want to achieve.

Some words about Unity's coroutine mechanism:

• Unity's coroutine scheduler is the only one who can start, run or continue a "Coroutine". This scheduler of course can't be modified.

• The only possible yield values the scheduler understands are: - classes derived from YieldInstruction (WaitForSeconds, WaitForEndOfFrame, WaitForFixedUpdate, AssetBundleCreateRequest, AssetBundleRequest and Coroutine - a WWW object - "any other value" which isn't one of the above.

• The YieldInstruction is just an empty class without any useful interface. The behaviour of the scheduler for the different YieldInstructions is hardcoded into the scheduler.

• if "any other value" is yielded (which includes "null" a string value any other basic type such as int, bool, ... or a reference to an arbitrary object which isn't one of the above mentioned) the scheduler will "schedule" the coroutine for the next frame.

• Coroutines are managed objects which are under the control of the Unity scheduler.

• Coroutines implement a cooperative multitasking and are executed on the main thread like any other scriptcode in unity. There's no parallel execution at all.

Since most built in classes are sealed, you can't derive your own class from them. Also it wouldn't work out since the schedulers behaviour is limited to the known values. Your best bet is to write a seperate coroutine which polls each frame / x amount of time if it should continue or not. Something like this:

 //c#
 public class CoHelper : MonoBehaviour
 {
     private static CoHelper m_Instance;
     public static CoHelper Instance
     {
         get
         {
             if (m_Instance == null)
             {
                 m_Instance = (new GameObject("helper")).AddComponent<CoHelper>();
                 // DontDestroyOnLoad(m_Instance.gameObject);
             }
             return m_Instance;
         }
     }
     public static Coroutine WaitForSomeExternalCondition()
     {
         return Instance.StartCoroutine(_WaitForSomeExternalCondition)
     }
     private static IEnumerator _WaitForSomeExternalCondition()
     {
         bool done = false
         while(not done)
         {
             // check your condition and set done to true if your done
             
             yield null;
             // yield new WaitForSeconds(UPDATE_INTERVALL);
         }
     }
 }

With that helper you could do this in any coroutine:

 IEnumerator SomeRoutine()
 {
     Dosomething();
     yield CoHelper.WaitForSomeExternalCondition();
     DoSomethingOther();
 }

Keep in mind if you're using threads to use proper locking / synchronising.

edit
I forgot to mention that you could implement your own scheduler like this one: CoroutineScheduler. Unity's scheduler works in a very similar way, however the exact implementation we'll never see since it's implemented in the native part of the engines core. It might have some additional optimisations like a ordered queue for routines which yielded WaitForSeconds and so on.

Unfortunately the authors blog page about coroutines (which was great) doesn't exist anymore. However he kind of copied the content into this post. If you want to understand how coroutines and generator methods work, read it ;)

2. edit
Just re-read the question and i'm still confused what you want to do and where exactly. If this question was about if it's possible to implement coroutines in C++ the same way as in C# then the answer is clearly: no. That's because C# has the yield keyword which is a powerful compiler feature. A method containing a yield statement is translated into a class that implements IEnumerator and the method itself just returns an instance of that class. Since C++ doesn't have this feature you can't do it the same way. The C# compiler has to be very smart to translate your yield-code into a statemachine.