Example #1
1
        public Junction MapXmlToDomain(XmlJunction xmlJunction, IList<SplitTrack> subTracks)
        {
            SplitTrack defaultTrack = subTracks.First(subTrack => xmlJunction.BranchDefaultId.Equals(subTrack.Id));
            SplitTrack altTrack = subTracks.First(subTrack => xmlJunction.BranchAlternateId.Equals(subTrack.Id));

            return new Junction(xmlJunction.Id, defaultTrack, altTrack, xmlJunction.Direction);
        }
Example #2
1
 //exactly same as x.browser
 private static void UpdateManifest(IList<Services.Data.ExtensionManifestDataModel> found, IExtensionManifest ext)
 {
     if (found != null && found.Count() > 0)
     {
         ext.IsExtEnabled = found.First().IsExtEnabled;
         ext.LaunchInDockPositions = (ExtensionInToolbarPositions)found.First().LaunchInDockPositions;
         ext.FoundInToolbarPositions = (ExtensionInToolbarPositions)found.First().FoundInToolbarPositions;
     }
 }
        public CurrencyRateViewMode(IList<CurrencyRate> rates)
        {
            var dollarSellingRate = rates.First(r => r.Type == TradeType.Selling && r.CurrencyName == "Dollar");
            var euroSellingRate = rates.First(r => r.Type == TradeType.Selling && r.CurrencyName == "Euro");
            var dollarBuyingRate = rates.First(r => r.Type == TradeType.Buying && r.CurrencyName == "Dollar");
            var euroBuyingRate = rates.First(r => r.Type == TradeType.Buying && r.CurrencyName == "Euro");

            SellingUsDollar = new RateKeyPair(dollarSellingRate.RateId){ExchangePrice =  dollarSellingRate.ExchangePrice};
            SellingEuro = new RateKeyPair(euroSellingRate.RateId) { ExchangePrice = euroSellingRate.ExchangePrice};
            BuyingUsDollar = new RateKeyPair(dollarBuyingRate.RateId) {ExchangePrice = dollarBuyingRate.ExchangePrice};
            BuyingEuro = new RateKeyPair(euroBuyingRate.RateId) { ExchangePrice = euroBuyingRate.ExchangePrice };
        }
 private Section CreateSection(IList<string> lines, int level)
 {
     string title = null;
     var headingMarker = new String('#', level) + " ";
     if (lines.First().StartsWith(headingMarker))
     {
         title = lines.First().TrimStart('#').Trim();
         lines.RemoveAt(0);
     }
     var furtherLevelMarkers = new String('#', level + 1);
     return lines.Any(x => x.StartsWith(furtherLevelMarkers))
         ? new Section(level, title, BreakDownSection(lines, level + 1).ToList())
         : new Section(level, title, string.Join(Environment.NewLine, lines));
 }
Example #5
1
        public Statistics(IList<IVehicle> vehicles, bool removeOutliers = true)
        {
            if (vehicles == null || !vehicles.Any())
                throw new ArgumentException("Vehicles is null or count is 0. Must be greater than 0");

            _vehicles = vehicles;
            _outlierVehicles = new List<OutlierVehicle>();
            Make = _vehicles.First().Make;
            Model = _vehicles.First().Model;

            if (removeOutliers)
            {
                RemoveOutliers();
            }
        }
