public bool Connect(string server, int port, string type, bool useSsl)
{
if (InvokeRequired)
{
var d = new ConnectDelegate(Connect);
return((bool)Invoke(d, new object[] { server, port, type, useSsl }));
}
else
{
try
{
TN3270.Config.UseSSL = useSsl;
TN3270.Config.TermType = type;
TN3270.Audit = this;
//TN3270.Debug = true;
TN3270.Config.FastScreenMode = true;
TN3270.Connect(server, port, string.Empty);
Redraw();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
return(false);
}
return(true);
}
}
/// <summary>
/// 接続・切断ボタンクリック
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void buttonConnect_Click(object sender, EventArgs e)
{
if (dataTransceiver.IsOpen == true)
{
try
{
ConnectDelegate disconnectDelegate = new ConnectDelegate(disconnectSerial);
this.BeginInvoke(disconnectDelegate);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return;
}
try
{
ConnectDelegate connectDelegate = new ConnectDelegate(connectSerial);
this.BeginInvoke(connectDelegate);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public TCPClient(Control control, ConnectDelegate connectDelegate, DisconnectDelegate disconnectDelegate, ServerMessageDelegate messageDelegate)
{
this.control = control;
this.connectDelegate = connectDelegate;
this.disconnectDelegate = disconnectDelegate;
AddMessageDelegate(messageDelegate);
}
public void EndConnect(IAsyncResult ar)
{
AsyncResult a = (AsyncResult)ar;
ConnectDelegate d = (ConnectDelegate)a.AsyncDelegate;
d.EndInvoke(ar);
}
private void MainForm_Load(object sender, EventArgs e)
{
vp.GridLevel = 10;
this.Connect = new ConnectDelegate(ShowConnection);
this.DrawPixel = new DrawPixelDelegate(DrawPixel3DView);
this.DrawChunk = new DrawChunkDelegate(DrawChunk3DView);
this.Monitor = new MonitorDelegate(UpdateMonitor);
this.antialias.SelectedIndex = 0;
td_bitmap = new Bitmap(view_3d.Width, view_3d.Height);
empty_bitmap(td_bitmap);
view_3d.Image = td_bitmap;
this.client = new ConClient();
this.listenerWorker = new ListenerWorker(client, this);
this.listenerWorker.WorkerSupportsCancellation = true;
this.listenerWorker.Offline = false;
this.calculusWorker.Offline = false;
calculusWorker.Connection = client;
calculusWorker.DestinationImage = view_3d.Image;
ol.Add(new Camera());
ol.Selected = ol.Collection[0];
redraw();
show_server_mapping.Enabled = false;
}
private void button1_Click(object sender, EventArgs e)
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
ConnectDelegate start = new ConnectDelegate(ServerConnect);
start.BeginInvoke(socket, null, null);
}
public override bool Launch(ConnectDelegate connect)
{
StopIIS();
string config = LauncherCommon.CreateConfigString(ProfilingMode, ListenPort, false, IncludeNative, SamplingInterval, CounterInterval, AllowMethodInlining, TrackGC, TrackAllocs);
string[] profilerEnv = LauncherCommon.CreateProfilerEnvironment(config, LauncherCommon.GetCounterString(PerformanceCounters));
string[] baseEnv = LauncherCommon.GetServicesEnvironment();
baseEnv = LauncherCommon.ReplaceTempDir(baseEnv, Path.GetTempPath());
string[] env = LauncherCommon.CombineEnvironments(baseEnv, profilerEnv);
LauncherCommon.SetEnvironmentVariables("IISADMIN", env);
LauncherCommon.SetEnvironmentVariables("W3SVC", env);
LauncherCommon.SetEnvironmentVariables("WAS", env);
string accountName = GetASP_NETaccountName();
string accountSid = null;
if (accountName != null)
{
accountSid = LauncherCommon.GetAccountSid(accountName);
if (accountSid != null)
{
LauncherCommon.SetAccountEnvironment(accountSid, profilerEnv);
}
}
bool returnVal = StartIIS();
if (returnVal)
{
Thread.Sleep(1000);
//we need to create a connection in order to know when CLR has been loaded
using (IDataEngine engine = new DummyDataEngine())
{
var client = connect("localhost", ListenPort, engine, 10);
if (client != null)
{
client.Dispose();
}
else
{
returnVal = false;
}
}
}
LauncherCommon.DeleteEnvironmentVariables("IISADMIN");
LauncherCommon.DeleteEnvironmentVariables("W3SVC");
LauncherCommon.DeleteEnvironmentVariables("WAS");
if (accountSid != null)
{
LauncherCommon.ResetAccountEnvironment(accountSid, profilerEnv);
}
return(returnVal);
}
/// <summary>
/// 构造函数
/// </summary>
public DoubleChannelClient()
{
isOpen = false;
connectDelegate = Connect;
sendByChannel1Delegate = SendByChannel1;
sendByChannel2Delegate = SendByChannel2;
receiveByChannel1Delegate = ReceiveByChannel1;
receiveByChannel2Delegate = ReceiveByChannel2;
}
/// <summary>
///
/// </summary>
/// <param name="callBack"></param>
/// <returns></returns>
public Task <PlayerIndex?> Connect(ConnectDelegate onConnect)
{
return(Task <PlayerIndex?> .Factory.StartNew(WaitForConnect)
.ContinueWith(
(r) =>
{
onConnect.Invoke(r.Result);
return r.Result;
}
));
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="channelHandler">通道的数据包处理器</param>
/// <param name="monitor">数据包处理器监测器</param>
internal SingleChannelClient(IPacketHandler channelHandler, IPacketMonitor monitor)
{
this.channelHandler = channelHandler;
isOpen = true;
key = channelHandler.Key;
iv = channelHandler.IV;
this.monitor = monitor;
connectDelegate = Connect;
sendDelegate = Send;
receiveDelegate = Receive;
}
public bool Connect()
{
if (this.InvokeRequired)
{
ConnectDelegate connectDelegate = Connect;
return((bool)this.Invoke(connectDelegate, null));
}
else
{
IntPtr result;
IntPtr aRetVal = Platform.SendMessageTimeout(Platform.HWND_BROADCAST, UM_SkypeControlAPIDiscover, Handle, IntPtr.Zero, Platform.SendMessageTimeoutFlags.SMTO_NORMAL, 100, out result);
return(aRetVal != IntPtr.Zero);
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="channelHandler1">通道1的数据包处理器</param>
/// <param name="channelHandler2">通道2的数据包处理器</param>
/// <param name="monitor">数据包处理器监测器</param>
internal DoubleChannelClient(IPacketHandler channelHandler1, IPacketHandler channelHandler2, IPacketMonitor monitor)
{
this.channelHandler1 = channelHandler1;
this.channelHandler2 = channelHandler2;
isOpen = true;
key = channelHandler1.Key;
iv = channelHandler1.IV;
this.monitor = monitor;
connectDelegate = Connect;
sendByChannel1Delegate = SendByChannel1;
sendByChannel2Delegate = SendByChannel2;
receiveByChannel1Delegate = ReceiveByChannel1;
receiveByChannel2Delegate = ReceiveByChannel2;
}
public override bool Launch(ConnectDelegate connect)
{
StopIIS();
string config = LauncherCommon.CreateConfigString(ProfilingMode, ListenPort, false, IncludeNative, SamplingInterval, CounterInterval, AllowMethodInlining, TrackGC, TrackAllocs);
string[] profilerEnv = LauncherCommon.CreateProfilerEnvironment(config, LauncherCommon.GetCounterString(PerformanceCounters));
string[] baseEnv = LauncherCommon.GetServicesEnvironment();
baseEnv = LauncherCommon.ReplaceTempDir(baseEnv, Path.GetTempPath());
string[] env = LauncherCommon.CombineEnvironments(baseEnv, profilerEnv);
LauncherCommon.SetEnvironmentVariables("IISADMIN", env);
LauncherCommon.SetEnvironmentVariables("W3SVC", env);
LauncherCommon.SetEnvironmentVariables("WAS", env);
string accountName = GetASP_NETaccountName();
string accountSid = null;
if(accountName != null)
{
accountSid = LauncherCommon.GetAccountSid(accountName);
if(accountSid != null)
LauncherCommon.SetAccountEnvironment(accountSid, profilerEnv);
}
bool returnVal = StartIIS();
if(returnVal)
{
Thread.Sleep(1000);
//we need to create a connection in order to know when CLR has been loaded
using(IDataEngine engine = new DummyDataEngine())
{
var client = connect("localhost", ListenPort, engine, 10);
if(client != null)
client.Dispose();
else
returnVal = false;
}
}
LauncherCommon.DeleteEnvironmentVariables("IISADMIN");
LauncherCommon.DeleteEnvironmentVariables("W3SVC");
LauncherCommon.DeleteEnvironmentVariables("WAS");
if(accountSid != null)
LauncherCommon.ResetAccountEnvironment(accountSid, profilerEnv);
return returnVal;
}
void ServerBegin(Socket s)
{
while (true)
{
try
{
while (s != null)
{
Socket ns = s.Accept();
ConnectDelegate cd = new ConnectDelegate(ServerConnect);
cd.BeginInvoke(ns, null, null);
}
}
catch { }
}
}
public void Close(bool resetConnect)
{
Log.Debug("Proto Close");
if (client != null)
{
waitingPong = false;
lastPingStartTime = 0;
connectBack = null;
connectBack1 = null;
StopAllCoroutines();
client.Close();
recvLen = 0;
IsServerConnet = false;
if (resetConnect)
{
ResetConnectType();
}
}
}
public void ReStartTcpSocket(ConnectDelegate1 _connectback)
{
Log.Debug("打开一个tcp连接StartTcpSocket");
if (client == null)
{
client = new SocketLayer();
}
else
{
Close(false);
}
connectBack = null;
connectBack1 = _connectback;
client.SetConnectCallback(ConnectBack);
proto = new CProto();
recvBuf = new byte[BUFFER_SIZE * 64];
recvLen = 0;
pingByte = new byte[] { (byte)CProto.PType.ping };
client.Connect(_host, _port);
}
public void Connect(ConnectDelegate connectCallback)
{
if (isWorking)
{
throw new NetIsWorking();
}
if (isConnecting)
{
throw new NetIsConnecting();
}
try {
asyncConnectResult = tcpClinet.BeginConnect(hostname, port, null, null);
} catch (Exception exception) {
asyncConnectResult = null;
connectCallback(new NetError(exception));
}
this.connectCallback = connectCallback;
}
private void Server_Begin(Socket s)
{
while (true)
{
try
{
while (s != null)
{
Socket ns = s.Accept();
Console.WriteLine(ns.RemoteEndPoint.ToString());
ConnectDelegate cd = new ConnectDelegate(Server_Connect);
cd.BeginInvoke(ns, null, null);
}
}
catch (SocketException ex)
{
Console.WriteLine(ex.Message);
}
}
}
public override bool Launch(ConnectDelegate connect)
{
string config = LauncherCommon.CreateConfigString(ProfilingMode, ListenPort, WaitForConnection, IncludeNative, SamplingInterval, CounterInterval, AllowMethodInlining, TrackGC, TrackAllocs);
var psi = new ProcessStartInfo(Executable, Arguments);
LauncherCommon.SetProcessOptions(psi, config, LauncherCommon.GetCounterString(PerformanceCounters));
psi.WorkingDirectory = string.IsNullOrEmpty(WorkingDir) ?
Path.GetDirectoryName(Executable) : WorkingDir;
try
{
Process.Start(psi);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Launch Error");
return(false);
}
return(true);
}
private void InitInstance()
{
_feederInstance = _nativeCreateCall();
if (_feederInstance == IntPtr.Zero)
{
throw new Exception($"[{_settings.Name}]: DsCreate failed.");
}
//var feedVersion = _nativeVersionCall();
var dst = IntPtr.Zero;
RtlMoveMemory(ref dst, _feederInstance, IntPtr.Size);
var cfeedInterfaceVtbl = Marshal.PtrToStructure <CFeedInterfaceVtbl>(dst);
_connectCall = Marshal.GetDelegateForFunctionPointer <ConnectDelegate>(cfeedInterfaceVtbl.Connect);
_closeCall = Marshal.GetDelegateForFunctionPointer <CloseDelegate>(cfeedInterfaceVtbl.Close);
_setSymbolsCall = Marshal.GetDelegateForFunctionPointer <SetSymbolsDelegate>
(cfeedInterfaceVtbl.SetSymbols);
_readCall = Marshal.GetDelegateForFunctionPointer <ReadDelegate>(cfeedInterfaceVtbl.Read);
}
static void ConnectAsync(SSBIServer srv, TreeView tv, TreeNode connNode)
{
Server serv = null;
try {
ConnectDelegate cd = new ConnectDelegate(smo.CreateServer2);
IAsyncResult iar = cd.BeginInvoke(srv, null, null);
while (!iar.IsCompleted)
{
//TVSetUp.SetStatusText(tv, toolStripStatusLabel1, string.Format("Connecting to: {0}", srv.Name));
Thread.Sleep(50);
}
serv = cd.EndInvoke(iar);
ConnectCompleted(srv, serv, tv, connNode, true, null);
}
catch (Exception e) {
ConnectCompleted(srv, serv, tv, connNode, false, e.Message);
}
}
private void Server_Begin(Socket s)
{
int i;
while (true)
{
try
{
Socket ns = s.Accept();
byte[] buffer = new byte[1024];
i = ns.Receive(buffer);
index = Encoding.Unicode.GetString(buffer, 0, i);
Console.WriteLine(ns.RemoteEndPoint.ToString());
ConnectDelegate cd = new ConnectDelegate(Server_Connect);
cd.BeginInvoke(ns, null, null);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
public void StartTcpSocket(string host, int port, SocketName name, ConnectDelegate _connectback)
{
Log.Debug("打开一个tcp连接StartTcpSocket");
_host = host;
_port = port;
if (client == null)
{
client = new SocketLayer();
}
else
{
Close(true);
}
socketName = name;
connectBack = _connectback;
connectBack1 = null;
client.SetConnectCallback(ConnectBack);
proto = new CProto();
recvBuf = new byte[BUFFER_SIZE * 64];
recvLen = 0;
pingByte = new byte[] { (byte)CProto.PType.ping };
client.Connect(host, port);
}
private void ConnectProgress_Shown(object sender, EventArgs e)
{
ConnectDelegate connector = new ConnectDelegate(Connect);
connector.BeginInvoke(ConnectFinished, null);
}
public extern static IntPtr ConnectSignals(IntPtr builder, ConnectDelegate onConnection);
public abstract bool Launch(ConnectDelegate connect);
public override bool Launch(ConnectDelegate connect)
{
string config = LauncherCommon.CreateConfigString(ProfilingMode, ListenPort, WaitForConnection, IncludeNative, SamplingInterval, CounterInterval, AllowMethodInlining, TrackGC, TrackAllocs);
var psi = new ProcessStartInfo(Executable, Arguments);
LauncherCommon.SetProcessOptions(psi, config, LauncherCommon.GetCounterString(PerformanceCounters));
psi.WorkingDirectory = string.IsNullOrEmpty(WorkingDir) ?
Path.GetDirectoryName(Executable) : WorkingDir;
try
{
Process.Start(psi);
}
catch(Exception ex)
{
MessageBox.Show(ex.Message, "Launch Error");
return false;
}
return true;
}
private void Connect_button_Click(object sender, RoutedEventArgs e)
{
ConnectDelegate cd = new ConnectDelegate(connect);
cd.BeginInvoke(this.Text_ip.Text, this.Text_port.Text, this.Text_user.Text, this.Box_pwd.Password, null, null);
}
public IAsyncResult BeginConnect(AsyncCallback cb, object state)
{
ConnectDelegate d = Connect;
return(d.BeginInvoke(cb, state));
}
private void ConnectProgress_Shown(object sender, EventArgs e)
{
ConnectDelegate connector = new ConnectDelegate(Connect);
connector.BeginInvoke(ConnectFinished, null);
}
public override bool Launch(ConnectDelegate connect)
{
StopService(ServiceName, StopCommand);
string config = LauncherCommon.CreateConfigString(ProfilingMode, ListenPort, WaitForConnection, IncludeNative, SamplingInterval, CounterInterval, AllowMethodInlining, TrackGC, TrackAllocs);
string[] profEnv = LauncherCommon.CreateProfilerEnvironment(config, LauncherCommon.GetCounterString(PerformanceCounters));
string serviceAccountSid = null;
string serviceAccountName = LauncherCommon.GetServiceAccountName(ServiceName);
if(serviceAccountName != null && serviceAccountName.StartsWith(@".\"))
serviceAccountName = Environment.MachineName + serviceAccountName.Substring(1);
if(serviceAccountName != null && serviceAccountName != "LocalSystem")
{
serviceAccountSid = LauncherCommon.GetAccountSid(serviceAccountName);
}
if(serviceAccountSid != null)
{
//set environment for target account
LauncherCommon.SetAccountEnvironment(serviceAccountSid, profEnv);
}
else
{
string[] baseEnv = LauncherCommon.GetServicesEnvironment();
baseEnv = LauncherCommon.ReplaceTempDir(baseEnv, Path.GetTempPath());
string[] combinedEnv = LauncherCommon.CombineEnvironments(baseEnv, profEnv);
LauncherCommon.SetEnvironmentVariables(ServiceName, combinedEnv);
}
bool returnVal = true;
StartService(ServiceName, StartCommand);
Thread.Sleep(1000);
using(var engine = new DummyDataEngine())
{
var client = connect("localhost", ListenPort, engine, 10);
if(client != null)
client.Dispose();
else
returnVal = false;
}
if(serviceAccountSid != null)
{
LauncherCommon.ResetAccountEnvironment(serviceAccountSid, profEnv);
}
else
{
LauncherCommon.DeleteEnvironmentVariables(ServiceName);
}
return returnVal;
}
private void ClearDelegate()
{
UILoginConnectResultDelegate = null;
}
public static void SetConcnectDelegate(ConnectDelegate delConnectFun)
{
m_delConnect = delConnectFun;
}
public abstract bool Launch(ConnectDelegate connect);
/// <summary>
///
/// </summary>
/// <param name="callBack"></param>
/// <returns></returns>
public Task<PlayerIndex?> Connect(ConnectDelegate onConnect)
{
return Task<PlayerIndex?>.Factory.StartNew(WaitForConnect)
.ContinueWith(
(r) =>
{
onConnect.Invoke(r.Result);
return r.Result;
}
);
}
static void ConnectAsync(SSBIServer srv, TreeView tv, TreeNode connNode)
{
Server serv = null;
try {
ConnectDelegate cd = new ConnectDelegate(smo.CreateServer2);
IAsyncResult iar = cd.BeginInvoke(srv, null, null);
while (!iar.IsCompleted) {
//TVSetUp.SetStatusText(tv, toolStripStatusLabel1, string.Format("Connecting to: {0}", srv.Name));
Thread.Sleep(50);
}
serv = cd.EndInvoke(iar);
ConnectCompleted(srv, serv, tv, connNode, true, null);
}
catch (Exception e) {
ConnectCompleted(srv, serv, tv, connNode, false, e.Message);
}
}
public void ProcessConnect(ConnectDelegate OnConnect)
{
if (!modbusMaster.connected) {
try {
TryConnect();
} catch (Exception e) {
Logger.Error("Ошибка при подключении " + e.Message);
if (OnError != null) {
OnError();
}
return;
}
}
if (modbusMaster.connected) {
if (OnConnect != null) {
OnConnect();
}
}
}
/// <summary>
/// 增加连接回调
/// </summary>
/// <param name="callback"></param>
public void SetConnectCallback(ConnectDelegate callback)
{
connectDelegate = callback;
}
/// <summary>
/// Makes <paramref name="source"/> connectable.
/// </summary>
/// <param name="source">The source sequence.</param>
/// <param name="connect">Set to a <see cref="ConnectDelegate"/> that, when invoked, connects to the <paramref name="source"/>.</param>
/// <remarks>
/// When <paramref name="connect"/> is called, all enumerators awaiting <see cref="IAsyncEnumerator{T}.MoveNextAsync"/> will observe the same sequence.
/// Late enumerators will experience a <see cref="AlreadyConnectedException"/>.
/// </remarks>
public static IAsyncEnumerable <T> Connectable <T>(this IAsyncEnumerable <T> source, out ConnectDelegate connect)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var connectable = new ConnectableEnumerable <T>(source);
connect = connectable.Connect;
return(connectable);
}
public override bool Launch(ConnectDelegate connect)
{
StopService(ServiceName, StopCommand);
string config = LauncherCommon.CreateConfigString(ProfilingMode, ListenPort, WaitForConnection, IncludeNative, SamplingInterval, CounterInterval, AllowMethodInlining, TrackGC, TrackAllocs);
string[] profEnv = LauncherCommon.CreateProfilerEnvironment(config, LauncherCommon.GetCounterString(PerformanceCounters));
string serviceAccountSid = null;
string serviceAccountName = LauncherCommon.GetServiceAccountName(ServiceName);
if (serviceAccountName != null && serviceAccountName.StartsWith(@".\"))
{
serviceAccountName = Environment.MachineName + serviceAccountName.Substring(1);
}
if (serviceAccountName != null && serviceAccountName != "LocalSystem")
{
serviceAccountSid = LauncherCommon.GetAccountSid(serviceAccountName);
}
if (serviceAccountSid != null)
{
//set environment for target account
LauncherCommon.SetAccountEnvironment(serviceAccountSid, profEnv);
}
else
{
string[] baseEnv = LauncherCommon.GetServicesEnvironment();
baseEnv = LauncherCommon.ReplaceTempDir(baseEnv, Path.GetTempPath());
string[] combinedEnv = LauncherCommon.CombineEnvironments(baseEnv, profEnv);
LauncherCommon.SetEnvironmentVariables(ServiceName, combinedEnv);
}
bool returnVal = true;
StartService(ServiceName, StartCommand);
Thread.Sleep(1000);
using (var engine = new DummyDataEngine())
{
var client = connect("localhost", ListenPort, engine, 10);
if (client != null)
{
client.Dispose();
}
else
{
returnVal = false;
}
}
if (serviceAccountSid != null)
{
LauncherCommon.ResetAccountEnvironment(serviceAccountSid, profEnv);
}
else
{
LauncherCommon.DeleteEnvironmentVariables(ServiceName);
}
return(returnVal);
}
