How to control caching headers? about embedio HOT 3 CLOSED

WebServer.Module<StaticFilesModule>().DefaultHeaders.Add(Constants.HeaderPragma, HeaderPragmaValue);

class StaticWebServer : IDisposable
{
    // TODO: Find a random port between a certain range.
    const string DefaultUrl = "http://127.0.0.1:9696/";

    public StaticWebServer()
    {
        _server = CreateServer();
    }

    WebServer _server;

    WebServer CreateServer()
    {
        var logger = new DebugLogger();
        var server = new WebServer(DefaultUrl, logger);

        var cwd = System.IO.Directory.GetCurrentDirectory();
        var browsePath = System.IO.Path.Combine(cwd, "browse");
        Debug.Print("Serving static files from: {0}", browsePath);

        var headers = new Dictionary<string, string>()
        {
            { Constants.HeaderCacheControl, "no-cache, no-store, must-revalidate" },
            { Constants.HeaderPragma, "no-cache" },
            { Constants.HeaderExpires, "0" }
        };

        var staticFileMod = new StaticFilesModule(browsePath, headers);
        staticFileMod.DefaultExtension = ".html";
        server.RegisterModule(staticFileMod);

        return server;
    }

    public void RunAsync()
    {
        _server.RunAsync();
    }

    public void Dispose()
    {
        Dispose(true);
    }

    void Dispose(bool disposing)
    {
        if (!disposing)
            return;

        var server = _server;
        _server = null;

        if (server == null)
            return;
        server.Dispose();
    }

    #region DebugLogger

    /// <summary>
    /// Provides a simple logger for Debug output.
    /// </summary>
    class DebugLogger : ILog
    {
        /// <summary>
        /// Writes the given line. This method is used by all other methods and it is asynchronous.
        /// </summary>
        /// <param name="color">The color.</param>
        /// <param name="format">The format.</param>
        /// <param name="args">The arguments.</param>
        private static void WriteLine(ConsoleColor color, string format, params object[] args)
        {
            var d = DateTime.Now;
            var dateTimeString = string.Format("{0}-{1}-{2} {3}:{4}:{5}.{6}",
                d.Year.ToString("0000"), d.Month.ToString("00"), d.Day.ToString("00"), d.Hour.ToString("00"),
                d.Minute.ToString("00"), d.Second.ToString("00"), d.Millisecond.ToString("000"));

            format = dateTimeString + "\t" + format;

            //ThreadPool.QueueUserWorkItem((context) =>
            //{
            //    var current = Console.ForegroundColor;
            //    Console.ForegroundColor = color;
            //    Console.WriteLine(format, args);
            //    Console.ForegroundColor = current;
            //});
            if (args != null)
                Debug.Print(format, args);
            else
                Debug.Print(format);
        }

        /// <summary>
        /// Writes an Info level message
        /// </summary>
        /// <param name="message"></param>
        public virtual void Info(object message)
        {
            InfoFormat(message.ToString(), null);
        }

        /// <summary>
        /// Writes an Error level message
        /// </summary>
        /// <param name="message"></param>
        public virtual void Error(object message)
        {
            ErrorFormat(message.ToString(), null);
        }

        /// <summary>
        /// Writes an Error message with Exception
        /// </summary>
        /// <param name="message"></param>
        /// <param name="exception"></param>
        public virtual void Error(object message, Exception exception)
        {
            ErrorFormat(message.ToString(), null);
            ErrorFormat(exception.ToString(), null);
        }

        /// <summary>
        /// Writes an Info level message with format
        /// </summary>
        /// <param name="format"></param>
        /// <param name="args"></param>
        public virtual void InfoFormat(string format, params object[] args)
        {
            WriteLine(ConsoleColor.Gray, format, args);
        }

        /// <summary>
        /// Writes a Warning level message with format
        /// </summary>
        /// <param name="format"></param>
        /// <param name="args"></param>
        public virtual void WarnFormat(string format, params object[] args)
        {
            WriteLine(ConsoleColor.DarkYellow, format, args);
        }

        /// <summary>
        /// Writes an Error level message with format
        /// </summary>
        /// <param name="format"></param>
        /// <param name="args"></param>
        public virtual void ErrorFormat(string format, params object[] args)
        {
            WriteLine(ConsoleColor.Red, format, args);
        }

        /// <summary>
        /// Writes an Debug level message with format
        /// </summary>
        /// <param name="format"></param>
        /// <param name="args"></param>
        public virtual void DebugFormat(string format, params object[] args)
        {
            WriteLine(ConsoleColor.Green, format, args);
        }
    }

    #endregion
}

[STAThread]
static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);

    using (var webServer = new StaticWebServer())
    {
        webServer.RunAsync();
        Application.Run(new Views.MainView());
    }
}