Example #6
1
 public Measure GetHourlyEnergyMeasure(IList<Measure> sourceMeasures, string hourMeasureSource, string hourDataVariable)
 {
     var dataVariable = hourDataVariable;
     var measurePercentage = 1;
     var plant = sourceMeasures.First().Plant;
     var reliability = 0;
     var resolution = getHourResolution();
     var source = hourMeasureSource;
     var utcDate = sourceMeasures.First().UtcDate;
     var utcHour = sourceMeasures.First().UtcHour;
     var utcMinute = 00;
     var utcSecond = 00;
     var value = getValue(sourceMeasures);
     return new Measure(plant, source, dataVariable, utcDate, utcHour, utcMinute, utcSecond, value, measurePercentage, reliability, resolution);
 }
        /// <summary>
        /// Sort the items by their priority and their index they currently exist in the collection
        /// </summary>
        /// <param name="files"></param>
        /// <returns></returns>
        public static IList<IClientDependencyFile> SortItems(IList<IClientDependencyFile> files)
        {
            //first check if each item's order is the same, if this is the case we'll make sure that we order them 
            //by the way they were defined
            if (!files.Any()) return files;

            var firstPriority = files.First().Priority;

            if (files.Any(x => x.Priority != firstPriority))
            {
                var sortedOutput = new List<IClientDependencyFile>();
                //ok they are not the same so we'll need to sort them by priority and by how they've been entered
                var groups = files.GroupBy(x => x.Priority).OrderBy(x => x.Key);
                foreach (var currentPriority in groups)
                {
                    //for this priority group, we'll need to prioritize them by how they are found in the files array
                    sortedOutput.AddRange(currentPriority.OrderBy(files.IndexOf));
                }
                return sortedOutput;
            }

            //they are all the same so we can really just return the original list since it will already be in the 
            //order that they were added.
            return files;
        } 
        private FeedResult FeedResult(IList<SyndicationItem> items)
        {
            var settings = Settings.GetSettings<FunnelWebSettings>();

            Debug.Assert(Request.GetOriginalUrl() != null, "Request.GetOriginalUrl() != null");

            var baseUri = Request.GetOriginalUrl();
            var feedUrl = new Uri(baseUri, Url.Action("Recent", "Wiki"));
            return new FeedResult(
                new Atom10FeedFormatter(
                    new SyndicationFeed(settings.SiteTitle, settings.SearchDescription, feedUrl, items)
                    {
                        Id = baseUri.ToString(),
                        Links =
                        {
                            new SyndicationLink(baseUri)
                            {
                                RelationshipType = "self"
                            }
                        },
                        LastUpdatedTime = items.Count() == 0 ? DateTime.Now : items.First().LastUpdatedTime
                    }), items.Max(i => i.LastUpdatedTime.LocalDateTime))
            {
                ContentType = "application/atom+xml"
            };
        }
        public static MapRepresentation Create(IOidStrategy oidStrategy, HttpRequestMessage req, ContextFacade contextFacade, IList<ContextFacade> contexts, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) {
            var memberValues = contexts.Select(c => new OptionalProperty(c.Id, GetMap(oidStrategy, req, c, flags))).ToList();
            IObjectFacade target = contexts.First().Target;
            MapRepresentation mapRepresentation;

            if (format == Format.Full) {
                var tempProperties = new List<OptionalProperty>();

                if (!string.IsNullOrEmpty(contextFacade?.Reason)) {
                    tempProperties.Add(new OptionalProperty(JsonPropertyNames.XRoInvalidReason, contextFacade.Reason));
                }

                var dt = new OptionalProperty(JsonPropertyNames.DomainType, target.Specification.DomainTypeName(oidStrategy));
                tempProperties.Add(dt);

                var members = new OptionalProperty(JsonPropertyNames.Members, Create(memberValues.ToArray()));
                tempProperties.Add(members);
                mapRepresentation = Create(tempProperties.ToArray());
            }
            else {
                mapRepresentation = Create(memberValues.ToArray());
            }

            mapRepresentation.SetContentType(mt);

            return mapRepresentation;
        }
        public void AugmentCompletionSession(ICompletionSession session, IList<CompletionSet> completionSets)
        {
            if (IsHtmlFile && completionSets.Any())
            {
                var bottomSpan = completionSets.First().ApplicableTo;
                if (!JScriptEditorUtil.IsInJScriptLanguageBlock(_lbm, bottomSpan.GetStartPoint(bottomSpan.TextBuffer.CurrentSnapshot)))
                {
                    // This is an HTML statement completion session, so do nothing
                    return;
                }
            }

            // TODO: Reflect over the ShimCompletionSet to see where the Description value comes from
            //       as setting the property does not actually change the value.
            var newCompletionSets = completionSets
                .Select(cs => cs == null ? cs : new ScriptCompletionSet(
                    cs.Moniker,
                    cs.DisplayName,
                    cs.ApplicableTo,
                    cs.Completions
                        .Select(c => c == null ? c : new Completion(
                            c.DisplayText,
                            c.InsertionText,
                            DocCommentHelper.ProcessParaTags(c.Description),
                            c.IconSource,
                            c.IconAutomationText))
                        .ToList(),
                    cs.CompletionBuilders))
                .ToList();
            
            completionSets.Clear();

            newCompletionSets.ForEach(cs => completionSets.Add(cs));
        }
