C# AuthenticationType类代码示例

 /// <summary>
 ///     Inicializa un nuevo cliente con la clavede acceso, la clave secreta, el tipo de autenticación y la url base
 /// </summary>
 /// <param name="accessKey"></param>
 /// <param name="secretKey"></param>
 /// <param name="authenticationScheme"></param>
 /// <param name="baseUrl"></param>
 public EffiPeopleRestClient(string accessKey, string secretKey, AuthenticationType authenticationScheme, string baseUrl)
     : base(baseUrl)
 {
     _accessKey = accessKey;
     _secretKey = secretKey;
     _authenticationScheme = authenticationScheme;
 }

 protected CouchBase(string username, string password, AuthenticationType aT, DbType dbType)
 {
     this.username = username;
     this.password = password;
     this.authType = aT;
     this.dbType = dbType;
 }

   public SqlGetDatabaseFromProcedureWorker(string server, AuthenticationType authenticationType, string user, string password, string version,
 out ISqlGetDatabaseFromProcedureWorkerReturnedData data)
       : base(server, "", authenticationType, user, password)
   {
       data = this.data = new SqlGetDatabaseFromProcedureWorkerReturnedData();
         this.version = version;
   }

        protected bool InitializeClient(AuthenticationType authType, EventHandler<AuthorizationCodeRequiredEventArgs> codeRequiredHandler, Guid clientId = default(Guid), string clientSecret = null)
        {
            var s = GetSettings();

            if (!s.IsConfigured) return false;

            lock (_lck)
            { 
                if (_aaClient == null || _settings == null || _clientSecret != clientSecret || _clientId != clientId || _settings.LastChanged < s.LastChanged )
                {
                    if (authType == AuthenticationType.Code)
                    {
                        clientId = s.UserAppId;
                        if (clientId == default(Guid))
                            clientId = Parameters.CLIENT_ID;
                    }

                    _aaClient = new AAClient(s.TenantId, s.SubscriptionId, s.ResourceGroupName, s.AutomationAccountName, authType, clientId, clientSecret);

                    if (authType == AuthenticationType.Code)
                        _aaClient.AuthorizationCodeRequired += codeRequiredHandler;

                    _clientSecret = clientSecret;
                    _settings = s;
                    _isInitialized = true;
                }
            }
            return true;
        }

   public SqlDatabaseExistWorker(string server, string checkedDatabase, AuthenticationType authenticationType, string user, string password,
 out ISqlDatabaseExistWorkerReturnedData data)
       : base(server, "", authenticationType, user, password)
   {
       this.checkedDatabase = checkedDatabase;
         data = this.data = new ReturnedData();
   }

 public AppManager(string sharePointUrl, AuthenticationType authenticationType, string userName, SecureString password)
 {
     this.sharePointUrl = sharePointUrl;
     this.authenticationType = authenticationType;
     this.userName = userName;
     this.password = password;
 }

   public SqlProgressWorker(string server, string database, AuthenticationType authenticationType, string user, string password,
 EventHandler<SqlWorkerProgressEventArgs> progressEvent = null)
       : base(server, database, authenticationType, user, password)
   {
       this.progressEvent = progressEvent;
         initializedDataAreSent = false;
         prevCurrentCount = 0;
   }

 public RemoteOperation(string targetUrl, AuthenticationType authType, string user, string password, string domain = "")
 {
     this.TargetSiteUrl = targetUrl;
     this.AuthType = authType;
     this.User = user;
     this.Password = password;
     this.Domain = domain;
 }

 public static AuthenticationType ParseAuthType(string value, AuthenticationType defaultvalue) {
     if (value == "Password")
         return AuthenticationType.Password;
     else if (value == "PublicKey")
         return AuthenticationType.PublicKey;
     else
         return defaultvalue;
 }

   public SqlAttachDatabaseWorker(string server, string newDatabase, AuthenticationType authenticationType, string user, string password,
 string pathToMdf, string pathToLdf, out ISqlAttachDatabaseWorkerReturnedData data)
       : base(server, "", authenticationType, user, password)
   {
       data = this.data = new ReturnedData();
         this.newDatabase = newDatabase;
         this.pathToMdf = pathToMdf;
         this.pathToLdf = pathToLdf;
   }

 public RemoteOperation(string targetUrl, AuthenticationType authType, string user, SecureString password, string AppInstanceId, string domain = "")
 {
     TargetSiteUrl = targetUrl;
     AuthType = authType;
     User = user;
     Password = password;
     Domain = domain;
     this.AppInstanceId = AppInstanceId;
 }

 public SharepointServerSourceCallbackHandler(IEnvironmentRepository environmentRepository,string server,string userName,string password,AuthenticationType authenticationType)
     : base(environmentRepository)
 {
     VerifyArgument.AreNotNull(new Dictionary<string, object>{{"environmentRepository",environmentRepository}});
     _server = server;
     _userName = userName;
     _password = password;
     _authenticationType = authenticationType;
 }

        public Stream(Uri streamUrl, AuthenticationType authenticationType, string httpMethod = "GET", int timeout = -1)
        {
            tokenSource = new CancellationTokenSource();
            ct = tokenSource.Token;

            AuthenticationType = authenticationType;
            HttpMethod = httpMethod.ToUpper();
            _streamUrl = streamUrl;
            Timeout = timeout;
        }

        /// <summary>
        /// This static method activates a user and creates a new instance of SecureEnvironment.
        /// The authentication type determines the type of user identity that will be activated. 
        /// If Permanent Windows activation is requested then the default currently logged on 
        /// Windows Account identity will be activated. If Temporary Windows activation requested 
        /// then user will be prompted for Windows Domain credentials through a dialog, and the 
        /// user identified through those credentials will be activated. 
        /// In case of Passport authentication, a Passport authentication dialog will always
        /// appear regardless of temporary or permanent activation mode. The user that authenticatd 
        /// through that Passport Authentication dialog will be activated.
        /// Regardless of Windows or Passport Authentication, all Temporary created activation will be 
        /// destroyed when SecureEnvironment instance is Disposed or Finalized.  
        /// </summary>   
        public static SecureEnvironment Create(string applicationManifest, 
                                                                                        AuthenticationType authentication, 
                                                                                        UserActivationMode userActivationMode)
        {
            SecurityHelper.DemandRightsManagementPermission();

            return CriticalCreate(applicationManifest, 
                                            authentication,
                                            userActivationMode);
        }

 public ApiInitializePushCommand(IEnumerable<IntegrationPackageDto> packages, AuthenticationType authenticationType,
     AuditIntegrationCommand audit, ApiConfigurationIdentifier configuration, long configurationId)
 {
     Packages = packages;
     PackageTransactions = new List<PackageTransactionDto>();
     AuthenticationType = authenticationType;
     Audit = audit;
     Configuration = configuration;
     ConfigurationId = configurationId;
 }