Пример #1
0
            public static void Decompress(FileInfo archFile, out String szOutFile)
            {
                Logger.Enter();
                using (FileStream archFileStream = archFile.OpenRead())
                {
                    String currentFileName = archFile.FullName;
                    String newFileName = currentFileName.Remove(
                        currentFileName.Length - archFile.Extension.Length);

                    using (FileStream normalFileStream = File.Create(newFileName))
                    {
                        using (GZipStream decompressionStream = new GZipStream(archFileStream, CompressionMode.Decompress))
                        {
                            byte[] buffer = new byte[1024];
                            int nRead;
                            while ((nRead = decompressionStream.Read(buffer, 0, buffer.Length)) > 0)
                            {
                                normalFileStream.Write(buffer, 0, nRead);
                            }

                            szOutFile = newFileName;
                            Console.WriteLine("Decompressed: {0}", archFile.Name);
                        }
                    }
                }
                Logger.Leave();
            }
Пример #2
0
        public void SettingUpdatesProperties()
        {
            FileInfo testFile = new FileInfo(GetTestFilePath());
            testFile.Create().Dispose();

            Assert.All(TimeFunctions(requiresRoundtripping: true), (tuple) =>
            {
                DateTime dt = new DateTime(2014, 12, 1, 12, 0, 0, tuple.Item3);
                tuple.Item1(testFile.FullName, dt);
                var result = tuple.Item2(testFile.FullName);
                Assert.Equal(dt, result);
                Assert.Equal(dt.ToLocalTime(), result.ToLocalTime());

                // File and Directory UTC APIs treat a DateTimeKind.Unspecified as UTC whereas
                // ToUniversalTime treats it as local.
                if (tuple.Item3 == DateTimeKind.Unspecified)
                {
                    Assert.Equal(dt, result.ToUniversalTime());
                }
                else
                {
                    Assert.Equal(dt.ToUniversalTime(), result.ToUniversalTime());
                }
            });
        }
Пример #3
0
    public static string GetFileName(string filePath)
    {
        if(string.IsNullOrEmpty(filePath)) return "";

        FileInfo fileInfo = new FileInfo(filePath);
        return (fileInfo != null) ? fileInfo.Name : "";
    }
Пример #4
0
 public static Excel LoadExcel(string path)
 {
     FileInfo file = new FileInfo(path);
     ExcelPackage ep = new ExcelPackage(file);
     Excel xls = new Excel(ep.Workbook);
     return xls;
 }
Пример #5
0
 public void FalseForDirectory()
 {
     string fileName = GetTestFilePath();
     Directory.CreateDirectory(fileName);
     FileInfo di = new FileInfo(fileName);
     Assert.False(di.Exists);
 }
Пример #6
0
 public void Length_Of_Directory_Throws_FileNotFoundException()
 {
     string path = GetTestFilePath();
     Directory.CreateDirectory(path);
     FileInfo info = new FileInfo(path);
     Assert.Throws<FileNotFoundException>(() => info.Length);
 }
Пример #7
0
    // 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 : "";
    }
Пример #8
0
    void LoadMapping()
    {
        FileInfo theSourceFile = new FileInfo (path);
        StreamReader reader = theSourceFile.OpenText();

        string text = reader.ReadToEnd();
        reader.Close();
        string[] lines = text.Split('\r');

        Client_lowerLeft_x = float.Parse(lines[1]);
        Client_lowerLeft_y = float.Parse(lines[2]);
        Client_lowerRight_x = float.Parse(lines[3]);
        Client_lowerRight_y = float.Parse(lines[4]);
        Client_upperRight_x = float.Parse(lines[5]);
        Client_upperRight_y = float.Parse(lines[6]);
        Client_upperLeft_x = float.Parse(lines[7]);
        Client_upperLeft_y = float.Parse(lines[8]);

        Server_lowerLeft_x = float.Parse(lines[10]);
        Server_lowerLeft_y = float.Parse(lines[11]);
        Server_lowerRight_x = float.Parse(lines[12]);
        Server_lowerRight_y = float.Parse(lines[13]);
        Server_upperRight_x = float.Parse(lines[14]);
        Server_upperRight_y = float.Parse(lines[15]);
        Server_upperLeft_x = float.Parse(lines[16]);
        Server_upperLeft_y = float.Parse(lines[17]);
    }
Пример #9
0
		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);
			}
		}
Пример #10
0
        static void Main(string[] args)
        {
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(onError);

            // Loading all configs files
            ConfigMgr.LoadConfigs();
            Config = ConfigMgr.GetConfig<LauncherConfig>();

            // Loading log level from file
            if (!Log.InitLog(Config.LogLevel, "LauncherServer"))
                ConsoleMgr.WaitAndExit(2000);

            Client = new RpcClient("LauncherServer", Config.RpcInfo.RpcLocalIp, 1);
            if (!Client.Start(Config.RpcInfo.RpcServerIp, Config.RpcInfo.RpcServerPort))
                ConsoleMgr.WaitAndExit(2000);

            Info = new FileInfo("Configs/mythloginserviceconfig.xml");
            if (!Info.Exists)
            {
                Log.Error("Configs/mythloginserviceconfig.xml", "Config file missing !");
                ConsoleMgr.WaitAndExit(5000);
            }

            StrInfo = Info.OpenText().ReadToEnd();

            if (!TCPManager.Listen<TCPServer>(Config.LauncherServerPort, "LauncherServer"))
                ConsoleMgr.WaitAndExit(2000);

            Server = TCPManager.GetTcp<TCPServer>("LauncherServer");

            ConsoleMgr.Start();
        }
Пример #11
0
	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));
		}
	}
Пример #12
0
 public static void renameFile(DirectoryInfo directory, FileInfo[] files, int i, string nameNumber)
 {
     Console.WriteLine(directory.Name);
     string newName = directory.FullName+@"\"+directory.Name + "-" + nameNumber+((FileInfo)files[i]).Extension;
     Console.WriteLine(newName);
     File.Move(((FileInfo)files[i]).FullName, newName);
 }
Пример #13
0
    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" );
    }
 /// <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);
     }
 }
    // ------------------------------------------------------------------
    // 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;
    }
Пример #16
0
        public void SymLinkLength()
        {
            string path = GetTestFilePath();
            string linkPath = GetTestFilePath();

            const int FileSize = 2000;
            using (var tempFile = new TempFile(path, FileSize))
            {
                Assert.True(MountHelper.CreateSymbolicLink(linkPath, path, isDirectory: false));

                var info = new FileInfo(path);
                Assert.Equal(FileSize, info.Length);

                var linkInfo = new FileInfo(linkPath);
                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                {
                    // On Windows, symlinks have length 0.
                    Assert.Equal(0, linkInfo.Length);
                }
                else
                {
                    // On Unix, a symlink contains the path to the target, and thus has that length.
                    // But the length could actually be longer if it's not just ASCII characters.
                    // We just verify it's at least that big, but also verify that we're not accidentally
                    // getting the target file size.
                    Assert.InRange(linkInfo.Length, path.Length, FileSize - 1);
                }

                // On both, FileStream should however open the target such that its length is the target length
                using (FileStream linkFs = File.OpenRead(linkPath))
                {
                    Assert.Equal(FileSize, linkFs.Length);
                }
            }
        }
Пример #17
0
        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;
        }
Пример #18
0
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {

            string sUser = UsuarioWeb.GetNomeUsuarioConectado(Session);
            if (sUser == "")
            {
                Response.Redirect("~/Home.aspx");
            }
            string sPathAnexo = "";

            if (Request.QueryString["ANEXO"].ToString() != String.Empty)
            {
                sPathAnexo = Request.QueryString["ANEXO"].ToString();
                FileInfo finfo = new FileInfo(Server.MapPath("Pedidos//" + sPathAnexo) + ".pdf");
                if (finfo.Exists)
                {
                    sPathAnexo = finfo.FullName;
                }
                ShowFile2(sPathAnexo);
            }

        }
    }
Пример #19
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LogControllerSingletone"/> class.
 /// </summary>
 public LogController(string logFilePath)
 {
     if((Application.platform == RuntimePlatform.WindowsPlayer)||
         (Application.platform == RuntimePlatform.WindowsEditor))
     {
         FileInfo logFileInfo = new FileInfo(logFilePath);
         FileStream logFile;
         ///logfile is exist - create FileStream
         try
         {
      			logFile = new FileStream(logFilePath,FileMode.Create);
             _fileNameFull = logFileInfo.FullName;
         }
         catch
         {
             Debug.LogError("Can not create or open log file");
             logFile = null;
         }
         ///if error with log File
         if(logFile == null)
             _logFileWriter = null;
         else
         {
         ///make buffered stream with 100KB buffer memory
             _logFileWriter = new StreamWriter(new BufferedStream(logFile,100000));
         }
             WriteLine("log created");
     }
     else
     {
         _logFileWriter = null;
     }
 }
    /// <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);
    }
Пример #21
0
    private void testFile(FileInfo fi)
    {
        string fileKey = fi.FullName.Substring(root.Length).Replace('\\','/');
        detailData dData = detailMap.ContainsKey(fileKey) ? detailMap[fileKey] : null;
        string detail = dData != null ? dData.detail : string.Format("<span class=\"infoError\">{0} detail info not found</span>",fileKey);
        string wUrl = dData != null ? string.Format("check.aspx?w={0}", dData.name) : string.Empty;

        try
        {
            packageLib.BondiWidgetClass widget = new BondiWidgetClass();

            //Response.Write(fi.FullName);

            widget.Load(fi.FullName,"en",false);

            if (dData.expectPass)
                Response.Write(string.Format("<tr><td class=\"passed\">PASSED</td><td>{0}</td><td>&nbsp;</td><td><a href=\"{1}\">{2}</a></td></tr>", detail, wUrl,fileKey));
            else
                Response.Write(string.Format("<tr><td class=\"failed\">FAILED</td><td>{0}</td><td>{1}</td><td><a href=\"{2}\">{3}</a></td></tr>", detail, "Widget loaded but test expected FAIL", wUrl, fileKey));
        }
        catch (Exception ex)
        {
            if (dData == null || dData.expectPass)
            {
                if (dData == null)
                    Response.Write(string.Format("<tr><td class=\"failed\">FAILED</td><td>{0}</td><td>{1}</td><td>{2}</td></tr>", detail, ex.Message, fileKey));
                else
                    Response.Write(string.Format("<tr><td class=\"failed\">FAILED</td><td>{0}</td><td>{1}</td><td><a href=\"{2}\">{3}</a></td></tr>", detail, ex.Message, wUrl, fileKey));
            }
            else
                Response.Write(string.Format("<tr><td class=\"passed\">PASSED</td><td>{0}</td><td>{1}</td><td><a href=\"{2}\">{3}</a></td></tr>", detail, ex.Message, wUrl, fileKey));
        }
    }
