public static object?Read(this IRead read, string filename) { if (filename.Contains("{")) { MemoryStream?memory = new MemoryStream(Encoding.UTF8.GetBytes(filename)); return(read.Read(memory)); } if (filename.Contains("(") && filename.Contains("*") && filename.Contains(".") && filename.Contains(")") && filename.Contains("|")) { // open file dialog filter Microsoft.Win32.OpenFileDialog?ofd = new Microsoft.Win32.OpenFileDialog { Filter = filename }; bool?result = ofd.ShowDialog(); if (result == true) { if (File.Exists(ofd.FileName)) { FileStream?stream = new FileStream(ofd.FileName, FileMode.Open); //stream.SetFileName(ofd.FileName); object?instance = read.Read(stream); stream.Close(); instance?.SetFileName(ofd.FileName); return(instance); } } else { return(null); } } if (File.Exists(filename)) { using FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read); object?item = read.Read(fs); fs.Close(); SetPropertyValue(item, "FileName", filename); item?.SetFileName(filename); return(item); } else { StackTrace?stackTrace = new StackTrace(); foreach (Assembly?assembly in stackTrace.GetAssemblies()) { Stream?stream = assembly.GetStream(filename); if (stream != null) { object?item = read.Read(stream); SetPropertyValue(item, "FileName", filename); item?.SetFileName(filename); return(item); } } throw new Exception($"{filename} not found"); } }
public static unsafe void Read <TElement>(this IRead <TElement> collection, TElement *elements, Int32 length) where TElement : unmanaged { for (Int32 i = 0; i < length; i++) { collection.Read(out elements[i]); } }
public void Copy() { var txt = reader.Read(); writer.Write(txt); Console.ReadLine(); }
public static object Read(IRead read, string value) { if (File.Exists(value)) { using (FileStream stream = new FileStream(value, FileMode.Open)) { var result = read.Read(stream); stream.Close(); return result; } } using (MemoryStream memory = new MemoryStream(Encoding.UTF8.GetBytes(value))) { return read.Read(memory); } }
public IEnumerable <IRow> DetermineDeletes() { var input = _inputReader.Read(); #if NETS10 // no PLINQ #else if (_context.Entity.Pipeline == "parallel.linq") { input = input.AsParallel(); } #endif // I believe this is here in case the primary key depends on transformations var transformed = _transforms.Aggregate(input, (current, transform) => current.Select(transform.Operate)); var output = _outputReader.Read(); #if NETS10 // no PLINQ #else if (_context.Entity.Pipeline == "parallel.linq") { output = output.AsParallel(); } #endif return(output.Except(transformed, new KeyComparer(_context.Entity.GetPrimaryKey()))); }
/// <summary> /// Reads until the <paramref name="elements"/> is filled. /// </summary> /// <param name="collection">This collection.</param> /// <param name="elements">The <see cref="Span{T}"/> of <typeparamref name="TElement"/> to fill.</param> public static void Read <TElement>(this IRead <TElement?> collection, Span <TElement?> elements) { for (Int32 i = 0; i < elements.Length; i++) { collection.Read(out elements[i]); } }
public static void Open(Window window, string[] fileExtensions, IRead<string> data) { var filter = FileExtensionModule.AddStar(fileExtensions); var filename = OpenFileModule.WithFilters(window, filter); if (filename == null) return; data.Read(filename); }
public static T FormatConfig <T>(string path) where T : class, new() { string str = File.ReadAllText(path); IRead ir = (IRead) new T(); ir.Read(str); return(ir as T); }
// This will be async because the reader has a task in it. public static async Task Consumer(IRead <string> reader) { while (!reader.IsComplete()) { var msg = await reader.Read(); Print(msg); } }
private void ModifyFields(IEnumerable <Field> fields) { var expanded = fields.ToArray(); if (_context.Connection.MaxLength > 0) { foreach (var field in expanded) { field.Length = _context.Connection.MaxLength.ToString(); } } var checkLength = _context.Connection.MinLength > 0 || _context.Connection.MaxLength > 0; var checkTypes = _context.Connection.Types.Any(t => t.Type != "string"); if (checkTypes || checkLength) { var entity = _process.Entities.First(); var rowFactory = new RowFactory(_context.RowCapacity, entity.IsMaster, false); var defaultTransform = new Transformalize.Transforms.System.DefaultTransform(new PipelineContext(_context.Logger, _process, entity), entity.GetAllFields()); var rows = defaultTransform.Operate(_reader.Read()).ToArray(); // can take a lot of memory if (rows.Length == 0) { return; } if (checkLength) { Parallel.ForEach(expanded, f => { var length = _context.Connection.MaxLength == 0 ? rows.Max(row => row[f].ToString().Length) + 1 : Math.Min(rows.Max(row => row[f].ToString().Length) + 1, _context.Connection.MaxLength); if (_context.Connection.MinLength > 0 && length < _context.Connection.MinLength) { length = _context.Connection.MinLength; } f.Length = length.ToString(); }); } if (checkTypes) { var canConvert = Constants.CanConvert(); Parallel.ForEach(expanded, f => { foreach (var dataType in _context.Connection.Types.Where(t => t.Type != "string")) { if (rows.All(r => canConvert[dataType.Type](r[f].ToString()))) { f.Type = dataType.Type; break; } } }); } } }
public Contributor GetOrInsert(Contributor contributor) { var contributorSaved = contributorReader.Read(contributor.Email); if (contributorSaved is null) { contributorSaved = contributorWriter.Save(contributor); } return(contributorSaved); }
public static object Read(IRead read, Assembly assembly, string name) { foreach (var manifestResourceName in assembly.GetManifestResourceNames()) { if (manifestResourceName.Contains(name)) { return read.Read(assembly.GetManifestResourceStream(manifestResourceName)); } } return null; }
private object ExecuteHandler(object command, IRead executor) { try { return executor.Read(command); } finally { _container.Release(executor); } }
public static object Read(IRead read,string filename) { if(File.Exists(filename)) { using (FileStream fs = new FileStream(filename, FileMode.Open)) { return read.Read(fs); } } return null; }
/// <summary> /// Reads <paramref name="amount"/> of <typeparamref name="TElement"/>. /// </summary> /// <param name="collection">This collection.</param> /// <param name="amount">The amount of elements to read.</param> /// <param name="elements">The <typeparamref name="TElement"/> values that were read.</param> public static void Read <TElement>(this IRead <TElement?> collection, nint amount, out ReadOnlySpan <TElement?> elements) { TElement?[] buffer = new TElement?[amount]; Int32 i = 0; for (; i < amount; i++) { collection.Read(out buffer[i]); } elements = buffer.AsSpan(0, i); }
public static object?Read(this IRead read, Assembly assembly, string name) { foreach (string?manifestResourceName in assembly.GetManifestResourceNames()) { if (manifestResourceName.Contains(name)) { #pragma warning disable CS8604 // Possible null reference argument. return(read.Read(assembly.GetManifestResourceStream(manifestResourceName))); #pragma warning restore CS8604 // Possible null reference argument. } } return(null); }
public IEnumerable <IRow> Read() { using (var cn = _cf.GetConnection()) { cn.Open(); foreach (var batch in _reader.Read().Partition(_input.Entity.ReadSize)) { foreach (var row in _fieldsReader.Read(batch)) { _rowCount++; yield return(row); } } } _input.Info("{0} from {1}", _rowCount, _input.Connection.Name); }
public T ReadDataFromFile <T>(string path) { dynamic result = null; try { if (!string.IsNullOrEmpty(path)) { if (File.Exists(path)) { string contents = read.Read <string>(path); result = jsonToCollec.Convert <T>(contents); } } } catch (Exception ex) { } return((T)Convert.ChangeType(result, typeof(T))); }
public IEnumerable <SparseTwinIndex <float> > Assign() { var zoneArray = this.Root.ZoneSystem.ZoneArray; var zoneSystem = zoneArray.GetFlatData(); var population = this.Root.Population.Population.GetFlatData(); var numberOfZones = zoneSystem.Length; foreach (var cat in Categories) { cat.InitializeDemographicCategory(); var ret = zoneArray.CreateSquareTwinArray <float>(); var flatRet = ret.GetFlatData(); Parallel.For(0, numberOfZones, delegate(int i) { var localPop = population[i]; int popLength; if (localPop != null && (popLength = localPop.Length) > 0) { var iArray = flatRet[i]; EnsureGetDest(ref getDest, localPop[0]); for (int j = 0; j < popLength; j++) { IZone destZone; var person = localPop[j]; if (cat.IsContained(person)) { getDest.Read(person, out destZone); if (destZone != null) { iArray[zoneArray.GetFlatIndex(destZone.ZoneNumber)] += Probability; } } } } }); yield return(ret); } }
public void ConsumeRepository(string connectionString) { IRead reader = null; IRepository repository = null; if (RepositoryFactory.ConnectionStringIsReadOnly(connectionString)) { reader = RepositoryFactory.GetReadOnlyRepository(connectionString); } else { repository = RepositoryFactory.GetRepository(connectionString); reader = repository; } object o = reader.Read(); // do something with o // if allowed then write o to repository if (repository != null) { repository.Write(o); } }
public IEnumerable <Row> DetermineDeletes() { return(_outputReader.Read().Except(_inputReader.Read(), new KeyComparer(_entity.GetPrimaryKey()))); }
public IEnumerable <IRow> Read() { return(_reader.Read()); }
public string Read(string file) { return(_read.Read(file)); }
public IEnumerable <User> GetUsers() { return(_userReader.Read()); }
public string ExecuteAsync(IRead fileReader, Document document) { Debug.Assert(document != null); Debug.Assert(document.Statement != null); var logo64Base = fileReader.GetImagebase64(document.Logo); var quoteTemplate = fileReader.Read(TEMPLATE); var serviceTemplate = fileReader.Read(SERVICE_TEMPLATE); var materialsTemplate = fileReader.Read(MATERIAL_TEMPLATE); var updatedTemplate1 = ApplyHeaderAsync(quoteTemplate, document.Statement, document.Customer, logo64Base); var updatedTemplate2 = ApplySummaryAsync(updatedTemplate1, document.Statement); var statement = document.Statement; var servicesHtml = ApplyServices(statement.Services, serviceTemplate); var html = updatedTemplate2; var htmlWithServices = html.Replace(serviceTemplate, servicesHtml); var materialsBuilder = new StringBuilder(); var services = statement.Services; string htmlWithMaterial = null; bool hasMaterials = false; foreach (var service in services) { string materialsHtml = string.Empty; if (service.Materials == null) { service.Materials = new ObservableCollection<Material>(); } if (service.Materials.Count > 0) { hasMaterials = true; string materialsTable = ApplyMaterials(service, materialsTemplate); materialsBuilder.Append(materialsTable); materialsHtml = materialsBuilder.ToString(); htmlWithMaterial = htmlWithServices.Replace(materialsTemplate, materialsHtml).Replace("~SERVICE_NAME~", string.Empty); } } if (hasMaterials) { var destinationFile = string.Format("{0}{1}", Guid.NewGuid(), HtmlFile); return fileReader.CreateFile(htmlWithMaterial, destinationFile); } else { var data = fileReader.Read(SERVICE_MATERIAL_TEMPLATE); bool exists = htmlWithServices.Contains(data); string noMaterialsHtml = htmlWithServices.Replace(data, string.Empty); var destinationFile = string.Format("{0}{1}", Guid.NewGuid(), HtmlFile); return fileReader.CreateFile(noMaterialsHtml, destinationFile); } }
public IEnumerable <IRow> DetermineDeletes() { var input = _transforms.Aggregate(_inputReader.Read(), (current, transform) => current.Select(transform.Operate)); return(_outputReader.Read().Except(input, new KeyComparer(_context.Entity.GetPrimaryKey()))); }
public T Read(int key) { return(_read.Read(key)); }
public IEnumerable<IRow> Read() { IRow row; var rows = _parentReader.Read().ToArray(); // 1 or 0 records if (rows.Length == 0) { rows = _defaultRowReader.Read().ToArray(); if (rows.Length == 0) { yield break; } } row = rows[0]; foreach (var field in _context.Entity.GetAllFields()) { Parameter p = null; if (_parameters.ContainsKey(field.Alias)) { p = _parameters[field.Alias]; } else if (_parameters.ContainsKey(field.Name)) { p = _parameters[field.Name]; } if (p != null && p.Value != null) { if (Constants.CanConvert()[field.Type](p.Value)) { row[field] = field.InputType == "file" && p.Value == string.Empty ? row[field] : field.Convert(p.Value); var len = field.Length.Equals("max", StringComparison.OrdinalIgnoreCase) ? int.MaxValue : Convert.ToInt32(field.Length); if (p.Value != null && p.Value.Length > len) { if (field.ValidField != string.Empty) { var validField = _context.Entity.CalculatedFields.First(f => f.Alias == field.ValidField); row[validField] = false; } if (field.MessageField != string.Empty) { var messageField = _context.Entity.CalculatedFields.First(f => f.Alias == field.MessageField); row[messageField] = $"This field is limited to {len} characters. Anything more than that is truncated.|"; } } } else { if (field.ValidField != string.Empty) { var validField = _context.Entity.CalculatedFields.First(f => f.Alias == field.ValidField); row[validField] = false; } if (field.MessageField != string.Empty) { var messageField = _context.Entity.CalculatedFields.First(f => f.Alias == field.MessageField); switch (field.Type) { case "char": row[messageField] = "Must be a single chracter.|"; break; case "byte": row[messageField] = "Must be a whole number (not a fraction) between 0 and 255.|"; break; case "bool": case "boolean": row[messageField] = "Must be true of false.|"; break; case "int": case "int32": row[messageField] = "Must be a whole number (not a fraction) between −2,147,483,648 and 2,147,483,647.|"; break; case "short": case "int16": row[messageField] = "Must be a whole number (not a fraction) between -32768 and 32767.|"; break; case "long": case "int64": row[messageField] = "Must be a whole number (not a fraction) between -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807.|"; break; case "double": row[messageField] = "Must be a number no more than 15 digits and between between 3.4E-38 and 3.4E+38.|"; break; case "float": case "single": row[messageField] = "Must be a number no more than 7 digits and between between 1.7E-308 and 1.7E+308.|"; break; case "decimal": row[messageField] = $"Must be a number no more than {field.Precision} total digits, with {field.Scale} digits to the right of the decimal point.|"; break; default: row[messageField] = $"Can not convert {p.Value} to a {field.Type}.|"; break; } } } } } yield return row; }
public Validator(IRead reader) { exp = reader.Read().Split(" ").ToList(); }
public void Read() { action.Read(); }
public string ExecuteAsync(IRead fileReader, Document document) { Debug.Assert(document != null); Debug.Assert(document.Statement != null); var logo64Base = fileReader.GetImagebase64(document.Logo); var quoteTemplate = fileReader.Read(TEMPLATE); var serviceTemplate = fileReader.Read(SERVICE_TEMPLATE); var materialsTemplate = fileReader.Read(MATERIAL_TEMPLATE); var updatedTemplate1 = ApplyHeaderAsync(quoteTemplate, document.Statement, document.Customer, logo64Base); var updatedTemplate2 = ApplySummaryAsync(updatedTemplate1, document.Statement); var statement = document.Statement; var servicesHtml = ApplyServices(statement.Services, serviceTemplate); var html = updatedTemplate2; var htmlWithServices = html.Replace(serviceTemplate, servicesHtml); var materialsBuilder = new StringBuilder(); var services = statement.Services; string htmlWithMaterial = null; bool hasMaterials = false; foreach (var service in services) { string materialsHtml = string.Empty; if (service.Materials == null) { service.Materials = new ObservableCollection <Material>(); } if (service.Materials.Count > 0) { hasMaterials = true; string materialsTable = ApplyMaterials(service, materialsTemplate); materialsBuilder.Append(materialsTable); materialsHtml = materialsBuilder.ToString(); htmlWithMaterial = htmlWithServices.Replace(materialsTemplate, materialsHtml).Replace("~SERVICE_NAME~", string.Empty); } } if (hasMaterials) { var destinationFile = string.Format("{0}{1}", Guid.NewGuid(), HtmlFile); return(fileReader.CreateFile(htmlWithMaterial, destinationFile)); } else { var data = fileReader.Read(SERVICE_MATERIAL_TEMPLATE); bool exists = htmlWithServices.Contains(data); string noMaterialsHtml = htmlWithServices.Replace(data, string.Empty); var destinationFile = string.Format("{0}{1}", Guid.NewGuid(), HtmlFile); return(fileReader.CreateFile(noMaterialsHtml, destinationFile)); } }
public string Read(string file) => _reader.Read(file);
public IEnumerable <IRow> Read() { return(_internalReader.Read()); }
public IEnumerable <IRow> Read() { return(_streamWriter.Read()); }