Example #11
1
        public MainWindow()
        {
            InitializeComponent();
            Loaded += (sender, e) => ClearValue(SizeToContentProperty);

            _allControllerViewModels =
                (from type in GetType().Assembly.GetTypes()
                 where !type.IsInterface && typeof(IController).IsAssignableFrom(type)
                 let viewModel = new ControllerViewModel((IController)Activator.CreateInstance(type))
                 orderby viewModel.SortIndex, viewModel.Library, viewModel.Description
                 select viewModel).ToList();
            _allControllerViewModels.First().IsChecked = true;
            ControllerGroups.ItemsSource = _allControllerViewModels.GroupBy(viewModel => viewModel.Library);

            _allResolutionViewModels = new[] {
                new ResolutionViewModel(800, 600, 50, 42),
                new ResolutionViewModel(1024, 768, 64, 54),
                new ResolutionViewModel(1280, 1024, 80, 73),
                new ResolutionViewModel(1440, 900, 90, 64),
            };
            _allResolutionViewModels.Last(
                res => res.Width <= SystemParameters.PrimaryScreenWidth &&
                res.Height <= SystemParameters.PrimaryScreenHeight).IsChecked = true;
            Resolutions.ItemsSource = _allResolutionViewModels;

            RunResults.ItemsSource = _runResults;
        }
Example #12
1
 private void CheckFirstAndLastPoint(IList<Point> points)
 {
     if (this.DistanceIsTooSmall(points.Last(), points.First()))
     {
         points.RemoveAt(points.Count - 1);
     }
 }
        public IList<DepthPointEx> Filter(IList<DepthPointEx> points)
        {
            IList<DepthPointEx> result = new List<DepthPointEx>();

            if (points.Count > 0)
            {
                var point = new DepthPointEx(points.First());
                result.Add(point);

                foreach (var currentSourcePoint in points.Skip(1))
                {
                    if (!PointsAreClose(currentSourcePoint, point))
                    {
                        point = new DepthPointEx(currentSourcePoint);
                        result.Add(point);
                    }
                }

                if (result.Count > 1)
                {
                    CheckFirstAndLastPoint(result);
                }
            }

            return result;
        }
Example #14
1
        public int Update(AdoAdapter adapter, string tableName, IList<IDictionary<string, object>> data, IDbTransaction transaction, IList<string> keyFields)
        {
            int count = 0;
            if (data == null) throw new ArgumentNullException("data");
            if (data.Count < 2) throw new ArgumentException("UpdateMany requires more than one record.");

            if (keyFields.Count == 0) throw new NotSupportedException("Adapter does not support key-based update for this object.");
            if (!AllRowsHaveSameKeys(data)) throw new SimpleDataException("Records have different structures. Bulk updates are only valid on consistent records.");
            var table = adapter.GetSchema().FindTable(tableName);

            var exampleRow = new Dictionary<string, object>(data.First(), HomogenizedEqualityComparer.DefaultInstance);

            var commandBuilder = new UpdateHelper(adapter.GetSchema()).GetUpdateCommand(tableName, exampleRow,
                                                                    ExpressionHelper.CriteriaDictionaryToExpression(
                                                                        tableName, GetCriteria(keyFields, exampleRow)));

            using (var connectionScope = ConnectionScope.Create(transaction, adapter.CreateConnection))
            using (var command = commandBuilder.GetRepeatableCommand(connectionScope.Connection))
            {
                var propertyToParameterMap = CreatePropertyToParameterMap(data, table, command);

                foreach (var row in data)
                {
                    foreach (var kvp in row)
                    {
                        propertyToParameterMap[kvp.Key].Value = kvp.Value ?? DBNull.Value;
                    }
                    count += command.ExecuteNonQuery();
                }
            }

            return count;
        }
