Jaki jest najlepszy sposób przekazania strumienia wokół numeru

Question

Próbowałem przekazać strumień jako argument, ale nie jestem pewien, która droga jest "najlepsza", dlatego chciałbym usłyszeć Twoją opinię/sugestie na temat mojej próbki kodu

Ja osobiście wolę opcje trzy, ale nowsze widziałem, jak to robiono w ten sposób gdziekolwiek indziej.

Wariant 1 jest dobre dla małych strumieni (i strumieni o znanej wielkości)

Option 2_1 i 2_2 zawsze opuścić „zakręt” wątpliwości, kto jest odpowiedzialny za zbywanie/zamykania.

public interface ISomeStreamHandler 
{ 
    // Option 1 
    void HandleStream(byte[] streamBytes); 

    // Option 2 
    void HandleStream(Stream stream); 

    // Option 3 
    void HandleStream(Func<Stream> openStream); 
} 


public interface IStreamProducer 
{ 
    Stream GetStream(); 
} 



public class SomeTestClass 
{ 
    private readonly ISomeStreamHandler _streamHandler; 
    private readonly IStreamProducer _streamProducer; 

    public SomeTestClass(ISomeStreamHandler streamHandler, IStreamProducer streamProducer) 
    { 
     _streamHandler = streamHandler; 
     _streamProducer = streamProducer; 
    } 

    public void DoOption1() 
    { 
     var buffer = new byte[16 * 1024]; 
     using (var input = _streamProducer.GetStream()) 
     { 
      using (var ms = new MemoryStream()) 
      { 
       int read; 
       while ((read = input.Read(buffer, 0, buffer.Length)) > 0) 
       { 
        ms.Write(buffer, 0, read); 
       } 
       _streamHandler.HandleStream(ms.ToArray()); 
      } 
     } 
    } 

    public void DoOption2_1() 
    { 
     _streamHandler.HandleStream(_streamProducer.GetStream()); 
    } 

    public void DoOption2_2() 
    { 
     using (var stream = _streamProducer.GetStream()) 
     { 
      _streamHandler.HandleStream(stream);  
     } 
    } 


    public void DoOption3() 
    { 
     _streamHandler.HandleStream(_streamProducer.GetStream); 
    } 
} 

Answer 1

Opcja 2_2 to standardowy sposób postępowania z zasobami rozporządzalnymi.

instancję SomeTestClass pyta producent dla strumienia - wtedy SomeTestClassposiada strumień i jest odpowiedzialny za sprzątanie.

Opcje 3 i 2_1 polegają na innym obiekcie w celu oczyszczenia zasobu należącego do SomeTestClass - to oczekiwanie może nie zostać spełnione.

Opcja 1 to kopiowanie treści strumienia do innego strumienia - nie widzę w tym żadnych korzyści.

Answer 2

przechodzące w IStream i mają w których historii strumień pochodzi realizacji IDisposable. Odpowiedzialność za pozbycie się strumienia spoczywa na obiekcie, który go utworzył.

Answer 3

Może nie zdajesz sobie z tego sprawy, ale próbujesz wdrożyć wzór projektowania rurociągu . Jako punkt wyjścia, należy rozważyć przyjrzeniu:

• MSDN: Pipelines
• Steve's Blog: Pipeline Design Pattern
• (inne dobre referencje ??)

W odniesieniu do implementacji, polecam, aby iść z opcja nr 2:

public interface IStreamHandler 
{ 
    void Process(Stream stream); 
} 

W odniesieniu do sprzeciwu całe życie, to jest moje przekonanie, że:

• realizacji powinien być spójny pod względem obsługi wywoływania, dlatego twoje rozwiązanie będzie bardziej elastyczne, jeśli IStreamHandler nie zadzwoni pod numer Dispose (n OW można koparki łańcuchowe razem podobnie jak byś w rurach Unix)

TRZECICH ROZWIĄZANIA

Budowanie rozwiązania rurociągu może być zabawne, ale warto również zauważyć, że istnieją istniejące produkty na Rynek:

• Yahoo: Pipes
• Microsoft: BizTalk
• IBM: Cast Iron
• StackOverflow: Alternatives to Yahoo Pipes

DODATKOWA

Jest to kwestia projektowania związane z proponowanego Opcja 2:

void Process(Stream stream); 

W Unix Pipes możesz łańcuch szereg zastosowań razem przez pobranie wyjścia jednego programu i wprowadzenie go jako wejścia innego. Jeśli chcesz zbudować podobne rozwiązanie przy użyciu opcji Opcja 2, będą występowały problemy, jeśli używasz wielu procedur obsługi, a dane będą tylko Stream (tj. stream.CanSeek=False).