Authenticator. Class design

Question

5.00/5 (2 votes)

See more:

Hi everyone!
I have a base class AuthenticatorBase that has ability to log in users with different authentication subjects - login & password and token.
Class looks like this:

C#

 public abstract class AuthenticatorBase {

        public abstract LogInResult LogIn(object authSubject);

        public abstract void LogOut(string sessionKey);
}

The sub-class that authenticates with login & password

C#

public class BasicAuthenticator : AuthenticatorBase {

       public override LogInResult Authenticate(object authSubject) {
            LogInData credentials = authSubject as LogInData;
              
            if (DbContext.Security.Authorize(credentials))
              ...............
       }
    }

The sub-class that authenticates with token

C#

public class TokenBasedAuthenticator: AuthenticatorBase {

    public override LogInResult Authenticate(object authSubject)
    {
        string token = authSubject as string;

        User user;
        if (DbContext.Security.LogInWithToken(token, out user))
            ...........
    }
}

What I don't like in this code is the parameter authSubject of type System.Object, I need to cast it in sub-classes. If I use, say BasicAuthenticator, I might pass invalid type as parameter.
I know I can make generic type AuthenticatorBase<TAuthSubject> and have two sub-classes BasicAuthenticator: AuthenticatorBase<LogInData> and TokenBasedAuthenticator : AuthenticatorBase<string>. But what if I need to have them in list, both generic classes don't have a common interface.
I could create an additional interface like this:

C#

public interface IAuthenticator {

      LogInResult LogIn(object authSubject);
}

public abstract class AuthenticatorBase<tauthsubject>: IAuthenticator {

   public abstract LogInResult LogIn(TAuthSubject authSubject);

   // implementing interface
   LogInResult IAuthenticator.LogIn(object authSubject)
   {
       return LogIn((TAuthSubject)authSubject);
   }
}

Now I can store instances of IAuthenticator in the list, but this seems to be very overwhelmed. What's the best way to get rid of the parameter authSubject as type System.Object??? I want to call it and pass correct instance of type to authenticators without having to think about correct types that authenticator accepts. Thanks

What I have tried:

Tried to use my code, but I find it overloaded

Posted 10-Nov-16 0:38am

NickResh777

Updated 10-Nov-16 1:09am

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

F-ES Sitecore · Accepted Answer · 2016-11-10T01:09:00

Using generics is the right way to go, however if adding them to a collection is the issue then you can make them implement an additional interface like this

C#

public interface IAuthenticatorBase
{
    // you don't need to define this here, you could leave this interface
    // as an empty token interface
    void LogOut(string sessionKey);
}

public abstract class AuthenticatorBase<TAuthSubject> : IAuthenticatorBase
{
    public abstract LogInResult LogIn(TAuthSubject authSubject);

    public abstract void LogOut(string sessionKey);
}

public class BasicAuthenticator : AuthenticatorBase<LogInData>
{
    public override LogInResult LogIn(LogInData authSubject)
    {
        throw new NotImplementedException();
    }

    public override void LogOut(string sessionKey)
    {
        throw new NotImplementedException();
    }
}

public class TokenBasedAuthenticator : AuthenticatorBase<string>
{
    public override LogInResult LogIn(string authSubject)
    {
        throw new NotImplementedException();
    }

    public override void LogOut(string sessionKey)
    {
        throw new NotImplementedException();
    }
}

You would then have a list of IAuthenticatorBase

C#

List<IAuthenticatorBase> myAuths = new List<IAuthenticatorBase>();
myAuths.Add(new BasicAuthenticator());
myAuths.Add(new TokenBasedAuthenticator());

foreach (IAuthenticatorBase auth in myAuths)
{
    // this is where it gets a bit naff but if you want to
    // deal with disparate types in a collection then at some point you
    // have to convert them to their concrete versions
    if (auth is BasicAuthenticator)
    {
        BasicAuthenticator basicAuthenticator = auth as BasicAuthenticator;
    }
    else if (auth is TokenBasedAuthenticator)
    {
        TokenBasedAuthenticator tokenBasedAuthenticator = auth as TokenBasedAuthenticator;
    }
}