public RealVirtualityLauncher(IMediator mediator, IGameLauncherProcess processManager, IPathConfiguration pathConfiguration, IFileWriter writer) : base(mediator, processManager) { Contract.Requires<ArgumentNullException>(writer != null); _writer = writer; _parPath = pathConfiguration.LocalDataPath.GetChildDirectoryWithName("games"); }
/// <summary> /// Initializes a new instance of the <see cref="FileTarget"/> class. /// </summary> /// <param name="name">Unique name for this target. Could be the file name</param> /// <param name="configuration">The configuration.</param> public FileTarget(string name, FileConfiguration configuration) { Contract.Requires(!String.IsNullOrEmpty(name)); Contract.Requires<ArgumentNullException>(configuration != null); _fileWriter = new FileWriter(name, configuration); }
/// <summary> /// Initializes a new instance of the <see cref="Base64StringToFile"/> class. /// </summary> /// <param name="fileWriter"> /// The file writer. /// </param> public Base64StringToFile(IFileWriter fileWriter) { if (fileWriter == null) throw new ArgumentNullException("fileWriter"); this.fileWriter = fileWriter; }
public async Task<ReportingResult> WriteAnalysisReportsAsync( IEnumerable<string> assemblyPaths, IFileWriter reportWriter, bool includeJson) { _outputWindow.ShowWindow(); await _optionsViewModel.UpdateAsync(); var reportDirectory = _optionsViewModel.OutputDirectory; var outputFormats = _optionsViewModel.Formats.Where(f => f.IsSelected).Select(f => f.DisplayName); var reportFileName = _optionsViewModel.DefaultOutputName; var analysisOptions = await GetApiPortOptions(assemblyPaths, outputFormats, Path.Combine(reportDirectory, reportFileName)); var issuesBefore = _reporter.Issues.Count; var result = await _client.WriteAnalysisReportsAsync(analysisOptions, includeJson); if (!result.Paths.Any()) { var issues = _reporter.Issues.ToArray(); for (int i = issuesBefore; i < issues.Length; i++) { _outputWindow.WriteLine(LocalizedStrings.ListItem, issues[i]); } } _viewer.View(result.Paths); return result.Result; }
public Highscore() { this.fileReader = new FileReader(this.highscoreExternalFileName); this.fileWriter = new FileWriter(this.highscoreExternalFileName); this.players = new List<IPlayer>(); this.GenerateListWithTopPlayers(5); }
/// <summary> /// Initializes a new instance of the <see cref="FileTarget"/> class. /// </summary> /// <param name="name">File name without extension.</param> /// <param name="configuration">The configuration.</param> public FileTarget(string name, FileConfiguration configuration) { if (name == null) throw new ArgumentNullException("name"); if (configuration == null) throw new ArgumentNullException("configuration"); _fileWriter = new FileWriter(name, configuration); }
public GenerateSQL(Configuration configuration, Settings settings, ISqlFormatter sql_formatter, IFileWriter file_writer, IMigrationProvider migration_provider) { _configuration = configuration; _settings = settings; _sql_formatter = sql_formatter; _file_writer = file_writer; _migration_provider = migration_provider; }
private static void WriteNumber(int number, IFileWriter fileWriter) { var isNegativeNumber = number < 0; var absoluteNumber = (uint)Math.Abs(number); fileWriter.WriteBit(isNegativeNumber); fileWriter.WriteValueOnBits(absoluteNumber, NumberOfBits - 1); }
public IceStreamHandler(ILogger log, IIceStreamReader reader, IFileWriter fileWriter, ISettings settings) { _log = log; _reader = reader; _fileWriter = fileWriter; _settings = settings; _reader.OnBlockReceived(BlockReceived); }
static void Main(string[] args) { // rozpoznanie argumentów i ewentualna korekta wartości domyślnych try { getArgs(args); } catch (ArgumentException ae) { handleException(ae); } try { inputFile = new StreamReader(inputData, System.Text.Encoding.UTF8); } catch (IOException e) { handleException(new FileNotFoundException("Nie znaleziono pliku: " + inputData)); try { inputFile = new StreamReader(inputDataFinal, System.Text.Encoding.UTF8); } catch (FileNotFoundException exc) { string msg = "Nie znaleziono pliku domyślnego: " + inputDataFinal + "\nDZIAŁANIE PROGRAMU PRZERWANE"; Console.WriteLine(msg); logFile.WriteLine(msg); logFile.Close(); return; } } // wczytywanie danych outputTable = ReadFile(); inputFile.Close(); Uczelnia uczelnia = new Uczelnia(new Studenci(outputTable)); // konwersja i zapis do pliku try { writer.write(uczelnia, outputData); } catch (DirectoryNotFoundException e) { handleException(new DirectoryNotFoundException("Katalog nie istnieje: " + outputData)); writer = new MyXmlWriter(); writer.write(uczelnia, outputDataFinal); } catch (UnauthorizedAccessException e) { handleException(new UnauthorizedAccessException("Nie masz dostępu do tego katalogu: " + outputData)); writer = new MyXmlWriter(); writer.write(uczelnia, outputDataFinal); } logFile.Close(); Console.WriteLine("Program wykonał się poprawnie"); }
// Disabled due to long runtime [TestCase(specificSchema, Codec.Type.Deflate, 1000, 588, 998)] public void TestSyncAndSeekPositions(string schemaStr, Codec.Type codecType, int iterations, int firstSyncPosition, int secondSyncPosition) { // create and write out IList <Foo> records = MakeRecords(GetTestFooObject()); MemoryStream dataFileOutputStream = new MemoryStream(); Schema schema = Schema.Parse(schemaStr); DatumWriter <Foo> writer = new SpecificWriter <Foo>(schema); using (IFileWriter <Foo> dataFileWriter = DataFileWriter <Foo> .OpenWriter(writer, dataFileOutputStream, Codec.CreateCodec(codecType))) { for (int i = 0; i < iterations; ++i) { foreach (Foo foo in records) { dataFileWriter.Append(foo); } // write out block if (i == firstSyncPosition || i == secondSyncPosition) { dataFileWriter.Sync(); } } } MemoryStream dataFileInputStream = new MemoryStream(dataFileOutputStream.ToArray()); // read syncs IList <long> syncs = new List <long>(); using (IFileReader <Foo> reader = DataFileReader <Foo> .OpenReader(dataFileInputStream)) { long previousSync = -1; foreach (Foo foo in reader.NextEntries) { if (reader.PreviousSync() != previousSync && reader.Tell() != reader.PreviousSync()) // EOF { previousSync = reader.PreviousSync(); syncs.Add(previousSync); } } // verify syncs wth seeks reader.Sync(0); // first sync Assert.AreEqual(reader.PreviousSync(), syncs[0], string.Format("Error syncing reader to position: {0}", syncs[0])); foreach (long sync in syncs) // the rest { reader.Seek(sync); Foo foo = reader.Next(); Assert.IsNotNull(foo, string.Format("Error seeking to sync position: {0}", sync)); } } }
/// <summary> /// Writes a DataTable to a CSV file specified by the path /// </summary> /// <param name="dataTable">The datatable to write</param> /// <param name="filePath">The location of the CSV to create</param> /// <param name="settings">Optional csv settings</param> public static void ToCsv(this DataTable dataTable, string filePath, ToCsvSettings settings = null) { settings = settings ?? new ToCsvSettings(); using (IFileWriter fileWriter = FileWriterFactory.GetFileWriter(filePath, settings.Compression)) { fileWriter.Write(dataTable.ToCsv(settings)); } }
public FileService( IFileReader fileReader, IFileWriter fileWriter, IStreamService streamService) { _fileReader = fileReader; _fileWriter = fileWriter; _streamService = streamService; }
public CoinFileCreator( IMapper<OutboundVoucherFile, CoinFile> documentMapper, IFileWriter<CoinFile> writer, IFileSystem fileSystem) { this.documentMapper = documentMapper; this.writer = writer; this.fileSystem = fileSystem; }
public ProcessedJobsConsumer(BlockingCollection <ProcessedBatchItem> processedJobQueue, IJobContext jobContext, IFileWriter fileWriter, CountdownEvent countdown, CancellationTokenSource cancellationTokenSource) { this.processedJobQueue = processedJobQueue; this.jobContext = jobContext; this.fileWriter = fileWriter; this.countdown = countdown; this.cancellationTokenSource = cancellationTokenSource; }
public void TestInititalize() { _dateTimeProviderMock = Substitute.For <IDateTimeProvider>(); _dateTimeProviderMock.UtcNow.Returns(DateTime.UtcNow.ToString()); _filePathProviderMock = Substitute.For <IFilePathProvider>(); _filePathProviderMock.GetFilePath().Returns(expectedFilePath); _filewriterMock = Substitute.For <IFileWriter>(); _fileLogger = new FileLogger(_dateTimeProviderMock, _filePathProviderMock, _filewriterMock); }
protected PersistenceProviderBase(ILogger logger, IFileReader reader, IFileWriter writer, IFileRemover remover, ISettingsMetadata metadata) { Logger = logger; Reader = reader; Writer = writer; Remover = remover; Metadata = metadata; }
internal RegistrationRepository(string file, ISynchronizer synchronizer, IFileReader reader, IFileWriter writer) { _synchronizer = synchronizer; _reader = reader; _writer = writer; _serializer = new JavaScriptSerializer(); _file = file; }
public virtual void WriteFunctionTryGetOne(IFileWriter fileWriter, IEntityType entityType, IReadOnlyList <IProperty> properties, string functionName = null, bool addEntityTypeToFunctionName = false) { functionName = functionName ?? $"{FunctionNamePrefixTryGetOne}{GetFunctionNameParameter(properties)}"; functionName = Smart.Format(functionName, addEntityTypeToFunctionName ? entityType : null); WriteFunction(fileWriter, GetFunctionHeader(GetEntityType(entityType), functionName, GetParameterList(properties)), GetFunctionBodyReturnSingleOrDefault(entityType, properties)); }
public AvroWriter(IAvroFileValueDef <V> valueDef, FileStream stream, Codec.Type codec) : base(valueDef, stream) { Preconditions.CheckArgument(Stream.CanWrite); var datumWriter = new GenericDatumWriter <GenericRecord>(ValueDef.Schema); mWriter = DataFileWriter <GenericRecord> .OpenWriter(datumWriter, Stream, Codec.CreateCodec(codec)); Stream.Position = Stream.Length; }
private void WriteGeneric <T>(Stream output, Schema schema, T value, Codec.Type codecType) { DatumWriter <T> writer = new GenericWriter <T>(schema); using (IFileWriter <T> dataFileWriter = DataFileWriter <T> .OpenWriter(writer, output, Codec.CreateCodec(codecType))) { dataFileWriter.Append(value); } }
public virtual void ProcessEntity(IScriptContext scriptContext, IEntityType entityType) { scriptContext.Logger.WriteDebug($"Processing entity '{entityType.Name}'."); scriptContext.Output.CurrentGeneratedFileName.FileNameWithoutExtension = entityType.ClrType.Name; IFileWriter fileWriter = scriptContext.Output.Current; fileWriter.WriteLine(Header).WriteLine(); using (fileWriter.WriteScope($"namespace {Namespace}")) { fileWriter.WriteLine("using System;").WriteLine("using System.Linq;").WriteLine("using System.Collections.Generic;") .WriteLine("using System.Linq.Expressions;") .WriteLine($"using {entityType.ClrType.Namespace};").WriteLine(); ISet <IEnumerable <IProperty> > addedFunctions = new HashSet <IEnumerable <IProperty> >(); using (fileWriter.WriteScope(Smart.Format(RepositoryClassHeader, new { entityType.ClrType.Name }))) { using (fileWriter.WriteScope(Smart.Format(RepositoryConstructorHeader, new { entityType.ClrType.Name }))) { fileWriter.WriteLine(Smart.Format(RepositoryConstructorBody, new { entityType.ClrType.Name })); } WriteBasicFunctions(fileWriter, entityType); IKey primaryKey = entityType.FindPrimaryKey(); ProcessPrimaryKey(addedFunctions, fileWriter, entityType, primaryKey); foreach (IIndex index in entityType.GetIndexes()) { ProcessIndex(addedFunctions, fileWriter, entityType, index); } foreach (IForeignKey foreignKey in entityType.GetForeignKeys()) { ProcessForeignKey(addedFunctions, fileWriter, entityType, foreignKey); } foreach (IProperty property in entityType.GetProperties()) { ProcessProperty(addedFunctions, fileWriter, entityType, property); } } } }
public EntityLogGenerator(string FriendlyName, IFileReader fileReader, IFileWriter fileWriter) : base(fileReader) { this.FriendlyName = FriendlyName; FileWriter = fileWriter; if (string.IsNullOrEmpty(FriendlyName)) { throw new NotImplementedException("Invariant what if the FrienlyName is empty or null?"); } }
public virtual void WriteFunctionDeleteMultipleByValues(IFileWriter fileWriter, IEntityType entityType, IReadOnlyList <IProperty> properties, string functionName = null, bool addEntityTypeToFunctionName = false) { functionName = functionName ?? $"{FunctionNamePrefixDeleteMultiple}{GetFunctionNameParameter(properties)}"; functionName = Smart.Format(functionName, addEntityTypeToFunctionName ? entityType : null); WriteFunction(fileWriter, GetFunctionHeader("void", functionName, GetParameterListEnumerable(properties)), GetFunctionBodyRemoveWhereEnumerable(entityType, properties)); }
/// <summary> /// Initializes a new instance of the <see cref="FileTarget"/> class. /// </summary> /// <param name="writer">Writer being used to to write log entries.</param> public FileTarget(IFileWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } _fileWriter = writer; }
public File(string name, string extension, string path, IFileReader reader, IFileWriter writer) { Name = name; Extension = extension; Path = path; _reader = reader; _writer = writer; }
void ISingleRecordMapper <T, V> .Insert(IFileWriter writer) { if (null != this.Value) { this.Insert((TextFileWriter)writer); //this.MultiFieldMapper.Insert(writer); writer.Next(); } }
public PhotoUploader( IFileWriter fileWriter, IFileNameProvider fileNameProvider, ICorrelationInitializer correlationInitializer) { _fileWriter = fileWriter; _fileNameProvider = fileNameProvider; _correlationInitializer = correlationInitializer; }
/// <inheritdoc/> public override async void Run(object item) { var editor = ServiceProvider.GetService <ProjectEditor>(); string name = string.Empty; if (item == null || item is ProjectEditor) { if (editor.Project == null) { return; } name = editor.Project.Name; item = editor.Project; } else if (item is ProjectContainer) { name = (item as ProjectContainer).Name; } else if (item is DocumentContainer) { name = (item as DocumentContainer).Name; } else if (item is PageContainer) { name = (item as PageContainer).Name; } var dlg = new SaveFileDialog(); foreach (var writer in editor?.FileWriters) { dlg.Filters.Add(new FileDialogFilter() { Name = writer.Name, Extensions = { writer.Extension } }); } dlg.Filters.Add(new FileDialogFilter() { Name = "All", Extensions = { "*" } }); dlg.InitialFileName = name; dlg.DefaultExtension = editor?.FileWriters.FirstOrDefault()?.Extension; var result = await dlg.ShowAsync(ServiceProvider.GetService <MainWindow>()); if (result != null) { string ext = System.IO.Path.GetExtension(result).ToLower().TrimStart('.'); IFileWriter writer = editor.FileWriters.Where(w => string.Compare(w.Extension, ext, StringComparison.OrdinalIgnoreCase) == 0).FirstOrDefault(); if (writer != null) { editor.OnExport(result, item, writer); } } }
public DirectoryManager(IFileWriter fileWriter, IFileReader fileReader, IFilePathBuilder filePathBuilder, IDatabase database, IHttpContextAccessor httpContextAccessor) { this.fileWriter = fileWriter; this.fileReader = fileReader; this.filePathBuilder = filePathBuilder; this.database = database; this.currentUserId = httpContextAccessor.HttpContext.GetCurrentUserId(); }
public void Setup() { _messageDispatcher = new Fake_MessageDispatcher(); _pluginFactory = MockRepository.GenerateMock<IPluginLoader>(); _editor = MockRepository.GenerateMock<IEditor>(); _fileWriter = MockRepository.GenerateMock<IFileWriter>(); _dispatcher = new EditorDispatcher(_pluginFactory, _messageDispatcher, _fileWriter); _dispatcher.SetEditor(_editor); }
public ColorService( IGeneralSetting setting, IFileWriter fileWriter, IFileReader fileReader) { _fileWriter = fileWriter ?? throw new ArgumentNullException(nameof(fileWriter)); _fileReader = fileReader ?? throw new ArgumentNullException(nameof(fileReader)); _setting = setting ?? throw new ArgumentNullException(nameof(setting)); }
public FileLogger(string categoryName, IFileWriter fileWriter, Func <bool> isFileLoggingEnabled, Func <bool> isPrimary, LogType logType, IExternalScopeProvider scopeProvider) { _fileWriter = fileWriter; _isFileLoggingEnabled = isFileLoggingEnabled; _isPrimary = isPrimary; _categoryName = categoryName; _logType = logType; _scopeProvider = scopeProvider ?? throw new ArgumentNullException(nameof(scopeProvider)); }
public MetadataTypeAttributeGenerator(string MetadataClassName, IFileReader fileReader, IFileWriter fileWriter) : base(fileReader) { this.MetadataClassName = MetadataClassName; FileWriter = fileWriter; if (string.IsNullOrEmpty(MetadataClassName)) { throw new NotImplementedException("Invariant what if the FrienlyName is empty or null?"); } }
public bool TryGetFileWriter(Guid writerId, out IFileWriter writer) { InitOnece(); FileWriterData g; bool r = _dicById.TryGetValue(writerId, out g); writer = g; return(r); }
public UploadManager(IFileStore fileStore, IFileWriter fileWriter, IUploadProgressManager uploadProgressManager, IUploadFileLock uploadFileLock, MetadataReader metadataReader, ILogger <UploadManager> logger) { this._fileStore = fileStore; this._fileWriter = fileWriter; this._logger = logger; this._metadataReader = metadataReader; this._uploadFileLock = uploadFileLock; this._uploadProgressManager = uploadProgressManager; }
/// <summary> /// Initializes a new instance of the <see cref="Base64StringToFile"/> class. /// </summary> /// <param name="fileWriter"> /// The file writer. /// </param> public Base64StringToFile(IFileWriter fileWriter) { if (fileWriter == null) { throw new ArgumentNullException("fileWriter"); } this.fileWriter = fileWriter; }
private int _maxCollectionSize = 1000; //should be taken from configuration public AsyncLog(IFileWriter writer) { _lines = new BlockingCollection <LogLine>(); var runThread = new Thread(MainLoop); runThread.Start(); _writer = writer; }
public FileDownloader( HttpClient httpClient, IFileWriter fileWriter) { Guard.IsNotNull(fileWriter, nameof(fileWriter)); Guard.IsNotNull(httpClient, nameof(httpClient)); _fileWriter = fileWriter; _client = httpClient; }
public ApiPortClient(IApiPortService apiPortService, IProgressReporter progressReport, ITargetMapper targetMapper, IDependencyFinder dependencyFinder, IReportGenerator reportGenerator, IEnumerable<IgnoreAssemblyInfo> assembliesToIgnore, IFileWriter writer) { _apiPortService = apiPortService; _progressReport = progressReport; _targetMapper = targetMapper; _dependencyFinder = dependencyFinder; _reportGenerator = reportGenerator; _assembliesToIgnore = assembliesToIgnore; _writer = writer; }
public ApiPortClient(IApiPortService apiPortService, IProgressReporter progressReport, ITargetMapper targetMapper, IDependencyFinder dependencyFinder, IReportGenerator reportGenerator, IEnumerable <IgnoreAssemblyInfo> assembliesToIgnore, IFileWriter writer) { _apiPortService = apiPortService; _progressReport = progressReport; _targetMapper = targetMapper; _dependencyFinder = dependencyFinder; _reportGenerator = reportGenerator; _assembliesToIgnore = assembliesToIgnore; _writer = writer; }
public Generator(Configuration configuration, Settings settings, IFileWriter file_writer) { if(!configuration.Generate) { throw new InvalidOperationException("Configuration not correctly set for Generator"); } _file_writer = file_writer; _configuration = configuration; _settings = settings; set_generation_action(); }
/// <summary> /// This will add or update a writer for a specific file extension /// </summary> /// <param name="fileExtension"></param> /// <param name="?"></param> /// <param name="writer"></param> public static void AddWriterForExtension(string fileExtension, IFileWriter writer) { if (fileExtension == null) throw new ArgumentNullException("fileExtension"); if (writer == null) throw new ArgumentNullException("writer"); if (!fileExtension.StartsWith(".")) { throw new FormatException("A file extension must begin with a '.'"); } ExtensionWriters.AddOrUpdate(fileExtension.ToUpper(), s => writer, (s, fileWriter) => writer); }
/// <summary> /// This will add or update a writer for a specific file /// </summary> /// <param name="filePath"></param> /// <param name="writer"></param> public static void AddWriterForFile(string filePath, IFileWriter writer) { if (filePath == null) throw new ArgumentNullException("filePath"); if (writer == null) throw new ArgumentNullException("writer"); if (!filePath.StartsWith("/")) { throw new FormatException("A file path must begin with a '/'"); } PathWriters.AddOrUpdate(filePath.ToUpper(), s => writer, (s, fileWriter) => writer); }
public ItemSerializer(IPathFacade pathFacade, IEditorLogger logger, IProjectLoader projectLoader, IXmlSerializer xmlSerializer, IFileWriter fileWriter) : base(pathFacade, logger, projectLoader) { Check.IfIsNull(xmlSerializer).Throw<ArgumentNullException>(() => xmlSerializer); Check.IfIsNull(fileWriter).Throw<ArgumentNullException>(() => fileWriter); this.xmlSerializer = xmlSerializer; this.fileWriter = fileWriter; }
public SSRSReportGenerator(IReportingConfiguration reportingConfiguration, IFileWriter fileWriter) { this.trusteduserHeader = new RE2005.TrustedUserHeader(); this.execHeader = new ExecutionHeader(); this.serviceInfo = new RE2005.ServerInfoHeader(); this.execInfo = new ExecutionInfo(); this.fileWriter = fileWriter; this.reportService2010Reference = new EndpointAddress(reportingConfiguration.ReportService2010Reference); this.reportExecution2005Reference = new EndpointAddress(reportingConfiguration.ReportExecution2005Reference); }
public SettingsSerializer(IApplication application, IFileFacade fileFacade, IPathFacade pathFacade, IXmlSerializer xmlSerializer, IXmlDeserializer xmlDeserializer, IFileWriter fileWriter, IFileReader fileReader) { this.application = application; this.fileFacade = fileFacade; this.pathFacade = pathFacade; this.xmlSerializer = xmlSerializer; this.xmlDeserializer = xmlDeserializer; this.fileWriter = fileWriter; this.fileReader = fileReader; }
public ProjectAnalyzer( IVsApiPortAnalyzer analyzer, Microsoft.VisualStudio.Shell.ErrorListProvider errorList, ISourceLineMapper sourceLineMapper, IFileWriter reportWriter, IFileSystem fileSystem, ProjectBuilder builder) { _analyzer = analyzer; _sourceLineMapper = sourceLineMapper; _reportWriter = reportWriter; _fileSystem = fileSystem; _builder = builder; _errorList = errorList; }
public async Task<string> Download(IFileWriter fileWriter) { //peep thread Id var tId = Thread.CurrentThread.ManagedThreadId; //suspend execution until this task is complete var contents = await new HttpClient().GetStringAsync(Url); //suspend execution until this task is complete var writeFileTask = fileWriter.WriteFile(contents, Name); var returnVal = await writeFileTask; //return the value returned from WriteFile return returnVal; }
/// <summary> /// Get data in this.Url and use <paramref name="fileWriter"/> to save to disk /// </summary> /// <param name="fileWriter"></param> /// <returns>Task that completes when file is written to disk</returns> public Task<string> Download(IFileWriter fileWriter) { var tId = Thread.CurrentThread.ManagedThreadId; try { var contentsTask = new HttpClient().GetStringAsync(Url); //Block current thread until contentsTask is complete contentsTask.Wait(); //Return task that will write the contents to disk return fileWriter.WriteFile(contentsTask.Result, Name); } catch { //Return a sucessfully completed Task<string> with the below result return Task.FromResult(string.Format("Failed to download: {0}", Url)); } }
public HtmlTopTenReport(IFileWriter fileWriter, string filePath) : base(fileWriter, filePath) { }
public FileManager(IFileRepository fileRepository, IFileWriter fileWriter, IManifestBuilder manifestBuilder) { _fileRepository = DIHelper.VerifyParameter(fileRepository); _fileWriter = DIHelper.VerifyParameter(fileWriter); _manifestBuilder = DIHelper.VerifyParameter(manifestBuilder); }
public ReverserImplementation(IFileReader fileReader, IFileWriter fileWriter) { _fileReader = fileReader; _fileWriter = fileWriter; }
/// <summary> /// Initializes a new instance of the <see cref="FileTarget"/> class. /// </summary> /// <param name="writer">Writer being used to to write log entries.</param> public FileTarget(IFileWriter writer) { if (writer == null) throw new ArgumentNullException("writer"); _fileWriter = writer; }
public AsyncArtist(IFileWriter writer) { Writer = writer; Songs = new Songs(); }
public OrderWriter(IFileWriter fileWriter) { _fileWriter = fileWriter; }
public void SaveToFile(object obj, IFileWriter fileWriter, IObjectContentReader contentReader, string filePath) { object content = contentReader.ReadContentFromObject(obj); fileWriter.WriteFile(filePath, content); }
public HtmlReport(IFileWriter fileWriter, string filePath) { _fileWriter = fileWriter; _filePath = filePath; }
/// <summary> /// Initializes a new instance of the <see cref="HtmlReportGenerator"/> class. /// </summary> /// <param name="outputWriter">The output writer.</param> public HtmlReportGenerator(IFileWriter outputWriter) { _outputWriter = outputWriter; }