In MSTSC (aka RDP), click ‘show options’ then go to the ‘Local Resources’ tab. Under keyboard, notice that ‘Apply Windows key combinations:’ defaults to ‘only when using the full screen’. So, if you’re in windowed mode, ALT-F4 closes your RDP session by default.

shutdown -a
Aborts the shutdown, useful if you accidentally do it on your system or if someone is playing games trying to shut your system down.

If the time value is greater than 0, -f is implied.

shutdown /i
Gives you a GUI version that is very useful if you’re restarting a list of hosts and will let you document why.

WebRequest documentRequest = (HttpWebRequest)HttpWebRequest.Create(fileUri);
WebRequestState requestState = new HttpWebRequestState(8192);
requestState.Request = documentRequest;

requestState.FileUri = fileUri;
requestState.ResponseInformationCallback = new WebRequestState.ResponseInfoDelegate(requestStateInformation_CallBack);
requestState.ProgressCallback = new WebRequestState.ProgressDelegate(ProgressChanged_CallBack);
requestState.DownloadCompleteCallback = new WebRequestState.DownloadCompleteDelegate(DownloadCompleted_Callback);
requestState.TransferStart = DateTime.Now;

IAsyncResult result = (IAsyncResult)documentRequest.BeginGetResponse(new AsyncCallback(ResponseCallBack), requestState);

private void requestStateInformation_CallBack(string statusDescr, string contentLength)
{
}

private void ProgressChanged_CallBack(int totalBytes, double pctComplete, double transferRate)
{
if (this.Dispatcher.CheckAccess())
{
this.UpdateProgressBar(totalBytes, pctComplete, transferRate);
}
else
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
UpdateProgressBar(totalBytes, pctComplete, transferRate);
});
}

}

private void DownloadCompleted_Callback(byte[] bufferRead)
{
if (this.Dispatcher.CheckAccess())
{
AddWatermarkIfAnyExists(bufferRead);
}
else
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
AddWatermarkIfAnyExists(bufferRead);
});
}
}

private void ResponseCallBack(IAsyncResult asyncResult)
{
WebRequestState requestState = ((WebRequestState)(asyncResult.AsyncState));
WebRequest request = requestState.Request;

((HttpWebRequest)request).AllowReadStreamBuffering = false;
((HttpWebRequest)request).AllowAutoRedirect = false;

HttpWebResponse response = ((HttpWebResponse)(request.EndGetResponse(asyncResult)));
requestState.Response = response;
requestState.TotalBytes = requestState.Response.ContentLength;

string statusDescription = response.StatusDescription;
string contentLength = requestState.Response.ContentLength.ToString();

if (statusDescription != “”)
requestState.ResponseInformationCallback(statusDescription, contentLength);

Stream responseStream = requestState.Response.GetResponseStream();
requestState.StreamResponse = responseStream;

IAsyncResult _asyncResult = responseStream.BeginRead(requestState.BufferRead, 0, 8192, new AsyncCallback(ReadStream_CallBack), requestState);
}

private void ReadStream_CallBack(IAsyncResult asyncResult)
{
WebRequestState requestState = ((WebRequestState)(asyncResult.AsyncState));
Stream responseStream = requestState.StreamResponse;
int bytesRead = responseStream.EndRead(asyncResult);

if (bytesRead > 0)
{
requestState.BytesRead += bytesRead;
double pctComplete = ((double)requestState.BytesRead / (double)requestState.TotalBytes) * 100.0f;

TimeSpan totalTime = DateTime.Now – requestState.TransferStart;
double kbPerSecond = (requestState.BytesRead * 1000.0f) / (totalTime.TotalMilliseconds * 1024.0f);

requestState.ProgressCallback(requestState.BytesRead, pctComplete, kbPerSecond);

//byte[] fileBytes = new byte[requestState.File.Length + bytesRead];

//System.Buffer.BlockCopy(requestState.File, 0, fileBytes, 0, requestState.File.Length);
//System.Buffer.BlockCopy(requestState.BufferRead, 0, fileBytes, requestState.File.Length, bytesRead);

requestState.File = CombineBytes(requestState.File, requestState.BufferRead, bytesRead);
//requestState.File = fileBytes;

//Trigger another read
IAsyncResult _asyncResult = responseStream.BeginRead(requestState.BufferRead, 0, 8192, new AsyncCallback(ReadStream_CallBack), requestState);
}
else
{
responseStream.Close();
requestState.Response.Close();
requestState.DownloadCompleteCallback(requestState.File);
}
}

private void UpdateProgressBar(int totalBytes, double pctComplete, double transferRate)
{
this.pbDownload.IsIndeterminate = false;
pbDownload.Value = pctComplete;
lblDownload.Content = string.Format(“Downloading {0}kb of {1}kb”, ((totalBytes * pctComplete) / 1024), totalBytes / 1024);
}

private void AddWatermarkIfAnyExists(byte[] document)
{
if (loadWaterMark)
LoadDocumentWithWaterMark(document);
else
LoadDocument(document);
}

