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));
}
internal RegistrationRepository(string file, ISynchronizer synchronizer, IFileReader reader, IFileWriter writer)
{
_synchronizer = synchronizer;
_reader = reader;
_writer = writer;
_serializer = new JavaScriptSerializer();
_file = file;
}
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;
}
