Daniel Vasquez Lopez

The ExecutionContext class in the .NET Framework 2.0

2004-10-08T13:32:00.000-05:00

The following example shows a basic use of the new ExecutionContext class. This class allows you to capture the current context where the code is executing in (e.g. security, syncronization, call context, etc.)

If you use both ThreadPool.UnsafeQueueUserWorkItem and ThreadPool.UnsafeRegisterForWaitForSingleObject methods, you will notice that in your callback method you don't have access to a bunch of context data like the the security context. If you impersonate an User before calling any of the ThreadPool.Unsafe* methods, the identity that will use your callback method will be the process identity, not the impersonated one.

This example shows you how to access the impersonated identity from the callback executed by ThreadPoolUnsafeQueueUserWorkItem.

// Author: danielvl(removethis)@microsoft.com

using System;
using System.Text;
using System.Threading;
using System.Security.Principal;
using System.Runtime.InteropServices;
class Program
{
[DllImport("advapi32.dll")]
public static extern bool LogonUser(string lpszUsername, string lpszDomain, string lpszPassword, int dwLogonType, int dwLogonProvider, out IntPtr phToken);
static void Main(string[] args)
{
WindowsImpersonationContext ctxt = null;
try
{
// Impersonate other user
IntPtr userToken;
LogonUser("SimpleUser", "MyLocalMachine", "T.hisIsMy.Secret0", 2, 0, out userToken);
// At this point I am MyDomain\danielvl
ctxt = WindowsIdentity.Impersonate(userToken);
// At this point I am MyLocalMachine\SimpleUser
// Save my current context (MyLocalMachine\SimpleUser)
ExecutionContext savedContext = ExecutionContext.Capture();
// Call the unsafe version of ThreadPool.QueueUserWorkItem
ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(MyUserWorkItem), savedContext);
}
finally
{
// Revert identity to MyDomain\danielvl
if (ctxt != null)
ctxt.Undo();
}
Console.Read();
}
///

/// Method invoked from ThreadPool.UnsafeQueueUserWorkItem
///

static void MyUserWorkItem(object state)
{
// Restore the ExecutionContext object
ExecutionContext context = (ExecutionContext)state;
// Get the curren username where ThreadPool.UnsafeQueueUserWorkItem is executing
string userNameFromUnsafeContext = WindowsIdentity.GetCurrent().Name;
// Execute myContextCallbackHandler in the context saved
ExecutionContext.Run(context.CreateCopy(), myContextCallbackHandler, userNameFromUnsafeContext);
}
///

/// The handler to the ContextCallback delegate
///

static ContextCallback myContextCallbackHandler = new ContextCallback(MyContextCallback);
///

/// Method invoked from ExecutionContext.Run
///

static void MyContextCallback(object state)
{
string userNameFromUnsafeContext = (string)state;
string userNameFormSavedContext = WindowsIdentity.GetCurrent().Name;
Console.WriteLine("Username from unsafe context is {0}", userNameFromUnsafeContext);
Console.WriteLine("Username from context saved is {0}", userNameFormSavedContext);
}
}

- Output -
Username from unsafe context is MyDomain\danielvl
Username from context saved is MyLocalMachine\SimpleUser

The OVERLAPPED structure in C#

2004-08-10T08:50:00.000-05:00

The OVERLAPPED structure is widely used in the Win32 functions (some examples are the functions ReadFile, WriteFile, DeviceIOControl, etc.). This structure is used to hold information about asynchronous operations.
The OVERLAPPED structure is defined as follows:

typedef struct _OVERLAPPED
{
ULONG_PTR Internal;
ULONG_PTR InternalHigh;
DWORD Offset;
DWORD OffsetHigh;
HANDLE hEvent;
} OVERLAPPED;
typedef OVERLAPPED* LPOVERLAPPED;

If you want to P/Invoke a Win32 function that has defined a parameter as LPOVERLAPPED (a pointer to a OVERLAPPED structure), I recommend you to use the already defined and documented System.Threading.NativeOverlapped structure instead of define your own OVERLAPPED structure in C# (or any other .NET-language).

See some examples at http://www.pinvoke.net/, I already changed all references to the OVERLAPPED structure to System.Threading.NativeOverlapped instead. Be aware that System.Threading.NativeOverlapped is not included in the Microsoft .NET Compact Framework.

How to Ping in C# using System.Management

2004-06-15T10:10:00.000-05:00

If you are using Windows XP, Windows Server 2003 or above perhaps you might want to avoid using unsupported code for emulating the Ping.exe utility that comes with Windows. Microsoft has introduced the new Win32_PingStatus WMI class. You can use the System.Management classes to access an Win32_PingStatus object directly or generate a wrapper by using the Management Strongly Typed Class Generator Tool.
Following the second option, open the Visual Studio .NET Command Prompt and type:

