¿Cómo se puede hacer co-rutinas en C #?

StackOverflow https://stackoverflow.com/questions/2493294

Pregunta

En Python la palabra clave de rendimiento se puede utilizar en ambos empujar y tirar de contextos, sé cómo hacer el contexto tirón en C #, pero ¿cómo iba a lograr el empuje. He puesto el código que estoy tratando de replicar en C # del pitón: 

def coroutine(func):
  def start(*args,**kwargs):
    cr = func(*args,**kwargs)
    cr.next()
    return cr
  return start

@coroutine
def grep(pattern):
  print "Looking for %s" % pattern
  try:
    while True:
      line = (yield)
      if pattern in line:
        print line,
  except GeneratorExit:
    print "Going away. Goodbye"
¿Fue útil?

Solución

Si lo que desea es una "colección observable" - es decir, una colección que empuja resultados en lugar de dejar que la atracción del consumidor ellos - entonces es probable que desee ver en las extensiones marco reactiva. He aquí un artículo sobre ella:

http://www.infoq.com/news/ 2009/07 / reactiva-Marco-LINQ-Events

Ahora, como se nota, se puede construir dos iteradores y estilo "empuje" "pull" fácilmente si tiene corrutinas disponibles. (O, como señala Thomas, se puede construir con continuaciones también.) En la versión actual de C # no tenemos corrutinas verdaderos (o continuaciones). Sin embargo, estamos muy preocupados por los usuarios se sienten dolor alrededor de programación asincrónica .

co-rutinas basadas en fibra de ejecución como una característica del lenguaje de primera clase es una técnica que podría ser utilizado para hacer más fácil la programación asincrónica, pero eso es sólo una idea posible de los muchos que estamos investigando en la actualidad. Si usted tiene una muy sólida escenario impresionante donde corrutinas hacer un mejor trabajo que cualquier otra cosa - incluyendo el marco reactiva - entonces me encantaría saber más sobre él. Los datos más realistas que tenemos acerca de cuáles son los problemas reales de personas se enfrentan en la programación asincrónica, es más probable que van a llegar a una buena solución. Gracias!

ACTUALIZACIÓN: Recientemente hemos anunciado que estamos añadiendo corrutina-como el control asíncrono fluye a la próxima versión de C # y VB. Puedes probarlo con nuestra edición Community Technology Preview, que se puede descargar href="http://msdn.microsoft.com/en-us/vstudio/async.aspx" aquí .

Otros consejos

C # no tiene co-rutinas. Un co-rutina general es donde el co-rutina tiene su propia pila, es decir, se puede invocar otros métodos y esos valores se pueden "rendimiento" métodos. Implementación de co-rutinas generales requiere hacer algunas cosas inteligentes con pilas, posiblemente, hasta e incluyendo la asignación de los marcos de pila (las estructuras ocultas que contienen variables locales) en el montón. Esto se puede hacer, algunas lenguas hacen eso (por ejemplo Scheme), pero es un poco difícil de hacerlo bien. Además, muchos programadores encuentran la característica difícil de entender.

Generales co-rutinas puede ser emulado con hilos. Cada hilo tiene su propia pila. En una configuración de co-rutina, ambos hilos (la persona que llama inicial, y el hilo para la co-rutina) se alternarán control, que serán en realidad nunca ejecutar simultáneamente. El mecanismo de "rendimiento" es entonces un intercambio entre los dos hilos, y como tal, es caro (sincronización, una ida y vuelta a través del núcleo del sistema operativo y el planificador ...). Además, no hay mucho margen de pérdidas de memoria (el co-rutina debe ser explícitamente "detuvo", de lo contrario el hilo de espera se pegará siempre). Por lo tanto, esto rara vez se hace.

C # proporciona una función de co-rutina bastardized abajo llamado iteradores . El compilador de C # convierte automáticamente el código de iterador en una clase de estado específico, con variables locales se conviertan en campos de clase. Ceder es entonces, a nivel de máquina virtual, un return llanura. Tal cosa es factible siempre que el "rendimiento" se lleva a cabo a partir del código iterador sí mismo, no a partir de un método que los invoca código iterador. C # iteradores ya cubren muchos casos de uso y los diseñadores de C # no estaban dispuestos a ir más lejos en el camino a continuaciones . Algunas personas sarcásticas están deseosos de estado que la implementación de las continuaciones con todas las funciones habría impedido C # de ser tan eficiente como su archienemigo Java (continuaciones eficientes son factibles, pero esto requiere un poco de trabajo con la GC y el compilador JIT).

Gracias @NickLarsen, que me ayudó a recordar las cosas nuevas que la EM se han introducido, la interfaz IObservable.

http://msdn.microsoft.com /en-us/library/dd783449(VS.100).aspx

En realidad .NET no hacer "suposiciones incorrectas" sobre la afinidad de rosca, de hecho se desacopla totalmente la noción de un hilo nivel de .NET desde el hilo de nivel de sistema operativo.

Lo que tienes que hacer es asociar un estado de rosca .NET lógico con su fibra (para eso se necesita el CLR Hosting API, pero no es necesario escribir un anfitrión sí mismo que puede utilizar los necesarios desde su propia aplicación directa) y todo, el seguimiento de la cerradura, manejo de excepciones funciona con normalidad.

Un ejemplo se puede encontrar aquí: http://msdn.microsoft. com / es-es / revista / cc164086.aspx

BTW Mono 2.6 contiene soporte Coroutine bajo nivel y se puede utilizar para poner en práctica todas las primitivas de nivel más alto fácilmente.

Me gustaría ver una API basada en fibra para .Net.

Me trató de utilizar la API de fibra nativa en C # a través p / invoke hace un tiempo, pero debido a la gestión de excepciones de tiempo de ejecución (incorrectamente) hace suposiciones basadas en rosca, las cosas se rompieron (mal) cuando excepciones ocurrieron.

Una "aplicación" de una API corrutina basado en fibra es la programación de juegos; ciertos tipos de AI requieren un hilo "ligera" que puede fracción de tiempo a voluntad. Por ejemplo, los árboles de comportamiento de juego requieren la capacidad de decisión del código "pulso" cada cuadro, permitiendo que el código de IA para volver rendimiento en cooperación para la persona que llama cuando la rebanada decisión le corresponde. Esto es posible implementar con hilos duros, pero mucho, mucho más complicado.

Así, mientras que la verdadera fibra de casos de uso no son la corriente principal, que sin duda existen, y un pequeño nicho de codificadores nos .Net animarían poderosamente si los errores existentes en el subsistema de fibra fueron elaborados.

Bueno, me dio una oportunidad el desarrollo de una biblioteca completa para gestionar corrutinas con un solo hilo. La parte más difícil fue llamar corrutinas dentro corrutinas ... y volver parámetros, pero finalmente llegó a un resultado bastante bueno aquí . La única advertencia que el bloqueo se operaciones I / O debe hacerse a través de tareas y felizmente "retorno" debe ser sustituido por "retorno de rendimiento". Con el servidor de aplicaciones basado en esta biblioteca que era capaz de casi el doble de las solicitudes realizadas con un estándar asíncrono / aguarde basado en IIS. (Seek para Node.Cs y Node.Cs.Musicstore en github probarlo en casa)

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top