public void Unsubscribe <T>(string channel, string subscriberKey) { var channelKey = new ChannelKey(channel, typeof(T)); List <Subscription> subs = GetSubscriptions(channelKey); subs.RemoveAll(s => s.SusbcriberKey == subscriberKey); }
public PooledClientChannel(IClientConnectionPool pool, ChannelKey key) { Guard.ArgumentNotNull(pool, nameof(pool)); _pool = pool; _innerChannel = _pool.BorrowChannel(key); this._key = key; }
public override int GetHashCode() { unchecked { return(((ChannelKey != null ? ChannelKey.GetHashCode() : 0) * 397) ^ (Exception != null ? Exception.GetHashCode() : 0)); } }
public void Subscribe <T>(string channel, string subscriberKey, Action <T> response) { var channelKey = new ChannelKey(channel, typeof(T)); List <Subscription> subs = GetSubscriptions(channelKey); subs.RemoveAll(s => s.SusbcriberKey == subscriberKey); subs.Add(new Subscription(subscriberKey, response)); Channels[channelKey] = subs; }
public INiftyClientChannel BorrowChannel(ChannelKey key) { var connector = new FramedClientConnector(key.IpEndPoint.Address.ToString(), key.IpEndPoint.Port, _options.LoggerFactory); var channel = _thriftClientManager.CreateChannelAsync(connector, TimeSpan.FromMilliseconds(key.ConnectionTimeout), TimeSpan.FromMilliseconds(key.ReceiveTimeout), TimeSpan.FromMilliseconds(key.ReadTimeout), TimeSpan.FromMilliseconds(key.WriteTimeout), _options.MaxFrameSize, key.SslConfig, _options.SocketProxy); return(channel.GetAwaiter().GetResult()); }
public void Publish(string channel) { var channelKey = new ChannelKey(channel, null); List <Subscription> subs = GetSubscriptions(channelKey); foreach (var sub in subs) { if (sub.Reponse.IsAlive) { Action subResponse = sub.Reponse.Target as Action; subResponse?.Invoke(); } } }
public void Publish <T>(string channel, T parameter) { var channelKey = new ChannelKey(channel, typeof(T)); List <Subscription> subs = GetSubscriptions(channelKey); foreach (var sub in subs) { if (sub.Reponse.IsAlive) { Action <T> subResponse = sub.Reponse.Target as Action <T>; subResponse?.Invoke(parameter); } } }
private Series GetSeriesInfo(Series timeDomainSeries, string channelDesignation, string measurementCharacteristicName) { string channelName; string measurementTypeName; string phaseName; string seriesTypeName; ChannelKey channelKey; SeriesKey seriesKey; channelName = string.Concat(timeDomainSeries.Channel.Name, " ", channelDesignation); measurementTypeName = timeDomainSeries.Channel.MeasurementType.Name; phaseName = timeDomainSeries.Channel.Phase.Name; seriesTypeName = timeDomainSeries.SeriesType.Name; channelKey = new ChannelKey(timeDomainSeries.Channel.LineID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName); seriesKey = new SeriesKey(channelKey, seriesTypeName); return(GetSeriesInfo(timeDomainSeries.Channel.Meter, channelKey, seriesKey)); }
// Static Methods private static Series GetSeriesInfo(MeterInfoDataContext meterInfo, Meter meter, DataGroup dataGroup, string measurementTypeName, string phaseName) { int lineID; string measurementCharacteristicName; string seriesTypeName; char typeDesignation; char phaseDesignation; string channelName; DataContextLookup<ChannelKey, Channel> channelLookup; DataContextLookup<SeriesKey, Series> seriesLookup; DataContextLookup<string, MeasurementType> measurementTypeLookup; DataContextLookup<string, MeasurementCharacteristic> measurementCharacteristicLookup; DataContextLookup<string, Phase> phaseLookup; DataContextLookup<string, SeriesType> seriesTypeLookup; ChannelKey channelKey; SeriesKey seriesKey; lineID = dataGroup.Line.ID; measurementCharacteristicName = "Instantaneous"; seriesTypeName = "Values"; typeDesignation = (measurementTypeName == "Current") ? 'I' : measurementTypeName[0]; phaseDesignation = (phaseName == "RES") ? 'R' : phaseName[0]; channelName = string.Concat(typeDesignation, phaseDesignation); channelLookup = new DataContextLookup<ChannelKey, Channel>(meterInfo, channel => new ChannelKey(channel)) .WithFilterExpression(channel => channel.MeterID == meter.ID) .WithFilterExpression(channel => channel.LineID == dataGroup.Line.ID); seriesLookup = new DataContextLookup<SeriesKey, Series>(meterInfo, series => new SeriesKey(series)) .WithFilterExpression(series => series.Channel.Meter.ID == meter.ID) .WithFilterExpression(series => series.Channel.Line.ID == dataGroup.Line.ID); measurementTypeLookup = new DataContextLookup<string, MeasurementType>(meterInfo, measurementType => measurementType.Name); measurementCharacteristicLookup = new DataContextLookup<string, MeasurementCharacteristic>(meterInfo, measurementCharacteristic => measurementCharacteristic.Name); phaseLookup = new DataContextLookup<string, Phase>(meterInfo, phase => phase.Name); seriesTypeLookup = new DataContextLookup<string, SeriesType>(meterInfo, seriesType => seriesType.Name); channelKey = new ChannelKey(lineID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName); seriesKey = new SeriesKey(channelKey, seriesTypeName); return seriesLookup.GetOrAdd(seriesKey, key => { SeriesType seriesType = seriesTypeLookup.GetOrAdd(key.SeriesType, name => new SeriesType() { Name = name, Description = name }); Channel channel = channelLookup.GetOrAdd(channelKey, chKey => { MeasurementType measurementType = measurementTypeLookup.GetOrAdd(chKey.MeasurementType, name => new MeasurementType() { Name = name, Description = name }); MeasurementCharacteristic measurementCharacteristic = measurementCharacteristicLookup.GetOrAdd(chKey.MeasurementCharacteristic, name => new MeasurementCharacteristic() { Name = name, Description = name }); Phase phase = phaseLookup.GetOrAdd(chKey.Phase, name => new Phase() { Name = name, Description = name }); return new Channel() { Meter = meter, Line = dataGroup.Line, MeasurementType = measurementType, MeasurementCharacteristic = measurementCharacteristic, Phase = phase, Name = chKey.Name, SamplesPerHour = dataGroup.SamplesPerHour, PerUnitValue = 0, HarmonicGroup = 0, Description = string.Concat(measurementCharacteristic.Name, " ", measurementType.Name, " ", phase.Name), Enabled = 1 }; }); return new Series() { SeriesType = seriesType, Channel = channel, SourceIndexes = string.Empty }; }); }
private List <Subscription> GetSubscriptions(ChannelKey key) => Channels.ContainsKey(key) ? Channels[key] ?? new List <Subscription>() : new List <Subscription>();
public void ClearChannel(ChannelKey key) { }
public void ReturnChannel(ChannelKey key, INiftyClientChannel channel) { channel.CloseAsync(); }
// Static Methods private static Series GetSeriesInfo(Meter meter, DataGroup dataGroup, string measurementTypeName, string phaseName, int assetID) { string measurementCharacteristicName = "Instantaneous"; string seriesTypeName = "Values"; char typeDesignation = (measurementTypeName == "Current") ? 'I' : measurementTypeName[0]; string phaseDesignation = (phaseName == "RES") ? "R" : phaseName.TrimEnd('N'); string channelName = string.Concat(typeDesignation, phaseDesignation); ChannelKey channelKey = new ChannelKey(assetID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName); SeriesKey seriesKey = new SeriesKey(channelKey, seriesTypeName); Series dbSeries = meter.Channels .SelectMany(channel => channel.Series) .FirstOrDefault(series => seriesKey.Equals(new SeriesKey(series))); if ((object)dbSeries == null) { Channel dbChannel = meter.Channels .FirstOrDefault(channel => channelKey.Equals(new ChannelKey(channel))); //need to get Asset based on the asset of the datagroup or the connected assets Asset asset = dataGroup.Asset; if (asset.ID != assetID) { List <Asset> connectedAssets = asset.ConnectedAssets.ToList(); asset = connectedAssets.Find(item => item.ID == assetID); } if ((object)dbChannel == null) { MeasurementType measurementType = new MeasurementType() { Name = measurementTypeName }; MeasurementCharacteristic measurementCharacteristic = new MeasurementCharacteristic() { Name = measurementCharacteristicName }; Phase phase = new Phase() { Name = phaseName }; dbChannel = new Channel() { MeterID = meter.ID, AssetID = assetID, MeasurementTypeID = measurementType.ID, MeasurementCharacteristicID = measurementCharacteristic.ID, PhaseID = phase.ID, Name = channelKey.Name, SamplesPerHour = dataGroup.SamplesPerHour, Description = string.Concat(measurementCharacteristicName, " ", measurementTypeName, " ", phaseName), Enabled = true, Meter = meter, Asset = asset, MeasurementType = measurementType, MeasurementCharacteristic = measurementCharacteristic, Phase = phase, Series = new List <Series>() }; meter.Channels.Add(dbChannel); } SeriesType seriesType = new SeriesType() { Name = seriesTypeName }; dbSeries = new Series() { ChannelID = dbChannel.ID, SeriesTypeID = seriesType.ID, SourceIndexes = string.Empty, Channel = dbChannel, SeriesType = seriesType }; dbChannel.Series.Add(dbSeries); } return(dbSeries); }
// Static Methods private static Series GetSeriesInfo(Meter meter, DataGroup dataGroup, string measurementTypeName, string phaseName) { int lineID = dataGroup.Line.ID; string measurementCharacteristicName = "Instantaneous"; string seriesTypeName = "Values"; char typeDesignation = (measurementTypeName == "Current") ? 'I' : measurementTypeName[0]; string phaseDesignation = (phaseName == "RES") ? "R" : phaseName.TrimEnd('N'); string channelName = string.Concat(typeDesignation, phaseDesignation); ChannelKey channelKey = new ChannelKey(lineID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName); SeriesKey seriesKey = new SeriesKey(channelKey, seriesTypeName); Series dbSeries = meter.Channels .SelectMany(channel => channel.Series) .FirstOrDefault(series => seriesKey.Equals(new SeriesKey(series))); if ((object)dbSeries == null) { using (AdoDataConnection connection = meter.ConnectionFactory()) { Channel dbChannel = meter.Channels .FirstOrDefault(channel => channelKey.Equals(new ChannelKey(channel))); if ((object)dbChannel == null) { TableOperations <Channel> channelTable = new TableOperations <Channel>(connection); TableOperations <MeasurementType> measurementTypeTable = new TableOperations <MeasurementType>(connection); TableOperations <MeasurementCharacteristic> measurementCharacteristicTable = new TableOperations <MeasurementCharacteristic>(connection); TableOperations <Phase> phaseTable = new TableOperations <Phase>(connection); MeasurementType measurementType = measurementTypeTable.GetOrAdd(measurementTypeName); MeasurementCharacteristic measurementCharacteristic = measurementCharacteristicTable.GetOrAdd(measurementCharacteristicName); Phase phase = phaseTable.GetOrAdd(phaseName); dbChannel = new Channel() { MeterID = meter.ID, LineID = lineID, MeasurementTypeID = measurementType.ID, MeasurementCharacteristicID = measurementCharacteristic.ID, PhaseID = phase.ID, Name = channelKey.Name, SamplesPerHour = dataGroup.SamplesPerHour, Description = string.Concat(measurementCharacteristicName, " ", measurementTypeName, " ", phaseName), Enabled = true }; channelTable.AddNewRecord(dbChannel); dbChannel.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY"); meter.Channels = null; } TableOperations <Series> seriesTable = new TableOperations <Series>(connection); TableOperations <SeriesType> seriesTypeTable = new TableOperations <SeriesType>(connection); SeriesType seriesType = seriesTypeTable.GetOrAdd(seriesTypeName); dbSeries = new Series() { ChannelID = dbChannel.ID, SeriesTypeID = seriesType.ID, SourceIndexes = string.Empty }; seriesTable.AddNewRecord(dbSeries); dbSeries.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY"); dbChannel.Series = null; dbSeries = meter.Channels .SelectMany(channel => channel.Series) .First(series => seriesKey.Equals(new SeriesKey(series))); } } return(dbSeries); }
// Static Methods private static Series GetSeriesInfo(MeterInfoDataContext meterInfo, Meter meter, DataGroup dataGroup, string measurementTypeName, string phaseName) { int lineID; string measurementCharacteristicName; string seriesTypeName; char typeDesignation; char phaseDesignation; string channelName; DataContextLookup <ChannelKey, Channel> channelLookup; DataContextLookup <SeriesKey, Series> seriesLookup; DataContextLookup <string, MeasurementType> measurementTypeLookup; DataContextLookup <string, MeasurementCharacteristic> measurementCharacteristicLookup; DataContextLookup <string, Phase> phaseLookup; DataContextLookup <string, SeriesType> seriesTypeLookup; ChannelKey channelKey; SeriesKey seriesKey; lineID = dataGroup.Line.ID; measurementCharacteristicName = "Instantaneous"; seriesTypeName = "Values"; typeDesignation = (measurementTypeName == "Current") ? 'I' : measurementTypeName[0]; phaseDesignation = (phaseName == "RES") ? 'R' : phaseName[0]; channelName = string.Concat(typeDesignation, phaseDesignation); channelLookup = new DataContextLookup <ChannelKey, Channel>(meterInfo, channel => new ChannelKey(channel)) .WithFilterExpression(channel => channel.MeterID == meter.ID) .WithFilterExpression(channel => channel.LineID == dataGroup.Line.ID) .WithFilterExpression(channel => channel.MeasurementType.Name == measurementTypeName) .WithFilterExpression(channel => channel.MeasurementCharacteristic.Name == measurementCharacteristicName) .WithFilterExpression(channel => channel.Phase.Name == phaseName); seriesLookup = new DataContextLookup <SeriesKey, Series>(meterInfo, series => new SeriesKey(series)) .WithFilterExpression(series => series.Channel.Meter.ID == meter.ID) .WithFilterExpression(series => series.Channel.Line.ID == dataGroup.Line.ID) .WithFilterExpression(series => series.Channel.MeasurementType.Name == measurementTypeName) .WithFilterExpression(series => series.Channel.MeasurementCharacteristic.Name == measurementCharacteristicName) .WithFilterExpression(series => series.Channel.Phase.Name == phaseName) .WithFilterExpression(series => series.SeriesType.Name == seriesTypeName); measurementTypeLookup = new DataContextLookup <string, MeasurementType>(meterInfo, measurementType => measurementType.Name); measurementCharacteristicLookup = new DataContextLookup <string, MeasurementCharacteristic>(meterInfo, measurementCharacteristic => measurementCharacteristic.Name); phaseLookup = new DataContextLookup <string, Phase>(meterInfo, phase => phase.Name); seriesTypeLookup = new DataContextLookup <string, SeriesType>(meterInfo, seriesType => seriesType.Name); channelKey = new ChannelKey(lineID, 0, channelName, measurementTypeName, measurementCharacteristicName, phaseName); seriesKey = new SeriesKey(channelKey, seriesTypeName); return(seriesLookup.GetOrAdd(seriesKey, key => { SeriesType seriesType = seriesTypeLookup.GetOrAdd(key.SeriesType, name => new SeriesType() { Name = name, Description = name }); Channel channel = channelLookup.GetOrAdd(channelKey, chKey => { MeasurementType measurementType = measurementTypeLookup.GetOrAdd(chKey.MeasurementType, name => new MeasurementType() { Name = name, Description = name }); MeasurementCharacteristic measurementCharacteristic = measurementCharacteristicLookup.GetOrAdd(chKey.MeasurementCharacteristic, name => new MeasurementCharacteristic() { Name = name, Description = name }); Phase phase = phaseLookup.GetOrAdd(chKey.Phase, name => new Phase() { Name = name, Description = name }); return new Channel() { Meter = meter, Line = dataGroup.Line, MeasurementType = measurementType, MeasurementCharacteristic = measurementCharacteristic, Phase = phase, Name = chKey.Name, SamplesPerHour = dataGroup.SamplesPerHour, PerUnitValue = 0, HarmonicGroup = 0, Description = string.Concat(measurementCharacteristic.Name, " ", measurementType.Name, " ", phase.Name), Enabled = 1 }; }); return new Series() { SeriesType = seriesType, Channel = channel, SourceIndexes = string.Empty }; })); }
private void AddUndefinedChannels(MeterDataSet meterDataSet) { List <DataSeries> undefinedDataSeries = meterDataSet.DataSeries .Concat(meterDataSet.Digitals) .Where(dataSeries => (object)dataSeries.SeriesInfo.Channel.Line == null) .ToList(); if (undefinedDataSeries.Count <= 0) { return; } Meter meter = meterDataSet.Meter; if (meter.MeterLines.Count == 0) { Log.Warn($"Unable to automatically add channels to meter {meterDataSet.Meter.Name} because there are no lines associated with that meter."); return; } if (meter.MeterLines.Count > 1) { Log.Warn($"Unable to automatically add channels to meter {meterDataSet.Meter.Name} because there are too many lines associated with that meter."); return; } Line line = meter.MeterLines .Select(meterLine => meterLine.Line) .Single(); foreach (DataSeries series in undefinedDataSeries) { series.SeriesInfo.Channel.LineID = line.ID; } using (AdoDataConnection connection = meterDataSet.CreateDbConnection()) { TableOperations <MeasurementType> measurementTypeTable = new TableOperations <MeasurementType>(connection); TableOperations <MeasurementCharacteristic> measurementCharacteristicTable = new TableOperations <MeasurementCharacteristic>(connection); TableOperations <Phase> phaseTable = new TableOperations <Phase>(connection); TableOperations <SeriesType> seriesTypeTable = new TableOperations <SeriesType>(connection); Dictionary <string, MeasurementType> measurementTypeLookup = undefinedDataSeries .Select(dataSeries => dataSeries.SeriesInfo.Channel.MeasurementType) .DistinctBy(measurementType => measurementType.Name) .Select(measurementType => measurementTypeTable.GetOrAdd(measurementType.Name, measurementType.Description)) .ToDictionary(measurementType => measurementType.Name); Dictionary <string, MeasurementCharacteristic> measurementCharacteristicLookup = undefinedDataSeries .Select(dataSeries => dataSeries.SeriesInfo.Channel.MeasurementCharacteristic) .DistinctBy(measurementCharacteristic => measurementCharacteristic.Name) .Select(measurementCharacteristic => measurementCharacteristicTable.GetOrAdd(measurementCharacteristic.Name, measurementCharacteristic.Description)) .ToDictionary(measurementCharacteristic => measurementCharacteristic.Name); Dictionary <string, Phase> phaseLookup = undefinedDataSeries .Select(dataSeries => dataSeries.SeriesInfo.Channel.Phase) .DistinctBy(phase => phase.Name) .Select(phase => phaseTable.GetOrAdd(phase.Name, phase.Description)) .ToDictionary(phase => phase.Name); Dictionary <string, SeriesType> seriesTypeLookup = undefinedDataSeries .Select(dataSeries => dataSeries.SeriesInfo.SeriesType) .DistinctBy(seriesType => seriesType.Name) .Select(seriesType => seriesTypeTable.GetOrAdd(seriesType.Name, seriesType.Description)) .ToDictionary(seriesType => seriesType.Name); Dictionary <ChannelKey, Channel> channelLookup = meter.Channels .GroupBy(channel => new ChannelKey(channel)) .ToDictionary(grouping => { if (grouping.Count() > 1) { Log.Warn($"Detected duplicate channel key: {grouping.First().ID}"); } return(grouping.Key); }, grouping => grouping.First()); List <Channel> undefinedChannels = undefinedDataSeries .Select(dataSeries => dataSeries.SeriesInfo.Channel) .GroupBy(channel => new ChannelKey(channel)) .Where(grouping => !channelLookup.ContainsKey(grouping.Key)) .Select(grouping => grouping.First()) .ToList(); TableOperations <Channel> channelTable = new TableOperations <Channel>(connection); // Add all undefined channels to the database foreach (Channel channel in undefinedChannels) { string measurementTypeName = channel.MeasurementType.Name; string measurementCharacteristicName = channel.MeasurementCharacteristic.Name; string phaseName = channel.Phase.Name; channel.MeterID = meter.ID; channel.LineID = line.ID; channel.MeasurementTypeID = measurementTypeLookup[measurementTypeName].ID; channel.MeasurementCharacteristicID = measurementCharacteristicLookup[measurementCharacteristicName].ID; channel.PhaseID = phaseLookup[phaseName].ID; channel.Enabled = true; // If the per-unit value was not specified in the input file, // we can obtain the per-unit value from the line configuration // if the channel happens to be an instantaneous or RMS voltage if (!channel.PerUnitValue.HasValue) { if (IsVoltage(channel)) { if (IsLineToNeutral(channel)) { channel.PerUnitValue = (line.VoltageKV * 1000.0D) / Sqrt3; } else if (IsLineToLine(channel)) { channel.PerUnitValue = line.VoltageKV * 1000.0D; } } } channelTable.AddNewRecord(channel); } if (undefinedChannels.Count > 0) { // Refresh the channel lookup to // include all the new channels meter.Channels = null; channelLookup = meter.Channels .GroupBy(channel => new ChannelKey(channel)) .ToDictionary(grouping => grouping.Key, grouping => grouping.First()); } Dictionary <SeriesKey, Series> seriesLookup = meter.Channels .SelectMany(channel => channel.Series) .Where(series => series.SourceIndexes == "") .GroupBy(series => new SeriesKey(series)) .ToDictionary(grouping => { if (grouping.Count() > 1) { Log.Warn($"Detected duplicate series key: {grouping.First().ID}"); } return(grouping.Key); }, grouping => grouping.First()); List <Series> undefinedSeries = undefinedDataSeries .SelectMany(dataSeries => dataSeries.SeriesInfo.Channel.Series) .GroupBy(series => new SeriesKey(series)) .Where(grouping => !seriesLookup.ContainsKey(grouping.Key)) .Select(grouping => grouping.First()) .ToList(); TableOperations <Series> seriesTable = new TableOperations <Series>(connection); // Add all undefined series objects to the database foreach (Series series in undefinedSeries) { ChannelKey channelKey = new ChannelKey(series.Channel); string seriesTypeName = series.SeriesType.Name; series.ChannelID = channelLookup[channelKey].ID; series.SeriesTypeID = seriesTypeLookup[seriesTypeName].ID; series.SourceIndexes = ""; seriesTable.AddNewRecord(series); } if (undefinedSeries.Count > 0) { // Refresh the series lookup to // include all the new series foreach (Channel channel in meter.Channels) { channel.Series = null; } seriesLookup = meter.Channels .SelectMany(channel => channel.Series) .GroupBy(series => new SeriesKey(series)) .ToDictionary(grouping => grouping.Key, grouping => grouping.First()); } // Update all undefined data series to reference the new database objects foreach (DataSeries dataSeries in undefinedDataSeries) { SeriesKey seriesKey = new SeriesKey(dataSeries.SeriesInfo); Series series = seriesLookup[seriesKey]; dataSeries.SeriesInfo = series; } } }
private Series GetSeriesInfo(Meter meter, ChannelKey channelKey, SeriesKey seriesKey) { Series dbSeries = meter.Channels .SelectMany(channel => channel.Series) .FirstOrDefault(series => seriesKey.Equals(new SeriesKey(series))); if ((object)dbSeries == null) { using (AdoDataConnection connection = meter.ConnectionFactory()) { Channel dbChannel = meter.Channels .FirstOrDefault(channel => channelKey.Equals(new ChannelKey(channel))); if ((object)dbChannel == null) { TableOperations <Channel> channelTable = new TableOperations <Channel>(connection); TableOperations <MeasurementType> measurementTypeTable = new TableOperations <MeasurementType>(connection); TableOperations <MeasurementCharacteristic> measurementCharacteristicTable = new TableOperations <MeasurementCharacteristic>(connection); TableOperations <Phase> phaseTable = new TableOperations <Phase>(connection); MeasurementType measurementType = measurementTypeTable.GetOrAdd(channelKey.MeasurementType); MeasurementCharacteristic measurementCharacteristic = measurementCharacteristicTable.GetOrAdd(channelKey.MeasurementCharacteristic); Phase phase = phaseTable.GetOrAdd(channelKey.Phase); dbChannel = new Channel() { MeterID = meter.ID, LineID = channelKey.LineID, MeasurementTypeID = measurementType.ID, MeasurementCharacteristicID = measurementCharacteristic.ID, PhaseID = phase.ID, Name = channelKey.Name, SamplesPerHour = 0, Description = string.Concat(channelKey.MeasurementCharacteristic, " ", channelKey.MeasurementType, " ", channelKey.Phase), Enabled = true }; channelTable.AddNewRecord(dbChannel); dbChannel.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY"); meter.Channels = null; } TableOperations <Series> seriesTable = new TableOperations <Series>(connection); TableOperations <SeriesType> seriesTypeTable = new TableOperations <SeriesType>(connection); SeriesType seriesType = seriesTypeTable.GetOrAdd(seriesKey.SeriesType); dbSeries = new Series() { ChannelID = dbChannel.ID, SeriesTypeID = seriesType.ID, SourceIndexes = string.Empty }; seriesTable.AddNewRecord(dbSeries); dbSeries.ID = connection.ExecuteScalar <int>("SELECT @@IDENTITY"); dbChannel.Series = null; dbSeries = meter.Channels .SelectMany(channel => channel.Series) .First(series => seriesKey.Equals(new SeriesKey(series))); } } return(dbSeries); }