using ExtremeSwank.OpenID;

public partial class _Default
{
   protected void LoginButton_Click(object sender, EventArgs e)
   {
       OpenIdClient openid = new OpenIdClient();
       openid.Identity = LoginBox1.Text;
       openid.CreateRequest();
   }
   protected void LogOutButton_Click(object sender, EventArgs e)
   {
       Session["OpenID_UserObject"] = null;
       // Handle user logout here
   }
   protected void Page_Load(object sender, EventArgs e)
   {
       if (!IsPostBack)
       {
           OpenIdClient openid = new OpenIdClient();
           switch (openid.RequestedMode)
           {
              case RequestedMode.IdResolution:
                   if (openid.ValidateResponse())
                   {
                       OpenIdUser thisuser = openid.RetrieveUser();
                       Session["OpenID_UserObject"] = thisuser;
                       // Authentication successful - Perform login here
                   }
                   else
                   {
                       // Authentication failure handled here
                   }
                   break;
               case RequestedMode.CanceledByUser:
                   // User has cancelled authentication - handle here
                   break;
           }
       }
   }
}

using ExtremeSwank.OpenID;
using ExtremeSwank.OpenID.Plugins.Extensions;

public partial class _Default
{

   protected void Page_Load(object sender, EventArgs e)
   {
       // If this is not a postback, start up the Consumer
       // and handle any OpenID request, if present
       if (!IsPostBack)
       {
           OpenIdClient openid = GetConsumer();
           openid.DetectAndHandleResponse();
       }
   }

   protected OpenIdClient GetConsumer()
   {
       // Initialize the OpenID Consumer
       OpenIdClient openid = new OpenIdClient();

       // Subscribe to all the events that could occur
       openid.ValidationSucceeded += new EventHandler(openid_ValidationSucceeded);
       openid.ValidationFailed += new EventHandler(openid_ValidationFailed);
       openid.ReceivedCancel += new EventHandler(openid_ReceivedCancel);

       return openid;
   }

   protected void Button_Click(object sender, EventArgs e)
   {
       OpenIdClient openid = GetConsumer();

       // Set Identity to the text of a field
       openid.Identity = openid_url.Text;

       openid.CreateRequest();
   }

   protected void openid_ReceivedCancel(object sender, EventArgs e)
   {
       // Request has been cancelled. Respond appropriately.
   }

   protected void openid_ValidationSucceeded(object sender, EventArgs e)
   {
       // User has been validated!  Respond appropriately.
       OpenIdUser UserObject = ((OpenIdClient)sender).RetrieveUser();
   }

   protected void openid_ValidationFailed(object sender, EventArgs e)
   {
       // Validating the user has failed.  Respond appropriately.
   }
}

IAssociationPersistence associationManager;
ISessionPersistence sessionManager;

public MyObject() 
{
    // Create the association manager.
    // Note that IAssociationPeristence object is only needed if OpenIdClient.EnableStatefulMode()
    // is used.
    string dsnstr = "Driver={SQL Server};Server=SERVER\\INSTANCE;Database=OpenIDDatabase;Uid=sa;Pwd=password;"
    associationManager = new OdbcAssociationManager(dsnstr, "Prefix_");
    // Use the SingularSessionManager for situations where the session does not actually
    // need to be persisted, assuming that this instance will survive the entire OpenID
    // authentication lifecycle.  DbSessionManager can also be used if you want to
    // save session state into a database.
    // Note that ISessionPersistence object is only needed if OpenIdClient.EnableStatefulMode()
    // is used.
    sessionManager = new SingularSessionManager();
}

public OpenIdClient SetupConsumer(NameValueCollection arguments) 
{
    // Create a new OpenIdClient object
    OpenIdClient openid = new OpenIdClient(arguments);

    // Enable Stateful mode.  If Stateful mode is not desired, just omit
    // this step.
    openid.EnableStatefulMode(associationManager, sessionManager);    

    openid.TrustRoot = "http://myserver.com/";
    openid.ReturnUrl = "http://myserver.com/myPage";
    return openid;
}

// Discover the supplied OpenID identity's Provider URL, build and
// return a redirect URL for the web browser.
public string RetrieveAuthenticationUrl(string identity) 
{
    OpenIdClient openid = SetupConsumer(new NameValueCollection());
    openid.Identity = identity;

    // Discover the supplied OpenID and return the redirect URL
    return openid.CreateRequest(false, false);
}

// An authentication response has been received from the OpenID Provider
// by way of the user's web browser.  Process the data in the response.
// If the response is valid, return an OpenIdUser object containing
// the authentication details.
public OpenIdUser ProcessAuthenticationResponse(NameValueCollection arguments) 
{
    OpenIdClient openid = SetupConsumer(arguments);
    switch (openid.RequestedMode) 
    {
        case RequestedMode.IdResolution:
            if (openid.ValidateResponse()) {
                OpenIdUser thisuser = openid.RetrieveUser();
                return thisuser;
            }
            break;
    }
    return null;
}