Example #15
1
        public static MapRepresentation Create(HttpRequestMessage req, IList<ContextSurface> contexts, Format format, RestControlFlags flags, MediaTypeHeaderValue mt) {
            OptionalProperty[] memberValues = contexts.Select(c => new OptionalProperty(c.Id, GetMap(req, c, flags))).ToArray();
            INakedObjectSurface target = contexts.First().Target;
            MapRepresentation mapRepresentation;

            if (format == Format.Full) {
                var tempProperties = new List<OptionalProperty>();

                if (flags.SimpleDomainModel) {
                    var dt = new OptionalProperty(JsonPropertyNames.DomainType, target.Specification.DomainTypeName());
                    tempProperties.Add(dt);
                }

                if (flags.FormalDomainModel) {
                    var links = new OptionalProperty(JsonPropertyNames.Links, new[] {
                        Create(new OptionalProperty(JsonPropertyNames.Rel, RelValues.DescribedBy),
                               new OptionalProperty(JsonPropertyNames.Href, new UriMtHelper(req, target.Specification).GetDomainTypeUri()))
                    });
                    tempProperties.Add(links);
                }

                var members = new OptionalProperty(JsonPropertyNames.Members, Create(memberValues));
                tempProperties.Add(members);
                mapRepresentation = Create(tempProperties.ToArray());
            }
            else {
                mapRepresentation = Create(memberValues);
            }

            mapRepresentation.SetContentType(mt);

            return mapRepresentation;
        }
 private void CheckFirstAndLastPoint(IList<DepthPointEx> points)
 {
     if (PointsAreClose(points.Last(), points.First()))
     {
         points.RemoveAt(points.Count - 1);
     }
 }
Example #17
1
        public MultilayerPerceptron(int numInputs, int numOutputs, IList<int> hiddenLayerSizes)
        {
            if (numInputs <= 0)
                throw new NeuralNetworkException($"Argument {nameof(numInputs)} must be positive; was {numInputs}.");

            if (numOutputs <= 0)
                throw new NeuralNetworkException($"Argument {nameof(numOutputs)} must be positive; was {numOutputs}.");

            if (hiddenLayerSizes == null || !hiddenLayerSizes.Any())
                throw new NeuralNetworkException($"Argument {nameof(hiddenLayerSizes)} cannot be null or empty.");

            if (hiddenLayerSizes.Any(h => h <= 0))
            {
                var badSize = hiddenLayerSizes.First(h => h <= 0);
                var index = hiddenLayerSizes.IndexOf(badSize);
                throw new NeuralNetworkException($"Argument {nameof(hiddenLayerSizes)} must contain only positive " +
                                                $"values; was {badSize} at index {index}.");
            }

            NumInputs = numInputs;
            NumOutputs = numOutputs;
            HiddenLayerSizes = hiddenLayerSizes.ToArray();

            Weights = new double[hiddenLayerSizes.Count + 1][];

            for (var i = 0; i < hiddenLayerSizes.Count + 1; i++)
            {
                if (i == 0)
                    Weights[i] = new double[(numInputs + 1) * hiddenLayerSizes[0]];
                else if (i < hiddenLayerSizes.Count)
                    Weights[i] = new double[(hiddenLayerSizes[i-1] + 1) * hiddenLayerSizes[i]];
                else
                    Weights[i] = new double[(hiddenLayerSizes[hiddenLayerSizes.Count - 1] + 1) * numOutputs];
            }
        }
Example #18
1
        public IList<Point> Filter(IList<Point> points)
        {
            IList<Point> result = new List<Point>();
            if (points.Count == 0)
            {
                return result;
            }

            var point = new Point(points.First());
            result.Add(point);

            foreach (var currentSourcePoint in points.Skip(1))
            {
                if (!this.DistanceIsTooSmall(currentSourcePoint, point))
                {
                    point = new Point(currentSourcePoint);
                    result.Add(point);
                }
            }

            if (this.checkBoundary && result.Count > 1)
            {
                CheckFirstAndLastPoint(result);
            }

            return result;
        }
Example #19
0
		public bool CanExecute(IList<string> documentIds)
		{
			if (documentIds == null || documentIds.Count == 0)
				return false;

			return string.IsNullOrEmpty(documentIds.First()) == false;
		}
 public static QueryExpressionSyntax WithAllClauses(
     this QueryExpressionSyntax query,
     IList<SyntaxNode> allClauses)
 {
     var fromClause = (FromClauseSyntax)allClauses.First();
     return query.WithFromClause(fromClause).WithBody(query.Body.WithAllClauses(allClauses.Skip(1)));
 }
