c# - 我对 session 状态序列化有疑问

Question

我用这段代码序列化了一个对象

public void play(string url, string i)
    {
      MP3StreamingPanel mp3=new MP3StreamingPanel ( );
      mp3.play ( url );
      HttpContext . Current . Session [ i ] = mp3;

然后当我想获取它时，mp3 属性中的某些值仍然为“null”

  MP3StreamingPanel mp3=new MP3StreamingPanel ( );
  mp3 = HttpContext . Current . Session [ i ] as MP3StreamingPanel;

这是 MP3StreamingPanel 类

    [Serializable]
    public class MP3StreamingPanel 
        {

        enum StreamingPlaybackState
            {
            Stopped ,
            Playing ,
            Buffering ,
            Paused
            }




[NonSerialized]
public HttpWebRequest webRequest;
[NonSerialized]
public System.Timers.Timer timer1 = new System . Timers . Timer ( );
public SerializableVolumeWaveProvider16 volumeProvider;
delegate void ShowErrorDelegate ( string message );
public string gurl="";
public SerializableBufferedWaveProvider bufferedWaveProvider;
public SerializableWaveOut waveOut;
private  volatile StreamingPlaybackState playbackState;
public volatile bool fullyDownloaded;

public MP3StreamingPanel ( )
    {
    }

public void InitTimer ( )
    {
    timer1 . Elapsed += new ElapsedEventHandler ( timer1_Tick );
    timer1 . Interval = 250; // in miliseconds
    timer1 . Start ( );
    }
public void timer1_Tick ( object sender , ElapsedEventArgs e )
    {
    if ( playbackState != StreamingPlaybackState . Stopped )
        {
        if ( this . waveOut == null && this . bufferedWaveProvider != null )
            {
            Debug . WriteLine ( "Creating WaveOut Device" );
            this . waveOut = CreateWaveOut ( );
            waveOut . PlaybackStopped += waveOut_PlaybackStopped;
            this . volumeProvider = new SerializableVolumeWaveProvider16 ( `enter code here`bufferedWaveProvider );
            waveOut . Init ( volumeProvider );

            }
        else if ( bufferedWaveProvider != null )
            {
            var bufferedSeconds = bufferedWaveProvider . BufferedDuration . TotalSeconds;

            if ( bufferedSeconds < 0.5 && this . playbackState == StreamingPlaybackState . Playing && !this . fullyDownloaded )
                {
                this . playbackState = StreamingPlaybackState . Buffering;
                waveOut . Pause ( );
                Debug . WriteLine ( String . Format ( "Paused to buffer, waveOut.PlaybackState={0}" , waveOut . PlaybackState ) );
                }
            else if ( bufferedSeconds > 4 && this . playbackState == StreamingPlaybackState . Buffering )
                {
                waveOut . Play ( );
                Debug . WriteLine ( String . Format ( "Started playing, waveOut.PlaybackState={0}" , waveOut . PlaybackState ) );
                this . playbackState = StreamingPlaybackState . Playing;
                }
            else if ( this . fullyDownloaded && bufferedSeconds == 0 )
                {
                Debug . WriteLine ( "Reached end of stream" );
                stop ( );
                }
            }

        }
    }


public void StreamMP3 ( object state )
    {
    this . fullyDownloaded = false;
    string url = ( string ) state;
    webRequest = ( HttpWebRequest ) WebRequest . Create ( url );
    HttpWebResponse resp = null;
    try
        {
        resp = ( HttpWebResponse ) webRequest . GetResponse ( );
        }
    catch ( WebException e )
        {
        if ( e . Status != WebExceptionStatus . RequestCanceled )
            {
            Console.WriteLine ( e . Message );
            }
        return;
        }
    byte[] buffer = new byte [ 16384 * 4 ]; 

    IMp3FrameDecompressor decompressor = null;
    try
        {
        using ( var responseStream = resp . GetResponseStream ( ) )
            {
            var readFullyStream = new ReadFullyStream ( responseStream );
            do
                {
                if ( bufferedWaveProvider != null && bufferedWaveProvider . BufferLength - bufferedWaveProvider . BufferedBytes < bufferedWaveProvider . WaveFormat . AverageBytesPerSecond / 4 )
                    {
                    Debug . WriteLine ( "Buffer getting full, taking a break" );
                    Thread . Sleep ( 500 );
                    }
                else
                    {
                    Mp3Frame frame = null;
                    try
                        {
                        frame = Mp3Frame . LoadFromStream ( readFullyStream );
                        }
                    catch ( EndOfStreamException )
                        {
                        this . fullyDownloaded = true;

                        break;
                        }
                    catch ( WebException )
                        {

                        break;
                        }
                    if ( decompressor == null )
                        {
                        WaveFormat waveFormat = new Mp3WaveFormat ( frame . SampleRate , frame . ChannelMode == ChannelMode . Mono ? 1 : 2 , frame . FrameLength , frame . BitRate );
                        decompressor = new AcmMp3FrameDecompressor ( waveFormat );
                        this . bufferedWaveProvider = new SerializableBufferedWaveProvider ( decompressor . OutputFormat );
                        this . bufferedWaveProvider . BufferDuration = TimeSpan . FromSeconds ( 20 ); // allow us to get well ahead of ourselves
                        }
                    int decompressed = decompressor . DecompressFrame ( frame , buffer , 0 );
                     bufferedWaveProvider . AddSamples ( buffer , 0 , decompressed );
                    }

                } while ( playbackState != StreamingPlaybackState . Stopped );
            Debug . WriteLine ( "Exiting" );
            decompressor . Dispose ( );
            }
        }
    finally
        {
        if ( decompressor != null )
            {
            decompressor . Dispose ( );
            }
        }
    }

public void play ( string url )
    {
    if ( playbackState == StreamingPlaybackState . Stopped )
        {
            playbackState = StreamingPlaybackState . Buffering;
            this . bufferedWaveProvider = null;
            ThreadPool . QueueUserWorkItem ( new WaitCallback ( StreamMP3 ) , url );
            gurl = url;
            InitTimer ( );
            timer1 . Enabled = true;
        }
    else if ( playbackState == StreamingPlaybackState . Paused )
        {
             playbackState = StreamingPlaybackState . Buffering;
        }
    }

public void stop ( )
    {

    if ( playbackState != StreamingPlaybackState . Stopped )
        {
        if ( !fullyDownloaded )
            {
            webRequest . Abort ( );
            }
        this . playbackState = StreamingPlaybackState . Stopped;
        if ( waveOut != null )
            {
            waveOut . Stop ( );
            waveOut . Dispose ( );
            waveOut = null;
            }
        timer1 . Enabled = false;
        // n.b. streaming thread may not yet have exited
        Thread . Sleep ( 500 );
         }
    }



public SerializableWaveOut CreateWaveOut ( )
    {
    return new SerializableWaveOut ( );

    }


public void pause ( )
    {
    if ( playbackState == StreamingPlaybackState . Playing || playbackState == StreamingPlaybackState . Buffering )
        {
        waveOut . Pause ( );
        Debug . WriteLine ( String . Format ( "User requested Pause, waveOut.PlaybackState={0}" , waveOut . PlaybackState ) );
        playbackState = StreamingPlaybackState . Paused;
        }
    }

public void buttonStop_Click ( object sender , EventArgs e )
    {
    stop ( );
    }

private void waveOut_PlaybackStopped ( object sender , StoppedEventArgs e )
    {
    Debug . WriteLine ( "Playback Stopped" );
    if ( e . Exception != null )
        {
        MessageBox . Show ( String . Format ( "Playback Error {0}" , e . Exception . Message ) );
        }
    }
}

对于 SerializableVolumeWaveProvider16 ，SerializableBufferedWaveProvider 和 SerializableWaveOut 是我声明为 [Serializable] 的类但我无法在序列化后获得这些值

Answer 1

不要在 session /缓存中存储复杂的对象

您在此处存储在 session 中的对象很复杂，并且有许多移动部分。人们在使用缓存和 session 时犯的主要错误是存储“事件”对象(见鬼，它有计时器、网络请求等)。您应该只存储(在 session 、缓存或文件系统等中)冷硬非事件数据。我强烈建议您创建一个仅包含数据 的单独 DTO 层；例如:

public class Something {
    public string Name {get;set;}
    public int SomeNumber {get;set;}
    public byte[] Blob {get;set;}
    // ... more simple data values
}

理想情况下，您会填充存储/检索这种形式的东西；简单、易于理解等。然后根据需要映射到此 DTO 模型和您的实际模型。

实际上，一个更好的主意是使 DTO 不可变；如果您的提供者实际上没有序列化，而是将内容保存在内存中，这将避免并发症。因为否则以下是模棱两可的:

var obj = session[key] as Something;
if(obj != null) {
    obj.Name = "new name";
}

使用序列化提供程序，通常不会反射(reflect)该更改，除非最后再次明确存储；使用 内存中 提供程序，所有其他调用者将立即看到它(请记住，用户可以有多个并发请求)。

如果您在使用 session /缓存等时转向基于 DTO 的模型，您将被迫编写可理解且明显正确的代码。而不是“有时工作的原因没人能猜到”。