public static Excel LoadExcel(string path)
 {
     FileInfo file = new FileInfo(path);
     ExcelPackage ep = new ExcelPackage(file);
     Excel xls = new Excel(ep.Workbook);
     return xls;
 }

    // Ex: C:\Users\Public\Test\blah.txt would return C:\Users\Public\Test\
    public static string GetDirectoryPath(string filePath)
    {
        if(string.IsNullOrEmpty(filePath)) return "";

        FileInfo fileInfo = new FileInfo(filePath);
        return (fileInfo != null) ? fileInfo.Directory.FullName : "";
    }

 public void FalseForDirectory()
 {
     string fileName = GetTestFilePath();
     Directory.CreateDirectory(fileName);
     FileInfo di = new FileInfo(fileName);
     Assert.False(di.Exists);
 }

	static void CopyFile(string filename, string outputfilename, string pathToBuiltProject) {
		string strCWD = Directory.GetCurrentDirectory();
		string strSource = Path.Combine(Path.Combine(strCWD, SteamAPIRelativeLoc), filename);
		string strFileDest = Path.Combine(Path.GetDirectoryName(pathToBuiltProject), outputfilename);

		if (!File.Exists(strSource)) {
			Debug.LogWarning(string.Format("[Steamworks.NET] Could not copy {0} into the project root. {0} could not be found in '{1}'. Place {0} from the redist into the project root manually.", filename, SteamAPIRelativeLoc));
			return;
		}

		if (File.Exists(strFileDest)) {
			if (File.GetLastWriteTime(strSource) == File.GetLastWriteTime(strFileDest)) {
				FileInfo fInfo = new FileInfo(strSource);
				FileInfo fInfo2 = new FileInfo(strFileDest);
				if (fInfo.Length == fInfo2.Length) {
					return;
				}
			}
		}

		File.Copy(strSource, strFileDest, true);

		if (!File.Exists(strFileDest)) {
			Debug.LogWarning(string.Format("[Steamworks.NET] Could not copy {0} into the built project. File.Copy() Failed. Place {0} from the redist folder into the output dir manually.", filename));
		}
	}

		public static Package Parse(FileInfo assemblyInfoFile)
		{
			try
			{
				var lines = Storage.ReadAllLines(assemblyInfoFile.FullName);

				var title = AssemblyInfo.GetData(lines, AssemblyInfoData.AssemblyTitle);

				var projectFile = assemblyInfoFile.Directory.Parent.GetFiles(title + "*.csproj").SingleOrDefault();

				if (projectFile == null)
				{
					return null;
				}

				var targetFramework = ExtractTargetFramework(projectFile);

				var version = AssemblyInfo.GetData(lines, AssemblyInfoData.AssemblyVersion);

				var nuspec = projectFile.Directory.GetFiles("Package.nuspec").SingleOrDefault();

				if (nuspec == null)
				{
					return new Package(projectFile, assemblyInfoFile, lines, title, version, targetFramework);
				}

				return new Package(projectFile, assemblyInfoFile, lines, title, version, targetFramework, nuspec);
			}
			catch (Exception exception)
			{
				throw new IOException($"Cannot parse the file {assemblyInfoFile.FullName}.", exception);
			}
		}

    // ------------------------------------------------------------------
    // Desc:
    // ------------------------------------------------------------------
    public static exTimebasedCurveInfo Create( string _path, string _name )
    {
        //
        if ( new DirectoryInfo(_path).Exists == false ) {
            Debug.LogError ( "can't create asset, path not found" );
            return null;
        }
        if ( string.IsNullOrEmpty(_name) ) {
            Debug.LogError ( "can't create asset, the name is empty" );
            return null;
        }
        string assetPath = Path.Combine( _path, _name + ".asset" );

        // check if create the asset
        FileInfo fileInfo = new FileInfo(assetPath);
        if ( fileInfo.Exists ) {
            if ( EditorUtility.DisplayDialog( _name + " already exists.",
                                              "Do you want to overwrite the old one?",
                                              "Yes",
                                              "No" ) == false )
            {
                return null;
            }
        }

        //
        exTimebasedCurveInfo newCurve = ScriptableObject.CreateInstance<exTimebasedCurveInfo>();
        AssetDatabase.CreateAsset(newCurve, assetPath);
        Selection.activeObject = newCurve;

        return newCurve;
    }

    void Start()
    {
        triviaFile = new FileInfo(Application.dataPath + "/trivia.txt");

        if (triviaFile != null && triviaFile.Exists) {
            reader = triviaFile.OpenText();
        } else {
            embedded = (TextAsset) Resources.Load("trivia_embedded", typeof (TextAsset));
            reader = new StringReader(embedded.text);
        }

        string lineOfText = "";
        int lineNumber = 0;

        while ( ( lineOfText = reader.ReadLine() ) != null ) {

            string question = lineOfText;
            int answerCount = Convert.ToInt32(reader.ReadLine());
            List<string> answers = new List<string>();
            for (int i = 0; i < answerCount; i++) {
                answers.Add(reader.ReadLine());
            }

            Trivia temp = new Trivia(question, answerCount, answers);

            triviaQuestions.Add(temp);
            lineNumber++;
        }

        SendMessage( "BeginGame" );
    }

    protected static bool IsFileLocked(string fullPath)
    {
        FileInfo file = new FileInfo(fullPath);

        FileStream stream = null;

        try
        {
            stream = file.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None);
        }
        catch (IOException)
        {
            //the file is unavailable because it is:
            //still being written to
            //or being processed by another thread
            //or does not exist (has already been processed)
            return true;
        }
        finally
        {
            if (stream != null)
                stream.Close();
        }

        //file is not locked
        return false;
    }

    static void Slice(string sourceFile, string destinationDirectory, int parts)
    {
        string extension = new FileInfo(sourceFile).Extension;
        ext = extension;

        using (var source = new FileStream(destinationDirectory + sourceFile, FileMode.Open))
        {
            int pieceSize = (int)Math.Ceiling((decimal)source.Length / parts);
            byte[] buffer = new byte[4096];

            for (int i = 1; i <= parts; i++)
            {

                string currentFilePath = string.Format(destinationDirectory + "part" + i + extension);
                using (var destination =
                    new FileStream(currentFilePath, FileMode.Create))
                {

                    long partBytes = 0;
                    while (partBytes < pieceSize)
                    {
                        int readBytes = source.Read(buffer, 0, buffer.Length);
                        if (readBytes == 0)
                        {
                            break;;
                        }
                        destination.Write(buffer, 0, readBytes);
                        partBytes += readBytes;
                    }
                }
                slicedFiles.Add(currentFilePath);
            }
        }
    }

    /// <summary>
    /// プロセスを実行
    /// </summary>
    public void StartProcess(ProcessData procData)
    {
        if(procData.use && !procData.IsRunning)
        {
            FileInfo fileInfo = new FileInfo(procData.exePath);
            if(fileInfo.Exists)
            {
                Process proc = new Process();
                proc.StartInfo.FileName = Path.GetFullPath(procData.exePath);

                //引数設定
                if(procData.argument != "")
                    proc.StartInfo.Arguments = procData.argument;

                //ウィンドウスタイル設定
                if(!ApplicationSetting.Instance.GetBool("IsDebug"))
                    proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;

                try
                {
                    proc.Start();

                    processList.Add(proc);
                    procData.IsRunning = true;
                }
                catch(Exception e)
                {
                    UnityEngine.Debug.Log("ExternalProcess :: process start error - " + e.Message);
                }
            }
        }
    }

    public void WithNoWeaving()
    {
        var sourceProjectFile = new FileInfo(@"TestProjects\ProjectWithNoWeaving.csproj");
        var targetFileInfo = sourceProjectFile.CopyTo(sourceProjectFile.FullName + "ProjectReaderTest", true);
        try
        {

            var reader = new ProjectReader(targetFileInfo.FullName);

            Assert.IsNull(reader.DependenciesDirectory);
            Assert.IsNull(reader.ToolsDirectory);
            Assert.IsNull(reader.CheckForEquality);
            Assert.IsNull(reader.CheckForIsChanged);
            Assert.IsNull(reader.ProcessFields);
            Assert.IsNull(reader.MessageImportance);
            Assert.IsNull(reader.TryToWeaveAllTypes);
            Assert.IsNull(reader.EventInvokerName);
            Assert.IsNull(reader.EventInvokerName);
            Assert.IsNull(reader.TargetPath);
            Assert.IsNull(reader.TargetNode);
            Assert.IsNull(reader.DependenciesDirectory);
        }
        finally
        {
            targetFileInfo.Delete();
        }
    }

    // Use this for initialization
    void Start()
    {
        FileStream file = null;
        FileInfo fileInfo = null;

        try
        {
            fileInfo = new FileInfo("file.txt");
            file = fileInfo.OpenWrite();

            for(int i = 0; i < 255; i++)
            {
                file.WriteByte((byte)i);
            }

            throw new ArgumentNullException("Something bad happened.");
        }
        catch(UnauthorizedAccessException e)
        {
            Debug.LogWarning(e.Message);
        }

        catch (ArgumentNullException e)
        {
            //Debug.LogWarning(e.Message);
            Debug.LogWarning("BAD!!!");
        }
        finally
        {
            if (file != null)
                file.Close();
        }
    }

    /// <summary>
    /// Evaluates and provides the relative path.
    /// </summary>
    /// <param name="mainDirPath">The source, or starting location.</param>
    /// <param name="absoluteFilePath">The location to find.</param>
    /// <returns></returns>
    public static string EvaluateRelativePath(this FileInfo mainDirPath, FileInfo absoluteFilePath)
    {
        string[] firstPathParts = mainDirPath.FullName.Trim(Path.DirectorySeparatorChar).Split(Path.DirectorySeparatorChar);
        string[] secondPathParts = absoluteFilePath.FullName.Trim(Path.DirectorySeparatorChar).Split(Path.DirectorySeparatorChar);

        int sameCounter = 0;
        for (int i = 0; i < Math.Min(firstPathParts.Length, secondPathParts.Length); i++)
        {
          if (!firstPathParts[i].ToLower().Equals(secondPathParts[i].ToLower()))
        break;

          sameCounter++;
        }

        if (sameCounter == 0)
          return absoluteFilePath.FullName;

        string newPath = String.Empty;
        for (int i = sameCounter; i < firstPathParts.Length; i++)
        {
          if (i > sameCounter)
        newPath += Path.DirectorySeparatorChar;

          newPath += "..";
        }

        for (int i = sameCounter; i < secondPathParts.Length; i++)
        {
          newPath = String.Format("{0}{1}{2}", newPath, Path.DirectorySeparatorChar, secondPathParts[i]);
        }

        return newPath;
    }

	public void FindLargeFiles(List<string> AllowedExtensions, long MinSize)
	{
		foreach (string Filename in Manifest)
		{
			FileInfo FI = new FileInfo(Filename);
			long Size = FI.Length;

			if (Size > MinSize)
			{
				bool bAllowed = false;
				foreach (string Extension in AllowedExtensions)
				{
					if (Filename.EndsWith(Extension, StringComparison.InvariantCultureIgnoreCase))
					{
						bAllowed = true;
						break;
					}
				}

				if (!bAllowed)
				{
					CommandUtils.LogWarning("{0} is {1} with an unexpected extension", Filename, AnalyzeThirdPartyLibs.ToMegabytes(Size));
				}
			}
		}
	}

        public object Start(string level)
        {
            LocalNode node = new LocalNode(Assembly.GetExecutingAssembly());
            node.Join();

            try
            {
                FileInfo levelInfo = new FileInfo(level);
                if (levelInfo.Directory.Name != "Resources")
                    return "Level is not in a resources directory.";

                DirectoryInfo directoryInfo = levelInfo.Directory.Parent;
                World.BaseDirectory = directoryInfo.FullName;
                World.RuntimeDirectory = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName;

                using (RuntimeGame game = new RuntimeGame(levelInfo.Name.Substring(0, levelInfo.Name.Length - levelInfo.Extension.Length)))
                {
                    game.Run();
                }
            }
            finally
            {
                node.Leave();
            }

            return null;
        }

 public void SelectTextFile(string file)
 {
     if (file == "FirstScene") {
         fileName = file;
         theSourceFile = new FileInfo ("Assets/Scripts/Dialogue/FirstScene.txt");
         reader = theSourceFile.OpenText ();
         startText = true;
     } else if (file == "Level1End") {
         fileName = file;
         theSourceFile = new FileInfo ("Assets/Scripts/Dialogue/Level1End.txt");
         reader = theSourceFile.OpenText ();
         startText = true;
     } else if (file == "GoodEnding") {
         fileName = file;
         theSourceFile = new FileInfo ("Assets/Scripts/Dialogue/FinalDialogues/GoodEnding.txt");
         reader = theSourceFile.OpenText ();
         startText = true;
     } else if (file == "BadEnding") {
         fileName = file;
         theSourceFile = new FileInfo ("Assets/Scripts/Dialogue/FinalDialogues/BadEnding.txt");
         reader = theSourceFile.OpenText ();
         startText = true;
     } else {
         theSourceFile = null;
     }
 }

 /// <summary>
 ///     A string extension method that save the string into a file.
 /// </summary>
 /// <param name="this">The @this to act on.</param>
 /// <param name="file">The FileInfo.</param>
 /// <param name="append">(Optional) if the text should be appended to file file if it's exists.</param>
 public static void SaveAs(this string @this, FileInfo file, bool append = false)
 {
     using (TextWriter tw = new StreamWriter(file.FullName, append))
     {
         tw.Write(@this);
     }
 }

    protected void btn_download_Click(object sender, EventArgs e)
    {
        DataTable dt = new DataTable();
        dt.TableName = "All_Contacts";
        using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["dlgf"].ConnectionString))
        {
            SqlCommand cmd = new SqlCommand("[CTX].[sp_Select_All_List]", conn);
            conn.Open();
            SqlDataAdapter adapter = new SqlDataAdapter(cmd);
            adapter.Fill(dt);
            conn.Close();
        }

        string dir = Server.MapPath("All_List_output");
        string milli = DateTime.Now.Millisecond.ToString();
        FileInfo newFile = new FileInfo(dir + @"\CTX_"+ milli + ".xlsx");
        if (newFile.Exists)
        {
            newFile.Delete();  // ensures we create a new workbook
            newFile = new FileInfo(dir + @"\CTX_" + milli + ".xlsx");
        }

        using (ExcelPackage pack = new ExcelPackage(newFile))
        {
            ExcelWorksheet ws = pack.Workbook.Worksheets.Add(dt.TableName.ToString());
            ws.Cells["A1"].LoadFromDataTable(dt, true);
            pack.Save();
        }

        string path = dir + @"\" + newFile.Name;
        Response.ContentType = "application/excel";
        Response.AppendHeader("Content-Disposition", "attachment; filename=\"" + newFile.Name + "\""); //file name must be in double quotes to allow spaces in the filename
        Response.TransmitFile(path);
        Response.End();
    }

 public static void renameFile(DirectoryInfo directory, FileInfo[] files, int i, string nameNumber)
 {
     Console.WriteLine(directory.Name);
     string newName = [email protected]"\"+directory.Name + "-" + nameNumber+((FileInfo)files[i]).Extension;
     Console.WriteLine(newName);
     File.Move(((FileInfo)files[i]).FullName, newName);
 }

    /// <summary>
    /// Returns 304 (use cached version) code to the client if
    /// file was not changed since last request.
    /// </summary>
    /// <param name="fileInfo">File location information</param>
    /// <returns>True if 304 was returned.</returns>
    public static bool Returned304(FileInfo fileInfo)
    {
        if (!fileInfo.Exists)
            return false;

        return Returned304(fileInfo.LastWriteTime);
    }