public byte[] CombineBytes(byte[] first, byte[] second, int secondLimit)
{
byte[] ret = new byte[first.Length + second.Length];
Buffer.BlockCopy(first, 0, ret, 0, first.Length);
Buffer.BlockCopy(second, 0, ret, first.Length, secondLimit);
return ret;
}

I need to do some more reading I think. TBH, I’ve only started coding in the last year so there’s a lot I need to learn.
Once again, thanks for the response.

I would just put the entire for loop in the BackgroundWorker and then, each time through the loop, do the work you’re doing synchronously, rather than firing up a BackgroundWorker for each iteration. You’d only do this if you wanted them to run in parallel.

Even better, you should probably look into using async/await keywords, available in .NET 4.5. (Or .NET 4.0, using Async Targeting Pack). They simplify the pattern for doing asynchronous work on background threads, even a bit more than the BackgroundWorker.

I have a question Sean if you don’t mind – once you fire off a backgroudworker, it does its job asynchronously. As a form button was used to kick start this whole process, control returns to the form which is now free from the time-consuming activities and thus does not freeze. And no other form code is executed until a user clicks on another enabled button etc.

But what if when you click on a button you have a for or while loop, and in this loop you want to call a background worker. But you do NOT want the next loop iteration to execute, until the background worker has completed its first task? Can this be done? i.e. can you somehow pause the next loop iteration while the background worker is doing its thing, but not freeze the main form?

WordAds definitely makes it easy to get ads served up, without having to work directly with the ad vendors. You’ve done a great job making this work so seamlessly.

I realize that it’s hard to serve the needs of thousands of blogs, in terms of what sorts of ads they’d like to see. Some are all about click-through, to maximize impressions, without a lot of concern about the actual aesthetics of the ads. Other (like me) would rather have ads that meet a particular level of professionalism, aesthetically speaking. Click-through is only secondary, since my primary goal is to provide professional content in my blog and secondary goal would be to underwrite the blog with ads, but only if I can be assured of doing this with ads that are as professional and aesthetically clean as my blog.

I still do object to the video-based ads, given how they are not visually distinct enough from the blog content, from a graphic design perspective. And despite the small header that mentions the video being an ad, I know that many readers confuse the ad as being part of the content. Perhaps that explains the higher click-through rates? :O)

The relevancy thing is less important to me, but also a philosophical discussion. I understand how ads are targeted based on either browsing history or on content. And possibly just my personal opinion, but I’d be pretty irritated to see a ski gear ad on a blog about something entirely different, just because I’d recently searched for ski gear. I realize that this is the way that online ads are trending, but I also believe that it’s disrespectful of the users. A professional and respectful ad should be relevant to what the user is doing right now, but without being so relevant as to be creepy or prying (e.g. ads based on content in the body of an e-mail message).

Again, I realize that there are competing goals here. Advertisers, ad partners, and content creators all want to make money. Users and consumers of content want to be treated in a respectful way and want to see something that is aesthetically clean. In my opinion, we’ve moved a bit too far away from the latter, in favor of the former. I hear all of the time (and I’m sure you do too) that “average” people are often frustrated with ads on web sites, because the ads are too intrusive, too garish, or too confusing (e.g. the large download button). This tells me that there is probably a market out there for ad partners and content creators to create aesthetically tasteful ads, though perhaps at the expense of a few pennies of ad revenue.

Sean

The purpose of WordAds is to make advertising easy for WordPress.com users. Online advertising can be a time suck with technical, design and business requirements. WordAds also extends to smaller sites the ability to work with ad partners that generally don’t work with smaller sites.

We do hear some misunderstanding about what is WordAds. WordAds is not an advertiser or ad network. Rather we optimize a fairly large number of ad partners. That means that there isn’t any one WordAds type of ad. If and when we find a new partner that has an ad product that we like and that pays well we will add them to WordAds. Likewise when an ad partner lets down sites we move away from that partner. One challenge we have is that there are many opinions about what users want and don’t in ads and its difficult to deliver exactly what each site wants.

> They don’t look like ads (e.g. ad consists solely of embedded YouTube video)
Ads creatives and type of ads differ depending on the country of the visitor. However, we do run and prefer to run click to play video ads. It’s a matter of taste but we prefer them a) because they pay much better per view than standard banner or text ads and b) We think the creative quality is higher than banner ads that we have tested and c) We get a very high click through rate on the videos and the data indicates that people watch the videos which are created to be entertaining so we think this is a better experience than running the display ads.

> Ads are not separated from my blog content in any way, e.g. with a border
We do insert an About These Ads link above the ads. We don’t insert a border because there are so many themes on WordPress.com if we add an additional layer it would cause layout problems. We do have a designer who is specifically working on improving the look on each theme.

> Ads aren’t relevant to my readers
We hear this a good amount. I believe that people are trained by Google search ads that the best online ads mirror the subject of the site. However, outside of search that is often not how online ads are bought and sold these days. As with TV advertisers, online advertisers are generally paying to be in front of an audience demographic (male/female, geo, etc.) and often via re-targeting so that if a visitor was looking at ski gear on another site they might see ski gear ads on your site even though your site has nothing to do with ski gear.

> Multiple ads leads to the web page being cluttered
WordAds has a one ad per page option.

This worked like a charm. Thank you , thank you soooooooo much! :)