Пример #22
0
 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;
     }
 }
Пример #23
0
    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;
    }
Пример #24
0
    /// <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();
        }
    }
Пример #26
0
    /// <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;
    }
    // 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();
        }
    }
    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);
            }
        }
    }
	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));
				}
			}
		}
	}
Пример #30
0
    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();
    }
Пример #31
0
        public Animation[] animations;                  //num_animation个

        ///////////////////////////////////////////////////////////////////////////////////////////////////////////
        public ABI(string filename)
        {
            this.filename = filename;
            FileInfo fi = new FileInfo(filename);

            this.filename = fi.Name;

            using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
            {
                using (BinaryReader br = new BinaryReader(fs))
                {
                    int sign = br.ReadInt32();;
                    Debug.Assert(sign == 0x424d444c);

                    version = int.Parse(ConvertBytesToString(br.ReadBytes(4)));
                    Debug.Assert(version == 1060 || version == 1050, "此ABI文件的版本不是1050或1060!");

                    num_timeaxis  = br.ReadInt32();
                    num_animation = br.ReadInt32();
                    num_texture   = br.ReadInt32();

                    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
                    //所有贴图
                    textureinfos = new TextureInfo[num_texture];
                    for (int i = 0; i < num_texture; i++)
                    {
                        textureinfos[i]         = new TextureInfo();
                        textureinfos[i].UNKNOWN = br.ReadInt32();
                        textureinfos[i].width   = br.ReadInt32();
                        textureinfos[i].height  = br.ReadInt32();
                        textureinfos[i].name    = ConvertBytesToString(br.ReadBytes(32));

                        textureinfos[i].palette = new uint[256];
                        for (int j = 0; j < 256; j++)
                        {
                            uint r = br.ReadByte();
                            uint g = br.ReadByte();
                            uint b = br.ReadByte();

                            textureinfos[i].palette[j] = 0xff000000 | (r << 16) | (g << 8) | b;
                        }

                        textureinfos[i].data = br.ReadBytes(textureinfos[i].width * textureinfos[i].height);
                    }

                    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
                    //模型数据
                    if (version != 1050)
                    {
                        br.ReadByte();                        //未知标志,并不恒为1,奇怪的是,1050格式里面没有这个自己,而1060却有
                    }
                    //Debug.Assert(br.ReadByte() == 1);

                    num_model = br.ReadInt32();
                    num_bone  = br.ReadInt32();

                    models = new Model[num_model];
                    for (int i = 0; i < num_model; i++)
                    {
                        Model d = models[i] = new Model();
                        d.num_vertice = br.ReadInt32();
                        d.num_polygon = br.ReadInt32();
                        d.name        = ConvertBytesToString(br.ReadBytes(32));

                        d.vertex = new Vertex[d.num_vertice];
                        for (int j = 0; j < d.num_vertice; j++)
                        {
                            Vertex v = d.vertex[j] = new Vertex();
                            v.X = br.ReadSingle();
                            v.Y = br.ReadSingle();
                            v.Z = br.ReadSingle();
                        }

                        d.polygon = new Polygon[d.num_polygon];
                        for (int j = 0; j < d.num_polygon; j++)
                        {
                            Polygon poly = d.polygon[j] = new Polygon();
                            poly.num_lines = br.ReadByte();

                            if (poly.num_lines != 3 && poly.num_lines != 4)
                            {
                                //的确存在num_lines超过3/4的情况,比方说tiger.abi,num_lines就有为6的情况
                                //throw new Exception();
                            }

                            poly.texture_id = br.ReadByte();

                            poly.map_points = new Point[poly.num_lines];
                            for (int k = 0; k < poly.num_lines; k++)
                            {
                                Point p = poly.map_points[k] = new Point();
                                p.vertex_id = br.ReadInt16();
                                p.U         = br.ReadInt16() / 4096f;
                                p.V         = br.ReadInt16() / 4096f;
                            }
                        }

                        d.vbt       = new VidToBoneTable();
                        d.vbt.entry = new VidToBoneTableEntry[num_bone];
                        for (int j = 0; j < num_bone; j++)
                        {
                            d.vbt.entry[j]           = new VidToBoneTableEntry();
                            d.vbt.entry[j].StartVidx = br.ReadInt32();
                            d.vbt.entry[j].EndVidx   = br.ReadInt32();                           //要不要-1?
                        }
                    }

                    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
                    //骨骼继承结构
                    hierarchy = new BoneHierarchy[num_bone];

                    for (int i = 0; i < num_bone; i++)
                    {
                        hierarchy[i]              = new BoneHierarchy();
                        hierarchy[i].ParentIdx    = br.ReadInt32();
                        hierarchy[i].GlobalOffset = new Vector3(
                            br.ReadSingle(),
                            br.ReadSingle(),
                            br.ReadSingle());
                        hierarchy[i].NodeName = ConvertBytesToString(br.ReadBytes(32));
                        hierarchy[i].UNKNOWN  = br.ReadInt32();

                        Debug.WriteLine(String.Format("{0} - [{1}]:{2}", i, hierarchy[i].ParentIdx, hierarchy[i].NodeName));
                        Debug.Assert(hierarchy[i].UNKNOWN == 0);
                    }

                    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
                    //关键帧、时间轴相关结构
                    timeaxises = new TransformTimeAxis[num_timeaxis];

                    for (int i = 0; i < num_timeaxis; i++)
                    {
                        TransformTimeAxis ta = timeaxises[i] = new TransformTimeAxis();
                        ta.trta = new TranslateTimeAxis();
                        ta.rta  = new RotateTimeAxis();

                        TranslateTimeAxis tta = ta.trta;
                        tta.num_keyframe = br.ReadInt32();
                        tta.tkf          = new TranslateKeyFrame[tta.num_keyframe];
                        for (int j = 0; j < tta.num_keyframe; j++)
                        {
                            tta.tkf[j]           = new TranslateKeyFrame();
                            tta.tkf[j].timestamp = br.ReadByte();
                            tta.tkf[j].translate = new Vector3(br.ReadInt16() / 256f, br.ReadInt16() / 256f, br.ReadInt16() / 256f);
                        }

                        RotateTimeAxis rta = ta.rta;
                        rta.num_keyframe = br.ReadInt32();
                        rta.rkf          = new RotateKeyFrame[rta.num_keyframe];
                        for (int j = 0; j < rta.num_keyframe; j++)
                        {
                            rta.rkf[j]           = new RotateKeyFrame();
                            rta.rkf[j].timestamp = br.ReadByte();
                            rta.rkf[j].rotate    = new Quaternion(br.ReadInt16() / 32768f, br.ReadInt16() / 32768f, br.ReadInt16() / 32768f, br.ReadInt16() / 32768f);
                        }
                    }

                    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
                    //动画行为定义结构
                    animations = new Animation[num_animation];

                    for (int i = 0; i < num_animation; i++)
                    {
                        Animation ani = animations[i] = new Animation();
                        ani.name             = ConvertBytesToString(br.ReadBytes(0x3c));
                        ani.num_related_bone = br.ReadInt32();

                        ani.bae = new BoneAnimationEntry[ani.num_related_bone];
                        for (int j = 0; j < ani.num_related_bone; j++)
                        {
                            BoneAnimationEntry bae = ani.bae[j] = new BoneAnimationEntry();
                            bae.bone_id = br.ReadInt32();
                            bae.transform_time_axis_idx = br.ReadInt32();
                            bae.tta = timeaxises[bae.transform_time_axis_idx];
                        }
                    }

                    Debug.WriteLine("已读长度: " + fs.Position.ToString());
                    Debug.WriteLine("文件长度: " + fs.Length.ToString());
                }

                //GenerateAllBitmaps(); //创建所有位图
            }
        }
Пример #32
0
 /// <summary>
 /// Inserts a set of keywords got from a FileInfo object into the 'keywords' collection
 /// </summary>
 /// <param name="keywords">The keyword collection</param>
 /// <param name="fileInfo">The FileInfo object</param>
 public static void GetKeywords(Dictionary <string, string> keywords, FileInfo fileInfo)
 {
     GetKeywords(keywords, "", fileInfo);
 }
Пример #33
0
        /// <summary>
        /// Method Scans the curr dir.
        /// </summary>
        static void ScanCurrDir()
        {
            int total = 0;

            WriteLine("-- Directory Scanner --");
            WriteLine();
            ForegroundColor = Blue;
            WriteLine($"[*] Scan Started At {Globals.CurrentDateTime}");
            ResetColor();

            // getting filenames
            var files = Directory.GetFiles(CurrentDirectory, "*", SearchOption.AllDirectories);
            // instacing misc to store misc files
            var misc   = new System.Collections.Generic.List <string>();
            var isMisc = false; // flag to check if any misc file

            foreach (var file in files)
            {
                if (++total > 5000)  // safeguard api calls
                {
                    ForegroundColor = Red;
                    WriteLine("You reached  5000/per day scan limit");
                    WriteLine("If you try to scan again then your API may be blocked");
                    ResetColor();
                    Exit(1);
                }
                var fileInfo = new FileInfo(file);
                if (fileInfo.Length < 1.28e+8)  // safeguard file size
                {
                    ForegroundColor = Yellow;
                    WriteLine($"[~] Scanning {fileInfo.FullName}");
                    ResetColor();
                    var report = Report(Globals.GetSHA256(fileInfo.FullName));
                    if (report.ResponseCode == FileReportResponseCode.Present)
                    {
                        // execute detection and format detection if file is present on server
                        int detected = 0;
                        foreach (var av in report.Scans.Keys)
                        {
                            if (report.Scans[av].Detected)
                            {
                                detected++;
                            }
                        }
                        FormatDetection(detected);
                    }
                    // otherwise misc file is not there or is being scanned
                    else if (report.ResponseCode == FileReportResponseCode.Queued)
                    {
                        // file is queued
                        ForegroundColor = Magenta;
                        WriteLine("[!] Not found - Misc File");
                        ResetColor();
                    }
                    else
                    {
                        ForegroundColor = Magenta;
                        WriteLine("[!] Not found - Misc File");
                        ResetColor();
                        var scan = SendScan(fileInfo);
                        misc.Add($"{scan.SHA256}|{fileInfo.FullName}");  // adding to misc file
                        isMisc = true;
                        //break;
                    }
                    WriteLine($"[#] Next Scan At {Now.AddSeconds(30):dd/MM/yyyy hh:mm:ss tt}");
                    Sleep(30000); // sleep to prevent spamming
                }
                else
                {
                    ForegroundColor = Yellow;
                    WriteLine($"[!] Skipping {fileInfo.FullName} - Beyond 128mB");
                    ResetColor();
                }
            }
            ForegroundColor = Blue;
            WriteLine($"[*] Scan Completed At {Globals.CurrentDateTime}");
            ResetColor();
            if (isMisc)
            {
                // writing misc files
                File.WriteAllLines(Globals.MiscFile, misc.ToArray());
                WriteLine();
                WriteLine("We found some miscellaneous files");
                WriteLine($"Try scaning misc file after {Now.AddHours(5):dd/MM/yyyy hh:mm:ss tt}");
            }
        }
