public static void SetIdentifiers(FI fi, IdentifierType identifierType, string[] identifiers, SymmetryEntities dc) { IList<FIIdentifier> list = null; { var currentIDs = fi.FIIdentifiers.Where(x => x.IdentifierType == identifierType); if (currentIDs != null && currentIDs.Any()) list = currentIDs.ToList(); } foreach (var identifier in identifiers) { if (string.IsNullOrEmpty(identifier)) continue; if (list == null) { fi.FIIdentifiers.Add(new FIIdentifier { IdentifierType = identifierType, Identifier = identifier }); } else if (list.Any(x => string.Compare(x.Identifier, identifier, true) == 0)) // already exists { list.Remove(list.First(x => string.Compare(x.Identifier, identifier, true) == 0)); // remove from the list of existing } else { fi.FIIdentifiers.Add(new FIIdentifier { IdentifierType = identifierType, Identifier = identifier }); } } // if we have any left in the original list, then remove them all if (list != null && list.Any()) foreach (var v in list) dc.Entry(v).State = EntityState.Deleted; }
private static bool import(SymmetryEntities dc_, IEnumerable<AuctionInfo> infos_) { if (infos_ == null) return false; foreach (var info in infos_.Where(x=>x.HasRequiredInfoForAuctions())) import(dc_, info); return true; }
public static FI GetFIBySymmetryCode(string symmetryCode, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { return dc.FIs.SingleOrDefault(fi => fi.SymmetryCode.Equals(symmetryCode, StringComparison.InvariantCultureIgnoreCase)); } catch (Exception ex) { Exceptions.Rethrow("GetFIBySymmetryCode", behavior, ex); } return null; }
public static FI GetFI(int fiid, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { return dc.FIs.SingleOrDefault(f => f.FIID == fiid); } catch (Exception ex) { Exceptions.Rethrow("GetFI", behavior, ex); } return null; }
protected override ValidatedInstrument[] getValidatedInstruments(SymmetryEntities dc_, ExtractionServiceClient dsClient_, CredentialsHeader credentials_) { var allEDs = dc_.FIs.Where(x => x.InstrumentType == InstrumentType.IRFuture && x.Maturity >= DateTime.Today && x.SymmetryCode.StartsWith("ED")) .Where(x => x.Maturity.Value.Month % 3 == 0) .OrderBy(x => x.Maturity) .Take(12); var listOfInstruments = new List<InstrumentIdentifier>(); // find the market snap to which var marketSnap = QuoteHelpers.GetMarketSnap("CLOSE", m_markDate, dc_, ThrowBehavior.DontThrow); if (marketSnap == null) return null; var source = QuoteHelpers.GetQuoteSource("SYM", dc_, ThrowBehavior.DontThrow); if (source == null) return null; foreach (var ed in allEDs) { EDItem item = new EDItem(ed, dc_, marketSnap, source); if (item.CanRequestPrice) { m_items.Add(item); m_ricToOptionItem[item.OptionAbovePrice.ReutersTicker] = item.OptionAbovePrice; m_ricToOptionItem[item.OptionBelowPrice.ReutersTicker] = item.OptionBelowPrice; listOfInstruments.Add(new InstrumentIdentifier() { IdentifierValue = item.OptionBelowPrice.ReutersTicker, IdentifierType="RIC" }); listOfInstruments.Add(new InstrumentIdentifier() { IdentifierValue = item.OptionAbovePrice.ReutersTicker, IdentifierType="RIC" }); } } if (listOfInstruments.Count() > 0) { var v = ServiceHelpers.ValidateInstruments_FindUnValidated(listOfInstruments.ToArray(), dsClient_, ref credentials_); m_notValidatedIdentifiers = v.Item2; return v.Item1; } else return null; }
public static MarketSnap GetMarketSnap(string marketSnapCode, DateTime snapDate, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { return dc.MarketSnaps.SingleOrDefault(s => s.MarketSnapSchedule.MarketSnapCode.Equals(marketSnapCode, StringComparison.InvariantCultureIgnoreCase) && s.ValueDate == snapDate); } catch (Exception ex) { Exceptions.Rethrow("GetMarketSnap", behavior, ex); } return null; }
public static string[] GetFIIdentifiers(string symmetryCode, IdentifierType identifierType, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { return dc.FIIdentifiers.Where(x => x.FI.SymmetryCode.Equals(symmetryCode, StringComparison.InvariantCultureIgnoreCase) && x.IdentifierType == identifierType) .Select(x => x.Identifier).ToArray(); } catch (Exception ex_) { Exceptions.Rethrow("GetFIIdentiers", behavior, ex_); } return null; }
public static string GetFIIdentifier(string symmetryCode, IdentifierType identifierType, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { var fiID = dc.FIIdentifiers.SingleOrDefault(i => i.FI.SymmetryCode.Equals(symmetryCode, StringComparison.InvariantCultureIgnoreCase) && i.IdentifierType == identifierType); return fiID==null ? null : fiID.Identifier; } catch (Exception ex) { Exceptions.Rethrow("GetFIIdentifier", behavior, ex); } return null; }
public static MarketSnap GetLatestMarketSnapWithValues(string marketSnapCode, DateTime latestDate, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { var snap = dc.MarketSnaps.Where(s => s.MarketSnapSchedule.MarketSnapCode.Equals(marketSnapCode, StringComparison.InvariantCultureIgnoreCase)) .Where(v => v.ValueDate <= latestDate) .OrderByDescending(v => v.ValueDate).FirstOrDefault(v=>v.Quotes.Count>0); return snap; } catch (Exception ex) { Exceptions.Rethrow("GetLatestMarketSnap", behavior, ex); } return null; }
public static void CheckDatabase() { try { using (var dc = new SymmetryEntities()) { var fi = dc.FIs.First(); SLog.log.InfoFormat("Connected to the datasource/database: [{0}]/[{1}]", dc.Database.Connection.Database, dc.Database.Connection.DataSource); } } catch (Exception ex) { SLog.log.Error("Error connecting to the database", ex); } }
public static FI GetFutureByMaturity(string bloombergChain, DateTime maturity, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { var fi = dc.FIs.FirstOrDefault(i => ( i.InstrumentType == InstrumentType.IRFuture || i.InstrumentType == InstrumentType.BondFuture ) && i.Maturity.HasValue && i.Maturity.Value == maturity && i.SymmetryCode.StartsWith(bloombergChain)); return fi; } catch (Exception ex) { Exceptions.Rethrow("GetFutureByMaturity", behavior, ex); } return null; }
public static FI GetFIByIdentifier(string identifier, IdentifierType identifierType, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { var identifierEntry = dc.FIIdentifiers.SingleOrDefault(i => i.IdentifierType == identifierType && i.Identifier.Equals(identifier, StringComparison.InvariantCultureIgnoreCase)); if (identifierEntry != null) { return identifierEntry.FI; } } catch (Exception ex) { Exceptions.Rethrow("GetFIByIdentifier", behavior, ex); } return null; }
public static void SetOrUpdateIdentifier(FI fi, IdentifierType identifierType, string identifier, SymmetryEntities dc) { if (!string.IsNullOrWhiteSpace(identifier)) { var id = fi.FIIdentifiers.SingleOrDefault(i => i.IdentifierType == identifierType); if (id == null) { fi.FIIdentifiers.Add(new FIIdentifier { IdentifierType = identifierType, Identifier = identifier }); } else { if (id.Identifier != identifier) { id.Identifier = identifier; FIChangeTracking.SetModified(id, dc); } } } }
private List<FI> getAllBondsToPrice(SymmetryEntities dc_) { var superSet = Symmetry.Data.FIHelpers.GetFIByLiveDateAndInstrumentType( dc_: dc_, liveDate_: DateTime.Today.AddDays(-3d), instrumentType_: Data.Enums.InstrumentType.Bond ); // take out inactive bonds superSet = superSet.Where(x => x.IsInactive.HasValue == false || x.IsInactive.Value != 1).ToList(); // get rid of floater bonds superSet = superSet.Where(x => x.FIBond != null && (x.FIBond.IsFloater.HasValue == false || x.FIBond.IsFloater.Value == 0)) .ToList(); return superSet.Where(x => m_bondFilter(x)).ToList(); }
protected override ValidatedInstrument[] getValidatedInstruments(SymmetryEntities dc_, ExtractionServiceClient dsClient_, CredentialsHeader credentials_) { var allFixings = getAllSwaps(dc_); m_ric_to_FIs = new Dictionary<string, FI>(); var listOfInstruments = new List<InstrumentIdentifier>(); foreach (var fi in allFixings) { string[] rics = FIHelpers.GetFIIdentifiers(fi.SymmetryCode, IdentifierType.RIC, dc_, ThrowBehavior.DontThrow); if (rics == null || rics.Length==0) { SLog.log.WarnFormat("Cannot locate RIC for SymmetryCode:{0}", fi.SymmetryCode); continue; } Array.ForEach(rics, x => { m_ric_to_FIs.Add(x, fi); listOfInstruments.Add(new InstrumentIdentifier() { IdentifierType="RIC", IdentifierValue=x }); } ); } var t = ServiceHelpers.ValidateInstruments_FindUnValidated(listOfInstruments.ToArray(), dsClient_, ref credentials_); m_notValidatedIdentifiers = t.Item2; return t.Item1; }
public static Dictionary<string, int> LookupSwaps(FI fixing, List<string> swapTenors, SymmetryEntities dc) { var result = new Dictionary<string, int>(); if (swapTenors != null && swapTenors.Count > 0) { SortedSet<string> normalizedTenors = new SortedSet<string>(swapTenors.Select(t => (Tenor.FromString(t)).ToString())); foreach (var swap in FIHelpers.GetDerivativeInstruments(fixing, InstrumentType.IRSwap, dc)) { try { string swapTenorString = (Tenor.FromString(swap.Tenor)).ToString(); // normalize if (normalizedTenors.Contains(swapTenorString)) { result.Add(swapTenorString, swap.FIID); } } catch (Exception) { SLog.log.WarnFormat("Ignoring instrument {0} as unable to parse tenor {1}", swap.SymmetryCode, swap.Tenor); } } } return result; }
public static Dictionary<string, int> LookupMoneyMarkets(string currency, List<string> moneyMarketsIndices, SymmetryEntities dc) { var result = new Dictionary<string, int>(); if (moneyMarketsIndices != null) { foreach (var index in moneyMarketsIndices) { var fi = FIHelpers.GetFIBySymmetryCode(index, dc, ThrowBehavior.DontThrow); if (fi != null && !string.IsNullOrWhiteSpace(fi.Tenor)) { result.Add(fi.Tenor, fi.FIID); } } } else { foreach (var fi in FIHelpers.GetFIByTypeAndCurrency(currency, InstrumentType.IRFixing, dc)) { try { if (!string.IsNullOrEmpty(fi.Tenor)) { if (!result.ContainsKey(fi.Tenor)) { result.Add(fi.Tenor, fi.FIID); } } } catch (Exception ex) { SLog.log.WarnFormat("Error accessing instrument {0} for curve inclusion: {1}", fi.SymmetryCode, ex.Message); } } } return result; }
public static List<List<object>> CreateConstituentsTable(Dictionary<int, QuoteValues> quotes, List<int> fiOrder, SymmetryEntities dc) { try { var constituentsTable = new List<List<object>>(); constituentsTable.Add(new List<object> { "Symmetry Code", "Maturity", "Tenor", "Quote", "Impl Vol" }); foreach (var fiid in fiOrder) { if (quotes.ContainsKey(fiid)) { var quote = quotes[fiid]; try { var fi = FIHelpers.GetFI(fiid, dc); decimal scalar = 1M; if(fi.InstrumentType == InstrumentType.IRFixing || fi.InstrumentType == InstrumentType.IRSwap) { scalar = 100M; } constituentsTable.Add(new List<object> { fi.SymmetryCode, fi.Maturity.HasValue ? (double?)fi.Maturity.Value.ToOADate() : null, fi.Tenor, quote.GetValue(QuoteValueType.Price) * scalar, quote.GetValue(QuoteValueType.ImpliedVol) * 100M }); } catch (Exception ex) { SLog.log.Warn("Error retrieving instrument info " + fiid, ex); } } } return constituentsTable; } catch(Exception ex) { SLog.log.Error("Error composing constituents table", ex); } return null; }
public static MarketSnap GetOrCreateMarketSnap(string marketSnapCode, DateTime snapDate, SymmetryEntities dc, ThrowBehavior behavior = ThrowBehavior.Throw) { try { var schedule = dc.MarketSnapSchedules.Single(s => s.MarketSnapCode.Equals(marketSnapCode)); var snap = dc.MarketSnaps.SingleOrDefault(s => s.MarketSnapSchedule.MarketSnapCode.Equals(marketSnapCode, StringComparison.InvariantCultureIgnoreCase) && s.ValueDate == snapDate); if (snap == null) { snap = new MarketSnap { ValueDate = snapDate, MarketSnapSchedule = schedule }; dc.MarketSnaps.Add(snap); } return snap; } catch (Exception ex) { Exceptions.Rethrow("GetOrCreateMarketSnap", behavior, ex); } return null; }
private bool saveValues(IList<ExtractClass> items_, SymmetryEntities dc_, string marketSnapCode_) { if (items_ == null || !items_.Any()) return false; foreach (var v in items_.Where(x => x.Value.HasValue && x.CloseDate.HasValue)) { try { MarketSnap snapToUse = QuoteHelpers.GetOrCreateMarketSnap(marketSnapCode_, v.CloseDate.Value.Date, dc_, ThrowBehavior.DontThrow); decimal adjustedPrice = Convert.ToDecimal(v.Value.Value)/100M; var fi = FIHelpers.GetFIByAnyIdentifier(v.RIC, dc_); SaveQuote(fi.FIID, QuoteValueType.Price, getQuoteSource(_symmetryQuoteSource, dc_), adjustedPrice, dc_, snapToUse); SaveQuoteAsMLPMLP(fi.FIID, QuoteValueType.Price, adjustedPrice, dc_, v.CloseDate.Value); } catch (Exception ex_) { SLog.log.Error(string.Format("Error saving quote for {0}", v.RIC), ex_); } } return true; }
private static void checkDatabase(SymmetryEntities dc) { Logger.Info( string.Format("about to operate on database {0}.{1}", dc.Database.Connection.DataSource, dc.Database.Connection.Database), typeof(USDataUploader)); Console.WriteLine("continue?"); Console.ReadLine(); }
private IList<FI> getAllSwaps(SymmetryEntities dc_) { return dc_.FIs.Where(x => x.InstrumentType == InstrumentType.IRSwap).ToList(); }
public override bool ProcessRetrievedFTPFile(SymmetryEntities dc_, string marketSnapCode_, DateTime valueDate_, string filePath_) { var loader = new CSVLoader<ExtractClass>(new Dictionary<string, string> { {AttributeHelper.GetSingleAttribute<RSSFieldAttribute>(FieldsToReturn.RIC).FieldName, "RIC"}, {AttributeHelper.GetSingleAttribute<RSSFieldAttribute>(FieldsToReturn.BidPrice).FieldName, "BidPrice"}, {AttributeHelper.GetSingleAttribute<RSSFieldAttribute>(FieldsToReturn.AskPrice).FieldName, "AskPrice"}, {AttributeHelper.GetSingleAttribute<RSSFieldAttribute>(FieldsToReturn.BidAskUpdateTime).FieldName,"BidAskDate"}, }); var list = loader.Load(filePath_); return saveResponses(list, dc_, QuoteHelpers.GetOrCreateMarketSnap(marketSnapCode_, valueDate_, dc_)); }
public override ReutersDSS.FTP.InputList BuildFTPInputList(SymmetryEntities dc_, ExtractionServiceClient dsClient_) { return new ReutersDSS.FTP.InputList() { InputListAction="Replace", Name=ftpInstrumentList.ToString(), Instrument=getAllSwaps(dc_) .Select(x=>FIHelpers.GetFIIdentifiers(x.SymmetryCode,IdentifierType.RIC,dc_,ThrowBehavior.DontThrow)) .Where(x=>x!=null && x.Length>0) .SelectMany(x=>x) .Select(x=>new ReutersDSS.FTP.Instrument() { IdentifierType="RIC", Identifier=x, }).ToList() }; }
private bool saveResponses(IList<ExtractClass> items_, SymmetryEntities dc_, MarketSnap snap_) { if (items_ == null || !items_.Any()) return false; var symmetryCodeToPrices = new SortedDictionary<string, decimal?[]>(); int objectLength = Enum.GetValues(typeof(RIC_SOURCE)).Length; foreach (var response in items_.Where(x=>x.BidPrice.HasValue && x.AskPrice.HasValue)) { try { var fi = FIHelpers.GetFIByAnyIdentifier(response.RIC, dc_, ThrowBehavior.Throw); // extract bid / ask price from line var scaledValue = Convert.ToDecimal(response.BidPrice.Value + response.AskPrice.Value)/2/100; // save this particular source of a price var ricSource = RICHelper.GetSourceFromRIC(response.RIC); SaveQuote(fi.FIID, QuoteValueType.Price, getQuoteSource(ricSource, dc_), scaledValue, dc_, snap_); // get array to store decimal?[] values; if (!symmetryCodeToPrices.ContainsKey(fi.SymmetryCode)) { values = new decimal?[objectLength]; symmetryCodeToPrices[fi.SymmetryCode] = values; } else { values = symmetryCodeToPrices[fi.SymmetryCode]; } // if the bidaskdate isn't the snapDate (i.e. =stale price), then don't want to include it in the average if (response.BidAskDate.HasValue && response.BidAskDate.Value.Date < snap_.ValueDate) { SLog.log.InfoFormat( "Not going to include quote with RIC=[{0}] as snapDate is {1} which is stale relative to {2}", response.RIC, response.BidAskDate.Value, snap_.ValueDate); continue; } // store in array to take average later RIC_SOURCE src = RICHelper.GetRICsourceFromRIC(response.RIC); values[(int) src] = scaledValue; } catch (Exception ex_) { SLog.log.Error( string.Format("Error extracting {0} pricing values from Datascope response row ({1})", sName, response.RIC), ex_); } } foreach (var code in symmetryCodeToPrices.Keys) { var nonZeros = symmetryCodeToPrices[code].Where(x => x.HasValue); if (!nonZeros.Any()) continue; decimal averagedValue = nonZeros.Select(x => x.Value).Average(); var fi = FIHelpers.GetFIBySymmetryCode(code, dc_); // save quote to 'SYM' for this market snap SaveQuote( fiid_: fi.FIID, quoteType_: QuoteValueType.Price, quoteSource_: getQuoteSource(_symmetryQuoteSource, dc_), value_: averagedValue, dc_: dc_, snap_: snap_); } return true; }
protected override void processResponsesFromDataScope(SymmetryEntities dc_, MarketSnap snap_, string marketSnapCode_) { OutputToCSV(m_resultsFromDataScope); var list = new List<ExtractClass>(); foreach(var response in m_resultsFromDataScope) { foreach(var row in response.Rows) { try { var ric = GetValueFromObjectArray<string>((int)FieldsToReturn.RIC, row, ThrowBehavior.Throw); // extract bid / ask price from line var bid = GetValueFromObjectArray<double>((int)FieldsToReturn.BidPrice, row, ThrowBehavior.Throw); var ask = GetValueFromObjectArray<double>((int)FieldsToReturn.AskPrice, row, ThrowBehavior.Throw); list.Add(new ExtractClass() { RIC = ric, BidPrice = bid, AskPrice = ask }); } catch (Exception ex_) { SLog.log.Error(string.Format("Error extracting {0} pricing values from Datascope response row ({1})", sName, ServiceHelpers.ToCsvLine(row)), ex_); } } } saveResponses(list, dc_, snap_); }
private static FIIdentifier findCusipIdentifier(SymmetryEntities dc_, AuctionInfo info_) { var cusipIdentifier = dc_.FIIdentifiers.FirstOrDefault( x => string.Compare(info_.Cusip, x.Identifier, StringComparison.OrdinalIgnoreCase) == 0); if (cusipIdentifier == null) { // can we find by assuming that the cusip is contained within the ISIN?.... var fi = dc_.FIs.FirstOrDefault( x => x.InstrumentType == Data.Enums.InstrumentType.Bond && x.SymmetryCode.ToUpper().Contains(info_.Cusip.ToUpper())); if (fi == null) { SLog.log.DebugFormat( "Couldn't find bond to update for auction info with cusip={0} ; issueDate={1} ; maturity={2}", info_.Cusip, info_.IssueDate, info_.Maturity); return null; } // let's take the opportunity to add in the cusip identifier cusipIdentifier = new FIIdentifier { FIID = fi.FIID, FI = fi, Identifier = info_.Cusip, IdentifierType = Data.Enums.IdentifierType.CUSIP }; dc_.FIIdentifiers.Add(cusipIdentifier); } return cusipIdentifier; }
private static void import(SymmetryEntities dc_, AuctionInfo info_) { var cusipIdentifier = findCusipIdentifier(dc_, info_); if (cusipIdentifier == null) return; // take the opportunity to update the coupon if it's different if (cusipIdentifier.FI != null && cusipIdentifier.FI.FIBond != null && info_.Coupon.HasValue && Math.Abs(Convert.ToDouble(cusipIdentifier.FI.FIBond.Coupon) - info_.Coupon.Value) > 1e-3) { SLog.log.InfoFormat("Changing coupon of {0} from {1} to {2}", cusipIdentifier.Identifier, cusipIdentifier.FI.FIBond.Coupon, info_.Coupon); cusipIdentifier.FI.FIBond.Coupon = Convert.ToDecimal(info_.Coupon.Value); FIChangeTracking.SetModified(cusipIdentifier.FI.FIBond, dc_); dc_.SaveChanges(); } bool found = false; foreach (var auction in dc_.FIBondAuctions.Where(x => x.FIID == cusipIdentifier.FIID)) { if (auction.AuctionDate == info_.AuctionDate.Value) { //SLog.log.DebugFormat("Auction already set up for {0} on {1}", info_.Cusip, info_.AuctionDate.Value); if (!auction.EffectiveDate.HasValue) { SLog.log.InfoFormat("Updating auction effective date to {0}", info_.IssueDate.Value); auction.EffectiveDate = info_.IssueDate.Value; FIChangeTracking.SetModified(auction, dc_); } found = true; break; } } if (found) { dc_.SaveChanges(); return; } SLog.log.InfoFormat("Setting up auction for {0} on {1}", info_.Cusip, info_.AuctionDate.Value); var newAuction = new FIBondAuction() { FIID = cusipIdentifier.FIID, FIBond = dc_.FIBonds.FirstOrDefault(x => x.FIID == cusipIdentifier.FIID), AuctionDate = info_.AuctionDate.Value, EffectiveDate = info_.IssueDate.Value, Term = info_.Term.Value }; dc_.FIBondAuctions.Add(newAuction); dc_.SaveChanges(); }
public override bool ProcessRetrievedFTPFile(SymmetryEntities dc_, string marketSnapCode_, DateTime valueDate_, string filePath_) { var loader = new CSVLoader<ExtractClass>(new Dictionary<string, string> { {AttributeHelper.GetSingleAttribute<RSSFieldAttribute>(FieldsToReturn.RIC).FieldName, "RIC"}, {AttributeHelper.GetSingleAttribute<RSSFieldAttribute>(FieldsToReturn.UniversalClosePrice).FieldName, "Value"}, {AttributeHelper.GetSingleAttribute<RSSFieldAttribute>(FieldsToReturn.UniversalClosePriceDate).FieldName, "CloseDate"}, }); var extracted = loader.Load(filePath_); return saveValues(extracted, dc_, marketSnapCode_); }
protected override void processResponsesFromDataScope(SymmetryEntities dc_, MarketSnap snap_, string marketSnapCode_) { OutputToCSV(m_resultsFromDataScope); var list = new List<ExtractClass>(); foreach (var response in m_resultsFromDataScope) { foreach (var row in response.Rows) { try { // extract values var ric = GetValueFromObjectArray<string>((int)FieldsToReturn.RIC, row, ThrowBehavior.Throw); var fi = m_ric_to_FIs[ric]; var fix = GetValueFromObjectArray<double>((int)FieldsToReturn.UniversalClosePrice, row,ThrowBehavior.Throw); var closeDate = GetValueFromObjectArray<DateTime>((int)FieldsToReturn.UniversalClosePriceDate, row, ThrowBehavior.Throw); list.Add(new ExtractClass() { RIC = ric, Value = fix, CloseDate = closeDate }); } catch (Exception ex_) { SLog.log.Error(string.Format("Error extracting {0} pricing values from Datascope response row ({1})", sName, ServiceHelpers.ToCsvLine(row)), ex_); } } } saveValues(list, dc_, snap_.MarketSnapSchedule.MarketSnapCode); }