C:\>mgmtclassgen.exe Win32_PingStatus

This will generate the file "PingStatus.CS". Create a new C# project and add the "PingStatus.CS" file. Use the PingStatus class as follows:

using System;
using ROOT.CIMV2.Win32;
sealed class MyPing {
static void Main(string[] args)
{
if(args.Length == 0)
{
Console.Error.WriteLine("Usage: myping");
return;
}
PingStatus ping = Ping(args[0]);
// Check if we got an answer
if(ping.PrimaryAddressResolutionStatus == 0)
{
Console.WriteLine("Resolved: {0}", ping.ProtocolAddress);
}
else
{
Console.Error.WriteLine("Error: '{0}' not resolved.", ping.Address);
}
}
static PingStatus Ping(string address)
{
string condition = string.Format("Address='{0}'", address);
foreach(PingStatus ping in PingStatus.GetInstances(condition))
{
return ping;
}
return null;
}}

The C# code above pings an address (IP or host name) and checks if it got an answer. Please check the Win32_PingStatus WMI class documentation on the
MSDN for property descriptions and status codes.

P/Invoke Add-in for Visual Studio.NET

2004-05-11T11:24:00.000-05:00

This is a very, very useful tool that can help you to find quickly the P/Invoke definition for almost any Win32 API function into the Visual Studio .NET. If the P/Invoke definition does not exist, but you did make it work, you can share your definition with other developers in the globe!.
This tool was developed by Adam Nathan, a P/Invoke expert here at Microsoft that wrote a great book Interoperability in .NET.
This tool communicates with a P/Invoke WiKi Web Site through a Web Service.
Try it out, it might save you several minutes debugging...

How to clear the Downloaded Cache programatically?

2004-05-09T15:47:00.000-05:00

The most important thing that you must considerate before clear the Downloade Cache programmatically it's that the .NET Framework has a default 50MB quota for this cache, so that you don't have to worry about the growing without a size controlled. Additionally, this API won't work for further versions of the .NET Framework. Please check the Alan Shi's blog for more information.
The following C# code clears the Downloaded Cache:

using System.Runtime.InteropServices;
sealed class App
{
[DllImport("fusion.dll")]
static extern void NukeDownloadedCache();
static void Main()
{
NukeDownloadedCache();
}
}

Use Buffer.BlockCopy instead of Array.Copy for better performance

2004-04-16T16:52:00.000-05:00

Buffer.BlockCopy is faster than Array.Copy when you are copying primitive arrays (arrays of type System.Int32, System.Char and so forth).
The reason is because (with base on the SSCLI implementation) both Buffer.Blockcopy and Array.Copy, call the method m_memmove (declared in comsystem.cpp) that copies data byte per byte from one array to another, but the major difference is that Array.Copy performs more validations and operations than Buffer.BlockCopy before calling m_memmove.
Buffer.BlockCopy just checks if bonderies are valid and if the array's data type is primitive, but Array.Copy checks thinks like type compatibility, casting, boxing, unboxing, among other things.

How to Break Software Security Book

2004-04-12T11:03:00.000-05:00

It focuses on find bugs that cause security vulnerabilities in your software. I really think that you should read this book if you are involved in a testing or software engineering role in a project. Check this link to find out more details.
This book this is widely recommended by Michael Howard [MSFT], co-author of Writing Secure Code.

The action being performed on this control is being called from the wrong thread.

2004-03-31T19:12:00.000-06:00

"The action being performed on this control is being called from the wrong thread. You must marshal to the correct thread using Control.Invoke or Control.BeginInvoke to perform this action."
What does that Exception mean?
Window Forms Controls were not designed to be thread-safe. To be sure of that, check the member property Control.InvokeRequired of any control like the System.Windows.Forms.TreeView. If it is true, then you require to call the control from the thread where it was created by using Control.Invoke.
You will need to use delegates. The following code declares a delegate that is used to marshal the call to the main thread:

private delegate void GeneralDelegate(object state);
private GeneralDelegate invoker;
private void MethodRunningInMainThread(object state)
{
treeView1.Nodes.Add(new TreeNode((string)state));
}
private void EventHandlerRunningInOtherThread(object sender, System.EventArgs e)
{
invoker = new GeneralDelegate(MethodRunningInMainThread);
treeView1.Invoke(invoker, new object[]{"Some Text"});
}

Instead of using the TreeView control in the EventHandlerRunningInOtherThread method, it creates a delegate (that could be created in the class contructor once) and calls the TreeView.Invoke method in order to marshal the values requiered ("Some Text") in the MethodRunningInMainThread method by the TreeView control.

Enabling XP Visual Style in Windows Forms

2004-03-31T18:38:00.000-06:00