Пример #34
0
        private void DoSearch()
        {
            UpdateStatueBarTextSafe("开始搜索");
            Invalidate();
            richTextBoxEx1.Clear();
            if (string.IsNullOrEmpty(excelPath))
            {
                richTextBoxEx1.SelectedText = "请先点击'绑定目录'选择绑定table文件夹";
                return;
            }
            int itemCount = 0;

            foreach (var file in Directory.GetFiles("./cache/"))
            {
                var fileInfo = new FileInfo(file);
                if (file.EndsWith(".txt"))
                {
                    using (StreamReader sr = new StreamReader(file, Encoding.UTF8))
                    {
                        string line;
                        int    lineIndx = 0;
                        while ((line = sr.ReadLine()) != null)
                        {
                            var  targetPos = line.IndexOf(textBox1.Text);
                            var  sizeStr   = textBox1.Text.Length;
                            bool isTarget  = false;
                            int  tabIndex  = 0;
                            while (targetPos >= 0)
                            {
                                if (!isTarget)
                                {
                                    // 第一次进入先拼一个表头
                                    richTextBoxEx1.SelectionColor = Color.Red;
                                    var fileNames = fileInfo.Name.Replace(".txt", "").Split('-');
                                    if (fileNames[0].Length > 8)
                                    {
                                        fileNames[0] = fileNames[0].Substring(0, 8);
                                    }
                                    if (fileNames[1].Length > 8)
                                    {
                                        fileNames[1] = fileNames[1].Substring(0, 8);
                                    }
                                    richTextBoxEx1.SelectedText   = string.Format("{0,-8}\t{1,-8}\t#{2:####}\t", fileNames[0], fileNames[1], lineIndx + 14);
                                    richTextBoxEx1.SelectionColor = Color.Black;
                                }

                                if (targetPos > 0)
                                {
                                    var pickText = line.Substring(0, targetPos);
                                    richTextBoxEx1.SelectedText = pickText;
                                    tabIndex += GetAppearTimes(pickText, "\t");
                                }

                                richTextBoxEx1.InsertLink(line.Substring(targetPos, sizeStr), string.Format("{0}#{1}#{2}", fileInfo.Name, lineIndx + 14, tabIndex));

                                line      = line.Substring(targetPos + sizeStr);
                                targetPos = line.IndexOf(textBox1.Text);
                                isTarget  = true;
                            }

                            if (isTarget)
                            {
                                richTextBoxEx1.SelectedText = line + "\n";
                                itemCount++;
                                if (itemCount >= 1000)
                                {
                                    UpdateStatueBarTextSafe(string.Format("搜索结束:记录数达到上限,共找到记录{0}条", itemCount));
                                    //最多出1000条,抱歉
                                    return;
                                }
                            }

                            lineIndx++;
                        }
                    }
                }
            }

            UpdateStatueBarTextSafe(string.Format("搜索结束:共找到记录{0}条", itemCount));
            //防止link点击后乱跳转的bug
            this.richTextBoxEx1.Select(0, 0);
        }
Пример #35
0
 public void FailConfigurationSet(FileInfo config)
 {
     Trace.Write("Tests failed\n\n");
     //Trace.WriteLine("");
 }
Пример #36
0
 public void PassConfigurationSet(FileInfo config)
 {
     Trace.Write("All passed\n\n");
 }
Пример #37
0
 public void RunningConfigurationSet(FileInfo config)
 {
     Trace.Write("{config}\n".Replace(new { config }));
 }
Пример #38
0
        static void Main(string[] args)
        {
            string file = @"d:\IT\testfile.txt";

            Console.WriteLine("Path osztály:");
            Console.WriteLine("Path.GetFileName(path): " + Path.GetFileName(file));
            Console.WriteLine("Path.GetExtension(path): " + Path.GetExtension(file));
            Console.WriteLine("Path.GetDirectoryName(path): " + Path.GetDirectoryName(file));

            Console.WriteLine("\nDirectory osztály:");
            Console.WriteLine(@"Directory.CreateDirectory(@'C:\FolderName1\FolderName2\...')");
            //Directory.CreateDirectory(@"C:\");


            var folderPath = @"C:\";
            var filePath   = @"C:\Windows";

            Console.WriteLine($"\nAdd vissza az összes mappát-t innen: {folderPath}");

            foreach (var item in Directory.GetDirectories(folderPath))
            {
                Console.WriteLine(item);
            }

            Console.WriteLine($"\nAdd vissza az összes file-t innen: {filePath}");
            foreach (var item in Directory.GetFiles(filePath))
            {
                Console.WriteLine(Path.GetFileName(item));
            }

            var comb1 = @"d:\IT\Proba\Eleres";
            var comb2 = @"files\test.txt";

            Console.WriteLine($"\nÖsszefűzése 2 elérési útnak: {comb1} és {comb2}");
            Console.WriteLine(Path.Combine(comb1, comb2));


            var fldr1 = @"d:\IT\test\üres mappa\";
            var fldr2 = @"d:\IT\test\nem üres mappa\";


            var dex = Directory.Exists(comb1);

            Console.WriteLine($"\nDirectory.Exists('{comb1}') >>>>> {dex} ");

            //Directory.CreateDirectory(fldr1);
            //Directory.CreateDirectory(fldr2);
            Console.WriteLine($"Directory.Create('{fldr1}')  >> Mappaszerkezet létrehozása");
            Console.WriteLine($"Directory.Delete('{fldr1}')  >> Csak akkor töröl, ha üres a mappa!");
            Console.WriteLine($"Directory.Delete('{fldr2}', true)  >> Minden esetben törli a mappát, a tartalmával együtt!");

            //Directory.Delete(fldr1, true);
            //Directory.Delete(fldr2, true);


            string sourceDirectory      = @"d:\IT\test\mappa1\testfile.txt";
            string destinationDirectory = @"d:\\IT\\mappa20\testfile.txt";

            Console.WriteLine("Filok, mappák másolása:");

            /*
             * try
             * {
             *   Directory.Move(sourceDirectory, destinationDirectory);
             * }
             * catch (Exception e)
             * {
             *   Console.WriteLine(e.Message);
             * }
             */
            var myPath = @"d:\ELADÓ CUCCOK\";
            // listSubfolderFiles(myPath);

            //Console.WriteLine($"Directory.Move('{copyFrom}', '{pasteTo}'");


            var      myFile  = @"D:\IT\test\BH4K8270.jpg";
            var      myFile2 = @"D:\IT\test\H.jpg";
            FileInfo info    = new FileInfo(myFile);
            long     length  = info.Length;

            var   fileSize  = Convert.ToString(length);
            float asd       = (length / 1024 / 1024);
            var   fileSize2 = Math.Round(asd, 2);

            Console.WriteLine($"File neve: {Path.GetFileName(myFile)}");
            Console.WriteLine($"File kiterjesztése: {Path.GetExtension(myFile)}");
            Console.WriteLine($"File mérete: {fileSize} byte");
            Console.WriteLine($"File mérete: {fileSize2} MB");

            Console.WriteLine($"File GetCreationTime: {File.GetCreationTime(myFile)}");
            Console.WriteLine($"File GetCreationTimeUtc: {File.GetCreationTimeUtc(myFile)}");
            Console.WriteLine($"File GetLastAccessTime: {File.GetLastAccessTime(myFile)}");
            Console.WriteLine($"File GetLastAccessTimeUtc: {File.GetLastAccessTimeUtc(myFile)}");
            Console.WriteLine($"File GetLastWriteTime: {File.GetLastWriteTime(myFile)}");
            Console.WriteLine($"File GetLastWriteTimeUtc: {File.GetLastWriteTimeUtc(myFile)}");

            var oldDate = File.GetLastWriteTimeUtc(myFile);
            var newDate = oldDate;


            Console.WriteLine($"Old Date: {oldDate}");
            Console.WriteLine($"New Date {newDate}");

            /*
             * newDate = newDate.AddYears(1);
             * newDate = newDate.AddMonths(1);
             * newDate = newDate.AddDays(1);
             * newDate = newDate.AddHours(1);
             * newDate = newDate.AddMinutes(1);
             * newDate = newDate.AddSeconds(1);
             */

            Console.WriteLine($"New Date {newDate}");


            var str = File.ReadAllLines(myFile);

            Console.WriteLine(str);


            File.SetLastWriteTimeUtc(myFile, newDate);
            Console.WriteLine($"File GetLastWriteTimeUtc: {File.GetLastWriteTimeUtc(myFile)}");



            Console.ReadLine();
        }
