IniHelper.cs

IniHelper.cs

 

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.IO;
using System.Web;

public  class IniHelper {
     private  static Dictionary< string,  object> _cache =  new Dictionary< string,  object>();
     private  static Dictionary< string, FileSystemWatcher> _watcher =  new Dictionary< string, FileSystemWatcher>();
     private  static  object _lock =  new  object();

     private  static  object loadAndCache( string path) {
        path = TranslateUrl(path);
         object ret =  null;
         if (!_cache.TryGetValue(path,  out ret)) {
             object value2 = LoadIniNotCache(path);
             string dir = Path.GetDirectoryName(path);
             string name = Path.GetFileName(path);
            FileSystemWatcher fsw =  new FileSystemWatcher(dir, name);
            fsw.IncludeSubdirectories =  false;
            fsw.Changed += watcher_handler;
            fsw.Renamed += watcher_handler;
            fsw.EnableRaisingEvents =  false;
             lock (_lock) {
                 if (!_cache.TryGetValue(path,  out ret)) {
                    _cache.Add(path, ret = value2);
                    _watcher.Add(path, fsw);
                    fsw.EnableRaisingEvents =  true;
                }  else {
                    fsw.Dispose();
                }
            }
        }
         return ret;
    }
     private  static  void watcher_handler( object sender, FileSystemEventArgs e) {
         lock (_lock) {
            _cache.Remove(e.FullPath);
            FileSystemWatcher fsw =  null;
             if (_watcher.TryGetValue(e.FullPath,  out fsw)) {
                fsw.EnableRaisingEvents =  false;
                fsw.Dispose();
            }
        }
    }

     public  static Dictionary< string, NameValueCollection> LoadIni( string path) {
         return loadAndCache(path)  as Dictionary< string, NameValueCollection>;
    }
     public  static Dictionary< string, NameValueCollection> LoadIniNotCache( string path) {
        Dictionary< string, NameValueCollection> ret =  new Dictionary< string, NameValueCollection>();
         string[] lines = ReadTextFile(path).Split( new  string[] {  " \n " }, StringSplitOptions.None);
         string key =  "";
         foreach ( string line2  in lines) {
             string line = line2.Trim();
             int idx = line.IndexOf( ' # ');
             if (idx != - 1) line = line.Remove(idx);
             if ( string.IsNullOrEmpty(line))  continue;

            Match m = Regex.Match(line,  @" ^\[([^\]]+)\]$ ");
             if (m.Success) {
                key = m.Groups[ 1].Value;
                 continue;
            }
             if (!ret.ContainsKey(key)) ret.Add(key,  new NameValueCollection());
             string[] kv = line.Split( new  char[] {  ' = ' },  2);
             if (! string.IsNullOrEmpty(kv[ 0])) {
                ret[key][kv[ 0]] = kv.Length >  1 ? kv[ 1] :  null;
            }
        }
         return ret;
    }

     public  static  string ReadTextFile( string path) {
         byte[] bytes = ReadFile(path);
         return Encoding.UTF8.GetString(bytes).TrimStart(( char) 65279);
    }
     public  static  byte[] ReadFile( string path) {
        path = TranslateUrl(path);

         if (File.Exists(path)) {
             // string destFileName = Path.GetTempFileName();
             // File.Copy(path, destFileName, true);
             string destFileName = path;
             int read =  0;
             byte[] data =  new  byte[ 1024 *  8];
            MemoryStream ms =  new MemoryStream();
             using (FileStream fs =  new FileStream(destFileName, FileMode.OpenOrCreate, FileAccess.Read)) {
                 do {
                    read = fs.Read(data,  0, data.Length);
                     if (read <=  0)  break;
                    ms.Write(data,  0, read);
                }  while ( true);
                fs.Close();
            }
             // File.Delete(destFileName);
            data = ms.ToArray();
            ms.Close();
             return data;
        }
         return  new  byte[] { };
    }

     public  static  string TranslateUrl( string url) {
         return TranslateUrl(url,  null);
    }
     private  static  object _ecd_lock =  new  object();
     public  static  string TranslateUrl( string url,  string baseDir) {
         if ( string.IsNullOrEmpty(url)) url =  "";

         if (! string.IsNullOrEmpty(baseDir) && !url.StartsWith( " ~/ ") && !url.StartsWith( " / ")) {
            baseDir = Path.GetDirectoryName(baseDir);
             if (HttpContext.Current !=  null)
                url = Path.GetFullPath(baseDir +  " \\ " + url);
             else {
                 lock (_ecd_lock) {
                     string ecd = Environment.CurrentDirectory;
                    Environment.CurrentDirectory = baseDir;
                    url = Path.GetFullPath(url);
                    Environment.CurrentDirectory = ecd;
                }
            }
        }  else {
             if (url.IndexOf( " :\\ ") == - 1) {
                 if (System.Web.HttpContext.Current !=  null)
                    url = System.Web.HttpContext.Current.Server.MapPath(url);
                 else
                    url = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory +  " \\ " + url.Trim( ' \\ ',  ' ~ '));
            }
        }
         return url;
    }
}