System.Collections.Generic.IEnumerable.Skip(int)

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 7

19 Source : ReflectionCommand.cs
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[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

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

[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

[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

[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

[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

[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

[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

[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

[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

[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

[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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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