Back to the .NET Framework version 1.0, the requirement to enable Windows XP Visual Style in a Windows Forms Application was a little dull, adding a xml manifest file into the application resources (opening the assembly from VS.NET). Now in .NET Framework version 1.1, you just need to call the static method Application.EnableVisualStyles just before calling the method Application.Run in your Main method:

static void Main()
{
Application.EnableVisualStyles();
Application.Run(new frmMainForm());
}

You also need to change the standard flat sytle of all the Button controls in your form to FlatSytle.System:
btnSubmit.FlatStyle = System.Windows.Forms.FlatStyle.System;

Of course, you need any Windows XP version or above.

Marshal.SizeOf returns 1 for System.Char

2004-03-30T12:19:00.001-06:00

As you might know, in .NET all strings are Unicode, because of that, the size of a System.Char type must be 2 bytes. When you try to get the size in bytes of a System.Char using the Marshal.SizeOf method, you will find that it return 1 instead of 2.
This is not a bug, Marshal.SizeOf was made for unmanaged types, not for managed types as System.Char. Marshal.SizeOf gets the size of the System.Char type declared in the mscorlib assembly, if you check its declaration using the "Lutz Roeder's .NET Reflector" you will notice that the System.Char type has the following modifiers:

Modifiers: Serializable BeforeFieldInit Ansi Auto

By this reason, the size of any Ansi character is 1. In order to get size of a character, you should use the value of Marshal.SystemDefaultCharSize.

How to recursively search a subdirectory or a file in a given directory

2004-03-30T11:48:00.005-06:00

The question is a little tricky, because we immediately think about write a recursive method, but there are some issues that you might want to considerate; Think about the Call Stack, what if the directory is too deep, enough to run into a StackOverflowException exception, or simple as you are paying a performance penalty.

Instead, try to use a Stack to remember the directories to look up:

sealed class App {
static void Main() {
StringCollection results = FindDirectory("c:\\Development", "compressionsink.dll", "*");
foreach(string value in results)
Console.WriteLine(value);
}
public StringCollection FindDirectory(string root, string value, string searchPattern)
{
StringCollection results = new StringCollection();
Stack stack = new Stack();
stack.Push(root);
while(stack.Count > 0) {
string currentDir = stack.Pop().ToString();
if(0 == string.Compare(Path.GetFileName(currentDir), value, true, CultureInfo.InvariantCulture)) {
results.Add(currentDir);
}
foreach(string path in Directory.GetFiles(currentDir, searchPattern)) {
string ok = Path.GetFileName(path);
if(0 == string.Compare(ok, value, true, CultureInfo.InvariantCulture)) {
results.Add(path);
}
}
foreach(string dir in Directory.GetDirectories(currentDir)) {
stack.Push(dir);
}
}
return results;
}
}

Check if a local account is enabled or disabled in .NET

2004-03-30T11:38:00.000-06:00

DirectoryEntry de = new DirectoryEntry("WinNT:///");
int value = Convert.ToInt32(de.Properties["UserFlags"][0]);
if((value & 0x002) == 0)
Console.WriteLine("This account is enabled.");

If is an AD Account, check the property userAccountControl instead.

Win32Exception class forgotten

2004-03-30T11:24:00.001-06:00

It’s very common to see people (and books) declaring the FormatMessage Win32 API function in .NET in order to get the message of the Last Win32 Error Code.
In .NET, if you want to get the message error of the error code returned by the last unmanaged function called using Platform Invoke, use:

String message = (new System.ComponentModel.Win32Exception()).Message;

Instead of P/Invoke the FormatMessage Win32 API function, like:

[DllImport("kernel32.dll", CharSet=CharSet.Auto)]
static extern int FormatMessage(int dwFlags,ref IntPtr lpSource,
int dwMessageId,int dwLanguageId,ref String lpBuffer,int nSize,
IntPtr Arguments)

Even the Microsoft Configuration Management Application Block for .NET (http://msdn.microsoft.com/library/en-us/dnbda/html/cmab.asp) declares FormatMessage in its DataProtection class and uses the following code instead of writing a simple line (new Win32Exception()).Message :

private static String GetErrorMessage(int errorCode)
{
int FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x00000100;
int FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200;
int FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000;
int messageSize = 255;
String lpMsgBuf = "";
int dwFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER FORMAT_MESSAGE_FROM_SYSTEM FORMAT_MESSAGE_IGNORE_INSERTS;
IntPtr ptrlpSource = new IntPtr();
IntPtr prtArguments = new IntPtr();
int retVal = FormatMessage(dwFlags, ref ptrlpSource, errorCode, 0, ref lpMsgBuf, messageSize, IntPtr.Zero );
if(0 == retVal)
{
throw new Exception( Resource.ResourceManager[ "Res_ExceptionFormattingMessage", errorCode ] );
}
return lpMsgBuf;
}