/// <summary>
/// Btn_StartSyn_Click
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Btn_StartSyn_Click(object sender, EventArgs e)
{
try
{
#region 是否开启Debug
///开启Debug模式
Sync.SetDebug(Boolean.Parse(Config.GetConfigValue("Debug")));
#endregion
//SyncEventHandler syncEn = new SyncEventHandler(SynDatas);
SyncEventHandler syncEn = new SyncEventHandler(SyncData);
syncEn.BeginInvoke(new AsyncCallback(RunCallBack), null);
frmSyn.sMessage = "操作正在执行中,请稍候...";
frmSyn.ShowDialog();
//SynUsers(Convert.ToInt32(strSynType));
}
catch (Exception ex)
{
//throw ex;
Log.WriteLog(ex.Message);
MessageBox.Show(Sync.errorMsg.ToString());
}
}
/// <summary>
/// 读串口线程
/// </summary>
public static void Read()
{
while (isContinue)
{
try
{
if (SyncSerialPort.IsOpen)
{
string message = SyncSerialPort.ReadTo(",END");
EventsClass.GpsEventArgs e = new EventsClass.GpsEventArgs(message);
SyncEventHandler handler = SyncLogEvent;
if (handler != null)
{
handler(null, e);
}
}
}
catch (Exception MyEx)
{
//MessageBox.Show(MyEx.Message + ":" + MyEx.StackTrace);
isContinue = false;
}
}
}
public void LoadSolution(bool clearCache, bool syncAfterLoad, SyncEventHandler handler)
{
_syncAfterLoad = syncAfterLoad;
if (!clearCache && !DbContext.Current.Database.IsSynced())
{
clearCache = true;
}
if (clearCache)
{
DbContext.Current.CreateDatabase();
}
else
{
LogManager.Logger.ScheduledClear();
}
if (!clearCache)
{
DbContext.Current.Database.OnStart();
LoadAsync(handler);
}
else
{
RefreshAsync(handler);
}
}
/// <summary>
/// Adds the event handler to the manager.
/// </summary>
/// <param name='handler'>
/// Handler to add.
/// </param>
public void AddEventHandler(SyncEventHandler handler) {
// The zero-based index of item in the sorted List<T>,
// if item is found; otherwise, a negative number that
// is the bitwise complement of the index of the next
// element that is larger than item or.
int pos = this.handler.BinarySearch(handler);
if (pos < 0) {
pos = ~pos;
}
this.handler.Insert(pos, handler);
}
/// <summary>
/// Initializes a new instance of the <see cref="CmisSync.Lib.Events.RequestIgnoredEvent"/> class.
/// </summary>
/// <param name="ignoredEvent">Ignored event.</param>
/// <param name="reason">Reason why it has been ignored.</param>
/// <param name="source">The source which ignored the event.</param>
public RequestIgnoredEvent(ISyncEvent ignoredEvent, string reason = null, SyncEventHandler source = null) {
if (ignoredEvent == null) {
throw new ArgumentNullException("ignoredEvent");
}
if (reason == null && source == null) {
throw new ArgumentNullException("There must be a reason or source given for the ignored event");
}
this.IgnoredEvent = ignoredEvent;
this.Reason = (reason != null) ? reason : "Event has been ignored by: " + source.ToString();
}
public SingleStepEventQueue(
ISyncEventManager manager,
IEventCounter fullCounter = null,
IEventCounter categoryCounter = null)
{
this.Manager = manager;
this.fullCounter = fullCounter ?? new QueuedEventsCounter();
this.categoryCounter = categoryCounter ?? new QueuedCategorizedEventsCounter();
this.dropAllFsEventsHandler = new GenericSyncEventHandler <IFSEvent>(
int.MaxValue,
delegate(ISyncEvent e) {
return(true);
});
}
public SingleStepEventQueue(
ISyncEventManager manager,
IEventCounter fullCounter = null,
IEventCounter categoryCounter = null)
{
this.Manager = manager;
this.fullCounter = fullCounter ?? new QueuedEventsCounter();
this.categoryCounter = categoryCounter ?? new QueuedCategorizedEventsCounter();
this.dropAllFsEventsHandler = new GenericSyncEventHandler<IFSEvent>(
int.MaxValue,
delegate(ISyncEvent e) {
return true;
});
}
public void RefreshAsync(SyncEventHandler handler)
{
if (!inSync)
{
if (DbEngine.Database.Current.InTransaction())
{
throw new Exception("You shoud rollback or commit transaction before sync");
}
inSync = true;
_syncEvent.Reset();
this.syncEvent = handler;
context.CacheController.RefreshAsync();
}
}
public void RefreshAsync(SyncEventHandler handler)
{
if (!_inSync)
{
if (DbContext.Current.Database.InTransaction())
{
throw new Exception("You shoud rollback or commit transaction before sync");
}
LogManager.Logger.SyncStarted();
_inSync = true;
_syncEvent.Reset();
SyncEvent = handler;
_context.CacheController.RefreshAsync();
}
}
internal Synchronizer(Target <Ta> target, Source <Tb> source, Func <Tb, Ta> createTargetItem, Action <Ta> destroyTargetItem, Predicate <Tb> filterPredicate, SyncEventHandler <Ta, Tb> syncEventHandler = null)
{
FTarget = target;
FSource = source;
FCreateTargetItem = createTargetItem;
FDestroyTargetItem = destroyTargetItem;
FFilterPredicate = filterPredicate;
FBToAMap = new Dictionary <Tb, List <Ta> >();
FStashedActions = new List <Action>();
if (syncEventHandler != null)
{
Synced += syncEventHandler;
}
Reload();
FSource.SourceChanged += HandleSourceChanged;
}
private void Form1_Load(object sender, EventArgs e)
{
SyncLogEvent += new SyncEventHandler(GPSForm_GpsLogEvent);
String input;
try
{
csFile fl = new csFile("command.txt");
while ((input = fl.readLine()) != null)
{
Commandlist.Items.Add(input);
}
}
catch (Exception MyEx)
{
MessageBox.Show(MyEx.Message + ":" + "请确认数据文件在commands文件夹中且当前路径下有command文件！");
Application.Exit();
}
}
/// <summary>
/// 异步CallBack
/// </summary>
/// <param name="ar"></param>
private void RunCallBack(IAsyncResult ar)
{
SyncEventHandler d = null;
try
{
System.Runtime.Remoting.Messaging.AsyncResult asres = (System.Runtime.Remoting.Messaging.AsyncResult)ar;
d = ((SyncEventHandler)asres.AsyncDelegate);
d.EndInvoke(ar);
frmSyn.BeginInvoke((Action) delegate()
{
frmSyn.Close();
});
}
catch (Exception ex)
{
throw ex;
}
}
public void LoadSolution(bool clearCache, bool syncAfterLoad, SyncEventHandler handler)
{
_syncAfterLoad = syncAfterLoad;
if (!clearCache && !DbEngine.Database.Current.IsSynced())
{
clearCache = true;
}
if (clearCache)
{
DbEngine.Database.CreateDatabase();
}
if (!clearCache)
{
DbEngine.Database.Current.OnStart();
LoadAsync(handler);
}
else
{
RefreshAsync(handler);
}
}
public static Synchronizer <Ta, Tb> SyncWith <Ta, Tb>(this ViewableCollection <Ta> collectionA, IEnumerable <Tb> collectionB, Func <Tb, Ta> createA, Action <Ta> destroyA = null, Predicate <Tb> filterPredicate = null, SyncEventHandler <Ta, Tb> syncEventHandler = null)
{
var target = new ViewableCollectionTarget <Ta>(collectionA);
var source = CreateGenericSource(collectionB);
destroyA = destroyA ?? RemoveAndDispose;
filterPredicate = filterPredicate ?? DefaultFilterPredicate;
return(new Synchronizer <Ta, Tb>(target, source, createA, destroyA, filterPredicate, syncEventHandler));
}
void LoadAsync(SyncEventHandler handler)
{
this.syncEvent = handler;
context.LoadAsync();
}
/// <summary>
/// Removes the event handler.
/// </summary>
/// <param name='handler'>
/// Handler to remove.
/// </param>
public void RemoveEventHandler(SyncEventHandler handler) {
this.handler.Remove(handler);
}
public void LoadSolution(bool clearCache, bool syncAfterLoad, SyncEventHandler handler)
{
_syncAfterLoad = syncAfterLoad;
if (!clearCache && !DbEngine.Database.Current.IsSynced())
clearCache = true;
if (clearCache)
DbEngine.Database.CreateDatabase();
if (!clearCache)
{
DbEngine.Database.Current.OnStart();
LoadAsync(handler);
}
else
{
RefreshAsync(handler);
}
}
public void RefreshAsync(SyncEventHandler handler)
{
if (!_inSync)
{
if (DbContext.Current.Database.InTransaction())
throw new Exception("You shoud rollback or commit transaction before sync");
LogManager.Logger.SyncStarted();
_inSync = true;
_syncEvent.Reset();
SyncEvent = handler;
_context.CacheController.RefreshAsync();
}
}
void LoadAsync(SyncEventHandler handler)
{
SyncEvent = handler;
_context.LoadAsync();
}
public void LoadSolution(bool clearCache, bool syncAfterLoad, SyncEventHandler handler)
{
_syncAfterLoad = syncAfterLoad;
if (!clearCache && !DbContext.Current.Database.IsSynced())
clearCache = true;
if (clearCache)
DbContext.Current.CreateDatabase();
else
LogManager.Logger.ScheduledClear();
if (!clearCache)
{
DbContext.Current.Database.OnStart();
LoadAsync(handler);
}
else
{
RefreshAsync(handler);
}
}
/// <summary></summary>
/// <param name="h"></param>
public void RemoveEventHandler(SyncEventHandler h)
{
handler.Remove(h);
}
void LoadAsync(SyncEventHandler handler)
{
this.syncEvent = handler;
context.LoadAsync();
}
public static Synchronizer <object, object> SyncWith(this IList listA, IEnumerable collectionB, Func <object, object> createA, Action <object> destroyA = null, Predicate <object> filterPredicate = null, SyncEventHandler <object, object> syncEventHandler = null)
{
var target = new NonGenericListTarget(listA);
var source = CreateNonGenericSource(collectionB);
destroyA = destroyA ?? RemoveAndDispose;
filterPredicate = filterPredicate ?? DefaultFilterPredicate;
return(new Synchronizer <object, object>(target, source, createA, destroyA, filterPredicate, syncEventHandler));
}
void LoadAsync(SyncEventHandler handler)
{
SyncEvent = handler;
_context.LoadAsync();
}
public void RefreshAsync(SyncEventHandler handler)
{
if (!inSync)
{
if (DbEngine.Database.Current.InTransaction())
throw new Exception("You shoud rollback or commit transaction before sync");
inSync = true;
_syncEvent.Reset();
this.syncEvent = handler;
context.CacheController.RefreshAsync();
}
}
