通过使用泛型避免在以下代码中进行强制转换

Question

I am new to generics and just wondering if it's possible to avoid the casting in the following code using better OO approach.

public class CollectorFactory
{
    public static MyCollector Create(ICredential credential)
    {
        return new MyCollector(credential);
    }
}

public class MyCollector {

    public MyCredential Credential { get; set; }

    public MyCollector(ICredential credential)
    {
        this.Credential = (MyCredential)credential;
    }

    public void Show()
    {
        Console.WriteLine(this.Credential.Username);
        Console.WriteLine(this.Credential.AuthToken);
    }
}

public class MyCredential : ICredential
{
    public string Username{ get; set;  }

    public string AuthToken { get; set; }
}

public interface ICredential
{

}

Is there a way to save the casting of ICredential to MyCredential in MyCollector's Constructor? I don't have option to put Username and AuthToken in ICredential as it's implemented by two different Credentials that both have different set of properties. CollectorFactory will be returning different MyCollector instances in the future and both need to have different credentials.

Any help would be really appreciated.

Answer 1

我不认为你可以实现不同的凭证并尝试将它们用于ICredential。

Answer 2

Here is a way of doing this using generics. Please read my comments in the code.

public class CollectorFactory<T>
{
    public T Create(ICredential credential)
    {
        return (T)Activator.CreateInstance(typeof(T), credential);
    }
}

public class MyCollector : BaseCollector
{
    public dynamic Credential { get; private set; }

    public MyCollector(ICredential credential)
        : base(credential)
    {
        this.Credential = credential;
    }

    // Having this method here limits your ability to make it more generic. 
    // Consider moving this to MyCredential since it refers to specific properties in MyCredential. 
    // If that is not what you want, then you must do a type check before calling methods/ accessing props in Credentials.
    public void Show()
    {
        Console.WriteLine(this.Credential.Username);
        Console.WriteLine(this.Credential.AuthToken);
    }
}

public class MyCredential : ICredential
{
    public string Username { get; set; }

    public string AuthToken { get; set; }
}

public abstract class BaseCollector : ICredentialCollector
{
    protected BaseCollector(ICredential credential)
    {
        if (credential == null)
        {
            throw new ArgumentNullException(nameof(credential));
        }
    }
}

public interface ICredentialCollector
{
}

public interface ICredential
{
}

// test implementation
public class TestClass
{
    public void AuthFactoryTest()
    {
        // test auth instance
        MyCredential auth = new MyCredential() {AuthToken = "asfgasdgdfg", Username = "xuser"};

        // Create test factory
        var fact = new CollectorFactory<MyCollector>(); 
        var myCollector = fact.Create(auth);

        // Do what you need to do to collector object
        myCollector.Show();
    }
}

Answer 3

Generics isn't the solution in this case. The issue here is that your factory is returning a specific type ( MyCollector ). A solution around this would be the following:

public class CollectorFactory
{
    public static ICollector Create(MyCredential credential)
    {
        return new MyCollector(credential);
    }
    public static ICollector Create(OtherCredential credential)
    {
        return new OtherCollector(credential);
    }
}

public interface ICollector
{
    void Show();
}

public class MyCollector : ICollector 
{

    public MyCredential Credential { get; set; }

    public MyCollector(MyCredential credential)
    {
        this.Credential = credential;
    }

    public void Show()
    {
        Console.WriteLine(this.Credential.Username);
        Console.WriteLine(this.Credential.AuthToken);
    }
}

public class MyCredential : ICredential
{
    public string Username{ get; set;  }

    public string AuthToken { get; set; }
}

public interface ICredential
{

}

The above is pretty much the canonical example of the Factory design pattern.

Instead of overloads you could also do typechecking in the factory:

public class CollectorFactory
{
    public static ICollector Create(ICredential credential)
    {
        if(credential.GetType() == typeof(MyCredential))
            return new MyCollector((MyCredential) credential);
        if(credential.GetType() == typeof(OtherCredential ))
            return new OtherCollector((OtherCredential ) credential);
    }
}