Пример #39
0
        /// <summary>
        /// Initializes a new instance of the <see cref="XmlObject"/> class
        /// for reading and/or writing.
        ///
        /// If the file does not exists it will be created.
        /// </summary>
        /// <exception cref="ArgumentNullException">
        /// When <paramref name="fallbackxmlcontent"/> or <paramref name="xmlfilename"/> is <see langword="null"/> or <see cref="string.Empty"/>.
        /// </exception>
        /// <param name="xmlfilename">
        /// The name of the XML File to load into the <see cref="XmlObject"/>.
        /// </param>
        /// <param name="fallbackxmlcontent">
        /// The fallback content string to write into the fallback XML File
        /// if the file does not exist or if the file is empty.
        /// </param>
        /// <param name="saveToCurrentDirectory">
        /// Controls weather to save the file to the xmlfilename param string if
        /// it is the full path or to the Current Directory if it supplies file name only.
        /// This implies that that file is saved to the fully qualified path of the
        /// current working directory prefixed before the filename.
        /// </param>
        public XmlObject(string xmlfilename, string fallbackxmlcontent, bool saveToCurrentDirectory)
        {
            if (string.IsNullOrEmpty(xmlfilename))
            {
                throw new ArgumentNullException(nameof(xmlfilename) /*, "'xmlfilename' cannot be null or empty."*/);
            }

            if (string.IsNullOrEmpty(fallbackxmlcontent))
            {
                throw new ArgumentNullException(nameof(fallbackxmlcontent) /*, "'fallbackxmlcontent' cannot be null or empty."*/);
            }

            this.ObjLock                  = new object();
            this.ElementsAdded            = new Dictionary <string, XmlElementData>();
            this.ElementsEdits            = new Dictionary <string, XmlElementData>();
            this.ElementAttributesDeleted = new Dictionary <string, XmlElementData>();
            this.ElementsDeleted          = new List <string>();
            if (saveToCurrentDirectory)
            {
                var directory = new DirectoryInfo(xmlfilename);
                if (!directory.Parent.Exists)
                {
                    throw new DirectoryNotFoundException(Resources.XmlObject_Directory_Not_Found);
                }

#if NET40 || NET45 || NET451 || NET452 || NET46 || NET461 || NET462 || NET47 || NET471 || NET472 || NET48 || NETCOREAPP2_0 || NETSTANDARD2_0
                if (!xmlfilename.Contains(Directory.GetCurrentDirectory()) &&
#else
                if (!xmlfilename.Contains(Directory.GetCurrentDirectory(), StringComparison.Ordinal) &&
#endif
                    directory.Parent.FullName == Directory.GetCurrentDirectory())
                {
                    xmlfilename = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + xmlfilename;
                }
            }

#if NET40 || NET45 || NET451 || NET452 || NET46 || NET461 || NET462 || NET47 || NET471 || NET472 || NET48 || NETCOREAPP2_0 || NETSTANDARD2_0
            if (!fallbackxmlcontent.Contains("<?xml version=\"1.0\" encoding=\"utf-8\" ?>"))
#else
            if (!fallbackxmlcontent.Contains("<?xml version=\"1.0\" encoding=\"utf-8\" ?>", StringComparison.Ordinal))
#endif
            {
                // insert root element at begginning of string data.
                fallbackxmlcontent = fallbackxmlcontent.Insert(0, "<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
            }

            long fileSize = 0;
            this.CachedXmlfilename = xmlfilename;
            if (!xmlfilename.Equals(":memory", StringComparison.Ordinal))
            {
                this.Exists     = File.Exists(xmlfilename);
                this.HasChanged = !this.Exists;
                var fileinfo = new FileInfo(xmlfilename);
                if (!fileinfo.Directory.Exists)
                {
                    throw new DirectoryNotFoundException(Resources.XmlObject_Directory_Not_Found);
                }

                if (this.Exists)
                {
                    fileSize = fileinfo.Length;
                }
            }

            this.Doc = fileSize > 0 ? XDocument.Load(xmlfilename) : XDocument.Parse(fallbackxmlcontent);
        }
Пример #40
0
 public CommonFile(FileInfo location)
 {
     this.Location = location;
 }
Пример #41
0
 static void Main()
 {
     try
     {
         Dialogue.Message("Hello world! I, " + Environment.MachineName + ", will be your narrator for tonight.");
         Application.EnableVisualStyles();
         Application.SetCompatibleTextRenderingDefault(false);
         Application.Run(new Fileselect());
         if (Global.Continue)
         {
             Prompt = new Prompt();
             var Folder = new FileInfo(Global.Path).Directory;
             foreach (FileInfo f in Folder.GetFiles())
             {
                 if (f.FullName.EndsWith(".lpc"))
                 {
                     Containers.Add(new FileList(f.FullName));
                 }
                 else if (f.FullName.EndsWith(".lpv"))
                 {
                     Vars.Add(new OptionSet(f.FullName));
                 }
             }
             Interpreter.Sysinit();
             foreach (OptionSet S in Vars)
             {
                 Memory.Init(S);
             }
             Application.Run(Prompt);
             Containers.Clear();
             foreach (Container C in Interpreter.Containers)
             {
                 if (!C.Sys)
                 {
                     File.WriteAllText(Folder.FullName + "\\" + C.Name + ".lpc", null);
                     FileList f = new FileList(Folder.FullName + "\\" + C.Name + ".lpc");
                     f.newElement("%%" + C.Path);
                     if (C.AttatchedEngine() != null)
                     {
                         f.newElement("##" + C.AttatchedEngine().Name + "," + C.AttatchedEngine().Action);
                     }
                     foreach (Pipe p in C.Attatched)
                     {
                         f.newElement(p.Name);
                     }
                     Containers.Add(f);
                 }
             }
             foreach (FileList F in Containers)
             {
                 F.reload();
             }
             OptionSet s = new OptionSet(Folder.FullName + "\\vars.lpv");
             foreach (Memory.Var v in Memory.Vars)
             {
                 s.NewEntry(v.name, v.value);
             }
         }
     } catch (Exception e)
     {
         MessageBox.Show
             ("An exception has occurred: " + e.Message, "Error", MessageBoxButtons.OK);
         Dialogue.Error
             ("An unhandled exception occurred! "
             + e.GetType()
             + ": " + e.Message);
     }
 }
Пример #42
0
        private void HandleFile(string folder1, string folder2, Dictionary <string, CompareMode> specialFiles, Dictionary <string, Comparence> comparence, FileInfo file, bool inReference, bool ignoreSame = true)
        {
            if (comparence.ContainsKey(file.Name))
            {
                return;
            }

            var cd = new Comparence
            {
                Name          = file.Name,
                File1FullPath = file.FullName,
                Result        = CompareResult.DoesNotExist,
                InReference   = inReference
            };

            var file2FullName = cd.File1FullPath.Replace(folder1, folder2);

            if (File.Exists(file2FullName))
            {
                cd.File2FullPath = file2FullName;

                string contentMarker = null;

                if (specialFiles != null && specialFiles.Count > 0)
                {
                    CompareMode specialFileMode;

                    if (specialFiles.TryGetValue(file.Name, out specialFileMode))
                    {
                        if (specialFileMode == CompareMode.MarkedContent)
                        {
                            contentMarker = Constansts.CONTENT_MARKER;
                        }
                        else
                        {
                            cd.Result = CompareResult.TheSame;

                            return;
                        }
                    }
                }

                cd.Result = CompareResult.HasContentDifferences;

                cd.Difference = AnyDifference(cd.File1FullPath, cd.File2FullPath, contentMarker);

                if (cd.Difference == null)
                {
                    if (ignoreSame)
                    {
                        return;
                    }

                    cd.Result = CompareResult.TheSame;
                }
            }

            comparence.Add(file.Name, cd);
        }
Пример #43
0
 /// <summary>
 /// Builds an analyzer with the stop words from the given file. </summary>
 /// <seealso cref="WordlistLoader.GetWordSet(TextReader, LuceneVersion)"/>
 /// <param name="matchVersion"> See <see cref="LuceneVersion"/> </param>
 /// <param name="stopwordsFile"> File to load stop words from  </param>
 public StopAnalyzer(LuceneVersion matchVersion, FileInfo stopwordsFile)
     : this(matchVersion, LoadStopwordSet(stopwordsFile, matchVersion))
 {
 }
Пример #44
0
        /// <summary>
        ///
        /// </summary>
        public void Import()
        {
            var foldersCreated = 0;

            foreach (var inputFile in Directory.GetFiles(_config.Source, "*.*", SearchOption.AllDirectories)
                     .Where(f =>
                            f.EndsWith(".jpg", StringComparison.InvariantCultureIgnoreCase) ||
                            f.EndsWith(".png", StringComparison.InvariantCultureIgnoreCase) ||
                            f.EndsWith(".mp4", StringComparison.InvariantCultureIgnoreCase) ||
                            f.EndsWith(".mov", StringComparison.InvariantCultureIgnoreCase)).AsParallel())
            {
                string   fileName  = new FileInfo(inputFile).Name;
                DateTime?dateTaken = null;

                // My Cameras / phones name photos with 2 conventions:
                //  IMG_yyyyMMdd_hhmmss.jpg
                //  yyyyMMdd_hhmmss.jpg
                // We'll try and pull the date taken from the filename and if not available, fall back to EXIF data
                // because pulling EXIF data is slow.

                var fileNameTokens = fileName.Split('_');

                if (fileNameTokens.Length > 0)
                {
                    var dateToken = fileNameTokens[0] == "IMG"
                        ? fileNameTokens[1]
                        : fileNameTokens[0];

                    if (DateTime.TryParseExact(dateToken, "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime dateTakenFromFileName))
                    {
                        dateTaken = dateTakenFromFileName;
                    }
                }

                if (!dateTaken.HasValue && TryGetDateTakenFromImageProperties(inputFile, out DateTime dateTakenFromImageProperties))
                {
                    // Couldn't find date taken from filename - try the exif data
                    dateTaken = dateTakenFromImageProperties;
                }


                if (!dateTaken.HasValue)
                {
                    // Photos could be downloaded images (e.g. synced using IFTTT from facebook etc)
                    dateTaken = File.GetLastWriteTime(inputFile);
                }

                // Create destination folder based on the photos date taken in a yyyy-MM/dd structure
                var outputFolder = Path.Combine(
                    _config.Destination,
                    dateTaken.Value.ToString("yyyy-MM"),
                    dateTaken.Value.ToString("dd"));

                lock (dirLock) // multiple threads could all try and create the same dir
                {
                    if (!Directory.Exists(outputFolder))
                    {
                        Directory.CreateDirectory(outputFolder);
                        foldersCreated++;
                    }
                }

                var outputFile = Path.Combine(outputFolder, fileName);

                try
                {
                    File.Move(inputFile, outputFile);
                    Console.WriteLine("Moved {0} ---> {1}", inputFile, outputFile);
                }
                catch (IOException e)
                {
                    if (e.Message == "Cannot create a file when that file already exists.\r\n")
                    {
                        File.Delete(inputFile);
                    }
                    Console.WriteLine("ERROR {0} ---> {1} :::: {2}", inputFile, outputFile, e.Message);
                }
                finally
                {
                    // If the directory is now empty, then we can delete it to clean up
                    var directoryPath = Path.GetDirectoryName(inputFile);
                    if (!Directory.EnumerateFileSystemEntries(directoryPath).Any(f => f != "Thumbs.db"))
                    {
                        Directory.Delete(directoryPath);
                    }
                }
            }
            Console.WriteLine("Created {0} folders", foldersCreated);
            Console.ReadLine();
        }
Пример #45
0
 public void TakeSnapshot(FileInfo file)
 {
     TakeSnapshot(file, 0, 0);
 }
        /// <summary>
        /// Does the Analysis
        /// Returns a DataTable
        /// </summary>
        /// <param name="fiSegmentOfSourceFile"></param>
        /// <param name="configDict"></param>
        /// <param name="diOutputDir"></param>
        /// <param name="opFileName"></param>
        /// <param name="segmentStartOffset"></param>
        /// <param name="config"></param>
        /// <param name="segmentAudioFile"></param>
        public static Tuple <BaseSonogram, double[, ], double[], List <AcousticEvent>, TimeSpan> Analysis(FileInfo fiSegmentOfSourceFile, Dictionary <string, string> configDict, DirectoryInfo diOutputDir, string opFileName, TimeSpan segmentStartOffset)
        {
            //set default values
            int    bandWidth          = 500; //detect bars in bands of this width.
            int    frameSize          = 1024;
            double windowOverlap      = 0.0;
            double intensityThreshold = double.Parse(configDict[key_INTENSITY_THRESHOLD]);
            //intensityThreshold = 0.01;

            AudioRecording recording = AudioRecording.GetAudioRecording(fiSegmentOfSourceFile, RESAMPLE_RATE, diOutputDir.FullName, opFileName);

            if (recording == null)
            {
                LoggedConsole.WriteLine("############ WARNING: Recording could not be obtained - likely file does not exist.");
                return(null);
            }
            int      sr                   = recording.SampleRate;
            double   binWidth             = recording.SampleRate / (double)frameSize;
            double   frameDuration        = frameSize / (double)sr;
            double   frameOffset          = frameDuration * (1 - windowOverlap); //seconds between start of each frame
            double   framesPerSecond      = 1 / frameOffset;
            TimeSpan tsRecordingtDuration = recording.Duration;
            int      colStep              = (int)Math.Round(bandWidth / binWidth);

            //i: GET SONOGRAM AS MATRIX
            double epsilon  = Math.Pow(0.5, recording.BitsPerSample - 1);
            var    results2 = DSP_Frames.ExtractEnvelopeAndAmplSpectrogram(recording.WavReader.Samples, sr, epsilon, frameSize, windowOverlap);

            double[] avAbsolute = results2.Average;                //average absolute value over the minute recording
            //double[] envelope = results2.Item2;
            double[,] spectrogram = results2.AmplitudeSpectrogram; //amplitude spectrogram. Note that column zero is the DC or average energy value and can be ignored.
            double windowPower = results2.WindowPower;

            //############################ NEXT LINE FOR DEBUGGING ONLY
            //spectrogram = GetTestSpectrogram(spectrogram.GetLength(0), spectrogram.GetLength(1), 0.01, 0.03);

            var output         = DetectGratingEvents(spectrogram, colStep, intensityThreshold);
            var amplitudeArray = output.Item2; //for debug purposes only

            //convert List of Dictionary events to List of ACousticevents.
            //also set up the hits matrix.
            int rowCount       = spectrogram.GetLength(0);
            int colCount       = spectrogram.GetLength(1);
            var hitsMatrix     = new double[rowCount, colCount];
            var acousticEvents = new List <AcousticEvent>();

            double minFrameCount = 8; //this assumes that the minimum grid is 2 * 4 = 8 long

            foreach (Dictionary <string, double> item in output.Item1)
            {
                int minRow     = (int)item[key_START_FRAME];
                int maxRow     = (int)item[key_END_FRAME];
                int frameCount = maxRow - minRow + 1;
                if (frameCount < minFrameCount)
                {
                    continue;                             //only want events that are over a minimum length
                }
                int    minCol      = (int)item[key_MIN_FREQBIN];
                int    maxCol      = (int)item[key_MAX_FREQBIN];
                double periodicity = item[key_PERIODICITY];

                double[] subarray = DataTools.Subarray(avAbsolute, minRow, maxRow - minRow + 1);
                double   severity = 0.1;
                int[]    bounds   = DataTools.Peaks_CropToFirstAndLast(subarray, severity);
                minRow = minRow + bounds[0];
                maxRow = minRow + bounds[1];
                if (maxRow >= rowCount)
                {
                    maxRow = rowCount - 1;
                }

                Oblong o  = new Oblong(minRow, minCol, maxRow, maxCol);
                var    ae = new AcousticEvent(segmentStartOffset, o, results2.NyquistFreq, frameSize, frameDuration, frameOffset, frameCount);
                ae.Name            = string.Format("p={0:f0}", periodicity);
                ae.Score           = item[key_SCORE];
                ae.ScoreNormalised = item[key_SCORE] / 0.5;
                acousticEvents.Add(ae);

                //display event on the hits matrix
                for (int r = minRow; r < maxRow; r++)
                {
                    for (int c = minCol; c < maxCol; c++)
                    {
                        hitsMatrix[r, c] = periodicity;
                    }
                }
            } //foreach

            //set up the songogram to return. Use the existing amplitude sonogram
            int bitsPerSample = recording.WavReader.BitsPerSample;
            //NoiseReductionType nrt = SNR.Key2NoiseReductionType("NONE");
            NoiseReductionType nrt = SNR.KeyToNoiseReductionType("STANDARD");
            var sonogram           = (BaseSonogram)SpectrogramStandard.GetSpectralSonogram(recording.BaseName, frameSize, windowOverlap, bitsPerSample, windowPower, sr, tsRecordingtDuration, nrt, spectrogram);

            sonogram.DecibelsNormalised = new double[sonogram.FrameCount];
            for (int i = 0; i < sonogram.FrameCount; i++) //foreach frame or time step
            {
                sonogram.DecibelsNormalised[i] = 2 * Math.Log10(avAbsolute[i]);
            }
            sonogram.DecibelsNormalised = DataTools.normalise(sonogram.DecibelsNormalised);

            return(Tuple.Create(sonogram, hitsMatrix, amplitudeArray, acousticEvents, tsRecordingtDuration));
        } //Analysis()
Пример #47
0
 protected abstract bool FoundFileOnDiskForFileInTorrent(string torrentFile, FileInfo onDisk, int numberInTorrent,
                                                         string nameInTorrent);
Пример #48
0
 public void TakeSnapshot(FileInfo file, uint width, uint height)
 {
     Manager.TakeSnapshot(myMediaPlayerInstance, file, width, height);
 }
Пример #49
0
 /// <summary>
 /// 为脚本文件设置临时数据库文件
 /// </summary>
 /// <param name="bitFile"></param>
 public static void Use(string bitFile) { 
     FileInfo file = new FileInfo(bitFile);
     DirectoryInfo rootDir = file.Directory.Parent;
     AppSettings.Instance.CurrentExecutePath = rootDir.FullName;                 
 }
Пример #50
0
 public VlcMedia SetMedia(FileInfo file, params string[] options)
 {
     return SetMedia(new VlcMedia(this, file, options));
 }
Пример #51
0
 public static bool IsFile(FileInfo file) => VoteFilePattern.IsMatch(file.Name);
Пример #52
0
        public bool ProcessTorrentFile(string torrentFile, TreeView tvTree, CommandLineArgs args)
        {
            // ----------------------------------------
            // read in torrent file

            if (tvTree != null)
            {
                tvTree.Nodes.Clear();
            }

            BEncodeLoader bel    = new BEncodeLoader();
            BTFile        btFile = bel.Load(torrentFile);

            if (btFile is null)
            {
                return(false);
            }

            BTItem bti = btFile.GetItem("info");

            if ((bti is null) || (bti.Type != BTChunk.kDictionary))
            {
                return(false);
            }

            BTDictionary infoDict = (BTDictionary)(bti);

            bti = infoDict.GetItem("piece length");
            if ((bti is null) || (bti.Type != BTChunk.kInteger))
            {
                return(false);
            }

            long pieceSize = ((BTInteger)bti).Value;

            bti = infoDict.GetItem("pieces");
            if ((bti is null) || (bti.Type != BTChunk.kString))
            {
                return(false);
            }

            BTString torrentPieces = (BTString)(bti);

            bti = infoDict.GetItem("files");

            if (bti is null) // single file torrent
            {
                bti = infoDict.GetItem("name");
                if ((bti is null) || (bti.Type != BTChunk.kString))
                {
                    return(false);
                }

                BTString di            = (BTString)(bti);
                string   nameInTorrent = di.AsString();

                BTItem fileSizeI = infoDict.GetItem("length");
                long   fileSize  = ((BTInteger)fileSizeI).Value;

                NewTorrentEntry(torrentFile, -1);
                if (DoHashChecking)
                {
                    byte[] torrentPieceHash = torrentPieces.StringTwentyBytePiece(0);

                    FileInfo fi = FindLocalFileWithHashAt(torrentPieceHash, 0, pieceSize, fileSize);
                    if (fi != null)
                    {
                        FoundFileOnDiskForFileInTorrent(torrentFile, fi, -1, nameInTorrent);
                    }
                    else
                    {
                        DidNotFindFileOnDiskForFileInTorrent(torrentFile, -1, nameInTorrent);
                    }
                }

                FinishedTorrentEntry(torrentFile, -1, nameInTorrent);

                // don't worry about updating overallPosition as this is the only file in the torrent
            }
            else
            {
                long overallPosition   = 0;
                long lastPieceLeftover = 0;

                if (bti.Type != BTChunk.kList)
                {
                    return(false);
                }

                BTList fileList = (BTList)(bti);

                // list of dictionaries
                for (int i = 0; i < fileList.Items.Count; i++)
                {
                    Prog(100 * i / fileList.Items.Count, i.ToString());
                    if (fileList.Items[i].Type != BTChunk.kDictionary)
                    {
                        return(false);
                    }

                    BTDictionary file    = (BTDictionary)(fileList.Items[i]);
                    BTItem       thePath = file.GetItem("path");
                    if (thePath.Type != BTChunk.kList)
                    {
                        return(false);
                    }

                    BTList pathList = (BTList)(thePath);
                    // want the last of the items in the list, which is the filename itself
                    int n = pathList.Items.Count - 1;
                    if (n < 0)
                    {
                        return(false);
                    }

                    BTString fileName = (BTString)(pathList.Items[n]);

                    BTItem fileSizeI = file.GetItem("length");
                    long   fileSize  = ((BTInteger)fileSizeI).Value;

                    int pieceNum = (int)(overallPosition / pieceSize);
                    if (overallPosition % pieceSize != 0)
                    {
                        pieceNum++;
                    }

                    NewTorrentEntry(torrentFile, i);

                    if (DoHashChecking)
                    {
                        byte[] torrentPieceHash = torrentPieces.StringTwentyBytePiece(pieceNum);

                        FileInfo fi = FindLocalFileWithHashAt(torrentPieceHash, lastPieceLeftover, pieceSize, fileSize);
                        if (fi != null)
                        {
                            FoundFileOnDiskForFileInTorrent(torrentFile, fi, i, fileName.AsString());
                        }
                        else
                        {
                            DidNotFindFileOnDiskForFileInTorrent(torrentFile, i, fileName.AsString());
                        }
                    }

                    FinishedTorrentEntry(torrentFile, i, fileName.AsString());

                    int sizeInPieces = (int)(fileSize / pieceSize);
                    if (fileSize % pieceSize != 0)
                    {
                        sizeInPieces++; // another partial piece
                    }
                    lastPieceLeftover = (lastPieceLeftover + (int)((sizeInPieces * pieceSize) - fileSize)) % pieceSize;
                    overallPosition  += fileSize;
                } // for each file in the torrent
            }

            if (tvTree != null)
            {
                tvTree.BeginUpdate();
                btFile.Tree(tvTree.Nodes);
                tvTree.ExpandAll();
                tvTree.EndUpdate();
                tvTree.Update();
            }

            Prog(0, string.Empty);

            return(true);
        }
Пример #53
0
        public async Task <List <string> > ExpandModel(FileInfo modelFile)
        {
            string dtmi = ParsingUtils.GetRootId(modelFile);

            return(await ExpandModel(dtmi));
        }
Пример #54
0
        /// <summary>
        /// 저널파일 FTP 전송
        /// </summary>
        /// <returns></returns>
        private bool SetFTP()
        {
            bool   bReturn   = false;
            string strFtpMsg = string.Empty;

            SetMsgBar(osiMsgBar04, OpenItemStatus.None, strMsg16);

            try
            {
                string strServer = ConfigData.Current.AppConfig.PosFTP.FtpSvrIP1;
                string strUser   = ConfigData.Current.AppConfig.PosFTP.User;
                string strPass   = ConfigData.Current.AppConfig.PosFTP.Pass;
                string strPort   = ConfigData.Current.AppConfig.PosFTP.FtpComPort1;
                string strPath   = Path.Combine(
                    FXConsts.JOURNAL.GetFolder(),
                    string.Format("{0}-{1}-{2}.jrn", ConfigData.Current.AppConfig.PosInfo.SaleDate, ConfigData.Current.AppConfig.PosInfo.StoreNo, ConfigData.Current.AppConfig.PosInfo.PosNo)
                    );
                FileInfo fi = new FileInfo(strPath);

                if (fi.Exists)
                {
                    if (strServer.Length > 0 && strUser.Length > 0 && strPass.Length > 0 && strPort.Length > 0 && strPath.Length > 0)
                    {
                        FtpUtils ftp = new FtpUtils(strServer, strUser, strPass, 10, TypeHelper.ToInt32(strPort));

                        if (ftp.Login(out strFtpMsg))
                        {
                            //폴더 검사
                            string[] arrDir = ftp.GetFileList(string.Format("{0}", ConfigData.Current.AppConfig.PosFTP.JournalPath), out bReturn, out strFtpMsg);

                            if (bReturn)
                            {
                                if (arrDir.Length > 0)
                                {
                                    string strDir = string.Format("{0}/{1}", ConfigData.Current.AppConfig.PosFTP.JournalPath, ConfigData.Current.AppConfig.PosInfo.SaleDate);
                                    bool   bMake  = false;
                                    foreach (string strTemp in arrDir)
                                    {
                                        if (strTemp == strDir)
                                        {
                                            bMake = true;
                                            break;
                                        }
                                    }

                                    if (bMake)
                                    {
                                        //폴더존재시 이동
                                        bReturn = ftp.ChangeDir(strDir, out strFtpMsg);
                                    }
                                    else
                                    {
                                        bReturn = ftp.MakeDir(strDir, out strFtpMsg);
                                    }
                                }
                            }
                        }

                        if (bReturn)
                        {
                            for (int i = 0; i < 3; i++)
                            {
                                if (ftp.Upload(strPath, out strFtpMsg))
                                {
                                    ftp.Close();
                                    bReturn = true;
                                    break;
                                }
                            }
                        }
                    }
                }
                else
                {
                    bReturn = true;
                }

                if (!bReturn)
                {
                    string[] strBtnNm = new string[1];
                    strBtnNm[0] = WSWD.WmallPos.FX.Shared.ConfigData.Current.SysMessage.GetMessage("00045");
                    //strBtnNm[1] = WSWD.WmallPos.FX.Shared.ConfigData.Current.SysMessage.GetMessage("00190");

                    //LogUtils.Instance.LogException(strFtpMsg);

                    //if (ShowMessageBox(MessageDialogType.Warning, null, strMsg22, strBtnNm) == DialogResult.Yes)
                    //{

                    //}

                    ShowMessageBox(MessageDialogType.Warning, null, strMsg22, strBtnNm);

#if DEBUG
                    m_ftpFailedCount++;
                    if (m_ftpFailedCount >= MAX_FTP_COUNT)
                    {
                        bReturn = true;
                    }
                    else
                    {
                        bReturn = SetFTP();
                    }
#else
                    bReturn = SetFTP();
#endif
                    //else
                    //{
                    //    bReturn = false;
                    //    //ChildManager.ShowProgress(false);
                    //    //SetControlDisable(false);

                    //    ////화면 종료
                    //    //this.DialogResult = DialogResult.Cancel;

                    //    //if (!_bAuto)
                    //    //{
                    //    //    //시스템 종료
                    //    //    InitiateSystemShutdown("\\\\127.0.0.1", null, 0, false, false);
                    //    //}
                    //}
                }
            }
            catch (Exception ex)
            {
                LogUtils.Instance.LogException(ex);
            }
            finally
            {
                SetMsgBar(osiMsgBar04, bReturn ? OpenItemStatus.OK : OpenItemStatus.Error, bReturn ? strMsg17 : strMsg18);
            }

            return(bReturn);
        }
Пример #55
0
        public void Show()
        {
            Data_Emp = new Dictionary <string, Employer>();
            FileInfo fi2 = new FileInfo("emps.dat");
            FileInfo fi3 = new FileInfo("pers.xml");

            if (fi2.Exists | fi3.Exists)
            {
                if (Config == "binary")
                {
                    BinaryFormatter bf2 = new BinaryFormatter();
                    using (FileStream fs = new FileStream("emps.dat", FileMode.Open))
                    {
                        Dictionary <string, Employer> data = new Dictionary <string, Employer>();
                        data     = (Dictionary <string, Employer>)bf2.Deserialize(fs);
                        Data_Emp = data;
                    }
                }
                else if (Config == "xml")
                {
                    //    XmlSerializer xs_2 = new XmlSerializer(typeof(Dictionary<string, Employer>));
                    //    using (FileStream fs_2 = new FileStream("emps.xml", FileMode.OpenOrCreate))
                    //    {
                    //        Dictionary<string, Employer> data_xml = new Dictionary<string, Employer>();
                    //        xs_2.Serialize(fs_2, data_xml);
                    //    }
                }
                else
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("В конфигурационном файле option.ini указаны некорректные данные - {0}", Config);
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    Console.WriteLine("Выполняется запись по умолчанию (binary) в конфигурационный файл option.ini...");
                    Thread.Sleep(2000);
                    using (FileStream fstream2 = new FileStream("option.ini", FileMode.Truncate))
                    {
                        string text  = "binary";
                        byte[] array = Encoding.Default.GetBytes(text);
                        fstream2.Write(array, 0, array.Length);
                    }
                    Console.WriteLine("Конфигурационные данные перезаписаны!");
                    Console.ResetColor();
                    Show();
                }
            }
            else
            {
                Console.WriteLine("Отсутвует файл для десеарилации emps.dat или pers.xml. Данные с последнего сеанса не загружены!\n");
            }

            while (true)
            {
                Console.ForegroundColor = ConsoleColor.Blue;
                Console.WriteLine("\nКол-во сотрудников в базе: {0}", Data_Emp.Count);
                Console.ResetColor();
                Console.WriteLine("\nБаза данных о сотрудниках фирмы\n");
                Console.Write("Введите команду: ");
                try
                {
                    string command = Console.ReadLine();
                    Console.Clear();
                    switch (command.ToLower())
                    {
                    case "add":
                        Console.WriteLine("Введите уникальный № ID:");
                        string id2 = Console.ReadLine();
                        Console.WriteLine("Введите имя:");
                        string name2 = Console.ReadLine();
                        Console.WriteLine("Введите возраст:");
                        int age2 = Convert.ToInt32(Console.ReadLine());
                        Console.WriteLine("Введите название фирмы:");
                        string company2 = Console.ReadLine();
                        Console.WriteLine("Введите должность:");
                        string post2 = Console.ReadLine();
                        Data_Emp.Add(id2, new Employer(name2, age2, company2, post2));
                        Console.ForegroundColor = ConsoleColor.DarkGreen;
                        Console.WriteLine("\nДобавлена запись");
                        ShowInfo_ID(id2);
                        Thread.Sleep(2000);
                        Console.ResetColor();
                        Console.Clear();
                        break;

                    case "info":
                        Console.Clear();
                        Console.ForegroundColor = ConsoleColor.DarkGray;
                        Console.WriteLine("\nВыполнение запроса...");
                        Thread.Sleep(1100);
                        Console.Clear();
                        ShowInfo();
                        Console.ResetColor();
                        break;

                    case "del":
                        Console.Clear();
                        ShowInfo();
                        Console.WriteLine("\nВведите ID для удаления:");
                        string num = Console.ReadLine();
                        Data_Emp.Remove(num);
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine("ID {0} удалена из списка", num);
                        Console.ResetColor();
                        break;

                    case "info_id":
                        foreach (KeyValuePair <string, Employer> p in Data_Emp)
                        {
                            Console.ForegroundColor = ConsoleColor.Magenta;
                            Console.Write("id  " + p.Key + " - ");
                            Console.ResetColor();
                            Console.WriteLine(p.Value.Post);
                        }
                        Console.WriteLine("\nВведите ID сотрудника:");
                        string id3 = Console.ReadLine();
                        ShowInfo_ID(id3);
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine("\nКоманда выполнена");
                        Console.ResetColor();
                        break;

                    default:
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        Console.WriteLine("\nДоступные команды:\n \nadd - добавить запись \ndel - удалить запись ");
                        Console.WriteLine("info - посмотреть записи о всех сотрудниках \ninfo_id - посмотреть запись о конктретном сотруднике");
                        Console.WriteLine("exit - выйти из программы. Данные сохранятся автоматически");
                        Console.WriteLine("exit* - выйти из программы без сохранения");
                        Console.ResetColor();
                        break;

                    case "exit":
                        Dictionary <string, Employer> empl_2 = new Dictionary <string, Employer> ();
                        empl_2 = /*employers*/ Data_Emp;
                        if (Config == "binary")
                        {
                            BinaryFormatter bf = new BinaryFormatter();
                            using (FileStream fs = new FileStream("emps.dat", FileMode.OpenOrCreate))
                            {
                                bf.Serialize(fs, empl_2);
                                Console.ForegroundColor = ConsoleColor.Green;
                                Console.WriteLine("Данные сохранены (сериализованы через BinaryFormatter)");
                                Console.WriteLine("Сеанс окончен! До свидания!\n");
                            }
                        }
                        else if (Config == "xml")
                        {
                            XmlSerializer xs = new XmlSerializer(typeof(Dictionary <string, Employer>));
                            using (FileStream fs_2 = new FileStream("pers.xml", FileMode.OpenOrCreate))
                            {
                                xs.Serialize(fs_2, empl_2);
                                Console.WriteLine("Данные сохранены (сериализованы через XmlSerializer)");
                                Console.WriteLine("Сеанс окончен! До свидания!\n");
                            }
                        }
                        return;

                    case "exit*":
                        Console.WriteLine("Сеанс окончен! До свидания!\n");
                        return;
                    }
                }
                catch (Exception e)
                {
                    Console.ForegroundColor = ConsoleColor.DarkRed;
                    Console.WriteLine("Ошибка ввода \n" + e);
                    Console.ResetColor();
                }
            }
        }
Пример #56
0
        /// <summary>
        /// Extract an entry from the archive. This method assumes that the
        /// tarIn stream has been properly set with a call to GetNextEntry().
        /// </summary>
        /// <param name="destDir">
        /// The destination directory into which to extract.
        /// </param>
        /// <param name="entry">
        /// The TarEntry returned by tarIn.GetNextEntry().
        /// </param>
        void ExtractEntry(string destDir, TarEntry entry)
        {
            OnProgressMessageEvent(entry, null);

            string name = entry.Name;

            if (Path.IsPathRooted(name) == true)
            {
                // NOTE:
                // for UNC names...  \\machine\share\zoom\beet.txt gives \zoom\beet.txt
                name = name.Substring(Path.GetPathRoot(name).Length);
            }

            name = name.Replace('/', Path.DirectorySeparatorChar);

            string destFile = Path.Combine(destDir, name);

            if (entry.IsDirectory)
            {
                EnsureDirectoryExists(destFile);
            }
            else
            {
                string parentDirectory = Path.GetDirectoryName(destFile);
                EnsureDirectoryExists(parentDirectory);

                bool     process  = true;
                FileInfo fileInfo = new FileInfo(destFile);
                if (fileInfo.Exists)
                {
                    if (this.keepOldFiles)
                    {
                        OnProgressMessageEvent(entry, "Destination file already exists");
                        process = false;
                    }
                    else if ((fileInfo.Attributes & FileAttributes.ReadOnly) != 0)
                    {
                        OnProgressMessageEvent(entry, "Destination file already exists, and is read-only");
                        process = false;
                    }
                }

                if (process)
                {
                    bool asciiTrans = false;

                    Stream outputStream = File.Create(destFile);
                    if (this.asciiTranslate)
                    {
                        asciiTrans = !IsBinary(destFile);
                    }

                    StreamWriter outw = null;
                    if (asciiTrans)
                    {
                        outw = new StreamWriter(outputStream);
                    }

                    byte[] rdbuf = new byte[32 * 1024];

                    while (true)
                    {
                        int numRead = this.tarIn.Read(rdbuf, 0, rdbuf.Length);

                        if (numRead <= 0)
                        {
                            break;
                        }

                        if (asciiTrans)
                        {
                            for (int off = 0, b = 0; b < numRead; ++b)
                            {
                                if (rdbuf[b] == 10)
                                {
                                    string s = Encoding.ASCII.GetString(rdbuf, off, (b - off));
                                    outw.WriteLine(s);
                                    off = b + 1;
                                }
                            }
                        }
                        else
                        {
                            outputStream.Write(rdbuf, 0, numRead);
                        }
                    }

                    if (asciiTrans)
                    {
                        outw.Close();
                    }
                    else
                    {
                        outputStream.Close();
                    }
                }
            }
        }
Пример #57
0
        /// <summary>
        /// Gets the item image infos.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <returns>Task{List{ImageInfo}}.</returns>
        public async Task<List<ImageInfo>> GetItemImageInfos(BaseItem item)
        {
            var list = new List<ImageInfo>();

            foreach (var image in item.Images)
            {
                var path = image.Value;

                var fileInfo = new FileInfo(path);

                var dateModified = Kernel.Instance.ImageManager.GetImageDateModified(item, path);

                var size = await Kernel.Instance.ImageManager.GetImageSize(path, dateModified).ConfigureAwait(false);

                list.Add(new ImageInfo
                {
                    Path = path,
                    ImageType = image.Key,
                    ImageTag = Kernel.Instance.ImageManager.GetImageCacheTag(item, image.Key, path),
                    Size = fileInfo.Length,
                    Width = Convert.ToInt32(size.Width),
                    Height = Convert.ToInt32(size.Height)
                });
            }

            var index = 0;

            foreach (var image in item.BackdropImagePaths)
            {
                var fileInfo = new FileInfo(image);

                var dateModified = Kernel.Instance.ImageManager.GetImageDateModified(item, image);

                var size = await Kernel.Instance.ImageManager.GetImageSize(image, dateModified).ConfigureAwait(false);

                list.Add(new ImageInfo
                {
                    Path = image,
                    ImageIndex = index,
                    ImageType = ImageType.Backdrop,
                    ImageTag = Kernel.Instance.ImageManager.GetImageCacheTag(item, ImageType.Backdrop, image),
                    Size = fileInfo.Length,
                    Width = Convert.ToInt32(size.Width),
                    Height = Convert.ToInt32(size.Height)
                });

                index++;
            }

            index = 0;

            foreach (var image in item.ScreenshotImagePaths)
            {
                var fileInfo = new FileInfo(image);

                var dateModified = Kernel.Instance.ImageManager.GetImageDateModified(item, image);

                var size = await Kernel.Instance.ImageManager.GetImageSize(image, dateModified).ConfigureAwait(false);

                list.Add(new ImageInfo
                {
                    Path = image,
                    ImageIndex = index,
                    ImageType = ImageType.Screenshot,
                    ImageTag = Kernel.Instance.ImageManager.GetImageCacheTag(item, ImageType.Screenshot, image),
                    Size = fileInfo.Length,
                    Width = Convert.ToInt32(size.Width),
                    Height = Convert.ToInt32(size.Height)
                });

                index++;
            }

            var video = item as Video;

            if (video != null)
            {
                index = 0;

                foreach (var chapter in _itemRepo.GetChapters(video.Id))
                {
                    if (!string.IsNullOrEmpty(chapter.ImagePath))
                    {
                        var image = chapter.ImagePath;

                        var fileInfo = new FileInfo(image);

                        var dateModified = Kernel.Instance.ImageManager.GetImageDateModified(item, image);

                        var size = await Kernel.Instance.ImageManager.GetImageSize(image, dateModified).ConfigureAwait(false);

                        list.Add(new ImageInfo
                        {
                            Path = image,
                            ImageIndex = index,
                            ImageType = ImageType.Chapter,
                            ImageTag = Kernel.Instance.ImageManager.GetImageCacheTag(item, ImageType.Chapter, image),
                            Size = fileInfo.Length,
                            Width = Convert.ToInt32(size.Width),
                            Height = Convert.ToInt32(size.Height)
                        });
                    }

                    index++;
                }
            }

            return list;
        }
Пример #58
0
        private void DoWork(object data)
        {
            var tuple      = (Tuple <string, string, bool, bool, int?, bool>)data;
            var srcDir     = tuple.Item1;
            var tgtDir     = tuple.Item2;
            var isWCacheOn = tuple.Item3;
            var isRcacheOn = tuple.Item4;
            var count      = tuple.Item5;
            var isAutoExit = tuple.Item6;

            var MyCounter = MakeCounter();
            var files     = Directory.GetFiles(srcDir);

            while (true)
            {
                this.Invoke(new Action(() => lbCount.Text = MyCounter().ToString()));
                foreach (var file in files)
                {
                    var srcFileInfo = new FileInfo(file);
                    var tgtFileInfo = new FileInfo(Path.Combine(tgtDir, srcFileInfo.Name));

                    try
                    {
                        #region COPY

                        // update status to copy
                        this.Invoke(new Action(() => tbStatusInfo.Text = TM.Translate("copy:") + srcFileInfo.Name));

                        // copy
                        using (var readStream = new FileStream(srcFileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.
                                                               ReadWrite, 4096, isRcacheOn ? FileOptions.None : (FileOptions)0x20000000))
                            using (var writeStream = new FileStream(tgtFileInfo.FullName, FileMode.Create,
                                                                    FileAccess.ReadWrite, FileShare.ReadWrite, 4096, isWCacheOn ? FileOptions.None : FileOptions.WriteThrough))
                            {
                                int  c     = -1;
                                long bytes = 0;
                                while ((c = readStream.ReadByte()) != -1)
                                {
                                    writeStream.WriteByte((byte)c);
                                    // show copy progress when file is greater than 200MB
                                    if (++bytes % (1024 * 1024) == 0 && readStream.Length > 1024 * 1024 * 200)
                                    {
                                        var length = readStream.Length;
                                        this.BeginInvoke(new Action(() => UpdateAppStatus("copied:",
                                                                                          string.Format("{0:d}M / {1:d}M", bytes / 1024 / 1024, length / 1024 / 1024),
                                                                                          false)));
                                    }
                                }
                                // clean app status
                                this.Invoke(new Action(() => lbStatus.Text = ""));
                            }


                        #endregion

                        #region COMPARE

                        // update status to compare
                        this.Invoke(new Action(() => tbStatusInfo.Text = TM.Translate("compare:") + srcFileInfo.Name));
                        // compare
                        CompareMd5(srcFileInfo, tgtFileInfo);
                        #endregion

                        #region DELETE
                        // update status to delete
                        this.Invoke(new Action(() => tbStatusInfo.Text = TM.Translate("delete:") + srcFileInfo.Name));
                        // delete
                        tgtFileInfo.Delete();
                    }
                    catch (ThreadAbortException)
                    {
                        return;
                    }
                    catch (Exception e)
                    {
                        // raise the error messagebox at main thread to block the UI (Modal)
                        if ((bool)this.Invoke(new Func <bool>(() => AskWhetherContinue(e.Message))))
                        {
                            continue;
                        }
                        else
                        {
                            // prepare ending this thread
                            this.Invoke(new Action(() => this.UpdateControls(WorkState.WaitingStartForcely)));
                            return;
                        }
                    }
                    #endregion
                }
                // since count is nullable type following is necessary
                // if (count == null) continue;
                count--;
                if (count == 0)
                {
                    break;
                }
            }
            // prepare ending this thread
            this.Invoke(new Action(() => elapsedTimer.Stop()));
            this.Invoke(new Action(() => this.UpdateControls(WorkState.WaitingStart)));

            // end main thread if necessary
            // COMMENT
            // Invoke method is blocking. If the working thread is foreground,
            // following code fails (different to BeginInvoke() method)
            if (isAutoExit)
            {
                this.Invoke(new Action(() => this.UpdateAppStatus("app_info_1")));
                this.BeginInvoke(new Action(() => this.exitTimer.Start()));
            }
        }
Пример #59
0
        private void ProcessJob(JobInfo jobInfo)
        {
            // Debug.LogFormat("processing job: {0} ({1})", jobInfo.name, jobInfo.comment);
            var tempPath = jobInfo.path + PartExt;

            if (_fileStream != null)
            {
                _fileStream.Close();
                _fileStream = null;
            }

            var dataChecker = GetDataChecker(jobInfo);

            while (true)
            {
                string error       = null;
                var    partialSize = 0;
                var    success     = true;
                var    wsize       = jobInfo.size;
                var    wchecksum   = jobInfo.checksum;
                var    url         = GetUrl(jobInfo);
                dataChecker.Reset();
                if (_fileStream == null)
                {
                    try
                    {
                        var fileInfo = new FileInfo(tempPath);
                        if (fileInfo.Exists) // 处理续传
                        {
                            _fileStream = fileInfo.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite);
                            partialSize = (int)fileInfo.Length;
                            if (partialSize > jobInfo.size) // 目标文件超过期望大小, 直接废弃
                            {
                                _fileStream.SetLength(0);
                                partialSize = 0;
                            }
                            else if (partialSize <= jobInfo.size) // 续传
                            {
                                dataChecker.Update(_fileStream);
                                // Debug.LogFormat("partial check {0} && {1} ({2})", partialSize, jobInfo.size,
                                //     dataChecker.hex);
                            }
                        }
                        else // 创建下载文件
                        {
                            if (!Directory.Exists(fileInfo.DirectoryName))
                            {
                                Directory.CreateDirectory(fileInfo.DirectoryName);
                            }

                            _fileStream = File.Open(tempPath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
                            _fileStream.SetLength(0);
                        }
                    }
                    catch (Exception exception)
                    {
                        // ResourceManager.logger.OnTaskError(jobInfo, exception);
                        error   = string.Format("file exception: {0}", exception);
                        success = false;
                    }
                }
                else
                {
                    _fileStream.SetLength(0L);
                }

                if (success && (jobInfo.size <= 0 || partialSize < jobInfo.size))
                {
                    try
                    {
                        var uri = new Uri(url);
                        var req = WebRequest.CreateHttp(uri);
                        req.Method      = WebRequestMethods.Http.Get;
                        req.ContentType = BundleContentType;
                        // req.ReadWriteTimeout = 10000;
                        if (_timeout > 0)
                        {
                            req.Timeout = _timeout;
                        }

                        if (partialSize > 0)
                        {
                            req.AddRange(partialSize);
                        }

                        using (var rsp = req.GetResponse())
                        {
                            using (var webStream = rsp.GetResponseStream())
                            {
                                var recvAll   = 0L;
                                var recvCalc  = 0L;
                                var stopwatch = new Stopwatch();
                                stopwatch.Start();
                                while (recvAll < rsp.ContentLength)
                                {
                                    var _bpms = Math.Max(1, jobInfo.bytesPerSecond / 10);
                                    var recv  = webStream.Read(_buffer, 0, Math.Min(_bpms, _buffer.Length));
                                    if (recv > 0 && !_destroy)
                                    {
                                        recvCalc += recv;
                                        if (recvCalc >= _bpms)
                                        {
                                            var millisecs = stopwatch.ElapsedMilliseconds;
                                            var delay     = (int)(100.0 * recvCalc / _bpms - millisecs);
                                            // Debug.LogFormat("net ++ {0} {1} sbps {2} recv {3}", delay, millisecs, _bpms, recvCalc);
                                            if (delay > 0)
                                            {
                                                Thread.Sleep(delay);
                                            }
                                            stopwatch.Restart();
                                            recvCalc -= _bpms;
                                        }
                                        recvAll += recv;
                                        _fileStream.Write(_buffer, 0, recv);
                                        dataChecker.Update(_buffer, 0, recv);
                                        jobInfo.bytes = (int)(recvAll + partialSize);
                                        // PrintDebug($"{recvAll + partialSize}, {_size}, {_progress}");
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    catch (Exception exception)
                    {
                        // ResourceManager.logger.OnTaskError(jobInfo, exception);
                        // Debug.LogErrorFormat("network exception: {0}\n{1}", url, exception);
                        error   = string.Format("network exception: {0}", exception);
                        success = false;
                    }
                }

                if (success && _fileStream.Length != jobInfo.size)
                {
                    if (jobInfo.size > 0)
                    {
                        error = string.Format("filesize exception: {0} != {1}", _fileStream.Length, jobInfo.size);
                        // Debug.LogError(error);
                        // ResourceManager.logger.OnTaskError(jobInfo, error);
                        success = false;
                    }
                    else
                    {
                        wsize = (int)_fileStream.Length;
                    }
                }

                if (success)
                {
                    // dirty code, md5 目前不能分段计算
                    if (dataChecker.hex == null)
                    {
                        _fileStream.Seek(0, SeekOrigin.Begin);
                        dataChecker.ComputeHashFull(_fileStream);
                    }

                    if (dataChecker.hex != jobInfo.checksum)
                    {
                        if (!string.IsNullOrEmpty(jobInfo.checksum))
                        {
                            error = string.Format("corrupted file: {0} != {1}", dataChecker.hex, jobInfo.checksum);
                            // Debug.LogError(error);
                            // ResourceManager.logger.OnTaskError(jobInfo, error);
                            success = false;
                        }
                        else
                        {
                            wchecksum = dataChecker.hex;
                        }
                    }
                }

                if (_destroy)
                {
                    success = false;
                }

                // close fileStream anyway
                try
                {
                    if (_fileStream != null)
                    {
                        _fileStream.Close();
                        _fileStream = null;
                    }
                }
                catch (Exception)
                {
                }

                if (success)
                {
                    try
                    {
                        // _WriteStream(buffer, fileStream, finalPath);
                        if (File.Exists(jobInfo.path))
                        {
                            File.Delete(jobInfo.path);
                        }

                        File.Move(tempPath, jobInfo.path);
                        // 写入额外的 meta
                        var meta = new Metadata()
                        {
                            checksum = wchecksum,
                            size     = wsize,
                        };
                        var json     = JsonUtility.ToJson(meta);
                        var metaPath = jobInfo.path + Metadata.Ext;
                        File.WriteAllText(metaPath, json);
                        Complete(jobInfo);
                        break;
                    }
                    catch (Exception exception)
                    {
                        error = string.Format("write exception: {0}", exception);
                        // Debug.LogError(error);
                        // ResourceManager.logger.OnTaskError(jobInfo, error);
                        success = false;
                    }
                }

                jobInfo.tried++;
                if (jobInfo.retry > 0 && jobInfo.tried >= jobInfo.retry)
                {
                    jobInfo.error = error ?? "unknown error";
                    Complete(jobInfo);
                    break;
                }

                ResourceManager.logger.OnTaskError(jobInfo, error);
                Thread.Sleep(1000);
                // Debug.LogErrorFormat("[retry] download failed: {0}\n{1}", url, error);
            }
        }
Пример #60
0
 protected abstract IEnumerable <TVolume> LoadVolumes(FileInfo file);