Example #21
0
        public static List<PlayEvent> Create(IList<Event> events, string homeTeam)
        {
            var penalties = new List<PlayEvent>();

            var penaltyEvents = events.Where(e => e.Class == "Penalty");

            foreach (var penaltyEvent in penaltyEvents)
            {
                var penaltyStartTime = GameTimeCalculator.Calculate(penaltyEvent.Period, penaltyEvent.TimePeriod);
                var penaltyEndTime = CalculatePenaltyEndTime(penaltyEvent.Description, penaltyEvent.Period, penaltyEvent.TimePeriod);

                Logger.Debug(string.Format("Game {0} S {1} E {2} ET {3}", events.First().GameId, penaltyStartTime.ToClockTime(), penaltyEndTime.ToClockTime(), penaltyEvent.Description));

                penalties.Add(new PlayEvent
                {
                    StartTime = penaltyStartTime,
                    EndTime = penaltyEndTime,
                    Class = penaltyEvent.Class,
                    Description = penaltyEvent.Description,
                    HomeTeam = penaltyEvent.Team == homeTeam,
                });
            }

            return penalties;
        }
Example #22
0
        public static RatioValue Calculate(IList<double> numerators, IList<double> denominators)
        {
            if (numerators.Count != denominators.Count)
            {
                throw new ArgumentException();
            }
            if (numerators.Count == 0)
            {
                return null;
            }
            if (numerators.Count == 1)
            {
                return new RatioValue(numerators.First()/denominators.First());
            }
            var statsNumerators = new Statistics(numerators);
            var statsDenominators = new Statistics(denominators);
            var ratios = new Statistics(numerators.Select((value, index) => value/denominators[index]));

            // The mean ratio is the average of "ratios" weighted by "statsDenominators".
            // It's also equal to the sum of the numerators divided by the sum of the denominators.
            var meanRatio = statsNumerators.Sum()/statsDenominators.Sum();

            // Helpers.Assume(Math.Abs(mean - stats.Mean(statsW)) < 0.0001);
            // Make sure the value does not exceed the bounds of a float.
            float meanRatioFloat = (float)Math.Min(float.MaxValue, Math.Max(float.MinValue, meanRatio));

            return new RatioValue
            {
                Ratio = meanRatioFloat,
                StdDev = (float) ratios.StdDev(statsDenominators),
                DotProduct = (float) statsNumerators.Angle(statsDenominators),
            };
        }
Example #23
0
        public virtual Span Handle(IList<Token> tokens, Options options)
        {
            var now = options.Clock();
            var span = new Span(now, now.AddSeconds(1));

            var grabberTokens = tokens
                .SkipWhile(token => token.IsNotTaggedAs<Grabber>())
                .ToList();
            if (grabberTokens.Any())
            {
                span = grabberTokens.GetAnchor(options);
            }

            var scalarRepeaters = tokens
                .TakeWhile(token => token.IsNotTaggedAs<Pointer>())
                .Where(token => token.IsNotTaggedAs<SeparatorComma>())
                .ToList();

            var pointer = tokens.First(token => token.IsTaggedAs<Pointer>());

            for (var index = 0; index < scalarRepeaters.Count - 1; index++)
            {
                var scalar = scalarRepeaters[index];
                var repeater = scalarRepeaters[++index];
                span = Handle(new List<Token>{ scalar, repeater, pointer}, span, options);
            }

            return span;
        }
 /// <summary>
 /// Constructor.
 /// </summary>
 public SubmissionCandidatesViewModel(
     User user,
     IList<Commit> commits,
     Func<Commit, string> commitUrlBuilder,
     Checkpoint checkpoint,
     Model.Projects.Submission latestSubmission,
     ITimeZoneProvider timeZoneProvider)
 {
     User = user;
     Checkpoint = checkpoint;
     Candidates = commits
         .OrderByDescending(commit => commit.PushDate)
         .ThenByDescending(commit => commit.CommitDate)
         .Select
         (
             commit => new SubmissionCandidateViewModel
             (
                 commit,
                 commitUrlBuilder(commit),
                 latestSubmission?.CommitId == commit.Id,
                 commit == commits.First(),
                 timeZoneProvider
             )
         ).ToList();
 }
 private static string tryGetInstanceName(MethodInfo methodInfo, IList<object> arguments)
 {
     return methodInfo.Name.StartsWith("GetNamed", StringComparison.InvariantCultureIgnoreCase)
            && arguments.Any()
         ? Convert.ToString(arguments.First())
         : null;
 }
