Ejemplo n.º 1
0
        public FileObject AddFile(string relativeFileName, Stream fileContent, FileOption fileOption, int bufferSize)
        {
            var file = new FileObject(FullName + relativeFileName);

            file.Write(fileContent, fileOption, bufferSize);
            return(file);
        }
 /// <inheritdoc />
 public void SerializeToFile <T>(T obj, string file, FileOption mode) where T : class
 {
     obj.IsNullThrow(nameof(obj));
     file.IsNullThrow(nameof(file));
     mode.IsNullThrow(nameof(mode));
     SerializeToFile(obj, typeof(T), file, mode);
 }
Ejemplo n.º 3
0
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="gpt2FilePath"></param>
        public Gpt2DataService(FileOption gpt2FilePath)
            : base(gpt2FilePath)
        {
            Gpt2File = new Gpt2FileReader(this.Option.FilePath).Read();

            Data = new Dictionary <string, Gpt2Res>();
        }
Ejemplo n.º 4
0
 public void Add(string fileFullPath, FileOption option = FileOption.Overwrite, WriterOptions writerOptions = null)
 {
     Add(new List <string>()
     {
         fileFullPath
     }, option, writerOptions);
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Prepares for stream use.  Prevents Exeception From Being Throwned When working with file Streams
        /// </summary>
        /// <param name="option">The option.</param>
        /// <exception cref="ArgumentOutOfRangeException">option - null</exception>
        internal void PrepareForStreamUse(FileOption option)
        {
            switch (option)
            {
            case FileOption.Append:
                CreateOrTruncate(false);
                break;

            case FileOption.Overwrite:
                CreateOrTruncate();
                break;

            case FileOption.DoNothingIfExist:
                if (Exist == true)
                {
                    return;
                }
                CreateOrTruncate();
                break;

            case FileOption.IncrementFileNameIfExist:
            case FileOption.IncrementFileExtensionIfExist:

                break;

            case FileOption.ReadOnly:
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(option), option, null);
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="gpt2FilePath"></param>
        public Gpt2DataService1Degree(FileOption gpt2FilePath)
            : base(gpt2FilePath)
        {
            gpt2File1Degree = new Gpt2FileReader1Degree(this.Option.FilePath).Read();

            Data = new ConcurrentDictionary <string, Gpt2Res1Degree>();
        }
Ejemplo n.º 7
0
        /// <inheritdoc />
        /// <summary>
        /// Serializes to file.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list">The list.</param>
        /// <param name="fullFilePath">The full file path.</param>
        /// <param name="mode">The mode.</param>
        public void SerializeToFile <T>(IEnumerable <T> list, string fullFilePath, FileOption option) where T : class
        {
            list.IsNullThrow(nameof(list));
            fullFilePath.IsNullThrow(nameof(fullFilePath));
            option.IsNullThrow(nameof(option));
            var a = new FileObject(fullFilePath);

            if (option == FileOption.DoNothingIfExist)
            {
                if (a.Exist == true)
                {
                    return;
                }
            }
            using (var sw = a.GetStreamWriter(false))
            {
                var csv = new CsvWriter(sw, Configuration);
                csv.WriteRecords(list);
            }

            // using (var stream = a.GetFileStream(mode))
            // {
            //     SerializeToStream(list, stream);
            // }
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Returns a dictionary where file names are
        /// used as keys, and absolute file paths are
        /// values.
        /// </summary>
        ///
        /// <exception cref="FileNotFoundException"/>
        ///
        /// <exception cref="ArgumentException">
        public virtual ReadOnlyDictionary <string, string> GetIncludeItems(ReferenceType type)
        {
            FileOption option = GetFileOption(type);

            Dictionary <string, string> output = new
                                                 Dictionary <string, string>(30);

            foreach (string directory in option.Include)
            {
                if (!Directory.Exists(directory))
                {
                    MessageHelper.AddMessage($"Directory: { directory } does not exist and will be skipped", TaskErrorCategory.Warning);

                    continue;
                }

                foreach (string absolutePath in Directory.GetFiles(directory, option.Pattern, SearchOption.AllDirectories).Where(i => !Contains(option.Exclude, i)))
                {
                    string key = Path.GetFileNameWithoutExtension(absolutePath);

                    if (!output.ContainsKey(key))
                    {
                        output.Add(key, absolutePath);
                    }
                    else
                    {
                        MessageHelper.AddMessage($"Project: { absolutePath } is a duplicate and will be skipped", TaskErrorCategory.Warning);
                    }
                }
            }

            return(new ReadOnlyDictionary <string, string>(output));
        }
Ejemplo n.º 9
0
        /// <summary>
        /// 构造函数。可以指定文件路径,但此处并不读取,。
        /// </summary>
        /// <param name="filePath"></param>
        public SphericalHarmonicsService(FileOption filePath)
        {
            var reader = new SphericalHarmonicsReader(filePath);

            this.File = reader.Read();
            Name      = Path.GetFileName(filePath.FilePath);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// 构造函数。可以指定文件路径,但此处并不读取,需要调用Read()方法才读取。
        /// </summary>
        /// <param name="filePath"></param>
        public SatExcludeFileService(FileOption filePath) : base(filePath)
        {
            SatExcludeReader reader = new SatExcludeReader(filePath);

            reader.Read();
            this.ExcludeSats = reader.ExcludeSats;
        }
Ejemplo n.º 11
0
 public void Add(FileObject fileObject, FileOption option = FileOption.Overwrite, WriterOptions writerOptions = null)
 {
     Add(new List <FileObject>()
     {
         fileObject
     }, option, writerOptions);
 }
Ejemplo n.º 12
0
 /// <summary>
 /// 卫星状态数据源
 /// </summary>
 /// <param name="filePath">文件路径</param>
 public SatInfoService(FileOption filePath) :
     base(filePath)
 {
     if (filePath != null)
     {
         this.SatInfoFile = new SatInfoReader(filePath.FilePath).Read();
     }
 }
Ejemplo n.º 13
0
 /// <summary>
 /// 天线数据源。
 /// </summary>
 /// <param name="antennaPath">天线文件路径</param>
 public AntennaFileService(FileOption antennaPath)
     : base(antennaPath)
 {
     this.Option            = antennaPath;
     this.antexReader       = new AntexReader(antennaPath.FilePath);
     this.typedBuffer       = new Dictionary <string, Antenna>();
     this.serialEpochBuffer = new Dictionary <string, Dictionary <BufferedTimePeriod, Antenna> >();
 }
Ejemplo n.º 14
0
 /// <summary>
 /// Changes the extension of the current file. Does nothing if file doesn't exist return boolean on whether or not the file extension actually got change
 ///
 /// </summary>
 /// <param name="newExtension"></param>
 /// <param name="option"></param>
 /// <param name="cancellationToken"></param>
 /// <param name="bufferSize"></param>
 /// <exception cref="Exception"></exception>
 /// <exception cref="UnauthorizedAccessException"> throws if the application doesn't have the required permission </exception>
 public async Task <bool> ChangeExtensionAsync(string newExtension, FileOption option, CancellationToken cancellationToken = default, int bufferSize = 4096)
 {
     if (newExtension == null)
     {
         throw new NullReferenceException($"Could not change the extension of file {FullName} Because Developer Provided A Null Value");
     }
     return(await MoveToAsync(Path.ChangeExtension(FullName, newExtension), option, cancellationToken, bufferSize));
 }
Ejemplo n.º 15
0
        public FileObject AddFile(string relativeFileName, byte[] fileContent, FileOption fileOption, int offset = 0,
                                  int?count = null)
        {
            var file = new FileObject(FullName + relativeFileName);

            file.Write(fileContent, fileOption, offset, count);
            return(file);
        }
Ejemplo n.º 16
0
        ///// <summary>
        ///// Sets the file attribute.
        ///// </summary>
        ///// <param name="option">The option.</param>
        ///// <param name="list">The list.</param>
        //public void SetFolderAttribute(AddOrRemoveEnum option, List<FileAttributes> list)
        //{

        //	if (Exist != true)
        //		return;
        //	try
        //	{
        //		if (option == AddOrRemoveEnum.Add)
        //		{
        //			foreach (var attr in list)
        //			{
        //				var di = new DirectoryInfo(FullName);
        //				di.Attributes &= ~attr;

        //			}

        //		}
        //		else if (option == AddOrRemoveEnum.Remove)
        //		{
        //			foreach (var attr in list)
        //			{
        //				var di = new DirectoryInfo(FullName);
        //				di.Attributes &= attr;
        //			}
        //		}
        //	}
        //	catch (Exception)
        //	{

        //		// ignored because this require the user to have full control permission set and we don't problems over that
        //		// if developer is doing something that require full conrol permission let the application throw the error
        //	}
        //}



        public FileObject AddFile(string relativeFileName, string fileContent, FileOption fileOption,
                                  Encoding encoding = null, int bufferSize = 4096)
        {
            var file = new FileObject(FullName + relativeFileName);

            file.Write(fileContent, fileOption, encoding, bufferSize);
            return(file);
        }
Ejemplo n.º 17
0
        /// <summary>
        /// 坐标服务
        /// </summary>
        public SiteCoordService(FileOption option)
        {
            this.FileOption    = option;
            this.Name          = Path.GetFileName(option.FilePath);
            this.NamedRmsXyzes = new BaseDictionary <string, NamedRmsXyz>();

            log.Info("启用了坐标文件服务。");
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Gets the file stream.
        /// </summary>
        /// <param name="option">The option.</param>
        /// <param name="bufferSize"></param>
        /// <param name="useAsync"></param>
        /// <returns>FileStream.</returns>
        /// <exception cref="ArgumentOutOfRangeException">option - null</exception>
        /// <exception cref="FileNotFoundException"></exception>
        public (FileStream fileStream, string fullName) GetFileStream(FileOption option, int bufferSize = 4096, bool useAsync = false)
        {
            var fileOptions = useAsync ? (FileOptions.Asynchronous | FileOptions.SequentialScan) : FileOptions.None;

            (FileStream fileStream, string fullName)stream;
            switch (option)
            {
            case FileOption.ReadOnly:
                stream = (new FileStream(FullName, FileMode.Open, FileAccess.Read, FileShare.Read), FullName);
                break;

            case FileOption.Append:
                PrepareForStreamUse(option);
                stream = GetFileStream(FileMode.Append, FileAccess.Write, FileShare.Read, bufferSize, fileOptions);
                if (stream.fileStream.CanSeek)
                {
                    stream.fileStream.Seek(0, SeekOrigin.End);
                }
                break;

            case FileOption.Overwrite:
                PrepareForStreamUse(option);
                stream = GetFileStream(FileMode.Truncate, FileAccess.Write, FileShare.Read, bufferSize, fileOptions);
                stream.fileStream.Seek(0, SeekOrigin.Begin);
                break;

            case FileOption.IncrementFileNameIfExist:
                stream = GetFileStream(FileMode.CreateNew, FileAccess.Write, FileShare.Read, bufferSize, fileOptions, true);
                stream.fileStream.Seek(0, SeekOrigin.Begin);
                break;

            case FileOption.IncrementFileExtensionIfExist:
                stream = GetFileStream(FileMode.CreateNew, FileAccess.Write, FileShare.Read, bufferSize, fileOptions, false, true);
                stream.fileStream.Seek(0, SeekOrigin.Begin);
                break;

            case FileOption.DoNothingIfExist:
                if (Exist)
                {
                    stream = GetFileStream(FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize, fileOptions);
                    stream.fileStream.Seek(0, SeekOrigin.Begin);
                    break;
                }
                else
                {
                    stream = GetFileStream(FileMode.CreateNew, FileAccess.Write, FileShare.Read, bufferSize, fileOptions);
                    if (stream.fileStream.CanSeek)
                    {
                        stream.fileStream.Seek(0, SeekOrigin.End);
                    }
                    break;
                }

            default:
                throw new ArgumentOutOfRangeException(nameof(option), option, null);
            }
            return(stream);
        }
Ejemplo n.º 19
0
        static void Main()
        {
            try
            {
                // load runsource.runsource.config.xml (config of runsource.runsource.exe)
                XmlConfig config = new XmlConfig();
                FormatInfo.SetInvariantCulture();
                Application.CurrentCulture = FormatInfo.CurrentFormat.CurrentCulture;
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                RemoteRunSource remoteRunSource = new RemoteRunSource();
                remoteRunSource.RunsourceDllFilename  = config.GetExplicit("RunsourceDllFilename");
                remoteRunSource.RunsourceClassName    = config.GetExplicit("RunsourceClassName");
                remoteRunSource.TraceManagerClassName = config.GetExplicit("TraceManagerClassName");
                remoteRunSource.TraceClassName        = config.GetExplicit("TraceClassName");
                // ATTENTION si CreateRunSourceDomain = true runsource.launch.exe ne peut pas mettre à jour runsource.runsource.exe
                remoteRunSource.CreateRunSourceDomain = config.Get("CreateRunSourceDomain").zTryParseAs <bool>(false);
                IRunSource runSource = remoteRunSource.GetRunSource();
                //remoteRunSource.LoadRunsourceCommand();
                //runSource.AllowMultipleExecution = config.Get("AllowMultipleExecution").zTryParseAs(false);
                ///////////////////////// donc il faut utiliser RemoteRunSource.GetTrace()
                //ITrace trace = remoteRunSource.GetTrace();
                //trace.SetWriter(config.Get("Log"), config.Get("Log/@option").zTextDeserialize(FileOption.None));

                // ATTENTION Trace exists in both 'runsource.runsource.exe' and 'runsource.dll'
                // both Trace are connected to TraceManager and can be used
                string     logFile       = config.Get("Log");
                FileOption logFileOption = config.Get("Log/@option").zTextDeserialize(FileOption.None);
                TraceManager.Current.AddTrace(Trace.Current);
                //TraceManager.Current.SetWriter(logFile, logFileOption);
                TraceManager.Current.SetWriter(WriteToFile.Create(logFile, logFileOption));

                ITraceManager remoteTraceManager = remoteRunSource.GetTraceManager();
                remoteTraceManager.AddTrace(remoteRunSource.GetTrace());
                //remoteTraceManager.SetWriter(logFile, logFileOption);
                remoteTraceManager.SetWriter(WriteToFile.Create(logFile, logFileOption));

                // ATTENTION appeler DeleteGeneratedAssemblies() après SetRunSourceConfig()
                //RunSourceForm form = new RunSourceForm(runSource, trace, config, GetRunSourceRestartParameters());
                //RunSourceForm_v3 form = new RunSourceForm_v3(runSource, trace, config, GetRunSourceRestartParameters());
                //RunSourceFormExe form = new RunSourceFormExe(runSource, trace, config, GetRunSourceRestartParameters());
                RunSourceFormExe form = new RunSourceFormExe(runSource, config, remoteRunSource, GetRunSourceRestartParameters());
                RunSourceFormExe.Current = form;

                form.SetRestartRunsource += FormSetRestartRunsource;
                Application.Run(form);

                TraceManager.Current.RemoveTrace(Trace.Current);
                TraceManager.Current.RemoveTrace(remoteRunSource.GetTrace());
                SetRunSourceRestartParameters();
            }
            catch (Exception ex)
            {
                zerrf.ErrorMessageBox(ex);
            }
        }
 public JsonTraceDataWriter(string file, FileOption option, Encoding encoding = null, JsonWriterSettings settings = null)
 {
     file = file.zRootPath(zapp.GetAppDirectory());
     if (option == FileOption.IndexedFile)
         file = zfile.GetNewIndexedFileName(zPath.GetDirectoryName(file), zPath.GetFileName(file));
     //_streamWriter = zFile.CreateText(file);
     Open(file, encoding, option != FileOption.RazFile);
     _closeStreamWriter = true;
     InitSettings(settings);
 }
Ejemplo n.º 21
0
        private async void LoadTextEncryptionButton_Click(object sender, RoutedEventArgs e)
        {
            var sourceTextFile = await FileOption.SelectTextSourceImageFile();

            if (sourceTextFile == null)
            {
                return;
            }
            this.readContentsofTheFile(sourceTextFile);
        }
Ejemplo n.º 22
0
 /// <summary>
 /// Writes the content to file. Returns the full file name content was written to. This method is not thread safe
 /// </summary>
 /// <param name="content">The content.</param>
 /// <param name="encoding">default to UTF-8</param>
 /// <param name="option">The option.</param>
 /// <param name="bufferSize"></param>
 public string Write(string content, FileOption option = FileOption.Overwrite, Encoding encoding = null, int bufferSize = 4096)
 {
     if (option == FileOption.DoNothingIfExist && Exist)
     {
         return(FullName);
     }
     var(fileStream, fullName) = GetFileStream(option);
     using var sw = new StreamWriter(fileStream, encoding ?? DefaultEncoding, bufferSize, false);
     sw.Write(content);
     return(fullName);
 }
Ejemplo n.º 23
0
 /// <summary>
 /// Writes the content to file. Returns the full file name content was written to. This method is not thread safe
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="progress">Report progress in stream bytes not percentages. </param>
 /// <param name="option">The option.</param>
 /// <param name="bufferSize"></param>
 public string Write(Stream stream, IProgress <long> progress, FileOption option = FileOption.Overwrite, int bufferSize = 4096)
 {
     if (option == FileOption.DoNothingIfExist && Exist)
     {
         return(FullName);
     }
     var(fileStream, fullName) = GetFileStream(option);
     using (fileStream)
         stream.CopyTo(fileStream, progress, bufferSize);
     return(fullName);
 }
Ejemplo n.º 24
0
        /// <summary>
        /// Copy the current file to the destination. Returns the destination file name
        /// </summary>
        /// <param name="copyToFullName"></param>
        /// <param name="option"></param>
        /// <param name="cancellationToken"></param>
        /// <param name="bufferSize"></param>
        /// <returns>The copy to file</returns>
        public async Task <string> CopyToAsync(string copyToFullName, FileOption option, CancellationToken cancellationToken = default, int bufferSize = 4096)
        {
            using var sourceStream = GetFileStream(FileOption.ReadOnly, bufferSize, true).fileStream;
            var fileStreamAndFileName = new FileObject(copyToFullName).GetFileStream(option, bufferSize, true);

            using (var destinationStream = fileStreamAndFileName.fileStream)
            {
                await sourceStream.CopyToAsync(destinationStream, bufferSize, cancellationToken)
                .ConfigureAwait(continueOnCapturedContext: false);
            }
            return(fileStreamAndFileName.fullName);
        }
Ejemplo n.º 25
0
 public JsonTraceDataWriter(string file, FileOption option, Encoding encoding = null, JsonWriterSettings settings = null)
 {
     file = file.zRootPath(zapp.GetAppDirectory());
     if (option == FileOption.IndexedFile)
     {
         file = zfile.GetNewIndexedFileName(zPath.GetDirectoryName(file), zPath.GetFileName(file));
     }
     //_streamWriter = zFile.CreateText(file);
     Open(file, encoding, option != FileOption.RazFile);
     _closeStreamWriter = true;
     InitSettings(settings);
 }
Ejemplo n.º 26
0
 public static WriteToFile Create(string file, FileOption option, Encoding encoding = null)
 {
     if (file != null)
     {
         file = file.zRootPath(zapp.GetAppDirectory());
         if (option == FileOption.IndexedFile)
             return new WriteToFile(() => zfile.GetNewIndexedFileName(zPath.GetDirectoryName(file), zPath.GetFileName(file)), encoding);
         else
             return new WriteToFile(file, encoding, appendToFile: option != FileOption.RazFile);
     }
     else
         return null;
 }
Ejemplo n.º 27
0
        private static void ReplaceSelectableOption(string replaceOptionName, FileOption <FileStream> newOption, List <IOption> selectableOptions)
        {
            IOption currentOption = selectableOptions.FirstOrDefault(x => x.Name == replaceOptionName);

            if (currentOption != null)
            {
                newOption.ApiName    = currentOption.ApiName;
                newOption.IsAssigned = false;
                newOption.Name       = currentOption.Name;
                selectableOptions.Remove(currentOption);
                selectableOptions.Add(newOption);
            }
        }
Ejemplo n.º 28
0
 /// <summary>
 /// Writes the bytes to file. Returns the full file name content was written to. This method is not thread safe
 /// </summary>
 /// <param name="bytes">The bytes.</param>
 /// <param name="option">The option.</param>
 /// <param name="offset"></param>
 /// <param name="count"></param>
 /// <param name="cancellationToken"></param>
 public async Task <string> WriteAsync(byte[] bytes, FileOption option = FileOption.Overwrite, int offset = 0, int?count = null, CancellationToken cancellationToken = default)
 {
     if (option == FileOption.DoNothingIfExist && Exist)
     {
         return(FullName);
     }
     var(fileStream, fullName) = GetFileStream(option);
     using (fileStream)
     {
         await fileStream.WriteAsync(bytes, offset, count.GetValueOrDefault(bytes.Length), cancellationToken);
     }
     return(fullName);
 }
Ejemplo n.º 29
0
 /// <summary>
 /// Writes the bytes to file. Returns the full file name content was written to. This method is not thread safe
 /// </summary>
 /// <param name="bytes">The bytes.</param>
 /// <param name="option">The option.</param>
 /// <param name="offset"></param>
 /// <param name="count"></param>
 public string Write(byte[] bytes, FileOption option = FileOption.Overwrite, int offset = 0, int?count = null)
 {
     if (option == FileOption.DoNothingIfExist && Exist)
     {
         return(FullName);
     }
     var(fileStream, fullName) = GetFileStream(option);
     using (fileStream)
     {
         fileStream.Write(bytes, offset, count.GetValueOrDefault(bytes.Length));
     }
     return(fullName);
 }
Ejemplo n.º 30
0
        public ValueTask <FileOption <long> > GetFileOptionAsync(long ID, string alternateDataStream)
        {
            var ret = FileOption <long> .Create(ID, alternateDataStream);

            if (!string.IsNullOrEmpty(alternateDataStream))
            {
                return(new ValueTask <FileOption <long> >(ret));
            }
            using (var da = new Models.Context())
            {
                var row = da.Files.Find(ID);
                if (row == null)
                {
                    return(default);
Ejemplo n.º 31
0
        private async void LoadPictureEncryptionButton_Click(object sender, RoutedEventArgs e)
        {
            this.sizeErrorMessage.Visibility = Visibility.Collapsed;
            var sourceImageFile = await FileOption.SelectSourceImageFile();

            if (sourceImageFile == null)
            {
                return;
            }
            var copyBitmapImage = await sourceImageFile.MakeCopyOfImage();

            this.imageUsedToEncrypt     = sourceImageFile;
            this.encryptingImage.Source = copyBitmapImage;
        }
        /// <inheritdoc />
        /// <summary>
        /// Serializes to file.
        /// </summary>
        /// <param name="obj">The obj.</param>
        /// <param name="file">The file.</param>
        /// <exception cref="T:System.ArgumentNullException">obj</exception>
        public void SerializeToFile(object obj, string fullFilePath, FileOption option = FileOption.DoNothingIfExist)
        {
            var file = new FileObject(fullFilePath);

            if (option == FileOption.DoNothingIfExist)
            {
                if (file.Exist == true)
                {
                    return;
                }
            }
            using (Stream stream = file.GetFileStream(option))
            {
                SerializeToStream(obj, stream);
            }
        }
Ejemplo n.º 33
0
        public ImagesBrowseViewModel( Action<FileModel> callback, string path = "", bool onlyImage = false)
        {
            //_window = window;
            _callback = callback;
            _rootPath = _path = path;

            if (onlyImage) // 将不能创建和 显示 删除 文件夹
            {
                _fileOption = FileOption.File;
            }
            _okCommand = new DelegateCommand(OK, CanOK);
            _uploadCommand = new DelegateCommand(Upload);
            _createDirectoryCommand = new DelegateCommand(CreateDirectory, CanCreateDirectory);
            _backCommand = new DelegateCommand(Back, CanBack);
            _deleteCommand = new DelegateCommand(Delete, CanDelete);
            _refreshCommand = new DelegateCommand(Refresh, CanRefresh);
            _openCommand = new DelegateCommand<FileModel>(Open);
            _renameCommand = new DelegateCommand(Rename, CanRename);
            _selectedItems.CollectionChanged += SelectedItems_CollectionChanged;
            Refresh();
        }
 public CustomizedAppSettings(string fileName, FileOption fileOption)
     : base(fileName, fileOption)
 {
 }
Ejemplo n.º 35
0
        public IEnumerable<FileModel> SearchFiles(string searchPattern, FileOption fileOption)
        {
            var root = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Upload");
            var length = root.Length;
            var physicalPath = root;
            if (!Directory.Exists(physicalPath))
            {
                Directory.CreateDirectory(physicalPath);
            }

            var rootDirectoryInfo = new DirectoryInfo(physicalPath); if (fileOption != FileOption.File)
            {
                var directoryInfos = rootDirectoryInfo.GetDirectories(searchPattern, SearchOption.AllDirectories);
                foreach (var directoryInfo in directoryInfos)
                {
                    yield return new FileModel()
                    {
                        Url = "Directory",
                        Name = directoryInfo.Name,
                        DisplayName = directoryInfo.Name,
                        CreationTime = directoryInfo.CreationTime,
                        ModifyTime = directoryInfo.LastWriteTime,
                        IsDirectory = true,
                        DirectoryName = directoryInfo.Parent.FullName.Remove(0, length),
                    };
                }
            }

            if (fileOption != FileOption.Directory)
            {
                var fileInfos = rootDirectoryInfo.GetFiles(searchPattern, fileOption != FileOption.File ?  SearchOption.AllDirectories : SearchOption.TopDirectoryOnly).Where(
                    file => string.Compare("*.jpg", file.Extension, true) == 0 || string.Compare("*.png", file.Extension, true) == 0
                    );
                foreach (var fileInfo in fileInfos)
                {
                    using (var pic = Image.FromFile(fileInfo.FullName))
                    {
                        yield return new FileModel()
                        {
                            Url = fileInfo.FullName.Remove(0, length).Replace("\\", "/").Trim('/'),
                            Name = fileInfo.Name,
                            DisplayName = fileInfo.Name,
                            FileSize = fileInfo.Length,
                            CreationTime = fileInfo.CreationTime,
                            ModifyTime = fileInfo.LastWriteTime,
                            Height = pic.Height,
                            Width = pic.Width,
                            DirectoryName = fileInfo.DirectoryName.Remove(0, length),
                        };
                    }
                }
            }
        }
Ejemplo n.º 36
0
        public IEnumerable<FileModel> GetImages(string path, FileOption fileOption)
        {
            var root = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Upload");
            var length = root.Length;
            var physicalPath = Path.Combine(root, path.Trim('\\'));
            if (!Directory.Exists(physicalPath))
            {
                Directory.CreateDirectory(physicalPath);
            }
            var rootDirectoryInfo = new DirectoryInfo(physicalPath);
            if (fileOption != FileOption.File)
            {
                var directoryInfos = rootDirectoryInfo.GetDirectories();
                foreach (var directoryInfo in directoryInfos)
                {
                    yield return new FileModel()
                    {
                        Url = "Directory",
                        Name = directoryInfo.Name,
                        DisplayName = directoryInfo.Name,
                        CreationTime = directoryInfo.CreationTime,
                        ModifyTime = directoryInfo.LastWriteTime,
                        IsDirectory = true,
                        DirectoryName = directoryInfo.Parent.FullName.Remove(0, length),
                    };
                }
            }

            if (fileOption != FileOption.Directory)
            {
                var fileInfos = rootDirectoryInfo.GetFiles("*.jpg").Union(rootDirectoryInfo.GetFiles("*.png"));
                foreach (var fileInfo in fileInfos)
                {
                    using (var pic = Image.FromFile(fileInfo.FullName))
                    {
                        yield return new FileModel()
                        {
                            Url = fileInfo.FullName.Remove(0, length).Replace("\\", "/").Trim('/'),
                            Name = fileInfo.Name,
                            DisplayName = fileInfo.Name,
                            FileSize = fileInfo.Length,
                            CreationTime = fileInfo.CreationTime,
                            ModifyTime = fileInfo.LastWriteTime,
                            Height = pic.Height,
                            Width = pic.Width,
                            DirectoryName = fileInfo.DirectoryName.Remove(0, length),
                        };
                    }
                }
            }
        }
Ejemplo n.º 37
0
 public void SetWriter(string file, FileOption option, Encoding encoding = null)
 {
     SetWriter(WriteToFile.Create(file, option, encoding));
 }