如果没有fileupload文件选择，则禁用提交按钮(Disable Submit Button if No fileupload File Chosen)

 依赖注入是您正在寻找的解决方案。 一般问题与创建依赖项的位置有关。 通常，在编写面向对象的程序时，自然的本能是使用您需要依赖项的位置处的new关键字直接创建依赖项。 有时您可能会在构造函数中创建长期存在的依赖项。 
 
 为了使您的类更可单元测试，您需要“反转”该规范，并在外部创建您的依赖项（或创建一个工厂/提供程序/上下文，然后可以注入并用于创建其他依赖项的实例），并且“注入” “那些依赖于你的班级。 两种最常见的注入机制既可以作为构造函数的参数，也可以作为带有setter的属性。 通过以这种方式外部化依赖关系管理，您可以轻松地创建这些依赖关系的模拟版本并将其传递，从而允许您完全隔离应用程序的其余部分来测试代码单元。 
 
 为了支持依赖注入并使其更容易管理Inversion of Control（IoC）容器已经出现。 IoC容器是一个框架，允许您独立于参与这些图的类配置依赖关系图。 一旦配置了依赖关系图（通常以感兴趣的单个关键类为根），您就可以在运行时轻松创建对象的实例，而无需担心手动创建所有必需的依赖关系。 这有助于创建非常松散耦合，灵活的代码，易于重新配置。 一个非常好的IoC容器的例子是Castle Windsor ，它提供了一个非常丰富的框架，用于通过依赖注入来连接类。 
 
 一个非常简单的依赖注入示例如下所示： 
 
interface ITaskService
{
    void SomeOperation();
}

interface IEntityService
{
    Entity GetEntity(object key);
    Entity Save(Entity entity);
}

class TaskService: ITaskService
{
    public TaskService(EntityServiceFactory factory)
    {
        m_factory = factory;
    }

    private EntityServiceFactory m_factory; // Dependency

    public void SomeOperation() // Method must be concurrent, so create new IEntityService each call
    {
        IEntityService entitySvc = m_factory.GetEntityService();
        Entity entity = entitySvc.GetEntity(...);
        // Do some work with entity
        entitySvc.Save(entity);
    }
}

class EntityServiceFactory
{
    public EntityServiceFactory(RepositoryProvider provider)
    {
        m_provider = provider;
    }

    private RepositoryProvider m_provider; // Dependency

    public virtual IEntityService GetEntityService()
    {
        var repository = m_provider.GetRepository<Entity>();
        return new EntityService(repository);
    }
}

class EntityService: IEntityService
{
    public EntityService(IEntityRepository repository)
    {
        m_repository = repository;
    }

    private IEntityRepository m_repository; // Dependency

    public Entity GetEntity(object key)
    {
        if (key == null) throw new ArgumentNullException("key");

        // TODO: Check for cached entity here?

        Entity entity = m_repository.GetByKey(key);
        return entity;
    }

    public Entity Save(Entity entity)
    {
        if (entity == null) throw new ArgumentNullException(entity);

        if (entity.Key == null)
        {
            entity = m_repository.Insert(entity);
        }
        else
        {
            m_repository.Update(entity);
        }

        return entity;
    }
}

class RepositoryProvider
{
    public virtual object GetRepository<T>()
    {
        if (typeof(T) == typeof(Entity))
            return new EntityRepository();
        else if (...)
            // ... etc.
    }
}

interface IEntityRepository
{
    Entity GetByKey(object key);
    Entity Insert(Entity entity);
    void Update(Entity entity);
}

class EntityRepository: IEntityRepository
{
    public Entity GetByKey(object key)
    {
        // TODO: Load up an entity from a database here
    }

    public Entity Insert(Entity entity)
    {
        // TODO: Insert entity into database here
    }

    public void Update(Entity entity)
    {
        // TODO: Update existing entity in database here
    }
}

Dependency Injection is the solution you are looking for. The general problem has to do with where your dependencies are created. Normally, when writing an object-oriented program, the natural instinct is to create your dependencies directly using the new keyword at the location you need your dependencies. Sometimes you may create long-lived dependencies in a constructor.
 
To make your classes more unit testable, you need to "invert" that norm, and create your dependencies externally (or create a factory/provider/context that can in turn be injected and used to create instances of other dependencies), and "inject" those dependencies into your class. The two most common mechanisms of injection are either as parameters to a constructor, or with properties with setters. By externalizing dependency management in this way, you are easily able to create mocked versions of those dependencies and pass those in, allowing you to test your units of code in full isolation from the rest of your application.
 
To support dependency injection and make it easier to manage Inversion of Control (IoC) containers have appeared. An IoC container is a framework that allows you to configure dependency graphs independently of the classes that participate in in those graphs. Once a dependency graph is configured (usually rooted at the single key class of interest), you can easily create instances of your objects at runtime without having to worry about manually creating all of the required dependencies as well. This helps in creating very loosely coupled, flexible code that is easy to reconfigure. An example of a very good IoC container is Castle Windsor, which provides a very rich framework for wiring up classes via dependency injection.
 
A very simple example of Dependency Injection would be something like the following:
 
interface ITaskService
{
    void SomeOperation();
}

interface IEntityService
{
    Entity GetEntity(object key);
    Entity Save(Entity entity);
}

class TaskService: ITaskService
{
    public TaskService(EntityServiceFactory factory)
    {
        m_factory = factory;
    }

    private EntityServiceFactory m_factory; // Dependency

    public void SomeOperation() // Method must be concurrent, so create new IEntityService each call
    {
        IEntityService entitySvc = m_factory.GetEntityService();
        Entity entity = entitySvc.GetEntity(...);
        // Do some work with entity
        entitySvc.Save(entity);
    }
}

class EntityServiceFactory
{
    public EntityServiceFactory(RepositoryProvider provider)
    {
        m_provider = provider;
    }

    private RepositoryProvider m_provider; // Dependency

    public virtual IEntityService GetEntityService()
    {
        var repository = m_provider.GetRepository<Entity>();
        return new EntityService(repository);
    }
}

class EntityService: IEntityService
{
    public EntityService(IEntityRepository repository)
    {
        m_repository = repository;
    }

    private IEntityRepository m_repository; // Dependency

    public Entity GetEntity(object key)
    {
        if (key == null) throw new ArgumentNullException("key");

        // TODO: Check for cached entity here?

        Entity entity = m_repository.GetByKey(key);
        return entity;
    }

    public Entity Save(Entity entity)
    {
        if (entity == null) throw new ArgumentNullException(entity);

        if (entity.Key == null)
        {
            entity = m_repository.Insert(entity);
        }
        else
        {
            m_repository.Update(entity);
        }

        return entity;
    }
}

class RepositoryProvider
{
    public virtual object GetRepository<T>()
    {
        if (typeof(T) == typeof(Entity))
            return new EntityRepository();
        else if (...)
            // ... etc.
    }
}

interface IEntityRepository
{
    Entity GetByKey(object key);
    Entity Insert(Entity entity);
    void Update(Entity entity);
}

class EntityRepository: IEntityRepository
{
    public Entity GetByKey(object key)
    {
        // TODO: Load up an entity from a database here
    }

    public Entity Insert(Entity entity)
    {
        // TODO: Insert entity into database here
    }

    public void Update(Entity entity)
    {
        // TODO: Update existing entity in database here
    }
}