Example #26
0
 public AnimatedSprite(Texture2D texture, EntityType entityType, IList<AnimationSequence> animations, AnimationActions initialAnimationAction,
     Rectangle worldPosition, Vector2 speed = new Vector2(), Vector2 direction = new Vector2(), bool isCollidable = false, int collisionOffset = 0)
     : base(texture, entityType, worldPosition, speed: speed, direction: direction, isCollidable: isCollidable, collisionOffset: collisionOffset)
 {
     Animations = animations;
     CurrentAnimation = Animations.First(a => a.AnimationAction == initialAnimationAction);
 }
        private void InternalSubmitData(IList<MongodbItem> items)
        {
            if (items == null || items.Count == 0)
                return;

            var databaseName = items.First().DatabaseName;

            try
            {
                if (CachedMongoServer == null)
                    return;

                var database = CachedMongoServer.GetDatabase(databaseName);

                foreach (var item in items)
                {
                    var collection = database.GetCollection(item.TableName);

                    collection.Insert(item.Data);
                }
            }
            catch (Exception ex)
            {
                LocalLoggingService.Exception("MongodbInsertService.InternalSubmitData<{0}> error: {1}", databaseName, ex.Message);
            }
        }
 public ActionResult AprobarOrden(int id, IList<DetalleOrdenRecargaPrepago> detalleOrden, decimal MontoTotalRecargas, string indicadorGuardar, string DocumentoReferencia, string Observaciones)
 {
     ViewModel viewmodel = new ViewModel();
     detalleOrden.First().documentoOrden = DocumentoReferencia;
     detalleOrden.First().observacionesOrden = Observaciones;
     if (indicadorGuardar == "Aprobar")
     {
         if (repOrden.AprobarOrden(detalleOrden.ToList(), MontoTotalRecargas))
         {
             viewmodel.Title = "Prepago / Ordenes de Recarga / Detalle de la Orden";
             viewmodel.Message = "Orden Aprobada.";
             viewmodel.ControllerName = "OrdenRecargaPrepago";
             viewmodel.ActionName = "FilterReview";
             return RedirectToAction("GenericView", viewmodel);
             //return RedirectToAction("DetalleOrden", new { id = id, idOrden = idOrden });
         }
         else
         {
             viewmodel.Title = "Prepago / Ordenes de Recarga / Detalle de la Orden";
             viewmodel.Message = "Falló el proceso de aprobación de la Orden.";
             viewmodel.ControllerName = "OrdenRecargaPrepago";
             viewmodel.ActionName = "FilterReview";
             return RedirectToAction("GenericView", viewmodel);
         }
     }
     else
     {
         if (repOrden.GuardarOrden(detalleOrden.ToList(), MontoTotalRecargas))
         {
             viewmodel.Title = "Prepago / Ordenes de Recarga / Detalle de la Orden";
             viewmodel.Message = "Datos de la Orden actualizados.";
             viewmodel.ControllerName = "OrdenRecargaPrepago";
             viewmodel.ActionName = "FilterReview";
             return RedirectToAction("GenericView", viewmodel);
             //return RedirectToAction("DetalleOrden", new { id = id, idOrden = idOrden });
         }
         else
         {
             viewmodel.Title = "Prepago / Ordenes de Recarga / Detalle de la Orden";
             viewmodel.Message = "Falló el proceso de guardado de la Orden.";
             viewmodel.ControllerName = "OrdenRecargaPrepago";
             viewmodel.ActionName = "FilterReview";
             return RedirectToAction("GenericView", viewmodel);
         }
     }
 }
Example #29
0
		public bool CanExecute(IList<DocumentViewModel> documents)
		{
			if (documents == null || documents.Count == 0)
				return false;

			var document = documents.First();
			return document != null && document.CollectionType != BuiltinCollectionName.Projection;
		}
 public DataProviderViewModel(ExperimentViewModel experimentViewModel, IServiceLocator serviceLocator)
 {
     this.serviceLocator = serviceLocator;
     _experimentViewModel = experimentViewModel;
     ViewModel = experimentViewModel;
     dataProviders = serviceLocator.GetAllInstances<IDataProvider>().ToList();
     selectedDataProvider = dataProviders.First();
 }