public string GenerateTestFixture(IEnumerable<Test> tests, string fileName)
{
var generator = new CodeGenerator(TemplateEnum.MbUnitTestFixture, TestText, MethodText, PropertyText, TypeText,
AssertText);
var code = generator.GenerateTestFixture(tests.ToList(), fileName);
return code;
}
public static bool RequiresRenumbering(IEnumerable<int> numbers)
{
List<int> SortedList = Renumber(numbers.ToList());
if (AreEqual(numbers.ToList(), SortedList))
return false;
return true;
}
public ActionResult Manage(IEnumerable<RoleRights> changes)
{
MasterService srv = new MasterService(_Session.MasterTbl);
bool CanCommit = true; string err = "";
//Make sure If there's any DELETE - it is NOT being referred
CanCommit = !MasterController.isDeletedBeingReferred(changes, true, ref err);//.Cast<Master>().ToList()
//Check duplicates among New records only
if (CanCommit && changes != null && changes.ToList<Master>().Exists(r => r.IsAdded))
CanCommit = !MasterController.hasDuplicateInNewEntries(changes, ref err);
#region All OK so go ahead
if (CanCommit)//Commit
{
new SecurityService().BulkAddEditDel(changes.ToList<RoleRights>());//Performs Add, Edit & Delete by chacking each item
base.operationSuccess = true; // Set operation sucess
//Log Activity
new ActivityLogService(ActivityLogService.Activity.RoleManage).Add(new CPM.DAL.ActivityHistory());
}
else // worst case or hack
return Json(err, JsonRequestBehavior.AllowGet);
#endregion
return Json(string.Empty, JsonRequestBehavior.AllowGet);
}
// Calcul des soldes opérations pour une série d'opérations et une série de comte banque
public void EnrichirAvecSoldeArchivable(IEnumerable<Budget> budgets)
{
// Reset solde opérations
budgets.ToList().ForEach(c => c.SoldeOperationArchivables = 0.0M);
budgets.ToList().ForEach(c => c.SoldeFinancementArchivables = 0.0M);
budgets.ToList().ForEach(c => c.SoldeProvisionArchivables = 0.0M);
budgets.ToList().ForEach(c => c.SoldeArchivable = 0.0M);
// Contrats
var s1 = new BudgetContratEnrichisseur(uow, groupeId);
s1.EnrichirAvecNbContrats(budgets);
// Inputs: opérations
FacadeRepo facade = new FacadeRepo(uow, groupeId);
InputSoldeBudgets inputs = facade.InputSoldeArchivableBudgets(dateLimiteArchivage);
// Enrichissement solde des opérations
var enrichisseur = new BudgetSoldeOperationArchivableEnrichisseur();
enrichisseur.Executer(inputs, budgets);
// Enrichissement solde archive
foreach (var budget in budgets)
{
budget.EnrichirAvecSoldeArchivable();
}
}
public string[] GetFormattedTicket(Ticket ticket, IEnumerable<Order> lines, PrinterTemplate printerTemplate)
{
var orders = printerTemplate.MergeLines ? MergeLines(lines.ToList()) : lines.ToList();
ticket.Orders.Clear();
orders.ToList().ForEach(ticket.Orders.Add);
var content = _ticketValueChanger.GetValue(printerTemplate, ticket);
content = UpdateExpressions(content);
return content.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).ToArray();
}
private static IList<SignatureHelpItem> Filter(IEnumerable<SignatureHelpItem> items, IEnumerable<string> parameterNames)
{
if (parameterNames == null)
{
return items.ToList();
}
var filteredList = items.Where(i => Include(i, parameterNames)).ToList();
return filteredList.Count == 0 ? items.ToList() : filteredList;
}
public MagicCard(Bitmap cameraBitmap, IEnumerable<IntPoint> corners)
{
this.CameraBitmap = cameraBitmap;
QuadrilateralTransformation transformFilter = new QuadrilateralTransformation(corners.ToList(), 211, 298);
this.CardBitmap = transformFilter.Apply(cameraBitmap);
QuadrilateralTransformation cardArtFilter = new QuadrilateralTransformation(artCorners.ToList(), 183, 133);
this.CardArtBitmap = cardArtFilter.Apply(this.CardBitmap);
this.Corners = corners.ToList();
}
public void AddEntities(string variable, IEnumerable<IPersistIfcEntity> entities)
{
FixVariableName(ref variable);
if (IsDefined(variable))
{
_data[variable] = _data[variable].Union(entities.ToList());
}
else
_data.Add(variable, entities.ToList());
_lastVariable = variable;
}
public JeapieResponse SendToConcreteSubscribers(IEnumerable<string> emails, string message, string title ="",
JeapieMessagePriority priority = DefaultPriority)
{
var validationCollection = ParameterValidator.ValidateArguments(message, emails.ToList());
var result = HttpClient.Request(providerKey,
message,
title,
emails.ToList(),
JeapieRequestType.SendToConcreteSubscribers,
priority);
result.ValidationResults.AddRange(validationCollection);
return result;
}
public EjectStorageDomainSpectraS3Request(IEnumerable<Ds3Object> objects, string storageDomainId)
{
this.StorageDomainId = storageDomainId;
this.Objects = objects.ToList();
this.QueryParams.Add("operation", "eject");
this.QueryParams.Add("storage_domain_id", storageDomainId);
if (!objects.ToList().TrueForAll(obj => obj.Size.HasValue))
{
throw new Ds3RequestException(Resources.ObjectsMissingSizeException);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ValidationResult"/> class.
/// </summary>
/// <param name="elementResults">The element results.</param>
/// <param name="fieldResults">The field results.</param>
/// <param name="childResults">The child results.</param>
public ValidationResult(IEnumerable<ValidationElementResult> elementResults, IEnumerable<IValidationFieldResult> fieldResults, IEnumerable<ValidationResult> childResults)
{
ElementDirectResults = elementResults.ToList();
ElementDirectFailures = elementResults.Where(result => result.Result.CountsAsFailure).ToList();
ElementResults = childResults.SelectMany(res => res.ElementResults).Union(elementResults.ToList()).ToList();
ElementFailures = ElementResults.Where(result => result.Result.CountsAsFailure);
Results = childResults.SelectMany(res => res.Failures).Union(fieldResults.ToList()).ToList();
Failures = Results.Where(result => result.CountsAsFailure);
ElementResultsCount = ElementResults.AsBindable().Count();
ElementFailureCount = ElementFailures.AsBindable().Count();
ResultsCount = Results.AsBindable().Count();
FailureCount = Failures.AsBindable().Count();
IsSuccessful = FailureCount.Project(count => count == 0);
}
public Action PrepareToExecute(IEnumerable<CacheElement> toInsert)
{
var insertList = toInsert.ToList();
return () =>
{
foreach (var v in insertList)
{
try
{
this.Checked(raw.sqlite3_bind_text(insertOp, 1, v.Key));
if (String.IsNullOrWhiteSpace(v.TypeName))
{
this.Checked(raw.sqlite3_bind_null(insertOp, 2));
}
else
{
this.Checked(raw.sqlite3_bind_text(insertOp, 2, v.TypeName));
}
this.Checked(raw.sqlite3_bind_blob(insertOp, 3, v.Value));
this.Checked(raw.sqlite3_bind_int64(insertOp, 4, v.Expiration.Ticks));
this.Checked(raw.sqlite3_bind_int64(insertOp, 5, v.CreatedAt.Ticks));
this.Checked(raw.sqlite3_step(insertOp));
}
finally
{
this.Checked(raw.sqlite3_reset(insertOp));
}
}
};
}
public static List<Obj_AI_Base> GetDashObjects(IEnumerable<Obj_AI_Base> predefinedObjectList = null)
{
var objects = predefinedObjectList != null ? predefinedObjectList.ToList() : ObjectManager.Get<Obj_AI_Base>().Where(o => o.LSIsValidTarget(ObjectManager.Player.AttackRange)).ToList();
var apexPoint = ObjectManager.Player.ServerPosition.ToVector2() + (ObjectManager.Player.ServerPosition.ToVector2() - Game.CursorPos.ToVector2()).LSNormalized() * ObjectManager.Player.AttackRange;
return objects.Where(o => IsLyingInCone(o.ServerPosition.ToVector2(), apexPoint, ObjectManager.Player.ServerPosition.ToVector2(), Math.PI)).OrderBy(o => o.LSDistanceSquared(apexPoint)).ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="ShardedMongoServerProxy"/> class.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="instances">The instances.</param>
/// <param name="connectionQueue">The state change queue.</param>
/// <param name="connectionAttempt">The connection attempt.</param>
/// <remarks>This constructor is used when the instances have already been instructed to connect.</remarks>
protected MultipleInstanceMongoServerProxy(MongoServer server, IEnumerable<MongoServerInstance> instances, BlockingQueue<MongoServerInstance> connectionQueue, int connectionAttempt)
{
_state = MongoServerState.Connecting;
_server = server;
_connectedInstances = new ConnectedInstanceCollection();
_connectionAttempt = connectionAttempt;
_outstandingInstanceConnections = connectionQueue.Count;
ThreadPool.QueueUserWorkItem(_ =>
{
while (connectionQueue.Count > 0)
{
var instance = connectionQueue.Dequeue();
Interlocked.Decrement(ref _outstandingInstanceConnections);
}
});
// It's important to have our own copy of this list because it might get modified during iteration.
_instances = instances.ToList();
foreach (var instance in instances)
{
instance.StateChanged += InstanceStateChanged;
ProcessInstanceStateChange(instance);
}
}
public ComposeEmailViewModel(IEnumerable<Video> videos)
{
Videos = videos.ToList();
Message = new Message();
}
public int UpdateMany(string tableName, IEnumerable<IDictionary<string, object>> data,
IAdapterTransaction transaction, IList<string> keyFields)
{
IBulkUpdater bulkUpdater = ProviderHelper.GetCustomProvider<IBulkUpdater>(ConnectionProvider) ??
new BulkUpdater();
return bulkUpdater.Update(this, tableName, data.ToList(), ((AdoAdapterTransaction)transaction).DbTransaction);
}
public HasPassengers(string title, IEnumerable<ProtoCrewMember> passengers)
: base(title)
{
this.passengers = passengers.ToList();
CreateDelegates();
}
public ContentTypeDefinition(string name, string displayName, IEnumerable<ContentTypePartDefinition> parts, JObject settings)
{
Name = name;
DisplayName = displayName;
Parts = parts.ToList();
Settings = settings;
}
public void Write(IEnumerable<CommandRegistry> commands)
{
var list = commands.ToList();
Writer.WriteLine("Commands found: {0}", list.Count);
foreach (var cmd in list)
{
Blank();
Writer.Write("Command: ");
WriteCommandName(cmd.Command, cmd.Parser);
var options = cmd.Parser.Options.ToList();
if (options.Count > 0)
{
Writer.WriteLine("Available options:");
foreach (var option in cmd.Parser.Options)
Writer.WriteLine("> {0} [{1}]", option.Name, option.Member.Type.GetRealClassName());
}
else
{
Writer.WriteLine("No available options.");
}
}
}
public AirNet( IEnumerable< CompAir > newNodes, NetLayer layer, CompAir root )
{
Layer = layer;
var compAirs = newNodes.ToList();
foreach ( var current in compAirs )
{
RegisterNode( current );
current.connectedNet = this;
}
checked
{
debugId = debugIdNext++;
}
this.root = root;
var intake =
compAirs.Where( s => s.GetType() == typeof ( CompAirTrader ) )
.Cast< CompAirTrader >()
.ToList()
.Find(
s =>
s.parent.def.defName == "RedistHeat_DuctIntake" ||
s.parent.def.defName == "RedistHeat_DuctCooler" );
if ( intake == null || intake.netTemp == 999 )
{
NetTemperature = GenTemperature.OutdoorTemp;
}
else
{
NetTemperature = intake.netTemp;
}
}
public static ExecutionRequestParameters Create(Guid processId, IEnumerable<ParameterDefinitionWithValue> parameters, ActivityDefinition activityToExecute, ConditionDefinition condition, bool isPreExecution)
{
List<ActionDefinitionForActivity> implementation = isPreExecution
? activityToExecute.PreExecutionImplemementation
: activityToExecute.Implemementation;
if (parameters == null) throw new ArgumentNullException("parameters");
var parametersList = parameters.ToList();
var methods = new List<MethodToExecuteInfo>(implementation.Count);
var executionParameters = new ExecutionRequestParameters
{
ProcessId = processId,
ConditionType = condition.Type,
ConditionResultOnPreExecution = condition.ResultOnPreExecution,
ConditionMethod = condition.Type == ConditionType.Action ? GetMethodToExecuteInfo(parametersList, ActionDefinition.Create(condition.Action, 0)) : null,
};
methods.AddRange(implementation.Select(method => GetMethodToExecuteInfo(parametersList, method)));
var parameters1 = new List<ParameterContainerInfo>();
parameters1.AddRange(parameters.Where(p => p.Name != DefaultDefinitions.ParameterExecutedActivityState.Name).Select(p => new ParameterContainerInfo() { Name = p.Name, Type = p.Type, Value = p.Value }));
parameters1.Add(new ParameterContainerInfo{Name = DefaultDefinitions.ParameterExecutedActivityState.Name,Type = DefaultDefinitions.ParameterExecutedActivityState.Type,Value = activityToExecute.State});
executionParameters.ParameterContainer = parameters1.ToArray();
executionParameters.Methods = methods.ToArray();
executionParameters.ActivityName = activityToExecute.Name;
return executionParameters;
}
public virtual void AddLocals(IEnumerable<ParameterDeclaration> declarations, AstNode statement)
{
declarations.ToList().ForEach(item =>
{
var name = this.Emitter.GetEntityName(item);
var vName = this.AddLocal(item.Name, item.Type);
if (item.ParameterModifier == ParameterModifier.Out || item.ParameterModifier == ParameterModifier.Ref)
{
this.Emitter.LocalsMap[item.Name] = name + ".v";
}
else
{
this.Emitter.LocalsMap[item.Name] = name;
}
});
var visitor = new ReferenceArgumentVisitor();
statement.AcceptVisitor(visitor);
foreach (var expr in visitor.DirectionExpression)
{
var rr = this.Emitter.Resolver.ResolveNode(expr, this.Emitter);
if (rr is LocalResolveResult && expr is IdentifierExpression)
{
var ie = (IdentifierExpression)expr;
this.Emitter.LocalsMap[ie.Identifier] = ie.Identifier + ".v";
}
else
{
throw new EmitterException(expr, "Only local variables can be passed by reference");
}
}
}
/// <summary>
/// Asynchronously sends a batch of event data to the same partition.
/// All the event data in the batch need to have the same value in the Partitionkey property.
/// If the batch size is greater than the maximum batch size,
/// the method partitions the original batch into multiple batches,
/// each smaller in size than the maximum batch size.
/// </summary>
/// <param name="eventHubClient">The current EventHubClient object.</param>
/// <param name="eventDataEnumerable">An IEnumerable object containing event data instances.</param>
/// <param name="trace">true to cause a message to be written; otherwise, false.</param>
public static void SendPartitionedBatch(this EventHubClient eventHubClient, IEnumerable<EventData> eventDataEnumerable, bool trace = false)
{
var eventDataList = eventDataEnumerable as IList<EventData> ?? eventDataEnumerable.ToList();
if (eventDataEnumerable == null || !eventDataList.Any())
{
throw new ArgumentNullException(EventDataListCannotBeNullOrEmpty);
}
var batchList = new List<EventData>();
long batchSize = 0;
foreach (var eventData in eventDataList)
{
if ((batchSize + eventData.SerializedSizeInBytes) > 262144)
{
// Send current batch
eventHubClient.SendBatch(batchList);
Trace.WriteLineIf(trace, string.Format(SendPartitionedBatchFormat, batchSize, batchList.Count));
// Initialize a new batch
batchList = new List<EventData> { eventData };
batchSize = eventData.SerializedSizeInBytes;
}
else
{
// Add the EventData to the current batch
batchList.Add(eventData);
batchSize += eventData.SerializedSizeInBytes;
}
}
// The final batch is sent outside of the loop
eventHubClient.SendBatch(batchList);
Trace.WriteLineIf(trace, string.Format(SendPartitionedBatchFormat, batchSize, batchList.Count));
}
public static Solid CreateFromIntersectingPlanes(IEnumerable<Plane> planes, IDGenerator generator)
{
var solid = new Solid(generator.GetNextObjectID());
var list = planes.ToList();
for (var i = 0; i < list.Count; i++)
{
// Split the polygon by all the other planes
var poly = new Polygon(list[i]);
for (var j = 0; j < list.Count; j++)
{
if (i != j) poly.Split(list[j]);
}
// The final polygon is the face
var face = new Face(generator.GetNextFaceID()) { Plane = poly.Plane , Parent = solid };
face.Vertices.AddRange(poly.Vertices.Select(x => new Vertex(x, face)));
face.UpdateBoundingBox();
face.AlignTextureToWorld();
solid.Faces.Add(face);
}
// Ensure all the faces point outwards
var origin = solid.GetOrigin();
foreach (var face in solid.Faces)
{
if (face.Plane.OnPlane(origin) >= 0) face.Flip();
}
solid.UpdateBoundingBox();
return solid;
}
public void UpdateConsumerSubscriptionTopics(string consumerId, IEnumerable<string> subscriptionTopics)
{
var subscriptionTopicChanged = false;
IEnumerable<string> oldSubscriptionTopics = new List<string>();
IEnumerable<string> newSubscriptionTopics = new List<string>();
_consumerSubscriptionTopicDict.AddOrUpdate(consumerId,
key =>
{
subscriptionTopicChanged = true;
newSubscriptionTopics = subscriptionTopics;
return subscriptionTopics;
},
(key, old) =>
{
if (IsStringCollectionChanged(old.ToList(), subscriptionTopics.ToList()))
{
subscriptionTopicChanged = true;
oldSubscriptionTopics = old;
newSubscriptionTopics = subscriptionTopics;
}
return subscriptionTopics;
});
if (subscriptionTopicChanged)
{
_logger.InfoFormat("Consumer subscription topics changed. groupName:{0}, consumerId:{1}, old:{2}, new:{3}", _groupName, consumerId, string.Join("|", oldSubscriptionTopics), string.Join("|", newSubscriptionTopics));
}
}
/// <summary>
/// Constructs a new playlist object
/// </summary>
/// <param name="medium">The medium the playlist belongs to</param>
/// <param name="persistentID">The persistent ID of the playlist</param>
/// <param name="name">The name of the playlist</param>
/// <param name="trackIDs">List of IDs of tracks which are part of the playlist</param>
public Playlist(Medium medium, string persistentID, string name, IEnumerable<string> trackIDs)
: this(medium)
{
this.PersistentID = persistentID;
this.Name = name;
this.SetTracks(trackIDs.ToList());
}
public RedisSentinelResolver(RedisSentinel sentinel, IEnumerable<RedisEndpoint> masters, IEnumerable<RedisEndpoint> slaves)
{
this.sentinel = sentinel;
ResetMasters(masters.ToList());
ResetSlaves(slaves.ToList());
ClientFactory = RedisConfig.ClientFactory;
}
public void Store(string messageId, IEnumerable<TransportOperation> transportOperations)
{
if (!storage.TryAdd(messageId, new StoredMessage(messageId, transportOperations.ToList())))
{
throw new Exception(string.Format("Outbox message with id '{0}' is already present in storage.", messageId));
}
}
public void UpdateConsumerConsumingQueues(string consumerId, IEnumerable<string> consumingQueues)
{
var consumingQueueChanged = false;
IEnumerable<string> oldConsumingQueues = new List<string>();
IEnumerable<string> newConsumingQueues = new List<string>();
_consumerConsumingQueueDict.AddOrUpdate(consumerId,
key =>
{
newConsumingQueues = consumingQueues;
if (consumingQueues.Count() > 0)
{
consumingQueueChanged = true;
}
return consumingQueues;
},
(key, old) =>
{
if (IsStringCollectionChanged(old.ToList(), consumingQueues.ToList()))
{
consumingQueueChanged = true;
oldConsumingQueues = old;
newConsumingQueues = consumingQueues;
}
return consumingQueues;
});
if (consumingQueueChanged)
{
_logger.InfoFormat("Consumer consuming queues changed. groupName:{0}, consumerId:{1}, old:{2}, new:{3}", _groupName, consumerId, string.Join("|", oldConsumingQueues), string.Join("|", newConsumingQueues));
}
}
public override void LoadTextures(IEnumerable<TextureItem> items)
{
var list = items.ToList();
var packages = list.Select(x => x.Package).Distinct();
try
{
HLLib.Initialize();
foreach (var package in packages)
{
var p = package;
using (var pack = new HLLib.Package(p.PackageFile))
{
var folder = pack.GetRootFolder();
foreach (var ti in list.Where(x => x.Package == p))
{
var item = folder.GetItemByName(ti.Name + ".bmp", HLLib.FindType.Files);
if (!item.Exists) continue;
using (var stream = pack.CreateStream(item))
{
var bmp = new Bitmap(new MemoryStream(stream.ReadAll()));
bool hasTransparency;
bmp = PostProcessBitmap(ti.Name, bmp, out hasTransparency);
TextureHelper.Create(ti.Name.ToLowerInvariant(), bmp, hasTransparency);
bmp.Dispose();
}
}
}
}
}
finally
{
HLLib.Shutdown();
}
}
public static IReadOnlyList <T> ToReadOnlyListFast <T>(this IEnumerable <T> enumerable) => enumerable as IReadOnlyList <T> ?? enumerable?.ToList() ?? (IReadOnlyList <T>)Array.Empty <T>();
public BulkDownloadFileResponse(IEnumerable <DownloadFileResponse> files)
{
Files = files?.ToList() ?? new List <DownloadFileResponse>();
}
/// <summary>
/// Creates a new <see cref="TransformBuilder"/>
/// </summary>
public TransformBuilder(IServiceProvider services, IEnumerable <ITransformFactory> factories, IEnumerable <ITransformProvider> providers)
{
_services = services ?? throw new ArgumentNullException(nameof(services));
_factories = factories?.ToList() ?? throw new ArgumentNullException(nameof(factories));
_providers = providers?.ToList() ?? throw new ArgumentNullException(nameof(providers));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="results"></param>
public VulcanSearchHitList(IEnumerable <VulcanSearchHit> results)
{
_took = -1;
_results = results?.ToList();
}
public AQRDataStream(IQRDataStreamEncodingFormat format, IEnumerable <IQRDataStreamData> payload = null)
{
this.format = format;
this.payload = payload?.ToList() ?? new List <IQRDataStreamData>();
}
/// <summary>
/// Parses a list even if value = null
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <returns></returns>
public static List <T> ParseList <T>(this IEnumerable <T> value)
{
return(value?.ToList() ?? new List <T>());
}
protected Controller(IEnumerable <IProvider <TMsg> > providers)
{
Providers = providers?.ToList() ?? new List <IProvider <TMsg> >(0);
}
public Task <bool> BlockIPAddresses(string ruleNamePrefix, IEnumerable <IPAddressRange> ranges, IEnumerable <PortRange> allowedPorts = null, CancellationToken cancelToken = default)
{
// for performance, ranges is assumed to be sorted
lock (this)
{
ruleNamePrefix = ScrubRuleNamePrefix(ruleNamePrefix);
List <IPAddressRange> rangesList = new List <IPAddressRange>(ranges);
blockRulesRanges[ruleNamePrefix] = new MemoryFirewallRuleRanges(rangesList, allowedPorts?.ToList(), true);
}
return(Task.FromResult <bool>(true));
}
/// <summary>
/// Initializes a new instance of the <see cref="ChatUpdate"/> class.
/// </summary>
/// <param name="channels">The <see cref="IEnumerable{T}"/> that forms the value of <see cref="Channels"/>.</param>
public ChatUpdate(IEnumerable <ChannelRepresentation> channels)
{
Channels = channels?.ToList() ?? throw new ArgumentNullException(nameof(channels));
}
public CacheInvalidationBehavior(IEnumerable <ICacheInvalidator <TRequest> > cacheInvalidators)
{
_cacheInvalidators = cacheInvalidators?.ToList();
}
public SpecificationValidationResult(bool isValid, IEnumerable <ValidationFailure> errors)
{
IsValid = isValid;
Errors = errors?.ToList().AsReadOnly() ?? new List <ValidationFailure>().AsReadOnly();
}
public async Task <List <TElement> > Convert <TMessage>(InitializeContext <TMessage> context, IEnumerable <TElement> input)
where TMessage : class
{
return(input?.ToList());
}
public ActionContext(
string contextGroupName = "default",
[CallerMemberName] string name = null,
ActionContextSettings settings = null,
IEnumerable <ISanitizer> logSanitizers = null)
{
_logSanitizers = logSanitizers?.ToList();
_stopwatch = new Stopwatch();
_stopwatch.Start();
_asyncLocalStacks.Value ??= new ConcurrentDictionary <string, ActionContextStack>();
_namedStacks = _asyncLocalStacks.Value;
_stack = _namedStacks.GetOrAdd(contextGroupName, new ActionContextStack());
_parent = _stack.Peek();
_stack.Push(this);
var id = Guid.NewGuid();
var causationId = _parent?.Info.Id ?? id;
var correlationId = _stack.CorrelationId;
if (_parent == null)
{
Settings = settings ?? new ActionContextSettings();
Info = new ContextInfo(
true,
0,
name,
contextGroupName,
_stack.CorrelationId);
State = new ContextState(_logSanitizers);
Logger = new ContextLogger(this);
}
else
{
Settings = _parent.Settings;
Info = new ContextInfo(
false,
_parent.Info.Depth + 1,
name,
contextGroupName,
_stack.CorrelationId,
_parent?.Info?.Id);
State = _parent.State;
Logger = _parent.Logger;
Logger.TrySetContext(this);
}
var entryType = Info.IsRoot ? ContextLogEntryType.ContextStart : ContextLogEntryType.ChildContextStart;
Logger.LogAsType(Settings.ContextStartMessageLevel,
$"Context {Info.ContextName} has started.", entryType);
Loaded?.Invoke(this);
}
public ColumnParameter(string name, ISqlParameterType type, IEnumerable <IColumnConstraint> constraints)
{
Name = name;
Type = type;
Constraints = constraints?.ToList();
}
/// <summary>
/// Constructs <see cref="FilterChain64"/> from collection of <paramref name="filters"/>.
/// </summary>
/// <param name="filters">Collection of online filters</param>
public FilterChain64(IEnumerable<IOnlineFilter64> filters = null)
{
_filters = filters?.ToList() ?? new List<IOnlineFilter64>();
}
public CompositeTypeInspector(IEnumerable <ITypeInspector> typeInspectors)
{
this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException(nameof(typeInspectors));
}
public InlineLayout(IEnumerable <ILayout> elements, double top, double bottom)
{
Elements = elements?.ToList() ?? new List <ILayout>(0);
Top = top;
Bottom = bottom;
}
/// <summary>
/// Initializes the query with the specified parameters.
/// </summary>
/// <param name="pageIds">PageIds of the pages to get.</param>
/// <param name="workFlowStatus">Used to determine which version of the page to include data for.</param>
public GetPageRenderDetailsByIdRangeQuery(IEnumerable <int> pageIds, PublishStatusQuery?workFlowStatus = null)
: this(pageIds?.ToList())
{
}
internal PolicyWrapper(IEnumerable <PolicyBase> policySettings, Func <ServiceStatus> getStatus) : base(getStatus)
{
mPolicySettings = policySettings?.ToList() ?? new List <PolicyBase>();
}
public GridLayout(IEnumerable <GridColumnLayout> columns, double top, double bottom)
{
Columns = columns?.ToList() ?? new List <GridColumnLayout>(0);
Top = top;
Bottom = bottom;
}
public ChatroomChangedNotification(int chatroomId, string chatroomName, IEnumerable <int> participants)
{
ChatroomId = chatroomId;
ChatroomName = chatroomName;
Participants = participants?.ToList() ?? throw new ArgumentNullException(nameof(participants));
}
internal static List <T> AsInstanceOrToListOrDefault <T>(this IEnumerable <T> list) => list as List <T> ?? list?.ToList <T>() ?? new List <T>();
public GetImageAssetEntityMicroSummariesByIdRangeQuery(
IEnumerable <int> ids
)
: this(ids?.ToList())
{
}
internal static List <T> AsInstanceOrToListOrNull <T>(this IEnumerable <T> list) => list as List <T> ?? list?.ToList <T>();
public QuizServiceClientFake(IEnumerable <Quiz> expectedQuizzes)
{
_quizzes = expectedQuizzes?.ToList();
}
public ActivityResponse(string text, IEnumerable <AttachmentResponse> attachments = null)
{
this.Text = text;
this.Attachments = attachments?.ToList() ?? new List <AttachmentResponse>();
}
public new static void Choice <T>(IDialogContext context, ResumeAfter <T> resume, IEnumerable <T> options, string prompt, string retry = null, int attempts = 3, PromptStyle promptStyle = PromptStyle.Auto, IEnumerable <string> descriptions = null)
{
if (!(context is TranslatingDialogContext))
{
context = new TranslatingDialogContext(context);
}
Choice(context, resume, new PromptOptions <T>(prompt, retry, attempts: attempts, options: options.ToList(), promptStyler: new PromptStyler(promptStyle), descriptions: descriptions?.ToList()));
}
/// <summary>
/// Use the parameter path to extensions
/// </summary>
public void UpdateExtensions(IEnumerable <string> additionalExtensionsPath, bool shouldLoadOnlyWellKnownExtensions)
{
lock (this.lockForExtensionsUpdate)
{
EqtTrace.Verbose(
"TestPluginCache: Updating loadOnlyWellKnownExtensions from {0} to {1}.",
this.loadOnlyWellKnownExtensions,
shouldLoadOnlyWellKnownExtensions);
this.loadOnlyWellKnownExtensions = shouldLoadOnlyWellKnownExtensions;
List <string> extensions = additionalExtensionsPath?.ToList();
if (extensions == null || extensions.Count == 0)
{
return;
}
string extensionString;
if (this.pathToExtensions != null &&
extensions.Count == this.pathToExtensions.Count() &&
extensions.All(e => this.pathToExtensions.Contains(e)))
{
extensionString = this.pathToExtensions != null
? string.Join(",", this.pathToExtensions.ToArray())
: null;
EqtTrace.Verbose(
"TestPluginCache: Ignoring the new extensions update as there is no change. Current extensions are '{0}'.",
extensionString);
return;
}
// Don't do a strict check for existence of the extension path. The extension paths may or may
// not exist on the disk. In case of .net core, the paths are relative to the nuget packages
// directory. The path to nuget directory is automatically setup for CLR to resolve.
// Test platform tries to load every extension by assembly name. If it is not resolved, we don't
// an error.
if (this.pathToExtensions != null)
{
extensions.AddRange(this.pathToExtensions);
}
extensions = extensions.Select(Path.GetFullPath).Distinct(StringComparer.OrdinalIgnoreCase).ToList();
// Use the new paths and set the extensions discovered to false so that the next time
// any one tries to get the additional extensions, we rediscover.
this.pathToExtensions = extensions;
this.TestExtensions?.InvalidateCache();
if (EqtTrace.IsVerboseEnabled)
{
var directories =
this.pathToExtensions.Select(e => Path.GetDirectoryName(Path.GetFullPath(e))).Distinct();
var directoryString = directories != null?string.Join(",", directories.ToArray()) : null;
EqtTrace.Verbose(
"TestPluginCache: Using directories for assembly resolution '{0}'.",
directoryString);
extensionString = this.pathToExtensions != null
? string.Join(",", this.pathToExtensions.ToArray())
: null;
EqtTrace.Verbose("TestPluginCache: Updated the available extensions to '{0}'.", extensionString);
}
}
}
public Task <bool> AllowIPAddresses(string ruleNamePrefix, IEnumerable <IPAddressRange> ipAddresses, IEnumerable <PortRange> allowedPorts = null, CancellationToken cancelToken = default)
{
lock (this)
{
allowRuleRanges[ruleNamePrefix] = new MemoryFirewallRuleRanges(ipAddresses.Select(i => IPAddressRange.Parse(i)).ToList(), allowedPorts?.ToList(), false);
}
return(Task.FromResult <bool>(true));
}
public static List <TSource> SafeToList <TSource>(this IEnumerable <TSource> source, List <TSource> nullResult = null)
{
return(source?.ToList() ?? nullResult);
}
