Here are the examples of the csharp api System.Collections.Generic.IEnumerable.Skip(int) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
4393 Examples
19
Source : ReflectionCommand.cs
with MIT License
from AlternateLife
with MIT License
from AlternateLife
public string GetParameterList()
{
var result = new StringBuilder();
foreach (var parameterInfo in MethodInfo.GetParameters().Skip(1))
{
if (parameterInfo.HasDefaultValue)
{
result.Append($"<{parameterInfo.Name}> ");
}
else
{
result.Append($"[{parameterInfo.Name}] ");
}
}
return result.ToString();
}
19
Source : Commands.cs
with MIT License
from AlternateLife
with MIT License
from AlternateLife
private async Task ExecuteDelegateCommand(IPlayer player, DelegateCommand delegateCommand, string[] arguments)
{
try
{
await delegateCommand.CommandDelegate(player, arguments.Skip(1).ToArray());
}
catch (Exception e)
{
_logger.Error($"An error occured when player {await player.GetNameAsync()} executed command: {delegateCommand.Name}: ", e);
}
}
19
Source : BinaryPatcher.cs
with MIT License
from amazingalek
with MIT License
from amazingalek
public byte[] PatchSectionBytes(byte[] fileBytes, byte[] newBytes, int sectionStart, int sectionOriginalSize, int sector = -1)
{
if (sector == -1)
{
sector = GetSectorIndex(fileBytes, sectionStart);
}
if (sector < 0 || sector >= SectorCount)
{
if (sector == -1)
{
_writer.WriteLine("Error - Patching header is not supported", MessageType.Error);
}
return fileBytes;
}
var sectionEnd = sectionStart + sectionOriginalSize;
var sizeDifference = newBytes.Length - sectionOriginalSize;
var newFileBytes = fileBytes.Take(sectionStart).Concat(newBytes).Concat(fileBytes.Skip(sectionEnd)).ToArray();
PatchFileSize(newFileBytes, sizeDifference, sector);
return newFileBytes;
}
19
Source : ShareLink.cs
with MIT License
from AmazingDM
with MIT License
from AmazingDM
private static string RemoveEmoji(string text)
{
byte[] emojiBytes = {240, 159};
var remark = Encoding.UTF8.GetBytes(text);
var startIndex = 0;
while (remark.Length > startIndex + 1 && remark[startIndex] == emojiBytes[0] && remark[startIndex + 1] == emojiBytes[1])
startIndex += 4;
return Encoding.UTF8.GetString(remark.Skip(startIndex).ToArray()).Trim();
}
19
Source : ObservableViewModelCollection.cs
with MIT License
from Aminator
with MIT License
from Aminator
protected virtual void OnViewModelCollectionChanged(NotifyCollectionChangedEventArgs e)
{
INotifyCollectionChanged? notifyCollection = modelCollection as INotifyCollectionChanged;
if (notifyCollection != null)
{
notifyCollection.CollectionChanged -= OnModelCollectionChanged;
}
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
for (int i = 0; i < e.NewItems.Count; i++)
{
modelCollection.Insert(e.NewStartingIndex + i, CreateModel((TViewModel)e.NewItems[i]));
}
break;
case NotifyCollectionChangedAction.Move:
if (e.OldItems.Count == 1 && modelCollection is ObservableCollection<object> observableCollection)
{
observableCollection.Move(e.OldStartingIndex, e.NewStartingIndex);
}
else
{
List<object> items = modelCollection.Cast<object>().Skip(e.OldStartingIndex).Take(e.OldItems.Count).ToList();
for (int i = 0; i < e.OldItems.Count; i++)
{
modelCollection.RemoveAt(e.OldStartingIndex);
}
for (int i = 0; i < items.Count; i++)
{
modelCollection.Insert(e.NewStartingIndex + i, items[i]);
}
}
break;
case NotifyCollectionChangedAction.Remove:
for (int i = 0; i < e.OldItems.Count; i++)
{
modelCollection.RemoveAt(e.OldStartingIndex);
}
break;
case NotifyCollectionChangedAction.Replace:
for (int i = 0; i < e.OldItems.Count; i++)
{
modelCollection.RemoveAt(e.OldStartingIndex);
}
goto case NotifyCollectionChangedAction.Add;
case NotifyCollectionChangedAction.Reset:
modelCollection.Clear();
break;
}
if (notifyCollection != null)
{
notifyCollection.CollectionChanged += OnModelCollectionChanged;
}
}
19
Source : ObservableViewModelCollection.cs
with MIT License
from Aminator
with MIT License
from Aminator
protected virtual void OnModelCollectionChanged(NotifyCollectionChangedEventArgs e)
{
CollectionChanged -= OnViewModelCollectionChanged;
Task collectionChangeTask = Task.Factory.StartNew(() =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
for (int i = 0; i < e.NewItems.Count; i++)
{
Insert(e.NewStartingIndex + i, CreateViewModel((TModel)e.NewItems[i], e.NewStartingIndex + i));
}
break;
case NotifyCollectionChangedAction.Move:
if (e.OldItems.Count == 1)
{
Move(e.OldStartingIndex, e.NewStartingIndex);
}
else
{
List<TViewModel> items = this.Skip(e.OldStartingIndex).Take(e.OldItems.Count).ToList();
for (int i = 0; i < e.OldItems.Count; i++)
{
RemoveAt(e.OldStartingIndex);
}
for (int i = 0; i < items.Count; i++)
{
Insert(e.NewStartingIndex + i, items[i]);
}
}
break;
case NotifyCollectionChangedAction.Remove:
for (int i = 0; i < e.OldItems.Count; i++)
{
RemoveAt(e.OldStartingIndex);
}
break;
case NotifyCollectionChangedAction.Replace:
for (int i = 0; i < e.OldItems.Count; i++)
{
RemoveAt(e.OldStartingIndex);
}
goto case NotifyCollectionChangedAction.Add;
case NotifyCollectionChangedAction.Reset:
Clear();
break;
}
}, default, TaskCreationOptions.None, originalTaskScheduler);
collectionChangeTask.Wait();
CollectionChanged += OnViewModelCollectionChanged;
}
19
Source : ObservableViewModelCollection.cs
with MIT License
from Aminator
with MIT License
from Aminator
protected virtual void OnModelCollectionChanged(NotifyCollectionChangedEventArgs e)
{
CollectionChanged -= OnViewModelCollectionChanged;
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
for (int i = 0; i < e.NewItems.Count; i++)
{
Insert(e.NewStartingIndex + i, CreateViewModel(e.NewItems[i], e.NewStartingIndex + i));
}
break;
case NotifyCollectionChangedAction.Move:
if (e.OldItems.Count == 1)
{
Move(e.OldStartingIndex, e.NewStartingIndex);
}
else
{
List<TViewModel> items = this.Skip(e.OldStartingIndex).Take(e.OldItems.Count).ToList();
for (int i = 0; i < e.OldItems.Count; i++)
{
RemoveAt(e.OldStartingIndex);
}
for (int i = 0; i < items.Count; i++)
{
Insert(e.NewStartingIndex + i, items[i]);
}
}
break;
case NotifyCollectionChangedAction.Remove:
for (int i = 0; i < e.OldItems.Count; i++)
{
RemoveAt(e.OldStartingIndex);
}
break;
case NotifyCollectionChangedAction.Replace:
for (int i = 0; i < e.OldItems.Count; i++)
{
RemoveAt(e.OldStartingIndex);
}
goto case NotifyCollectionChangedAction.Add;
case NotifyCollectionChangedAction.Reset:
Clear();
break;
}
CollectionChanged += OnViewModelCollectionChanged;
}
19
Source : ObservableViewModelCollection.cs
with MIT License
from Aminator
with MIT License
from Aminator
protected virtual void OnViewModelCollectionChanged(NotifyCollectionChangedEventArgs e)
{
INotifyCollectionChanged? notifyCollection = modelCollection as INotifyCollectionChanged;
if (notifyCollection != null)
{
notifyCollection.CollectionChanged -= OnModelCollectionChanged;
}
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
for (int i = 0; i < e.NewItems.Count; i++)
{
modelCollection.Insert(e.NewStartingIndex + i, CreateModel((TViewModel)e.NewItems[i]));
}
break;
case NotifyCollectionChangedAction.Move:
if (e.OldItems.Count == 1 && modelCollection is ObservableCollection<TModel> observableCollection)
{
observableCollection.Move(e.OldStartingIndex, e.NewStartingIndex);
}
else
{
List<TModel> items = modelCollection.Skip(e.OldStartingIndex).Take(e.OldItems.Count).ToList();
for (int i = 0; i < e.OldItems.Count; i++)
{
modelCollection.RemoveAt(e.OldStartingIndex);
}
for (int i = 0; i < items.Count; i++)
{
modelCollection.Insert(e.NewStartingIndex + i, items[i]);
}
}
break;
case NotifyCollectionChangedAction.Remove:
for (int i = 0; i < e.OldItems.Count; i++)
{
modelCollection.RemoveAt(e.OldStartingIndex);
}
break;
case NotifyCollectionChangedAction.Replace:
for (int i = 0; i < e.OldItems.Count; i++)
{
modelCollection.RemoveAt(e.OldStartingIndex);
}
goto case NotifyCollectionChangedAction.Add;
case NotifyCollectionChangedAction.Reset:
modelCollection.Clear();
break;
}
if (notifyCollection != null)
{
notifyCollection.CollectionChanged += OnModelCollectionChanged;
}
}
19
Source : AnalogyFilePlotting.cs
with MIT License
from Analogy-LogViewer
with MIT License
from Analogy-LogViewer
public IEnumerable<(string SeriesName, replacedogyPlottingSeriesType SeriesViewType)> GetChartSeries()
{
foreach (string seriesName in headers.Skip(CustomXAxis ? 1 : 0))
{
yield return (seriesName, replacedogyPlottingSeriesType.Line);
}
}
19
Source : InterpreterParser.cs
with MIT License
from Analogy-LogViewer
with MIT License
from Analogy-LogViewer
public static IElement Parse(IReadOnlyList<Token> tokens)
{
var result = new SearchOperation();
bool haveLHS = false;
for (int i = 0; i < tokens.Count; i++)
{
var token = tokens[i];
switch (token.Type)
{
case SearchType.Expression:
if (!haveLHS)
{
result.Left = new SearchExpression(token.Text);
haveLHS = true;
}
else
{
result.Right = new SearchExpression(token.Text);
}
break;
case SearchType.And:
result.Type = SearchOperation.SearchType.And;
break;
case SearchType.Or:
result.Type = SearchOperation.SearchType.Or;
break;
case SearchType.Lparentheses:
int j = i;
for (; j < tokens.Count; ++j)
{
if (tokens[j].Type == SearchType.Rparentheses)
{
break;
}
}
var subexpression = tokens.Skip(i + 1).Take(j - i - 1).ToList();
var element = Parse(subexpression);
if (!haveLHS)
{
result.Left = element;
haveLHS = true;
}
else
{
result.Right = element;
}
i = j;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return result;
}
19
Source : SynchronizedObjectListener.cs
with Apache License 2.0
from Anapher
with Apache License 2.0
from Anapher
public T GetSynchronizedObject<T>(string syncObjId) where T : clreplaced
{
lock (_lock)
{
if (!_cachedData.TryGetValue(syncObjId, out var events))
throw new InvalidOperationException("The synchronized object was never received.");
var serializer = JsonSerializer.Create(JsonSettings);
var initialEvent = events.Last(x => !x.IsPatch);
var patches = events.Skip(events.IndexOf(initialEvent) + 1);
var initialObj = initialEvent.Payload.DeepClone();
foreach (var patch in patches.Select(x => x.Payload))
{
var jsonPatch = patch.DeepClone().ToObject<JsonPatchDoreplacedent<JToken>>(serializer);
if (jsonPatch == null) throw new NullReferenceException("A patch must never be null.");
jsonPatch.ApplyTo(initialObj);
}
var result = initialObj.ToObject<T>(serializer);
if (result == null) throw new NullReferenceException("The sync object must not be null.");
return result;
}
}
19
Source : Program.cs
with MIT License
from anastasios-stamoulis
with MIT License
from anastasios-stamoulis
static public System.Drawing.Bitmap createBitmap(float[] src, int gridIndex, int width, int height, bool adjustColorRange, int numChannels) {
SciColorMaps.Portable.ColorMap cmap = null;
var colorScaleFactor = 1.0;
var numPixels = width * height;
if (adjustColorRange) {
var maxValue = src.Skip(gridIndex * numPixels * numChannels).Take(numPixels * numChannels).Max();
var minValue = src.Skip(gridIndex * numPixels * numChannels).Take(numPixels * numChannels).Min();
if (numChannels == 1) {
cmap = new SciColorMaps.Portable.ColorMap("viridis", minValue, maxValue);
}
colorScaleFactor = (float)(254.0 / maxValue);
}
var bitmap = new System.Drawing.Bitmap(width, height);
var srcStart = gridIndex * numPixels;
for (int row = 0; row < height; row++) {
for (int col = 0; col < width; col++) {
var pos = srcStart + row * width + col;
if (cmap!=null) {
var rgb = cmap[colorScaleFactor * src[pos]];
var color = System.Drawing.Color.FromArgb(rgb[0], rgb[1], rgb[2]);
bitmap.SetPixel(col, row, color);
}
else {
var b = (int)(colorScaleFactor * src[pos]);
var g = (numChannels == 1) ? b : (int)(colorScaleFactor * src[pos + numPixels]);
var r = (numChannels == 1) ? b : (int)(colorScaleFactor * src[pos + 2 * numPixels]);
bitmap.SetPixel(col, row, System.Drawing.Color.FromArgb(r, g, b));
}
}
}
return bitmap;
}
19
Source : Program.cs
with MIT License
from anastasios-stamoulis
with MIT License
from anastasios-stamoulis
float[][] load_data(List<string> all_lines) {
var float_data = new float[all_lines.Count][];
for (int i = 0; i < all_lines.Count; i++) {
var current_line = all_lines[i];
float_data[i] = current_line.Split(',').Skip(1).Select((x) => float.Parse(x)).ToArray();
}
return float_data;
}
19
Source : Program.cs
with MIT License
from anastasios-stamoulis
with MIT License
from anastasios-stamoulis
Dictionary<string, float[]> preprocess_embeddings() {
var glove_dir = "C:\\Users\\anastasios\\Downloads\\glove.6B";
var embeddings_index = new Dictionary<string, float[]>();
var glove_path = System.IO.Path.Combine(glove_dir, "glove.6B.100d.txt");
Console.WriteLine($"Processing {glove_path}");
foreach(var line in System.IO.File.ReadLines(glove_path, Encoding.UTF8)) {
var values = line.Split(' ');
var word = values[0];
var coefs = values.Skip(1).Select(v => Single.Parse(v)).ToArray();
System.Diagnostics.Debug.replacedert(coefs.Length == Constants.embedding_dim);
embeddings_index[word] = coefs;
}
Console.WriteLine($"Found {embeddings_index.Keys.Count:n0} word vectors.");
return embeddings_index;
}
19
Source : Program.cs
with MIT License
from anastasios-stamoulis
with MIT License
from anastasios-stamoulis
void from_raw_text_to_word_embeddings(out Tokenizer tokenizer, out float[][] x_train, out float[] y_train, out float[][] x_val, out float[] y_val) {
List<string> texts;
List<float> labels;
tokenize_alImdb(out tokenizer, out texts, out labels);
var sequences = tokenizer.texts_to_sequences(texts.ToArray());
var word_index = tokenizer.word_index;
Console.WriteLine($"Found {word_index.Keys.Count:n0} unique tokens.");
var data_array = Preprocessing.pad_sequences(sequences, maxlen: Constants.maxlen);
var labels_array = labels.ToArray();
Util.shuffle(data_array, labels_array);
x_train = data_array.Take(Constants.training_samples).ToArray();
y_train = labels_array.Take(Constants.training_samples).ToArray();
x_val = data_array.Skip(Constants.training_samples).Take(Constants.validation_samples).ToArray();
y_val = labels_array.Skip(Constants.training_samples).Take(Constants.validation_samples).ToArray();
}
19
Source : InMemoryDatabaseActions.cs
with Apache License 2.0
from Anapher
with Apache License 2.0
from Anapher
public virtual ValueTask<IReadOnlyList<string>> ListRangeAsync(string key, int start, int end)
{
using (LockRead())
{
if (!_data.TryGetValue(key, out var listObj))
return new ValueTask<IReadOnlyList<string>>(ImmutableList<string>.Empty);
var list = (List<string>) listObj;
if (!list.Any())
return new ValueTask<IReadOnlyList<string>>(ImmutableList<string>.Empty);
(start, end) = IndexUtils.TranslateStartEndIndex(start, end, list.Count);
if (start > list.Count) return new ValueTask<IReadOnlyList<string>>(ImmutableList<string>.Empty);
var rangeLength = end - start + 1;
var range = list.Skip(start).Take(rangeLength).ToList();
return new ValueTask<IReadOnlyList<string>>(range);
}
}
19
Source : State.cs
with MIT License
from ancientproject
with MIT License
from ancientproject
public void Load(string name, params ulong[] prog)
{
var pin = 0x600;
var set = 0x599;
if (AcceptOpCode(prog.First()) == 0x33)
{
Func<int> shift = ShiftFactory.CreateByIndex(sizeof(int) * 0b100 - 0b100).Shift;
Accept(prog.First());
prog = prog.Skip(1).ToArray();
pin = (r1 << shift()) | (r2 << shift()) | (r3 << shift()) | (u1 << shift());
set = pin - 0b1;
}
foreach (var (@ulong, index) in prog.Select((x, i) => (x, i)))
bus.find(0x0).write(pin + index, @ulong);
bus.find(0x0).write(set, prog.Length);
sectors.Add((name, u32 & pin));
if(pc == 0x0) pc = i64 | pin;
}
19
Source : Extensions.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
public static double GetDouble(this IEnumerable<ModbusObject> list, int startIndex = 0, bool inverseRegisters = false)
{
if (list == null)
throw new ArgumentNullException(nameof(list));
int count = list.Count();
if (count < 4)
throw new ArgumentException("At least four registers needed", nameof(list));
if (startIndex < 0 || count < startIndex + 4)
throw new ArgumentOutOfRangeException(nameof(startIndex));
if (!list.All(r => r.Type == ModbusObjectType.HoldingRegister) && !list.All(r => r.Type == ModbusObjectType.InputRegister))
throw new ArgumentException("Invalid register type");
list = list.OrderBy(r => r.Address).Skip(startIndex).Take(4);
if (inverseRegisters)
list = list.Reverse();
var registers = list.ToArray();
byte[] blob = new byte[registers.Length * 2];
for (int i = 0; i < registers.Length; i++)
{
blob[i * 2] = registers[i].HiByte;
blob[i * 2 + 1] = registers[i].LoByte;
}
if (BitConverter.IsLittleEndian)
Array.Reverse(blob);
return BitConverter.ToDouble(blob, 0);
}
19
Source : Extensions.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
public static string GetString(this IEnumerable<ModbusObject> list, int length, int startIndex = 0, Encoding encoding = null, bool flipBytes = false)
{
if (list == null)
throw new ArgumentNullException(nameof(list));
int count = list.Count();
if (count < length)
throw new ArgumentException($"At least {length} registers needed", nameof(list));
if (startIndex < 0 || count < startIndex + length)
throw new ArgumentOutOfRangeException(nameof(startIndex));
if (!list.All(r => r.Type == ModbusObjectType.HoldingRegister) && !list.All(r => r.Type == ModbusObjectType.InputRegister))
throw new ArgumentException("Invalid register type");
if (encoding == null)
encoding = Encoding.UTF8;
var registers = list.Skip(startIndex).Take(length).ToArray();
byte[] blob = new byte[registers.Length * 2];
for (int i = 0; i < registers.Length; i++)
{
blob[i * 2] = flipBytes ? registers[i].LoByte : registers[i].HiByte;
blob[i * 2 + 1] = flipBytes ? registers[i].HiByte : registers[i].LoByte;
}
string str = encoding.GetString(blob).Trim(new[] { ' ', '\t', '\0', '\r', '\n' });
int nullIdx = str.IndexOf('\0');
if (nullIdx >= 0)
return str.Substring(0, nullIdx);
return str;
}
19
Source : ModbusServer.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
private async Task HandleClient(TcpClient client)
{
logger?.LogTrace("ModbusServer.HandleClient enter");
var endpoint = (IPEndPoint)client.Client.RemoteEndPoint;
try
{
ClientConnected?.Invoke(this, new ClientEventArgs(endpoint));
logger?.LogInformation($"Client connected: {endpoint.Address}.");
var stream = client.GetStream();
while (!stopCts.IsCancellationRequested)
{
using var requestStream = new MemoryStream();
using (var cts = new CancellationTokenSource(Timeout))
using (stopCts.Token.Register(() => cts.Cancel()))
{
try
{
byte[] header = await stream.ReadExpectedBytes(6, cts.Token);
await requestStream.WriteAsync(header, 0, header.Length, cts.Token);
byte[] bytes = header.Skip(4).Take(2).ToArray();
if (BitConverter.IsLittleEndian)
Array.Reverse(bytes);
int following = BitConverter.ToUInt16(bytes, 0);
byte[] payload = await stream.ReadExpectedBytes(following, cts.Token);
await requestStream.WriteAsync(payload, 0, payload.Length, cts.Token);
}
catch (OperationCanceledException) when (cts.IsCancellationRequested)
{
continue;
}
}
try
{
var request = new Request(requestStream.GetBuffer());
var response = requestHandler?.Invoke(request, stopCts.Token);
if (response != null)
{
using var cts = new CancellationTokenSource(Timeout);
using var reg = stopCts.Token.Register(() => cts.Cancel());
try
{
byte[] bytes = response.Serialize();
await stream.WriteAsync(bytes, 0, bytes.Length, cts.Token);
}
catch (OperationCanceledException) when (cts.IsCancellationRequested)
{
continue;
}
}
}
catch (ArgumentException ex)
{
logger?.LogWarning(ex, $"Invalid data received from {endpoint.Address}: {ex.Message}");
}
catch (NotImplementedException ex)
{
logger?.LogWarning(ex, $"Invalid data received from {endpoint.Address}: {ex.Message}");
}
}
}
catch (IOException)
{
// client connection closed
return;
}
catch (Exception ex)
{
logger?.LogError(ex, $"Unexpected error ({ex.GetType().Name}) occurred: {ex.GetMessage()}");
}
finally
{
ClientDisconnected?.Invoke(this, new ClientEventArgs(endpoint));
logger?.LogInformation($"Client disconnected: {endpoint.Address}");
client.Dispose();
tcpClients.TryRemove(client, out _);
logger?.LogTrace("ModbusServer.HandleClient leave");
}
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientReadExceptionTest()
{
byte[] expectedRequest = new byte[] { 0, 0, 0, 6, 2, 1, 0, 24, 0, 2 };
string expectedExceptionMessage = ErrorCode.GatewayTargetDevice.GetDescription();
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending error response");
return new byte[] { request[0], request[1], 0, 0, 0, 3, 2, 129, 11 };
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
try
{
var response = await client.ReadCoils(2, 24, 2);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
replacedert.Fail("Exception not thrown");
}
catch (ModbusException ex)
{
replacedert.AreEqual(expectedExceptionMessage, ex.Message);
}
}
19
Source : ModbusClient.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
private async Task ReceiveLoop()
{
try
{
logger?.LogTrace("ModbusClient.ReceiveLoop enter");
logger?.LogInformation("Receiving responses started.");
while (!receiveCts.IsCancellationRequested)
{
try
{
if (stream == null)
{
await Task.Delay(200, receiveCts.Token);
continue;
}
while (!receiveCts.IsCancellationRequested)
{
using var responseStream = new MemoryStream();
using (var timeCts = new CancellationTokenSource(ReceiveTimeout))
using (var cts = CancellationTokenSource.CreateLinkedTokenSource(timeCts.Token, receiveCts.Token))
{
try
{
byte[] header = await stream.ReadExpectedBytes(6, cts.Token);
await responseStream.WriteAsync(header, 0, header.Length, cts.Token);
byte[] bytes = header.Skip(4).Take(2).ToArray();
if (BitConverter.IsLittleEndian)
Array.Reverse(bytes);
int following = BitConverter.ToUInt16(bytes, 0);
byte[] payload = await stream.ReadExpectedBytes(following, cts.Token);
await responseStream.WriteAsync(payload, 0, payload.Length, cts.Token);
}
catch (OperationCanceledException) when (timeCts.IsCancellationRequested)
{
continue;
}
}
try
{
var response = new Response(responseStream.GetBuffer());
QueuedRequest queueItem = null;
await queueLock.WaitAsync(receiveCts.Token);
try
{
if (DisableTransactionId)
{
queueItem = awaitingResponses.FirstOrDefault();
}
else
{
queueItem = awaitingResponses
.Where(i => i.TransactionId == response.TransactionId)
.FirstOrDefault();
if (queueItem == null)
logger?.LogWarning($"Received response for transaction #{response.TransactionId}. The matching request could not be resolved.");
}
if (queueItem != null)
{
queueItem.Registration.Dispose();
awaitingResponses.Remove(queueItem);
}
}
finally
{
queueLock.Release();
}
if (queueItem != null)
{
if (!DisableTransactionId)
logger?.LogDebug($"Received response for transaction #{response.TransactionId}.");
queueItem.CancellationTokenSource.Dispose();
queueItem.TaskCompletionSource.TrySetResult(response);
queueItem.TimeoutCancellationTokenSource.Dispose();
}
}
catch (ArgumentException ex)
{
logger?.LogError(ex, $"Invalid data received: {ex.Message}");
}
catch (NotImplementedException ex)
{
logger?.LogError(ex, $"Invalid data received: {ex.Message}");
}
}
}
catch (OperationCanceledException) when (receiveCts.IsCancellationRequested)
{
// Receive loop stopping
throw;
}
catch (IOException)
{
if (!isReconnecting)
ConnectingTask = GetReconnectTask();
await Task.Delay(1, receiveCts.Token); // make sure the reconnect task has time to start.
}
catch (Exception ex)
{
logger?.LogError(ex, $"Unexpected error ({ex.GetType().Name}) on receive: {ex.GetMessage()}");
}
}
}
catch (OperationCanceledException) when (receiveCts.IsCancellationRequested)
{
// Receive loop stopping
var ex = new SocketException((int)SocketError.TimedOut);
await queueLock.WaitAsync(stopCts.Token);
try
{
foreach (var queuedItem in awaitingResponses)
{
queuedItem.Registration.Dispose();
queuedItem.CancellationTokenSource.Dispose();
queuedItem.TaskCompletionSource.TrySetCanceled();
queuedItem.TimeoutCancellationTokenSource.Dispose();
}
awaitingResponses.Clear();
}
catch
{ }
finally
{
queueLock.Release();
}
logger?.LogInformation("Receiving responses stopped.");
}
catch (Exception ex)
{
logger?.LogError(ex, $"Unexpected error ({ex.GetType().Name}) on receive: {ex.GetMessage()}");
}
finally
{
logger?.LogTrace("ModbusClient.ReceiveLoop leave");
}
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientReadCoilsTest()
{
// Function Code 0x01
byte[] expectedRequest = new byte[] { 0, 0, 0, 6, 12, 1, 0, 20, 0, 10 };
var expectedResponse = new List<Coil>
{
new Coil { Address = 20, BoolValue = true },
new Coil { Address = 21, BoolValue = false },
new Coil { Address = 22, BoolValue = true },
new Coil { Address = 23, BoolValue = true },
new Coil { Address = 24, BoolValue = false },
new Coil { Address = 25, BoolValue = false },
new Coil { Address = 26, BoolValue = true },
new Coil { Address = 27, BoolValue = true },
new Coil { Address = 28, BoolValue = true },
new Coil { Address = 29, BoolValue = false },
};
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
return new byte[] { request[0], request[1], 0, 0, 0, 5, 12, 1, 2, 205, 1 };
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var coils = await client.ReadCoils(12, 20, 10);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
Collectionreplacedert.AreEqual(expectedResponse, coils, "Response is incorrect");
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientReadDiscreteInputsTest()
{
// Function Code 0x02
byte[] expectedRequest = new byte[] { 0, 0, 0, 6, 1, 2, 0, 12, 0, 2 };
var expectedResponse = new List<DiscreteInput>
{
new DiscreteInput { Address = 12, BoolValue = true },
new DiscreteInput { Address = 13, BoolValue = true }
};
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
return new byte[] { request[0], request[1], 0, 0, 0, 4, 1, 2, 1, 3 };
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var inputs = await client.ReadDiscreteInputs(1, 12, 2);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
Collectionreplacedert.AreEqual(expectedResponse, inputs, "Response is incorrect");
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientReadHoldingRegisterTest()
{
// Function Code 0x03
byte[] expectedRequest = new byte[] { 0, 0, 0, 6, 5, 3, 0, 10, 0, 2 };
var expectedResponse = new List<Register>
{
new Register { Address = 10, RegisterValue = 3, Type = ModbusObjectType.HoldingRegister },
new Register { Address = 11, RegisterValue = 7, Type = ModbusObjectType.HoldingRegister }
};
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
return new byte[] { request[0], request[1], 0, 0, 0, 7, 5, 3, 4, 0, 3, 0, 7 };
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var registers = await client.ReadHoldingRegisters(5, 10, 2);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
Collectionreplacedert.AreEqual(expectedResponse, registers, "Response is incorrect");
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientReadInputRegisterTest()
{
// Function Code 0x04
byte[] expectedRequest = new byte[] { 0, 0, 0, 6, 3, 4, 0, 6, 0, 3 };
var expectedResponse = new List<Register>
{
new Register { Address = 6, RegisterValue = 123, Type = ModbusObjectType.InputRegister },
new Register { Address = 7, RegisterValue = 0, Type = ModbusObjectType.InputRegister },
new Register { Address = 8, RegisterValue = 12345, Type = ModbusObjectType.InputRegister }
};
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
return new byte[] { request[0], request[1], 0, 0, 0, 9, 3, 4, 6, 0, 123, 0, 0, 48, 57 };
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var registers = await client.ReadInputRegisters(3, 6, 3);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
Collectionreplacedert.AreEqual(expectedResponse, registers, "Response is incorrect");
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientReadDeviceInformationBasicTest()
{
byte[] expectedRequest = new byte[] { 0, 0, 0, 5, 13, 43, 14, 1, 0 };
var expectedResponse = new Dictionary<DeviceIDObject, string>
{
{ DeviceIDObject.VendorName, "AM.WD" },
{ DeviceIDObject.ProductCode, "Mini-Test" },
{ DeviceIDObject.MajorMinorRevision, "1.2.3.4" }
};
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
var bytes = new List<byte>();
bytes.AddRange(request.Take(2));
bytes.AddRange(new byte[] { 0, 0, 0, 0, 13, 43, 14, 1, 1, 0, 0, (byte)expectedResponse.Count });
int len = 8;
foreach (var kvp in expectedResponse)
{
byte[] b = Encoding.ASCII.GetBytes(kvp.Value);
bytes.Add((byte)kvp.Key);
len++;
bytes.Add((byte)b.Length);
len++;
bytes.AddRange(b);
len += b.Length;
}
bytes[5] = (byte)len;
return bytes.ToArray();
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var deviceInfo = await client.ReadDeviceInformation(13, DeviceIDCategory.Basic);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
Collectionreplacedert.AreEqual(expectedResponse, deviceInfo, "Response is incorrect");
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientReadDeviceInformationIndividualTest()
{
byte[] expectedRequest = new byte[] { 0, 0, 0, 5, 13, 43, 14, 4, (byte)DeviceIDObject.ModelName };
var expectedResponse = new Dictionary<DeviceIDObject, string>
{
{ DeviceIDObject.ModelName, "TestModel" }
};
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
var bytes = new List<byte>();
bytes.AddRange(request.Take(2));
bytes.AddRange(new byte[] { 0, 0, 0, 0, 13, 43, 14, 4, 2, 0, 0, (byte)expectedResponse.Count });
int len = 8;
foreach (var kvp in expectedResponse)
{
byte[] b = Encoding.ASCII.GetBytes(kvp.Value);
bytes.Add((byte)kvp.Key);
len++;
bytes.Add((byte)b.Length);
len++;
bytes.AddRange(b);
len += b.Length;
}
bytes[5] = (byte)len;
return bytes.ToArray();
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var deviceInfo = await client.ReadDeviceInformation(13, DeviceIDCategory.Individual, DeviceIDObject.ModelName);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
Collectionreplacedert.AreEqual(expectedResponse, deviceInfo, "Response is incorrect");
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientWriteSingleCoilTest()
{
// Function Code 0x05
byte[] expectedRequest = new byte[] { 0, 0, 0, 6, 1, 5, 0, 173, 255, 0 };
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
return request;
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var coil = new Coil
{
Address = 173,
BoolValue = true
};
bool success = await client.WriteSingleCoil(1, coil);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
replacedert.IsTrue(success);
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientWriteSingleRegisterTest()
{
// Function Code 0x06
byte[] expectedRequest = new byte[] { 0, 0, 0, 6, 2, 6, 0, 5, 48, 57 };
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
return request;
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var register = new Register
{
Type = ModbusObjectType.HoldingRegister,
Address = 5,
RegisterValue = 12345
};
bool success = await client.WriteSingleRegister(2, register);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
replacedert.IsTrue(success);
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientWriteCoilsTest()
{
// Function Code 0x0F
byte[] expectedRequest = new byte[] { 0, 0, 0, 9, 4, 15, 0, 20, 0, 10, 2, 205, 1 };
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
return new byte[] { request[0], request[1], 0, 0, 0, 6, 4, 15, 0, 20, 0, 10 };
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var coils = new List<Coil>
{
new Coil { Address = 20, BoolValue = true },
new Coil { Address = 21, BoolValue = false },
new Coil { Address = 22, BoolValue = true },
new Coil { Address = 23, BoolValue = true },
new Coil { Address = 24, BoolValue = false },
new Coil { Address = 25, BoolValue = false },
new Coil { Address = 26, BoolValue = true },
new Coil { Address = 27, BoolValue = true },
new Coil { Address = 28, BoolValue = true },
new Coil { Address = 29, BoolValue = false },
};
bool success = await client.WriteCoils(4, coils);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
replacedert.IsTrue(success);
}
19
Source : ModbusTcpTests.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
[TestMethod]
public async Task ClientWriteRegistersTest()
{
// Function Code 0x10
byte[] expectedRequest = new byte[] { 0, 0, 0, 11, 10, 16, 0, 2, 0, 2, 4, 0, 10, 1, 2 };
using var server = new MiniTestServer
{
RequestHandler = (request, clientIp) =>
{
Collectionreplacedert.AreEqual(expectedRequest, request.Skip(2).ToArray(), "Request is incorrect");
Console.WriteLine("Server sending response");
return new byte[] { request[0], request[1], 0, 0, 0, 6, 10, 16, 0, 2, 0, 2 };
}
};
server.Start();
using var client = new ModbusClient(IPAddress.Loopback, server.Port, new ConsoleLogger());
await client.Connect();
replacedert.IsTrue(client.IsConnected);
var registers = new List<Register>
{
new Register { Address = 2, RegisterValue = 10, Type = ModbusObjectType.HoldingRegister },
new Register { Address = 3, RegisterValue = 258, Type = ModbusObjectType.HoldingRegister }
};
bool success = await client.WriteRegisters(10, registers);
replacedert.IsTrue(string.IsNullOrWhiteSpace(server.LastError), server.LastError);
replacedert.IsTrue(success);
}
19
Source : KernelManager.cs
with MIT License
from andreaschiavinato
with MIT License
from andreaschiavinato
public string StartKernel(string sessionId, string kernelName)
{
_kernelSpec = KernelSpecs.kernelspecs[kernelName];
var connectionFile = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"jupyter",
"runtime",
sessionId + ".json");
var kernelExe = _kernelSpec.spec.argv[0];
var kernalArgs = _kernelSpec.spec.argv
.Skip(1)
.Aggregate(string.Empty, (a, b) => a + " " + b)
.Replace("{connection_file}", connectionFile);
_kernelProcess = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = kernelExe,
Arguments = kernalArgs,
UseShellExecute = false,
RedirectStandardOutput = false,
RedirectStandardInput = true,
CreateNoWindow = true
}
};
_kernelProcess.Start();
WaitConnectionFileWritten(connectionFile);
return connectionFile;
}
19
Source : Extensions.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
public static uint GetUInt32(this IEnumerable<ModbusObject> list, int startIndex = 0, bool inverseRegisters = false)
{
if (list == null)
throw new ArgumentNullException(nameof(list));
int count = list.Count();
if (count < 2)
throw new ArgumentException("At least two registers needed", nameof(list));
if (startIndex < 0 || count < startIndex + 2)
throw new ArgumentOutOfRangeException(nameof(startIndex));
if (!list.All(r => r.Type == ModbusObjectType.HoldingRegister) && !list.All(r => r.Type == ModbusObjectType.InputRegister))
throw new ArgumentException("Invalid register type");
list = list.OrderBy(r => r.Address).Skip(startIndex).Take(2);
if (inverseRegisters)
list = list.Reverse();
var registers = list.ToArray();
byte[] blob = new byte[registers.Length * 2];
for (int i = 0; i < registers.Length; i++)
{
blob[i * 2] = registers[i].HiByte;
blob[i * 2 + 1] = registers[i].LoByte;
}
if (BitConverter.IsLittleEndian)
Array.Reverse(blob);
return BitConverter.ToUInt32(blob, 0);
}
19
Source : Extensions.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
public static ulong GetUInt64(this IEnumerable<ModbusObject> list, int startIndex = 0, bool inverseRegisters = false)
{
if (list == null)
throw new ArgumentNullException(nameof(list));
int count = list.Count();
if (count < 4)
throw new ArgumentException("At least four registers needed", nameof(list));
if (startIndex < 0 || count < startIndex + 4)
throw new ArgumentOutOfRangeException(nameof(startIndex));
if (!list.All(r => r.Type == ModbusObjectType.HoldingRegister) && !list.All(r => r.Type == ModbusObjectType.InputRegister))
throw new ArgumentException("Invalid register type");
list = list.OrderBy(r => r.Address).Skip(startIndex).Take(4);
if (inverseRegisters)
list = list.Reverse();
var registers = list.ToArray();
byte[] blob = new byte[registers.Length * 2];
for (int i = 0; i < registers.Length; i++)
{
blob[i * 2] = registers[i].HiByte;
blob[i * 2 + 1] = registers[i].LoByte;
}
if (BitConverter.IsLittleEndian)
Array.Reverse(blob);
return BitConverter.ToUInt64(blob, 0);
}
19
Source : Extensions.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
public static int GetInt32(this IEnumerable<ModbusObject> list, int startIndex = 0, bool inverseRegisters = false)
{
if (list == null)
throw new ArgumentNullException(nameof(list));
int count = list.Count();
if (count < 2)
throw new ArgumentException("At least two registers needed", nameof(list));
if (startIndex < 0 || count < startIndex + 2)
throw new ArgumentOutOfRangeException(nameof(startIndex));
if (!list.All(r => r.Type == ModbusObjectType.HoldingRegister) && !list.All(r => r.Type == ModbusObjectType.InputRegister))
throw new ArgumentException("Invalid register type");
list = list.OrderBy(r => r.Address).Skip(startIndex).Take(2);
if (inverseRegisters)
list = list.Reverse();
var registers = list.ToArray();
byte[] blob = new byte[registers.Length * 2];
for (int i = 0; i < registers.Length; i++)
{
blob[i * 2] = registers[i].HiByte;
blob[i * 2 + 1] = registers[i].LoByte;
}
if (BitConverter.IsLittleEndian)
Array.Reverse(blob);
return BitConverter.ToInt32(blob, 0);
}
19
Source : Extensions.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
public static long GetInt64(this IEnumerable<ModbusObject> list, int startIndex = 0, bool inverseRegisters = false)
{
if (list == null)
throw new ArgumentNullException(nameof(list));
int count = list.Count();
if (count < 4)
throw new ArgumentException("At least four registers needed", nameof(list));
if (startIndex < 0 || count < startIndex + 4)
throw new ArgumentOutOfRangeException(nameof(startIndex));
if (!list.All(r => r.Type == ModbusObjectType.HoldingRegister) && !list.All(r => r.Type == ModbusObjectType.InputRegister))
throw new ArgumentException("Invalid register type");
list = list.OrderBy(r => r.Address).Skip(startIndex).Take(4);
if (inverseRegisters)
list = list.Reverse();
var registers = list.ToArray();
byte[] blob = new byte[registers.Length * 2];
for (int i = 0; i < registers.Length; i++)
{
blob[i * 2] = registers[i].HiByte;
blob[i * 2 + 1] = registers[i].LoByte;
}
if (BitConverter.IsLittleEndian)
Array.Reverse(blob);
return BitConverter.ToInt64(blob, 0);
}
19
Source : Extensions.cs
with MIT License
from AndreasAmMueller
with MIT License
from AndreasAmMueller
public static float GetSingle(this IEnumerable<ModbusObject> list, int startIndex = 0, bool inverseRegisters = false)
{
if (list == null)
throw new ArgumentNullException(nameof(list));
int count = list.Count();
if (count < 2)
throw new ArgumentException("At least two registers needed", nameof(list));
if (startIndex < 0 || count < startIndex + 2)
throw new ArgumentOutOfRangeException(nameof(startIndex));
if (!list.All(r => r.Type == ModbusObjectType.HoldingRegister) && !list.All(r => r.Type == ModbusObjectType.InputRegister))
throw new ArgumentException("Invalid register type");
list = list.OrderBy(r => r.Address).Skip(startIndex).Take(2);
if (inverseRegisters)
list = list.Reverse();
var registers = list.ToArray();
byte[] blob = new byte[registers.Length * 2];
for (int i = 0; i < registers.Length; i++)
{
blob[i * 2] = registers[i].HiByte;
blob[i * 2 + 1] = registers[i].LoByte;
}
if (BitConverter.IsLittleEndian)
Array.Reverse(blob);
return BitConverter.ToSingle(blob, 0);
}
19
Source : HeaderNamespaceTree.cs
with MIT License
from AndresTraks
with MIT License
from AndresTraks
public void Merge(ModelNodeDefinition node, IList<NamespaceTreeNode> path)
{
if (path.Count == 1)
{
Nodes.Add(node);
}
else
{
NamespaceTreeNode nextSource = path[1];
NamespaceTreeNode nextTarget = Children
.FirstOrDefault(c => c.Namespace == nextSource.Namespace);
if (nextTarget == null)
{
nextTarget = new NamespaceTreeNode
{
Namespace = nextSource.Namespace
};
Children.Add(nextTarget);
}
nextTarget.Merge(node, path.Skip(1).ToList());
}
}
19
Source : FileLoggerProvider.cs
with MIT License
from andrewlock
with MIT License
from andrewlock
protected void RollFiles()
{
if (_maxRetainedFiles > 0)
{
var groupsToDelete = new DirectoryInfo(_path)
.GetFiles(_fileName + "*")
.GroupBy(file => GetFilenameForGrouping(file.Name))
.OrderByDescending(f => f.Key)
.Skip(_maxRetainedFiles.Value);
foreach (var groupToDelete in groupsToDelete)
{
foreach (var fileToDelete in groupToDelete)
{
fileToDelete.Delete();
}
}
}
string GetFilenameForGrouping(string filename)
{
var hasExtension = !string.IsNullOrEmpty(_extension);
var isMultiFile = _maxFileCountPerPeriodicity > 1;
return (isMultiFile, hasExtension) switch
{
(false, false) => filename,
(false, true) => Path.GetFileNameWithoutExtension(filename),
(true, false) => Path.GetFileNameWithoutExtension(filename),
(true, true) => Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(filename)),
};
}
19
Source : Program.cs
with MIT License
from AndreyAkinshin
with MIT License
from AndreyAkinshin
static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("The first argument should be specified.");
PrintAvailableSimulations();
return;
}
string simulationName = args[0];
if (!Simulations.ContainsKey(simulationName))
{
Console.WriteLine($"'{simulationName}' is not a valid simulation name.");
PrintAvailableSimulations();
return;
}
var example = Simulations[simulationName];
example(args.Skip(1).ToArray());
}
19
Source : WebSocketListener.cs
with MIT License
from andruzzzhka
with MIT License
from andruzzzhka
protected override void OnMessage(WebSocketSharp.MessageEventArgs e)
{
base.OnMessage(e);
try
{
if (e.IsText)
{
IncomingMessage message = JsonConvert.DeserializeObject<IncomingMessage>(e.Data);
Logger.Instance.Debug($"Got message from RCON client: ID={message.Identifier}, Message={message.Message}");
List<string> args = Program.ParseLine(message.Message);
var response = Program.ProcessCommand(args[0], args.Skip(1).ToArray());
OutgoingMessage outMsg = new OutgoingMessage() { Identifier = message.Identifier, Message = response, Type = "Generic", Stacktrace = "" };
Send(JsonConvert.SerializeObject(outMsg));
}
}catch(Exception ex)
{
Logger.Instance.Warning("Unable to proccess a command from RCON client! Exception: "+ex);
}
}
19
Source : Printer.cs
with MIT License
from andycb
with MIT License
from andycb
public async Task StoreFileAsync(string filePath, string fileName)
{
this.ValidatePrinterReady();
var modelBytes = File.ReadAllBytes(filePath);
// Start a transfer
this.streamWriter.WriteLine(string.Format(CultureInfo.InvariantCulture, "~{0} {1} 0:/user/{2}", MachineCommands.BeginWriteToSdCard, modelBytes.Count(), fileName));
await this.WaitForPrinterAck().ConfigureAwait(false);
var crcAlg = new Crc32Algorithm(!BitConverter.IsLittleEndian);
var count = 0;
int offset = 0;
var printerStream = this.printerConnection.GetStream();
while (offset < modelBytes.Length)
{
uint crc;
byte[] packet = new byte[packetSizeBytes];
var dataSize = 0u;
if (offset + packetSizeBytes < modelBytes.Length)
{
packet = modelBytes.Skip(offset).Take(packetSizeBytes).ToArray();
var crcBytes = BitConverter.ToUInt32(crcAlg.ComputeHash(packet));
crc = GetBigEndian(crcBytes);
dataSize = packetSizeBytes;
}
else
{
// Every packet needs to be the same size, so zero pad the last one if we need to.
var actualLength = modelBytes.Length - offset;
var data = modelBytes.Skip(offset).Take(actualLength).ToArray();
// The CRC is for the un-padded data.
var crcBytes = BitConverter.ToUInt32(crcAlg.ComputeHash(data));
crc = GetBigEndian(crcBytes);
Array.Copy(data, 0, packet, 0, actualLength);
Array.Fill<byte>(packet, 0x0, actualLength, packetSizeBytes - actualLength);
dataSize = (uint)actualLength;
}
var packetToSend = new List<byte>();
// Always start each packet with four bytes
packetToSend.AddRange(this.fileTransferPrefixBytes);
// Add the count of this packet, the size of the data it in (not counting padding) and the CRC.
packetToSend.AddRange(BitConverter.GetBytes(GetBigEndian((uint)count)));
packetToSend.AddRange(BitConverter.GetBytes(GetBigEndian(dataSize)));
packetToSend.AddRange(BitConverter.GetBytes(crc));
// Finally add thr actual data
packetToSend.AddRange(packet);
// Send the data
printerStream.Write(packetToSend.ToArray());
printerStream.Flush();
offset += packetSizeBytes;
++count;
}
// Tell the printer that we have finished sending the file.
this.streamWriter.WriteLine(string.Format(CultureInfo.InvariantCulture, "~{0}", MachineCommands.EndWriteToSdCard));
await this.WaitForPrinterAck();
}
19
Source : CommandLineVerbExtension.cs
with MIT License
from ANF-Studios
with MIT License
from ANF-Studios
public static ParserResult<object> ParseVerbs(this Parser parser, IEnumerable<string> args, params Type[] types)
{
if (parser == null) throw new ArgumentNullException(nameof(parser));
var argsArray = args as string[] ?? args.ToArray();
if (argsArray.Length == 0 || argsArray[0].StartsWith("-"))
{
return parser.ParseArguments(argsArray, types);
}
var verb = argsArray[0];
foreach (var type in types)
{
var verbAttribute = type.GetCustomAttribute<VerbAttribute>();
if (verbAttribute == null || verbAttribute.Name != verb)
{
continue;
}
var subVerbsAttribute = type.GetCustomAttribute<ChildVerbsAttribute>();
if (subVerbsAttribute != null)
{
return ParseVerbs(parser, argsArray.Skip(1).ToArray(), subVerbsAttribute.Types);
}
break;
}
return parser.ParseArguments(argsArray, types);
}
19
Source : DnaCSharpEngine.cs
with MIT License
from angelsix
with MIT License
from angelsix
private string GenerateXmlComment(string comment, string indentString)
{
// Remove carriage returns, so we just have newlines
comment = comment.Replace("\r", "");
var result = $"{indentString}/// <summary>";
// Get each line
var lines = new List<string>(comment.Split('\n'));
// If it's a single line comment, just trim it
if (lines.Count == 1)
lines[0] = lines[0]?.Trim();
else
{
// Ignore empty lines if this is the last line
if (lines.Count > 1 && string.IsNullOrWhiteSpace(lines[lines.Count - 1]))
lines = lines.Take(lines.Count - 1).ToList();
// Ignore empty lines if this is the first line
if (lines.Count > 1 && string.IsNullOrWhiteSpace(lines[0]))
lines = lines.Skip(1).Take(lines.Count - 1).ToList();
}
// If every comment has at least the indent number of spaces
// Presume they are doing a multi-line comment and remove them
//
// e.g.
// < !--
// This is a comment for one
// second
// third
// -- >
//
// Then we should remove the spaces from the start of the comment
if (lines.All(c => c.Length >= indentString.Length && c.Take(indentString.Length).All(cc => cc == ' ')))
lines = lines.Select(f => f.Substring(indentString.Length)).ToList();
// For each line
for (var i = 0; i < lines.Count; i++)
{
// Get the current line
var line = lines[i];
// Ignore empty lines if this is the first or last
if ((i == 0 || i == lines.Count - 1) && string.IsNullOrWhiteSpace(line))
continue;
result += $"\r\n{indentString}/// {line}";
}
result += $"\r\n{indentString}/// </summary>\r\n";
return result;
}
19
Source : GraphOperator.cs
with MIT License
from angshuman
with MIT License
from angshuman
private static IEnumerable<Triple> PathImpl(IGraph graph, string id, string[] paths)
{
if (paths.Length == 1) {
var destination = paths[0];
var rsp = graph.SP(id, destination);
return rsp;
}
var destinations = graph.SP(id, paths[0]).Where(x => x.Object.IsID).Select(x => x.Object.Id);
var newPaths = paths.Skip(1).ToArray();
var all = new List<Triple>();
foreach (var item in destinations) {
all.AddRange(PathImpl(graph, item, newPaths));
}
return all;
}
19
Source : StringHelper.cs
with Apache License 2.0
from anjoy8
with Apache License 2.0
from anjoy8
public static string GetCusLine(string resourceStr, int length) {
string[] arrStr = resourceStr.Split("\r\n");
return string.Join("", (from q in arrStr select q).Skip(arrStr.Length - length + 1).Take(length).ToArray());
}
19
Source : CatalogContextSeed.cs
with MIT License
from anjoy8
with MIT License
from anjoy8
private IEnumerable<CatalogBrand> GetCatalogBrandsFromFile(string contentRootPath, ILogger<CatalogContextSeed> logger)
{
string csvFileCatalogBrands = Path.Combine(contentRootPath, "Setup", "CatalogBrands.csv");
if (!File.Exists(csvFileCatalogBrands))
{
return GetPreconfiguredCatalogBrands();
}
string[] csvheaders;
try
{
string[] requiredHeaders = { "catalogbrand" };
csvheaders = GetHeaders( csvFileCatalogBrands, requiredHeaders );
}
catch (Exception ex)
{
logger.LogError(ex, "EXCEPTION ERROR: {Message}", ex.Message);
return GetPreconfiguredCatalogBrands();
}
return File.ReadAllLines(csvFileCatalogBrands)
.Skip(1) // skip header row
.SelectTry(x => CreateCatalogBrand(x))
.OnCaughtException(ex => { logger.LogError(ex, "EXCEPTION ERROR: {Message}", ex.Message); return null; })
.Where(x => x != null);
}
19
Source : CatalogContextSeed.cs
with MIT License
from anjoy8
with MIT License
from anjoy8
private IEnumerable<CatalogType> GetCatalogTypesFromFile(string contentRootPath, ILogger<CatalogContextSeed> logger)
{
string csvFileCatalogTypes = Path.Combine(contentRootPath, "Setup", "CatalogTypes.csv");
if (!File.Exists(csvFileCatalogTypes))
{
return GetPreconfiguredCatalogTypes();
}
string[] csvheaders;
try
{
string[] requiredHeaders = { "catalogtype" };
csvheaders = GetHeaders( csvFileCatalogTypes, requiredHeaders );
}
catch (Exception ex)
{
logger.LogError(ex, "EXCEPTION ERROR: {Message}", ex.Message);
return GetPreconfiguredCatalogTypes();
}
return File.ReadAllLines(csvFileCatalogTypes)
.Skip(1) // skip header row
.SelectTry(x => CreateCatalogType(x))
.OnCaughtException(ex => { logger.LogError(ex, "EXCEPTION ERROR: {Message}", ex.Message); return null; })
.Where(x => x != null);
}
19
Source : CatalogContextSeed.cs
with MIT License
from anjoy8
with MIT License
from anjoy8
private IEnumerable<CatalogItem> GetCatalogItemsFromFile(string contentRootPath, CatalogContext context, ILogger<CatalogContextSeed> logger)
{
string csvFileCatalogItems = Path.Combine(contentRootPath, "Setup", "CatalogItems.csv");
if (!File.Exists(csvFileCatalogItems))
{
return GetPreconfiguredItems();
}
string[] csvheaders;
try
{
string[] requiredHeaders = { "catalogtypename", "catalogbrandname", "description", "name", "price", "picturefilename" };
string[] optionalheaders = { "availablestock", "restockthreshold", "maxstockthreshold", "onreorder" };
csvheaders = GetHeaders(csvFileCatalogItems, requiredHeaders, optionalheaders );
}
catch (Exception ex)
{
logger.LogError(ex, "EXCEPTION ERROR: {Message}", ex.Message);
return GetPreconfiguredItems();
}
var catalogTypeIdLookup = context.CatalogTypes.ToDictionary(ct => ct.Type, ct => ct.Id);
var catalogBrandIdLookup = context.CatalogBrands.ToDictionary(ct => ct.Brand, ct => ct.Id);
return File.ReadAllLines(csvFileCatalogItems)
.Skip(1) // skip header row
.Select(row => Regex.Split(row, ",(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)") )
.SelectTry(column => CreateCatalogItem(column, csvheaders, catalogTypeIdLookup, catalogBrandIdLookup))
.OnCaughtException(ex => { logger.LogError(ex, "EXCEPTION ERROR: {Message}", ex.Message); return null; })
.Where(x => x != null);
}
See More Examples