static IAsyncResult BeginGetRequestStreamWithTimeout (HttpWebRequest request, AsyncCallback callback, object state, out RegisteredWaitHandle handle)
{
IAsyncResult asyncResult = request.BeginGetRequestStream (callback, state);
handle = ThreadPool.RegisterWaitForSingleObject (
asyncResult.AsyncWaitHandle,
CancelRequest,
request,
1000,
true);
return asyncResult;
}
public BlockChecker()
{
this.InitializeFinish += this.BlockChecker_InitializeFinish;
this._registration = this.RegisterSendTimeout();
}
public static void QueueRegisterPositiveAndFlowTest()
{
var asyncLocal = new AsyncLocal <int>();
asyncLocal.Value = 1;
var obj = new object();
var registerWaitEvent = new AutoResetEvent(false);
var threadDone = new AutoResetEvent(false);
RegisteredWaitHandle registeredWaitHandle = null;
Exception backgroundEx = null;
int backgroundAsyncLocalValue = 0;
Action <bool, Action> commonBackgroundTest =
(isRegisteredWaitCallback, test) =>
{
try
{
if (isRegisteredWaitCallback)
{
RegisteredWaitHandle toUnregister = registeredWaitHandle;
registeredWaitHandle = null;
Assert.True(toUnregister.Unregister(threadDone));
}
test();
backgroundAsyncLocalValue = asyncLocal.Value;
}
catch (Exception ex)
{
backgroundEx = ex;
}
finally
{
if (!isRegisteredWaitCallback)
{
threadDone.Set();
}
}
};
Action <bool> waitForBackgroundWork =
isWaitForRegisteredWaitCallback =>
{
if (isWaitForRegisteredWaitCallback)
{
registerWaitEvent.Set();
}
threadDone.CheckedWait();
if (backgroundEx != null)
{
throw new AggregateException(backgroundEx);
}
};
ThreadPool.QueueUserWorkItem(
state =>
{
commonBackgroundTest(false, () =>
{
Assert.Same(obj, state);
});
},
obj);
waitForBackgroundWork(false);
Assert.Equal(1, backgroundAsyncLocalValue);
ThreadPool.UnsafeQueueUserWorkItem(
state =>
{
commonBackgroundTest(false, () =>
{
Assert.Same(obj, state);
});
},
obj);
waitForBackgroundWork(false);
Assert.Equal(0, backgroundAsyncLocalValue);
registeredWaitHandle =
ThreadPool.RegisterWaitForSingleObject(
registerWaitEvent,
(state, timedOut) =>
{
commonBackgroundTest(true, () =>
{
Assert.Same(obj, state);
Assert.False(timedOut);
});
},
obj,
UnexpectedTimeoutMilliseconds,
false);
waitForBackgroundWork(true);
Assert.Equal(1, backgroundAsyncLocalValue);
registeredWaitHandle =
ThreadPool.UnsafeRegisterWaitForSingleObject(
registerWaitEvent,
(state, timedOut) =>
{
commonBackgroundTest(true, () =>
{
Assert.Same(obj, state);
Assert.False(timedOut);
});
},
obj,
UnexpectedTimeoutMilliseconds,
false);
waitForBackgroundWork(true);
Assert.Equal(0, backgroundAsyncLocalValue);
}
internal static void WriteToSync <T>(this Stream stream, Stream toStream, long?copyLength, long?maxLength, bool calculateMd5, bool syncRead, ExecutionState <T> executionState, StreamDescriptor streamCopyState)
{
if (copyLength.HasValue && maxLength.HasValue)
{
throw new ArgumentException(SR.StreamLengthMismatch);
}
if (stream.CanSeek && maxLength.HasValue && stream.Length - stream.Position > maxLength)
{
throw new InvalidOperationException(SR.StreamLengthError);
}
if (stream.CanSeek && copyLength.HasValue && stream.Length - stream.Position < copyLength)
{
throw new ArgumentOutOfRangeException("copyLength", SR.StreamLengthShortError);
}
byte[] buffer = new byte[GetBufferSize(stream)];
if (streamCopyState != null && calculateMd5 && streamCopyState.Md5HashRef == null)
{
streamCopyState.Md5HashRef = new MD5Wrapper();
}
RegisteredWaitHandle waitHandle = null;
ManualResetEvent completedEvent = null;
if (!syncRead && executionState.OperationExpiryTime.HasValue)
{
completedEvent = new ManualResetEvent(false);
waitHandle = ThreadPool.RegisterWaitForSingleObject(
completedEvent,
StreamExtensions.MaximumCopyTimeCallback <T>,
executionState,
executionState.RemainingTimeout,
true);
}
try
{
long?bytesRemaining = copyLength;
int readCount;
do
{
if (executionState.OperationExpiryTime.HasValue && DateTime.Now.CompareTo(executionState.OperationExpiryTime.Value) > 0)
{
throw Exceptions.GenerateTimeoutException(executionState.Cmd != null ? executionState.Cmd.CurrentResult : null, null);
}
// Determine how many bytes to read this time so that no more than copyLength bytes are read
int bytesToRead = MinBytesToRead(bytesRemaining, buffer.Length);
if (bytesToRead == 0)
{
break;
}
// Read synchronously or asynchronously
readCount = syncRead
? stream.Read(buffer, 0, bytesToRead)
: stream.EndRead(stream.BeginRead(buffer, 0, bytesToRead, null /* Callback */, null /* State */));
// Decrement bytes to write from bytes read
if (bytesRemaining.HasValue)
{
bytesRemaining -= readCount;
}
// Write
if (readCount > 0)
{
toStream.Write(buffer, 0, readCount);
// Update the StreamDescriptor after the bytes are successfully committed to the output stream
if (streamCopyState != null)
{
streamCopyState.Length += readCount;
if (maxLength.HasValue && streamCopyState.Length > maxLength.Value)
{
throw new InvalidOperationException(SR.StreamLengthError);
}
if (streamCopyState.Md5HashRef != null)
{
streamCopyState.Md5HashRef.UpdateHash(buffer, 0, readCount);
}
}
}
}while (readCount != 0);
if (bytesRemaining.HasValue && bytesRemaining != 0)
{
throw new ArgumentOutOfRangeException("copyLength", SR.StreamLengthShortError);
}
}
catch (Exception)
{
if (executionState.OperationExpiryTime.HasValue && DateTime.Now.CompareTo(executionState.OperationExpiryTime.Value) > 0)
{
throw Exceptions.GenerateTimeoutException(executionState.Cmd != null ? executionState.Cmd.CurrentResult : null, null);
}
else
{
throw;
}
}
finally
{
if (waitHandle != null)
{
waitHandle.Unregister(null);
}
if (completedEvent != null)
{
completedEvent.Close();
}
}
if (streamCopyState != null && streamCopyState.Md5HashRef != null)
{
streamCopyState.Md5 = streamCopyState.Md5HashRef.ComputeHash();
streamCopyState.Md5HashRef = null;
}
}
public void Start(
Guid payloadGuid,
ArraySegment <byte> payloadData,
SafeFileHandle inheritableReportHandle,
string dllNameX64,
string dllNameX86)
{
using (m_syncSemaphore.AcquireSemaphore())
{
if (m_starting || m_disposed)
{
throw new InvalidOperationException("Cannot invoke start process more than once or after this instance has been Disposed.");
}
m_starting = true;
bool redirectStreams = m_errorDataReceived != null || m_outputDataReceived != null;
// The process creation flags:
// - We use CREATE_DEFAULT_ERROR_MODE to ensure that the hard error mode of the child process (i.e., GetErrorMode)
// is deterministic. Inheriting error mode is the default, but there may be some concurrent operation that temporarily
// changes it (process global). The CLR has been observed to do so.
// - We use CREATE_NO_WINDOW when redirecting stdout/err/in and there is a parent console (to prevent creating extra conhost.exe
// processes on Windows when running headless) or when console sharing is disabled (typical for BuildXL which takes over
// management of the console). Otherwise we use the parent console for output.
int creationFlags = Native.Processes.ProcessUtilities.CREATE_DEFAULT_ERROR_MODE;
if (redirectStreams && (s_consoleWindow != IntPtr.Zero || m_disableConHostSharing))
{
creationFlags |= Native.Processes.ProcessUtilities.CREATE_NO_WINDOW;
}
SafeFileHandle standardInputWritePipeHandle = null;
SafeFileHandle standardOutputReadPipeHandle = null;
SafeFileHandle standardErrorReadPipeHandle = null;
try
{
// set up the environment block parameter
var environmentHandle = default(GCHandle);
var payloadHandle = default(GCHandle);
SafeFileHandle hStdInput = null;
SafeFileHandle hStdOutput = null;
SafeFileHandle hStdError = null;
SafeThreadHandle threadHandle = null;
try
{
IntPtr environmentPtr = IntPtr.Zero;
if (m_unicodeEnvironmentBlock != null)
{
creationFlags |= Native.Processes.ProcessUtilities.CREATE_UNICODE_ENVIRONMENT;
environmentHandle = GCHandle.Alloc(m_unicodeEnvironmentBlock, GCHandleType.Pinned);
environmentPtr = environmentHandle.AddrOfPinnedObject();
}
if (redirectStreams)
{
Pipes.CreateInheritablePipe(
Pipes.PipeInheritance.InheritRead,
Pipes.PipeFlags.WriteSideAsync,
readHandle: out hStdInput,
writeHandle: out standardInputWritePipeHandle);
}
else
{
// Avoid stdin hooking when not needed.
hStdInput = new SafeFileHandle(new IntPtr(-1), true);
}
if (m_outputDataReceived != null)
{
Pipes.CreateInheritablePipe(
Pipes.PipeInheritance.InheritWrite,
Pipes.PipeFlags.ReadSideAsync,
readHandle: out standardOutputReadPipeHandle,
writeHandle: out hStdOutput);
}
else
{
// Pass through to the parent console.
hStdOutput = new SafeFileHandle(new IntPtr(-1), true);
}
if (m_errorDataReceived != null)
{
Pipes.CreateInheritablePipe(
Pipes.PipeInheritance.InheritWrite,
Pipes.PipeFlags.ReadSideAsync,
readHandle: out standardErrorReadPipeHandle,
writeHandle: out hStdError);
}
else
{
// Pass through to the parent console.
hStdError = new SafeFileHandle(new IntPtr(-1), true);
}
// We want a per-process job primarily. If nested job support is not available, then we make sure to not have a BuildXL-level job.
if (JobObject.OSSupportsNestedJobs && m_createJobObjectForCurrentProcess)
{
JobObject.SetTerminateOnCloseOnCurrentProcessJob();
}
// Initialize the injector
m_processInjector = new ProcessTreeContext(
payloadGuid,
inheritableReportHandle,
payloadData,
dllNameX64,
dllNameX86,
m_numRetriesPipeReadOnCancel,
m_debugPipeReporter,
m_loggingContext);
// If path remapping is enabled then we wrap the job object in a container, so the filter drivers get
// configured (and they get cleaned up when the container is disposed)
if (m_containerConfiguration.IsIsolationEnabled)
{
m_job = new Container(
name: null,
containerConfiguration: m_containerConfiguration,
loggingContext: m_loggingContext);
}
else
{
m_job = new JobObject(null);
}
// We want the effects of SEM_NOGPFAULTERRORBOX on all children (but can't set that with CreateProcess).
// That's not set otherwise (even if set in this process) due to CREATE_DEFAULT_ERROR_MODE above.
m_job.SetLimitInformation(terminateOnClose: true, failCriticalErrors: false, allowProcessesToBreakAway: m_setJobBreakawayOk);
m_processInjector.Listen();
if (m_containerConfiguration.IsIsolationEnabled)
{
// After calling SetLimitInformation, start up the container if present
// This will throw if the container is not set up properly
m_job.StartContainerIfPresent();
}
// The call to the CreateDetouredProcess below will add a newly created process to the job.
System.Diagnostics.Stopwatch m_startUpTimeWatch = System.Diagnostics.Stopwatch.StartNew();
var detouredProcessCreationStatus =
Native.Processes.ProcessUtilities.CreateDetouredProcess(
m_commandLine,
creationFlags,
environmentPtr,
m_workingDirectory,
hStdInput,
hStdOutput,
hStdError,
m_job,
m_processInjector.Injector,
m_containerConfiguration.IsIsolationEnabled,
out m_processHandle,
out threadHandle,
out m_processId,
out int errorCode);
m_startUpTimeWatch.Stop();
m_startUpTime = m_startUpTimeWatch.ElapsedMilliseconds;
if (detouredProcessCreationStatus != CreateDetouredProcessStatus.Succeeded)
{
// TODO: Indicating user vs. internal errors (and particular phase failures e.g. adding to job object or injecting detours)
// is good progress on the transparency into these failures. But consider making this indication visible beyond this
// function without throwing exceptions; consider returning a structured value or logging events.
string message;
if (detouredProcessCreationStatus.IsDetoursSpecific())
{
message = string.Format(
CultureInfo.InvariantCulture,
"Internal error during process creation: {0:G}",
detouredProcessCreationStatus);
}
else if (detouredProcessCreationStatus == CreateDetouredProcessStatus.ProcessCreationFailed)
{
message = "Process creation failed";
}
else
{
message = string.Format(
CultureInfo.InvariantCulture,
"Process creation failed: {0:G}",
detouredProcessCreationStatus);
}
throw new BuildXLException(
message,
new NativeWin32Exception(errorCode));
}
// TODO: We should establish good post-conditions for CreateDetouredProcess. As a temporary measure, it would be nice
// to determine if we are sometimes getting invalid process handles with retVal == true. So for now we differentiate
// that possible case with a unique error string.
if (m_processHandle.IsInvalid)
{
throw new BuildXLException("Unable to start or detour a process (process handle invalid)", new NativeWin32Exception(errorCode));
}
}
finally
{
if (environmentHandle.IsAllocated)
{
environmentHandle.Free();
}
if (payloadHandle.IsAllocated)
{
payloadHandle.Free();
}
if (hStdInput != null && !hStdInput.IsInvalid)
{
hStdInput.Dispose();
}
if (hStdOutput != null && !hStdOutput.IsInvalid)
{
hStdOutput.Dispose();
}
if (hStdError != null && !hStdError.IsInvalid)
{
hStdError.Dispose();
}
if (inheritableReportHandle != null && !inheritableReportHandle.IsInvalid)
{
inheritableReportHandle.Dispose();
}
if (threadHandle != null && !threadHandle.IsInvalid)
{
threadHandle.Dispose();
}
}
if (standardInputWritePipeHandle != null)
{
var standardInputStream = new FileStream(standardInputWritePipeHandle, FileAccess.Write, m_bufferSize, isAsync: true);
m_standardInputWriter = new StreamWriter(standardInputStream, m_standardInputEncoding, m_bufferSize)
{
AutoFlush = true
};
}
if (standardOutputReadPipeHandle != null)
{
var standardOutputFile = AsyncFileFactory.CreateAsyncFile(
standardOutputReadPipeHandle,
FileDesiredAccess.GenericRead,
ownsHandle: true,
kind: FileKind.Pipe);
m_outputReader = new AsyncPipeReader(standardOutputFile, m_outputDataReceived, m_standardOutputEncoding, m_bufferSize);
m_outputReader.BeginReadLine();
}
if (standardErrorReadPipeHandle != null)
{
var standardErrorFile = AsyncFileFactory.CreateAsyncFile(
standardErrorReadPipeHandle,
FileDesiredAccess.GenericRead,
ownsHandle: true,
kind: FileKind.Pipe);
m_errorReader = new AsyncPipeReader(standardErrorFile, m_errorDataReceived, m_standardErrorEncoding, m_bufferSize);
m_errorReader.BeginReadLine();
}
Contract.Assert(!m_processHandle.IsInvalid);
m_processWaitHandle = new SafeWaitHandleFromSafeHandle(m_processHandle);
m_waiting = true;
TimeSpan timeout = m_timeout ?? Timeout.InfiniteTimeSpan;
m_registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(
m_processWaitHandle,
CompletionCallbackAsync,
null,
timeout,
true);
m_started = true;
}
catch (Exception e)
{
if (e is AccessViolationException)
{
Logger.Log.DetouredProcessAccessViolationException(m_loggingContext, creationFlags + " - " + m_commandLine);
}
// Dispose pipe handles in case they are not assigned to streams.
if (m_standardInputWriter == null)
{
standardInputWritePipeHandle?.Dispose();
}
if (m_outputReader == null)
{
standardOutputReadPipeHandle?.Dispose();
}
if (m_errorReader == null)
{
standardErrorReadPipeHandle?.Dispose();
}
throw;
}
}
}
private static void StartHelper(NetworkAddressChangedEventHandler caller, bool captureContext, StartIPOptions startIPOptions)
{
lock (s_globalLock)
{
// Setup changedEvent and native overlapped struct.
if (s_ipv4Socket == null)
{
int blocking;
// Sockets will be initialized by the call to OSSupportsIP*.
if (Socket.OSSupportsIPv4)
{
blocking = -1;
s_ipv4Socket = SafeCloseSocketAndEvent.CreateWSASocketWithEvent(AddressFamily.InterNetwork, SocketType.Dgram, (ProtocolType)0, true, false);
Interop.Winsock.ioctlsocket(s_ipv4Socket, Interop.Winsock.IoctlSocketConstants.FIONBIO, ref blocking);
s_ipv4WaitHandle = s_ipv4Socket.GetEventHandle();
}
if (Socket.OSSupportsIPv6)
{
blocking = -1;
s_ipv6Socket = SafeCloseSocketAndEvent.CreateWSASocketWithEvent(AddressFamily.InterNetworkV6, SocketType.Dgram, (ProtocolType)0, true, false);
Interop.Winsock.ioctlsocket(s_ipv6Socket, Interop.Winsock.IoctlSocketConstants.FIONBIO, ref blocking);
s_ipv6WaitHandle = s_ipv6Socket.GetEventHandle();
}
}
if ((caller != null) && (!s_callerArray.ContainsKey(caller)))
{
s_callerArray.Add(caller, captureContext ? ExecutionContext.Capture() : null);
}
if (s_isListening || s_callerArray.Count == 0)
{
return;
}
if (!s_isPending)
{
int length;
SocketError errorCode;
if (Socket.OSSupportsIPv4 && (startIPOptions & StartIPOptions.StartIPv4) != 0)
{
s_registeredWait = ThreadPool.RegisterWaitForSingleObject(
s_ipv4WaitHandle,
new WaitOrTimerCallback(AddressChangedCallback),
StartIPOptions.StartIPv4,
-1,
true);
errorCode = Interop.Winsock.WSAIoctl_Blocking(
s_ipv4Socket.DangerousGetHandle(),
(int)IOControlCode.AddressListChange,
null, 0, null, 0,
out length,
IntPtr.Zero, IntPtr.Zero);
if (errorCode != SocketError.Success)
{
NetworkInformationException exception = new NetworkInformationException();
if (exception.ErrorCode != (uint)SocketError.WouldBlock)
{
throw exception;
}
}
SafeWaitHandle s_ipv4SocketGetEventHandleSafeWaitHandle =
s_ipv4Socket.GetEventHandle().GetSafeWaitHandle();
errorCode = Interop.Winsock.WSAEventSelect(
s_ipv4Socket,
s_ipv4SocketGetEventHandleSafeWaitHandle,
Interop.Winsock.AsyncEventBits.FdAddressListChange);
if (errorCode != SocketError.Success)
{
throw new NetworkInformationException();
}
}
if (Socket.OSSupportsIPv6 && (startIPOptions & StartIPOptions.StartIPv6) != 0)
{
s_registeredWait = ThreadPool.RegisterWaitForSingleObject(
s_ipv6WaitHandle,
new WaitOrTimerCallback(AddressChangedCallback),
StartIPOptions.StartIPv6,
-1,
true);
errorCode = Interop.Winsock.WSAIoctl_Blocking(
s_ipv6Socket.DangerousGetHandle(),
(int)IOControlCode.AddressListChange,
null, 0, null, 0,
out length,
IntPtr.Zero, IntPtr.Zero);
if (errorCode != SocketError.Success)
{
NetworkInformationException exception = new NetworkInformationException();
if (exception.ErrorCode != (uint)SocketError.WouldBlock)
{
throw exception;
}
}
SafeWaitHandle s_ipv6SocketGetEventHandleSafeWaitHandle =
s_ipv6Socket.GetEventHandle().GetSafeWaitHandle();
errorCode = Interop.Winsock.WSAEventSelect(
s_ipv6Socket,
s_ipv6SocketGetEventHandleSafeWaitHandle,
Interop.Winsock.AsyncEventBits.FdAddressListChange);
if (errorCode != SocketError.Success)
{
throw new NetworkInformationException();
}
}
}
s_isListening = true;
s_isPending = true;
}
}
/// <summary>
/// Report session context to WSMan..this will let WSMan send ACK to
/// client and client can send data.
/// </summary>
internal void ReportContext()
{
int result = 0;
bool isRegisterWaitForSingleObjectFailed = false;
lock (_syncObject)
{
if (isClosed)
{
return;
}
if (!isContextReported)
{
isContextReported = true;
PSEtwLog.LogAnalyticInformational(PSEventId.ReportContext,
PSOpcode.Connect, PSTask.None,
PSKeyword.ManagedPlugin | PSKeyword.UseAlwaysAnalytic,
creationRequestDetails.ToString(), creationRequestDetails.ToString());
// TO BE FIXED - As soon as this API is called, WinRM service will send CommandResponse back and Signal is expected anytime
// If Signal comes and executes before registering the notification handle, cleanup will be messed
result = WSManNativeApi.WSManPluginReportContext(creationRequestDetails.unmanagedHandle, 0, creationRequestDetails.unmanagedHandle);
if (Platform.IsWindows && (WSManPluginConstants.ExitCodeSuccess == result))
{
registeredShutdownNotification = 1;
// Wrap the provided handle so it can be passed to the registration function
SafeWaitHandle safeWaitHandle = new SafeWaitHandle(creationRequestDetails.shutdownNotificationHandle, false); // Owned by WinRM
EventWaitHandle eventWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
eventWaitHandle.SafeWaitHandle = safeWaitHandle;
// Register shutdown notification handle
this.registeredShutDownWaitHandle = ThreadPool.RegisterWaitForSingleObject(
eventWaitHandle,
new WaitOrTimerCallback(WSManPluginManagedEntryWrapper.PSPluginOperationShutdownCallback),
shutDownContext,
-1, // INFINITE
true); // TODO: Do I need to worry not being able to set missing WT_TRANSFER_IMPERSONATION?
if (this.registeredShutDownWaitHandle == null)
{
isRegisterWaitForSingleObjectFailed = true;
registeredShutdownNotification = 0;
}
}
}
}
if ((WSManPluginConstants.ExitCodeSuccess != result) || (isRegisterWaitForSingleObjectFailed))
{
string errorMessage;
if (isRegisterWaitForSingleObjectFailed)
{
errorMessage = StringUtil.Format(RemotingErrorIdStrings.WSManPluginShutdownRegistrationFailed);
}
else
{
errorMessage = StringUtil.Format(RemotingErrorIdStrings.WSManPluginReportContextFailed);
}
// Report error and close the session
Exception mgdException = new InvalidOperationException(errorMessage);
Close(mgdException);
}
}
internal void PrinterNotifyWaitCallback(object state, bool timedOut)
{
if (_printerHandle == IntPtr.Zero)
{
return;
}
_notifyOptions.Count = 1;
int pdwChange = 0;
var pNotifyInfo = IntPtr.Zero;
bool bResult = FindNextPrinterChangeNotification(_changeHandle, out pdwChange, _notifyOptions,
ref pNotifyInfo);
if (bResult == false || pNotifyInfo == IntPtr.Zero)
{
return;
}
bool bJobRelatedChange = (pdwChange & PRINTER_CHANGES.PRINTER_CHANGE_ADD_JOB) ==
PRINTER_CHANGES.PRINTER_CHANGE_ADD_JOB ||
(pdwChange & PRINTER_CHANGES.PRINTER_CHANGE_SET_JOB) ==
PRINTER_CHANGES.PRINTER_CHANGE_SET_JOB ||
(pdwChange & PRINTER_CHANGES.PRINTER_CHANGE_DELETE_JOB) ==
PRINTER_CHANGES.PRINTER_CHANGE_DELETE_JOB ||
(pdwChange & PRINTER_CHANGES.PRINTER_CHANGE_WRITE_JOB) ==
PRINTER_CHANGES.PRINTER_CHANGE_WRITE_JOB;
if (!bJobRelatedChange)
{
return;
}
var info = (PRINTER_NOTIFY_INFO)Marshal.PtrToStructure(pNotifyInfo, typeof(PRINTER_NOTIFY_INFO));
long pData = (long)pNotifyInfo + (long)Marshal.OffsetOf(typeof(PRINTER_NOTIFY_INFO), "aData");
var data = new PRINTER_NOTIFY_INFO_DATA[info.Count];
for (uint i = 0; i < info.Count; i++)
{
data[i] =
(PRINTER_NOTIFY_INFO_DATA)Marshal.PtrToStructure((IntPtr)pData, typeof(PRINTER_NOTIFY_INFO_DATA));
pData += Marshal.SizeOf(typeof(PRINTER_NOTIFY_INFO_DATA));
}
for (int i = 0; i < data.Count(); i++)
{
if (data[i].Field == (ushort)PRINTERJOBNOTIFICATIONTYPES.JOB_NOTIFY_FIELD_STATUS &&
data[i].Type == (ushort)PRINTERNOTIFICATIONTYPES.JOB_NOTIFY_TYPE
)
{
var jStatus = (JOBSTATUS)Enum.Parse(typeof(JOBSTATUS), data[i].NotifyData.Data.cbBuf.ToString());
int intJobId = (int)data[i].Id;
string strJobName;
PrintSystemJobInfo pji = null;
try
{
_spooler = new PrintQueue(new PrintServer(), SpoolerName);
pji = _spooler.GetJob(intJobId);
if (!_objJobDict.ContainsKey(intJobId))
{
_objJobDict[intJobId] = pji.Name;
}
strJobName = pji.Name;
}
catch
{
//Trace.WriteLine(ex.Message);
pji = null;
_objJobDict.TryGetValue(intJobId, out strJobName);
if (strJobName == null)
{
strJobName = string.Empty;
}
}
if (OnJobStatusChange != null)
{
//Let us raise the event
OnJobStatusChange(this, new PrintJobChangeEventArgs(intJobId, strJobName, jStatus, pji));
}
}
}
_mrEvent.Reset();
_waitHandle =
ThreadPool.RegisterWaitForSingleObject(_mrEvent, PrinterNotifyWaitCallback, _mrEvent, -1, true);
}
// Any exceptions that escape synchronously will be caught by the caller and wrapped in a PingException.
// We do not need to or want to capture such exceptions into the returned task.
private Task <PingReply> SendPingAsyncCore(IPAddress address, byte[] buffer, int timeout, PingOptions options)
{
var tcs = new TaskCompletionSource <PingReply>();
_taskCompletionSource = tcs;
_ipv6 = (address.AddressFamily == AddressFamily.InterNetworkV6);
_sendSize = buffer.Length;
// Get and cache correct handle.
if (!_ipv6 && _handlePingV4 == null)
{
_handlePingV4 = Interop.IpHlpApi.IcmpCreateFile();
if (_handlePingV4.IsInvalid)
{
_handlePingV4 = null;
throw new Win32Exception(); // Gets last error.
}
}
else if (_ipv6 && _handlePingV6 == null)
{
_handlePingV6 = Interop.IpHlpApi.Icmp6CreateFile();
if (_handlePingV6.IsInvalid)
{
_handlePingV6 = null;
throw new Win32Exception(); // Gets last error.
}
}
var ipOptions = new Interop.IpHlpApi.IPOptions(options);
if (_replyBuffer == null)
{
_replyBuffer = SafeLocalAllocHandle.LocalAlloc(MaxUdpPacket);
}
// Queue the event.
int error;
try
{
if (_pingEvent == null)
{
_pingEvent = new ManualResetEvent(false);
}
else
{
_pingEvent.Reset();
}
_registeredWait = ThreadPool.RegisterWaitForSingleObject(_pingEvent, (state, _) => ((Ping)state).PingCallback(), this, -1, true);
SetUnmanagedStructures(buffer);
if (!_ipv6)
{
SafeWaitHandle pingEventSafeWaitHandle = _pingEvent.GetSafeWaitHandle();
error = (int)Interop.IpHlpApi.IcmpSendEcho2(
_handlePingV4,
pingEventSafeWaitHandle,
IntPtr.Zero,
IntPtr.Zero,
#pragma warning disable CS0618 // Address is marked obsolete
(uint)address.Address,
#pragma warning restore CS0618
_requestBuffer,
(ushort)buffer.Length,
ref ipOptions,
_replyBuffer,
MaxUdpPacket,
(uint)timeout);
}
else
{
IPEndPoint ep = new IPEndPoint(address, 0);
Internals.SocketAddress remoteAddr = IPEndPointExtensions.Serialize(ep);
byte[] sourceAddr = new byte[28];
SafeWaitHandle pingEventSafeWaitHandle = _pingEvent.GetSafeWaitHandle();
error = (int)Interop.IpHlpApi.Icmp6SendEcho2(
_handlePingV6,
pingEventSafeWaitHandle,
IntPtr.Zero,
IntPtr.Zero,
sourceAddr,
remoteAddr.Buffer,
_requestBuffer,
(ushort)buffer.Length,
ref ipOptions,
_replyBuffer,
MaxUdpPacket,
(uint)timeout);
}
}
catch
{
UnregisterWaitHandle();
throw;
}
if (error == 0)
{
error = Marshal.GetLastWin32Error();
// Only skip Async IO Pending error value.
if (error != Interop.IpHlpApi.ERROR_IO_PENDING)
{
// Cleanup.
FreeUnmanagedStructures();
UnregisterWaitHandle();
throw new Win32Exception(error);
}
}
return(tcs.Task);
}
public TimeoutKillswitch(RegisteredWaitHandle regWait, WaitHandle wait)
{
RegisteredWaitHandle = regWait;
WaitHandle = wait;
}
private void AddObjectChangedEvent(EventHandler <ObjectChangedEventArgs> callback)
{
//
// Register a wait handle if one has not been registered already
//
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "AddObjectChanged() called.");
lock (LockObjChangedEvent){
if (m_objectChanged == null)
{
if (m_id.Equals(Guid.Empty))
{
throw (new PeerToPeerException(SR.GetString(SR.Collab_EmptyGuidError)));
}
m_objChangedEvent = new AutoResetEvent(false);
//
// Register callback with a wait handle
//
m_regObjChangedWaitHandle = ThreadPool.RegisterWaitForSingleObject(m_objChangedEvent, //Event that triggers the callback
new WaitOrTimerCallback(ObjectChangedCallback), //callback to be called
null, //state to be passed
-1, //Timeout - aplicable only for timers
false //call us everytime the event is set
);
PEER_COLLAB_EVENT_REGISTRATION pcer = new PEER_COLLAB_EVENT_REGISTRATION();
pcer.eventType = PeerCollabEventType.EndPointObjectChanged;
GUID guid = CollaborationHelperFunctions.ConvertGuidToGUID(m_id);
GCHandle guidHandle = GCHandle.Alloc(guid, GCHandleType.Pinned);
//
// Register event with collab
//
pcer.pInstance = guidHandle.AddrOfPinnedObject();
try{
int errorCode = UnsafeCollabNativeMethods.PeerCollabRegisterEvent(
m_objChangedEvent.SafeWaitHandle,
1,
ref pcer,
out m_safeObjChangedEvent);
if (errorCode != 0)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "PeerCollabRegisterEvent returned with errorcode {0}", errorCode);
throw PeerToPeerException.CreateFromHr(SR.GetString(SR.Collab_ObjectChangedRegFailed), errorCode);
}
}
finally{
if (guidHandle.IsAllocated)
{
guidHandle.Free();
}
}
}
m_objectChanged += callback;
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Information, 0, "AddObjectChanged() successful.");
}
private void button1_Click(object sender, EventArgs e)
{
var filePath = "";
if (!File.Exists(txtFileName.Text))
{
MessageBox.Show("文件不存在。");
return;
}
else if (textBox2.Text == "")
{
MessageBox.Show("城市不能为空。");
return;
}
else
{
filePath = openFileDialog1.FileName;//txtFileName.Text;
//读取excel
IWorkbook ssfworkbook;
using (FileStream file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
var fileExtension = Path.GetExtension(filePath);
if (fileExtension == ".xls")
{
ssfworkbook = new HSSFWorkbook(file);
StringHelp.filePathOut = filePath.Substring(0, filePath.Length - 4) + "_baidu手机批量检索结果_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".xls";
StringHelp.pathError = filePath.Substring(0, filePath.Length - 5) + "_baidu手机批量执行日志_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".txt";
}
else if (fileExtension == ".xlsx")
{
ssfworkbook = new XSSFWorkbook(file);
StringHelp.filePathOut = filePath.Substring(0, filePath.Length - 5) + "_baidu手机批量检索结果_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".xls";
StringHelp.pathError = filePath.Substring(0, filePath.Length - 5) + "_baidu手机批量执行日志_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".txt";
}
else
{
MessageBox.Show("文件类型不支持");
return;
}
}
StringHelp.CreateExcel();
//for (int i = 0; i < ssfworkbook.NumberOfSheets; i++)//遍历薄
//{
var sheet = ssfworkbook.GetSheetAt(0);
dt = DateTime.Now;
int daoNum = sheet.LastRowNum + 1;
label3.Text = "导入" + daoNum + "个号码。";
label4.Text = dt + "正在采集……";
ThreadPool.SetMaxThreads(4, 4); //设置最大线程数
List <Thread> arr = new List <Thread>();
for (int j = 0; j < daoNum; j++) //LastRowNum 获取的是最后一行的编号（编号从0开始）。getPhysicalNumberOfRows()获取的是物理行数，也就是不包括那些空行（隔行）的情况。
{
var row = sheet.GetRow(j); //读取当前行数据
if (row.GetCell(0).ToString() != "")
{
ThreadPool.QueueUserWorkItem(new WaitCallback(mainWhile), row.GetCell(0).ToString());
}
}
//}
}
rhw = ThreadPool.RegisterWaitForSingleObject(new System.Threading.AutoResetEvent(false), CheckThreadPool, null, 10000, false);
}
/// <summary>
/// Creates a task that will complete after a time delay.
/// </summary>
/// <remarks>
/// <para>If the cancellation token is signaled before the specified time delay, then the task
/// is completed in <see cref="TaskStatus.Canceled"/> state. Otherwise, the task is
/// completed in <see cref="TaskStatus.RanToCompletion"/> state once the specified time
/// delay has expired.</para>
/// <para>This method ignores any fractional milliseconds when evaluating <paramref name="delay"/>.</para>
/// </remarks>
/// <param name="delay">The time span to wait before completing the returned task</param>
/// <param name="cancellationToken">The cancellation token that will be checked prior to completing the returned task</param>
/// <returns>A task that represents the time delay</returns>
/// <exception cref="ArgumentOutOfRangeException">If <paramref name="delay"/> represents a negative time interval.</exception>
/// <exception cref="TaskCanceledException">If the task has been canceled.</exception>
/// <exception cref="ObjectDisposedException">If the provided <paramref name="cancellationToken"/> has already been disposed.</exception>
public static Task Delay(TimeSpan delay, CancellationToken cancellationToken)
{
#if NET45PLUS
return(Task.Delay(delay, cancellationToken));
#else
long totalMilliseconds = (long)delay.TotalMilliseconds;
if (totalMilliseconds < 0)
{
throw new ArgumentOutOfRangeException("delay");
}
if (cancellationToken.IsCancellationRequested)
{
return(CompletedTask.Canceled());
}
if (totalMilliseconds == 0)
{
return(CompletedTask.Default);
}
TaskCompletionSource <VoidResult> result = new TaskCompletionSource <VoidResult>();
#if !PORTABLE
TaskCompletionSource <VoidResult> intermediateResult = new TaskCompletionSource <VoidResult>();
RegisteredWaitHandle timerRegisteredWaitHandle = null;
RegisteredWaitHandle cancellationRegisteredWaitHandle = null;
WaitOrTimerCallback timedOutCallback =
(object state, bool timedOut) =>
{
if (timedOut)
{
intermediateResult.TrySetResult(default(VoidResult));
}
};
IAsyncResult asyncResult = intermediateResult.Task;
timerRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, timedOutCallback, null, delay, true);
if (cancellationToken.CanBeCanceled)
{
WaitOrTimerCallback cancelledCallback =
(object state, bool timedOut) =>
{
if (cancellationToken.IsCancellationRequested)
{
intermediateResult.TrySetCanceled();
}
};
cancellationRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(cancellationToken.WaitHandle, cancelledCallback, null, Timeout.Infinite, true);
}
intermediateResult.Task
.ContinueWith(
_ =>
{
if (cancellationRegisteredWaitHandle != null)
{
cancellationRegisteredWaitHandle.Unregister(null);
}
if (timerRegisteredWaitHandle != null)
{
timerRegisteredWaitHandle.Unregister(null);
}
}, TaskContinuationOptions.ExecuteSynchronously)
.ContinueWith(
cleanupTask =>
{
switch (cleanupTask.Status)
{
case TaskStatus.RanToCompletion:
result.SetFromTask(intermediateResult.Task);
break;
case TaskStatus.Canceled:
result.SetCanceled();
break;
case TaskStatus.Faulted:
result.SetException(cleanupTask.Exception.InnerExceptions);
break;
default:
throw new InvalidOperationException("Unreachable");
}
});
#else
// Since portable-net40 doesn't provide Task.Delay and also doesn't provide ThreadPool.RegisterWaitForSingleObject,
// we need to implement this functionality using timers stored in a ConditionalWeakTable, which are associated with
// the actual Task instance that gets returned by this method.
CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);
Timer timer = null;
TimerCallback timerCallback =
state =>
{
result.TrySetResult(default(VoidResult));
timer.Dispose();
cancellationTokenRegistration.Dispose();
};
timer = new Timer(timerCallback, null, Timeout.Infinite, Timeout.Infinite);
_delayTimers.Add(result.Task, timer);
timer.Change(delay, TimeSpan.FromMilliseconds(-1));
if (cancellationToken.CanBeCanceled)
{
Action cancellationCallback =
() =>
{
result.TrySetCanceled();
if (timer != null)
{
timer.Dispose();
}
cancellationTokenRegistration.Dispose();
};
cancellationTokenRegistration = cancellationToken.Register(cancellationCallback);
}
#endif
return(result.Task);
#endif
}
private void HandleTimer(Object State, bool TimedOut)
{
// SWC 20130122 Fix ObjectDisposedException
if (mre == null)
{
System.Reflection.MethodBase method =
System.Reflection.MethodInfo.GetCurrentMethod();
OpenSource.Utilities.EventLogger.Log(
this,
System.Diagnostics.EventLogEntryType.Error,
String.Format(
"{0}.{1}() EH called on disposed object",
method.DeclaringType.Name,
method.Name));
return;
}
if (TimedOut == false)
{
return;
}
lock (RegLock)
{
// SWC 20130122 Fix ObjectDisposedException
if (mre == null) // Object disposed
{
System.Reflection.MethodBase method =
System.Reflection.MethodInfo.GetCurrentMethod();
OpenSource.Utilities.EventLogger.Log(
this,
System.Diagnostics.EventLogEntryType.Error,
String.Format(
"{0}.{1}() msg01 Object disposed while executing",
method.DeclaringType.Name,
method.Name));
return;
}
if (handle != null)
{
handle.Unregister(null);
handle = null;
}
WaitFlag = true;
StartFlag = false;
// SWC 20130227 Fix high cpu problem
// SWC Move assignment closer to actual usage
//timeout = Interval;
}
this.ElapsedWeakEvent.Fire();
// SWC 20130122 Lock down the entire code block
lock (RegLock)
{
// SWC 20130122 Fix ObjectDisposedException
if (mre == null) // Object disposed
{
System.Reflection.MethodBase method =
System.Reflection.MethodInfo.GetCurrentMethod();
OpenSource.Utilities.EventLogger.Log(
this,
System.Diagnostics.EventLogEntryType.Error,
String.Format(
"{0}.{1}() msg02 Object disposed while executing",
method.DeclaringType.Name,
method.Name));
return;
}
if (AutoReset == true)
{
mre.Reset();
// SWC 20130227 Fix high cpu problem
// SWC Validate Interval setting, assign to timeout for use in callback timer
//handle = ThreadPool.RegisterWaitForSingleObject(mre, WOTcb, null, Interval, true);
timeout = Math.Max(MINIMUM_INTERVAL, Interval);
handle = ThreadPool.RegisterWaitForSingleObject(mre, WOTcb, null, timeout, true);
}
else
{
if (WaitFlag == true && StartFlag == true)
{
// SWC 20130227 Fix high cpu problem
// SWC Move assignment closer to actual usage
//Interval = timeout;
mre.Reset();
if (handle != null)
{
handle.Unregister(null);
}
// SWC 20130227 Fix high cpu problem
// SWC Conditionally assign validated Interval setting to timeout for use in callback timer
//handle = ThreadPool.RegisterWaitForSingleObject(mre, WOTcb, null, Interval, true);
handle = ThreadPool.RegisterWaitForSingleObject(mre, WOTcb, null, timeout, true);
// SWC Reset timeout to max value for use in next execution
timeout = Int32.MaxValue;
}
WaitFlag = false;
StartFlag = false;
}
}
}
private void RegisterTimeOut(WaitHandle handle)
{
m_waihandle = handle;
m_registerwaithandle =
ThreadPool.RegisterWaitForSingleObject(handle, TimeOutCallback, m_httpwebrequest, TIMEOUT_TIME, true);
}
public void SendRequest(JsonRpcRequest rpcRequest, int timeout, Action <JsonRpcResponse> callback)
{
// Console.WriteLine("发送请求11111111111111"+DateTime.Now.ToShortDateString());
TracingManager.Info(
delegate()
{
string module = null;
string action = null;
if (rpcRequest.Header != null)
{
module = rpcRequest.Header["UU-REQUEST-MODULE"] == null ? "" : rpcRequest.Header["UU-REQUEST-MODULE"];
action = rpcRequest.Header["UU-REQUEST-ACTION"] == null ? "" : rpcRequest.Header["UU-REQUEST-ACTION"];
}
_tracing.Info(string.Format("jsonrpc request:uri={0} module={1} action={2}\r\nrequestbody:{3}",
rpcRequest.ServiceUri, module, action, rpcRequest.ReqBody));
}
);
_sericeUri = rpcRequest.ServiceUri;
_callback = callback;
_webRequest = HttpWebRequest.Create(new Uri(_sericeUri));
_webRequest.Method = "POST";
_webRequest.Proxy = null;
_webRequest.ContentType = "application/json";
_webRequest.Headers.Add(HttpRequestHeader.From, rpcRequest.FromComputer);
_webRequest.Headers.Add(HttpRequestHeader.Pragma, rpcRequest.FromService);
if (rpcRequest.Header != null && rpcRequest.Header.Count > 0)
{
foreach (string key in rpcRequest.Header.AllKeys)
{
_webRequest.Headers.Add(key, rpcRequest.Header[key]);
}
}
byte[] buffer = null;
if (rpcRequest.ReqBody == null)
{
_webRequest.ContentLength = 0;
}
else
{
buffer = Encoding.UTF8.GetBytes(rpcRequest.ReqBody);//Request.BodyBuffer.GetByteArray();
_webRequest.ContentLength = buffer.Length;
}
timeout = timeout > 0 ? timeout : _timeOut;
if (timeout > 0)
{
_waitHandle = new ManualResetEvent(false);
_registeredHandle = ThreadPool.RegisterWaitForSingleObject(_waitHandle, new WaitOrTimerCallback(TimeoutCallback), this, timeout, true);
}
if (_webRequest.ContentLength == 0)
{
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
}
else
{
_webRequest.BeginGetRequestStream(
delegate(IAsyncResult asyncResult)
{
JsonRpcHttpClientTransaction trans = (JsonRpcHttpClientTransaction)asyncResult.AsyncState;
try
{
WebRequest webReq = trans._webRequest;
Stream stream = webReq.EndGetRequestStream(asyncResult);
stream.Write(buffer, 0, buffer.Length);
stream.Close();
webReq.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
}
catch (Exception ex)
{
var rpcResonse = new JsonRpcResponse(JsonRpcErrorCode.SendFailed, null, new JsonRpcException(_sericeUri, "send failed", ex), 0);
trans.OnCallback(rpcResonse);
}
},
this
);
}
}
/// <summary>
/// Returns a response to an Internet request as an asynchronous operation.
/// </summary>
/// <remarks>
/// This operation will not block. The returned <see cref="Task{TResult}"/> object will
/// complete after a response to an Internet request is available.
/// </remarks>
/// <param name="request">The request.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that will be assigned to the new <see cref="Task"/>.</param>
/// <returns>A <see cref="Task"/> object which represents the asynchronous operation.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="request"/> is <see langword="null"/>.</exception>
/// <exception cref="WebException">
/// If <see cref="WebRequest.Abort"/> was previously called.
/// <para>-or-</para>
/// <para>If the timeout period for the request expired.</para>
/// <para>-or-</para>
/// <para>If an error occurred while processing the request.</para>
/// </exception>
public static Task <WebResponse> GetResponseAsync(this WebRequest request, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
bool timeout = false;
TaskCompletionSource <WebResponse> completionSource = new TaskCompletionSource <WebResponse>();
RegisteredWaitHandle timerRegisteredWaitHandle = null;
RegisteredWaitHandle cancellationRegisteredWaitHandle = null;
AsyncCallback completedCallback =
result =>
{
try
{
if (cancellationRegisteredWaitHandle != null)
{
cancellationRegisteredWaitHandle.Unregister(null);
}
if (timerRegisteredWaitHandle != null)
{
timerRegisteredWaitHandle.Unregister(null);
}
completionSource.TrySetResult(request.EndGetResponse(result));
}
catch (WebException ex)
{
if (timeout)
{
completionSource.TrySetException(new WebException("No response was received during the time-out period for a request.", WebExceptionStatus.Timeout));
}
else if (cancellationToken.IsCancellationRequested)
{
completionSource.TrySetCanceled();
}
else
{
completionSource.TrySetException(ex);
}
}
catch (Exception ex)
{
completionSource.TrySetException(ex);
}
};
IAsyncResult asyncResult = request.BeginGetResponse(completedCallback, null);
if (!asyncResult.IsCompleted)
{
if (request.Timeout != Timeout.Infinite)
{
WaitOrTimerCallback timedOutCallback =
(object state, bool timedOut) =>
{
if (timedOut)
{
timeout = true;
request.Abort();
}
};
timerRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, timedOutCallback, null, request.Timeout, true);
}
if (cancellationToken.CanBeCanceled)
{
WaitOrTimerCallback cancelledCallback =
(object state, bool timedOut) =>
{
if (cancellationToken.IsCancellationRequested)
{
request.Abort();
}
};
cancellationRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(cancellationToken.WaitHandle, cancelledCallback, null, Timeout.Infinite, true);
}
}
return(completionSource.Task);
}
/// <summary>
/// Lancement de l'action
/// </summary>
public GenericTesterResult Start()
{
GenericTesterResult result = new GenericTesterResult();
//initialisation
autoWaitHandle = new AutoResetEvent(false);
_waitLock = new ManualResetEvent(false);
try
{
Trace.WriteInfo("Start Action");
//Enregitrements des instances de fonction de la classe aux événement Econf
Register();
Console.WriteLine("TimeOut: " + timeOut);
//Chargement du timer
timerHandle = ThreadPool.RegisterWaitForSingleObject(autoWaitHandle, new WaitOrTimerCallback(WaitProc), null, timeOut, true);
//Lancement de l'action
Action();
Trace.WriteInfo("Attente de résultat");
_waitLock.WaitOne();
//Si le Timer s'est déclenché
if (status == TestStatus.TimeOut)
{
listMsg.Add("Timer déclenché");
status = TestStatus.TimeOut;
Trace.WriteInfo("TIMEOUT :" + status);
result = new GenericTesterResult(status, listMsg);
}
else if (status == TestStatus.Failed || status == TestStatus.Unknown)
{
Trace.WriteInfo("ECHEC :" + status);
result = new GenericTesterResult(status, listMsg);
}
else
{
if (datas != null)
{
Trace.WriteInfo("SUCCES : " + status);
result = new GenericTesterResult(status, listMsg, datas);
}
else
{
result = new GenericTesterResult(status, listMsg);
}
}
}
catch (Exception e)
{
status = TestStatus.Failed;
listMsg.Add("Erreur innatendue");
Trace.WriteError(e.ToString());
result = new GenericTesterResult(status, listMsg);
}
finally
{
Trace.WriteInfo("Fin de l'action");
//Désenregitrements des instances de fonction de la classe aux événement Econf
Unregister();
//On désarme le Timer
timerHandle.Unregister(null);
}
return(result);
}
protected override void InternalStart_FromWorkerThread(int delay)
{
m_waitObject.Reset();
m_registeredHandle = ThreadPool.RegisterWaitForSingleObject(m_waitObject, BeginRunOnTimer, null, delay, executeOnlyOnce: true);
}
public static Task <bool> ToTask(this WaitHandle handle, int timeout = Timeout.Infinite, CancellationToken cancellationToken = default(CancellationToken))
{
Requires.NotNull(handle, nameof(handle));
// Check whether the handle is already signaled as an optimization.
// But even for WaitOne(0) the CLR can pump messages if called on the UI thread, which the caller may not
// be expecting at this time, so be sure there is no message pump active by controlling the SynchronizationContext.
using (NoMessagePumpSyncContext.Default.Apply())
{
if (handle.WaitOne(0))
{
return(TrueTask);
}
else if (timeout == 0)
{
return(FalseTask);
}
}
cancellationToken.ThrowIfCancellationRequested();
var tcs = new TaskCompletionSource <bool>();
// Arrange that if the caller signals their cancellation token that we complete the task
// we return immediately. Because of the continuation we've scheduled on that task, this
// will automatically release the wait handle notification as well.
CancellationTokenRegistration cancellationRegistration =
cancellationToken.Register(
state =>
{
var tuple = (Tuple <TaskCompletionSource <bool>, CancellationToken>)state;
tuple.Item1.TrySetCanceled(tuple.Item2);
},
Tuple.Create(tcs, cancellationToken));
RegisteredWaitHandle callbackHandle = ThreadPool.RegisterWaitForSingleObject(
handle,
(state, timedOut) => ((TaskCompletionSource <bool>)state).TrySetResult(!timedOut),
state: tcs,
millisecondsTimeOutInterval: timeout,
executeOnlyOnce: true);
// It's important that we guarantee that when the returned task completes (whether cancelled, timed out, or signaled)
// that we release all resources.
if (cancellationToken.CanBeCanceled)
{
// We have a cancellation token registration and a wait handle registration to release.
// Use a tuple as a state object to avoid allocating delegates and closures each time this method is called.
tcs.Task.ContinueWith(
(_, state) =>
{
var tuple = (Tuple <RegisteredWaitHandle, CancellationTokenRegistration>)state;
tuple.Item1.Unregister(null); // release resources for the async callback
tuple.Item2.Dispose(); // release memory for cancellation token registration
},
Tuple.Create <RegisteredWaitHandle, CancellationTokenRegistration>(callbackHandle, cancellationRegistration),
CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default);
}
else
{
// Since the cancellation token was the default one, the only thing we need to track is clearing the RegisteredWaitHandle,
// so do this such that we allocate as few objects as possible.
tcs.Task.ContinueWith(
(_, state) => ((RegisteredWaitHandle)state).Unregister(null),
callbackHandle,
CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default);
}
return(tcs.Task);
}
private void RegisterTimeOut(WaitHandle handle)
{
m_WaitHandle = handle;
m_RegisterWaitHandle = ThreadPool.RegisterWaitForSingleObject(handle, new WaitOrTimerCallback(OnTimeoutCallback), m_Request, TIMEOUT_TIME, true);
}
public static int Main(String [] args)
{
int rValue = 100;
RegisteredWaitHandle rwh = null;
Console.WriteLine("Test AutoResetEvent for expected NullRef Exceptions");
Console.WriteLine( );
try {
rwh.Equals(new ManualResetEvent(true));
rValue = 4;
}
catch (NullReferenceException) {
Console.WriteLine("Caught NullReferenceException (rwh.Equals(new ManualResetEvent()))");
}
try {
rwh.GetHashCode();
rValue = 5;
}
catch (NullReferenceException) {
Console.WriteLine("Caught NullReferenceException (rwh.GetHasCode())");
}
// try {
// rwh.GetLifetimeService();
// rValue = 6;
// }
// catch (NullReferenceException) {
// Console.WriteLine("Caught NullReferenceException (rwh.GetLifetimeService())");
// }
try {
rwh.GetType();
rValue = 7;
}
catch (NullReferenceException) {
Console.WriteLine("Caught NullReferenceException (rwh.GetType())");
}
// try {
// rwh.InitializeLifetimeService();
// rValue = 8;
// }
// catch (NullReferenceException) {
// Console.WriteLine("Caught NullReferenceException (rwh.InitializeLifeTimeService())");
// }
try {
rwh.ToString();
rValue = 11;
}
catch (NullReferenceException) {
Console.WriteLine("Caught NullReferenceException (rwh.ToString())");
}
try {
rwh.Unregister(new AutoResetEvent(true));
rValue = 12;
}
catch (NullReferenceException) {
Console.WriteLine("Caught NullReferenceException (rwh.Unregister())");
}
Console.WriteLine("Return Code == {0}", rValue);
return(rValue);
}
public void PrinterNotifyWaitCallback(Object state, bool timedOut)
{
if (_printerHandle == IntPtr.Zero)
{
return;
}
#region read notification details
_notifyOptions.Count = 1;
int pdwChange = 0;
IntPtr pNotifyInfo = IntPtr.Zero;
bool bResult = FindNextPrinterChangeNotification(_changeHandle, out pdwChange, _notifyOptions, out pNotifyInfo);
//If the Printer Change Notification Call did not give data, exit code
if ((bResult == false) || (((int)pNotifyInfo) == 0))
{
return;
}
//If the Change Notification was not relgated to job, exit code
bool bJobRelatedChange = ((pdwChange & PRINTER_CHANGES.PRINTER_CHANGE_ADD_JOB) == PRINTER_CHANGES.PRINTER_CHANGE_ADD_JOB) ||
((pdwChange & PRINTER_CHANGES.PRINTER_CHANGE_SET_JOB) == PRINTER_CHANGES.PRINTER_CHANGE_SET_JOB) ||
((pdwChange & PRINTER_CHANGES.PRINTER_CHANGE_DELETE_JOB) == PRINTER_CHANGES.PRINTER_CHANGE_DELETE_JOB) ||
((pdwChange & PRINTER_CHANGES.PRINTER_CHANGE_WRITE_JOB) == PRINTER_CHANGES.PRINTER_CHANGE_WRITE_JOB);
if (!bJobRelatedChange)
{
return;
}
#endregion
#region populate Notification Information
//Now, let us initialize and populate the Notify Info data
PRINTER_NOTIFY_INFO info = (PRINTER_NOTIFY_INFO)Marshal.PtrToStructure(pNotifyInfo, typeof(PRINTER_NOTIFY_INFO));
int pData = (int)pNotifyInfo + Marshal.SizeOf(typeof(PRINTER_NOTIFY_INFO));
PRINTER_NOTIFY_INFO_DATA[] data = new PRINTER_NOTIFY_INFO_DATA[info.Count];
for (uint i = 0; i < info.Count; i++)
{
data[i] = (PRINTER_NOTIFY_INFO_DATA)Marshal.PtrToStructure((IntPtr)pData, typeof(PRINTER_NOTIFY_INFO_DATA));
pData += Marshal.SizeOf(typeof(PRINTER_NOTIFY_INFO_DATA));
}
#endregion
#region iterate through all elements in the data array
for (int i = 0; i < data.Count(); i++)
{
if ((data[i].Field == (ushort)PRINTERJOBNOTIFICATIONTYPES.JOB_NOTIFY_FIELD_STATUS) &&
(data[i].Type == (ushort)PRINTERNOTIFICATIONTYPES.JOB_NOTIFY_TYPE)
)
{
JOBSTATUS jStatus = (JOBSTATUS)Enum.Parse(typeof(JOBSTATUS), data[i].NotifyData.Data.cbBuf.ToString());
int intJobID = (int)data[i].Id;
string strJobName = "";
PrintSystemJobInfo pji = null;
try
{
_spooler = new PrintQueue(new PrintServer(), _spoolerName);
pji = _spooler.GetJob(intJobID);
if (!objJobDict.ContainsKey(intJobID))
{
objJobDict[intJobID] = pji.Name;
}
strJobName = pji.Name;
}
catch
{
pji = null;
objJobDict.TryGetValue(intJobID, out strJobName);
if (strJobName == null)
{
strJobName = "";
}
}
if (OnJobStatusChange != null)
{
//Let us raise the event
OnJobStatusChange(this, new PrintJobChangeEventArgs(intJobID, strJobName, jStatus, pji));
}
}
}
#endregion
#region reset the Event and wait for the next event
_mrEvent.Reset();
_waitHandle = ThreadPool.RegisterWaitForSingleObject(_mrEvent, new WaitOrTimerCallback(PrinterNotifyWaitCallback), _mrEvent, -1, false);
#endregion
}
public ThreadPoolRegistration(WaitHandle handle, TimeSpan timeout, TaskCompletionSource <bool> tcs)
{
_registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(handle,
(state, timedOut) => ((TaskCompletionSource <bool>)state).TrySetResult(!timedOut), tcs,
timeout, executeOnlyOnce: true);
}
private void ReadCallBack(IAsyncResult asyncResult)
{
this.myRequestState = (Downloader.RequestState)asyncResult.get_AsyncState();
Stream streamResponse = this.myRequestState.streamResponse;
int num = streamResponse.EndRead(asyncResult);
this.myRequestState.read = num;
try
{
if (num > 0)
{
this.Result = this.fs.BeginWrite(this.myRequestState.BufferRead, 0, num, new AsyncCallback(this.WriteCallBack), this.myRequestState);
return;
}
}
catch (Exception ex)
{
TimerHeap.DelTimer(this.timeOutTimer);
if (this.Handle != null)
{
this.Handle.Unregister(this.Result.get_AsyncWaitHandle());
this.Handle = null;
}
if (this.ManualHandle)
{
return;
}
Debug.LogError("ReadCallBack Exception raised!");
Debug.LogError(ex.ToString());
if (this.ManualHandle)
{
return;
}
Loom.Current.QueueOnMainThread(delegate
{
this.ExceptionHandle();
});
return;
}
string md5FilePath = Downloader.GetMd5FilePath(this.fileFullName);
FileHelper.DeleteIfExist(md5FilePath);
TimerHeap.DelTimer(this.timeOutTimer);
long length = this.fs.get_Length();
this.fs.Dispose();
if (this.Handle != null)
{
this.Handle.Unregister(this.Result.get_AsyncWaitHandle());
}
this.myRequestState.response.Close();
Debug.LogFormat("localFileLen: {0} localFileSize: {1} downloadFileSize: {2}", new object[]
{
length,
this.localFileSize,
this.downloadFileSize
});
if ((long)this.localFileSize == this.downloadFileSize && length == this.downloadFileSize)
{
if (++this.downloadFileIndex < this.urls.get_Count())
{
Loom.Current.QueueOnMainThread(delegate
{
this.SetDetails();
});
this.fs.Close();
this.retryTime = 0;
Loom.Current.QueueOnMainThread(delegate
{
this.Download(this.urls.get_Item(this.downloadFileIndex), this.localPaths.get_Item(this.downloadFileIndex));
});
}
else
{
this.fs.Close();
this.allIsFinish = true;
Loom.Current.QueueOnMainThread(delegate
{
this.DoFinished();
});
}
}
else
{
this.fs.Dispose();
File.Delete(this.LocalPath);
this.retryTime = 0;
Loom.Current.QueueOnMainThread(delegate
{
this.Download(this.urls.get_Item(this.downloadFileIndex), this.localPaths.get_Item(this.downloadFileIndex));
});
}
}
/// <summary>
/// Returns a response to an Internet request as an asynchronous operation.
/// </summary>
/// <remarks>
/// <para>This operation will not block. The returned <see cref="Task{TResult}"/> object will
/// complete after a response to an Internet request is available.</para>
/// </remarks>
/// <param name="request">The request.</param>
/// <param name="throwOnError"><see langword="true"/> to throw a <see cref="WebException"/> if the <see cref="HttpWebResponse.StatusCode"/> of the response is greater than 400; otherwise, <see langword="false"/> to return the <see cref="WebResponse"/> in the result for these cases.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that will be assigned to the new <see cref="Task"/>.</param>
/// <returns>A <see cref="Task"/> object which represents the asynchronous operation.</returns>
/// <exception cref="ArgumentNullException">
/// <para>If <paramref name="request"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="WebException">
/// <para>If <see cref="WebRequest.Abort"/> was previously called.</para>
/// <para>-or-</para>
/// <para>If the timeout period for the request expired.</para>
/// <para>-or-</para>
/// <para>If an error occurred while processing the request.</para>
/// </exception>
public static Task <WebResponse> GetResponseAsync(this WebRequest request, bool throwOnError, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
#if PORTABLE
bool timeout = false;
CancellationTokenRegistration cancellationTokenRegistration;
if (cancellationToken.CanBeCanceled)
{
Action cancellationAction = request.Abort;
cancellationTokenRegistration = cancellationToken.Register(cancellationAction);
}
else
{
cancellationTokenRegistration = default(CancellationTokenRegistration);
}
CancellationTokenSource noRequestTimeoutTokenSource = new CancellationTokenSource();
WebExceptionStatus timeoutStatus;
if (!Enum.TryParse("Timeout", out timeoutStatus))
{
timeoutStatus = WebExceptionStatus.UnknownError;
}
int requestTimeout;
#if NET45PLUS
try
{
// hack to work around PCL limitation in .NET 4.5
dynamic dynamicRequest = request;
requestTimeout = dynamicRequest.Timeout;
}
catch (RuntimeBinderException)
{
requestTimeout = Timeout.Infinite;
}
#else
// hack to work around PCL limitation in .NET 4.0
var propertyInfo = request.GetType().GetProperty("Timeout", typeof(int));
if (propertyInfo != null)
{
requestTimeout = (int)propertyInfo.GetValue(request, null);
}
else
{
requestTimeout = Timeout.Infinite;
}
#endif
if (requestTimeout >= 0)
{
Task timeoutTask = DelayedTask.Delay(TimeSpan.FromMilliseconds(requestTimeout), noRequestTimeoutTokenSource.Token).Select(
_ =>
{
timeout = true;
request.Abort();
});
}
TaskCompletionSource <WebResponse> completionSource = new TaskCompletionSource <WebResponse>();
AsyncCallback completedCallback =
result =>
{
try
{
noRequestTimeoutTokenSource.Cancel();
noRequestTimeoutTokenSource.Dispose();
cancellationTokenRegistration.Dispose();
completionSource.TrySetResult(request.EndGetResponse(result));
}
catch (WebException ex)
{
if (timeout)
{
completionSource.TrySetException(new WebException("No response was received during the time-out period for a request.", timeoutStatus));
}
else if (cancellationToken.IsCancellationRequested)
{
completionSource.TrySetCanceled();
}
else if (ex.Response != null && !throwOnError)
{
completionSource.TrySetResult(ex.Response);
}
else
{
completionSource.TrySetException(ex);
}
}
catch (Exception ex)
{
completionSource.TrySetException(ex);
}
};
IAsyncResult asyncResult = request.BeginGetResponse(completedCallback, null);
return(completionSource.Task);
#else
bool timeout = false;
TaskCompletionSource <WebResponse> completionSource = new TaskCompletionSource <WebResponse>();
RegisteredWaitHandle timerRegisteredWaitHandle = null;
RegisteredWaitHandle cancellationRegisteredWaitHandle = null;
AsyncCallback completedCallback =
result =>
{
try
{
if (cancellationRegisteredWaitHandle != null)
{
cancellationRegisteredWaitHandle.Unregister(null);
}
if (timerRegisteredWaitHandle != null)
{
timerRegisteredWaitHandle.Unregister(null);
}
completionSource.TrySetResult(request.EndGetResponse(result));
}
catch (WebException ex)
{
if (timeout)
{
completionSource.TrySetException(new WebException("No response was received during the time-out period for a request.", WebExceptionStatus.Timeout));
}
else if (cancellationToken.IsCancellationRequested)
{
completionSource.TrySetCanceled();
}
else if (ex.Response != null && !throwOnError)
{
completionSource.TrySetResult(ex.Response);
}
else
{
completionSource.TrySetException(ex);
}
}
catch (Exception ex)
{
completionSource.TrySetException(ex);
}
};
IAsyncResult asyncResult = request.BeginGetResponse(completedCallback, null);
if (!asyncResult.IsCompleted)
{
if (request.Timeout != Timeout.Infinite)
{
WaitOrTimerCallback timedOutCallback =
(object state, bool timedOut) =>
{
if (timedOut)
{
timeout = true;
request.Abort();
}
};
timerRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, timedOutCallback, null, request.Timeout, true);
}
if (cancellationToken.CanBeCanceled)
{
WaitOrTimerCallback cancelledCallback =
(object state, bool timedOut) =>
{
if (cancellationToken.IsCancellationRequested)
{
request.Abort();
}
};
cancellationRegisteredWaitHandle = ThreadPool.RegisterWaitForSingleObject(cancellationToken.WaitHandle, cancelledCallback, null, Timeout.Infinite, true);
}
}
return(completionSource.Task);
#endif
}
private static void StartHelper(NetworkAddressChangedEventHandler caller, bool captureContext, StartIPOptions startIPOptions)
{
lock (s_callerArray) {
// setup changedEvent and native overlapped struct.
if (s_ipv4Socket == null)
{
Socket.InitializeSockets();
int blocking;
if (Socket.OSSupportsIPv4)
{
blocking = -1;
s_ipv4Socket = SafeCloseSocketAndEvent.CreateWSASocketWithEvent(AddressFamily.InterNetwork, SocketType.Dgram, (ProtocolType)0, true, false);
UnsafeNclNativeMethods.OSSOCK.ioctlsocket(s_ipv4Socket, IoctlSocketConstants.FIONBIO, ref blocking);
s_ipv4WaitHandle = s_ipv4Socket.GetEventHandle();
}
if (Socket.OSSupportsIPv6)
{
blocking = -1;
s_ipv6Socket = SafeCloseSocketAndEvent.CreateWSASocketWithEvent(AddressFamily.InterNetworkV6, SocketType.Dgram, (ProtocolType)0, true, false);
UnsafeNclNativeMethods.OSSOCK.ioctlsocket(s_ipv6Socket, IoctlSocketConstants.FIONBIO, ref blocking);
s_ipv6WaitHandle = s_ipv6Socket.GetEventHandle();
}
}
if ((caller != null) && (!s_callerArray.Contains(caller)))
{
s_callerArray.Add(caller, captureContext ? ExecutionContext.Capture() : null);
}
//if s_listener is not null, it means we are already actively listening
if (s_isListening || s_callerArray.Count == 0)
{
return;
}
if (!s_isPending)
{
int length;
SocketError errorCode;
if (Socket.OSSupportsIPv4 && (startIPOptions & StartIPOptions.StartIPv4) != 0)
{
s_registeredWait = ThreadPool.UnsafeRegisterWaitForSingleObject(
s_ipv4WaitHandle,
new WaitOrTimerCallback(AddressChangedCallback),
StartIPOptions.StartIPv4,
-1,
true);
errorCode = (SocketError)UnsafeNclNativeMethods.OSSOCK.WSAIoctl_Blocking(
s_ipv4Socket.DangerousGetHandle(),
(int)IOControlCode.AddressListChange,
null, 0, null, 0,
out length,
SafeNativeOverlapped.Zero, IntPtr.Zero);
if (errorCode != SocketError.Success)
{
NetworkInformationException exception = new NetworkInformationException();
if (exception.ErrorCode != (uint)SocketError.WouldBlock)
{
throw exception;
}
}
errorCode = (SocketError)UnsafeNclNativeMethods.OSSOCK.WSAEventSelect(s_ipv4Socket, s_ipv4Socket.GetEventHandle().SafeWaitHandle, AsyncEventBits.FdAddressListChange);
if (errorCode != SocketError.Success)
{
throw new NetworkInformationException();
}
}
if (Socket.OSSupportsIPv6 && (startIPOptions & StartIPOptions.StartIPv6) != 0)
{
s_registeredWait = ThreadPool.UnsafeRegisterWaitForSingleObject(
s_ipv6WaitHandle,
new WaitOrTimerCallback(AddressChangedCallback),
StartIPOptions.StartIPv6,
-1,
true);
errorCode = (SocketError)UnsafeNclNativeMethods.OSSOCK.WSAIoctl_Blocking(
s_ipv6Socket.DangerousGetHandle(),
(int)IOControlCode.AddressListChange,
null, 0, null, 0,
out length,
SafeNativeOverlapped.Zero, IntPtr.Zero);
if (errorCode != SocketError.Success)
{
NetworkInformationException exception = new NetworkInformationException();
if (exception.ErrorCode != (uint)SocketError.WouldBlock)
{
throw exception;
}
}
errorCode = (SocketError)UnsafeNclNativeMethods.OSSOCK.WSAEventSelect(s_ipv6Socket, s_ipv6Socket.GetEventHandle().SafeWaitHandle, AsyncEventBits.FdAddressListChange);
if (errorCode != SocketError.Success)
{
throw new NetworkInformationException();
}
}
}
s_isListening = true;
s_isPending = true;
}
}
internal bool EnableTransportManagerSendDataToClient(
WSManNativeApi.WSManPluginRequest requestDetails,
WSManPluginOperationShutdownContext ctxtToReport)
{
_shutDownContext = ctxtToReport;
bool isRegisterWaitForSingleObjectSucceeded = true;
lock (_syncObject)
{
if (_isRequestPending)
{
// if a request is already pending..ignore this.
WSManPluginInstance.ReportWSManOperationComplete(
requestDetails,
WSManPluginErrorCodes.NoError);
return(false);
}
if (_isClosed)
{
WSManPluginInstance.ReportWSManOperationComplete(requestDetails, _lastErrorReported);
return(false);
}
_isRequestPending = true;
_requestDetails = requestDetails;
if (Platform.IsWindows)
{
// Wrap the provided handle so it can be passed to the registration function
SafeWaitHandle safeWaitHandle = new SafeWaitHandle(requestDetails.shutdownNotificationHandle, false); // Owned by WinRM
EventWaitHandle eventWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
eventWaitHandle.SafeWaitHandle = safeWaitHandle;
_registeredShutDownWaitHandle = ThreadPool.RegisterWaitForSingleObject(
eventWaitHandle,
new WaitOrTimerCallback(WSManPluginManagedEntryWrapper.PSPluginOperationShutdownCallback),
_shutDownContext,
-1, // INFINITE
true); // TODO: Do I need to worry not being able to set missing WT_TRANSFER_IMPERSONATION?
if (_registeredShutDownWaitHandle == null)
{
isRegisterWaitForSingleObjectSucceeded = false;
}
}
// release thread waiting to send data to the client.
_waitHandle.Set();
}
if (!isRegisterWaitForSingleObjectSucceeded)
{
WSManPluginInstance.PerformCloseOperation(ctxtToReport);
WSManPluginInstance.ReportOperationComplete(
requestDetails,
WSManPluginErrorCodes.ShutdownRegistrationFailed,
StringUtil.Format(
RemotingErrorIdStrings.WSManPluginShutdownRegistrationFailed));
return(false);
}
return(true);
}
private void btnStart_Click(object sender, EventArgs e)
{
btnSearch.Text = "加载中..";
btnSearch.Enabled = false;
string strurlBaidu = "http://image.baidu.com/i?tn=baiduimage&ipn=r&ct=201326592&cl=2&lm=-1&st=-1&fm=result&fr=&sf=1&fmq=&pv=&ic=0&nc=1&z=&se=1&showtab=0&fb=0&width=&height=&face=0&istype=2&ie=utf-8&word=";
string strurlQQ = "http://soso.music.qq.com/fcgi-bin/music_json.fcg?mid=1&catZhida=1&lossless=0&json=1&w=Key&num=30&t=8&p=1&utf8=1&searchid=216648286573551810&remoteplace=sizer.yqqlist.album&g_tk=5381&loginUin=0&hostUin=0&format=yqq&jsonpCallback=MusicJsonCallback&needNewCode=0";
string strurlGoogle = "http://www.google.com.hk/search?newwindow=1&safe=strict&hl=zh-CN&biw=1366&bih=654&site=imghp&tbm=isch&sa=1&q=";
string strurl163 = "http://music.163.com/#/m/search?s=key&_page=search&type=10";
string strurlXiaMi = "http://www.xiami.com/search?spm=a1z1s.3521873.23310045.1.AKUtUf&key=";
string strurlSouGou = "http://pic.sogou.com/pics?ie=utf8&p=40230504&interV=kKIOkrELjboMmLkEk7oTkKIMkbELjbgQmLkElbcTkKILmrELjboLmLkEkr4TkKIRmLkEk78TkKILkbELjboN_1861238217&query=";
string strurl360 = "http://image.so.com/i?ie=utf-8&q=";
string strurl = "";
switch (cobEngine.Text)
{
case "BaiDu":
strurl = strurlBaidu + txtKeyWord.Text;
strEngine = cobEngine.Text;
SourceCode += GetWebClient(strurl);
break;
case "QQ":
strurl = strurlQQ.Replace("Key", System.Web.HttpUtility.UrlEncode(txtKeyWord.Text, System.Text.Encoding.GetEncoding("UTF-8")));
strEngine = cobEngine.Text;
SourceCode = GetWebClient(strurl);
SourceCode = CreateImageUrl(SourceCode);
break;
case "Google":
strurl = strurlGoogle + txtKeyWord.Text;
strEngine = cobEngine.Text;
SourceCode = GetWebClient(strurl);
break;
case "163":
strEngine = cobEngine.Text;
SourceCode = PostData("http://music.163.com/api/search/get/web?csrf_token=", "hlpretag=%3Cspan%20class%3D%22s-fc7%22%3E&hlposttag=%3C%2Fspan%3E&s=" + GuessAlbumNameBy163(txtKeyWord.Text) + "&_page=search&type=10&offset=0&total=true&limit=75", "http://music.163.com");
break;
case "XiaMi":
strurl = strurlXiaMi + txtKeyWord.Text;
strEngine = cobEngine.Text;
SourceCode = GetWebClient(strurl);
break;
case "SouGou":
strurl = strurlSouGou + txtKeyWord.Text;
strEngine = cobEngine.Text;
SourceCode = GetWebClient(strurl);
break;
case "360":
strurl = strurl360 + txtKeyWord.Text;
strEngine = cobEngine.Text;
SourceCode = GetWebClient(strurl);
break;
default:
break;
}
flpPicture.Controls.Clear();
httpList = GetHyperLinks(SourceCode);
iThread = 10;
int iSum = httpList.Count;
int iAve = iSum / iThread;
int iMod = iSum % iThread;
try
{
for (int i = 0; i < iThread; i++)
{
ThreadInfo ti = new ThreadInfo();
if (i == 0)
{
ti.iStart = 0;
ti.iEnd = iAve - 1;
}
else
{
ti.iStart = i * iAve;
ti.iEnd = (i * iAve) + iAve - 1;
}
ThreadPool.QueueUserWorkItem(new WaitCallback(Mp3AlbumCoverUpdaterToForm), ti);
}
if (iMod != 0)
{
ThreadInfo ti = new ThreadInfo();
ti.iStart = iAve * iThread;
ti.iEnd = iSum - 1;
ThreadPool.QueueUserWorkItem(new WaitCallback(Mp3AlbumCoverUpdaterToForm), ti);
}
//AutoResetEvent mainAutoResetEvent = new AutoResetEvent(false);
registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(new AutoResetEvent(false), new WaitOrTimerCallback(delegate(object obj, bool timeout)
{
int workerThreads = 0;
int maxWordThreads = 0;
int compleThreads = 0;
ThreadPool.GetAvailableThreads(out workerThreads, out compleThreads);
ThreadPool.GetMaxThreads(out maxWordThreads, out compleThreads);
if (workerThreads == maxWordThreads)
{
//mainAutoResetEvent.Set();
registeredWaitHandle.Unregister(null);
btnSearch.Invoke(new ChangeControlEnable(ChangeButtonEnable), new object[] { btnSearch });
}
}), null, 1000, false);
//mainAutoResetEvent.WaitOne();
this.Cursor = Cursors.WaitCursor;
}
catch (Exception)
{
throw;
}
finally
{
this.Cursor = Cursors.Default;
}
}
internal void DoClose(
bool isShuttingDown,
Exception reasonForClose)
{
if (_isClosed)
{
return;
}
lock (_syncObject)
{
if (_isClosed)
{
return;
}
_isClosed = true;
_lastErrorReported = reasonForClose;
if (!_isRequestPending)
{
// release threads blocked on the sending data to client if any
_waitHandle.Set();
}
}
// only one thread will reach here
// let everyone know that we are about to close
try
{
RaiseClosingEvent();
foreach (var cmdTransportKvp in _activeCmdTransportManagers)
{
cmdTransportKvp.Value.Close(reasonForClose);
}
_activeCmdTransportManagers.Clear();
if (_registeredShutDownWaitHandle != null)
{
// This will not wait for the callback to complete.
_registeredShutDownWaitHandle.Unregister(null);
_registeredShutDownWaitHandle = null;
}
// Delete the context only if isShuttingDown != true. isShuttingDown will
// be true only when the method is called from RegisterWaitForSingleObject
// handler..in which case the context will be freed from the callback.
if (_shutDownContext != null)
{
_shutDownContext = null;
}
// This might happen when client did not send a receive request
// but the server is closing
if (_requestDetails != null)
{
// Notify that no more data is being sent on this transport.
WSManNativeApi.WSManPluginReceiveResult(
_requestDetails.unmanagedHandle,
(int)WSManNativeApi.WSManFlagReceive.WSMAN_FLAG_RECEIVE_RESULT_NO_MORE_DATA,
WSManPluginConstants.SupportedOutputStream,
IntPtr.Zero,
WSManNativeApi.WSMAN_COMMAND_STATE_DONE,
0);
WSManPluginInstance.ReportWSManOperationComplete(_requestDetails, reasonForClose);
// We should not use request details again after reporting operation complete
// so releasing the resource. Remember not to free this memory as this memory
// is allocated and owned by WSMan.
_requestDetails = null;
}
}
finally
{
// dispose resources
_waitHandle.Dispose();
}
}
static Stream EndGetRequestStreamWithTimeout (HttpWebRequest request, IAsyncResult asyncResult, RegisteredWaitHandle handle)
{
try {
handle.Unregister (asyncResult.AsyncWaitHandle);
return request.EndGetRequestStream (asyncResult);
} catch (WebException ex) {
if (ex.Status == WebExceptionStatus.RequestCanceled) {
throw new WebException ("GetRequestStream operation has timed out.", WebExceptionStatus.Timeout);
}
throw;
}
}
private void RegisterTimeOut(WaitHandle wait)
{
waitHandle = wait;
registeredWaitHandle = ThreadPool.RegisterWaitForSingleObject(wait, Callback, null, TIMEOUT_TIME, true);
}
