private void RescanInternal()
{
if (!rescanning)
{
Debug("Rescanning disabled");
return;
}
Task.Factory.StartNew(() =>
{
if (Changing != null)
{
Changing.Invoke(this, EventArgs.Empty);
}
try {
NoticeFormat("Rescanning {0}...", FriendlyName);
DoRoot();
NoticeFormat("Done rescanning {0}...", FriendlyName);
}
catch (Exception ex) {
Error(ex);
}
if (Changed != null)
{
Changed.Invoke(this, EventArgs.Empty);
}
},
TaskCreationOptions.AttachedToParent | TaskCreationOptions.LongRunning);
}
/// <summary>
/// Unloads a Assambly From the Mef Container.
/// It does NOT unload it from the Domain
/// </summary>
/// <param name="assambly">Your Target assambly</param>
public void FreeAssambly(Assembly assambly)
{
var assemblyName = assambly.Location;
var all = _aggregateCatalog.Catalogs.Where(s =>
{
var assemblyCatalog = s as AssemblyCatalog;
if (assemblyCatalog != null)
{
var assamblName = assemblyCatalog.Assembly;
var fn = assamblName.Location;
return(assemblyName == fn);
}
return(false);
}).Cast <AssemblyCatalog>();
var assemblyCatalogs = all as AssemblyCatalog[] ?? all.ToArray();
if (!assemblyCatalogs.Any())
{
ImportPool.AddImportFailMessage(assambly);
return;
}
AssemblyCatalog first;
if (assemblyCatalogs.Count() != 1)
{
var version = assemblyCatalogs.Max(s => AssemblyName.GetAssemblyName(s.Assembly.FullName).Version);
first =
assemblyCatalogs.FirstOrDefault(
s => AssemblyName.GetAssemblyName(s.Assembly.FullName).Version == version);
}
else
{
first = assemblyCatalogs.FirstOrDefault();
}
if (first != null)
{
var parts = first.Parts;
if (Changing != null)
{
Changing.Invoke(this,
new ComposablePartCatalogChangeEventArgs(new List <ComposablePartDefinition>(), parts,
null));
}
_aggregateCatalog.Catalogs.Remove(first);
ImportPool.AddSuccessExcludedMessage(assambly);
if (Changed != null)
{
Changed.Invoke(this,
new ComposablePartCatalogChangeEventArgs(new List <ComposablePartDefinition>(), parts,
null));
}
}
}
/// <summary>
/// Raises the <see cref="Changing"/> event with the given parameters.
/// </summary>
/// <param name="index">The index where the change occurred, if applicable. <c>null</c> otherwise.</param>
/// <param name="changeType">The type of change that occurred.</param>
/// <param name="oldValue">The old value of this content.</param>
/// <param name="newValue">The new value of this content.</param>
protected void NotifyContentChanging(object index, ContentChangeType changeType, object oldValue, object newValue)
{
var args = new ContentChangeEventArgs(this, index, changeType, oldValue, newValue);
PrepareChange?.Invoke(this, args);
Changing?.Invoke(this, args);
}
public void ApplyEdits(params TestEdit[] edits)
{
if (edits.Length == 0)
{
return;
}
var args = new TextContentChangedEventArgs(edits[0].OldSnapshot, edits[edits.Length - 1].NewSnapshot, new EditOptions(), null);
foreach (var edit in edits)
{
args.Changes.Add(new TestTextChange(edit.Change));
}
CurrentSnapshot = edits[edits.Length - 1].NewSnapshot;
if (CurrentSnapshot is StringTextSnapshot testSnapshot)
{
testSnapshot.TextBuffer = this;
}
foreach (var changedEvent in AttachedChangedEvents)
{
changedEvent.Invoke(this, args);
}
PostChanged?.Invoke(this, null);
ReadOnlyRegionsChanged?.Invoke(this, null);
ChangedLowPriority?.Invoke(this, null);
ChangedHighPriority?.Invoke(this, null);
Changing?.Invoke(this, null);
}
private void Rescan()
{
Task.Factory.StartNew(() =>
{
if (Changing != null)
{
Changing.Invoke(this, EventArgs.Empty);
}
try {
InfoFormat("Rescanning...");
DoRoot();
InfoFormat("Done rescanning...");
}
catch (Exception ex) {
Error(ex);
}
if (Changed != null)
{
Changed.Invoke(this, EventArgs.Empty);
}
}, TaskCreationOptions.AttachedToParent | TaskCreationOptions.LongRunning);
}
private void UpdateSyncModes(SyncMode newModes)
{
if (_logger.IsTrace)
{
if (newModes != Current)
{
string message = $"Changing state to {newModes}";
if (_logger.IsTrace)
{
_logger.Trace(message);
}
}
}
SyncMode previous = Current;
SyncModeChangedEventArgs args = new SyncModeChangedEventArgs(previous, Current);
// Changing is invoked here so we can block until all the subsystems are ready to switch
// for example when switching to Full sync we need to ensure that we safely transition
// the beam sync DB and beam processor
Preparing?.Invoke(this, args);
Changing?.Invoke(this, args);
Current = newModes;
Changed?.Invoke(this, args);
}
private void RaiseOnChanging(string key, object data, out ChangingEventArgs e)
{
e = new ChangingEventArgs
{
Key = key,
OldValue = GetItem(key),
NewValue = data
};
Changing?.Invoke(this, e);
}
internal virtual void OnAddingObject()
{
if (Parent != null)
{
Parent.OnAddingObject();
}
if (Changing != null)
{
Changing.Invoke(this, null);
}
}
private void RaiseOnChangingSync(string key, object oldValue, object data)
{
var e = new ChangingEventArgs
{
Key = key,
OldValue = oldValue,
NewValue = data
};
Changing?.Invoke(this, e);
}
private ChangingEventArgs RaiseOnChangingSync(string key, object data)
{
var e = new ChangingEventArgs
{
Key = key,
OldValue = ((ISyncLocalStorageService)this).GetItem <object>(key),
NewValue = data
};
Changing?.Invoke(this, e);
return(e);
}
private ChangingEventArgs RaiseOnChangingSync(string key, object data)
{
var e = new ChangingEventArgs
{
Key = key,
OldValue = GetItemInternal <object>(key),
NewValue = data
};
Changing?.Invoke(this, e);
return(e);
}
private async Task <ChangingEventArgs> RaiseOnChangingAsync(string key, object data)
{
var e = new ChangingEventArgs
{
Key = key,
OldValue = await GetItemAsync <object>(key),
NewValue = data
};
Changing?.Invoke(this, e);
return(e);
}
public ValueTask SetItemAsync <T>(string key, T data)
{
Changing?.Invoke(this, new ChangingEventArgs()
{
Key = key, NewValue = data
});
dictionary[key] = data;
Changed?.Invoke(this, new ChangedEventArgs()
{
Key = key, NewValue = data
});
return(ValueTask.CompletedTask);
}
private void ContentChanging(object sender, ContentChangeEventArgs e)
{
var node = e.Content.OwnerNode as IGraphNode;
if (node != null)
{
foreach (var child in GetAllChildNodes(node))
{
child.Content.Changing -= ContentChanging;
child.Content.Changed -= ContentChanged;
}
}
Changing?.Invoke(sender, e);
}
private void ApplyChange(TextSnapshotMock snapshot)
{
Changing?.Invoke(this, new TextContentChangingEventArgs(CurrentSnapshot, new object(), CancelAction));
var before = CurrentSnapshot;
CurrentSnapshot = snapshot;
var args = new TextContentChangedEventArgs(before, CurrentSnapshot, EditOptions.None, new object());
BeforeChanged?.Invoke(this, args);
ChangedHighPriority?.Invoke(this, args);
Changed?.Invoke(this, args);
ChangedLowPriority?.Invoke(this, args);
PostChanged?.Invoke(this, EventArgs.Empty);
}
public void ApplyEdit(TestEdit edit)
{
var args = new TextContentChangedEventArgs(edit.OldSnapshot, edit.NewSnapshot, new EditOptions(), null);
args.Changes.Add(new TextChange(edit));
Changed?.Invoke(this, args);
ReadOnlyRegionsChanged?.Invoke(null, null);
ChangedLowPriority?.Invoke(null, null);
ChangedHighPriority?.Invoke(null, null);
Changing?.Invoke(null, null);
PostChanged?.Invoke(null, null);
ContentTypeChanged?.Invoke(null, null);
_currentSnapshot = edit.NewSnapshot;
}
void UpdateList()
{
if (enableHacks)
{
foreach (var result in search.Results)
{
if (itemsInList.Add(result.Item1))
{
Add(CreateCompletionData(result.Item1));
}
}
}
else
{
Clear();
foreach (var result in search.Results)
{
Add(CreateCompletionData(result.Item1));
}
}
//HACK: the completion window will not re-sort the list
Sort(Comparer);
IsSorted = true;
//HACK: the completion list doesn't refilter after we update it
//so we have to manually reset the filtering
if (enableHacks && CompletionWindowManager.Wnd != null)
{
var window = completionWindowWindowField.GetValue(CompletionWindowManager.Wnd);
var list = listWindowListProp.GetValue(window);
oldCompletionStringField.SetValue(list, null);
filterWordsMeth.Invoke(CompletionWindowManager.Wnd, null);
}
bool wasChanging = false;
IsChanging = search.RemainingFeeds.Count > 0;
Changed?.Invoke(this, EventArgs.Empty);
if (!wasChanging && IsChanging)
{
Changing?.Invoke(this, EventArgs.Empty);
}
}
private void RescanInternal()
{
lock (this)
{
if (!rescanning)
{
Debug("Rescanning disabled");
return;
}
if (isRescanning)
{
Debug("Already rescanning");
}
isRescanning = true;
}
Task.Factory.StartNew(() =>
{
try
{
Changing?.Invoke(this, EventArgs.Empty);
try
{
NoticeFormat("Rescanning {0}...", FriendlyName);
DoRoot();
NoticeFormat("Done rescanning {0}...", FriendlyName);
}
catch (Exception ex)
{
Error(ex);
}
Changed?.Invoke(this, EventArgs.Empty);
}
finally
{
lock (this)
{
isRescanning = false;
}
}
}, TaskCreationOptions.AttachedToParent | TaskCreationOptions.LongRunning);
}
void UpdateSearch(string searchString)
{
if (oldSearchString != null && !ShouldUpdate(searchString, oldSearchString))
{
return;
}
oldSearchString = searchString;
var newSearch = CreateSearch(searchString);
if (search != null)
{
search.Cancel();
search.Updated -= HandleSearchUpdated;
}
search = newSearch;
search.Updated += HandleSearchUpdated;
Changing?.Invoke(this, EventArgs.Empty);
UpdateList();
}
public void ApplyEdits(params TestEdit[] edits)
{
var args = new TextContentChangedEventArgs(edits[0].OldSnapshot, edits[edits.Length - 1].NewSnapshot, new EditOptions(), null);
foreach (var edit in edits)
{
args.Changes.Add(new TestTextChange(edit.Change));
}
_currentSnapshot = edits[edits.Length - 1].NewSnapshot;
foreach (var changedEvent in AttachedChangedEvents)
{
changedEvent.Invoke(this, args);
}
PostChanged?.Invoke(null, null);
ReadOnlyRegionsChanged?.Invoke(null, null);
ChangedLowPriority?.Invoke(null, null);
ChangedHighPriority?.Invoke(null, null);
Changing?.Invoke(null, null);
ContentTypeChanged?.Invoke(null, null);
}
private void AddOrDeleteChanging(ComposablePartCatalogChangeEventArgs changeArgs, Action addDeleteAction, bool added)
{
bool changeException = false;
ChangeRejectedException changeRejectedException = null;
string failureDetails = null;
bool recompositionSuccess = false;
RecompositionEventReason recompositionEventReason = RecompositionEventReason.Deleted;
try
{
Changing?.Invoke(this, changeArgs);
}
catch (ChangeRejectedException exc)
{
failureDetails = GetChangeRejectedExceptionMessage(exc);
changeException = true;
}
addDeleteAction();
Changed?.Invoke(this, changeArgs);
if (!changeException)
{
recompositionSuccess = true;
}
else
{
RecompositionException(changeRejectedException);
}
if (added)
{
recompositionEventReason = RecompositionEventReason.Added;
}
RecompositionAttemptEvent?.Invoke(this, new RecompositionAttemptEventArgs(recompositionSuccess, recompositionEventReason, failureDetails));
}
public int this[int idx]
{
get
{
return(_Contents[idx]);
}
set
{
if (idx > 0)
{
var arg = new MemoryEventArgs()
{
Address = idx
};
Changing?.Invoke(this, arg);
_Contents[idx] = value;
Changed?.Invoke(this, arg);
}
else
{
//ignore or throw an exception
}
}
}
private void ContentChanging(object sender, ContentChangeEventArgs e)
{
var path = GetPath(e.Content.OwnerNode);
Changing?.Invoke(sender, new GraphContentChangeEventArgs(e, path));
}
/// <summary>Raise <see cref="Changing"/> event.</summary> /// <param name="startIndex">Index of the first item in a changing range.</param> /// <param name="endIndex">Index of the last item in a changing range.</param> /// <param name="notifyEvent">Change type.</param> protected void RaiseChanging(int startIndex, int endIndex, NotifyEvent notifyEvent) => Changing?.Invoke(this, new NotifyCollectionEventArgs(startIndex, endIndex, notifyEvent));
/// <summary>Raise <see cref="Changing"/> event.</summary> /// <param name="index">Index of the item which is changing.</param> /// <param name="notifyEvent">Change type.</param> protected void RaiseChanging(int index, NotifyEvent notifyEvent) => Changing?.Invoke(this, new NotifyCollectionEventArgs(index, notifyEvent));
private void ContentChanging(object sender, ContentChangeEventArgs e)
{
Changing?.Invoke(sender, new GraphContentChangeEventArgs(e));
}
private void ContentChanging(object sender, MemberNodeChangeEventArgs e)
{
Changing?.Invoke(sender, e);
}
private void SyncModeSelectorOnChanging(object sender, SyncModeChangedEventArgs e)
{
Changing?.Invoke(this, e);
}
protected virtual void OnChanging(object sender, ChangingMatrixElementEventArgs <T> e) => Changing?.Invoke(sender, e);
private void CheckAndAddAssambly(string filename, Action cancel)
{
AssemblyName assemblyName = null;
try
{
assemblyName = AssemblyName.GetAssemblyName(filename);
}
catch (ArgumentException e)
{
IsHandeld(e, filename);
return;
}
catch (BadImageFormatException e)
{
IsHandeld(e, filename);
return;
}
catch (FileLoadException e)
{
IsHandeld(e, filename);
return;
}
catch (FileNotFoundException e)
{
IsHandeld(e, filename);
return;
}
catch (PlatformNotSupportedException e)
{
IsHandeld(e, filename);
return;
}
catch (SecurityException e)
{
IsHandeld(e, filename);
return;
}
catch (Exception e)
{
IsHandeld(e, filename);
Console.WriteLine("first chance exception of type '" + e.GetType() + "' in assambly '" + filename +
"' was NOT Handeled by StrongNameCatalog ...");
cancel();
}
if (assemblyName == null)
{
return;
}
#if (SECLOADING)
var publicKey = assemblyName.GetPublicKey();
if (publicKey == null)
{
continue;
}
var trusted = _trustedKeys.Any(trustedKey => assemblyName.GetPublicKey().SequenceEqual(trustedKey));
if (!trusted)
{
continue;
}
#endif
try
{
var assam = new AssemblyCatalog(filename);
if (!assam.Parts.Any())
{
ImportPool.AddNotAnImportMessage(assam.Assembly);
return;
}
if (_aggregateCatalog.Catalogs.Any(s => s.ToString() == assam.ToString()))
{
return;
}
if (Changing != null)
{
Changing.Invoke(this,
new ComposablePartCatalogChangeEventArgs(assam.Parts,
new List <ComposablePartDefinition>(), null));
}
_aggregateCatalog.Catalogs.Add(assam);
ImportPool.AddSuccessIncludedMessage(filename);
if (Changed != null)
{
Changed.Invoke(this,
new ComposablePartCatalogChangeEventArgs(assam.Parts,
new List <ComposablePartDefinition>(), null));
}
}
catch (Exception e)
{
IsHandeld(e, filename);
}
}