void IPrgPrntTracker.AddTracker(ITrackable tracker)
{
if (!_trackerList.ContainsKey(tracker.Id))
_trackerList.Add(tracker.Id, tracker);
if (tracker is BasicTrackerCtrl)
{
BasicTrackerCtrl bCtrl = (BasicTrackerCtrl)tracker;
_mPanel.Children.Add(bCtrl);
}
else if (tracker is PrgTrackerCtrl)
{
PrgTrackerCtrl pCtrl = (PrgTrackerCtrl)tracker;
_mPanel.Children.Add(pCtrl);
}
else if (tracker is TrckCtnrCtrl)
{
TrckCtnrCtrl tCtrl = (TrckCtnrCtrl)tracker;
_mPanel.Children.Add(tCtrl);
}
else
{
// An unknown tracker device has been added.
}
}
public Camera(Rectangle view)
{
this.View = view;
this.Target = Vector2.Zero;
this.track = false;
toTrack = null;
}
public static void ApplyTo(
this string json,
ITrackable trackable,
JsonSerializerSettings jsonSerializerSettings)
{
var pathToChangeMap = JsonConvert.DeserializeObject<Dictionary<string, JObject>>(
json, jsonSerializerSettings);
pathToChangeMap.ApplyTo(trackable, jsonSerializerSettings);
}
public static void ApplyTo(
this IEnumerable<KeyValuePair<string, ITracker>> pathAndTrackers,
ITrackable trackable)
{
foreach (var item in pathAndTrackers)
{
var targetTrackable = trackable.GetTrackableByPath(item.Key);
item.Value.ApplyTo(targetTrackable);
}
}
public TrckCtnrCtrl(ITrackableCtrl tracker)
{
InitializeComponent();
if (tracker == null)
throw new ArgumentNullException("tracker");
_mTracker = tracker;
this.xMainGrid.Children.Add(tracker.TrackableCtrl);
}
public SimpleTorrentManager(ITrackable trackable, IPeerComparer comparer, Tracker tracker)
{
_comparer = comparer;
_trackable = trackable;
_tracker = tracker;
_complete = new BEncodedNumber(0);
_downloaded = new BEncodedNumber(0);
_incomplete = new BEncodedNumber(0);
_peers = new Dictionary<object, Peer>();
_random = new Random();
}
public SimpleTorrentManager(ITrackable trackable, IPeerComparer comparer, Tracker tracker)
{
this.comparer = comparer;
this.trackable = trackable;
this.tracker = tracker;
complete = new BEncodedNumber(0);
downloaded = new BEncodedNumber(0);
incomplete = new BEncodedNumber(0);
peers = new Dictionary<object, Peer>();
random = new Random();
}
public BEncodedValue Handle(PeerDetails d, Common.TorrentEvent e, ITrackable trackable)
{
NameValueCollection c = new NameValueCollection();
c.Add("info_hash", trackable.InfoHash.UrlEncode());
c.Add("peer_id", d.peerId);
c.Add("port", d.Port.ToString());
c.Add("uploaded", d.Uploaded.ToString());
c.Add("downloaded", d.Downloaded.ToString());
c.Add("left", d.Remaining.ToString());
c.Add("compact", "0");
return base.Handle(c, d.ClientAddress, false);
}
public BEncodedValue Handle(PeerDetails peerDetails, ITrackable trackable)
{
var c = new NameValueCollection();
c.Add("info_hash", trackable.InfoHash.UrlEncode());
c.Add("peer_id", peerDetails.PeerId);
c.Add("port", peerDetails.Port.ToString(CultureInfo.InvariantCulture));
c.Add("uploaded", peerDetails.Uploaded.ToString(CultureInfo.InvariantCulture));
c.Add("downloaded", peerDetails.Downloaded.ToString(CultureInfo.InvariantCulture));
c.Add("left", peerDetails.Remaining.ToString(CultureInfo.InvariantCulture));
c.Add("compact", "0");
return base.Handle(c, peerDetails.ClientAddress, false);
}
public static void ApplyTo(
this IEnumerable<KeyValuePair<string, JObject>> pathAndTrackerJObjects,
ITrackable trackable,
JsonSerializerSettings jsonSerializerSettings)
{
foreach (var item in pathAndTrackerJObjects)
{
var targetTrackable = trackable.GetTrackableByPath(item.Key);
if (targetTrackable != null)
{
var trackerType = TrackerResolver.GetDefaultTracker(targetTrackable.GetType());
var tracker = (ITracker)item.Value.ToObject(
trackerType, JsonSerializer.Create(jsonSerializerSettings));
tracker.ApplyTo(targetTrackable);
}
}
}
/// <summary>
/// Adds the trackable to the server
/// </summary>
/// <param name="trackable">The trackable to add</param>
/// <param name="comparer">The comparer used to decide whether two peers are the same.</param>
/// <returns></returns>
public bool Add(ITrackable trackable, IPeerComparer comparer)
{
CheckDisposed();
if (trackable == null)
{
throw new ArgumentNullException(nameof(trackable));
}
lock (Torrents)
{
if (Torrents.ContainsKey(trackable.InfoHash))
{
return(false);
}
Torrents.Add(trackable.InfoHash, new SimpleTorrentManager(trackable, comparer, this));
}
return(true);
}
static void Main(string[] args)
{
logger.LogInfo("Log initialized");
var lines = File.ReadAllLines(csvPath);
logger.LogInfo($"Lines: {lines[0]}");
var parser = new TacoParser();
var locations = lines.Select(parser.Parse).ToArray(); // lists of tacobell location that conforms to Itrackable
ITrackable locationA = new TacoBell();
ITrackable locationB = new TacoBell();
ITrackable location1 = null;
ITrackable location2 = null;
double farDistance = 0;
double distance;
for (int i = 0; i < locations.Count(); i++)
{
locationA = locations[i];
var orgin = new GeoCoordinate(locationA.Location.Latitude, locationA.Location.Longitude);
for (int j = 1; j < locations.Count(); j++)
{
locationB = locations[j];
var destination = new GeoCoordinate(locationB.Location.Latitude, locationB.Location.Longitude);
distance = orgin.GetDistanceTo(destination);
if (distance > farDistance)
{
farDistance = distance * 0.621371;
location1 = locationA;
location2 = locationB;
}
}
}
Console.WriteLine($"Farthest distance = {farDistance} miles between {location1.Name} and {location2.Name}");
}
// Recursively get entity states
public static IEnumerable<EntityState> GetEntityStates(this DbContext context,
ITrackable item, EntityState? entityState = null,
ObjectVisitationHelper visitationHelper = null)
{
// Prevent endless recursion
ObjectVisitationHelper.EnsureCreated(ref visitationHelper);
if (!visitationHelper.TryVisit(item)) yield break;
foreach (var colProp in item.GetNavigationProperties().OfCollectionType())
{
foreach (ITrackable child in colProp.EntityCollection)
{
foreach (var state in context.GetEntityStates(child, visitationHelper: visitationHelper))
{
if (entityState == null || state == entityState)
yield return state;
}
}
}
yield return context.Entry(item).State;
}
public static void Subscribe(ITrackable target, Action <ITrackable, PositionData, PositionData> callback)
{
if (_onPositionChangedCallbacks.TryGetValue(target, out var callbacks))
{
if (callbacks.Contains(callback))
{
throw new ArgumentException("Duplicate callbacks have been subscribed!");
}
else
{
callbacks.Add(callback);
}
}
else
{
_onPositionChangedCallbacks.Add(target, new List <Action <ITrackable, PositionData, PositionData> >()
{
callback
});
}
}
public void ShouldDoSomething()
{
//Act
Point location = new Point()
{
Latitude = 34.252214, Longitude = -84.088239
};
ITrackable expected = new TacoBell()
{
Name = "Taco Bell Cummin...", Location = location
};
//Arrange
TacoParser parser = new TacoParser();
ITrackable actual = parser.Parse("34.252214,84.088239,Taco Bell Cummin...");
//Assert
Assert.Equal(expected.Name, actual.Name);
Assert.Equal(expected.Location.Latitude, actual.Location.Latitude);
Assert.Equal(expected.Location.Longitude, actual.Location.Longitude);
}
public void ShouldParse(string str)
{
//Act
Point location = new Point()
{
Latitude = 34.764965, Longitude = -86.48607
};
ITrackable expected = new TacoBell()
{
Name = "Taco Bell Huntsville", Location = location
};
//Arrange
TacoParser parser = new TacoParser();
ITrackable actual = parser.Parse(str);
//Assert
Assert.Equal(expected.Name, actual.Name);
Assert.Equal(expected.Location.Latitude, actual.Location.Latitude);
Assert.Equal(expected.Location.Longitude, actual.Location.Longitude);
}
// 元素发生改变时的处理事件
void OnItemChanged(object sender, PropertyChangedEventArgs e)
{
if (Tracking)
{
ITrackable item = (ITrackable)sender;
if (e.PropertyName != "TrackingState")
{
// 标志元素被更新
if (item.TrackingState == TrackingInfo.Unchanged)
{
item.TrackingState = TrackingInfo.Updated;
}
// Notify interested parties
if (ItemChanged != null)
{
ItemChanged(this, new ItemChangedEventArgs <T>((T)sender));
}
}
}
}
public void DetectCondition_MultipleConditions_EventHandlerInvokedCorrect(int numConditions)
{
int timesInvoked = 0;
ITrack trackInAirspace = FakeTrackFactory.GetTrack(1000, 1000, 1000);
ITrackable airspace = FakeAirspaceGenerator.GetAirspace(0, 0, 0);
airspace.Trackables.Add(trackInAirspace); //There must be one track always
for (int i = 0; i < numConditions; i++)
{
airspace.Trackables.Add(trackInAirspace);
}
//Because each element in the airspace is compared to each other:
int expectedVisitations = numConditions * airspace.Trackables.Count / 2;
_fakeCondition.ConditionBetween(Arg.Any <ITrack>(), Arg.Any <ITrack>()).Returns(true);
_uutConditionDetector.ConditionsHandler += (s, e) => ++ timesInvoked;
_uutConditionDetector.DetectCondition(airspace);
Assert.That(timesInvoked, Is.EqualTo(expectedVisitations));
}
public static void Track(this ITrackable model, bool creation = true, string user = null)
{
if (creation)
{
if (user != null)
{
model.CreatedBy = user;
}
model.CreatedDateTimeUtc = DateTime.UtcNow;
}
else
{
if (user != null)
{
model.ModifiedBy = user;
}
model.ModifiedDateTimeUtc = DateTime.UtcNow;
}
}
public bool Add(ITrackable trackable, IPeerComparer comparer)
{
CheckDisposed();
if (trackable == null)
{
throw new ArgumentNullException("trackable");
}
lock (torrents)
{
if (torrents.ContainsKey(trackable.InfoHash))
{
return(false);
}
torrents.Add(trackable.InfoHash, new SimpleTorrentManager(trackable, comparer, this));
}
Debug.WriteLine(string.Format("Tracking Torrent: {0}", trackable.Name));
return(true);
}
private void BeforeDrawingDeletion(AbstractDrawing drawing)
{
ITrackable trackableDrawing = drawing as ITrackable;
if (trackableDrawing != null)
{
DeleteTrackableDrawing(trackableDrawing);
}
IMeasurable measurableDrawing = drawing as IMeasurable;
if (measurableDrawing != null)
{
measurableDrawing.ShowMeasurableInfoChanged -= MeasurableDrawing_ShowMeasurableInfoChanged;
}
if (drawing is DrawingDistortionGrid)
{
((DrawingDistortionGrid)drawing).LensCalibrationAsked -= LensCalibrationAsked;
}
}
private async static Task LoadRelatedEntitiesOnPropertiesAsync(this DbContext context,
ITrackable item, ObjectVisitationHelper visitationHelper, CancellationToken cancellationToken, bool loadAll)
{
// Recursively load related entities
foreach (var navProp in item.GetNavigationProperties())
{
// Apply changes to 1-1 and M-1 properties
foreach (var refProp in navProp.AsReferenceProperty())
{
await context.LoadRelatedEntitiesAsync(new[] { refProp.EntityReference }, item, visitationHelper,
cancellationToken, loadAll).ConfigureAwait(false);
}
// Apply changes to 1-M and M-M properties
foreach (var colProp in navProp.AsCollectionProperty())
{
await context.LoadRelatedEntitiesAsync(colProp.EntityCollection, item, visitationHelper,
cancellationToken, loadAll).ConfigureAwait(false);
}
}
}
/// <summary>
/// Recursively set tracking state on trackable properties in an object graph.
/// </summary>
/// <param name="item">Trackable object</param>
/// <param name="modified">Properties on an entity that have been modified</param>
/// <param name="visitationHelper">Circular reference checking helper</param>
public static void SetModifiedProperties(this ITrackable item,
ICollection <string> modified, ObjectVisitationHelper visitationHelper = null)
{
// Prevent endless recursion
ObjectVisitationHelper.EnsureCreated(ref visitationHelper);
if (!visitationHelper.TryVisit(item))
{
return;
}
// Iterate entity properties
foreach (var colProp in item.GetNavigationProperties().OfCollectionType <ITrackingCollection>())
{
// Recursively set modified
foreach (ITrackable child in colProp.EntityCollection)
{
child.SetModifiedProperties(modified, visitationHelper);
child.ModifiedProperties = modified;
}
}
}
static void Main(string[] args)
{
logger.LogInfo("Log initialized");
var lines = File.ReadAllLines(csvPath);
logger.LogInfo($"Lines: {lines[0]}");
var parser = new TacoParser();
var locations = lines.Select(parser.Parse).ToArray();
ITrackable locA = null;
ITrackable locB = null;
Double maxDistance = 0;
for (int i = 0; i < locations.Length; i++)
{
GeoCoordinate corA = new GeoCoordinate();
corA.Latitude = locations[i].Location.Latitude;
corA.Longitude = locations[i].Location.Longitude;
for (int k = 0; k < locations.Length; k++)
{
GeoCoordinate corB = new GeoCoordinate();
corB.Latitude = locations[k].Location.Latitude;
corB.Longitude = locations[k].Location.Longitude;
if (corA.GetDistanceTo(corB) >= maxDistance)
{
maxDistance = corA.GetDistanceTo(corB);
locA = locations[i];
locB = locations[k];
}
}
}
Console.WriteLine($"The Two Farthest Taco Bells are {locA.Name} and {locB.Name}");
// TODO: Find the two Taco Bells in Alabama that are the furthest from one another.
// HINT: You'll need two nested forloops
}
// Recursively get tracking states
public static IEnumerable <TrackingState> GetTrackingStates
(this ITrackable item, TrackingState?trackingState = null,
ObjectVisitationHelper visitationHelper = null)
{
// Prevent endless recursion
ObjectVisitationHelper.EnsureCreated(ref visitationHelper);
if (!visitationHelper.TryVisit(item))
{
yield break;
}
foreach (var navProp in item.GetNavigationProperties())
{
foreach (var refProp in navProp.AsReferenceProperty())
{
foreach (var state in refProp.EntityReference.GetTrackingStates(visitationHelper: visitationHelper))
{
if (trackingState == null || state == trackingState)
{
yield return(state);
}
}
}
foreach (var colProp in navProp.AsCollectionProperty())
{
foreach (ITrackable child in colProp.EntityCollection)
{
foreach (var state in child.GetTrackingStates(visitationHelper: visitationHelper))
{
if (trackingState == null || state == trackingState)
{
yield return(state);
}
}
}
}
}
yield return(item.TrackingState);
}
static void Main(string[] args)
{
logger.LogInfo("Log initialized\n");
var lines = File.ReadAllLines(csvPath);
var parser = new TacoParser();
var locations = lines.Select(parser.Parse);
ITrackable location1 = null;
ITrackable location2 = null;
var distanceMax = 0.0;
foreach (var locA in locations)
{
var origin = new GeoCoordinate(locA.Location.Latitude, locA.Location.Longitude);
foreach (var locB in locations)
{
var destination = new GeoCoordinate(locB.Location.Latitude, locB.Location.Longitude);
var currentDistance = origin.GetDistanceTo(destination);
if (currentDistance > distanceMax)
{
distanceMax = currentDistance;
location1 = locA;
location2 = locB;
}
}
}
Console.WriteLine($"Location 1 : {location1.Name.Substring(1, location1.Name.IndexOf("(") - 1)}");
Console.WriteLine($"Location 2 : {location2.Name.Substring(1, location2.Name.IndexOf("(") - 1)}");
Console.WriteLine($"Distance : {Math.Round(distanceMax, 2)} meters");
logger.LogInfo("Log Complete");
Console.ReadKey();
}
static void Main(string[] args)
{
//logger.LogInfo("Log initialized"); // print logs to console
var lines = File.ReadAllLines(csvPath); //array designed to read locations a
var parser = new TacoParser();
var locations = lines.Select(parser.Parse).ToArray();
ITrackable taco1 = null;
ITrackable taco2 = null;
double distance = 0;
for (int i = 0; i < locations.Length; i++)
{
// logger.LogInfo($"Lines: {lines[i]}");
ITrackable locA = locations[i];
GeoCoordinate corA = new GeoCoordinate(locA.Location.Latitude, locA.Location.Longitude);
for (int k = i + 1; k < locations.Length; k++)
{
ITrackable locB = locations[k];
GeoCoordinate corB = new GeoCoordinate(locB.Location.Latitude, locB.Location.Longitude);
if (corA.GetDistanceTo(corB) >= distance)
{
distance = corA.GetDistanceTo(corB);
taco1 = locA;
taco2 = locB;
}
}
}
Console.WriteLine(taco1.Name);
Console.WriteLine(taco2.Name);
// TODO: Find the two Taco Bells in Alabama that are the furthest from one another.
// HINT: You'll need two nested forloops
}
public static void Rollback(this ITrackable trackable)
{
var tracker = trackable.Tracker;
if (tracker == null)
{
throw new ArgumentException("trackable should have Tracker");
}
if (trackable.Changed)
{
// To prevent tracker from saving rollback changes
// detach tracker from trackable temporarily.
trackable.Tracker = null;
tracker.RollbackTo(trackable);
tracker.Clear();
// Attcah tracker to trackable to undo temporary touch.
trackable.Tracker = tracker;
}
}
private void OnEnemyPositionUpdate(ITrackable trackedEnemy, PositionData oldPosition, PositionData newPosition)
{
var enemy = trackedEnemy as EnemyHealth;
if (newPosition.Chunk != this)
{
Unregister(enemy);
if (newPosition.Chunk != null)
{
newPosition.Chunk.Register(enemy);
}
else if (newPosition.Builder != null)
{
newPosition.Builder.AddEnemy(enemy);
}
else
{
_log.Error($"Enemy {trackedEnemy} has left known bounds at location {newPosition.Position}.");
}
}
}
object ReadField(object instanceEntity, ITrackable trackable, EntityAccessor entityAccessor, Property prop, Type type, int ordinal, DbDataReader dbReader)
{
var accessor = entityAccessor.Properties[prop.PropertyName];
if (accessor == null)
{
throw new GoliathDataException("Could not find accessor for " + instanceEntity.ToString() + "." + prop.PropertyName);
}
var val = dbReader[ordinal];
var fieldType = dbReader.GetFieldType(ordinal);
if (val == DBNull.Value || val == null)
{
return(null);
}
if ((fieldType == accessor.PropertyType) && (val != DBNull.Value))
{
accessor.SetMethod(instanceEntity, val);
LoadInitialValueForInTracker(trackable, prop.PropertyName, val);
return(val);
}
else if (accessor.PropertyType.IsEnum)
{
var enumVal = TypeConverterStore.ConvertToEnum(accessor.PropertyType, val);
accessor.SetMethod(instanceEntity, enumVal);
LoadInitialValueForInTracker(trackable, prop.PropertyName, enumVal);
return(enumVal);
}
else
{
var converter = TypeConverterStore.GetConverterFactoryMethod(accessor.PropertyType);
var convertedValue = converter.Invoke(val);
accessor.SetMethod(instanceEntity, convertedValue);
LoadInitialValueForInTracker(trackable, prop.PropertyName, convertedValue);
return(convertedValue);
}
}
static void Main(string[] args)
{
Logger.LogInfo("Log initialized");
var lines = File.ReadAllLines(CsvPath);
Logger.LogInfo($"Lines: {lines[0]}");
var parser = new TacoParser();
var locations = lines.Select(parser.Parse);
ITrackable a = null;
ITrackable b = null;
double distance = 0;
foreach (var locA in locations)
{
var origin = new GeoCoordinate(locA.Location.Latitude, locA.Location.Longitude);
foreach (var locB in locations)
{
var destination = new GeoCoordinate(locB.Location.Latitude, locB.Location.Longitude);
double newDistance = origin.GetDistanceTo(destination);
if (!(newDistance > distance))
{
continue;
}
a = locA;
b = locB;
distance = newDistance;
}
}
Console.WriteLine($"The two tacobells that are farthest apart are:\n\t{a?.Name} and \n\t{b?.Name}");
Console.WriteLine($"These two locations are {distance/3.28} feet apart");
Console.ReadLine();
}
private static void ApplyChangesOnCollectionProperties(TrackingState stateFilter, bool includeState,
EntityNavigationProperty navProp, EntityCollectionProperty <IList> colProp,
DbContext context, ITrackable item, ObjectVisitationHelper visitationHelper, TrackingState?state = null)
{
// Apply changes to 1-M and M-M properties filtering by tracking state
var count = colProp.EntityCollection.Count;
for (int i = count - 1; i > -1; i--)
{
var trackableChild = colProp.EntityCollection[i] as ITrackable;
if (trackableChild != null)
{
bool condition = includeState
? trackableChild.TrackingState == stateFilter
: trackableChild.TrackingState != stateFilter;
if (condition)
{
context.ApplyChanges(trackableChild, item, visitationHelper, navProp.Property.Name, state);
}
}
}
}
public void StartTracking(ITrackable target)
{
if (isShuttingDown)
{
return;
}
if (IsTracking)
{
StopTracking();
}
if (target != null)
{
Target = target;
GetDesiredPosition(Target.Position);
subscribedProcessors.Add(GetDesiredPosition);
Target.OnPositionChange += GetDesiredPosition;
TrackingProcess += HandleMovement;
IsTracking = true;
}
}
static void Main(string[] args)
{
logger.LogInfo("Log initialized");
Console.Write("Read from where? CSV or Database: ");
var typeOfFile = Console.ReadLine();
typeOfFile = CheckUserInput(typeOfFile);
var locations = SelectFileType(typeOfFile);
double maxDistance = 0;
ITrackable store1 = null;
ITrackable store2 = null;
foreach (var line1 in locations)
{
GeoCoordinate corA = new GeoCoordinate(line1.Location.Latitude, line1.Location.Longitude);
foreach (var line2 in locations)
{
GeoCoordinate corB = new GeoCoordinate(line2.Location.Latitude, line2.Location.Longitude);
double distance = corA.GetDistanceTo(corB);
if (maxDistance < distance)
{
store1 = line1;
store2 = line2;
maxDistance = distance;
}
}
}
Console.WriteLine($"{store1.Name}, {store2.Name}, {maxDistance}");
Console.ReadLine();
}
private static void Main(string[] args)
{
logger.LogInfo("Log initialized");
var lines = File.ReadAllLines(CsvPath);
var parser = new TacoParser();
var locations = lines.Select(parser.Parse);
ITrackable a = null;
ITrackable b = null;
double distance = 0;
foreach (var locA in locations)
{
var origin = new GeoCoordinate(locA.Location.Latitude, locA.Location.Longitude);
foreach (var locB in locations)
{
var destination = new GeoCoordinate(locB.Location.Latitude, locB.Location.Longitude);
var newDistance = origin.GetDistanceTo(destination);
if (!(newDistance > distance))
{
continue;
}
a = locA;
b = locB;
distance = newDistance;
}
}
Console.WriteLine($"These are the two Taco Bells furthest away from each other: \n\t{a?.Name} and \n\t{b?.Name}");
Console.WriteLine($"They are {distance / 0.000621371} miles apart.");
Console.ReadLine();
}
private DomainResult WaitForCompletion(ITrackable command, bool commandOnly)
{
_logger.DebugFormat("Wait from completion, ID is {0}, command only is {1}", command.TrackingId, commandOnly);
IEnumerable <DomainResult> results;
bool hasOngoingProcessing;
var start = DateTime.Now;
do
{
results = _resultStore.Get(command.TrackingId).ToArray();
if (commandOnly)
{
results = results.Where(x => x.IsCommand).ToArray();
}
hasOngoingProcessing = results.Any(x => x.ResultCode == ResultCode.Unknown);
_logger.DebugFormat("Has ongoing for ID {0} : {1}", command.TrackingId, hasOngoingProcessing);
if (hasOngoingProcessing)
{
Thread.Sleep(_sleepInterval);
}
}while (hasOngoingProcessing && (DateTime.Now - start).TotalMilliseconds < _waitTimeout);
_logger.DebugFormat("Done waiting for ID {0}, has ongoing: {1}, has results: {2}", command.TrackingId, hasOngoingProcessing, results.Any());
_logger.DebugFormat("Last known results for ID {0} are", command.TrackingId);
foreach (var cqrsResult in results)
{
_logger.DebugFormat("Result: {0}, isCommand: {1}", cqrsResult.ResultCode, cqrsResult.IsCommand);
}
if (hasOngoingProcessing || !results.Any())
{
return(new DomainResult {
TrackingId = command.TrackingId, ResultCode = ResultCode.Unknown,
});
}
_resultStore.Delete(command.TrackingId);
return(results.OrderByDescending(x => x.ResultCode).FirstOrDefault());
}
public void InitializeEnd(bool cancelCurrentPoint)
{
IInitializable initializable = hitDrawing as IInitializable;
if (initializable == null || !initializable.Initializing)
{
return;
}
string key = initializable.InitializeEnd(cancelCurrentPoint);
if (string.IsNullOrEmpty(key) || !cancelCurrentPoint)
{
return;
}
ITrackable trackable = hitDrawing as ITrackable;
if (trackable != null)
{
trackabilityManager.RemovePoint(trackable, key);
}
}
static void Main(string[] args)
{
var lines = File.ReadAllLines(csvPath);
var parser = new TacoParser();
var locations = lines.Select(parser.Parse).ToArray();
ITrackable trackable1 = null;
ITrackable trackable2 = null;
double maxDistance = 0;
for (int i = 0; i < locations.Length; i++)
{
ITrackable locA = locations[i];
GeoCoordinate corA = new GeoCoordinate(locA.Location.Latitude, locA.Location.Longitude);
for (int k = 0; k < locations.Length; k++)
{
ITrackable locB = locations[k];
GeoCoordinate corB = new GeoCoordinate(locB.Location.Latitude, locB.Location.Longitude);
double distance = corB.GetDistanceTo(corA);
if (distance > maxDistance)
{
maxDistance = distance;
trackable1 = locA;
trackable2 = locB;
}
}
}
Console.WriteLine(trackable1.Name);
Console.WriteLine(trackable2.Name);
Console.WriteLine(maxDistance);
}
static void Main(string[] args)
{
logger.LogInfo("Log initialized");
var lines = File.ReadAllLines(csvPath);
logger.LogInfo($"Lines: {lines[0]}");
var parser = new TacoParser();
var locations = lines.Select(parser.Parse).ToArray();
ITrackable firstTacoBell = null;
ITrackable secondTacoBell = null;
double distance = 0;
for (int i = 0; i < locations.Length; i++)
{
ITrackable locA = locations[i];
GeoCoordinate corA = new GeoCoordinate(locA.Location.Latitude, locA.Location.Longitude);
for (int x = 1; x < locations.Length; x++)
{
ITrackable locB = locations[x];
GeoCoordinate corB = new GeoCoordinate(locB.Location.Latitude, locB.Location.Longitude);
if (corA.GetDistanceTo(corB) > distance)
{
distance = corA.GetDistanceTo(corB);
firstTacoBell = locA;
secondTacoBell = locB;
}
}
}
Console.WriteLine(firstTacoBell.Name);
Console.WriteLine(secondTacoBell.Name);
Console.ReadLine();
}
/// <summary>
/// Получить из делева плоский список ВСЕХ дочерние сущьностей, относительно текущего узла
/// </summary>
/// <param name="rootEntity">Элемент, от которого поиск</param>
/// <param name="predicat">Фильтр полученных элементов </param>
public static IEnumerable <BaseEntity> GetFromCurrent([NotNull] this ITrackable rootEntity, Func <BaseEntity, bool> predicat = null)
{
var flatList = new Dictionary <BaseEntity, BaseEntity>(ReferenceEqualityComparer.Instance);
var monitor = rootEntity.GetMonitor() as EntityStateMonitor;
if (monitor == null)
{
return(new List <BaseEntity>());
}
monitor.TraverseGraph(rootEntity, x =>
{
if (x is BaseEntity baseEntity) // это сущьность
{
if (!flatList.ContainsKey(baseEntity))
{
if (predicat != null)
{
if (predicat.Invoke(baseEntity))
{
flatList.Add(baseEntity, baseEntity);
}
}
else
{
flatList.Add(baseEntity, baseEntity);
}
}
}
return(true); //обходим дерево дальше
});
return(flatList.Keys);
}
private static void ApplyChangesOnProperties(this DbContext context,
ITrackable item, ObjectVisitationHelper visitationHelper, TrackingState?state = null)
{
// Recursively apply changes
foreach (var navProp in item.GetNavigationProperties())
{
// Apply changes to 1-1 and M-1 properties
foreach (var refProp in navProp.AsReferenceProperty())
{
context.ApplyChanges(refProp.EntityReference, item, visitationHelper, navProp.Property.Name, state);
}
// Apply changes to 1-M and M-M properties
foreach (var colProp in navProp.AsCollectionProperty <IList>())
{
// Apply changes on collection property for each state.
// Process added items first, then process others.
ApplyChangesOnCollectionProperties(TrackingState.Added, true,
navProp, colProp, context, item, visitationHelper, state);
ApplyChangesOnCollectionProperties(TrackingState.Added, false,
navProp, colProp, context, item, visitationHelper, state);
}
}
}
public bool Remove(ITrackable item)
{
return _workingSet.Remove(item);
}
public bool Contains(ITrackable item)
{
return _workingSet.Contains(item);
}
public void Add(ITrackable item)
{
_workingSet.Add(item);
}
public void UnTrack()
{
this.track = false;
this.toTrack = null;
}
public void CopyTo(ITrackable[] array, int arrayIndex)
{
_workingSet.CopyTo(array, arrayIndex);
}
public void Track(ITrackable obj)
{
this.track = true;
this.toTrack = obj;
}
bool IPrgPrntTracker.TryGetTracker(string id, out ITrackable tracker)
{
return _trackerList.TryGetValue(id, out tracker);
}
