//public static void SetDataSource<T>(this BindingSource bs, IList<T>, Control ctrlContext) //{ // bs.DataSource = // return new SortableBindingList<T>(list, ctrlContext); //} public static TSource[] ToSortedArray <TSource>(this System.Collections.Generic.IEnumerable <TSource> source, Comparison <TSource> comparer) { var res = source.ToArray(); Array.Sort(res, comparer); return(res); }
public async void Push(System.Collections.Generic.IEnumerable <TPackage> packages) { var buffer = _CreateBuffer(packages.ToArray()); if (buffer.Length == 0) { return; } IWaitableValue <int> wv = null; try { wv = _Peer.Send(buffer, 0, buffer.Length); } catch (System.Exception ex) { Regulus.Utility.Log.Instance.WriteInfo(ex.ToString()); ErrorEvent(); } if (wv == null) { return; } var sendCount = await wv; _WriteEnd(sendCount); }
public static TSource[] ToSortedArray <TSource>(this System.Collections.Generic.IEnumerable <TSource> source) where TSource : IComparable <TSource> { var res = source.ToArray(); Array.Sort(res); return(res); }
private int RefreshUI() { var selectedItem = _lstCharacters.SelectedItem; System.Collections.Generic.IEnumerable <NewCharacter> newCharacters = (IEnumerable <NewCharacter>)_lstCharacters; var items = newCharacters.ToArray(); _lstCharacters.DataSource = items; return(items.Length); }
public ZipStreamResult(System.Collections.Generic.IEnumerable <string> files, string fileDownloadName) : base(ZipStreamResult.ContextType) { this.files = files.ToArray <string>(); string name = fileDownloadName ?? ""; if (name.Length == 0 && files.Count <string>() == 1) { name = System.IO.Path.GetFileNameWithoutExtension(files.First <string>()); } if (!name.ToLower().EndsWith(ZipStreamResult.FileExtension)) { name += ZipStreamResult.FileExtension; } base.FileDownloadName = HttpUtility.UrlEncode(name); }
public static String[] CreateEarlyBoundClass(String connectionString, String[] entities) { if (String.IsNullOrWhiteSpace(connectionString)) { throw new Exception("Missing connection string."); } var trace = new MemorySpklTraceLogger(); MemoryTraceLogger traceCollection = new MemoryTraceLogger(); var temporaryFilePath = System.IO.Path.GetTempFileName(); var temporaryFile = System.IO.Path.GetFileName(temporaryFilePath); var temporaryFolder = System.IO.Path.GetDirectoryName(temporaryFilePath); ConfigFile mockConfigFile = GetMockConfigFile(entities, temporaryFile, temporaryFolder); var fakeContext = new FakeServiceContext(); try { var earlyBound = new EarlyBoundClassGeneratorTask(fakeContext, trace); earlyBound.ConectionString = connectionString; earlyBound.CreateEarlyBoundTypes(null, mockConfigFile); } catch (Exception ex) { for (int i = traceCollection.traces.Count - 1; i > 0; i--) { if (!Regex.Match(traceCollection.traces[i], "Exiting program with exception").Success) { continue; } var snippets = traceCollection.traces[i].Split(new string[] { "Exiting program with exception: " }, StringSplitOptions.RemoveEmptyEntries); throw new Exception(snippets[snippets.Length - 1], ex); } throw ex; } System.Collections.Generic.IEnumerable <String> lines = System.IO.File.ReadLines(temporaryFilePath); return(lines.ToArray <String>()); }
internal static string[] SplitString(string original) { string[] result; if (string.IsNullOrEmpty(original)) { result = new string[0]; } else { System.Collections.Generic.IEnumerable <string> split = from piece in original.Split(new char[] { ',' }) let trimmed = piece.Trim() where !string.IsNullOrEmpty(trimmed) select trimmed; result = split.ToArray <string>(); } return(result); }
/// Analyze the incoming buffer. /// 3 statuses. /// State, IsIncomingDataFinished, IsIncomingDataLength. /// 1st state, True, True. The previous data is finished. And if there is an incoming data, should analyze the length first. /// 2nd state, False, True. set this state if the current incoming data arrives. And should analyze the length. /// 3rd state, False, False. After analyzing the length, set to analyze the content. private void AnalyzeIncomingBuffer() { byte[] byteDataInQueue; int iIndex1;/// Number of bytes that already analyzied in the data of the queue. int iCopy, iInputRemaining, iOutputRemaining; string remoteEndPoint = ""; string localEndPoint = ""; try { //if (mQueueOfIncomingBuffer == null || mQueueOfIncomingBuffer.Count < 1) { return; } remoteEndPoint = RemoteEndPoint; localEndPoint = LocalEndPoint; if (ContainLengthAsHeader) { /// The case that data contains the length as header. /// TT edited on 2018-08-21 to lock the common resource. while (TryDequeueAtIncomingBufferQueue(out byteDataInQueue)) { //if (byteDataInQueue == null) { return; } if (byteDataInQueue != null) { Logger?.Debug("AnalyzeIncomingBuffer. byteDataInQueue.Length = {0}, Server socket = {1}, Local socket = {2}", byteDataInQueue.Length, remoteEndPoint, localEndPoint); /// Loop through the buffer item of the queue. iIndex1 = 0; while (iIndex1 < byteDataInQueue.Length) { /// If they are bytes of length, do following. if (IsIncomingDataLength) { /// If the previous data is finished, do following. if (IsIncomingDataFinished) { IsIncomingDataFinished = false;/// Go to 2nd state. IncomingLengthIndex = 0; IncomingContentIndex = 0; IncomingContentSize = 0; /// Assign 4 byte to the Length buffer. if (IncomingLengthBuffer != null) { IncomingLengthBuffer = null; } IncomingLengthBuffer = new byte[4]; } /// Determine the number of bytes to be read and copied. iInputRemaining = byteDataInQueue.Length - iIndex1; /// number of bytes that input remains to be read. iOutputRemaining = 4 - IncomingLengthIndex; /// number of bytes that output remains to be write. if (iInputRemaining >= iOutputRemaining) { /// If remaining data length is larger than or equal to 4, do following. iCopy = iOutputRemaining; } else { /// If the remaining data length is smaller than 4, do following. iCopy = iInputRemaining; } /// Copy. if (iCopy > 0) { Array.Copy(byteDataInQueue, iIndex1, IncomingLengthBuffer, IncomingLengthIndex, iCopy); } IncomingLengthIndex += iCopy; iIndex1 += iCopy; /// Check if finish to copy the length. if (IncomingLengthIndex < 4) { } /// do nothing and continue to loop. else { if (IncomingLengthIndex == 4) { IncomingContentSize = BitConverter.ToInt32(IncomingLengthBuffer, 0); if (IncomingContentBuffer != null) { IncomingContentBuffer = null; } if (IncomingContentSize > 0) { IncomingContentBuffer = new byte[IncomingContentSize]; } IsIncomingDataLength = false; /// go to 3rd state. IncomingContentIndex = 0; /// reset the index of content again. } else { Logger?.Error("AnalyzeIncomingBuffer. Too many bytes of length are copied. It is unexpected. Server socket = {0}, local socket = {1}", remoteEndPoint, localEndPoint); return; } } } else { /// If they are bytes of content, do following. /// assume the memory is assigned for content. iInputRemaining = byteDataInQueue.Length - iIndex1; iOutputRemaining = IncomingContentSize - IncomingContentIndex; if (iInputRemaining >= iOutputRemaining) { /// if remaining data length is larger than or equal to the remaining data required to read to the buffer, do following. iCopy = iOutputRemaining; } else { /// if remaining data length is smaller than the remaining data required to read to the buffer, do following. iCopy = iInputRemaining; } /// Copy. if (iCopy > 0) { Array.Copy(byteDataInQueue, iIndex1, IncomingContentBuffer, IncomingContentIndex, iCopy); } IncomingContentIndex += iCopy; iIndex1 += iCopy; /// Check if finish to copy the content. if (IncomingContentIndex < IncomingContentSize) { } /// do nothing and continue to loop. else { if (IncomingContentIndex == IncomingContentSize) { AddDataToIncomingDataQueue(DateTime.Now, IncomingContentBuffer); /// go back to 1st state. IsIncomingDataFinished = true; IsIncomingDataLength = true; } else { Logger?.Error("AnalyzeIncomingBuffer. Too many bytes of content are copied. It is unexpected. Server socket = {0}, local socket = {1}", remoteEndPoint, localEndPoint); return; } } } } } } } else { // /// The case that data does NOT contain the length as header. // int iLengthContent = byteDataInQueue.Length; // if (iLengthContent < 1) { return; } // byte[] vbyteContent = new byte[iLengthContent]; // Array.Copy(byteDataInQueue, 0, vbyteContent, 0, iLengthContent); // AddDataToIncomingDataQueue(DateTime.Now, true, ref vbyteContent); /// TT edited on 2018-08-21 to lock the common resource. while (TryDequeueAtIncomingBufferQueue(out byteDataInQueue)) { if ((byteDataInQueue?.Length ?? 0) < 1) { /// if there is a zero-byte content, assume that it is the end of data. if (IncomingBufferList != null) { /// https://stackoverflow.com/questions/4868113/convert-listbyte-to-one-byte-array //byte[] byteFinalData = mListOfIncomingBuffer.SelectMany(x => x).ToArray(); byte[] byteFinalData = null; System.Collections.Generic.IEnumerable <byte> oIEnumerable = null; if (IncomingBufferList != null) { oIEnumerable = IncomingBufferList.SelectMany(x => x); } if (oIEnumerable != null) { byteFinalData = oIEnumerable.ToArray(); } AddDataToIncomingDataQueue(DateTime.Now, byteFinalData); /// Release memory of the list. IncomingBufferList.Clear(); IncomingBufferList = null; } } else { /// add data into temp list. if (IncomingBufferList == null) { IncomingBufferList = new List <byte[]>(); } IncomingBufferList.Add(byteDataInQueue); } } } } catch (Exception ex) { Logger?.Error("Server socket = {0}, local socket = {1}", remoteEndPoint, localEndPoint); Logger?.Error(ex); } }
/// <summary> /// Return a string which is the concatenation of the strings in the collection. The separator between elements /// is the string providing this method. Mimics str.join(iterable) in Python. /// </summary> /// <param name="separator">Separator.</param> /// <param name="collection">Collection.</param> public static string Join(this string separator, System.Collections.Generic.IEnumerable <string> collection) { return(string.Join(separator, collection.ToArray())); }
public async Task <ProcessConsentResult> ProcessConsent(ConsentInputModel model) { ProcessConsentResult result = new ProcessConsentResult(); ConsentResponse grantedConsent = null; // user clicked 'no' - send back the standard 'access_denied' response if (model.Button == "no") { grantedConsent = ConsentResponse.Denied; } // user clicked 'yes' - validate the data else if (model.Button == "yes" && model != null) { // if the user consented to some scope, build the response model if (model.ScopesConsented != null && model.ScopesConsented.Any()) { System.Collections.Generic.IEnumerable <string> scopes = model.ScopesConsented; if (ConsentOptions.EnableOfflineAccess == false) { scopes = scopes.Where(x => x != IdentityServer4.IdentityServerConstants.StandardScopes.OfflineAccess); } grantedConsent = new ConsentResponse { RememberConsent = model.RememberConsent, ScopesConsented = scopes.ToArray() }; } else { result.ValidationError = ConsentOptions.MustChooseOneErrorMessage; } } else { result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage; } if (grantedConsent != null) { // validate return url is still valid AuthorizationRequest request = await this._interaction.GetAuthorizationContextAsync(model.ReturnUrl); if (request == null) { return(result); } // communicate outcome of consent back to identityserver await this._interaction.GrantConsentAsync(request, grantedConsent); // indicate that's it ok to redirect back to authorization endpoint result.RedirectUri = model.ReturnUrl; } else { // we need to redisplay the consent UI result.ViewModel = await this.BuildViewModelAsync(model.ReturnUrl, model); } return(result); }
private string[] FileToArray(string path) { System.Collections.Generic.IEnumerable <String> lines = File.ReadLines(path); return(lines.ToArray()); }
public void SetAffectedActors(System.Collections.Generic.IEnumerable <FightActor> actors) { this.m_customAffectedActors = actors.ToArray <FightActor>(); }