private void GetDelegateInformation(string methodName, ref SimpleBitVector32 flags,
int hasHandlerBit, int isArglessBit)
{
// First, try to get a delegate to the two parameter handler
EventHandler e = null;
try {
e = (EventHandler)Delegate.CreateDelegate(typeof(EventHandler), this,
methodName, true /*ignoreCase*/);
}
catch {
}
// If there isn't one, try the argless one
if (e == null)
{
try {
VoidMethod vm = (VoidMethod)Delegate.CreateDelegate(typeof(VoidMethod), this,
methodName, true /*ignoreCase*/);
e = new ArglessEventHandlerDelegateProxy(vm).Handler;
flags[isArglessBit] = true;
}
catch {
}
}
flags[hasHandlerBit] = (e != null);
}
public void SetIndexer()
{
var vector = new SimpleBitVector32(0);
vector[3] = true;
Assert.AreEqual(true, vector[3]);
vector[3] = false;
Assert.AreEqual(false, vector[3]);
vector[15] = true;
Assert.AreEqual(true, vector[15]);
vector[15] = false;
Assert.AreEqual(false, vector[15]);
}
public void GetIndexer()
{
var vector = new SimpleBitVector32(101);
Assert.AreEqual(true, vector[0]);
Assert.AreEqual(false, vector[1]);
Assert.AreEqual(true, vector[2]);
Assert.AreEqual(false, vector[3]);
Assert.AreEqual(false, vector[4]);
Assert.AreEqual(true, vector[5]);
Assert.AreEqual(true, vector[6]);
Assert.AreEqual(false, vector[7]);
for (var i = 8; i < 32; i++)
{
Assert.AreEqual(false, vector[i]);
}
}
public void StartWithOnes()
{
{
var vector = SimpleBitVector32.StartWithOnes(0);
Assert.AreEqual(0, vector.Data);
}
{
var vector = SimpleBitVector32.StartWithOnes(13);
for (var i = 0; i < 13; i++)
{
Assert.IsTrue(vector[i]);
}
for (var i = 13; i < 32; i++)
{
Assert.IsFalse(vector[i]);
}
}
}
internal void HookUpAutomaticHandlers()
{
// Do nothing if auto-events are not supported
if (!SupportAutoEvents)
{
return;
}
// Get the generated class's __autoHandler static
SimpleBitVector32 flags = new SimpleBitVector32(AutoHandlers);
// Make sure we have reflection permission to discover the handlers (ASURT 105965)
InternalSecurityPermissions.Reflection.Assert();
// Try to find what handlers are implemented if not tried before
if (!flags[attempted])
{
flags[attempted] = true;
GetDelegateInformation("Page_Init", ref flags, hasInitHandler, isInitArgless);
GetDelegateInformation("Page_Load", ref flags, hasLoadHandler, isLoadArgless);
GetDelegateInformation("Page_DataBind", ref flags, hasDataBindHandler, isDataBindArgless);
GetDelegateInformation("Page_PreRender", ref flags, hasPreRenderHandler, isPreRenderArgless);
GetDelegateInformation("Page_Unload", ref flags, hasUnloadHandler, isUnloadArgless);
GetDelegateInformation("Page_Error", ref flags, hasErrorHandler, isErrorArgless);
GetDelegateInformation("Page_AbortTransaction", ref flags, hasAbortTransactionHandler, isAbortTransactionArgless);
GetDelegateInformation("OnTransactionAbort", ref flags, hasOnTransactionAbortHandler, isOnTransactionAbortArgless);
GetDelegateInformation("Page_CommitTransaction", ref flags, hasCommitTransactionHandler, isCommitTransactionArgless);
GetDelegateInformation("OnTransactionCommit", ref flags, hasOnTransactionCommitHandler, isOnTransactionCommitArgless);
// Store it back into the generated class's __autoHandler static
AutoHandlers = flags.Data;
Debug.Assert(AutoHandlers != 0, "AutoHandlers != 0");
}
if (flags[hasInitHandler])
{
Init += GetDelegateFromMethodName("Page_Init", flags[isInitArgless]);
}
if (flags[hasLoadHandler])
{
Load += GetDelegateFromMethodName("Page_Load", flags[isLoadArgless]);
}
if (flags[hasDataBindHandler])
{
DataBinding += GetDelegateFromMethodName("Page_DataBind", flags[isDataBindArgless]);
}
if (flags[hasPreRenderHandler])
{
PreRender += GetDelegateFromMethodName("Page_PreRender", flags[isPreRenderArgless]);
}
if (flags[hasUnloadHandler])
{
Unload += GetDelegateFromMethodName("Page_Unload", flags[isUnloadArgless]);
}
if (flags[hasErrorHandler])
{
Error += GetDelegateFromMethodName("Page_Error", flags[isErrorArgless]);
}
// Only one transaction event should be hooked up per ASURT 99474
if (flags[hasAbortTransactionHandler])
{
AbortTransaction += GetDelegateFromMethodName("Page_AbortTransaction", flags[isAbortTransactionArgless]);
}
else if (flags[hasOnTransactionAbortHandler])
{
AbortTransaction += GetDelegateFromMethodName("OnTransactionAbort", flags[isOnTransactionAbortArgless]);
}
if (flags[hasCommitTransactionHandler])
{
CommitTransaction += GetDelegateFromMethodName("Page_CommitTransaction", flags[isCommitTransactionArgless]);
}
else if (flags[hasOnTransactionCommitHandler])
{
CommitTransaction += GetDelegateFromMethodName("OnTransactionCommit", flags[isOnTransactionCommitArgless]);
}
}
